script_core 0.2.5 → 0.3.2

data/ext/enterprise_script_service/mruby/mrbgems/mruby-compiler/core/codegen.c

@@ -5,16 +5,17 @@
 */
 
 #include <ctype.h>
-#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include <mruby.h>
 #include <mruby/compile.h>
 #include <mruby/proc.h>
+#include <mruby/dump.h>
 #include <mruby/numeric.h>
 #include <mruby/string.h>
 #include <mruby/debug.h>
+#include <mruby/presym.h>
 #include "node.h"
 #include <mruby/opcode.h>
 #include <mruby/re.h>
@@ -39,8 +40,8 @@ enum looptype {
 
 struct loopinfo {
   enum looptype type;
-  int pc0, pc1, pc2, pc3, acc;
-  int ensure_level;
+  uint32_t pc0, pc1, pc2, pc3;
+  int acc;
   struct loopinfo *prev;
 };
 
@@ -54,14 +55,13 @@ typedef struct scope {
   node *lv;
 
   uint16_t sp;
-  uint16_t pc;
-  uint16_t lastpc;
-  uint16_t lastlabel;
+  uint32_t pc;
+  uint32_t lastpc;
+  uint32_t lastlabel;
   int ainfo:15;
   mrb_bool mscope:1;
 
   struct loopinfo *loop;
-  int ensure_level;
   mrb_sym filename_sym;
   uint16_t lineno;
 
@@ -70,6 +70,10 @@ typedef struct scope {
   uint32_t icapa;
 
   mrb_irep *irep;
+  mrb_pool_value *pool;
+  mrb_sym *syms;
+  mrb_irep **reps;
+  struct mrb_irep_catch_handler *catch_table;
   uint32_t pcapa, scapa, rcapa;
 
   uint16_t nlocals;
@@ -89,6 +93,15 @@ static struct loopinfo *loop_push(codegen_scope *s, enum looptype t);
 static void loop_break(codegen_scope *s, node *tree);
 static void loop_pop(codegen_scope *s, int val);
 
+/*
+ * The search for catch handlers starts at the end of the table in mrb_vm_run().
+ * Therefore, the next handler to be added must meet one of the following conditions.
+ * - Larger start position
+ * - Same start position but smaller end position
+ */
+static int catch_handler_new(codegen_scope *s);
+static void catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target);
+
 static void gen_assignment(codegen_scope *s, node *tree, int sp, int val);
 static void gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val);
 
@@ -101,12 +114,31 @@ codegen_error(codegen_scope *s, const char *message)
   if (!s) return;
   while (s->prev) {
     codegen_scope *tmp = s->prev;
-    mrb_free(s->mrb, s->iseq);
-    mrb_free(s->mrb, s->lines);
+    if (s->irep) {
+      mrb_free(s->mrb, s->iseq);
+      for (int i=0; i<s->irep->plen; i++) {
+        mrb_pool_value *pv = &s->pool[i];
+        if ((pv->tt & 0x3) == IREP_TT_STR) {
+          mrb_free(s->mrb, (void*)pv->u.str);
+        }
+      }
+      mrb_free(s->mrb, s->pool);
+      mrb_free(s->mrb, s->syms);
+      mrb_free(s->mrb, s->catch_table);
+      if (s->reps) {
+        /* copied from mrb_irep_free() in state.c */
+        for (int i=0; i<s->irep->rlen; i++) {
+          if (s->reps[i])
+            mrb_irep_decref(s->mrb, (mrb_irep*)s->reps[i]);
+        }
+        mrb_free(s->mrb, s->reps);
+      }
+      mrb_free(s->mrb, s->lines);
+    }
     mrb_pool_close(s->mpool);
     s = tmp;
   }
-#ifndef MRB_DISABLE_STDIO
+#ifndef MRB_NO_STDIO
   if (s->filename_sym && s->lineno) {
     const char *filename = mrb_sym_name_len(s->mrb, s->filename_sym, NULL);
     fprintf(stderr, "codegen error:%s:%d: %s\n", filename, s->lineno, message);
@@ -145,13 +177,15 @@ new_label(codegen_scope *s)
 static void
 emit_B(codegen_scope *s, uint32_t pc, uint8_t i)
 {
-  if (pc >= MAXARG_S || s->icapa >= MAXARG_S) {
-    codegen_error(s, "too big code block");
-  }
   if (pc >= s->icapa) {
-    s->icapa *= 2;
-    if (s->icapa > MAXARG_S) {
-      s->icapa = MAXARG_S;
+    if (pc == UINT32_MAX) {
+      codegen_error(s, "too big code block");
+    }
+    if (pc >= UINT32_MAX / 2) {
+      pc = UINT32_MAX;
+    }
+    else {
+      s->icapa *= 2;
     }
     s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
     if (s->lines) {
@@ -203,9 +237,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);
@@ -217,24 +249,30 @@ 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);
+  if (a > 0xff || b > 0xff) {
+    codegen_error(s, "too big operand");
   }
-  else if (b > 0xff) {
-    gen_B(s, OP_EXT2);
+  else {
     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);
   }
+}
+
+/* similar to `genop_2` but generate `genop_2S` with `i+1` */
+/* works for OP_LOADL, OP_LOADSYM, OP_STRING */
+static void
+genop_bs(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
+{
+  s->lastpc = s->pc;
+  if (a > 0xff || b > 0xffff) {
+    codegen_error(s, "too big operand");
+  }
+  if (b > 0xff) {
+    gen_B(s, i+1);
+    gen_B(s, (uint8_t)a);
+    gen_S(s, b);
+  }
   else {
     gen_B(s, i);
     gen_B(s, (uint8_t)a);
@@ -256,6 +294,14 @@ genop_2S(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
   gen_S(s, b);
 }
 
+static void
+genop_2SS(codegen_scope *s, mrb_code i, uint16_t a, uint32_t b)
+{
+  genop_1(s, i, a);
+  gen_S(s, b>>16);
+  gen_S(s, b&0xffff);
+}
+
 static void
 genop_W(codegen_scope *s, mrb_code i, uint32_t a)
 {
@@ -281,15 +327,6 @@ no_optimize(codegen_scope *s)
   return FALSE;
 }
 
-static
-mrb_bool
-on_eval(codegen_scope *s)
-{
-  if (s && s->parser && s->parser->on_eval)
-    return TRUE;
-  return FALSE;
-}
-
 struct mrb_insn_data
 mrb_decode_insn(const mrb_code *pc)
 {
@@ -297,39 +334,13 @@ mrb_decode_insn(const mrb_code *pc)
   mrb_code insn = READ_B();
   uint16_t a = 0;
   uint16_t b = 0;
-  uint8_t  c = 0;
+  uint16_t c = 0;
 
   switch (insn) {
 #define FETCH_Z() /* empty */
 #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;
   }
@@ -358,22 +369,44 @@ no_peephole(codegen_scope *s)
   return no_optimize(s) || s->lastlabel == s->pc || s->pc == 0 || s->pc == s->lastpc;
 }
 
-static uint16_t
-genjmp(codegen_scope *s, mrb_code i, uint16_t pc)
+#define JMPLINK_START UINT32_MAX
+
+static void
+gen_jmpdst(codegen_scope *s, uint32_t pc)
 {
-  uint16_t pos;
+
+  if (pc == JMPLINK_START) {
+    gen_S(s, 0);
+  }
+  else {
+    uint32_t pos2 = s->pc+2;
+    int32_t off = pc - pos2;
+
+    if (off > INT16_MAX || INT16_MIN > off) {
+      codegen_error(s, "too big jump offset");
+    }
+    gen_S(s, (uint16_t)off);
+  }
+}
+
+static uint32_t
+genjmp(codegen_scope *s, mrb_code i, uint32_t pc)
+{
+  uint32_t pos;
 
   s->lastpc = s->pc;
   gen_B(s, i);
   pos = s->pc;
-  gen_S(s, pc);
+  gen_jmpdst(s, pc);
   return pos;
 }
 
-static uint16_t
-genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val)
+#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
+
+static uint32_t
+genjmp2(codegen_scope *s, mrb_code i, uint16_t a, uint32_t pc, int val)
 {
-  uint16_t pos;
+  uint32_t pos;
 
   if (!no_peephole(s) && !val) {
     struct mrb_insn_data data = mrb_last_insn(s);
@@ -386,30 +419,26 @@ 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);
     gen_B(s, (uint8_t)a);
     pos = s->pc;
-    gen_S(s, pc);
+    gen_jmpdst(s, pc);
   }
   return pos;
 }
 
+#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
+
 static void
 gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep)
 {
   if (no_peephole(s)) {
   normal:
     genop_2(s, OP_MOVE, dst, src);
-    if (on_eval(s)) {
-      genop_0(s, OP_NOP);
-    }
     return;
   }
   else {
@@ -429,10 +458,13 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep)
       s->pc = s->lastpc;
       genop_1(s, data.insn, dst);
       break;
-    case OP_LOADI: case OP_LOADINEG: case OP_LOADL: case OP_LOADSYM:
+    case OP_LOADI: case OP_LOADINEG:
+    case OP_LOADL: case OP_LOADSYM:
+    case OP_LOADL16: case OP_LOADSYM16:
     case OP_GETGV: case OP_GETSV: case OP_GETIV: case OP_GETCV:
-    case OP_GETCONST: case OP_STRING:
+    case OP_GETCONST: case OP_STRING: case OP_STRING16:
     case OP_LAMBDA: case OP_BLOCK: case OP_METHOD: case OP_BLKPUSH:
+    case OP_LAMBDA16: case OP_BLOCK16: case OP_METHOD16:
       if (nopeep || data.a != src || data.a < s->nlocals) goto normal;
       s->pc = s->lastpc;
       genop_2(s, data.insn, dst, data.b);
@@ -500,21 +532,31 @@ gen_addsub(codegen_scope *s, uint8_t op, uint16_t dst)
   }
 }
 
-static int
-dispatch(codegen_scope *s, uint16_t pos0)
+static uint32_t
+dispatch(codegen_scope *s, uint32_t pos0)
 {
-  uint16_t newpos;
+  int32_t pos1;
+  int32_t offset;
+  int16_t newpos;
 
+  if (pos0 == JMPLINK_START) return 0;
+
+  pos1 = pos0 + 2;
+  offset = s->pc - pos1;
+  if (offset > INT16_MAX) {
+    codegen_error(s, "too big jmp offset");
+  }
   s->lastlabel = s->pc;
-  newpos = PEEK_S(s->iseq+pos0);
-  emit_S(s, pos0, s->pc);
-  return newpos;
+  newpos = (int16_t)PEEK_S(s->iseq+pos0);
+  emit_S(s, pos0, (uint16_t)offset);
+  if (newpos == 0) return 0;
+  return pos1+newpos;
 }
 
 static void
-dispatch_linked(codegen_scope *s, uint16_t pos)
+dispatch_linked(codegen_scope *s, uint32_t pos)
 {
-  if (pos==0) return;
+  if (pos==JMPLINK_START) return;
   for (;;) {
     pos = dispatch(s, pos);
     if (pos==0) break;
@@ -551,37 +593,46 @@ static inline int
 new_lit(codegen_scope *s, mrb_value val)
 {
   int i;
-  mrb_value *pv;
+  mrb_pool_value *pv;
 
   switch (mrb_type(val)) {
   case MRB_TT_STRING:
     for (i=0; i<s->irep->plen; i++) {
       mrb_int len;
-      pv = &s->irep->pool[i];
-
-      if (!mrb_string_p(*pv)) continue;
-      if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue;
-      if (memcmp(RSTRING_PTR(*pv), RSTRING_PTR(val), len) == 0)
+      pv = &s->pool[i];
+      if (pv->tt & IREP_TT_NFLAG) continue;
+      len = pv->tt>>2;
+      if (RSTRING_LEN(val) != len) continue;
+      if (memcmp(pv->u.str, RSTRING_PTR(val), len) == 0)
         return i;
     }
     break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     for (i=0; i<s->irep->plen; i++) {
       mrb_float f1, f2;
-      pv = &s->irep->pool[i];
-      if (!mrb_float_p(*pv)) continue;
-      f1 = mrb_float(*pv);
+      pv = &s->pool[i];
+      if (pv->tt != IREP_TT_FLOAT) continue;
+      pv = &s->pool[i];
+      f1 = pv->u.f;
       f2 = mrb_float(val);
       if (f1 == f2 && !signbit(f1) == !signbit(f2)) return i;
     }
     break;
 #endif
-  case MRB_TT_FIXNUM:
+  case MRB_TT_INTEGER:
     for (i=0; i<s->irep->plen; i++) {
-      pv = &s->irep->pool[i];
-      if (!mrb_fixnum_p(*pv)) continue;
-      if (mrb_fixnum(*pv) == mrb_fixnum(val)) return i;
+      mrb_int v = mrb_integer(val);
+      pv = &s->pool[i];
+      if (pv->tt == IREP_TT_INT32) {
+        if (v == pv->u.i32) return i;
+      }
+#ifdef MRB_64BIT
+      else if (pv->tt == IREP_TT_INT64) {
+        if (v == pv->u.i64) return i;
+      }
+      continue;
+#endif
     }
     break;
   default:
@@ -591,26 +642,43 @@ new_lit(codegen_scope *s, mrb_value val)
 
   if (s->irep->plen == s->pcapa) {
     s->pcapa *= 2;
-    s->irep->pool = (mrb_value *)codegen_realloc(s, s->irep->pool, sizeof(mrb_value)*s->pcapa);
+    s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa);
   }
 
-  pv = &s->irep->pool[s->irep->plen];
+  pv = &s->pool[s->irep->plen];
   i = s->irep->plen++;
 
   switch (mrb_type(val)) {
   case MRB_TT_STRING:
-    *pv = mrb_str_pool(s->mrb, RSTRING_PTR(val), RSTRING_LEN(val), RSTR_NOFREE_P(RSTRING(val)));
+    if (RSTR_NOFREE_P(RSTRING(val))) {
+      pv->tt = (uint32_t)(RSTRING_LEN(val)<<2) | IREP_TT_SSTR;
+      pv->u.str = RSTRING_PTR(val);
+    }
+    else {
+      char *p;
+      mrb_int len = RSTRING_LEN(val);
+      pv->tt = (uint32_t)(len<<2) | IREP_TT_STR;
+      p = (char*)codegen_realloc(s, NULL, len+1);
+      memcpy(p, RSTRING_PTR(val), len);
+      p[len] = '\0';
+      pv->u.str = p;
+    }
     break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
-#ifdef MRB_WORD_BOXING
-    *pv = mrb_float_pool(s->mrb, mrb_float(val));
+    pv->tt = IREP_TT_FLOAT;
+    pv->u.f = mrb_float(val);
     break;
 #endif
+  case MRB_TT_INTEGER:
+#ifdef MRB_INT64
+    pv->tt = IREP_TT_INT64;
+    pv->u.i64 = mrb_integer(val);
+#else
+    pv->tt = IREP_TT_INT32;
+    pv->u.i32 = mrb_integer(val);
 #endif
-  case MRB_TT_FIXNUM:
-    *pv = val;
     break;
 
   default:
@@ -620,9 +688,6 @@ new_lit(codegen_scope *s, mrb_value val)
   return i;
 }
 
-/* maximum symbol numbers */
-#define MAXSYMLEN 0x10000
-
 static int
 new_sym(codegen_scope *s, mrb_sym sym)
 {
@@ -632,13 +697,16 @@ new_sym(codegen_scope *s, mrb_sym sym)
 
   len = s->irep->slen;
   for (i=0; i<len; i++) {
-    if (s->irep->syms[i] == sym) return i;
+    if (s->syms[i] == sym) return i;
   }
   if (s->irep->slen >= s->scapa) {
     s->scapa *= 2;
-    s->irep->syms = (mrb_sym*)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*s->scapa);
+    if (s->scapa > 0xffff) {
+      codegen_error(s, "too many symbols");
+    }
+    s->syms = (mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->scapa);
   }
-  s->irep->syms[s->irep->slen] = sym;
+  s->syms[s->irep->slen] = sym;
   return s->irep->slen++;
 }
 
@@ -674,6 +742,45 @@ lv_idx(codegen_scope *s, mrb_sym id)
   return 0;
 }
 
+static int
+search_upvar(codegen_scope *s, mrb_sym id, int *idx)
+{
+  const struct RProc *u;
+  int lv = 0;
+  codegen_scope *up = s->prev;
+
+  while (up) {
+    *idx = lv_idx(up, id);
+    if (*idx > 0) {
+      return lv;
+    }
+    lv ++;
+    up = up->prev;
+  }
+
+  if (lv < 1) lv = 1;
+  u = s->parser->upper;
+  while (u && !MRB_PROC_CFUNC_P(u)) {
+    const struct mrb_irep *ir = u->body.irep;
+    uint_fast16_t n = ir->nlocals;
+    int i;
+
+    const mrb_sym *v = ir->lv;
+    for (i=1; n > 1; n--, v++, i++) {
+      if (*v == id) {
+        *idx = i;
+        return lv - 1;
+      }
+    }
+    if (MRB_PROC_SCOPE_P(u)) break;
+    u = u->upper;
+    lv ++;
+  }
+
+  codegen_error(s, "Can't found local variables");
+  return -1; /* not reached */
+}
+
 static void
 for_body(codegen_scope *s, node *tree)
 {
@@ -712,7 +819,7 @@ for_body(codegen_scope *s, node *tree)
   genop_2(s, OP_BLOCK, cursp(), s->irep->rlen-1);
   push();pop(); /* space for a block */
   pop();
-  idx = new_sym(s, mrb_intern_lit(s->mrb, "each"));
+  idx = new_sym(s, MRB_SYM_2(s->mrb, each));
   genop_3(s, OP_SENDB, cursp(), idx, 0);
 }
 
@@ -749,7 +856,7 @@ lambda_body(codegen_scope *s, node *tree, int blk)
     oa = node_len(tree->car->cdr->car);
     /* rest argument? */
     ra = tree->car->cdr->cdr->car ? 1 : 0;
-    /* mandatory arugments after rest argument */
+    /* mandatory arguments after rest argument */
     pa = node_len(tree->car->cdr->cdr->cdr->car);
     pargs = tree->car->cdr->cdr->cdr->car;
     /* keyword arguments */
@@ -777,21 +884,28 @@ lambda_body(codegen_scope *s, node *tree, int blk)
     pos = new_label(s);
     for (i=0; i<oa; i++) {
       new_label(s);
-      genjmp(s, OP_JMP, 0);
+      genjmp_0(s, OP_JMP);
     }
     if (oa > 0) {
-      genjmp(s, OP_JMP, 0);
+      genjmp_0(s, OP_JMP);
     }
     opt = tree->car->cdr->car;
     i = 0;
     while (opt) {
       int idx;
+      mrb_sym id = nsym(opt->car->car);
 
       dispatch(s, pos+i*3+1);
       codegen(s, opt->car->cdr, VAL);
       pop();
-      idx = lv_idx(s, nsym(opt->car->car));
-      gen_move(s, idx, cursp(), 0);
+      idx = lv_idx(s, id);
+      if (idx > 0) {
+        gen_move(s, idx, cursp(), 0);
+      }
+      else {
+        int lv = search_upvar(s, id, &idx);
+        genop_3(s, OP_GETUPVAR, cursp(), idx, lv);
+      }
       i++;
       opt = opt->cdr;
     }
@@ -818,12 +932,20 @@ lambda_body(codegen_scope *s, node *tree, int blk)
         mrb_assert(nint(kwd->car) == NODE_KW_ARG);
 
         if (def_arg) {
+          int idx;
           genop_2(s, OP_KEY_P, lv_idx(s, kwd_sym), new_sym(s, kwd_sym));
-          jmpif_key_p = genjmp2(s, OP_JMPIF, lv_idx(s, kwd_sym), 0, 0);
+          jmpif_key_p = genjmp2_0(s, OP_JMPIF, lv_idx(s, kwd_sym), NOVAL);
           codegen(s, def_arg, VAL);
           pop();
-          gen_move(s, lv_idx(s, kwd_sym), cursp(), 0);
-          jmp_def_set = genjmp(s, OP_JMP, 0);
+          idx = lv_idx(s, kwd_sym);
+          if (idx > 0) {
+            gen_move(s, idx, cursp(), 0);
+          }
+          else {
+            int lv = search_upvar(s, kwd_sym, &idx);
+            genop_3(s, OP_GETUPVAR, cursp(), idx, lv);
+          }
+          jmp_def_set = genjmp_0(s, OP_JMP);
           dispatch(s, jmpif_key_p);
         }
         genop_2(s, OP_KARG, lv_idx(s, kwd_sym), new_sym(s, kwd_sym));
@@ -1004,7 +1126,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe)
   if (safe) {
     int recv = cursp()-1;
     gen_move(s, cursp(), recv, 1);
-    skip = genjmp2(s, OP_JMPNIL, cursp(), 0, val);
+    skip = genjmp2_0(s, OP_JMPNIL, cursp(), val);
   }
   tree = tree->cdr->cdr->car;
   if (tree) {
@@ -1103,23 +1225,12 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val)
     if (idx > 0) {
       if (idx != sp) {
         gen_move(s, idx, sp, val);
-        if (val && on_eval(s)) genop_0(s, OP_NOP);
       }
       break;
     }
     else {                      /* upvar */
-      int lv = 0;
-      codegen_scope *up = s->prev;
-
-      while (up) {
-        idx = lv_idx(up, nsym(tree));
-        if (idx > 0) {
-          genop_3(s, OP_SETUPVAR, sp, idx, lv);
-          break;
-        }
-        lv++;
-        up = up->prev;
-      }
+      int lv = search_upvar(s, nsym(tree), &idx);
+      genop_3(s, OP_SETUPVAR, sp, idx, lv);
     }
     break;
   case NODE_NVAR:
@@ -1167,7 +1278,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val)
     break;
 
   default:
-#ifndef MRB_DISABLE_STDIO
+#ifndef MRB_NO_STDIO
     fprintf(stderr, "unknown lhs %d\n", type);
 #endif
     break;
@@ -1296,34 +1407,6 @@ raise_error(codegen_scope *s, const char *msg)
   genop_1(s, OP_ERR, idx);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
-static double
-readint_float(codegen_scope *s, const char *p, int base)
-{
-  const char *e = p + strlen(p);
-  double f = 0;
-  int n;
-
-  if (*p == '+') p++;
-  while (p < e) {
-    char c = *p;
-    c = tolower((unsigned char)c);
-    for (n=0; n<base; n++) {
-      if (mrb_digitmap[n] == c) {
-        f *= base;
-        f += n;
-        break;
-      }
-    }
-    if (n == base) {
-      codegen_error(s, "malformed readint input");
-    }
-    p++;
-  }
-  return f;
-}
-#endif
-
 static mrb_int
 readint_mrb_int(codegen_scope *s, const char *p, int base, mrb_bool neg, mrb_bool *overflow)
 {
@@ -1427,21 +1510,25 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_RESCUE:
     {
-      int noexc, exend, pos1, pos2, tmp;
+      int noexc;
+      uint32_t exend, pos1, pos2, tmp;
       struct loopinfo *lp;
+      int catch_entry, begin, end;
 
       if (tree->car == NULL) goto exit;
       lp = loop_push(s, LOOP_BEGIN);
       lp->pc0 = new_label(s);
-      lp->pc1 = genjmp(s, OP_ONERR, 0);
+      catch_entry = catch_handler_new(s);
+      begin = s->pc;
       codegen(s, tree->car, VAL);
       pop();
       lp->type = LOOP_RESCUE;
-      noexc = genjmp(s, OP_JMP, 0);
-      dispatch(s, lp->pc1);
+      end = s->pc;
+      noexc = genjmp_0(s, OP_JMP);
+      catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
       tree = tree->cdr;
-      exend = 0;
-      pos1 = 0;
+      exend = JMPLINK_START;
+      pos1 = JMPLINK_START;
       if (tree->car) {
         node *n2 = tree->car;
         int exc = cursp();
@@ -1452,22 +1539,22 @@ codegen(codegen_scope *s, node *tree, int val)
           node *n3 = n2->car;
           node *n4 = n3->car;
 
-          if (pos1) dispatch(s, pos1);
-          pos2 = 0;
+          dispatch(s, pos1);
+          pos2 = JMPLINK_START;
           do {
             if (n4 && n4->car && nint(n4->car->car) == NODE_SPLAT) {
               codegen(s, n4->car, VAL);
               gen_move(s, cursp(), exc, 0);
               push_n(2); pop_n(2); /* space for one arg and a block */
               pop();
-              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, __case_eqq)), 1);
             }
             else {
               if (n4) {
                 codegen(s, n4->car, VAL);
               }
               else {
-                genop_2(s, OP_GETCONST, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "StandardError")));
+                genop_2(s, OP_GETCONST, cursp(), new_sym(s, MRB_SYM_2(s->mrb, StandardError)));
                 push();
               }
               pop();
@@ -1479,7 +1566,7 @@ codegen(codegen_scope *s, node *tree, int val)
               n4 = n4->cdr;
             }
           } while (n4);
