Merge master.

11 files changed, 162 insertions, 152 deletions

diff --git a/src/array.c b/src/array.c
index dae2fbf34..ef8588d31 100644
--- a/src/array.c
+++ b/src/array.c
@@ -522,8 +522,10 @@ mrb_ary_push_m(mrb_state *mrb, mrb_value self)
   }
   array_copy(ARY_PTR(a)+len, argv, alen);
   ARY_SET_LEN(a, len2);
-  mrb_write_barrier(mrb, (struct RBasic*)a);
-
+  while (alen--) {
+    mrb_field_write_barrier_value(mrb, (struct RBasic*)a, *argv);
+    argv++;
+  }
   return self;
 }
 
@@ -941,7 +943,7 @@ mrb_ary_aset(mrb_state *mrb, mrb_value self)
   mrb_value v1, v2, v3;
   mrb_int i, len;
 
-  mrb_ary_modify(mrb, mrb_ary_ptr(self));
+  ary_modify(mrb, mrb_ary_ptr(self));
   if (mrb_get_argc(mrb) == 2) {
     mrb_value *vs = mrb_get_argv(mrb);
     v1 = vs[0]; v2 = vs[1];
diff --git a/src/class.c b/src/class.c
index 1a36c1333..fc8a38ff9 100644
--- a/src/class.c
+++ b/src/class.c
@@ -587,6 +587,7 @@ void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
     s:      String         [char*,mrb_int]        Receive two arguments; s! gives (NULL,0) for nil
     z:      String         [char*]                NUL terminated string; z! gives NULL for nil
     a:      Array          [mrb_value*,mrb_int]   Receive two arguments; a! gives (NULL,0) for nil
+    c:      Class/Module   [strcut RClass*]
     f:      Fixnum/Float   [mrb_float]
     i:      Fixnum/Float   [mrb_int]
     b:      boolean        [mrb_bool]
@@ -713,6 +714,22 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         }
       }
       break;
