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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
#ifndef COMPILER_C
#define COMPILER_C
#include "badlib.h"
#include "parser.c"
typedef struct Instruction {
u8 dst;
u8 a;
u8 b;
u8 op;
} Instruction;
typedef union Constant {
s64 i;
u64 u;
double f;
ptrsize ptr;
} Constant;
typedef struct Chunk {
Instruction *code;
// Constant values that fit in 64 bits.
Constant *constants;
IntIntMap *intmap;
sz const_idx;
// Constant strings.
Str *strings;
StrIntMap *strmap;
sz str_idx;
// Number of registers currently used in this chunk.
sz reg_idx;
// Debugging.
Str file_name;
Arena *storage;
// TODO: line/col info for debugging.
} Chunk;
typedef enum OpCode {
// OP DST A B
// ---------------------------------------------------------------
// VM/high level instructions.
OP_HALT, // halt
// Load/Store instructions.
OP_LD8K, // ld8k rx, ca -> u8 rx = ca
OP_LD16K, // ld16k rx, ca -> u16 rx = ca
OP_LD32K, // ld32k rx, ca -> u32 rx = ca
OP_LD64K, // ld64k rx, ca -> u64 rx = ca
OP_LD8I, // ld8i rx, ra, cb -> u8 *p; rx = p[ra + cb]
OP_LD16I, // ld16i rx, ra, cb -> u16 *p; rx = p[ra + cb]
OP_LD32I, // ld32i rx, ra, cb -> u32 *p; rx = p[ra + cb]
OP_LD64I, // ld64i rx, ra, cb -> u64 *p; rx = p[ra + cb]
OP_LD8, // ld8 rx, ra, rb -> u8 *p; rx = p[ra + rb]
OP_LD16, // ld16 rx, ra, rb -> u16 *p; rx = p[ra + rb]
OP_LD32, // ld32 rx, ra, rb -> u32 *p; rx = p[ra + rb]
OP_LD64, // ld64 rx, ra, rb -> u64 *p; rx = p[ra + rb]
OP_ST8I, // st8i rx, ra, cb -> u8 *p; p[ra + cb] = rx
OP_ST16I, // st16i rx, ra, cb -> u16 *p; p[ra + cb] = rx
OP_ST32I, // st32i rx, ra, cb -> u32 *p; p[ra + cb] = rx
OP_ST64I, // st64i rx, ra, cb -> u64 *p; p[ra + cb] = rx
OP_ST8, // st8 rx, ra, rb -> u8 *p; p[ra + rb] = rx
OP_ST16, // st16 rx, ra, rb -> u16 *p; p[ra + rb] = rx
OP_ST32, // st32 rx, ra, rb -> u32 *p; p[ra + rb] = rx
OP_ST64, // st64 rx, ra, rb -> u64 *p; p[ra + rb] = rx
// Integer arithmetic (only int/s64 for now).
OP_ADDI, // addk rx, ra, cb
OP_SUBI, // subk rx, ra, cb
OP_MULI, // mulk rx, ra, cb
OP_DIVI, // divk rx, ra, cb
OP_MODI, // modk rx, ra, cb
OP_ADD, // add rx, ra, rb
OP_SUB, // sub rx, ra, rb
OP_MUL, // mul rx, ra, rb
OP_DIV, // div rx, ra, rb
OP_MOD, // mod rx, ra, rb
// Floating point arithmetic (only f64 for now).
OP_ADDFI, // addfk rx, ra, cb
OP_SUBFI, // subfk rx, ra, cb
OP_MULFI, // mulfk rx, ra, cb
OP_DIVFI, // divfk rx, ra, cb
OP_MODFI, // modfk rx, ra, cb
OP_ADDF, // addf rx, ra, rb
OP_SUBF, // subf rx, ra, rb
OP_MULF, // mulf rx, ra, rb
OP_DIVF, // divf rx, ra, rb
OP_MODF, // modf rx, ra, rb
// Register-to-register copy.
OP_MOV8, // mov8 rx, ra -> rx = ra & 0xFF
OP_MOV16, // mov16 rx, ra -> rx = ra & 0xFFFF
OP_MOV32, // mov32 rx, ra -> rx = ra & 0xFFFFFFFF
OP_MOV64, // mov64 rx, ra -> rx = ra & 0xFFFFFFFFFFFFFFFF
} OpCode;
Str op_str[] = {
[OP_HALT] = cstr("HALT "),
// Load ops.
[OP_LD8K] = cstr("LD8K "),
[OP_LD16K] = cstr("LD16K "),
[OP_LD32K] = cstr("LD32K "),
[OP_LD64K] = cstr("LD64K "),
[OP_LD8I] = cstr("LD8I "),
[OP_LD16I] = cstr("LD16I "),
[OP_LD32I] = cstr("LD32I "),
[OP_LD64I] = cstr("LD64I "),
[OP_LD8] = cstr("LD8 "),
[OP_LD16] = cstr("LD16 "),
[OP_LD32] = cstr("LD32 "),
[OP_LD64] = cstr("LD64 "),
// Store ops.
[OP_ST8I] = cstr("ST8I "),
[OP_ST16I] = cstr("ST16I "),
[OP_ST32I] = cstr("ST32I "),
[OP_ST64I] = cstr("ST64I "),
[OP_ST8] = cstr("ST8 "),
[OP_ST16] = cstr("ST16 "),
[OP_ST32] = cstr("ST32 "),
[OP_ST64] = cstr("ST64 "),
// Arithmetic.
[OP_ADDI] = cstr("ADDI "),
[OP_SUBI] = cstr("SUBI "),
[OP_MULI] = cstr("MULI "),
[OP_DIVI] = cstr("DIVI "),
[OP_MODI] = cstr("MODI "),
[OP_ADD] = cstr("ADD "),
[OP_SUB] = cstr("SUB "),
[OP_MUL] = cstr("MUL "),
[OP_DIV] = cstr("DIV "),
[OP_MOD] = cstr("MOD "),
[OP_ADDFI] = cstr("ADDFI "),
[OP_SUBFI] = cstr("SUBFI "),
[OP_MULFI] = cstr("MULFI "),
[OP_DIVFI] = cstr("DIVFI "),
[OP_MODFI] = cstr("MODFI "),
[OP_ADDF] = cstr("ADDF "),
[OP_SUBF] = cstr("SUBF "),
[OP_MULF] = cstr("MULF "),
[OP_DIVF] = cstr("DIVF "),
// Reg copy/move.
[OP_MODF] = cstr("MODF "),
[OP_MOV8] = cstr("MOV8 "),
[OP_MOV16] = cstr("MOV16 "),
[OP_MOV32] = cstr("MOV32 "),
[OP_MOV64] = cstr("MOV64 "),
};
typedef enum {
COMP_CONST,
COMP_STRING,
COMP_REG,
COMP_ERR,
} CompResultType;
typedef struct CompResult {
sz idx;
CompResultType type;
} CompResult;
CompResult compile_expr(Chunk *chunk, Node *node);
#define EMIT_OP(OP, DST, A, B, NODE, CHUNK) \
do { \
Instruction inst = (Instruction){ \
.op = (OP), \
.dst = (DST), \
.a = (A), \
.b = (B), \
}; \
array_push((CHUNK)->code, inst, (CHUNK)->storage); \
} while (0)
CompResult
compile_binary(OpCode op, Chunk *chunk, Node *node) {
CompResult comp_a = compile_expr(chunk, node->left);
CompResult comp_b = compile_expr(chunk, node->right);
sz reg_a;
sz reg_b;
switch (comp_a.type) {
case COMP_CONST: {
reg_a = chunk->reg_idx++;
EMIT_OP(OP_LD64K, reg_a, comp_a.idx, 0, node, chunk);
} break;
case COMP_REG: {
reg_a = comp_a.idx;
} break;
default: {
return (CompResult){.type = COMP_ERR};
} break;
}
switch (comp_b.type) {
case COMP_CONST: {
reg_b = chunk->reg_idx++;
EMIT_OP(OP_LD64K, reg_b, comp_b.idx, 0, node, chunk);
} break;
case COMP_REG: {
reg_b = comp_b.idx;
} break;
default: {
return (CompResult){.type = COMP_ERR};
} break;
}
sz reg_dst = comp_a.idx; // Less registers
// sz reg_dst = chunk->reg_idx++; // Better for optimization
EMIT_OP(op, reg_dst, reg_a, reg_b, node, chunk);
return (CompResult){.type = COMP_REG, .idx = reg_dst};
}
CompResult
compile_expr(Chunk *chunk, Node *node) {
switch (node->kind) {
case NODE_ADD: return compile_binary(OP_ADD, chunk, node); break;
case NODE_SUB: return compile_binary(OP_SUB, chunk, node); break;
case NODE_MUL: return compile_binary(OP_MUL, chunk, node); break;
case NODE_DIV: return compile_binary(OP_DIV, chunk, node); break;
case NODE_MOD: return compile_binary(OP_MOD, chunk, node); break;
case NODE_TRUE:
case NODE_FALSE:
case NODE_NUM_FLOAT:
case NODE_NUM_INT: {
sz value = node->value.i;
// Make sure we don't have duplicated constants.
IntIntMap *map = intintmap_lookup(&chunk->intmap, value);
if (!map) {
map = intintmap_insert(&chunk->intmap, value,
chunk->const_idx++, chunk->storage);
Constant c = (Constant){.i = node->value.i};
array_push(chunk->constants, c, chunk->storage);
}
return (CompResult){
.type = COMP_CONST,
.idx = map->val,
};
} break;
case NODE_STRING: {
Str string = node->value.str;
// Make sure we don't have duplicated strings.
StrIntMap *map = strintmap_lookup(&chunk->strmap, string);
if (!map) {
map = strintmap_insert(&chunk->strmap, string, chunk->str_idx++,
chunk->storage);
array_push(chunk->strings, string, chunk->storage);
}
return (CompResult){
.type = COMP_STRING,
.idx = map->val,
};
} break;
default: {
eprintln("error: compilation not implemented for node %s",
node_str[node->kind]);
exit(EXIT_FAILURE);
} break;
}
return (CompResult){.type = COMP_ERR};
}
#endif // COMPILER_C
|