-          pos1 = genjmp(s, OP_JMP, 0);
+          pos1 = genjmp_0(s, OP_JMP);
           dispatch_linked(s, pos2);
 
           pop();
@@ -1495,15 +1582,14 @@ codegen(codegen_scope *s, node *tree, int val)
           n2 = n2->cdr;
           push();
         }
-        if (pos1) {
+        if (pos1 != JMPLINK_START) {
           dispatch(s, pos1);
-          genop_1(s, OP_RAISE, exc);
+          genop_1(s, OP_RAISEIF, exc);
         }
       }
       pop();
       tree = tree->cdr;
       dispatch(s, noexc);
-      genop_1(s, OP_POPERR, 1);
       if (tree->car) {
         codegen(s, tree->car, val);
       }
@@ -1519,14 +1605,22 @@ codegen(codegen_scope *s, node *tree, int val)
     if (!tree->cdr || !tree->cdr->cdr ||
         (nint(tree->cdr->cdr->car) == NODE_BEGIN &&
          tree->cdr->cdr->cdr)) {
+      int catch_entry, begin, end, target;
       int idx;
 
-      s->ensure_level++;
-      idx = scope_body(s, tree->cdr, NOVAL);
-      genop_1(s, OP_EPUSH, idx);
+      catch_entry = catch_handler_new(s);
+      begin = s->pc;
       codegen(s, tree->car, val);
-      s->ensure_level--;
-      genop_1(s, OP_EPOP, 1);
+      end = target = s->pc;
+      push();
+      idx = cursp();
+      genop_1(s, OP_EXCEPT, idx);
+      push();
+      codegen(s, tree->cdr->cdr, NOVAL);
+      pop();
+      genop_1(s, OP_RAISEIF, idx);
+      pop();
+      catch_handler_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target);
     }
     else {                      /* empty ensure ignored */
       codegen(s, tree->car, val);
@@ -1537,7 +1631,7 @@ codegen(codegen_scope *s, node *tree, int val)
     if (val) {
       int idx = lambda_body(s, tree, 1);
 
-      genop_2(s, OP_LAMBDA, cursp(), idx);
+      genop_bs(s, OP_LAMBDA, cursp(), idx);
       push();
     }
     break;
@@ -1546,7 +1640,7 @@ codegen(codegen_scope *s, node *tree, int val)
     if (val) {
       int idx = lambda_body(s, tree, 1);
 
-      genop_2(s, OP_BLOCK, cursp(), idx);
+      genop_bs(s, OP_BLOCK, cursp(), idx);
       push();
     }
     break;
@@ -1574,7 +1668,7 @@ codegen(codegen_scope *s, node *tree, int val)
         {
           node *n = tree->car->cdr;
           mrb_sym mid = nsym(n->cdr->car);
-          mrb_sym mnil = mrb_intern_lit(s->mrb, "nil?");
+          mrb_sym mnil = MRB_SYM_Q_2(s->mrb, nil);
           if (mid == mnil && n->cdr->cdr->car == NULL) {
             nil_p = TRUE;
             codegen(s, n->car, VAL);
@@ -1588,17 +1682,17 @@ codegen(codegen_scope *s, node *tree, int val)
       pop();
       if (val || tree->cdr->car) {
         if (nil_p) {
-          pos2 = genjmp2(s, OP_JMPNIL, cursp(), 0, val);
-          pos1 = genjmp(s, OP_JMP, 0);
+          pos2 = genjmp2_0(s, OP_JMPNIL, cursp(), val);
+          pos1 = genjmp_0(s, OP_JMP);
           dispatch(s, pos2);
         }
         else {
-          pos1 = genjmp2(s, OP_JMPNOT, cursp(), 0, val);
+          pos1 = genjmp2_0(s, OP_JMPNOT, cursp(), val);
         }
         codegen(s, tree->cdr->car, val);
         if (val) pop();
         if (elsepart || val) {
-          pos2 = genjmp(s, OP_JMP, 0);
+          pos2 = genjmp_0(s, OP_JMP);
           dispatch(s, pos1);
           codegen(s, elsepart, val);
           dispatch(s, pos2);
@@ -1610,10 +1704,10 @@ codegen(codegen_scope *s, node *tree, int val)
       else {                    /* empty then-part */
         if (elsepart) {
           if (nil_p) {
-            pos1 = genjmp2(s, OP_JMPNIL, cursp(), 0, val);
+            pos1 = genjmp2_0(s, OP_JMPNIL, cursp(), val);
           }
           else {
-            pos1 = genjmp2(s, OP_JMPIF, cursp(), 0, val);
+            pos1 = genjmp2_0(s, OP_JMPIF, cursp(), val);
           }
           codegen(s, elsepart, val);
           dispatch(s, pos1);
@@ -1632,7 +1726,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
       codegen(s, tree->car, VAL);
       pop();
-      pos = genjmp2(s, OP_JMPNOT, cursp(), 0, val);
+      pos = genjmp2_0(s, OP_JMPNOT, cursp(), val);
       codegen(s, tree->cdr, val);
       dispatch(s, pos);
     }
@@ -1644,7 +1738,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
       codegen(s, tree->car, VAL);
       pop();
-      pos = genjmp2(s, OP_JMPIF, cursp(), 0, val);
+      pos = genjmp2_0(s, OP_JMPIF, cursp(), val);
       codegen(s, tree->cdr, val);
       dispatch(s, pos);
     }
@@ -1655,7 +1749,7 @@ codegen(codegen_scope *s, node *tree, int val)
       struct loopinfo *lp = loop_push(s, LOOP_NORMAL);
 
       lp->pc0 = new_label(s);
-      lp->pc1 = genjmp(s, OP_JMP, 0);
+      lp->pc1 = genjmp_0(s, OP_JMP);
       lp->pc2 = new_label(s);
       codegen(s, tree->cdr, NOVAL);
       dispatch(s, lp->pc1);
@@ -1672,7 +1766,7 @@ codegen(codegen_scope *s, node *tree, int val)
       struct loopinfo *lp = loop_push(s, LOOP_NORMAL);
 
       lp->pc0 = new_label(s);
-      lp->pc1 = genjmp(s, OP_JMP, 0);
+      lp->pc1 = genjmp_0(s, OP_JMP);
       lp->pc2 = new_label(s);
       codegen(s, tree->cdr, NOVAL);
       dispatch(s, lp->pc1);
@@ -1692,10 +1786,10 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_CASE:
     {
       int head = 0;
-      int pos1, pos2, pos3, tmp;
+      uint32_t pos1, pos2, pos3, tmp;
       node *n;
 
-      pos3 = 0;
+      pos3 = JMPLINK_START;
       if (tree->car) {
         head = cursp();
         codegen(s, tree->car, VAL);
@@ -1703,17 +1797,17 @@ codegen(codegen_scope *s, node *tree, int val)
       tree = tree->cdr;
       while (tree) {
         n = tree->car->car;
-        pos1 = pos2 = 0;
+        pos1 = pos2 = JMPLINK_START;
         while (n) {
           codegen(s, n->car, VAL);
           if (head) {
             gen_move(s, cursp(), head, 0);
             push(); push(); pop(); pop(); pop();
             if (nint(n->car->car) == NODE_SPLAT) {
-              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, __case_eqq)), 1);
             }
             else {
-              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "===")), 1);
+              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_OPSYM_2(s->mrb, eqq)), 1);
             }
           }
           else {
@@ -1724,20 +1818,20 @@ codegen(codegen_scope *s, node *tree, int val)
           n = n->cdr;
         }
         if (tree->car->car) {
-          pos1 = genjmp(s, OP_JMP, 0);
+          pos1 = genjmp_0(s, OP_JMP);
           dispatch_linked(s, pos2);
         }
         codegen(s, tree->car->cdr, val);
         if (val) pop();
         tmp = genjmp(s, OP_JMP, pos3);
         pos3 = tmp;
-        if (pos1) dispatch(s, pos1);
+        dispatch(s, pos1);
         tree = tree->cdr;
       }
       if (val) {
-        int pos = cursp();
+        uint32_t pos = cursp();
         genop_1(s, OP_LOADNIL, cursp());
-        if (pos3) dispatch_linked(s, pos3);
+        if (pos3 != JMPLINK_START) dispatch_linked(s, pos3);
         if (head) pop();
         if (cursp() != pos) {
           gen_move(s, cursp(), pos, 0);
@@ -1745,7 +1839,7 @@ codegen(codegen_scope *s, node *tree, int val)
         push();
       }
       else {
-        if (pos3) {
+        if (pos3 != JMPLINK_START) {
           dispatch_linked(s, pos3);
         }
         if (head) {
@@ -1860,7 +1954,7 @@ codegen(codegen_scope *s, node *tree, int val)
           len++;
         }
         tree = tree->cdr;
-        if (val && len == 255) {
+        if (val && cursp() > 127) {
           pop_n(len*2);
           if (!update) {
             genop_2(s, OP_HASH, cursp(), len);
@@ -1988,18 +2082,20 @@ codegen(codegen_scope *s, node *tree, int val)
       if ((len == 2 && name[0] == '|' && name[1] == '|') &&
           (nint(tree->car->car) == NODE_CONST ||
            nint(tree->car->car) == NODE_CVAR)) {
-        int onerr, noexc, exc;
+        int catch_entry, begin, end;
+        int noexc, exc;
         struct loopinfo *lp;
 
-        onerr = genjmp(s, OP_ONERR, 0);
         lp = loop_push(s, LOOP_BEGIN);
-        lp->pc1 = onerr;
+        lp->pc0 = new_label(s);
+        catch_entry = catch_handler_new(s);
+        begin = s->pc;
         exc = cursp();
         codegen(s, tree->car, VAL);
+        end = s->pc;
+        noexc = genjmp_0(s, OP_JMP);
         lp->type = LOOP_RESCUE;
-        genop_1(s, OP_POPERR, 1);
-        noexc = genjmp(s, OP_JMP, 0);
-        dispatch(s, onerr);
+        catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
         genop_1(s, OP_EXCEPT, exc);
         genop_1(s, OP_LOADF, exc);
         dispatch(s, noexc);
@@ -2050,10 +2146,10 @@ codegen(codegen_scope *s, node *tree, int val)
           if (vsp >= 0) {
             gen_move(s, vsp, cursp(), 1);
           }
-          pos = genjmp2(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), 0, val);
+          pos = genjmp2_0(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), val);
         }
         else {
-          pos = genjmp2(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), 0, val);
+          pos = genjmp2_0(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), val);
         }
         codegen(s, tree->cdr->cdr->car, VAL);
         pop();
@@ -2237,7 +2333,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop_n(n+1);
       genop_2S(s, OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf));
       if (sendv) n = CALL_MAXARGS;
-      genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "call")), n);
+      genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, call)), n);
       if (val) push();
     }
     break;