+    case 'c':
+      {
+        struct RClass **p;
+
+        p = va_arg(ap, struct RClass**);
+        if (i < argc) {
+          mrb_value ss;
+
+          ss = argv[i++];
+          if (!class_ptr_p(ss)) {
+            mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", ss);
+          }
+          *p = mrb_class_ptr(ss);
+        }
+      }
+      break;
     case 'S':
       {
         mrb_value *p;
@@ -1151,22 +1168,22 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
 static mrb_value
 mrb_mod_prepend_features(mrb_state *mrb, mrb_value mod)
 {
-  mrb_value klass;
+  struct RClass *c;
 
   mrb_check_type(mrb, mod, MRB_TT_MODULE);
-  mrb_get_args(mrb, "C", &klass);
-  mrb_prepend_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
+  mrb_get_args(mrb, "c", &c);
+  mrb_prepend_module(mrb, c, mrb_class_ptr(mod));
   return mod;
 }
 
 static mrb_value
 mrb_mod_append_features(mrb_state *mrb, mrb_value mod)
 {
-  mrb_value klass;
+  struct RClass *c;
 
   mrb_check_type(mrb, mod, MRB_TT_MODULE);
-  mrb_get_args(mrb, "C", &klass);
-  mrb_include_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
+  mrb_get_args(mrb, "c", &c);
+  mrb_include_module(mrb, c, mrb_class_ptr(mod));
   return mod;
 }
 
diff --git a/src/etc.c b/src/etc.c
index 785f49357..74b9ab03b 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -107,10 +107,11 @@ mrb_obj_id(mrb_value obj)
     return MakeID(0); /* not define */
   case MRB_TT_FALSE:
     if (mrb_nil_p(obj))
-      return MakeID(1);
-    return MakeID(0);
+      return MakeID(4);
+    else
+      return MakeID(0);
   case MRB_TT_TRUE:
-    return MakeID(1);
+    return MakeID(2);
   case MRB_TT_SYMBOL:
     return MakeID(mrb_symbol(obj));
   case MRB_TT_FIXNUM:
diff --git a/src/gc.c b/src/gc.c
index 03c561d35..be812c4d3 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -225,14 +225,8 @@ mrb_realloc(mrb_state *mrb, void *p, size_t len)
   p2 = mrb_realloc_simple(mrb, p, len);
   if (len == 0) return p2;
   if (p2 == NULL) {
-    if (mrb->gc.out_of_memory) {
-      mrb_raise_nomemory(mrb);
-      /* mrb_panic(mrb); */
-    }
-    else {
-      mrb->gc.out_of_memory = TRUE;
-      mrb_raise_nomemory(mrb);
-    }
+    mrb->gc.out_of_memory = TRUE;
+    mrb_raise_nomemory(mrb);
   }
   else {
     mrb->gc.out_of_memory = FALSE;
@@ -673,7 +667,6 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
 {
   mrb_assert(is_gray(obj));
   paint_black(obj);
-  gc->gray_list = obj->gcnext;
   mrb_gc_mark(mrb, (struct RBasic*)obj->c);
   switch (obj->tt) {
   case MRB_TT_ICLASS:
@@ -737,10 +730,11 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
   case MRB_TT_ARRAY:
     {
       struct RArray *a = (struct RArray*)obj;
-      size_t i, e;
+      size_t i, e=ARY_LEN(a);
+      mrb_value *p = ARY_PTR(a);
 
-      for (i=0,e=ARY_LEN(a); i<e; i++) {
-        mrb_gc_mark_value(mrb, ARY_PTR(a)[i]);
+      for (i=0; i<e; i++) {
+        mrb_gc_mark_value(mrb, p[i]);
       }
     }
     break;
@@ -1049,10 +1043,9 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
 static void
 gc_mark_gray_list(mrb_state *mrb, mrb_gc *gc) {
   while (gc->gray_list) {
-    if (is_gray(gc->gray_list))
-      gc_mark_children(mrb, gc, gc->gray_list);
-    else
-      gc->gray_list = gc->gray_list->gcnext;
+    struct RBasic *obj = gc->gray_list;
+    gc->gray_list = obj->gcnext;
+    gc_mark_children(mrb, gc, obj);
   }
 }
 
@@ -1064,6 +1057,7 @@ incremental_marking_phase(mrb_state *mrb, mrb_gc *gc, size_t limit)
 
   while (gc->gray_list && tried_marks < limit) {
     struct RBasic *obj = gc->gray_list;
+    gc->gray_list = obj->gcnext;
     gc_mark_children(mrb, gc, obj);
     tried_marks += gc_gray_counts(mrb, gc, obj);
   }
@@ -1082,7 +1076,9 @@ final_marking_phase(mrb_state *mrb, mrb_gc *gc)
   }
   mrb_gc_mark_gv(mrb);
   mark_context(mrb, mrb->c);
-  mark_context(mrb, mrb->root_c);
+  if (mrb->c != mrb->root_c) {
+    mark_context(mrb, mrb->root_c);
+  }
   mrb_gc_mark(mrb, (struct RBasic*)mrb->exc);
   gc_mark_gray_list(mrb, gc);
   mrb_assert(gc->gray_list == NULL);
@@ -1605,6 +1601,13 @@ mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, vo
   }
 }
 
+mrb_int
+mrb_objspace_page_slot_size(void)
+{
+  const mrb_int i = sizeof(RVALUE);
+  return i;
+}
+
 #ifdef GC_TEST
 #ifdef GC_DEBUG
 static mrb_value gc_test(mrb_state *, mrb_value);
diff --git a/src/hash.c b/src/hash.c
index d9ee483d5..fd338d53b 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -174,6 +174,11 @@ ht_index(mrb_state *mrb, htable *t)
   segment *seg;
   size_t i;
 
+  if (size == 0) {
+    t->index = NULL;
+    mrb_free(mrb, index);
+    return;
+  }
   /* allocate index table */
   if (index && index->size >= UPPER_BOUND(index->capa)) {
     size = index->capa+1;
@@ -194,7 +199,7 @@ ht_index(mrb_state *mrb, htable *t)
     index->table[i] = NULL;
   }
 
-  /* rebuld index */
+  /* rebuild index */
   mask = HT_MASK(index);
   seg = t->rootseg;
   while (seg) {
@@ -518,6 +523,20 @@ ht_foreach(mrb_state *mrb, htable *t, mrb_hash_foreach_func *func, void *p)
   }
 }
 
+mrb_int
+mrb_os_memsize_of_hash_table(mrb_value obj)
+{
+  struct htable *h = mrb_hash_ptr(obj)->ht;
+  mrb_int segkv_size = 0;
+
+  if(h->index) segkv_size = (sizeof(struct segkv) * h->index->capa);
+
+  return sizeof(htable) +
+    sizeof(segindex) +
+    (sizeof(segment) * h->size) +
+    segkv_size;
+}
+
 /* Iterates over the hash table. */
 MRB_API void
 mrb_hash_foreach(mrb_state *mrb, struct RHash *hash, mrb_hash_foreach_func *func, void *p)
@@ -1053,7 +1072,8 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash)
 
   mrb_hash_modify(mrb, hash);
   if (t && t->size > 0) {
-    mrb_value del_key, del_val;
+    mrb_value del_key = mrb_nil_value();
+    mrb_value del_val = mrb_nil_value();
 
     ht_shift(mrb, t, &del_key, &del_val);
     mrb_gc_protect(mrb, del_key);
diff --git a/src/kernel.c b/src/kernel.c
index 8f0c9c7b5..682feb13c 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -99,6 +99,18 @@ mrb_obj_id_m(mrb_state *mrb, mrb_value self)
   return mrb_fixnum_value(mrb_obj_id(self));
 }
 
