Remove `OP_EXT[123]` from operands.

doc/opcode.md

@@ -20,14 +20,6 @@ sign) of operands.
 * sS: signed 16bit
 * W: 24bit
 
-First two byte operands may be extended to 16bit. When those byte
-operands are bigger than 256, the instruction will be prefixed by
-`OP_EXT1` (means 1st operand is 16bit) or `OP_EXT2` (means 2nd operand
-is 16bit) or `OP_EXT3` (means 1st and 2nd operands are 16bit).
-
-For instructions marked by `'`, `OP_EXT1` can be prefixed. For those
-with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
-
 ## table.1 Instruction Table
 
 | Instruction Name | Operand type | Semantics                                              |
@@ -133,8 +125,5 @@ with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
 | OP_TCLASS'       | B            | R(a) = target_class                                    |
 | OP_DEBUG"        | BBB          | print a,b,c                                            |
 | OP_ERR'          | B            | raise(LocalJumpError, Lit(a))                          |
-| OP_EXT1          | -            | make 1st operand 16bit                                 |
-| OP_EXT2          | -            | make 2nd operand 16bit                                 |
-| OP_EXT3          | -            | make 1st and 2nd operands 16bit                        |
 | OP_STOP          | -            | stop VM                                                |
 |------------------|--------------|--------------------------------------------------------|

include/mruby/opcode.h