@@ -2252,11 +2348,8 @@ codegen(codegen_scope *s, node *tree, int val)
       raise_error(s, "unexpected next");
     }
     else if (s->loop->type == LOOP_NORMAL) {
-      if (s->ensure_level > s->loop->ensure_level) {
-        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
-      }
       codegen(s, tree, NOVAL);
-      genjmp(s, OP_JMP, s->loop->pc0);
+      genjmp(s, OP_JMPUW, s->loop->pc0);
     }
     else {
       if (tree) {
@@ -2276,10 +2369,7 @@ codegen(codegen_scope *s, node *tree, int val)
       raise_error(s, "unexpected redo");
     }
     else {
-      if (s->ensure_level > s->loop->ensure_level) {
-        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
-      }
-      genjmp(s, OP_JMP, s->loop->pc2);
+      genjmp(s, OP_JMPUW, s->loop->pc2);
     }
     if (val) push();
     break;
@@ -2287,32 +2377,16 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_RETRY:
     {
       const char *msg = "unexpected retry";
+      const struct loopinfo *lp = s->loop;
 
-      if (!s->loop) {
+      while (lp && lp->type != LOOP_RESCUE) {
+        lp = lp->prev;
+      }
+      if (!lp) {
         raise_error(s, msg);
       }
       else {
-        struct loopinfo *lp = s->loop;
-        int n = 0;
-
-        while (lp && lp->type != LOOP_RESCUE) {
-          if (lp->type == LOOP_BEGIN) {
-            n++;
-          }
-          lp = lp->prev;
-        }
-        if (!lp) {
-          raise_error(s, msg);
-        }
-        else {
-          if (n > 0) {
-            genop_1(s, OP_POPERR, n);
-          }
-          if (s->ensure_level > lp->ensure_level) {
-            genop_1(s, OP_EPOP, s->ensure_level - lp->ensure_level);
-          }
-          genjmp(s, OP_JMP, lp->pc0);
-        }
+        genjmp(s, OP_JMPUW, lp->pc0);
       }
       if (val) push();
     }
@@ -2324,21 +2398,10 @@ codegen(codegen_scope *s, node *tree, int val)
 
       if (idx > 0) {
         gen_move(s, cursp(), idx, val);
-        if (val && on_eval(s)) genop_0(s, OP_NOP);
       }
       else {
-        int lv = 0;
-        codegen_scope *up = s->prev;
-
-        while (up) {
-          idx = lv_idx(up, nsym(tree));
-          if (idx > 0) {
-            genop_3(s, OP_GETUPVAR, cursp(), idx, lv);
-            break;
-          }
-          lv++;
-          up = up->prev;
-        }
+        int lv = search_upvar(s, nsym(tree), &idx);
+        genop_3(s, OP_GETUPVAR, cursp(), idx, lv);
       }
       push();
     }
@@ -2349,7 +2412,6 @@ codegen(codegen_scope *s, node *tree, int val)
       int idx = nint(tree);
 
       gen_move(s, cursp(), idx, val);
-      if (val && on_eval(s)) genop_0(s, OP_NOP);
 
       push();
     }
