yulang-native 0.1.1

Native backend experiments for Yulang
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use yulang_typed_ir as typed_ir;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeModule {
    pub functions: Vec<NativeFunction>,
    pub roots: Vec<NativeFunction>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeFunction {
    pub name: String,
    pub captures: Vec<ValueId>,
    pub params: Vec<ValueId>,
    pub blocks: Vec<NativeBlock>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeBlock {
    pub id: BlockId,
    pub params: Vec<ValueId>,
    pub stmts: Vec<NativeStmt>,
    pub terminator: NativeTerminator,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativeStmt {
    Literal {
        dest: ValueId,
        literal: NativeLiteral,
    },
    Primitive {
        dest: ValueId,
        op: typed_ir::PrimitiveOp,
        args: Vec<ValueId>,
    },
    DirectCall {
        dest: ValueId,
        target: String,
        args: Vec<ValueId>,
    },
    Tuple {
        dest: ValueId,
        items: Vec<ValueId>,
    },
    Record {
        dest: ValueId,
        base: Option<ValueId>,
        fields: Vec<NativeRecordField>,
    },
    RecordWithoutFields {
        dest: ValueId,
        base: ValueId,
        fields: Vec<typed_ir::Name>,
    },
    Variant {
        dest: ValueId,
        tag: typed_ir::Name,
        value: Option<ValueId>,
    },
    Select {
        dest: ValueId,
        base: ValueId,
        field: typed_ir::Name,
    },
    TupleGet {
        dest: ValueId,
        tuple: ValueId,
        index: usize,
    },
    VariantTagEq {
        dest: ValueId,
        variant: ValueId,
        tag: typed_ir::Name,
    },
    VariantPayload {
        dest: ValueId,
        variant: ValueId,
    },
    ValueEq {
        dest: ValueId,
        left: ValueId,
        right: ValueId,
    },
    BoolAnd {
        dest: ValueId,
        left: ValueId,
        right: ValueId,
    },
    MakeClosure {
        dest: ValueId,
        target: String,
        captures: Vec<ValueId>,
    },
    ClosureCall {
        dest: ValueId,
        callee: ValueId,
        args: Vec<ValueId>,
    },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeRecordField {
    pub name: typed_ir::Name,
    pub value: ValueId,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativeTerminator {
    Return(ValueId),
    Jump {
        target: BlockId,
        args: Vec<ValueId>,
    },
    Branch {
        cond: ValueId,
        then_block: BlockId,
        else_block: BlockId,
    },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativeLiteral {
    Int(String),
    Float(String),
    String(String),
    Bool(bool),
    Unit,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ValueId(pub usize);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct BlockId(pub usize);