@@ -39,31 +39,4 @@ enum mrb_insn {
 #define FETCH_S() do {a=READ_S();} while (0)
 #define FETCH_W() do {a=READ_W();} while (0)
 
-/* with OP_EXT1 (1st 16bit) */
-#define FETCH_Z_1() FETCH_Z()
-#define FETCH_B_1() FETCH_S()
-#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
-#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
-#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_1() FETCH_S()
-#define FETCH_W_1() FETCH_W()
-
-/* with OP_EXT2 (2nd 16bit) */
-#define FETCH_Z_2() FETCH_Z()
-#define FETCH_B_2() FETCH_B()
-#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
-#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_2() FETCH_BS()
-#define FETCH_S_2() FETCH_S()
-#define FETCH_W_2() FETCH_W()
-
-/* with OP_EXT3 (1st & 2nd 16bit) */
-#define FETCH_Z_3() FETCH_Z()
-#define FETCH_B_3() FETCH_B()
-#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_3() FETCH_S()
-#define FETCH_W_3() FETCH_W()
-
 #endif  /* MRUBY_OPCODE_H */

include/mruby/ops.h

@@ -111,8 +111,5 @@ OPCODE(SCLASS,     B)        /* R(a) = R(a).singleton_class */
 OPCODE(TCLASS,     B)        /* R(a) = target_class */
 OPCODE(DEBUG,      BBB)      /* print a,b,c */
 OPCODE(ERR,        B)        /* raise(LocalJumpError, Lit(a)) */
-OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
-OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
-OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
 OPCODE(STOP,       Z)        /* stop VM */
 OPCODE(LOADI16,    BS)       /* R(a) = mrb_int(b) */

mrbgems/mruby-compiler/core/codegen.c

@@ -217,9 +217,7 @@ genop_1(codegen_scope *s, mrb_code i, uint16_t a)
 {
   s->lastpc = s->pc;
   if (a > 0xff) {
-    gen_B(s, OP_EXT1);
-    gen_B(s, i);
-    gen_S(s, a);
+    codegen_error(s, "too big operand");
   }
   else {
     gen_B(s, i);
@@ -231,23 +229,8 @@ static void
 genop_2(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
 {
   s->lastpc = s->pc;
-  if (a > 0xff && b > 0xff) {
-    gen_B(s, OP_EXT3);
-    gen_B(s, i);
-    gen_S(s, a);
-    gen_S(s, b);
-  }
-  else if (b > 0xff) {
-    gen_B(s, OP_EXT2);
-    gen_B(s, i);
-    gen_B(s, (uint8_t)a);
-    gen_S(s, b);
-  }
-  else if (a > 0xff) {
-    gen_B(s, OP_EXT1);
-    gen_B(s, i);
-    gen_S(s, a);
-    gen_B(s, (uint8_t)b);
+  if (a > 0xff || b > 0xff) {
+    codegen_error(s, "too big operand");
   }
   else {
     gen_B(s, i);
@@ -309,32 +292,6 @@ mrb_decode_insn(const mrb_code *pc)
 #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
 #include "mruby/ops.h"
 #undef OPCODE
-  }
-  switch (insn) {
-  case OP_EXT1:
-    insn = READ_B();
-    switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
-    }
-    break;
-  case OP_EXT2:
-    insn = READ_B();
-    switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
-    }
-    break;
-  case OP_EXT3:
-    insn = READ_B();
-    switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
-    }
-    break;
   default:
     break;
   }
@@ -391,11 +348,8 @@ genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val)
 
   s->lastpc = s->pc;
   if (a > 0xff) {
-    gen_B(s, OP_EXT1);
-    gen_B(s, i);
-    gen_S(s, a);
-    pos = s->pc;
-    gen_S(s, pc);
+    codegen_error(s, "too big operand");
+    pos = 0;
   }
   else {
     gen_B(s, i);
@@ -3314,35 +3268,3 @@ uint8_t mrb_insn_size[] = {
 #undef SB
 #undef BBB
 };
-/* EXT1 instruction sizes */
-uint8_t mrb_insn_size1[] = {
-#define B 3
-#define BB 4
-#define BBB 5
-#define BS 5
-#define SB 5
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-#undef OPCODE
-#undef B
-};
-/* EXT2 instruction sizes */
-uint8_t mrb_insn_size2[] = {
-#define B 2
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-#undef OPCODE
-#undef BB
-#undef BBB
-#undef BS
-#undef SB
-};
-/* EXT3 instruction sizes */
-#define BB 5
-#define BBB 6
-#define BS 4
-#define SB 5
-uint8_t mrb_insn_size3[] = {
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-};

src/codedump.c

@@ -63,7 +63,7 @@ print_header(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t i)
   printf("%03d ", (int)i);
 }
 
-#define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn
+#define CASE(insn,ops) case insn: FETCH_ ## ops ();
 
 static void
 codedump(mrb_state *mrb, const mrb_irep *irep)
@@ -107,14 +107,14 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
     print_header(mrb, irep, i);
     ins = READ_B();
     switch (ins) {
-    CASE(OP_NOP, Z):
+    CASE(OP_NOP, Z);
       printf("OP_NOP\n");
       break;
-    CASE(OP_MOVE, BB):
+    CASE(OP_MOVE, BB);
       printf("OP_MOVE\tR%d\tR%d\t", a, b);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_LOADL, BB):
+    CASE(OP_LOADL, BB);
       switch (irep->pool[b].tt) {
       case IREP_TT_FLOAT:
         printf("OP_LOADL\tR%d\tL(%d)\t; %f", a, b, (double)irep->pool[b].u.f);
@@ -133,144 +133,144 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
       }
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI, BB):
+    CASE(OP_LOADI, BB);
       printf("OP_LOADI\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADINEG, BB):
+    CASE(OP_LOADINEG, BB);
       printf("OP_LOADI\tR%d\t-%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI16, BS):
+    CASE(OP_LOADI16, BS);
       printf("OP_LOADI16\tR%d\t%d\t", a, (int)(int16_t)b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI__1, B):
+    CASE(OP_LOADI__1, B);
       printf("OP_LOADI__1\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI_0, B): goto L_LOADI;
-    CASE(OP_LOADI_1, B): goto L_LOADI;
-    CASE(OP_LOADI_2, B): goto L_LOADI;
-    CASE(OP_LOADI_3, B): goto L_LOADI;
-    CASE(OP_LOADI_4, B): goto L_LOADI;
-    CASE(OP_LOADI_5, B): goto L_LOADI;
-    CASE(OP_LOADI_6, B): goto L_LOADI;
-    CASE(OP_LOADI_7, B):
+    CASE(OP_LOADI_0, B); goto L_LOADI;
+    CASE(OP_LOADI_1, B); goto L_LOADI;
+    CASE(OP_LOADI_2, B); goto L_LOADI;
+    CASE(OP_LOADI_3, B); goto L_LOADI;
+    CASE(OP_LOADI_4, B); goto L_LOADI;
+    CASE(OP_LOADI_5, B); goto L_LOADI;
+    CASE(OP_LOADI_6, B); goto L_LOADI;
+    CASE(OP_LOADI_7, B);
     L_LOADI:
       printf("OP_LOADI_%d\tR%d\t\t", ins-(int)OP_LOADI_0, a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADSYM, BB):
+    CASE(OP_LOADSYM, BB);
       printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADNIL, B):
+    CASE(OP_LOADNIL, B);
       printf("OP_LOADNIL\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADSELF, B):
+    CASE(OP_LOADSELF, B);
       printf("OP_LOADSELF\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADT, B):
+    CASE(OP_LOADT, B);
       printf("OP_LOADT\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADF, B):
+    CASE(OP_LOADF, B);
       printf("OP_LOADF\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETGV, BB):
+    CASE(OP_GETGV, BB);
       printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETGV, BB):
-      printf("OP_SETGV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
+    CASE(OP_SETGV, BB);
+      printf("OP_SETGV\t;%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETSV, BB):
+    CASE(OP_GETSV, BB);
       printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETSV, BB):
+    CASE(OP_SETSV, BB);
       printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETCONST, BB):
+    CASE(OP_GETCONST, BB);
       printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETCONST, BB):
+    CASE(OP_SETCONST, BB);
       printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETMCNST, BB):
+    CASE(OP_GETMCNST, BB);
       printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETMCNST, BB):
+    CASE(OP_SETMCNST, BB);
       printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETIV, BB):
+    CASE(OP_GETIV, BB);
       printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETIV, BB):
+    CASE(OP_SETIV, BB);
       printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETUPVAR, BBB):