+static int
+env_bidx(struct REnv *e)
+{
+  int bidx;
+
+  /* use saved block arg position */
+  bidx = MRB_ENV_BIDX(e);
+  /* bidx may be useless (e.g. define_method) */
+  if (bidx >= MRB_ENV_LEN(e)) return -1;
+  return bidx;
+}
+
 /* 15.3.1.2.2  */
 /* 15.3.1.2.5  */
 /* 15.3.1.3.6  */
@@ -129,6 +141,8 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
   mrb_callinfo *ci = &mrb->c->ci[-1];
   mrb_callinfo *cibase = mrb->c->cibase;
   mrb_value *bp;
+  int bidx;
+  struct REnv *e = NULL;
   struct RProc *p;
 
   if (ci <= cibase) {
@@ -139,29 +153,36 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
   /* search method/class/module proc */
   while (p) {
     if (MRB_PROC_SCOPE_P(p)) break;
+    e = MRB_PROC_ENV(p);
     p = p->upper;
   }
   if (p == NULL) return mrb_false_value();
+  if (e) {
+    bidx = env_bidx(e);
+    if (bidx < 0) return mrb_false_value();
+    bp = &e->stack[bidx];
+    goto block_given;
+  }
   /* search ci corresponding to proc */
   while (cibase < ci) {
     if (ci->proc == p) break;
     ci--;
   }
   if (ci == cibase) {
-    return mrb_false_value();
+    /* proc is closure */
+    if (!MRB_PROC_ENV_P(p)) return mrb_false_value();
+    e = MRB_PROC_ENV(p);
+    bidx = env_bidx(e);
+    if (bidx < 0) return mrb_false_value();
+    bp = &e->stack[bidx];
   }
   else if (ci->env) {
-    struct REnv *e = ci->env;
-    int bidx;
-
+    e = ci->env;
     /* top-level does not have block slot (always false) */
-    if (e->stack == mrb->c->stbase)
-      return mrb_false_value();
-    /* use saved block arg position */
-    bidx = MRB_ENV_BIDX(e);
+    if (e->stack == mrb->c->stbase) return mrb_false_value();
+    bidx = env_bidx(e);
     /* bidx may be useless (e.g. define_method) */
-    if (bidx >= MRB_ENV_LEN(e))
-      return mrb_false_value();
+    if (bidx < 0) return mrb_false_value();
     bp = &e->stack[bidx];
   }
   else {
@@ -173,6 +194,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
       bp++;
     }
   }