@@ -2430,37 +2492,41 @@ codegen(codegen_scope *s, node *tree, int val)
       mrb_bool overflow;
 
       i = readint_mrb_int(s, p, base, FALSE, &overflow);
-#ifndef MRB_WITHOUT_FLOAT
       if (overflow) {
-        double f = readint_float(s, p, base);
-        int off = new_lit(s, mrb_float_value(s->mrb, f));
-
-        genop_2(s, OP_LOADL, cursp(), off);
+        codegen_error(s, "integer overflow");
       }
-      else
-#endif
-      {
-        if (i == -1) genop_1(s, OP_LOADI__1, cursp());
-        else if (i < 0) genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i);
+      else {
+        if (i < 0) {
+          if (i == -1) genop_1(s, OP_LOADI__1, cursp());
+          else if (i >= -0xff) genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i);
+          else if (i >= INT16_MIN) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i);
+          else if (i >= INT32_MIN) genop_2SS(s, OP_LOADI32, cursp(), (uint32_t)i);
+          else goto lit_int;
+        }
         else if (i < 8) genop_1(s, OP_LOADI_0 + (uint8_t)i, cursp());
-        else if (i <= 0xffff) genop_2(s, OP_LOADI, cursp(), (uint16_t)i);
+        else if (i <= 0xff) genop_2(s, OP_LOADI, cursp(), (uint16_t)i);
+        else if (i <= INT16_MAX) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i);
+        else if (i <= INT32_MAX) genop_2SS(s, OP_LOADI32, cursp(), (uint32_t)i);
         else {
-          int off = new_lit(s, mrb_fixnum_value(i));
-          genop_2(s, OP_LOADL, cursp(), off);
+          int off;
+
+        lit_int:
+          off = new_lit(s, mrb_int_value(s->mrb, i));
+          genop_bs(s, OP_LOADL, cursp(), off);
         }
       }
       push();
     }
     break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case NODE_FLOAT:
     if (val) {
       char *p = (char*)tree;
       mrb_float f = mrb_float_read(p, NULL);
       int off = new_lit(s, mrb_float_value(s->mrb, f));
 
-      genop_2(s, OP_LOADL, cursp(), off);
+      genop_bs(s, OP_LOADL, cursp(), off);
       push();
     }
     break;
