hexagon 0.1.2

The Hexagon VM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use executor::Executor;
use opcode::OpCode;
use basic_block::BasicBlock;
use function::Function;
use value::ValueContext;

#[test]
fn test_executor() {
    let executor = Executor::new();
    let mut handle = executor.handle_mut();

    const END: i64 = 100000;

    let mut sum_fn = Box::new(Function::from_basic_blocks(vec! [
        // bb 0
        BasicBlock::from_opcodes(vec! [
            { OpCode::InitLocal(8) },
            { OpCode::LoadInt(0) }, // current (initial) value (exclusive)
            { OpCode::SetLocal(0) },
            { OpCode::LoadInt(END) }, // end value (inclusive)
            { OpCode::SetLocal(1) },
            { OpCode::LoadInt(0) }, // sum
            { OpCode::SetLocal(2) },
            { OpCode::Branch(1) }
        ]),
        // bb 1
        BasicBlock::from_opcodes(vec! [
            { OpCode::GetLocal(1) },
            { OpCode::GetLocal(0) },
            { OpCode::TestLt },
            { OpCode::Not },
            { OpCode::ConditionalBranch(3, 2) }
        ]),
        // bb 2
        BasicBlock::from_opcodes(vec! [
            { OpCode::LoadInt(1) },
            { OpCode::GetLocal(0) },
            { OpCode::IntAdd },
            { OpCode::Dup },
            { OpCode::SetLocal(0) },
            { OpCode::GetLocal(2) },
            { OpCode::IntAdd },
            { OpCode::SetLocal(2) },
            { OpCode::Branch(1) }
        ]),
        // bb 3
        BasicBlock::from_opcodes(vec! [
            { OpCode::GetLocal(2) },
            { OpCode::Return }
        ])
    ]));
    sum_fn.enable_optimization();
    handle.create_static_object("sum", sum_fn);

    let blocks: Vec<BasicBlock> = vec! [
        BasicBlock::from_opcodes(vec! [
            { OpCode::InitLocal(8) },
            { OpCode::LoadString("sum".to_string()) },
            { OpCode::GetStatic },
            { OpCode::SetLocal(0) },
            { OpCode::LoadNull },
            { OpCode::GetLocal(0) },
            { OpCode::Call(0) },
            { OpCode::LoadString("output".to_string()) },
            { OpCode::SetStatic },
            { OpCode::LoadNull },
            { OpCode::Return }
        ])
    ];
    handle.create_static_object("entry", Box::new(Function::from_basic_blocks(blocks)));
    match handle.run_callable("entry") {
        Ok(_) => {},
        Err(e) => panic!(e.unwrap().to_string())
    }

    handle.gc();

    let result_value = handle.get_static_object("output").unwrap();
    let result = ValueContext::new(
        &result_value,
        handle.get_object_pool()
    ).to_i64();

    assert_eq!(result, (1 + END) * END / 2);
}