+ block_given:
   if (mrb_nil_p(*bp))
     return mrb_false_value();
   return mrb_true_value();
@@ -498,11 +520,11 @@ mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c)
 static mrb_value
 obj_is_instance_of(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg;
+  struct RClass *c;
 
-  mrb_get_args(mrb, "C", &arg);
+  mrb_get_args(mrb, "c", &c);
 
-  return mrb_bool_value(mrb_obj_is_instance_of(mrb, self, mrb_class_ptr(arg)));
+  return mrb_bool_value(mrb_obj_is_instance_of(mrb, self, c));
 }
 
 /* 15.3.1.3.24 */
@@ -535,11 +557,11 @@ obj_is_instance_of(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg;
+  struct RClass *c;
 
-  mrb_get_args(mrb, "C", &arg);
+  mrb_get_args(mrb, "c", &c);
 
-  return mrb_bool_value(mrb_obj_is_kind_of(mrb, self, mrb_class_ptr(arg)));
+  return mrb_bool_value(mrb_obj_is_kind_of(mrb, self, c));
 }
 
 KHASH_DECLARE(st, mrb_sym, char, FALSE)
diff --git a/src/object.c b/src/object.c
index db9dfb568..7257f402d 100644
--- a/src/object.c
+++ b/src/object.c
@@ -338,6 +338,7 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char
   if (mrb_type(val) == type) return val;
   v = convert_type(mrb, val, tname, method, TRUE);
   if (mrb_type(v) != type) {
+    if (type == MRB_TT_STRING) return mrb_any_to_s(mrb, val);
     mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%s", val, tname, method);
   }
   return v;
diff --git a/src/state.c b/src/state.c
index 533bdaa0b..790f7ca13 100644
--- a/src/state.c
+++ b/src/state.c
@@ -164,8 +164,6 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
   mrb_free(mrb, irep);
 }
 
-void mrb_free_backtrace(mrb_state *mrb);
-
 MRB_API void
 mrb_free_context(mrb_state *mrb, struct mrb_context *c)
 {
diff --git a/src/string.c b/src/string.c
index f1ffbe43d..78c41c5f3 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1121,6 +1121,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str)
     return mrb_sym_str(mrb, mrb_symbol(str));
   case MRB_TT_FIXNUM:
     return mrb_fixnum_to_str(mrb, str, 10);
+  case MRB_TT_SCLASS:
   case MRB_TT_CLASS:
   case MRB_TT_MODULE:
     return mrb_mod_to_s(mrb, str);
diff --git a/src/variable.c b/src/variable.c
index 030aa7b00..f05fcee90 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -349,7 +349,7 @@ mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value
     obj->iv = iv_new(mrb);
   }
   iv_put(mrb, obj->iv, sym, v);
-  mrb_write_barrier(mrb, (struct RBasic*)obj);
+  mrb_field_write_barrier_value(mrb, (struct RBasic*)obj, v);
 }
 
 MRB_API void
@@ -679,7 +679,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
     if (iv_get(mrb, t, sym, NULL)) {
       mrb_check_frozen(mrb, c);
       iv_put(mrb, t, sym, v);
-      mrb_write_barrier(mrb, (struct RBasic*)c);
+      mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
       return;
     }
     c = c->super;
@@ -711,7 +711,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   }
 
   iv_put(mrb, c->iv, sym, v);
-  mrb_write_barrier(mrb, (struct RBasic*)c);
+  mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
 }
 
 MRB_API void
@@ -1128,6 +1128,21 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
   return path;
 }
 
+mrb_int
+mrb_obj_iv_tbl_memsize(mrb_state* mrb, mrb_value obj)
+{
+  size_t nseg = 0;
+  segment *seg;
+
+  if (mrb_obj_ptr(obj)->iv == NULL) return 0;
+  seg = mrb_obj_ptr(obj)->iv->rootseg;
+  while (seg) {
+    nseg++;
+    seg = seg->next;
+  }
+  return sizeof(iv_tbl) + sizeof(segment)*nseg;
+}
+
 #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
 
 mrb_bool