@@ -2470,14 +2536,14 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       nt = nint(tree->car);
       switch (nt) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       case NODE_FLOAT:
         if (val) {
           char *p = (char*)tree->cdr;
           mrb_float f = mrb_float_read(p, NULL);
           int off = new_lit(s, mrb_float_value(s->mrb, -f));
 
-          genop_2(s, OP_LOADL, cursp(), off);
+          genop_bs(s, OP_LOADL, cursp(), off);
           push();
         }
         break;
@@ -2491,33 +2557,32 @@ codegen(codegen_scope *s, node *tree, int val)
           mrb_bool overflow;
 
           i = readint_mrb_int(s, p, base, TRUE, &overflow);
-#ifndef MRB_WITHOUT_FLOAT
           if (overflow) {
-            double f = readint_float(s, p, base);
-            int off = new_lit(s, mrb_float_value(s->mrb, -f));
-
-            genop_2(s, OP_LOADL, cursp(), off);
+            codegen_error(s, "integer overflow");
           }
           else {
-#endif
             if (i == -1) genop_1(s, OP_LOADI__1, cursp());
-            else if (i >= -0xffff) {
+            else if (i >= -0xff) {
               genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i);
             }
+            else if (i >= INT16_MIN) {
+              genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i);
+            }
+            else if (i >= INT32_MIN) {
+              genop_2SS(s, OP_LOADI32, cursp(), (uint32_t)i);
+            }
             else {
-              int off = new_lit(s, mrb_fixnum_value(i));
-              genop_2(s, OP_LOADL, cursp(), off);
+              int off = new_lit(s, mrb_int_value(s->mrb, i));
+              genop_bs(s, OP_LOADL, cursp(), off);
             }
