[331] | 1 | #include <mruby.h>
|
---|
| 2 | #include <mruby/irep.h>
|
---|
| 3 | #include <mruby/debug.h>
|
---|
| 4 | #include <mruby/opcode.h>
|
---|
| 5 | #include <mruby/string.h>
|
---|
| 6 | #include <mruby/proc.h>
|
---|
[270] | 7 |
|
---|
| 8 | #ifndef MRB_DISABLE_STDIO
|
---|
[439] | 9 | static void
|
---|
| 10 | print_r(mrb_state *mrb, mrb_irep *irep, size_t n)
|
---|
[270] | 11 | {
|
---|
| 12 | size_t i;
|
---|
| 13 |
|
---|
[439] | 14 | if (n == 0) return;
|
---|
[270] | 15 |
|
---|
| 16 | for (i=0; i+1<irep->nlocals; i++) {
|
---|
| 17 | if (irep->lv[i].r == n) {
|
---|
| 18 | mrb_sym sym = irep->lv[i].name;
|
---|
[439] | 19 | printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, sym));
|
---|
| 20 | break;
|
---|
[270] | 21 | }
|
---|
| 22 | }
|
---|
| 23 | }
|
---|
| 24 |
|
---|
[439] | 25 | static void
|
---|
| 26 | print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a)
|
---|
| 27 | {
|
---|
| 28 | if (!irep->lv || a >= irep->nlocals || a == 0) {
|
---|
| 29 | printf("\n");
|
---|
| 30 | return;
|
---|
| 31 | }
|
---|
| 32 | printf("\t;");
|
---|
| 33 | print_r(mrb, irep, a);
|
---|
| 34 | printf("\n");
|
---|
| 35 | }
|
---|
[270] | 36 |
|
---|
| 37 | static void
|
---|
[439] | 38 | print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
|
---|
[270] | 39 | {
|
---|
[439] | 40 | if (!irep->lv || (a >= irep->nlocals && b >= irep->nlocals) || a+b == 0) {
|
---|
[270] | 41 | printf("\n");
|
---|
| 42 | return;
|
---|
| 43 | }
|
---|
[439] | 44 | printf("\t;");
|
---|
| 45 | if (a > 0) print_r(mrb, irep, a);
|
---|
| 46 | if (b > 0) print_r(mrb, irep, b);
|
---|
| 47 | printf("\n");
|
---|
| 48 | }
|
---|
| 49 |
|
---|
| 50 | static void
|
---|
| 51 | print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
|
---|
| 52 | {
|
---|
| 53 | int32_t line;
|
---|
| 54 |
|
---|
| 55 | line = mrb_debug_get_line(mrb, irep, i);
|
---|
| 56 | if (line < 0) {
|
---|
| 57 | printf(" ");
|
---|
[270] | 58 | }
|
---|
[439] | 59 | else {
|
---|
| 60 | printf("%5d ", line);
|
---|
[270] | 61 | }
|
---|
[439] | 62 |
|
---|
| 63 | printf("%03d ", (int)i);
|
---|
[270] | 64 | }
|
---|
| 65 |
|
---|
[439] | 66 | #define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn
|
---|
| 67 |
|
---|
[270] | 68 | static void
|
---|
| 69 | codedump(mrb_state *mrb, mrb_irep *irep)
|
---|
| 70 | {
|
---|
| 71 | int ai;
|
---|
[439] | 72 | const mrb_code *pc, *pcend;
|
---|
| 73 | mrb_code ins;
|
---|
[270] | 74 | const char *file = NULL, *next_file;
|
---|
| 75 |
|
---|
| 76 | if (!irep) return;
|
---|
[439] | 77 | printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d iseq=%d\n", (void*)irep,
|
---|
| 78 | irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen, (int)irep->ilen);
|
---|
[270] | 79 |
|
---|
[439] | 80 | if (irep->lv) {
|
---|
| 81 | int i;
|
---|
| 82 |
|
---|
| 83 | printf("local variable names:\n");
|
---|
| 84 | for (i = 1; i < irep->nlocals; ++i) {
|
---|
| 85 | char const *s = mrb_sym_dump(mrb, irep->lv[i - 1].name);
|
---|
| 86 | int n = irep->lv[i - 1].r ? irep->lv[i - 1].r : i;
|
---|
| 87 | printf(" R%d:%s\n", n, s ? s : "");
|
---|
| 88 | }
|
---|
| 89 | }
|
---|
| 90 |
|
---|
| 91 | pc = irep->iseq;
|
---|
| 92 | pcend = pc + irep->ilen;
|
---|
| 93 | while (pc < pcend) {
|
---|
| 94 | ptrdiff_t i;
|
---|
| 95 | uint32_t a;
|
---|
| 96 | uint16_t b;
|
---|
| 97 | uint8_t c;
|
---|
| 98 |
|
---|
[270] | 99 | ai = mrb_gc_arena_save(mrb);
|
---|
| 100 |
|
---|
[439] | 101 | i = pc - irep->iseq;
|
---|
| 102 | next_file = mrb_debug_get_filename(mrb, irep, i);
|
---|
[270] | 103 | if (next_file && file != next_file) {
|
---|
| 104 | printf("file: %s\n", next_file);
|
---|
| 105 | file = next_file;
|
---|
| 106 | }
|
---|
[439] | 107 | print_header(mrb, irep, i);
|
---|
| 108 | ins = READ_B();
|
---|
| 109 | switch (ins) {
|
---|
| 110 | CASE(OP_NOP, Z):
|
---|
[270] | 111 | printf("OP_NOP\n");
|
---|
| 112 | break;
|
---|
[439] | 113 | CASE(OP_MOVE, BB):
|
---|
| 114 | printf("OP_MOVE\tR%d\tR%d\t", a, b);
|
---|
| 115 | print_lv_ab(mrb, irep, a, b);
|
---|
[270] | 116 | break;
|
---|
[439] | 117 | CASE(OP_LOADL, BB):
|
---|
[270] | 118 | {
|
---|
[439] | 119 | mrb_value v = irep->pool[b];
|
---|
[270] | 120 | mrb_value s = mrb_inspect(mrb, v);
|
---|
[439] | 121 | printf("OP_LOADL\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
|
---|
[270] | 122 | }
|
---|
[439] | 123 | print_lv_a(mrb, irep, a);
|
---|
[270] | 124 | break;
|
---|
[439] | 125 | CASE(OP_LOADI, BB):
|
---|
| 126 | printf("OP_LOADI\tR%d\t%d\t", a, b);
|
---|
| 127 | print_lv_a(mrb, irep, a);
|
---|
[270] | 128 | break;
|
---|
[439] | 129 | CASE(OP_LOADINEG, BB):
|
---|
| 130 | printf("OP_LOADI\tR%d\t-%d\t", a, b);
|
---|
| 131 | print_lv_a(mrb, irep, a);
|
---|
[270] | 132 | break;
|
---|
[439] | 133 | CASE(OP_LOADI__1, B):
|
---|
| 134 | printf("OP_LOADI__1\tR%d\t\t", a);
|
---|
| 135 | print_lv_a(mrb, irep, a);
|
---|
[270] | 136 | break;
|
---|
[439] | 137 | CASE(OP_LOADI_0, B): goto L_LOADI;
|
---|
| 138 | CASE(OP_LOADI_1, B): goto L_LOADI;
|
---|
| 139 | CASE(OP_LOADI_2, B): goto L_LOADI;
|
---|
| 140 | CASE(OP_LOADI_3, B): goto L_LOADI;
|
---|
| 141 | CASE(OP_LOADI_4, B): goto L_LOADI;
|
---|
| 142 | CASE(OP_LOADI_5, B): goto L_LOADI;
|
---|
| 143 | CASE(OP_LOADI_6, B): goto L_LOADI;
|
---|
| 144 | CASE(OP_LOADI_7, B):
|
---|
| 145 | L_LOADI:
|
---|
| 146 | printf("OP_LOADI_%d\tR%d\t\t", ins-(int)OP_LOADI_0, a);
|
---|
| 147 | print_lv_a(mrb, irep, a);
|
---|
[270] | 148 | break;
|
---|
[439] | 149 | CASE(OP_LOADSYM, BB):
|
---|
| 150 | printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 151 | print_lv_a(mrb, irep, a);
|
---|
[270] | 152 | break;
|
---|
[439] | 153 | CASE(OP_LOADNIL, B):
|
---|
| 154 | printf("OP_LOADNIL\tR%d\t\t", a);
|
---|
| 155 | print_lv_a(mrb, irep, a);
|
---|
[270] | 156 | break;
|
---|
[439] | 157 | CASE(OP_LOADSELF, B):
|
---|
| 158 | printf("OP_LOADSELF\tR%d\t\t", a);
|
---|
| 159 | print_lv_a(mrb, irep, a);
|
---|
[270] | 160 | break;
|
---|
[439] | 161 | CASE(OP_LOADT, B):
|
---|
| 162 | printf("OP_LOADT\tR%d\t\t", a);
|
---|
| 163 | print_lv_a(mrb, irep, a);
|
---|
[270] | 164 | break;
|
---|
[439] | 165 | CASE(OP_LOADF, B):
|
---|
| 166 | printf("OP_LOADF\tR%d\t\t", a);
|
---|
| 167 | print_lv_a(mrb, irep, a);
|
---|
[270] | 168 | break;
|
---|
[439] | 169 | CASE(OP_GETGV, BB):
|
---|
| 170 | printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 171 | print_lv_a(mrb, irep, a);
|
---|
[270] | 172 | break;
|
---|
[439] | 173 | CASE(OP_SETGV, BB):
|
---|
| 174 | printf("OP_SETGV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
|
---|
| 175 | print_lv_a(mrb, irep, a);
|
---|
[270] | 176 | break;
|
---|
[439] | 177 | CASE(OP_GETSV, BB):
|
---|
| 178 | printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 179 | print_lv_a(mrb, irep, a);
|
---|
[270] | 180 | break;
|
---|
[439] | 181 | CASE(OP_SETSV, BB):
|
---|
| 182 | printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
|
---|
| 183 | print_lv_a(mrb, irep, a);
|
---|
[270] | 184 | break;
|
---|
[439] | 185 | CASE(OP_GETCONST, BB):
|
---|
| 186 | printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 187 | print_lv_a(mrb, irep, a);
|
---|
[270] | 188 | break;
|
---|
[439] | 189 | CASE(OP_SETCONST, BB):
|
---|
| 190 | printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
|
---|
| 191 | print_lv_a(mrb, irep, a);
|
---|
[270] | 192 | break;
|
---|
[439] | 193 | CASE(OP_GETMCNST, BB):
|
---|
| 194 | printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 195 | print_lv_a(mrb, irep, a);
|
---|
[270] | 196 | break;
|
---|
[439] | 197 | CASE(OP_SETMCNST, BB):
|
---|
| 198 | printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a);
|
---|
| 199 | print_lv_a(mrb, irep, a);
|
---|
[270] | 200 | break;
|
---|
[439] | 201 | CASE(OP_GETIV, BB):
|
---|
| 202 | printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 203 | print_lv_a(mrb, irep, a);
|
---|
[270] | 204 | break;
|
---|
[439] | 205 | CASE(OP_SETIV, BB):
|
---|
| 206 | printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
|
---|
| 207 | print_lv_a(mrb, irep, a);
|
---|
[270] | 208 | break;
|
---|
[439] | 209 | CASE(OP_GETUPVAR, BBB):
|
---|
| 210 | printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c);
|
---|
| 211 | print_lv_a(mrb, irep, a);
|
---|
[270] | 212 | break;
|
---|
[439] | 213 | CASE(OP_SETUPVAR, BBB):
|
---|
| 214 | printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c);
|
---|
| 215 | print_lv_a(mrb, irep, a);
|
---|
[270] | 216 | break;
|
---|
[439] | 217 | CASE(OP_GETCV, BB):
|
---|
| 218 | printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 219 | print_lv_a(mrb, irep, a);
|
---|
[270] | 220 | break;
|
---|
[439] | 221 | CASE(OP_SETCV, BB):
|
---|
| 222 | printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
|
---|
| 223 | print_lv_a(mrb, irep, a);
|
---|
[270] | 224 | break;
|
---|
[439] | 225 | CASE(OP_JMP, S):
|
---|
| 226 | printf("OP_JMP\t\t%03d\n", a);
|
---|
[270] | 227 | break;
|
---|
[439] | 228 | CASE(OP_JMPIF, BS):
|
---|
| 229 | printf("OP_JMPIF\tR%d\t%03d\t", a, b);
|
---|
| 230 | print_lv_a(mrb, irep, a);
|
---|
[270] | 231 | break;
|
---|
[439] | 232 | CASE(OP_JMPNOT, BS):
|
---|
| 233 | printf("OP_JMPNOT\tR%d\t%03d\t", a, b);
|
---|
| 234 | print_lv_a(mrb, irep, a);
|
---|
[270] | 235 | break;
|
---|
[439] | 236 | CASE(OP_JMPNIL, BS):
|
---|
| 237 | printf("OP_JMPNIL\tR%d\t%03d\t", a, b);
|
---|
| 238 | print_lv_a(mrb, irep, a);
|
---|
| 239 | break;
|
---|
| 240 | CASE(OP_SENDV, BB):
|
---|
| 241 | printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 242 | break;
|
---|
| 243 | CASE(OP_SENDVB, BB):
|
---|
| 244 | printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 245 | break;
|
---|
| 246 | CASE(OP_SEND, BBB):
|
---|
| 247 | printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
|
---|
| 248 | break;
|
---|
| 249 | CASE(OP_SENDB, BBB):
|
---|
| 250 | printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
|
---|
| 251 | break;
|
---|
| 252 | CASE(OP_CALL, Z):
|
---|
| 253 | printf("OP_CALL\n");
|
---|
| 254 | break;
|
---|
| 255 | CASE(OP_SUPER, BB):
|
---|
| 256 | printf("OP_SUPER\tR%d\t%d\n", a, b);
|
---|
| 257 | break;
|
---|
| 258 | CASE(OP_ARGARY, BS):
|
---|
| 259 | printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a,
|
---|
| 260 | (b>>11)&0x3f,
|
---|
| 261 | (b>>10)&0x1,
|
---|
| 262 | (b>>5)&0x1f,
|
---|
| 263 | (b>>4)&0x1,
|
---|
| 264 | (b>>0)&0xf);
|
---|
| 265 | print_lv_a(mrb, irep, a);
|
---|
| 266 | break;
|
---|
| 267 | CASE(OP_ENTER, W):
|
---|
[270] | 268 | printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
|
---|
[439] | 269 | MRB_ASPEC_REQ(a),
|
---|
| 270 | MRB_ASPEC_OPT(a),
|
---|
| 271 | MRB_ASPEC_REST(a),
|
---|
| 272 | MRB_ASPEC_POST(a),
|
---|
| 273 | MRB_ASPEC_KEY(a),
|
---|
| 274 | MRB_ASPEC_KDICT(a),
|
---|
| 275 | MRB_ASPEC_BLOCK(a));
|
---|
[270] | 276 | break;
|
---|
[439] | 277 | CASE(OP_KEY_P, BB):
|
---|
| 278 | printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 279 | print_lv_a(mrb, irep, a);
|
---|
[270] | 280 | break;
|
---|
[439] | 281 | CASE(OP_KEYEND, Z):
|
---|
| 282 | printf("OP_KEYEND\n");
|
---|
[270] | 283 | break;
|
---|
[439] | 284 | CASE(OP_KARG, BB):
|
---|
| 285 | printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 286 | print_lv_a(mrb, irep, a);
|
---|
[270] | 287 | break;
|
---|
[439] | 288 | CASE(OP_RETURN, B):
|
---|
| 289 | printf("OP_RETURN\tR%d\t\t", a);
|
---|
| 290 | print_lv_a(mrb, irep, a);
|
---|
[270] | 291 | break;
|
---|
[439] | 292 | CASE(OP_RETURN_BLK, B):
|
---|
| 293 | printf("OP_RETURN_BLK\tR%d\t\t", a);
|
---|
| 294 | print_lv_a(mrb, irep, a);
|
---|
[270] | 295 | break;
|
---|
[439] | 296 | CASE(OP_BREAK, B):
|
---|
| 297 | printf("OP_BREAK\tR%d\t\t", a);
|
---|
| 298 | print_lv_a(mrb, irep, a);
|
---|
[270] | 299 | break;
|
---|
[439] | 300 | CASE(OP_BLKPUSH, BS):
|
---|
| 301 | printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a,
|
---|
| 302 | (b>>11)&0x3f,
|
---|
| 303 | (b>>10)&0x1,
|
---|
| 304 | (b>>5)&0x1f,
|
---|
| 305 | (b>>4)&0x1,
|
---|
| 306 | (b>>0)&0xf);
|
---|
| 307 | print_lv_a(mrb, irep, a);
|
---|
[270] | 308 | break;
|
---|
[439] | 309 | CASE(OP_LAMBDA, BB):
|
---|
| 310 | printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
|
---|
[270] | 311 | break;
|
---|
[439] | 312 | CASE(OP_BLOCK, BB):
|
---|
| 313 | printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
|
---|
[270] | 314 | break;
|
---|
[439] | 315 | CASE(OP_METHOD, BB):
|
---|
| 316 | printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
|
---|
[270] | 317 | break;
|
---|
[439] | 318 | CASE(OP_RANGE_INC, B):
|
---|
| 319 | printf("OP_RANGE_INC\tR%d\n", a);
|
---|
[270] | 320 | break;
|
---|
[439] | 321 | CASE(OP_RANGE_EXC, B):
|
---|
| 322 | printf("OP_RANGE_EXC\tR%d\n", a);
|
---|
[270] | 323 | break;
|
---|
[439] | 324 | CASE(OP_DEF, BB):
|
---|
| 325 | printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
[270] | 326 | break;
|
---|
[439] | 327 | CASE(OP_UNDEF, B):
|
---|
| 328 | printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a]));
|
---|
[270] | 329 | break;
|
---|
[439] | 330 | CASE(OP_ALIAS, BB):
|
---|
| 331 | printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_dump(mrb, irep->syms[a]), mrb_sym_dump(mrb, irep->syms[b]));
|
---|
[270] | 332 | break;
|
---|
[439] | 333 | CASE(OP_ADD, B):
|
---|
| 334 | printf("OP_ADD\tR%d\t\n", a);
|
---|
[270] | 335 | break;
|
---|
[439] | 336 | CASE(OP_ADDI, BB):
|
---|
| 337 | printf("OP_ADDI\tR%d\t%d\n", a, b);
|
---|
[270] | 338 | break;
|
---|
[439] | 339 | CASE(OP_SUB, B):
|
---|
| 340 | printf("OP_SUB\tR%d\t\n", a);
|
---|
[270] | 341 | break;
|
---|
[439] | 342 | CASE(OP_SUBI, BB):
|
---|
| 343 | printf("OP_SUBI\tR%d\t%d\n", a, b);
|
---|
[270] | 344 | break;
|
---|
[439] | 345 | CASE(OP_MUL, B):
|
---|
| 346 | printf("OP_MUL\tR%d\t\n", a);
|
---|
[270] | 347 | break;
|
---|
[439] | 348 | CASE(OP_DIV, B):
|
---|
| 349 | printf("OP_DIV\tR%d\t\n", a);
|
---|
[270] | 350 | break;
|
---|
[439] | 351 | CASE(OP_LT, B):
|
---|
| 352 | printf("OP_LT\t\tR%d\t\n", a);
|
---|
[270] | 353 | break;
|
---|
[439] | 354 | CASE(OP_LE, B):
|
---|
| 355 | printf("OP_LE\t\tR%d\t\n", a);
|
---|
| 356 | break;
|
---|
| 357 | CASE(OP_GT, B):
|
---|
| 358 | printf("OP_GT\t\tR%d\t\n", a);
|
---|
| 359 | break;
|
---|
| 360 | CASE(OP_GE, B):
|
---|
| 361 | printf("OP_GE\t\tR%d\t\n", a);
|
---|
| 362 | break;
|
---|
| 363 | CASE(OP_EQ, B):
|
---|
| 364 | printf("OP_EQ\t\tR%d\t\n", a);
|
---|
| 365 | break;
|
---|
| 366 | CASE(OP_ARRAY, BB):
|
---|
| 367 | printf("OP_ARRAY\tR%d\t%d\t", a, b);
|
---|
| 368 | print_lv_a(mrb, irep, a);
|
---|
| 369 | break;
|
---|
| 370 | CASE(OP_ARRAY2, BBB):
|
---|
| 371 | printf("OP_ARRAY\tR%d\tR%d\t%d\t", a, b, c);
|
---|
| 372 | print_lv_ab(mrb, irep, a, b);
|
---|
| 373 | break;
|
---|
| 374 | CASE(OP_ARYCAT, B):
|
---|
| 375 | printf("OP_ARYCAT\tR%d\t", a);
|
---|
| 376 | print_lv_a(mrb, irep, a);
|
---|
| 377 | break;
|
---|
| 378 | CASE(OP_ARYPUSH, B):
|
---|
| 379 | printf("OP_ARYPUSH\tR%d\t", a);
|
---|
| 380 | print_lv_a(mrb, irep, a);
|
---|
| 381 | break;
|
---|
| 382 | CASE(OP_ARYDUP, B):
|
---|
| 383 | printf("OP_ARYDUP\tR%d\t", a);
|
---|
| 384 | print_lv_a(mrb, irep, a);
|
---|
| 385 | break;
|
---|
| 386 | CASE(OP_AREF, BBB):
|
---|
| 387 | printf("OP_AREF\tR%d\tR%d\t%d", a, b, c);
|
---|
| 388 | print_lv_ab(mrb, irep, a, b);
|
---|
| 389 | break;
|
---|
| 390 | CASE(OP_ASET, BBB):
|
---|
| 391 | printf("OP_ASET\tR%d\tR%d\t%d", a, b, c);
|
---|
| 392 | print_lv_ab(mrb, irep, a, b);
|
---|
| 393 | break;
|
---|
| 394 | CASE(OP_APOST, BBB):
|
---|
| 395 | printf("OP_APOST\tR%d\t%d\t%d", a, b, c);
|
---|
| 396 | print_lv_a(mrb, irep, a);
|
---|
| 397 | break;
|
---|
| 398 | CASE(OP_INTERN, B):
|
---|
| 399 | printf("OP_INTERN\tR%d", a);
|
---|
| 400 | print_lv_a(mrb, irep, a);
|
---|
| 401 | break;
|
---|
| 402 | CASE(OP_STRING, BB):
|
---|
[270] | 403 | {
|
---|
[439] | 404 | mrb_value v = irep->pool[b];
|
---|
[270] | 405 | mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
|
---|
[439] | 406 | printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
|
---|
[270] | 407 | }
|
---|
[439] | 408 | print_lv_a(mrb, irep, a);
|
---|
[270] | 409 | break;
|
---|
[439] | 410 | CASE(OP_STRCAT, B):
|
---|
| 411 | printf("OP_STRCAT\tR%d\t", a);
|
---|
| 412 | print_lv_a(mrb, irep, a);
|
---|
[270] | 413 | break;
|
---|
[439] | 414 | CASE(OP_HASH, BB):
|
---|
| 415 | printf("OP_HASH\tR%d\t%d\t", a, b);
|
---|
| 416 | print_lv_a(mrb, irep, a);
|
---|
[270] | 417 | break;
|
---|
[439] | 418 | CASE(OP_HASHADD, BB):
|
---|
| 419 | printf("OP_HASHADD\tR%d\t%d\t", a, b);
|
---|
| 420 | print_lv_a(mrb, irep, a);
|
---|
| 421 | break;
|
---|
| 422 | CASE(OP_HASHCAT, B):
|
---|
| 423 | printf("OP_HASHCAT\tR%d\t", a);
|
---|
| 424 | print_lv_a(mrb, irep, a);
|
---|
| 425 | break;
|
---|
[270] | 426 |
|
---|
[439] | 427 | CASE(OP_OCLASS, B):
|
---|
| 428 | printf("OP_OCLASS\tR%d\t\t", a);
|
---|
| 429 | print_lv_a(mrb, irep, a);
|
---|
[270] | 430 | break;
|
---|
[439] | 431 | CASE(OP_CLASS, BB):
|
---|
| 432 | printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 433 | print_lv_a(mrb, irep, a);
|
---|
[270] | 434 | break;
|
---|
[439] | 435 | CASE(OP_MODULE, BB):
|
---|
| 436 | printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
|
---|
| 437 | print_lv_a(mrb, irep, a);
|
---|
[270] | 438 | break;
|
---|
[439] | 439 | CASE(OP_EXEC, BB):
|
---|
| 440 | printf("OP_EXEC\tR%d\tI(%d:%p)", a, b, irep->reps[b]);
|
---|
| 441 | print_lv_a(mrb, irep, a);
|
---|
[270] | 442 | break;
|
---|
[439] | 443 | CASE(OP_SCLASS, B):
|
---|
| 444 | printf("OP_SCLASS\tR%d\t", a);
|
---|
| 445 | print_lv_a(mrb, irep, a);
|
---|
[270] | 446 | break;
|
---|
[439] | 447 | CASE(OP_TCLASS, B):
|
---|
| 448 | printf("OP_TCLASS\tR%d\t\t", a);
|
---|
| 449 | print_lv_a(mrb, irep, a);
|
---|
[270] | 450 | break;
|
---|
[439] | 451 | CASE(OP_ERR, B):
|
---|
[270] | 452 | {
|
---|
[439] | 453 | mrb_value v = irep->pool[a];
|
---|
[270] | 454 | mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
|
---|
| 455 | printf("OP_ERR\t%s\n", RSTRING_PTR(s));
|
---|
| 456 | }
|
---|
| 457 | break;
|
---|
[439] | 458 | CASE(OP_EPUSH, B):
|
---|
| 459 | printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]);
|
---|
[270] | 460 | break;
|
---|
[439] | 461 | CASE(OP_ONERR, S):
|
---|
| 462 | printf("OP_ONERR\t%03d\n", a);
|
---|
[270] | 463 | break;
|
---|
[439] | 464 | CASE(OP_EXCEPT, B):
|
---|
| 465 | printf("OP_EXCEPT\tR%d\t\t", a);
|
---|
| 466 | print_lv_a(mrb, irep, a);
|
---|
| 467 | break;
|
---|
| 468 | CASE(OP_RESCUE, BB):
|
---|
| 469 | printf("OP_RESCUE\tR%d\tR%d", a, b);
|
---|
| 470 | print_lv_ab(mrb, irep, a, b);
|
---|
| 471 | break;
|
---|
| 472 | CASE(OP_RAISE, B):
|
---|
| 473 | printf("OP_RAISE\tR%d\t\t", a);
|
---|
| 474 | print_lv_a(mrb, irep, a);
|
---|
| 475 | break;
|
---|
| 476 | CASE(OP_POPERR, B):
|
---|
| 477 | printf("OP_POPERR\t%d\t\t\n", a);
|
---|
| 478 | break;
|
---|
| 479 | CASE(OP_EPOP, B):
|
---|
| 480 | printf("OP_EPOP\t%d\n", a);
|
---|
| 481 | break;
|
---|
[331] | 482 |
|
---|
[439] | 483 | CASE(OP_DEBUG, BBB):
|
---|
| 484 | printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c);
|
---|
| 485 | break;
|
---|
| 486 |
|
---|
| 487 | CASE(OP_STOP, Z):
|
---|
| 488 | printf("OP_STOP\n");
|
---|
| 489 | break;
|
---|
| 490 |
|
---|
| 491 | CASE(OP_EXT1, Z):
|
---|
| 492 | ins = READ_B();
|
---|
| 493 | printf("OP_EXT1\n");
|
---|
| 494 | print_header(mrb, irep, pc-irep->iseq-2);
|
---|
| 495 | switch (ins) {
|
---|
| 496 | #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i;
|
---|
| 497 | #include "mruby/ops.h"
|
---|
| 498 | #undef OPCODE
|
---|
[331] | 499 | }
|
---|
[270] | 500 | break;
|
---|
[439] | 501 | CASE(OP_EXT2, Z):
|
---|
| 502 | ins = READ_B();
|
---|
| 503 | printf("OP_EXT2\n");
|
---|
| 504 | print_header(mrb, irep, pc-irep->iseq-2);
|
---|
| 505 | switch (ins) {
|
---|
| 506 | #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i;
|
---|
| 507 | #include "mruby/ops.h"
|
---|
| 508 | #undef OPCODE
|
---|
| 509 | }
|
---|
[270] | 510 | break;
|
---|
[439] | 511 | CASE(OP_EXT3, Z):
|
---|
| 512 | ins = READ_B();
|
---|
| 513 | printf("OP_EXT3\n");
|
---|
| 514 | print_header(mrb, irep, pc-irep->iseq-2);
|
---|
| 515 | switch (ins) {
|
---|
| 516 | #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i;
|
---|
| 517 | #include "mruby/ops.h"
|
---|
| 518 | #undef OPCODE
|
---|
| 519 | }
|
---|
[270] | 520 | break;
|
---|
| 521 |
|
---|
| 522 | default:
|
---|
[439] | 523 | printf("OP_unknown (0x%x)\n", ins);
|
---|
[270] | 524 | break;
|
---|
| 525 | }
|
---|
| 526 | mrb_gc_arena_restore(mrb, ai);
|
---|
| 527 | }
|
---|
| 528 | printf("\n");
|
---|
| 529 | }
|
---|
| 530 |
|
---|
| 531 | static void
|
---|
| 532 | codedump_recur(mrb_state *mrb, mrb_irep *irep)
|
---|
| 533 | {
|
---|
[439] | 534 | int i;
|
---|
[270] | 535 |
|
---|
| 536 | codedump(mrb, irep);
|
---|
| 537 | for (i=0; i<irep->rlen; i++) {
|
---|
| 538 | codedump_recur(mrb, irep->reps[i]);
|
---|
| 539 | }
|
---|
| 540 | }
|
---|
[439] | 541 | #endif
|
---|
[270] | 542 |
|
---|
| 543 | void
|
---|
| 544 | mrb_codedump_all(mrb_state *mrb, struct RProc *proc)
|
---|
| 545 | {
|
---|
[439] | 546 | #ifndef MRB_DISABLE_STDIO
|
---|
[270] | 547 | codedump_recur(mrb, proc->body.irep);
|
---|
[439] | 548 | #endif
|
---|
[270] | 549 | }
|
---|