diff --git a/src/vm.c b/src/vm.c
index f74be7edd..79bb3ed60 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -269,14 +269,13 @@ top_proc(mrb_state *mrb, struct RProc *proc)
 #define CI_ACC_RESUMED -3
 
 static inline mrb_callinfo*
-cipush(mrb_state *mrb)
+cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc,
+    struct RClass *target_class, struct RProc *proc, mrb_sym mid, int argc)
 {
   struct mrb_context *c = mrb->c;
   static const mrb_callinfo ci_zero = { 0 };
   mrb_callinfo *ci = c->ci;
 
-  int ridx = ci->ridx;
-
   if (ci + 1 == c->ciend) {
     ptrdiff_t size = ci - c->cibase;
 
@@ -286,8 +285,16 @@ cipush(mrb_state *mrb)
   }
   ci = ++c->ci;
   *ci = ci_zero;
-  ci->epos = mrb->c->eidx;
-  ci->ridx = ridx;
+  ci->mid = mid;
+  ci->proc = proc;
+  ci->stackent = c->stack;
+  ci->epos = c->eidx;
+  ci->ridx = ci[-1].ridx;
+  ci->pc = pc;
+  ci->argc = argc;
+  ci->acc = acc;
+  ci->target_class = target_class;
+  c->stack += push_stacks;
 
   return ci;
 }
@@ -313,14 +320,16 @@ mrb_env_unshare(mrb_state *mrb, struct REnv *e)
   }
 }
 
-static inline void
+static inline mrb_callinfo*
 cipop(mrb_state *mrb)
 {
   struct mrb_context *c = mrb->c;
   struct REnv *env = c->ci->env;
 
+  mrb->c->stack = c->ci->stackent;
   c->ci--;
   if (env) mrb_env_unshare(mrb, env);
+  return c->ci;
 }
 
 void mrb_exc_set(mrb_state *mrb, mrb_value exc);
@@ -356,16 +365,9 @@ ecall(mrb_state *mrb)
     nregs = ci->proc->body.irep->nregs;
   }
   cioff = ci - c->cibase;
-  ci = cipush(mrb);
-  ci->stackent = mrb->c->stack;
-  ci->mid = ci[-1].mid;
-  ci->acc = CI_ACC_SKIP;
-  ci->argc = 0;
-  ci->proc = p;
-  ci->target_class = MRB_PROC_TARGET_CLASS(p);
+  ci = cipush(mrb, NULL, nregs, CI_ACC_SKIP, MRB_PROC_TARGET_CLASS(p), p, ci->mid, 0);
   env = MRB_PROC_ENV(p);
   mrb_assert(env);
-  c->stack += nregs;
   exc = mrb->exc; mrb->exc = 0;
   if (exc) {
     mrb_gc_protect(mrb, mrb_obj_value(exc));
@@ -447,7 +449,6 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
     }
     MRB_CATCH(&c_jmp) { /* error */
       while (nth_ci < (mrb->c->ci - mrb->c->cibase)) {
-        mrb->c->stack = mrb->c->ci->stackent;
         cipop(mrb);
       }
       mrb->jmp = 0;
@@ -486,12 +487,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
     if (mrb->c->ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) {
       mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
     }
-    ci = cipush(mrb);
-    ci->mid = mid;
-    ci->stackent = mrb->c->stack;
-    ci->argc = (int)argc;
-    ci->target_class = c;
-    mrb->c->stack = mrb->c->stack + n;
+    ci = cipush(mrb, NULL, n, 0, c, NULL, mid, argc);
     if (argc < 0) argc = 1;
     if (mrb->c->stbase <= argv && argv < mrb->c->stend) {
       voff = argv - mrb->c->stbase;
@@ -524,7 +520,6 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
     if (MRB_METHOD_CFUNC_P(m)) {
       ci->acc = CI_ACC_DIRECT;
       val = MRB_METHOD_CFUNC(m)(mrb, self);
-      mrb->c->stack = mrb->c->ci->stackent;
       cipop(mrb);
     }
     else {
@@ -565,11 +560,7 @@ mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
     stack_clear(mrb->c->stack+keep, nregs-keep);
   }
 
-  ci = cipush(mrb);
-  ci->target_class = 0;
-  ci->pc = p->body.irep->iseq;
-  ci->stackent = mrb->c->stack;
-  ci->acc = 0;
+  cipush(mrb, p->body.irep->iseq, 0, 0, NULL, NULL, 0, 0);
 
   return self;
 }
@@ -671,11 +662,7 @@ eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c)
   mrb->c->stack[0] = self;
   mrb->c->stack[1] = self;
   stack_clear(mrb->c->stack+2, nregs-2);