-#ifndef MRB_WITHOUT_FLOAT
           }
-#endif
           push();
         }
         break;
 
       default:
         if (val) {
-          int sym = new_sym(s, mrb_intern_lit(s->mrb, "-@"));
+          int sym = new_sym(s, MRB_OPSYM_2(s->mrb, minus));
           codegen(s, tree, VAL);
           pop();
           genop_3(s, OP_SEND, cursp(), sym, 0);
@@ -2539,7 +2604,7 @@ codegen(codegen_scope *s, node *tree, int val)
       int off = new_lit(s, mrb_str_new(s->mrb, p, len));
 
       mrb_gc_arena_restore(s->mrb, ai);
-      genop_2(s, OP_STRING, cursp(), off);
+      genop_bs(s, OP_STRING, cursp(), off);
       push();
     }
     break;
@@ -2590,7 +2655,7 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       node *n;
       int ai = mrb_gc_arena_save(s->mrb);
-      int sym = new_sym(s, mrb_intern_lit(s->mrb, "Kernel"));
+      int sym = new_sym(s, MRB_SYM_2(s->mrb, Kernel));
 
       genop_1(s, OP_LOADSELF, cursp());
       push();
@@ -2609,7 +2674,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       push();                   /* for block */
       pop_n(3);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
+      sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */
       genop_3(s, OP_SEND, cursp(), sym, 1);
       if (val) push();
       mrb_gc_arena_restore(s->mrb, ai);
@@ -2626,10 +2691,10 @@ codegen(codegen_scope *s, node *tree, int val)
 
       genop_1(s, OP_LOADSELF, cursp());
       push();
-      genop_2(s, OP_STRING, cursp(), off);
+      genop_bs(s, OP_STRING, cursp(), off);
       push(); push();
       pop_n(3);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
+      sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */
       genop_3(s, OP_SEND, cursp(), sym, 1);
       if (val) push();
       mrb_gc_arena_restore(s->mrb, ai);
