-
Notifications
You must be signed in to change notification settings - Fork 0
/
debug.c
197 lines (182 loc) · 6.43 KB
/
debug.c
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
#include <stdio.h>
#include "debug.h"
#include "object.h"
#include "value.h"
/// @brief チャンクを逆アセンブルする
/// @param chunk 対象のチャンク
/// @param name 名前
void disassemble_chunk(Chunk* chunk, const char* name) {
printf("== %s ==\n", name);
for (int offset = 0; offset < chunk->count; ) {
offset = disassemble_instruction(chunk, offset);
}
}
/// @brief 1バイトの命令を逆アセンブルする
/// @param name 名前
/// @param offset 開始位置
/// @return 次の命令の開始位置
static int simple_instruction(const char* name, int offset) {
printf("%s\n", name);
return offset + 1;
}
/// @brief 2バイトの命令を逆アセンブルする
/// @param name
/// @param chunk
/// @param offset
/// @return
static int byte_instruction(const char* name, Chunk* chunk, int offset) {
uint8_t slot = chunk->code[offset + 1];
printf("%-16s %4d\n", name, slot);
return offset + 2;
}
/// @brief ジャンプ命令を逆アセンブルする
/// @param name
/// @param sign 符号
/// @param chunk
/// @param offset
/// @return
static int jump_instruction(const char* name, int sign, Chunk* chunk, int offset) {
uint16_t jump = (uint16_t)(chunk->code[offset + 1] << 8);
jump |= chunk->code[offset + 2];
printf("%-16s %4d -> %d\n", name, offset, offset + 3 + sign*jump);
return offset + 3;
}
/// @brief 定数命令を逆アセンブルする
/// @param name 名前
/// @param chunk チャンク
/// @param offset 開始位置
/// @return 次の命令の開始位置
static int constant_instruction(const char* name, Chunk* chunk, int offset) {
uint8_t constant = chunk->code[offset + 1];
printf("%-16s %4d \'", name, constant);
print_value(chunk->constants.values[constant]);
printf("\'\n");
return offset + 2;
}
/// @brief INVOKE命令を逆アセンブルする
/// @param name
/// @param chunk
/// @param offset
/// @return
static int invoke_instruction(const char* name, Chunk* chunk, int offset) {
uint8_t constant = chunk->code[offset + 1];
uint8_t arg_count = chunk->code[offset + 2];
printf("%-16s (%d args) %4d '", name, arg_count, constant);
print_value(chunk->constants.values[constant]);
printf("'\n");
return offset + 3;
}
/// @brief 命令を逆アセンブルする
/// @param chunk チャンク
/// @param offset 開始位置
/// @return
int disassemble_instruction(Chunk* chunk, int offset) {
printf("%04d ", offset);
if (offset > 0 && chunk->lines[offset] == chunk->lines[offset-1]) {
printf(" | ");
} else {
printf("%4d ", chunk->lines[offset]);
}
uint8_t instruction = chunk->code[offset];
switch (instruction) {
case OP_CONSTANT:
return constant_instruction("OP_CONSTANT", chunk, offset);
case OP_NIL:
return simple_instruction("OP_NIL", offset);
case OP_TRUE:
return simple_instruction("OP_TRUE", offset);
case OP_FALSE:
return simple_instruction("OP_FALSE", offset);
case OP_POP:
return simple_instruction("OP_POP", offset);
case OP_GET_LOCAL:
return byte_instruction("OP_GET_LOCAL", chunk, offset);
case OP_GET_UPVALUE:
return byte_instruction("OP_GET_UPVALUE", chunk, offset);
case OP_SET_UPVALUE:
return byte_instruction("OP_SET_UPVALUE", chunk, offset);
case OP_GET_PROPERTY:
return constant_instruction("OP_GET_PROPERTY", chunk, offset);
case OP_SET_PROPERTY:
return constant_instruction("OP_SET_PROPERTY", chunk, offset);
case OP_GET_SUPER:
return constant_instruction("OP_GET_SUPER", chunk, offset);
case OP_SET_LOCAL:
return byte_instruction("OP_SET_LOCAL", chunk, offset);
case OP_GET_GLOBAL:
return constant_instruction("OP_GET_GLOBAL", chunk, offset);
case OP_DEFINE_GLOBAL:
return simple_instruction("OP_DEFINE_GLOBAL", offset);
case OP_SET_GLOBAL:
return constant_instruction("OP_SET_GLOBAL", chunk, offset);
case OP_EQUAL:
return simple_instruction("OP_EQUAL", offset);
case OP_GREATER:
return simple_instruction("OP_GREATER", offset);
case OP_LESS:
return simple_instruction("OP_LESS", offset);
case OP_ADD:
return simple_instruction("OP_ADD", offset);
case OP_SUBTRACT:
return simple_instruction("OP_SUBTRACT", offset);
case OP_MULTIPLY:
return simple_instruction("OP_MULTIPLY", offset);
case OP_DIVIDE:
return simple_instruction("OP_DIVIDE", offset);
case OP_NOT:
return simple_instruction("OP_NOT", offset);
case OP_NEGATE:
return simple_instruction("OP_NEGATE", offset);
case OP_PRINT:
return simple_instruction("OP_PRINT", offset);
case OP_JUMP:
return jump_instruction("OP_JUMP", 1, chunk, offset);
case OP_JUMP_IF_FALSE:
return jump_instruction("OP_JUMP_IF_FALSE", 1, chunk, offset);
case OP_LOOP:
return jump_instruction("OP_LOOP", -1, chunk, offset);
case OP_CALL:
return byte_instruction("OP_CALL", chunk, offset);
case OP_INVOKE:
return invoke_instruction("OP_INVOKE", chunk, offset);
case OP_SUPER_INVOKE:
return invoke_instruction("OP_SUPER_INVOKE", chunk, offset);
case OP_CLOSURE: {
offset += 1;
uint8_t constant = chunk->code[offset];
offset += 1;
printf("%-16s %4d ", "OP_CLOSURE", constant);
print_value(chunk->constants.values[constant]);
printf("\n");
ObjFunction* function = AS_FUNCTION(
chunk->constants.values[constant]
);
for (int i = 0; i < function->upvalue_count; i++) {
int is_local = chunk->code[offset];
offset += 1;
int index = chunk->code[offset];
offset += 1;
printf(
"%04d | %s %d\n",
offset - 2,
is_local ? "local" : "upvalue",
index
);
}
return offset;
}
case OP_CLOSE_UPVALUE:
return simple_instruction("OP_CLOSE_UPVALUE", offset);
case OP_RETURN:
return simple_instruction("OP_RETURN", offset);
case OP_CLASS:
return constant_instruction("OP_CLASS", chunk, offset);
case OP_INHERIT:
return simple_instruction("OP_INHERIT", offset);
case OP_METHOD:
return constant_instruction("OP_METHOD", chunk, offset);
default:
printf("unknown opcode %d\n", instruction);
return offset + 1;
}
}