-  ci = cipush(mrb);
-  ci->target_class = 0;
-  ci->pc = p->body.irep->iseq;
-  ci->stackent = mrb->c->stack;
-  ci->acc = 0;
+  ci = cipush(mrb, p->body.irep->iseq, 0, 0, NULL, NULL, 0, 0);
 
   return self;
 }
@@ -751,13 +738,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
     mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
   }
   p = mrb_proc_ptr(b);
-  ci = cipush(mrb);
-  ci->mid = mid;
-  ci->proc = p;
-  ci->target_class = c;
-  ci->acc = CI_ACC_SKIP;
-  ci->stackent = mrb->c->stack;
-  mrb->c->stack += n;
+  ci = cipush(mrb, NULL, n, CI_ACC_SKIP, c, p, mid, 0 /* dummy */);
   if (argc >= CALL_MAXARGS) {
     ci->argc = -1;
     n = 3;
@@ -779,7 +760,6 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
 
   if (MRB_PROC_CFUNC_P(p)) {
     val = MRB_PROC_CFUNC(p)(mrb, self);
-    mrb->c->stack = mrb->c->ci->stackent;
     cipop(mrb);
   }
   else {
@@ -1328,15 +1308,7 @@ RETRY_TRY_BLOCK:
         mrb->c->ensure[epos+n] = NULL;
         if (proc == NULL) continue;
         irep = proc->body.irep;
-        ci = cipush(mrb);
-        ci->mid = ci[-1].mid;
-        ci->argc = 0;
-        ci->proc = proc;
-        ci->stackent = mrb->c->stack;
-        ci->target_class = target_class;
-        ci->pc = pc;
-        ci->acc = nregs;
-        mrb->c->stack += ci->acc;
+        ci = cipush(mrb, pc, nregs, nregs, target_class, proc, ci->mid, 0);
         mrb_stack_extend(mrb, irep->nregs);
         regs[0] = self;
         pc = irep->iseq;
@@ -1418,17 +1390,7 @@ RETRY_TRY_BLOCK:
       }
 
       /* push callinfo */
-      ci = cipush(mrb);
-      ci->mid = mid;
-      ci->stackent = mrb->c->stack;
-      ci->target_class = cls;
-      ci->argc = argc;
-
-      ci->pc = pc;
-      ci->acc = a;
-
-      /* prepare stack */
-      mrb->c->stack += a;
+      ci = cipush(mrb, pc, a, a, cls, NULL, mid, argc);
 
       if (MRB_METHOD_CFUNC_P(m)) {
         if (MRB_METHOD_PROC_P(m)) {
@@ -1470,7 +1432,6 @@ RETRY_TRY_BLOCK:
         }
         mrb->c->stack[0] = recv;
         /* pop stackpos */
-        mrb->c->stack = ci->stackent;
         pc = ci->pc;
         cipop(mrb);
         JUMP;
@@ -1508,10 +1469,9 @@ RETRY_TRY_BLOCK:
         if (mrb->exc) goto L_RAISE;
         /* pop stackpos */
         ci = mrb->c->ci;
-        mrb->c->stack = ci->stackent;
-        regs[ci->acc] = recv;
         pc = ci->pc;
         cipop(mrb);
+        regs[ci->acc] = recv;
         irep = mrb->c->ci->proc->body.irep;
         pool = irep->pool;
         syms = irep->syms;
@@ -1617,15 +1577,9 @@ RETRY_TRY_BLOCK:
       }
 
       /* push callinfo */
-      ci = cipush(mrb);
-      ci->mid = mid;
-      ci->stackent = mrb->c->stack;
-      ci->target_class = cls;
-      ci->pc = pc;
-      ci->argc = argc;
+      ci = cipush(mrb, pc, a, 0, cls, NULL, mid, argc);
 
       /* prepare stack */
-      mrb->c->stack += a;
       mrb->c->stack[0] = recv;
 
       if (MRB_METHOD_CFUNC_P(m)) {
@@ -1652,8 +1606,6 @@ RETRY_TRY_BLOCK:
           }
         }
         mrb->c->stack[0] = v;