@@ -2649,12 +2714,12 @@ codegen(codegen_scope *s, node *tree, int val)
       genop_1(s, OP_OCLASS, cursp());
       genop_2(s, OP_GETMCNST, cursp(), sym);
       push();
-      genop_2(s, OP_STRING, cursp(), off);
+      genop_bs(s, OP_STRING, cursp(), off);
       push();
       if (p2 || p3) {
         if (p2) { /* opt */
           off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
-          genop_2(s, OP_STRING, cursp(), off);
+          genop_bs(s, OP_STRING, cursp(), off);
         }
         else {
           genop_1(s, OP_LOADNIL, cursp());
@@ -2663,14 +2728,14 @@ codegen(codegen_scope *s, node *tree, int val)
         argc++;
         if (p3) { /* enc */
           off = new_lit(s, mrb_str_new(s->mrb, p3, 1));
-          genop_2(s, OP_STRING, cursp(), off);
+          genop_bs(s, OP_STRING, cursp(), off);
           push();
           argc++;
         }
       }
       push(); /* space for a block */
       pop_n(argc+2);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
+      sym = new_sym(s, MRB_SYM_2(s->mrb, compile));
       genop_3(s, OP_SEND, cursp(), sym, argc);
       mrb_gc_arena_restore(s->mrb, ai);
       push();
@@ -2703,7 +2768,7 @@ codegen(codegen_scope *s, node *tree, int val)
         p = (char*)n->car;
         off = new_lit(s, mrb_str_new_cstr(s->mrb, p));
         codegen(s, tree->car, VAL);
-        genop_2(s, OP_STRING, cursp(), off);
+        genop_bs(s, OP_STRING, cursp(), off);
         pop();
         genop_1(s, OP_STRCAT, cursp());
         push();
@@ -2711,20 +2776,20 @@ codegen(codegen_scope *s, node *tree, int val)
       if (n->cdr->car) { /* opt */
         char *p2 = (char*)n->cdr->car;
         off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
-        genop_2(s, OP_STRING, cursp(), off);
+        genop_bs(s, OP_STRING, cursp(), off);
         push();
         argc++;
       }
       if (n->cdr->cdr) { /* enc */
         char *p2 = (char*)n->cdr->cdr;
         off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
-        genop_2(s, OP_STRING, cursp(), off);
+        genop_bs(s, OP_STRING, cursp(), off);
         push();
         argc++;
       }
       push(); /* space for a block */
       pop_n(argc+2);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
+      sym = new_sym(s, MRB_SYM_2(s->mrb, compile));
       genop_3(s, OP_SEND, cursp(), sym, argc);
       mrb_gc_arena_restore(s->mrb, ai);
       push();
@@ -2745,7 +2810,7 @@ codegen(codegen_scope *s, node *tree, int val)
     if (val) {
       int sym = new_sym(s, nsym(tree));
 
-      genop_2(s, OP_LOADSYM, cursp(), sym);
+      genop_bs(s, OP_LOADSYM, cursp(), sym);
       push();
     }
     break;
@@ -2846,7 +2911,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       else {
         idx = scope_body(s, body, val);
-        genop_2(s, OP_EXEC, cursp(), idx);
+        genop_bs(s, OP_EXEC, cursp(), idx);
       }
       if (val) {
         push();
@@ -2878,7 +2943,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       else {
         idx = scope_body(s, tree->cdr->car, val);
-        genop_2(s, OP_EXEC, cursp(), idx);
+        genop_bs(s, OP_EXEC, cursp(), idx);
       }
       if (val) {
         push();
@@ -2899,7 +2964,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       else {
         idx = scope_body(s, tree->cdr->car, val);
-        genop_2(s, OP_EXEC, cursp(), idx);
+        genop_bs(s, OP_EXEC, cursp(), idx);
       }
       if (val) {
         push();
@@ -2914,12 +2979,12 @@ codegen(codegen_scope *s, node *tree, int val)
 
       genop_1(s, OP_TCLASS, cursp());
       push();
-      genop_2(s, OP_METHOD, cursp(), idx);
+      genop_bs(s, OP_METHOD, cursp(), idx);
       push(); pop();
       pop();
       genop_2(s, OP_DEF, cursp(), sym);
       if (val) {
-        genop_2(s, OP_LOADSYM, cursp(), sym);
+        genop_bs(s, OP_LOADSYM, cursp(), sym);
         push();
       }
     }
@@ -2935,11 +3000,11 @@ codegen(codegen_scope *s, node *tree, int val)
       pop();
       genop_1(s, OP_SCLASS, cursp());
       push();
-      genop_2(s, OP_METHOD, cursp(), idx);
+      genop_bs(s, OP_METHOD, cursp(), idx);
       pop();
       genop_2(s, OP_DEF, cursp(), sym);
       if (val) {
-        genop_2(s, OP_LOADSYM, cursp(), sym);
+        genop_bs(s, OP_LOADSYM, cursp(), sym);
         push();
       }
     }
@@ -2957,99 +3022,100 @@ codegen(codegen_scope *s, node *tree, int val)
 }
 
 static void
-scope_add_irep(codegen_scope *s, mrb_irep *irep)
+scope_add_irep(codegen_scope *s)
 {
-  if (s->irep == NULL) {
-    s->irep = irep;
+  mrb_irep *irep;
+  codegen_scope *prev = s->prev;
+
+  if (prev->irep == NULL) {
+    irep = mrb_add_irep(s->mrb);
+    prev->irep = s->irep = irep;
     return;
   }
-  if (s->irep->rlen == s->rcapa) {
-    s->rcapa *= 2;
-    s->irep->reps = (mrb_irep**)codegen_realloc(s, s->irep->reps, sizeof(mrb_irep*)*s->rcapa);
+  else {
+    if (prev->irep->rlen == UINT16_MAX) {
+      codegen_error(s, "too many nested blocks/methods");
+    }
+    s->irep = irep = mrb_add_irep(s->mrb);
+    if (prev->irep->rlen == prev->rcapa) {
+      prev->rcapa *= 2;
+      prev->reps = (mrb_irep**)codegen_realloc(s, prev->reps, sizeof(mrb_irep*)*prev->rcapa);
+    }
+    prev->reps[prev->irep->rlen] = irep;
+    prev->irep->rlen++;
   }
-  s->irep->reps[s->irep->rlen] = irep;
-  s->irep->rlen++;
 }
 
 static codegen_scope*
-scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
+scope_new(mrb_state *mrb, codegen_scope *prev, node *nlv)
 {
   static const codegen_scope codegen_scope_zero = { 0 };
   mrb_pool *pool = mrb_pool_open(mrb);
-  codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
+  codegen_scope *s = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
 
-  if (!p) {
+  if (!s) {
     if (prev)
       codegen_error(prev, "unexpected scope");
     return NULL;
   }
-  *p = codegen_scope_zero;
-  p->mrb = mrb;
-  p->mpool = pool;
-  if (!prev) return p;
-  p->prev = prev;
-  p->ainfo = -1;
-  p->mscope = 0;
-
-  p->irep = mrb_add_irep(mrb);
-  scope_add_irep(prev, p->irep);
-
-  p->rcapa = 8;
-  p->irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*p->rcapa);
-
-  p->icapa = 1024;
-  p->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa);
-  p->irep->iseq = NULL;
-
-  p->pcapa = 32;
-  p->irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa);
-  p->irep->plen = 0;
-
-  p->scapa = 256;
-  p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*p->scapa);
-  p->irep->slen = 0;
-
-  p->lv = lv;
-  p->sp += node_len(lv)+1;        /* add self */
-  p->nlocals = p->sp;
-  if (lv) {
-    node *n = lv;
+  *s = codegen_scope_zero;
+  s->mrb = mrb;
+  s->mpool = pool;
+  if (!prev) return s;
+  s->prev = prev;
+  s->ainfo = -1;
+  s->mscope = 0;
+
+  scope_add_irep(s);
+
+  s->rcapa = 8;
+  s->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*s->rcapa);
+
+  s->icapa = 1024;
+  s->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*s->icapa);
+
+  s->pcapa = 32;
+  s->pool = (mrb_pool_value*)mrb_malloc(mrb, sizeof(mrb_pool_value)*s->pcapa);
+
+  s->scapa = 256;
+  s->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*s->scapa);
+
+  s->lv = nlv;
+  s->sp += node_len(nlv)+1;        /* add self */
+  s->nlocals = s->sp;
+  if (nlv) {
+    mrb_sym *lv;
+    node *n = nlv;
     size_t i = 0;
 
-    p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (p->nlocals - 1));
-    for (i=0, n=lv; n; i++,n=n->cdr) {
-      p->irep->lv[i].name = lv_name(n);
-      if (lv_name(n)) {
-        p->irep->lv[i].r = lv_idx(p, lv_name(n));
-      }
-      else {
-        p->irep->lv[i].r = 0;
-      }
+    s->irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*(s->nlocals-1));
+    for (i=0, n=nlv; n; i++,n=n->cdr) {
+      lv[i] = lv_name(n);
     }
