Merge pull request #4151 from take-cheeze/remove_op_symidx

Reduce instruction size

3 files changed, 101 insertions, 57 deletions

diff --git a/src/codedump.c b/src/codedump.c
index 30a14f937..7d1950f75 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -328,38 +328,38 @@ codedump(mrb_state *mrb, mrb_irep *irep)
     CASE(OP_ALIAS, BB):
       printf("OP_ALIAS\t:%s\t%s\n", mrb_sym2name(mrb, irep->syms[a]), mrb_sym2name(mrb, irep->syms[b]));
       break;
-    CASE(OP_ADD, BB):
-      printf("OP_ADD\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_ADD, B):
+      printf("OP_ADD\tR%d\t\n", a);
       break;
-    CASE(OP_ADDI, BBB):
-      printf("OP_ADDI\tR%d\t:%s\t%d\n", a, mrb_sym2name(mrb, irep->syms[b]), c);
+    CASE(OP_ADDI, BB):
+      printf("OP_ADDI\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_SUB, BB):
-      printf("OP_SUB\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_SUB, B):
+      printf("OP_SUB\tR%d\t\n", a);
       break;
-    CASE(OP_SUBI, BBB):
-      printf("OP_SUBI\tR%d\t:%s\t%d\n", a, mrb_sym2name(mrb, irep->syms[b]), c);
+    CASE(OP_SUBI, BB):
+      printf("OP_SUBI\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_MUL, BB):
-      printf("OP_MUL\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_MUL, B):
+      printf("OP_MUL\tR%d\t\n", a);
       break;
-    CASE(OP_DIV, BB):
-      printf("OP_DIV\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_DIV, B):
+      printf("OP_DIV\tR%d\t\n", a);
       break;
-    CASE(OP_LT, BB):
-      printf("OP_LT\t\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_LT, B):
+      printf("OP_LT\t\tR%d\t\n", a);
       break;
-    CASE(OP_LE, BB):
-      printf("OP_LE\t\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_LE, B):
+      printf("OP_LE\t\tR%d\t\n", a);
       break;
-    CASE(OP_GT, BB):
-      printf("OP_GT\t\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_GT, B):
+      printf("OP_GT\t\tR%d\t\n", a);
       break;
-    CASE(OP_GE, BB):
-      printf("OP_GE\t\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_GE, B):
+      printf("OP_GE\t\tR%d\t\n", a);
       break;
-    CASE(OP_EQ, BB):
-      printf("OP_EQ\t\tR%d\t:%s\t\n", a, mrb_sym2name(mrb, irep->syms[b]));
+    CASE(OP_EQ, B):
+      printf("OP_EQ\t\tR%d\t\n", a);
       break;
     CASE(OP_ARRAY, BB):
       printf("OP_ARRAY\tR%d\t%d\t", a, b);
diff --git a/src/symbol.c b/src/symbol.c
index 6b4c7200c..8ec300e20 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -11,6 +11,7 @@
 #include <mruby/string.h>
 #include <mruby/dump.h>
 #include <mruby/class.h>
+#include <mruby/symbol.h>
 
 /* ------------------------------------------------------ */
 typedef struct symbol_name {
@@ -170,10 +171,35 @@ mrb_free_symtbl(mrb_state *mrb)
   kh_destroy(n2s, mrb, mrb->name2sym);
 }
 
+struct reserved_symbol_t {
+  mrb_reserved_symbol sym;
+  char const *str;
+};
+
+static struct reserved_symbol_t reserved_symbols[] = {
+  { mrb_sym_add, "+" },
+  { mrb_sym_sub, "-" },
+  { mrb_sym_mul, "*" },
+  { mrb_sym_div, "/" },
+  { mrb_sym_eq, "==" },
+  { mrb_sym_lt, "<" },
+  { mrb_sym_le, "<=" },
+  { mrb_sym_gt, ">" },
+  { mrb_sym_ge, ">=" },
+  { mrb_sym_method_missing, "method_missing" },
+  { mrb_sym_null, NULL },
+};
+
 void
 mrb_init_symtbl(mrb_state *mrb)
 {
+  int i;
   mrb->name2sym = kh_init(n2s, mrb);
+
+  for (i = 0; reserved_symbols[i].sym != mrb_sym_null; ++i) {
+    mrb_sym s = mrb_intern_static(mrb, reserved_symbols[i].str, strlen(reserved_symbols[i].str));
+    mrb_assert(s == reserved_symbols[i].sym);
+  }
 }
 
 /**********************************************************************
diff --git a/src/vm.c b/src/vm.c
index 8157f6ca0..627eb9325 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -21,6 +21,7 @@
 #include <mruby/opcode.h>
 #include "value_array.h"
 #include <mruby/throw.h>
+#include <mruby/symbol.h>
 
 #ifdef MRB_DISABLE_STDIO
 #if defined(__cplusplus)
@@ -1009,6 +1010,7 @@ mrb_vm_exec(mrb_state *mrb, struct RProc *proc, mrb_code *pc)
   uint32_t a;
   uint16_t b;
   uint8_t c;
+  mrb_sym mid;
 
 #ifdef DIRECT_THREADED
   static void *optable[] = {
@@ -1386,9 +1388,18 @@ RETRY_TRY_BLOCK:
       SET_NIL_VALUE(regs[bidx]);
       goto L_SENDB;
     };
+    L_SEND_CONSTSYM:
+    {
+      /* push nil after arguments */
+      int bidx = (c == CALL_MAXARGS) ? a+2 : a+c+1;
+      SET_NIL_VALUE(regs[bidx]);
+      goto L_SENDB_CONSTSYM;
+    };
 
     CASE(OP_SENDB, BBB)
     L_SENDB:
+    mid = syms[b];
+    L_SENDB_CONSTSYM:
     {
       int argc = (c == CALL_MAXARGS) ? -1 : c;
       int bidx = (argc < 0) ? a+2 : a+c+1;
@@ -1396,7 +1407,6 @@ RETRY_TRY_BLOCK:
       struct RClass *cls;
       mrb_callinfo *ci = mrb->c->ci;
       mrb_value recv, blk;
-      mrb_sym mid = syms[b];
 
       mrb_assert(bidx < irep->nregs);
 
@@ -2204,7 +2214,7 @@ RETRY_TRY_BLOCK:
   v1(regs[a]) = v1(regs[a]) op v2(regs[a+1]);\
 } while(0)
 
-    CASE(OP_ADD, BB) {
+    CASE(OP_ADD, B) {
       /* need to check if op is overridden */
       switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
       case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
@@ -2259,13 +2269,14 @@ RETRY_TRY_BLOCK:
         break;
       default:
         c = 1;
-        goto L_SEND;
+        mid = mrb_sym_add;
+        goto L_SEND_CONSTSYM;
       }
       mrb_gc_arena_restore(mrb, ai);
       NEXT;
     }
 
-    CASE(OP_SUB, BB) {
+    CASE(OP_SUB, B) {
       /* need to check if op is overridden */
       switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
       case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
@@ -2316,12 +2327,13 @@ RETRY_TRY_BLOCK:
 #endif
       default:
         c = 1;
-        goto L_SEND;
+        mid = mrb_sym_sub;
+        goto L_SEND_CONSTSYM;
       }
       NEXT;
     }
 
-    CASE(OP_MUL, BB) {
+    CASE(OP_MUL, B) {
       /* need to check if op is overridden */
       switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
       case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
@@ -2372,12 +2384,13 @@ RETRY_TRY_BLOCK:
 #endif
       default:
         c = 1;
-        goto L_SEND;
+        mid = mrb_sym_mul;
+        goto L_SEND_CONSTSYM;
       }
       NEXT;
     }
 
-    CASE(OP_DIV, BB) {
+    CASE(OP_DIV, B) {
 #ifndef MRB_WITHOUT_FLOAT
       double x, y, f;
 #endif
@@ -2411,7 +2424,8 @@ RETRY_TRY_BLOCK:
 #endif
       default:
         c = 1;
-        goto L_SEND;
+        mid = mrb_sym_div;
+        goto L_SEND_CONSTSYM;
       }
 
 #ifndef MRB_WITHOUT_FLOAT
@@ -2428,13 +2442,13 @@ RETRY_TRY_BLOCK:
       NEXT;
     }
 
-    CASE(OP_ADDI, BBB) {
+    CASE(OP_ADDI, BB) {
       /* need to check if + is overridden */
       switch (mrb_type(regs[a])) {
       case MRB_TT_FIXNUM:
         {
           mrb_int x = mrb_fixnum(regs[a]);
-          mrb_int y = (mrb_int)c;
+          mrb_int y = (mrb_int)b;
           mrb_int z;
 
           if (mrb_int_add_overflow(x, y, &z)) {
@@ -2451,22 +2465,23 @@ RETRY_TRY_BLOCK:
 #ifdef MRB_WORD_BOXING
         {
           mrb_float x = mrb_float(regs[a]);
-          SET_FLOAT_VALUE(mrb, regs[a], x + c);
+          SET_FLOAT_VALUE(mrb, regs[a], x + b);
         }
 #else
-        mrb_float(regs[a]) += c;
+        mrb_float(regs[a]) += b;
 #endif
         break;
 #endif
       default:
-        SET_INT_VALUE(regs[a+1], c);
+        SET_INT_VALUE(regs[a+1], b);
         c = 1;
-        goto L_SEND;
+        mid = mrb_sym_add;
+        goto L_SEND_CONSTSYM;
       }
       NEXT;
     }
 
-    CASE(OP_SUBI, BBB) {
+    CASE(OP_SUBI, BB) {
       mrb_value *regs_a = regs + a;
 
       /* need to check if + is overridden */
@@ -2474,7 +2489,7 @@ RETRY_TRY_BLOCK:
       case MRB_TT_FIXNUM:
         {
           mrb_int x = mrb_fixnum(regs_a[0]);
-          mrb_int y = (mrb_int)c;
+          mrb_int y = (mrb_int)b;
           mrb_int z;
 
           if (mrb_int_sub_overflow(x, y, &z)) {
@@ -2491,17 +2506,18 @@ RETRY_TRY_BLOCK:
 #ifdef MRB_WORD_BOXING
         {
           mrb_float x = mrb_float(regs[a]);
-          SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x - (mrb_float)c);
+          SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x - (mrb_float)b);
         }
 #else
-        mrb_float(regs_a[0]) -= c;
+        mrb_float(regs_a[0]) -= b;
 #endif
         break;
 #endif
       default:
-        SET_INT_VALUE(regs_a[1], c);
+        SET_INT_VALUE(regs_a[1], b);
         c = 1;
-        goto L_SEND;
+        mid = mrb_sym_sub;
+        goto L_SEND_CONSTSYM;
       }
       NEXT;
     }
@@ -2509,7 +2525,7 @@ RETRY_TRY_BLOCK:
 #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
 
 #ifdef MRB_WITHOUT_FLOAT
-#define OP_CMP(op) do {\
+#define OP_CMP(op, sym) do {\
   int result;\
   /* need to check if - is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
@@ -2518,7 +2534,8 @@ RETRY_TRY_BLOCK:
     break;\
   default:\
     c = 1;\
-    goto L_SEND;\
+    mid = mrb_sym_ ## sym;\
+    goto L_SEND_CONSTSYM;\
   }\
   if (result) {\
     SET_TRUE_VALUE(regs[a]);\
@@ -2528,7 +2545,7 @@ RETRY_TRY_BLOCK:
   }\
 } while(0)
 #else
-#define OP_CMP(op) do {\
+#define OP_CMP(op, sym) do {\
   int result;\
   /* need to check if - is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
@@ -2546,7 +2563,8 @@ RETRY_TRY_BLOCK:
     break;\
   default:\
     c = 1;\
-    goto L_SEND;\
+    mid = mrb_sym_ ## sym;\
+    goto L_SEND_CONSTSYM;\
   }\
   if (result) {\
     SET_TRUE_VALUE(regs[a]);\
@@ -2557,33 +2575,33 @@ RETRY_TRY_BLOCK:
 } while(0)
 #endif
 
-    CASE(OP_EQ, BB) {
+    CASE(OP_EQ, B) {
       if (mrb_obj_eq(mrb, regs[a], regs[a+1])) {
         SET_TRUE_VALUE(regs[a]);
       }
       else {
-        OP_CMP(==);
+        OP_CMP(==, eq);
       }
       NEXT;
     }
 
-    CASE(OP_LT, BB) {
-      OP_CMP(<);
+    CASE(OP_LT, B) {
+      OP_CMP(<, lt);
       NEXT;
     }
 
-    CASE(OP_LE, BB) {
-      OP_CMP(<=);
+    CASE(OP_LE, B) {
+      OP_CMP(<=, le);
       NEXT;
     }
 
-    CASE(OP_GT, BB) {
-      OP_CMP(>);
+    CASE(OP_GT, B) {
+      OP_CMP(>, gt);
       NEXT;
     }
 
-    CASE(OP_GE, BB) {
-      OP_CMP(>=);
+    CASE(OP_GE, B) {
+      OP_CMP(>=, ge);
       NEXT;
     }