-        /* pop stackpos */
-        mrb->c->stack = ci->stackent;
         pc = ci->pc;
         cipop(mrb);
         JUMP;
@@ -1954,13 +1906,11 @@ RETRY_TRY_BLOCK:
           goto L_RESCUE;
         }
         while (ci[0].ridx == ci[-1].ridx) {
-          cipop(mrb);
-          mrb->c->stack = ci->stackent;
-          if (ci->acc == CI_ACC_SKIP && prev_jmp) {
+          ci = cipop(mrb);
+          if (ci[1].acc == CI_ACC_SKIP && prev_jmp) {
             mrb->jmp = prev_jmp;
             MRB_THROW(prev_jmp);
           }
-          ci = mrb->c->ci;
           if (ci == mrb->c->cibase) {
             if (ci->ridx == 0) {
             L_FTOP:             /* fiber top */
@@ -2142,15 +2092,13 @@ RETRY_TRY_BLOCK:
           return v;
         }
         acc = ci->acc;
-        mrb->c->stack = ci->stackent;
-        cipop(mrb);
+        ci = cipop(mrb);
         if (acc == CI_ACC_SKIP || acc == CI_ACC_DIRECT) {
           mrb_gc_arena_restore(mrb, ai);
           mrb->jmp = prev_jmp;
           return v;
         }
-        pc = ci->pc;
-        ci = mrb->c->ci;
+        pc = ci[1].pc;
         DEBUG(fprintf(stderr, "from :%s\n", mrb_sym_name(mrb, ci->mid)));
         proc = mrb->c->ci->proc;
         irep = proc->body.irep;
@@ -2664,7 +2612,6 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_EXEC, BB) {
-      mrb_callinfo *ci;
       mrb_value recv = regs[a];
       struct RProc *p;
       mrb_irep *nirep = irep->reps[b];
@@ -2677,19 +2624,7 @@ RETRY_TRY_BLOCK:
       p->flags |= MRB_PROC_SCOPE;
 
       /* prepare call stack */
-      ci = cipush(mrb);
-      ci->pc = pc;
-      ci->acc = a;
-      ci->mid = 0;
-      ci->stackent = mrb->c->stack;
-      ci->argc = 0;
-      ci->target_class = mrb_class_ptr(recv);
-
-      /* prepare stack */
-      mrb->c->stack += a;
-
-      /* setup block to call */
-      ci->proc = p;
+      cipush(mrb, pc, a, a, mrb_class_ptr(recv), p, 0, 0);
 
       irep = p->body.irep;
       pool = irep->pool;
@@ -2834,7 +2769,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 MRB_API mrb_value
 mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
 {
-  mrb_callinfo *ci;
   mrb_value v;
 
   if (!mrb->c->cibase) {
@@ -2844,11 +2778,7 @@ mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int sta
     mrb->c->ci->env = NULL;
     return mrb_vm_run(mrb, proc, self, stack_keep);
   }
-  ci = cipush(mrb);
-  ci->stackent = mrb->c->stack;
-  ci->mid = 0;
-  ci->acc = CI_ACC_SKIP;
-  ci->target_class = mrb->object_class;
+  cipush(mrb, NULL, 0, CI_ACC_SKIP, mrb->object_class, NULL, 0, 0);
   v = mrb_vm_run(mrb, proc, self, stack_keep);
 
   return v;