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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::any::Any;
use object::Object;
use object_pool::ObjectPool;
use basic_block::BasicBlock;
use opcode::{OpCode, RtOpCode, ValueLocation, StackMapPattern};
use value::Value;

#[test]
fn test_transform_const_calls() {
    let mut pool = ObjectPool::new();
    let obj_id = pool.allocate(Box::new("a".to_string()));
    //let mut rt_handles: Vec<usize> = Vec::new();

    let mut bb = BasicBlock::from_opcodes(vec! [
        { OpCode::LoadString("Hello world".into()) },
        { OpCode::LoadInt(42) },
        { OpCode::LoadNull },
        { OpCode::Rt(RtOpCode::LoadObject(obj_id)) },
        { OpCode::Call(1) },
        { OpCode::Pop },
        { OpCode::Return }
    ]);
    bb.transform_const_calls();
    bb.remove_nops();

    assert_eq!(bb.opcodes, vec! [
        { OpCode::LoadString("Hello world".into()) },
        { OpCode::LoadInt(42) },
        { OpCode::Rt(RtOpCode::ConstCall(
            ValueLocation::ConstObject(obj_id),
            ValueLocation::ConstNull,
            1
        )) },
        { OpCode::Pop },
        { OpCode::Return }
    ]);
}

struct TestObject {

}

impl Object for TestObject {
    fn get_children(&self) -> Vec<usize> {
        Vec::new()
    }

    fn as_any(&self) -> &Any {
        self as &Any
    }

    fn as_any_mut(&mut self) -> &mut Any {
        self as &mut Any
    }

    fn get_field(&self, _: &ObjectPool, name: &str) -> Option<Value> {
        if name == "key" {
            Some(Value::Bool(true))
        } else {
            None
        }
    }

    fn has_const_field(&self, _: &ObjectPool, name: &str) -> bool {
        if name == "key" {
            true
        } else {
            false
        }
    }
}

#[test]
fn test_transform_const_get_fields() {
    let mut pool = ObjectPool::new();
    let mut rt_handles: Vec<usize> = Vec::new();
    let this_id = pool.allocate(Box::new(TestObject {}));
    let key_id = pool.allocate(Box::new("key".to_string()));

    let mut bb = BasicBlock::from_opcodes(vec! [
        { OpCode::LoadNull },
        { OpCode::LoadInt(1) },
        { OpCode::Pop },
        { OpCode::Pop },
        { OpCode::Rt(RtOpCode::LoadObject(key_id)) },
        { OpCode::Rt(RtOpCode::LoadObject(this_id)) },
        { OpCode::GetField },
        { OpCode::Pop },
        { OpCode::Rt(RtOpCode::LoadObject(key_id)) },
        { OpCode::LoadNull },
        { OpCode::Rt(RtOpCode::LoadObject(this_id)) },
        { OpCode::CallField(0) },
        { OpCode::Return }
    ]);
    while bb.transform_const_get_fields(&mut rt_handles, &mut pool, Some(Value::Object(this_id))) {
        bb.remove_nops();
    }

    assert_eq!(bb.opcodes, vec! [
        { OpCode::Rt(RtOpCode::StackMap(StackMapPattern {
            map: (&[] as &[ValueLocation]).into(),
            end_state: 0
        }))},
        { OpCode::Rt(RtOpCode::StackMap(StackMapPattern {
            map: (&[
                ValueLocation::ConstNull
            ] as &[ValueLocation]).into(),
            end_state: 1
        }))},
        { OpCode::LoadBool(true) },
        { OpCode::Call(0) },
        { OpCode::Return }
    ]);
}