-    mrb_assert(i + 1 == p->nlocals);
+    mrb_assert(i + 1 == s->nlocals);
   }
-  p->ai = mrb_gc_arena_save(mrb);
+  s->ai = mrb_gc_arena_save(mrb);
 
-  p->filename_sym = prev->filename_sym;
-  if (p->filename_sym) {
-    p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa);
+  s->filename_sym = prev->filename_sym;
+  if (s->filename_sym) {
+    s->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*s->icapa);
   }
-  p->lineno = prev->lineno;
+  s->lineno = prev->lineno;
 
   /* debug setting */
-  p->debug_start_pos = 0;
-  if (p->filename_sym) {
-    mrb_debug_info_alloc(mrb, p->irep);
+  s->debug_start_pos = 0;
+  if (s->filename_sym) {
+    mrb_debug_info_alloc(mrb, s->irep);
   }
   else {
-    p->irep->debug_info = NULL;
+    s->irep->debug_info = NULL;
   }
-  p->parser = prev->parser;
-  p->filename_index = prev->filename_index;
+  s->parser = prev->parser;
+  s->filename_index = prev->filename_index;
 
-  p->rlev = prev->rlev+1;
+  s->rlev = prev->rlev+1;
 
-  return p;
+  return s;
 }
 
 static void
@@ -3058,17 +3124,26 @@ scope_finish(codegen_scope *s)
   mrb_state *mrb = s->mrb;
   mrb_irep *irep = s->irep;
 
-  if (s->nlocals >= 0x3ff) {
+  if (s->nlocals > 0xff) {
     codegen_error(s, "too many local variables");
   }
   irep->flags = 0;
   if (s->iseq) {
-    irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc);
+    size_t catchsize = sizeof(struct mrb_irep_catch_handler) * irep->clen;
+    irep->iseq = (const mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc + catchsize);
     irep->ilen = s->pc;
+    if (irep->clen > 0) {
+      memcpy((void *)(irep->iseq + irep->ilen), s->catch_table, catchsize);
+    }
+  }
+  else {
+    irep->clen = 0;
   }
-  irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen);
-  irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen);
-  irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen);
+  mrb_free(s->mrb, s->catch_table);
+  s->catch_table = NULL;
+  irep->pool = (const mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*irep->plen);
+  irep->syms = (const mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*irep->slen);
+  irep->reps = (const mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*irep->rlen);
   if (s->filename_sym) {
     mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
     const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
@@ -3091,9 +3166,8 @@ loop_push(codegen_scope *s, enum looptype t)
   struct loopinfo *p = (struct loopinfo *)codegen_palloc(s, sizeof(struct loopinfo));
 
   p->type = t;
-  p->pc0 = p->pc1 = p->pc2 = p->pc3 = 0;
+  p->pc0 = p->pc1 = p->pc2 = p->pc3 = JMPLINK_START;
   p->prev = s->loop;
-  p->ensure_level = s->ensure_level;
   p->acc = cursp();
   s->loop = p;
 
@@ -3109,7 +3183,6 @@ loop_break(codegen_scope *s, node *tree)
   }
   else {
     struct loopinfo *loop;
-    int n = 0;
 
     if (tree) {
       gen_retval(s, tree);
@@ -3118,7 +3191,6 @@ loop_break(codegen_scope *s, node *tree)
     loop = s->loop;
     while (loop) {
       if (loop->type == LOOP_BEGIN) {
-        n++;
         loop = loop->prev;
       }
       else if (loop->type == LOOP_RESCUE) {
@@ -3132,20 +3204,14 @@ loop_break(codegen_scope *s, node *tree)
       raise_error(s, "unexpected break");
       return;
     }
-    if (n > 0) {
-      genop_1(s, OP_POPERR, n);
-    }
 
     if (loop->type == LOOP_NORMAL) {
       int tmp;
 
-      if (s->ensure_level > s->loop->ensure_level) {
-        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
-      }
       if (tree) {
         gen_move(s, loop->acc, cursp(), 0);
       }
-      tmp = genjmp(s, OP_JMP, loop->pc3);
+      tmp = genjmp(s, OP_JMPUW, loop->pc3);
       loop->pc3 = tmp;
     }
     else {
@@ -3168,6 +3234,28 @@ loop_pop(codegen_scope *s, int val)
   if (val) push();
 }
 
+static int
+catch_handler_new(codegen_scope *s)
+{
+  size_t newsize = sizeof(struct mrb_irep_catch_handler) * (s->irep->clen + 1);
+  s->catch_table = (struct mrb_irep_catch_handler *)codegen_realloc(s, (void *)s->catch_table, newsize);
+  return s->irep->clen ++;
+}
+
+static void
+catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target)
+{
+  struct mrb_irep_catch_handler *e;
+
+  mrb_assert(ent >= 0 && ent < s->irep->clen);
+
+  e = &s->catch_table[ent];
+  uint8_to_bin(type, &e->type);
+  mrb_irep_catch_handler_pack(begin, e->begin);
+  mrb_irep_catch_handler_pack(end, e->end);
+  mrb_irep_catch_handler_pack(target, e->target);
+}
+
 static struct RProc*
 generate_code(mrb_state *mrb, parser_state *p, int val)
 {
@@ -3214,13 +3302,14 @@ mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
 {
   int i;
 
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   if (irep->lv) {
-    mrb_free(mrb, irep->lv);
+    mrb_free(mrb, (void*)irep->lv);
     irep->lv = NULL;
   }
-
+  if (!irep->reps) return;
   for (i = 0; i < irep->rlen; ++i) {
-    mrb_irep_remove_lv(mrb, irep->reps[i]);
+    mrb_irep_remove_lv(mrb, (mrb_irep*)irep->reps[i]);
   }
 }
 
@@ -3234,6 +3323,7 @@ uint8_t mrb_insn_size[] = {
 #define BB 3
 #define BBB 4
 #define BS 4
+#define BSS 6
 #define SB 4
 #define OPCODE(_,x) x,
 #include "mruby/ops.h"
@@ -3241,38 +3331,7 @@ uint8_t mrb_insn_size[] = {
 #undef B
 #undef BB
 #undef BS
+#undef BSS
 #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"
-};