+    CASE(OP_GETUPVAR, BBB);
       printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETUPVAR, BBB):
+    CASE(OP_SETUPVAR, BBB);
       printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETCV, BB):
+    CASE(OP_GETCV, BB);
       printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETCV, BB):
+    CASE(OP_SETCV, BB);
       printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_JMP, S):
+    CASE(OP_JMP, S);
       printf("OP_JMP\t\t%03d\n", a);
       break;
-    CASE(OP_JMPIF, BS):
+    CASE(OP_JMPIF, BS);
       printf("OP_JMPIF\tR%d\t%03d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_JMPNOT, BS):
+    CASE(OP_JMPNOT, BS);
       printf("OP_JMPNOT\tR%d\t%03d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_JMPNIL, BS):
+    CASE(OP_JMPNIL, BS);
       printf("OP_JMPNIL\tR%d\t%03d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SENDV, BB):
+    CASE(OP_SENDV, BB);
       printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_SENDVB, BB):
+    CASE(OP_SENDVB, BB);
       printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_SEND, BBB):
+    CASE(OP_SEND, BBB);
       printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
       break;
-    CASE(OP_SENDB, BBB):
+    CASE(OP_SENDB, BBB);
       printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
       break;
-    CASE(OP_CALL, Z):
+    CASE(OP_CALL, Z);
       printf("OP_CALL\n");
       break;
-    CASE(OP_SUPER, BB):
+    CASE(OP_SUPER, BB);
       printf("OP_SUPER\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_ARGARY, BS):
+    CASE(OP_ARGARY, BS);
       printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a,
              (b>>11)&0x3f,
              (b>>10)&0x1,
@@ -279,7 +279,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
              (b>>0)&0xf);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ENTER, W):
+    CASE(OP_ENTER, W);
       printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
              MRB_ASPEC_REQ(a),
              MRB_ASPEC_OPT(a),
@@ -289,30 +289,30 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
              MRB_ASPEC_KDICT(a),
              MRB_ASPEC_BLOCK(a));
       break;
-    CASE(OP_KEY_P, BB):
+    CASE(OP_KEY_P, BB);
       printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_KEYEND, Z):
+    CASE(OP_KEYEND, Z);
       printf("OP_KEYEND\n");
       break;
-    CASE(OP_KARG, BB):
+    CASE(OP_KARG, BB);
       printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_RETURN, B):
+    CASE(OP_RETURN, B);
       printf("OP_RETURN\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_RETURN_BLK, B):
+    CASE(OP_RETURN_BLK, B);
       printf("OP_RETURN_BLK\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_BREAK, B):
+    CASE(OP_BREAK, B);
       printf("OP_BREAK\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_BLKPUSH, BS):
+    CASE(OP_BLKPUSH, BS);
       printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a,
              (b>>11)&0x3f,
              (b>>10)&0x1,
@@ -321,100 +321,100 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
              (b>>0)&0xf);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LAMBDA, BB):
+    CASE(OP_LAMBDA, BB);
       printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
       break;
-    CASE(OP_BLOCK, BB):
+    CASE(OP_BLOCK, BB);
       printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
       break;
-    CASE(OP_METHOD, BB):
+    CASE(OP_METHOD, BB);
       printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
       break;
-    CASE(OP_RANGE_INC, B):
+    CASE(OP_RANGE_INC, B);
       printf("OP_RANGE_INC\tR%d\n", a);
       break;
-    CASE(OP_RANGE_EXC, B):
+    CASE(OP_RANGE_EXC, B);
       printf("OP_RANGE_EXC\tR%d\n", a);
       break;
-    CASE(OP_DEF, BB):
+    CASE(OP_DEF, BB);
       printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_UNDEF, B):
+    CASE(OP_UNDEF, B);
       printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a]));
       break;
-    CASE(OP_ALIAS, BB):
+    CASE(OP_ALIAS, BB);
       printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_dump(mrb, irep->syms[a]), mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_ADD, B):
+    CASE(OP_ADD, B);
       printf("OP_ADD\tR%d\t\n", a);
       break;
-    CASE(OP_ADDI, BB):
+    CASE(OP_ADDI, BB);
       printf("OP_ADDI\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_SUB, B):
+    CASE(OP_SUB, B);
       printf("OP_SUB\tR%d\t\n", a);
       break;
-    CASE(OP_SUBI, BB):
+    CASE(OP_SUBI, BB);
       printf("OP_SUBI\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_MUL, B):
+    CASE(OP_MUL, B);
       printf("OP_MUL\tR%d\t\n", a);
       break;
-    CASE(OP_DIV, B):
+    CASE(OP_DIV, B);
       printf("OP_DIV\tR%d\t\n", a);
       break;
-    CASE(OP_LT, B):
+    CASE(OP_LT, B);
       printf("OP_LT\t\tR%d\t\n", a);
       break;
-    CASE(OP_LE, B):
+    CASE(OP_LE, B);
       printf("OP_LE\t\tR%d\t\n", a);
       break;
-    CASE(OP_GT, B):
+    CASE(OP_GT, B);
       printf("OP_GT\t\tR%d\t\n", a);
       break;
-    CASE(OP_GE, B):
+    CASE(OP_GE, B);
       printf("OP_GE\t\tR%d\t\n", a);
       break;
-    CASE(OP_EQ, B):
+    CASE(OP_EQ, B);
       printf("OP_EQ\t\tR%d\t\n", a);
       break;
-    CASE(OP_ARRAY, BB):
+    CASE(OP_ARRAY, BB);
       printf("OP_ARRAY\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ARRAY2, BBB):
+    CASE(OP_ARRAY2, BBB);
       printf("OP_ARRAY\tR%d\tR%d\t%d\t", a, b, c);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_ARYCAT, B):
+    CASE(OP_ARYCAT, B);
       printf("OP_ARYCAT\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ARYPUSH, B):
+    CASE(OP_ARYPUSH, B);
       printf("OP_ARYPUSH\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ARYDUP, B):
+    CASE(OP_ARYDUP, B);
       printf("OP_ARYDUP\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_AREF, BBB):
+    CASE(OP_AREF, BBB);
       printf("OP_AREF\tR%d\tR%d\t%d", a, b, c);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_ASET, BBB):
+    CASE(OP_ASET, BBB);
       printf("OP_ASET\tR%d\tR%d\t%d", a, b, c);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_APOST, BBB):
+    CASE(OP_APOST, BBB);
       printf("OP_APOST\tR%d\t%d\t%d", a, b, c);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_INTERN, B):
+    CASE(OP_INTERN, B);
       printf("OP_INTERN\tR%d", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_STRING, BB):
+    CASE(OP_STRING, BB);
       if ((irep->pool[b].tt & IREP_TT_NFLAG) == 0) {
         printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str);
       }
@@ -423,48 +423,48 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
       }
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_STRCAT, B):
+    CASE(OP_STRCAT, B);
       printf("OP_STRCAT\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_HASH, BB):
+    CASE(OP_HASH, BB);
       printf("OP_HASH\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_HASHADD, BB):
+    CASE(OP_HASHADD, BB);
       printf("OP_HASHADD\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_HASHCAT, B):
+    CASE(OP_HASHCAT, B);
       printf("OP_HASHCAT\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
 
-    CASE(OP_OCLASS, B):
+    CASE(OP_OCLASS, B);
       printf("OP_OCLASS\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_CLASS, BB):
+    CASE(OP_CLASS, BB);
       printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_MODULE, BB):
+    CASE(OP_MODULE, BB);
       printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_EXEC, BB):
+    CASE(OP_EXEC, BB);
       printf("OP_EXEC\tR%d\tI(%d:%p)", a, b, irep->reps[b]);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SCLASS, B):
+    CASE(OP_SCLASS, B);
       printf("OP_SCLASS\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_TCLASS, B):
+    CASE(OP_TCLASS, B);
       printf("OP_TCLASS\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ERR, B):
+    CASE(OP_ERR, B);
       if ((irep->pool[a].tt & IREP_TT_NFLAG) == 0) {
         printf("OP_ERR\t%s\n", irep->pool[a].u.str);
       }
@@ -472,70 +472,39 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
         printf("OP_ERR\tL(%d)\n", a);
       }
       break;
-    CASE(OP_EPUSH, B):
+    CASE(OP_EPUSH, B);
       printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]);
       break;
-    CASE(OP_ONERR, S):
+    CASE(OP_ONERR, S);
       printf("OP_ONERR\t%03d\n", a);
       break;
-    CASE(OP_EXCEPT, B):
+    CASE(OP_EXCEPT, B);
       printf("OP_EXCEPT\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_RESCUE, BB):
+    CASE(OP_RESCUE, BB);
       printf("OP_RESCUE\tR%d\tR%d", a, b);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_RAISE, B):
+    CASE(OP_RAISE, B);
       printf("OP_RAISE\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_POPERR, B):
+    CASE(OP_POPERR, B);
       printf("OP_POPERR\t%d\t\t\n", a);
       break;
-    CASE(OP_EPOP, B):
+    CASE(OP_EPOP, B);
       printf("OP_EPOP\t%d\n", a);
       break;
 
-    CASE(OP_DEBUG, BBB):
+    CASE(OP_DEBUG, BBB);
       printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c);
       break;
 
-    CASE(OP_STOP, Z):
+    CASE(OP_STOP, Z);
       printf("OP_STOP\n");
       break;
 
-    CASE(OP_EXT1, Z):
-      ins = READ_B();
-      printf("OP_EXT1\n");
-      print_header(mrb, irep, pc-irep->iseq-2);
-      switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      break;
-    CASE(OP_EXT2, Z):
-      ins = READ_B();
-      printf("OP_EXT2\n");
-      print_header(mrb, irep, pc-irep->iseq-2);
-      switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      break;
-    CASE(OP_EXT3, Z):
-      ins = READ_B();
-      printf("OP_EXT3\n");
-      print_header(mrb, irep, pc-irep->iseq-2);
-      switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      break;
-
     default:
       printf("OP_unknown (0x%x)\n", ins);
       break;

src/vm.c

@@ -901,7 +901,7 @@ argnum_error(mrb_state *mrb, mrb_int num)
 #ifndef DIRECT_THREADED
 
 #define INIT_DISPATCH for (;;) { insn = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (insn) {
-#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops ();; L_ ## insn ## _BODY:
+#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops ();
 #define NEXT break
 #define JUMP NEXT
 #define END_DISPATCH }}
@@ -909,7 +909,7 @@ argnum_error(mrb_state *mrb, mrb_int num)
 #else
 
 #define INIT_DISPATCH JUMP; return mrb_nil_value();
-#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); L_ ## insn ## _BODY:
+#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops ();
 #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
 #define JUMP NEXT
 
@@ -1512,7 +1512,7 @@ RETRY_TRY_BLOCK:
           mrb->c->stack[0] = mrb_nil_value();
           a = 0;
           c = OP_R_NORMAL;
-          goto L_OP_RETURN_BODY;
+          goto L_RETURN;
         }
         pool = irep->pool;
         syms = irep->syms;
@@ -2733,37 +2733,6 @@ RETRY_TRY_BLOCK:
       goto L_RAISE;
     }
 
-    CASE(OP_EXT1, Z) {
-      insn = READ_B();
-      switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      pc--;
-      NEXT;
-    }
-    CASE(OP_EXT2, Z) {
-      insn = READ_B();
-      switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      pc--;
-      NEXT;
-    }
-    CASE(OP_EXT3, Z) {
-      uint8_t insn = READ_B();
-      switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      pc--;
-      NEXT;
-    }
-
     CASE(OP_STOP, Z) {
       /*        stop VM */
     L_STOP: