changeset 16:5dad2b2a4da3

fix INTERP instance values and add __CODES array
author Takahiro SHIMIZU <anatofuz@cr.ie.u-ryukyu.ac.jp>
date Thu, 18 Oct 2018 14:01:51 +0900
parents e8ab4ff02207
children f4636c3adb79
files cbctools/change_OPS_h_to_cbc.pl src/core/cbc-interp.cbc src/core/oplables-cbc-codes.h
diffstat 3 files changed, 1892 insertions(+), 166 deletions(-) [+]
line wrap: on
line diff
--- a/cbctools/change_OPS_h_to_cbc.pl	Tue Oct 16 19:23:56 2018 +0900
+++ b/cbctools/change_OPS_h_to_cbc.pl	Thu Oct 18 14:01:51 2018 +0900
@@ -40,7 +40,7 @@
 
 for my $code_gear (@out){
     $code_gear =~ s/^\s+(\w+),\n/$1/g;
-    print "__code $code_gear(INTERP);\n";
+    print "__code $code_gear();\n";
 }
 
 print "\n";
--- a/src/core/cbc-interp.cbc	Tue Oct 16 19:23:56 2018 +0900
+++ b/src/core/cbc-interp.cbc	Thu Oct 18 14:01:51 2018 +0900
@@ -104,7 +104,7 @@
     goto NEXT(i);
 }
 __code cbc_const_s(INTERP i){
-    GET_REG(i->cur_op, 0,i).s = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2));
+    GET_REG(i->cur_op, 0,i).s = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2));
     i->cur_op += 6;
     goto NEXT(i);
 }
@@ -184,13 +184,13 @@
     goto NEXT(i);
 }
 __code cbc_goto(INTERP i){
-    i->cur_op = bytecode_start + GET_UI32(i->cur_op, 0);
+    i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 0);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
 }
 __code cbc_if_i(INTERP i){
     if (GET_REG(i->cur_op, 0,i).i64)
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     else
         i->cur_op += 6;
     GC_SYNC_POINT(i->tc);
@@ -200,13 +200,13 @@
     if (GET_REG(i->cur_op, 0,i).i64)
         i->cur_op += 6;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
 }
 __code cbc_if_n(INTERP i){
     if (GET_REG(i->cur_op, 0,i).n64 != 0.0)
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     else
         i->cur_op += 6;
     GC_SYNC_POINT(i->tc);
@@ -216,7 +216,7 @@
     if (GET_REG(i->cur_op, 0,i).n64 != 0.0)
         i->cur_op += 6;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
 }
@@ -225,14 +225,14 @@
     if (!str || MVM_string_graphs(i->tc, str) == 0)
         i->cur_op += 6;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
             }
 __code cbc_unless_s(INTERP i){
     MVMString *str = GET_REG(i->cur_op, 0,i).s;
     if (!str || MVM_string_graphs(i->tc, str) == 0)
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     else
         i->cur_op += 6;
     GC_SYNC_POINT(i->tc);
@@ -243,14 +243,14 @@
     if (!MVM_coerce_istrue_s(i->tc, str))
         i->cur_op += 6;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
             }
 __code cbc_unless_s0(INTERP i){
     MVMString *str = GET_REG(i->cur_op, 0,i).s;
     if (!MVM_coerce_istrue_s(i->tc, str))
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     else
         i->cur_op += 6;
     GC_SYNC_POINT(i->tc);
@@ -259,7 +259,7 @@
 __code cbc_if_o(INTERP i){
     GC_SYNC_POINT(i->tc);
     MVM_coerce_istrue(i->tc, GET_REG(i->cur_op, 0,i).o, NULL,
-        bytecode_start + GET_UI32(i->cur_op, 2),
+        i->bytecode_start + GET_UI32(i->cur_op, 2),
         i->cur_op + 6,
         0);
     goto NEXT(i);
@@ -267,7 +267,7 @@
 __code cbc_unless_o(INTERP i){
     GC_SYNC_POINT(i->tc);
     MVM_coerce_istrue(i->tc, GET_REG(i->cur_op, 0,i).o, NULL,
-        bytecode_start + GET_UI32(i->cur_op, 2),
+        i->bytecode_start + GET_UI32(i->cur_op, 2),
         i->cur_op + 6,
         1);
     goto NEXT(i);
@@ -282,7 +282,7 @@
         i->cur_op += (6 /* size of each goto op */) * num_labels;
     }
     else { /* delve directly into the selected goto op */
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op,
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op,
             input * (6 /* size of each goto op */)
             + (2 /* size of the goto instruction itself */));
     }
@@ -345,25 +345,25 @@
             }
 __code cbc_getlex_ni(INTERP i){
     GET_REG(i->cur_op, 0,i).i64 = MVM_frame_find_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_reg_int64)->i64;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_reg_int64)->i64;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_getlex_nn(INTERP i){
     GET_REG(i->cur_op, 0,i).n64 = MVM_frame_find_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_reg_num64)->n64;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_reg_num64)->n64;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_getlex_ns(INTERP i){
     GET_REG(i->cur_op, 0,i).s = MVM_frame_find_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_reg_str)->s;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_reg_str)->s;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_getlex_no(INTERP i){
     MVMRegister *found = MVM_frame_find_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_reg_obj);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_reg_obj);
     if (found) {
         GET_REG(i->cur_op, 0,i).o = found->o;
         if (MVM_spesh_log_is_logging(i->tc))
@@ -377,28 +377,28 @@
             }
 __code cbc_bindlex_ni(INTERP i){
     MVM_frame_bind_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 0)),
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 0)),
         MVM_reg_int64, &(GET_REG(i->cur_op, 4,i)));
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_bindlex_nn(INTERP i){
     MVM_frame_bind_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 0)),
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 0)),
         MVM_reg_num64, &(GET_REG(i->cur_op, 4,i)));
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_bindlex_ns(INTERP i){
     MVM_frame_bind_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 0)),
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 0)),
         MVM_reg_str, &(GET_REG(i->cur_op, 4,i)));
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_bindlex_no(INTERP i){
     MVM_frame_bind_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 0)),
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 0)),
         MVM_reg_obj, &(GET_REG(i->cur_op, 4,i)));
     i->cur_op += 6;
     goto NEXT(i);
@@ -423,7 +423,7 @@
             }
 __code cbc_setlexvalue(INTERP i){
     MVMObject *code = GET_REG(i->cur_op, 0,i).o;
-    MVMString *name = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2));
+    MVMString *name = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2));
     MVMObject *val  = GET_REG(i->cur_op, 6,i).o;
     MVMint16   flag = GET_I16(i->cur_op, 8);
     if (flag < 0 || flag > 2)
@@ -467,7 +467,7 @@
     MVM_args_set_result_int(i->tc, GET_REG(i->cur_op, 0,i).i64,
         MVM_RETURN_CALLER_FRAME);
     if (MVM_frame_try_return(i->tc) == 0)
-        goto return_label;
+        goto return_label(i);
     goto NEXT(i);
 }
 __code cbc_return_n(INTERP i){
@@ -476,7 +476,7 @@
     MVM_args_set_result_num(i->tc, GET_REG(i->cur_op, 0,i).n64,
         MVM_RETURN_CALLER_FRAME);
     if (MVM_frame_try_return(i->tc) == 0)
-        goto return_label;
+        goto return_label(i);
     goto NEXT(i);
 }
 __code cbc_return_s(INTERP i){
@@ -485,7 +485,7 @@
     MVM_args_set_result_str(i->tc, GET_REG(i->cur_op, 0,i).s,
         MVM_RETURN_CALLER_FRAME);
     if (MVM_frame_try_return(i->tc) == 0)
-        goto return_label;
+        goto return_label(i);
     goto NEXT(i);
 }
 __code cbc_return_o(INTERP i){
@@ -497,7 +497,7 @@
     }
     MVM_args_set_result_obj(i->tc, value, MVM_RETURN_CALLER_FRAME);
     if (MVM_frame_try_return(i->tc) == 0)
-        goto return_label;
+        goto return_label(i);
     goto NEXT(i);
             }
 __code cbc_return(INTERP i){
@@ -505,7 +505,7 @@
         MVM_spesh_log_return_type(i->tc, NULL);
     MVM_args_assert_void_return_ok(i->tc, MVM_RETURN_CALLER_FRAME);
     if (MVM_frame_try_return(i->tc) == 0)
-        goto return_label;
+        goto return_label(i);
     goto NEXT(i);
 }
 __code cbc_eq_i(INTERP i){
@@ -675,9 +675,9 @@
             }
         }
         GET_REG(i->cur_op, 0,i).i64 = result;
-    }
-    i->cur_op += 6;
-    goto NEXT(i);
+    i->cur_op += 6;
+    goto NEXT(i);
+}
 __code cbc_not_i(INTERP i){
     GET_REG(i->cur_op, 0,i).i64 = GET_REG(i->cur_op, 2,i).i64 ? 0 : 1;
     i->cur_op += 4;
@@ -929,7 +929,7 @@
      * any arguments. Note that since none of the arg-setting ops can
      * trigger GC, there's no way the setup can be interrupted, so we
      * don't need to clear the args buffer before we start. */
-    i->cur_callsite = cu->body.callsites[GET_UI16(i->cur_op, 0)];
+    i->cur_callsite =i->cu->body.callsites[GET_UI16(i->cur_op, 0)];
     i->tc->cur_frame->cur_args_callsite = i->cur_callsite;
     i->cur_op += 2;
     goto NEXT(i);
@@ -966,7 +966,7 @@
 }
 __code cbc_argconst_s(INTERP i){
     i->tc->cur_frame->args[GET_UI16(i->cur_op, 0)].s =
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2));
     i->cur_op += 6;
     goto NEXT(i);
 }
@@ -1110,7 +1110,7 @@
         GET_UI16(i->cur_op, 2));
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).i64 = param.arg.i64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 4);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 4);
     }
     else {
         i->cur_op += 8;
@@ -1119,13 +1119,11 @@
             }
 }
 __code cbc_param_op_n(INTERP i){
-            {
     MVMArgInfo param = MVM_args_get_pos_num(i->tc, &i->tc->cur_frame->params,
-}
         GET_UI16(i->cur_op, 2), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).n64 = param.arg.n64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 4);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 4);
     }
     else {
         i->cur_op += 8;
@@ -1138,7 +1136,7 @@
         GET_UI16(i->cur_op, 2));
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).s = param.arg.s;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 4);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 4);
     }
     else {
         i->cur_op += 8;
@@ -1154,7 +1152,7 @@
         GET_REG(i->cur_op, 0,i).o = param.arg.o;
         if (MVM_spesh_log_is_logging(i->tc))
             MVM_spesh_log_parameter(i->tc, arg_idx, param.arg.o);
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 4);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 4);
     }
     else {
         i->cur_op += 8;
@@ -1164,25 +1162,25 @@
 }
 __code cbc_param_rn_i(INTERP i){
     GET_REG(i->cur_op, 0,i).i64 = MVM_args_get_named_int(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.i64;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.i64;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_param_rn_n(INTERP i){
     GET_REG(i->cur_op, 0,i).n64 = MVM_args_get_named_num(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.n64;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.n64;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_param_rn_s(INTERP i){
     GET_REG(i->cur_op, 0,i).s = MVM_args_get_named_str(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.s;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.s;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_param_rn_o(INTERP i){
     MVMArgInfo param = MVM_args_get_named_obj(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED);
     GET_REG(i->cur_op, 0,i).o = param.arg.o;
     if (MVM_spesh_log_is_logging(i->tc))
         MVM_spesh_log_parameter(i->tc, param.arg_idx, param.arg.o);
@@ -1190,13 +1188,11 @@
     goto NEXT(i);
             }
 __code cbc_param_on_i(INTERP i){
-            {
     MVMArgInfo param = MVM_args_get_named_int(i->tc, &i->tc->cur_frame->params,
-}
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).i64 = param.arg.i64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 6);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 6);
     }
     else {
         i->cur_op += 10;
@@ -1204,13 +1200,11 @@
     goto NEXT(i);
             }
 __code cbc_param_on_n(INTERP i){
-            {
     MVMArgInfo param = MVM_args_get_named_num(i->tc, &i->tc->cur_frame->params,
-}
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).n64 = param.arg.n64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 6);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 6);
     }
     else {
         i->cur_op += 10;
@@ -1218,13 +1212,11 @@
     goto NEXT(i);
             }
 __code cbc_param_on_s(INTERP i){
-            {
     MVMArgInfo param = MVM_args_get_named_str(i->tc, &i->tc->cur_frame->params,
-}
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).s = param.arg.s;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 6);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 6);
     }
     else {
         i->cur_op += 10;
@@ -1232,15 +1224,13 @@
     goto NEXT(i);
             }
 __code cbc_param_on_o(INTERP i){
-            {
     MVMArgInfo param = MVM_args_get_named_obj(i->tc, &i->tc->cur_frame->params,
-}
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).o = param.arg.o;
         if (MVM_spesh_log_is_logging(i->tc))
             MVM_spesh_log_parameter(i->tc, param.arg_idx, param.arg.o);
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 6);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 6);
     }
     else {
         i->cur_op += 10;
@@ -1258,7 +1248,7 @@
     goto NEXT(i);
 }
 __code cbc_getcode(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = cu->body.coderefs[GET_UI16(i->cur_op, 2)];
+    GET_REG(i->cur_op, 0,i).o =i->cu->body.coderefs[GET_UI16(i->cur_op, 2)];
     i->cur_op += 4;
     goto NEXT(i);
 }
@@ -1484,14 +1474,14 @@
             }
 __code cbc_captureposprimspec(INTERP i){
     MVMObject *obj = GET_REG(i->cur_op, 2,i).o;
-    MVMint64   i   = GET_REG(i->cur_op, 4,i).i64;
+    MVMint64   j   = GET_REG(i->cur_op, 4,i).i64;
     if (IS_CONCRETE(obj) && REPR(obj)->ID == MVM_REPR_ID_MVMCallCapture) {
         MVMCallCapture *cc = (MVMCallCapture *)obj;
-        if (i >= 0 && i < cc->body.apc->num_pos) {
+        if (j >= 0 && j < cc->body.apc->num_pos) {
             MVMCallsiteEntry *arg_flags = cc->body.apc->arg_flags
                 ? cc->body.apc->arg_flags
                 : cc->body.apc->callsite->arg_flags;
-            swii->tch (arg_flags[i] & MVM_CALLSITE_ARG_MASK) {
+            switch (arg_flags[j] & MVM_CALLSITE_ARG_MASK) {
                 case MVM_CALLSITE_ARG_INT:
         GET_REG(i->cur_op, 0,i).i64 = MVM_STORAGE_SPEC_BP_INT;
         break;
@@ -1745,7 +1735,7 @@
     goto NEXT(i);
 }
 __code cbc_tc(INTERP i){
-    GET_REG(i->cur_op, 0,i).s = MVM_string_i->tc(i->tc,
+    GET_REG(i->cur_op, 0,i).s = MVM_string_tc(i->tc,
         GET_REG(i->cur_op, 2,i).s);
     i->cur_op += 4;
     goto NEXT(i);
@@ -1778,10 +1768,10 @@
     /* branches on *failure* to mai->tch in the constant string, to save an instruction in regexes */
     if (MVM_string_char_at_in_string(i->tc, GET_REG(i->cur_op, 0,i).s,
             GET_REG(i->cur_op, 2,i).i64,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4))) >= 0)
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4))) >= 0)
         i->cur_op += 12;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 8);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 8);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
 }
@@ -1789,10 +1779,10 @@
     /* branches on *failure* to mai->tch in the constant string, to save an instruction in regexes */
     if (MVM_string_char_at_in_string(i->tc, GET_REG(i->cur_op, 0,i).s,
             GET_REG(i->cur_op, 2,i).i64,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4))) == -1)
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4))) == -1)
         i->cur_op += 12;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 8);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 8);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
 }
@@ -1951,7 +1941,7 @@
     if (MVM_is_null(i->tc, GET_REG(i->cur_op, 0,i).o))
         i->cur_op += 6;
     else
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 2);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 2);
     GC_SYNC_POINT(i->tc);
     goto NEXT(i);
 }
@@ -1959,7 +1949,7 @@
     /* Increment PC first, as we may make a method call. */
     MVMRegister *res  = &GET_REG(i->cur_op, 0,i);
     MVMObject   *obj  = GET_REG(i->cur_op, 2,i).o;
-    MVMString   *name = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4));
+    MVMString   *name = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4));
     i->cur_op += 8;
     MVM_6model_find_method(i->tc, obj, name, res, 1);
     goto NEXT(i);
@@ -1977,7 +1967,7 @@
     /* Increment PC first, as we may make a method call. */
     MVMRegister *res  = &GET_REG(i->cur_op, 0,i);
     MVMObject   *obj  = GET_REG(i->cur_op, 2,i).o;
-    MVMString   *name = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4));
+    MVMString   *name = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4));
     i->cur_op += 8;
     MVM_6model_can_method(i->tc, obj, name, res);
     goto NEXT(i);
@@ -2112,7 +2102,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot bind attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.bind_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4)),
+        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4)),
         GET_I16(i->cur_op, 10), GET_REG(i->cur_op, 8,i), MVM_reg_int64);
     MVM_SC_WB_OBJ(i->tc, obj);
     i->cur_op += 12;
@@ -2124,7 +2114,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot bind attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.bind_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4)),
+        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4)),
         GET_I16(i->cur_op, 10), GET_REG(i->cur_op, 8,i), MVM_reg_num64);
     MVM_SC_WB_OBJ(i->tc, obj);
     i->cur_op += 12;
@@ -2136,7 +2126,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot bind attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.bind_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4)),
+        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4)),
         GET_I16(i->cur_op, 10), GET_REG(i->cur_op, 8,i), MVM_reg_str);
     MVM_SC_WB_OBJ(i->tc, obj);
     i->cur_op += 12;
@@ -2148,7 +2138,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot bind attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.bind_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4)),
+        GET_REG(i->cur_op, 2,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4)),
         GET_I16(i->cur_op, 10), GET_REG(i->cur_op, 8,i), MVM_reg_obj);
     MVM_SC_WB_OBJ(i->tc, obj);
     i->cur_op += 12;
@@ -2208,7 +2198,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot look up attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.get_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)),
+        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)),
         GET_I16(i->cur_op, 10), &GET_REG(i->cur_op, 0,i), MVM_reg_int64);
     i->cur_op += 12;
     goto NEXT(i);
@@ -2219,7 +2209,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot look up attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.get_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)),
+        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)),
         GET_I16(i->cur_op, 10), &GET_REG(i->cur_op, 0,i), MVM_reg_num64);
     i->cur_op += 12;
     goto NEXT(i);
@@ -2230,7 +2220,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot look up attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.get_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)),
+        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)),
         GET_I16(i->cur_op, 10), &GET_REG(i->cur_op, 0,i), MVM_reg_str);
     i->cur_op += 12;
     goto NEXT(i);
@@ -2241,7 +2231,7 @@
         MVM_exception_throw_adhoc(i->tc, "Cannot look up attributes in a %s type object", MVM_6model_get_debug_name(i->tc, obj));
     REPR(obj)->attr_funcs.get_attribute(i->tc,
         STABLE(obj), obj, OBJECT_BODY(obj),
-        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)),
+        GET_REG(i->cur_op, 4,i).o, MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)),
         GET_I16(i->cur_op, 10), &GET_REG(i->cur_op, 0,i), MVM_reg_obj);
     if (MVM_spesh_log_is_logging(i->tc))
         MVM_spesh_log_type(i->tc, GET_REG(i->cur_op, 0,i).o);
@@ -2709,10 +2699,10 @@
     MVMObject *obj    = GET_REG(i->cur_op, 0,i).o;
     MVMObject *types  = GET_REG(i->cur_op, 2,i).o;
     MVMSTable *st     = STABLE(obj);
-    MVMint64 i, elems = REPR(types)->elems(i->tc, STABLE(types), types, OBJECT_BODY(types));
+    MVMint64 j, elems = REPR(types)->elems(i->tc, STABLE(types), types, OBJECT_BODY(types));
     MVMObject **cache = MVM_malloc(sizeof(MVMObject *) * elems);
-    for (i = 0; i < elems; i++) {
-        MVM_ASSIGN_REF(i->tc, &(st->header), cache[i], MVM_repr_at_pos_o(i->tc, types, i));
+    for (j = 0; j < elems; j++) {
+        MVM_ASSIGN_REF(i->tc, &(st->header), cache[j], MVM_repr_at_pos_o(i->tc, types, j));
     }
     /* technically this free isn't thread safe */
     if (st->type_check_cache)
@@ -2836,27 +2826,27 @@
     goto NEXT(i);
 }
 __code cbc_hllboxtype_i(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = cu->body.hll_config->int_box_type;
+    GET_REG(i->cur_op, 0,i).o =i->cu->body.hll_config->int_box_type;
     i->cur_op += 2;
     goto NEXT(i);
 }
 __code cbc_hllboxtype_n(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = cu->body.hll_config->num_box_type;
+    GET_REG(i->cur_op, 0,i).o =i->cu->body.hll_config->num_box_type;
     i->cur_op += 2;
     goto NEXT(i);
 }
 __code cbc_hllboxtype_s(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = cu->body.hll_config->str_box_type;
+    GET_REG(i->cur_op, 0,i).o =i->cu->body.hll_config->str_box_type;
     i->cur_op += 2;
     goto NEXT(i);
 }
 __code cbc_hlllist(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = cu->body.hll_config->slurpy_array_type;
+    GET_REG(i->cur_op, 0,i).o =i->cu->body.hll_config->slurpy_array_type;
     i->cur_op += 2;
     goto NEXT(i);
 }
 __code cbc_hllhash(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = cu->body.hll_config->slurpy_hash_type;
+    GET_REG(i->cur_op, 0,i).o =i->cu->body.hll_config->slurpy_hash_type;
     i->cur_op += 2;
     goto NEXT(i);
 }
@@ -3121,18 +3111,18 @@
     goto NEXT(i);
             }
 __code cbc_setdispatcher(INTERP i){
-    i->tc->cur_dispai->tcher = GET_REG(i->cur_op, 0,i).o;
-    i->tc->cur_dispai->tcher_for = NULL;
+    i->tc->cur_dispatcher = GET_REG(i->cur_op, 0,i).o;
+    i->tc->cur_dispatcher_for = NULL;
     i->cur_op += 2;
     goto NEXT(i);
 }
 __code cbc_takedispatcher(INTERP i){
-    MVMObject *disp = i->tc->cur_dispai->tcher;
-    MVMObject *disp_for = i->tc->cur_dispai->tcher_for;
+    MVMObject *disp = i->tc->cur_dispatcher;
+    MVMObject *disp_for = i->tc->cur_dispatcher_for;
     MVMObject *cur_code = i->tc->cur_frame->code_ref;
     if (disp && (!disp_for || disp_for == cur_code)) {
         GET_REG(i->cur_op, 0,i).o = disp;
-        i->tc->cur_dispai->tcher = NULL;
+        i->tc->cur_dispatcher = NULL;
     }
     else {
         GET_REG(i->cur_op, 0,i).o = i->tc->instance->VMNull;
@@ -3176,7 +3166,7 @@
     MVMRegister *r = &GET_REG(i->cur_op, 0,i);
     i->cur_op += 4;
     if (obj && IS_CONCRETE(obj) && STABLE(obj)->container_spec) {
-        STABLE(obj)->container_spec->fei->tch(i->tc, obj, r);
+        STABLE(obj)->container_spec->fetch(i->tc, obj, r);
         if (MVM_spesh_log_is_logging(i->tc))
             MVM_spesh_log_decont(i->tc, prev_op, r->o);
     }
@@ -3337,14 +3327,14 @@
 __code cbc_wval(INTERP i){
     MVMuint16 dep = GET_UI16(i->cur_op, 2);
     MVMuint16 idx = GET_UI16(i->cur_op, 4);
-    GET_REG(i->cur_op, 0,i).o = MVM_sc_get_sc_object(i->tc, cu, dep, idx);
+    GET_REG(i->cur_op, 0,i).o = MVM_sc_get_sc_object(i->tc,i->cu, dep, idx);
     i->cur_op += 6;
     goto NEXT(i);
             }
 __code cbc_wval_wide(INTERP i){
     MVMuint16 dep = GET_UI16(i->cur_op, 2);
     MVMuint64 idx = MVM_BC_get_I64(i->cur_op, 4);
-    GET_REG(i->cur_op, 0,i).o = MVM_sc_get_sc_object(i->tc, cu, dep, idx);
+    GET_REG(i->cur_op, 0,i).o = MVM_sc_get_sc_object(i->tc,i->cu, dep, idx);
     i->cur_op += 12;
     goto NEXT(i);
             }
@@ -3461,7 +3451,7 @@
     MVMObject *maybe_cu = GET_REG(i->cur_op, 2,i).o;
     if (REPR(maybe_cu)->ID == MVM_REPR_ID_MVMCompUnit) {
         MVMCompUnit *cu = (MVMCompUnit *)maybe_cu;
-        GET_REG(i->cur_op, 0,i).o = cu->body.coderefs[0];
+        GET_REG(i->cur_op, 0,i).o =i->cu->body.coderefs[0];
     }
     else {
         MVM_exception_throw_adhoc(i->tc, "compunitmainline requires an MVMCompUnit");
@@ -3475,10 +3465,10 @@
     if (REPR(maybe_cu)->ID == MVM_REPR_ID_MVMCompUnit) {
         const MVMuint32 num_frames  = maybe_cu->body.num_frames;
         MVMObject ** const coderefs = maybe_cu->body.coderefs;
-        MVMuint32 i;
+        MVMuint32 j;
 
-        for (i = 0; i < num_frames; i++) {
-            MVM_repr_push_o(i->tc, result, coderefs[i]);
+        for (j = 0; j < num_frames; j++) {
+            MVM_repr_push_o(i->tc, result, coderefs[j]);
         }
 
         GET_REG(i->cur_op, 0,i).o = result;
@@ -3931,7 +3921,7 @@
 __code cbc_tryfindmeth(INTERP i){
     MVMRegister *res  = &GET_REG(i->cur_op, 0,i);
     MVMObject   *obj  = GET_REG(i->cur_op, 2,i).o;
-    MVMString   *name = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4));
+    MVMString   *name = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4));
     i->cur_op += 8;
     MVM_6model_find_method(i->tc, obj, name, res, 0);
     goto NEXT(i);
@@ -4509,7 +4499,7 @@
     goto NEXT(i);
 }
 __code cbc_watchfile(INTERP i){
-    GET_REG(i->cur_op, 0,i).o = MVM_io_file_wai->tch(i->tc, GET_REG(i->cur_op, 2,i).o,
+    GET_REG(i->cur_op, 0,i).o = MVM_io_file_watch(i->tc, GET_REG(i->cur_op, 2,i).o,
         GET_REG(i->cur_op, 4,i).o, GET_REG(i->cur_op, 6,i).s, GET_REG(i->cur_op, 8,i).o);
     i->cur_op += 10;
     goto NEXT(i);
@@ -4593,43 +4583,43 @@
             }
 __code cbc_param_rn2_i(INTERP i){
     MVMArgInfo param = MVM_args_get_named_int(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists)
         GET_REG(i->cur_op, 0,i).i64 = param.arg.i64;
     else
         GET_REG(i->cur_op, 0,i).i64 = MVM_args_get_named_int(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.i64;
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.i64;
     i->cur_op += 10;
     goto NEXT(i);
             }
 __code cbc_param_rn2_n(INTERP i){
     MVMArgInfo param = MVM_args_get_named_num(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists)
         GET_REG(i->cur_op, 0,i).n64 = param.arg.n64;
     else
         GET_REG(i->cur_op, 0,i).n64 = MVM_args_get_named_num(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.n64;
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.n64;
     i->cur_op += 10;
     goto NEXT(i);
             }
 __code cbc_param_rn2_s(INTERP i){
     MVMArgInfo param = MVM_args_get_named_str(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists)
         GET_REG(i->cur_op, 0,i).s = param.arg.s;
     else
         GET_REG(i->cur_op, 0,i).s = MVM_args_get_named_str(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.s;
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.s;
     i->cur_op += 10;
     goto NEXT(i);
             }
 __code cbc_param_rn2_o(INTERP i){
     MVMArgInfo param = MVM_args_get_named_obj(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (!param.exists)
         param = MVM_args_get_named_obj(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED);
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED);
     GET_REG(i->cur_op, 0,i).o = param.arg.o;
     if (MVM_spesh_log_is_logging(i->tc))
         MVM_spesh_log_parameter(i->tc, param.arg_idx, param.arg.o);
@@ -4638,13 +4628,13 @@
             }
 __code cbc_param_on2_i(INTERP i){
     MVMArgInfo param = MVM_args_get_named_int(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (!param.exists)
         param = MVM_args_get_named_int(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).i64 = param.arg.i64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 10);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 10);
     }
     else {
         i->cur_op += 14;
@@ -4653,13 +4643,13 @@
             }
 __code cbc_param_on2_n(INTERP i){
     MVMArgInfo param = MVM_args_get_named_num(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (!param.exists)
         param = MVM_args_get_named_num(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).n64 = param.arg.n64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 10);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 10);
     }
     else {
         i->cur_op += 14;
@@ -4668,13 +4658,13 @@
             }
 __code cbc_param_on2_s(INTERP i){
     MVMArgInfo param = MVM_args_get_named_str(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (!param.exists)
         param = MVM_args_get_named_str(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).s = param.arg.s;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 10);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 10);
     }
     else {
         i->cur_op += 14;
@@ -4683,15 +4673,15 @@
             }
 __code cbc_param_on2_o(INTERP i){
     MVMArgInfo param = MVM_args_get_named_obj(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (!param.exists)
         param = MVM_args_get_named_obj(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).o = param.arg.o;
         if (MVM_spesh_log_is_logging(i->tc))
             MVM_spesh_log_parameter(i->tc, param.arg_idx, param.arg.o);
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 10);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 10);
     }
     else {
         i->cur_op += 14;
@@ -4882,19 +4872,19 @@
 }
 __code cbc_getlexref_ni(INTERP i){
     GET_REG(i->cur_op, 0,i).o = MVM_nativeref_lex_name_i(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)));
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_getlexref_nn(INTERP i){
     GET_REG(i->cur_op, 0,i).o = MVM_nativeref_lex_name_n(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)));
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_getlexref_ns(INTERP i){
     GET_REG(i->cur_op, 0,i).o = MVM_nativeref_lex_name_s(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)));
     i->cur_op += 6;
     goto NEXT(i);
 }
@@ -4919,21 +4909,21 @@
 __code cbc_getattrref_i(INTERP i){
     GET_REG(i->cur_op, 0,i).o = MVM_nativeref_attr_i(i->tc,
         GET_REG(i->cur_op, 2,i).o, GET_REG(i->cur_op, 4,i).o,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)));
     i->cur_op += 12;
     goto NEXT(i);
 }
 __code cbc_getattrref_n(INTERP i){
     GET_REG(i->cur_op, 0,i).o = MVM_nativeref_attr_n(i->tc,
         GET_REG(i->cur_op, 2,i).o, GET_REG(i->cur_op, 4,i).o,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)));
     i->cur_op += 12;
     goto NEXT(i);
 }
 __code cbc_getattrref_s(INTERP i){
     GET_REG(i->cur_op, 0,i).o = MVM_nativeref_attr_s(i->tc,
         GET_REG(i->cur_op, 2,i).o, GET_REG(i->cur_op, 4,i).o,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)));
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)));
     i->cur_op += 12;
     goto NEXT(i);
 }
@@ -5367,7 +5357,7 @@
         GET_UI16(i->cur_op, 2), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).u64 = param.arg.u64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 4);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 4);
     }
     else {
         i->cur_op += 8;
@@ -5376,16 +5366,16 @@
             }
 __code cbc_param_rn_u(INTERP i){
     GET_REG(i->cur_op, 0,i).u64 = MVM_args_get_named_uint(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.u64;
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_REQUIRED).arg.u64;
     i->cur_op += 6;
     goto NEXT(i);
 }
 __code cbc_param_on_u(INTERP i){
     MVMArgInfo param = MVM_args_get_named_uint(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).u64 = param.arg.u64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 6);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 6);
     }
     else {
         i->cur_op += 10;
@@ -5394,24 +5384,24 @@
             }
 __code cbc_param_rn2_u(INTERP i){
     MVMArgInfo param = MVM_args_get_named_uint(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (param.exists)
         GET_REG(i->cur_op, 0,i).u64 = param.arg.u64;
     else
         GET_REG(i->cur_op, 0,i).u64 = MVM_args_get_named_uint(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.u64;
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_REQUIRED).arg.u64;
     i->cur_op += 10;
     goto NEXT(i);
             }
 __code cbc_param_on2_u(INTERP i){
     MVMArgInfo param = MVM_args_get_named_uint(i->tc, &i->tc->cur_frame->params,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_ARG_OPTIONAL);
     if (!param.exists)
         param = MVM_args_get_named_uint(i->tc, &i->tc->cur_frame->params,
-            MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
+            MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 6)), MVM_ARG_OPTIONAL);
     if (param.exists) {
         GET_REG(i->cur_op, 0,i).u64 = param.arg.u64;
-        i->cur_op = bytecode_start + GET_UI32(i->cur_op, 10);
+        i->cur_op = i->bytecode_start + GET_UI32(i->cur_op, 10);
     }
     else {
         i->cur_op += 14;
@@ -5561,8 +5551,8 @@
 }
 __code cbc_setdispatcherfor(INTERP i){
     MVMObject *disp_for = GET_REG(i->cur_op, 2,i).o;
-    i->tc->cur_dispai->tcher = GET_REG(i->cur_op, 0,i).o;
-    i->tc->cur_dispai->tcher_for = REPR(disp_for)->ID == MVM_REPR_ID_MVMCode
+    i->tc->cur_dispatcher = GET_REG(i->cur_op, 0,i).o;
+    i->tc->cur_dispatcher_for = REPR(disp_for)->ID == MVM_REPR_ID_MVMCode
         ? disp_for
         : MVM_frame_find_invokee(i->tc, disp_for, NULL);
     i->cur_op += 4;
@@ -5810,7 +5800,7 @@
     MVMRegister *r = &GET_REG(i->cur_op, 0,i);
     i->cur_op += 4;
     if (obj && IS_CONCRETE(obj) && STABLE(obj)->container_spec)
-        STABLE(obj)->container_spec->fei->tch(i->tc, obj, r);
+        STABLE(obj)->container_spec->fetch(i->tc, obj, r);
     else
         r->o = obj;
     goto NEXT(i);
@@ -5849,7 +5839,7 @@
             }
 __code cbc_sp_getlex_no(INTERP i){
     MVMRegister *found = MVM_frame_find_lexical_by_name(i->tc,
-        MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 2)), MVM_reg_obj);
+        MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 2)), MVM_reg_obj);
     GET_REG(i->cur_op, 0,i).o = found ? found->o : i->tc->instance->VMNull;
     i->cur_op += 6;
     goto NEXT(i);
@@ -5956,7 +5946,7 @@
     }
     else {
         /* May invoke, so pre-increment op counter */
-        MVMString *name = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 4));
+        MVMString *name = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 4));
         MVMRegister *res = &GET_REG(i->cur_op, 0,i);
         i->cur_op += 10;
         MVM_6model_find_method_spesh(i->tc, obj, name, idx, res);
@@ -6216,15 +6206,15 @@
     goto NEXT(i);
             }
 __code cbc_sp_jit_enter(INTERP i){
-    if (i->tc->cur_frame->spesh_cand->jii->tcode == NULL) {
-        MVM_exception_throw_adhoc(i->tc, "Try to enter NULL jii->tcode");
+    if (i->tc->cur_frame->spesh_cand->jitcode == NULL) {
+        MVM_exception_throw_adhoc(i->tc, "Try to enter NULL jitcode");
     }
     /* trampoline back to this opcode */
     i->cur_op -= 2;
-    MVM_jit_enter_code(i->tc, cu, i->tc->cur_frame->spesh_cand->jii->tcode);
+    MVM_jit_enter_code(i->tc,i->cu, i->tc->cur_frame->spesh_cand->jitcode);
     if (!i->tc->cur_frame) {
         /* somehow unwound our top frame */
-        goto return_label;
+        goto return_label(i);
     }
     goto NEXT(i);
             }
@@ -6397,7 +6387,7 @@
     MVM_exception_throw_adhoc(i->tc, "The lexoticresult op was removed in MoarVM 2017.08.");
 }
 __code cbc_coverage_log(INTERP i){
-    MVMString *filename = MVM_cu_string(i->tc, cu, GET_UI32(i->cur_op, 0));
+    MVMString *filename = MVM_cu_string(i->tc,i->cu, GET_UI32(i->cur_op, 0));
     MVMuint32 lineno    = GET_UI32(i->cur_op, 4);
     MVMuint32 cacheidx  = GET_UI32(i->cur_op, 8);
     char      *cache    = (char *)MVM_BC_get_I64(i->cur_op, 12);
@@ -6420,6 +6410,15 @@
     goto NEXT(i);
             }
 
+__code return_label (INTERP i){
+    /* Need to clear these pointer pointers since they may be rooted
+     * by some GC procedure. */
+    i->tc->interp_cur_op         = NULL;
+    i->tc->interp_bytecode_start = NULL;
+    i->tc->interp_reg_base       = NULL;
+    i->tc->interp_cu             = NULL;
+    MVM_barrier();
+}
 /* This is the interpreter run loop. We have one of these per thread. */
 void MVM_interp_run(MVMThreadContext *tc, void (*initial_invoke)(MVMThreadContext *, void *), void *invoke_data) {
 #if MVM_CGOTO
@@ -6431,10 +6430,10 @@
      /* Stash addresses of current op, register base and SC deref base
      * in the TC; this will be used by anything that needs to switch
      * the current place we're interpreting. */
-    tc->interp_cur_op         = &cur_op;
-    tc->interp_bytecode_start = &bytecode_start;
-    tc->interp_reg_base       = &reg_base;
-    tc->interp_cu             = &cu;
+    tc->interp_cur_op         = &i->cur_op;
+    tc->interp_bytecode_start = &i->bytecode_start;
+    tc->interp_reg_base       = &i->reg_base;
+    tc->interp_cu             = &i->cu;
 
     /* With everything set up, do the initial invocation (exactly what this does
      * varies depending on if this is starting a new thread or is the top-level
@@ -6465,24 +6464,24 @@
 #if MVM_CGOTO
             OP_CALL_EXTOP: {
                 /* Bounds checking? Never heard of that. */
-                MVMuint8 *op_before = cur_op;
-                MVMExtOpRecord *record = &cu->body.extops[op - MVM_OP_EXT_BASE];
-                record->func(tc, cur_op);
-                if (op_before == cur_op)
-                    cur_op += record->operand_bytes;
-                goto NEXT;
+                MVMuint8 *op_before = i->cur_op;
+                MVMExtOpRecord *record = &i->cu->body.extops[op - MVM_OP_EXT_BASE];
+                record->func(tc, i->cur_op);
+                if (op_before == i->cur_op)
+                    i->cur_op += record->operand_bytes;
+                goto NEXT(i);
             }
 #else
             default: {
                 if (op >= MVM_OP_EXT_BASE
-                        && (op - MVM_OP_EXT_BASE) < cu->body.num_extops) {
+                        && (op - MVM_OP_EXT_BASE) <i->cu->body.num_extops) {
                     MVMuint8 *op_before = cur_op;
                     MVMExtOpRecord *record =
                             &cu->body.extops[op - MVM_OP_EXT_BASE];
                     record->func(tc, cur_op);
                     if (op_before == cur_op)
                         cur_op += record->operand_bytes;
-                    goto NEXT;
+                    goto NEXT(i);
                 }
 
                 MVM_panic(MVM_exitcode_invalidopcode, "Invalid opcode executed (corrupt bytecode stream?) opcode %u", op);
@@ -6491,14 +6490,6 @@
         }
     }
 
-    return_label:
-    /* Need to clear these pointer pointers since they may be rooted
-     * by some GC procedure. */
-    tc->interp_cur_op         = NULL;
-    tc->interp_bytecode_start = NULL;
-    tc->interp_reg_base       = NULL;
-    tc->interp_cu             = NULL;
-    MVM_barrier();
 }
 
 void MVM_interp_enable_tracing() {
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core/oplables-cbc-codes.h	Thu Oct 18 14:01:51 2018 +0900
@@ -0,0 +1,1735 @@
+__code cbc_no_op();
+__code cbc_const_i8();
+__code cbc_const_i16();
+__code cbc_const_i32();
+__code cbc_const_i64();
+__code cbc_const_n32();
+__code cbc_const_n64();
+__code cbc_const_s();
+__code cbc_set();
+__code cbc_extend_u8();
+__code cbc_extend_u16();
+__code cbc_extend_u32();
+__code cbc_extend_i8();
+__code cbc_extend_i16();
+__code cbc_extend_i32();
+__code cbc_trunc_u8();
+__code cbc_trunc_u16();
+__code cbc_trunc_u32();
+__code cbc_trunc_i8();
+__code cbc_trunc_i16();
+__code cbc_trunc_i32();
+__code cbc_extend_n32();
+__code cbc_trunc_n32();
+__code cbc_goto();
+__code cbc_if_i();
+__code cbc_unless_i();
+__code cbc_if_n();
+__code cbc_unless_n();
+__code cbc_if_s();
+__code cbc_unless_s();
+__code cbc_if_s0();
+__code cbc_unless_s0();
+__code cbc_if_o();
+__code cbc_unless_o();
+__code cbc_jumplist();
+__code cbc_getlex();
+__code cbc_bindlex();
+__code cbc_getlex_ni();
+__code cbc_getlex_nn();
+__code cbc_getlex_ns();
+__code cbc_getlex_no();
+__code cbc_bindlex_ni();
+__code cbc_bindlex_nn();
+__code cbc_bindlex_ns();
+__code cbc_bindlex_no();
+__code cbc_getlex_ng();
+__code cbc_bindlex_ng();
+__code cbc_getdynlex();
+__code cbc_binddynlex();
+__code cbc_setlexvalue();
+__code cbc_lexprimspec();
+__code cbc_return_i();
+__code cbc_return_n();
+__code cbc_return_s();
+__code cbc_return_o();
+__code cbc_return();
+__code cbc_eq_i();
+__code cbc_ne_i();
+__code cbc_lt_i();
+__code cbc_le_i();
+__code cbc_gt_i();
+__code cbc_ge_i();
+__code cbc_cmp_i();
+__code cbc_add_i();
+__code cbc_sub_i();
+__code cbc_mul_i();
+__code cbc_div_i();
+__code cbc_div_u();
+__code cbc_mod_i();
+__code cbc_mod_u();
+__code cbc_neg_i();
+__code cbc_abs_i();
+__code cbc_inc_i();
+__code cbc_inc_u();
+__code cbc_dec_i();
+__code cbc_dec_u();
+__code cbc_band_i();
+__code cbc_bor_i();
+__code cbc_bxor_i();
+__code cbc_bnot_i();
+__code cbc_blshift_i();
+__code cbc_brshift_i();
+__code cbc_pow_i();
+__code cbc_not_i();
+__code cbc_gcd_i();
+__code cbc_lcm_i();
+__code cbc_eq_n();
+__code cbc_ne_n();
+__code cbc_lt_n();
+__code cbc_le_n();
+__code cbc_gt_n();
+__code cbc_ge_n();
+__code cbc_cmp_n();
+__code cbc_add_n();
+__code cbc_sub_n();
+__code cbc_mul_n();
+__code cbc_div_n();
+__code cbc_mod_n();
+__code cbc_neg_n();
+__code cbc_abs_n();
+__code cbc_pow_n();
+__code cbc_ceil_n();
+__code cbc_floor_n();
+__code cbc_sin_n();
+__code cbc_asin_n();
+__code cbc_cos_n();
+__code cbc_acos_n();
+__code cbc_tan_n();
+__code cbc_atan_n();
+__code cbc_atan2_n();
+__code cbc_sec_n();
+__code cbc_asec_n();
+__code cbc_sinh_n();
+__code cbc_cosh_n();
+__code cbc_tanh_n();
+__code cbc_sech_n();
+__code cbc_sqrt_n();
+__code cbc_log_n();
+__code cbc_exp_n();
+__code cbc_coerce_in();
+__code cbc_coerce_ni();
+__code cbc_coerce_is();
+__code cbc_coerce_ns();
+__code cbc_coerce_si();
+__code cbc_coerce_sn();
+__code cbc_smrt_numify();
+__code cbc_smrt_strify();
+__code cbc_prepargs();
+__code cbc_arg_i();
+__code cbc_arg_n();
+__code cbc_arg_s();
+__code cbc_arg_o();
+__code cbc_argconst_i();
+__code cbc_argconst_n();
+__code cbc_argconst_s();
+__code cbc_invoke_v();
+__code cbc_invoke_i();
+__code cbc_invoke_n();
+__code cbc_invoke_s();
+__code cbc_invoke_o();
+__code cbc_checkarity();
+__code cbc_param_rp_i();
+__code cbc_param_rp_n();
+__code cbc_param_rp_s();
+__code cbc_param_rp_o();
+__code cbc_param_op_i();
+__code cbc_param_op_n();
+__code cbc_param_op_s();
+__code cbc_param_op_o();
+__code cbc_param_rn_i();
+__code cbc_param_rn_n();
+__code cbc_param_rn_s();
+__code cbc_param_rn_o();
+__code cbc_param_on_i();
+__code cbc_param_on_n();
+__code cbc_param_on_s();
+__code cbc_param_on_o();
+__code cbc_param_sp();
+__code cbc_param_sn();
+__code cbc_getcode();
+__code cbc_caller();
+__code cbc_capturelex();
+__code cbc_takeclosure();
+__code cbc_exception();
+__code cbc_bindexmessage();
+__code cbc_bindexpayload();
+__code cbc_bindexcategory();
+__code cbc_getexmessage();
+__code cbc_getexpayload();
+__code cbc_getexcategory();
+__code cbc_throwdyn();
+__code cbc_throwlex();
+__code cbc_throwlexotic();
+__code cbc_throwcatdyn();
+__code cbc_throwcatlex();
+__code cbc_throwcatlexotic();
+__code cbc_die();
+__code cbc_rethrow();
+__code cbc_resume();
+__code cbc_takehandlerresult();
+__code cbc_DEPRECATED_33();
+__code cbc_DEPRECATED_34();
+__code cbc_backtracestrings();
+__code cbc_usecapture();
+__code cbc_savecapture();
+__code cbc_captureposelems();
+__code cbc_captureposarg();
+__code cbc_captureposarg_i();
+__code cbc_captureposarg_n();
+__code cbc_captureposarg_s();
+__code cbc_captureposprimspec();
+__code cbc_captureexistsnamed();
+__code cbc_capturehasnameds();
+__code cbc_invokewithcapture();
+__code cbc_multicacheadd();
+__code cbc_multicachefind();
+__code cbc_null_s();
+__code cbc_isnull_s();
+__code cbc_eq_s();
+__code cbc_ne_s();
+__code cbc_gt_s();
+__code cbc_ge_s();
+__code cbc_lt_s();
+__code cbc_le_s();
+__code cbc_cmp_s();
+__code cbc_eqat_s();
+__code cbc_eqatic_s();
+__code cbc_haveat_s();
+__code cbc_concat_s();
+__code cbc_repeat_s();
+__code cbc_substr_s();
+__code cbc_index_s();
+__code cbc_graphs_s();
+__code cbc_codes_s();
+__code cbc_getcp_s();
+__code cbc_indexcp_s();
+__code cbc_uc();
+__code cbc_lc();
+__code cbc_tc();
+__code cbc_split();
+__code cbc_join();
+__code cbc_getcpbyname();
+__code cbc_indexat();
+__code cbc_indexnat();
+__code cbc_unipropcode();
+__code cbc_unipvalcode();
+__code cbc_hasuniprop();
+__code cbc_hasunipropc();
+__code cbc_chars();
+__code cbc_chr();
+__code cbc_ordfirst();
+__code cbc_ordat();
+__code cbc_rindexfrom();
+__code cbc_escape();
+__code cbc_flip();
+__code cbc_setbuffersize_fh();
+__code cbc_iscclass();
+__code cbc_findcclass();
+__code cbc_findnotcclass();
+__code cbc_nfafromstatelist();
+__code cbc_nfarunproto();
+__code cbc_nfarunalt();
+__code cbc_radix();
+__code cbc_encode();
+__code cbc_decode();
+__code cbc_istrue_s();
+__code cbc_isfalse_s();
+__code cbc_null();
+__code cbc_isnull();
+__code cbc_ifnonnull();
+__code cbc_findmeth();
+__code cbc_findmeth_s();
+__code cbc_can();
+__code cbc_can_s();
+__code cbc_create();
+__code cbc_clone();
+__code cbc_isconcrete();
+__code cbc_rebless();
+__code cbc_istype();
+__code cbc_objprimspec();
+__code cbc_gethow();
+__code cbc_getwhat();
+__code cbc_getwho();
+__code cbc_setwho();
+__code cbc_reprname();
+__code cbc_getwhere();
+__code cbc_eqaddr();
+__code cbc_bindattr_i();
+__code cbc_bindattr_n();
+__code cbc_bindattr_s();
+__code cbc_bindattr_o();
+__code cbc_bindattrs_i();
+__code cbc_bindattrs_n();
+__code cbc_bindattrs_s();
+__code cbc_bindattrs_o();
+__code cbc_getattr_i();
+__code cbc_getattr_n();
+__code cbc_getattr_s();
+__code cbc_getattr_o();
+__code cbc_getattrs_i();
+__code cbc_getattrs_n();
+__code cbc_getattrs_s();
+__code cbc_getattrs_o();
+__code cbc_attrinited();
+__code cbc_box_i();
+__code cbc_box_n();
+__code cbc_box_s();
+__code cbc_unbox_i();
+__code cbc_unbox_n();
+__code cbc_unbox_s();
+__code cbc_atpos_i();
+__code cbc_atpos_n();
+__code cbc_atpos_s();
+__code cbc_atpos_o();
+__code cbc_bindpos_i();
+__code cbc_bindpos_n();
+__code cbc_bindpos_s();
+__code cbc_bindpos_o();
+__code cbc_push_i();
+__code cbc_push_n();
+__code cbc_push_s();
+__code cbc_push_o();
+__code cbc_pop_i();
+__code cbc_pop_n();
+__code cbc_pop_s();
+__code cbc_pop_o();
+__code cbc_shift_i();
+__code cbc_shift_n();
+__code cbc_shift_s();
+__code cbc_shift_o();
+__code cbc_unshift_i();
+__code cbc_unshift_n();
+__code cbc_unshift_s();
+__code cbc_unshift_o();
+__code cbc_splice();
+__code cbc_setelemspos();
+__code cbc_existspos();
+__code cbc_atkey_i();
+__code cbc_atkey_n();
+__code cbc_atkey_s();
+__code cbc_atkey_o();
+__code cbc_bindkey_i();
+__code cbc_bindkey_n();
+__code cbc_bindkey_s();
+__code cbc_bindkey_o();
+__code cbc_existskey();
+__code cbc_deletekey();
+__code cbc_elems();
+__code cbc_knowhow();
+__code cbc_knowhowattr();
+__code cbc_newtype();
+__code cbc_composetype();
+__code cbc_setmethcache();
+__code cbc_setmethcacheauth();
+__code cbc_settypecache();
+__code cbc_settypecheckmode();
+__code cbc_setboolspec();
+__code cbc_istrue();
+__code cbc_isfalse();
+__code cbc_bootint();
+__code cbc_bootnum();
+__code cbc_bootstr();
+__code cbc_bootarray();
+__code cbc_bootintarray();
+__code cbc_bootnumarray();
+__code cbc_bootstrarray();
+__code cbc_boothash();
+__code cbc_isint();
+__code cbc_isnum();
+__code cbc_isstr();
+__code cbc_islist();
+__code cbc_ishash();
+__code cbc_sethllconfig();
+__code cbc_hllboxtype_i();
+__code cbc_hllboxtype_n();
+__code cbc_hllboxtype_s();
+__code cbc_hlllist();
+__code cbc_hllhash();
+__code cbc_getcomp();
+__code cbc_bindcomp();
+__code cbc_getcurhllsym();
+__code cbc_bindcurhllsym();
+__code cbc_gethllsym();
+__code cbc_bindhllsym();
+__code cbc_settypehll();
+__code cbc_settypehllrole();
+__code cbc_hllize();
+__code cbc_hllizefor();
+__code cbc_usecompileehllconfig();
+__code cbc_usecompilerhllconfig();
+__code cbc_iter();
+__code cbc_iterkey_s();
+__code cbc_iterval();
+__code cbc_getcodename();
+__code cbc_iscoderef();
+__code cbc_getcodeobj();
+__code cbc_setcodeobj();
+__code cbc_setcodename();
+__code cbc_forceouterctx();
+__code cbc_setinvokespec();
+__code cbc_isinvokable();
+__code cbc_freshcoderef();
+__code cbc_markcodestatic();
+__code cbc_markcodestub();
+__code cbc_getstaticcode();
+__code cbc_getcodecuid();
+__code cbc_setdispatcher();
+__code cbc_takedispatcher();
+__code cbc_assign();
+__code cbc_assignunchecked();
+__code cbc_iscont();
+__code cbc_decont();
+__code cbc_setcontspec();
+__code cbc_sha1();
+__code cbc_createsc();
+__code cbc_scsetobj();
+__code cbc_scsetcode();
+__code cbc_scgetobj();
+__code cbc_scgethandle();
+__code cbc_scgetobjidx();
+__code cbc_scsetdesc();
+__code cbc_scobjcount();
+__code cbc_setobjsc();
+__code cbc_getobjsc();
+__code cbc_serialize();
+__code cbc_deserialize();
+__code cbc_wval();
+__code cbc_wval_wide();
+__code cbc_scwbdisable();
+__code cbc_scwbenable();
+__code cbc_pushcompsc();
+__code cbc_popcompsc();
+__code cbc_scgetdesc();
+__code cbc_loadbytecode();
+__code cbc_masttofile();
+__code cbc_masttocu();
+__code cbc_iscompunit();
+__code cbc_compunitmainline();
+__code cbc_compunitcodes();
+__code cbc_ctx();
+__code cbc_ctxouter();
+__code cbc_ctxcaller();
+__code cbc_ctxlexpad();
+__code cbc_curcode();
+__code cbc_callercode();
+__code cbc_add_I();
+__code cbc_sub_I();
+__code cbc_mul_I();
+__code cbc_div_I();
+__code cbc_mod_I();
+__code cbc_neg_I();
+__code cbc_abs_I();
+__code cbc_cmp_I();
+__code cbc_eq_I();
+__code cbc_ne_I();
+__code cbc_lt_I();
+__code cbc_le_I();
+__code cbc_gt_I();
+__code cbc_ge_I();
+__code cbc_bor_I();
+__code cbc_bxor_I();
+__code cbc_band_I();
+__code cbc_bnot_I();
+__code cbc_blshift_I();
+__code cbc_brshift_I();
+__code cbc_pow_I();
+__code cbc_gcd_I();
+__code cbc_lcm_I();
+__code cbc_expmod_I();
+__code cbc_isprime_I();
+__code cbc_rand_I();
+__code cbc_coerce_In();
+__code cbc_coerce_Is();
+__code cbc_coerce_nI();
+__code cbc_coerce_sI();
+__code cbc_isbig_I();
+__code cbc_bool_I();
+__code cbc_base_I();
+__code cbc_radix_I();
+__code cbc_div_In();
+__code cbc_copy_f();
+__code cbc_append_f();
+__code cbc_rename_f();
+__code cbc_delete_f();
+__code cbc_chmod_f();
+__code cbc_exists_f();
+__code cbc_mkdir();
+__code cbc_rmdir();
+__code cbc_open_dir();
+__code cbc_read_dir();
+__code cbc_close_dir();
+__code cbc_open_fh();
+__code cbc_close_fh();
+__code cbc_DEPRECATED_23();
+__code cbc_DEPRECATED_27();
+__code cbc_DEPRECATED_28();
+__code cbc_DEPRECATED_18();
+__code cbc_seek_fh();
+__code cbc_lock_fh();
+__code cbc_unlock_fh();
+__code cbc_sync_fh();
+__code cbc_trunc_fh();
+__code cbc_eof_fh();
+__code cbc_getstdin();
+__code cbc_getstdout();
+__code cbc_getstderr();
+__code cbc_connect_sk();
+__code cbc_socket();
+__code cbc_bind_sk();
+__code cbc_DEPRECATED_24();
+__code cbc_accept_sk();
+__code cbc_decodetocodes();
+__code cbc_encodefromcodes();
+__code cbc_DEPRECATED_17();
+__code cbc_print();
+__code cbc_say();
+__code cbc_DEPRECATED_22();
+__code cbc_tell_fh();
+__code cbc_stat();
+__code cbc_tryfindmeth();
+__code cbc_tryfindmeth_s();
+__code cbc_chdir();
+__code cbc_srand();
+__code cbc_rand_i();
+__code cbc_rand_n();
+__code cbc_time_i();
+__code cbc_sleep();
+__code cbc_newthread();
+__code cbc_threadjoin();
+__code cbc_time_n();
+__code cbc_exit();
+__code cbc_DEPRECATED_30();
+__code cbc_cwd();
+__code cbc_clargs();
+__code cbc_getenvhash();
+__code cbc_loadlib();
+__code cbc_freelib();
+__code cbc_findsym();
+__code cbc_dropsym();
+__code cbc_loadext();
+__code cbc_backendconfig();
+__code cbc_getlexouter();
+__code cbc_getlexrel();
+__code cbc_getlexreldyn();
+__code cbc_getlexrelcaller();
+__code cbc_getlexcaller();
+__code cbc_bitand_s();
+__code cbc_bitor_s();
+__code cbc_bitxor_s();
+__code cbc_isnanorinf();
+__code cbc_inf();
+__code cbc_neginf();
+__code cbc_nan();
+__code cbc_getpid();
+__code cbc_DEPRECATED_29();
+__code cbc_filereadable();
+__code cbc_filewritable();
+__code cbc_fileexecutable();
+__code cbc_DEPRECATED_19();
+__code cbc_capturenamedshash();
+__code cbc_read_fhb();
+__code cbc_write_fhb();
+__code cbc_replace();
+__code cbc_newexception();
+__code cbc_permit();
+__code cbc_backtrace();
+__code cbc_symlink();
+__code cbc_link();
+__code cbc_gethostname();
+__code cbc_exreturnafterunwind();
+__code cbc_DEPRECATED_13();
+__code cbc_continuationreset();
+__code cbc_continuationcontrol();
+__code cbc_continuationinvoke();
+__code cbc_randscale_n();
+__code cbc_uniisblock();
+__code cbc_assertparamcheck();
+__code cbc_hintfor();
+__code cbc_paramnamesused();
+__code cbc_getuniname();
+__code cbc_getuniprop_int();
+__code cbc_getuniprop_bool();
+__code cbc_getuniprop_str();
+__code cbc_matchuniprop();
+__code cbc_nativecallbuild();
+__code cbc_nativecallinvoke();
+__code cbc_nativecallrefresh();
+__code cbc_threadrun();
+__code cbc_threadid();
+__code cbc_threadyield();
+__code cbc_currentthread();
+__code cbc_lock();
+__code cbc_unlock();
+__code cbc_semacquire();
+__code cbc_semtryacquire();
+__code cbc_semrelease();
+__code cbc_getlockcondvar();
+__code cbc_condwait();
+__code cbc_condsignalone();
+__code cbc_condsignalall();
+__code cbc_queuepoll();
+__code cbc_setmultispec();
+__code cbc_ctxouterskipthunks();
+__code cbc_ctxcallerskipthunks();
+__code cbc_timer();
+__code cbc_cancel();
+__code cbc_signal();
+__code cbc_watchfile();
+__code cbc_asyncconnect();
+__code cbc_asynclisten();
+__code cbc_DEPRECATED_14();
+__code cbc_asyncwritebytes();
+__code cbc_DEPRECATED_16();
+__code cbc_asyncreadbytes();
+__code cbc_getlexstatic_o();
+__code cbc_getlexperinvtype_o();
+__code cbc_execname();
+__code cbc_const_i64_16();
+__code cbc_const_i64_32();
+__code cbc_isnonnull();
+__code cbc_param_rn2_i();
+__code cbc_param_rn2_n();
+__code cbc_param_rn2_s();
+__code cbc_param_rn2_o();
+__code cbc_param_on2_i();
+__code cbc_param_on2_n();
+__code cbc_param_on2_s();
+__code cbc_param_on2_o();
+__code cbc_osrpoint();
+__code cbc_nativecallcast();
+__code cbc_spawnprocasync();
+__code cbc_killprocasync();
+__code cbc_startprofile();
+__code cbc_endprofile();
+__code cbc_objectid();
+__code cbc_settypefinalize();
+__code cbc_force_gc();
+__code cbc_nativecallglobal();
+__code cbc_DEPRECATED_32();
+__code cbc_setparameterizer();
+__code cbc_parameterizetype();
+__code cbc_typeparameterized();
+__code cbc_typeparameters();
+__code cbc_typeparameterat();
+__code cbc_readlink();
+__code cbc_lstat();
+__code cbc_iscont_i();
+__code cbc_iscont_n();
+__code cbc_iscont_s();
+__code cbc_assign_i();
+__code cbc_assign_n();
+__code cbc_assign_s();
+__code cbc_decont_i();
+__code cbc_decont_n();
+__code cbc_decont_s();
+__code cbc_getrusage();
+__code cbc_threadlockcount();
+__code cbc_DEPRECATED_4();
+__code cbc_getlexref_i();
+__code cbc_getlexref_n();
+__code cbc_getlexref_s();
+__code cbc_getlexref_ni();
+__code cbc_getlexref_nn();
+__code cbc_getlexref_ns();
+__code cbc_atposref_i();
+__code cbc_atposref_n();
+__code cbc_atposref_s();
+__code cbc_getattrref_i();
+__code cbc_getattrref_n();
+__code cbc_getattrref_s();
+__code cbc_getattrsref_i();
+__code cbc_getattrsref_n();
+__code cbc_getattrsref_s();
+__code cbc_nativecallsizeof();
+__code cbc_encodenorm();
+__code cbc_normalizecodes();
+__code cbc_strfromcodes();
+__code cbc_strtocodes();
+__code cbc_getcodelocation();
+__code cbc_eqatim_s();
+__code cbc_ordbaseat();
+__code cbc_neverrepossess();
+__code cbc_scdisclaim();
+__code cbc_DEPRECATED_31();
+__code cbc_atpos2d_i();
+__code cbc_atpos2d_n();
+__code cbc_atpos2d_s();
+__code cbc_atpos2d_o();
+__code cbc_atpos3d_i();
+__code cbc_atpos3d_n();
+__code cbc_atpos3d_s();
+__code cbc_atpos3d_o();
+__code cbc_atposnd_i();
+__code cbc_atposnd_n();
+__code cbc_atposnd_s();
+__code cbc_atposnd_o();
+__code cbc_bindpos2d_i();
+__code cbc_bindpos2d_n();
+__code cbc_bindpos2d_s();
+__code cbc_bindpos2d_o();
+__code cbc_bindpos3d_i();
+__code cbc_bindpos3d_n();
+__code cbc_bindpos3d_s();
+__code cbc_bindpos3d_o();
+__code cbc_bindposnd_i();
+__code cbc_bindposnd_n();
+__code cbc_bindposnd_s();
+__code cbc_bindposnd_o();
+__code cbc_dimensions();
+__code cbc_setdimensions();
+__code cbc_numdimensions();
+__code cbc_ctxcode();
+__code cbc_isrwcont();
+__code cbc_fc();
+__code cbc_DEPRECATED_25();
+__code cbc_DEPRECATED_21();
+__code cbc_encoderep();
+__code cbc_istty_fh();
+__code cbc_multidimref_i();
+__code cbc_multidimref_n();
+__code cbc_multidimref_s();
+__code cbc_fileno_fh();
+__code cbc_asyncudp();
+__code cbc_DEPRECATED_15();
+__code cbc_asyncwritebytesto();
+__code cbc_objprimbits();
+__code cbc_objprimunsigned();
+__code cbc_DEPRECATED_5();
+__code cbc_DEPRECATED_6();
+__code cbc_DEPRECATED_7();
+__code cbc_DEPRECATED_8();
+__code cbc_getlexref_i32();
+__code cbc_getlexref_i16();
+__code cbc_getlexref_i8();
+__code cbc_getlexref_n32();
+__code cbc_box_u();
+__code cbc_unbox_u();
+__code cbc_coerce_iu();
+__code cbc_coerce_ui();
+__code cbc_coerce_nu();
+__code cbc_coerce_un();
+__code cbc_decont_u();
+__code cbc_DEPRECATED_9();
+__code cbc_DEPRECATED_10();
+__code cbc_DEPRECATED_11();
+__code cbc_DEPRECATED_12();
+__code cbc_getlexref_u();
+__code cbc_getlexref_u32();
+__code cbc_getlexref_u16();
+__code cbc_getlexref_u8();
+__code cbc_param_rp_u();
+__code cbc_param_op_u();
+__code cbc_param_rn_u();
+__code cbc_param_on_u();
+__code cbc_param_rn2_u();
+__code cbc_param_on2_u();
+__code cbc_stat_time();
+__code cbc_lstat_time();
+__code cbc_setdebugtypename();
+__code cbc_loadbytecodebuffer();
+__code cbc_loadbytecodefh();
+__code cbc_throwpayloadlex();
+__code cbc_throwpayloadlexcaller();
+__code cbc_lastexpayload();
+__code cbc_cancelnotify();
+__code cbc_decoderconfigure();
+__code cbc_decodersetlineseps();
+__code cbc_decoderaddbytes();
+__code cbc_decodertakechars();
+__code cbc_decodertakeallchars();
+__code cbc_decodertakeavailablechars();
+__code cbc_decodertakeline();
+__code cbc_decoderbytesavailable();
+__code cbc_decodertakebytes();
+__code cbc_decoderempty();
+__code cbc_indexingoptimized();
+__code cbc_captureinnerlex();
+__code cbc_unicmp_s();
+__code cbc_setdispatcherfor();
+__code cbc_getstrfromname();
+__code cbc_indexic_s();
+__code cbc_getport_sk();
+__code cbc_cpucores();
+__code cbc_eqaticim_s();
+__code cbc_indexicim_s();
+__code cbc_decodertakecharseof();
+__code cbc_indexim_s();
+__code cbc_cas_o();
+__code cbc_cas_i();
+__code cbc_atomicinc_i();
+__code cbc_atomicdec_i();
+__code cbc_atomicadd_i();
+__code cbc_atomicload_o();
+__code cbc_atomicload_i();
+__code cbc_atomicstore_o();
+__code cbc_atomicstore_i();
+__code cbc_barrierfull();
+__code cbc_coveragecontrol();
+__code cbc_nativeinvoke_v();
+__code cbc_nativeinvoke_i();
+__code cbc_nativeinvoke_n();
+__code cbc_nativeinvoke_s();
+__code cbc_nativeinvoke_o();
+__code cbc_getarg_i();
+__code cbc_getarg_n();
+__code cbc_getarg_s();
+__code cbc_getarg_o();
+__code cbc_coerce_II();
+__code cbc_encoderepconf();
+__code cbc_encodeconf();
+__code cbc_decodeconf();
+__code cbc_decoderepconf();
+__code cbc_getppid();
+__code cbc_getsignals();
+__code cbc_sp_guard();
+__code cbc_sp_guardconc();
+__code cbc_sp_guardtype();
+__code cbc_sp_guardsf();
+__code cbc_sp_guardsfouter();
+__code cbc_sp_rebless();
+__code cbc_sp_resolvecode();
+__code cbc_sp_decont();
+__code cbc_sp_getlex_o();
+__code cbc_sp_getlex_ins();
+__code cbc_sp_getlex_no();
+__code cbc_sp_getarg_o();
+__code cbc_sp_getarg_i();
+__code cbc_sp_getarg_n();
+__code cbc_sp_getarg_s();
+__code cbc_sp_fastinvoke_v();
+__code cbc_sp_fastinvoke_i();
+__code cbc_sp_fastinvoke_n();
+__code cbc_sp_fastinvoke_s();
+__code cbc_sp_fastinvoke_o();
+__code cbc_sp_paramnamesused();
+__code cbc_sp_getspeshslot();
+__code cbc_sp_findmeth();
+__code cbc_sp_fastcreate();
+__code cbc_sp_get_o();
+__code cbc_sp_get_i64();
+__code cbc_sp_get_i32();
+__code cbc_sp_get_i16();
+__code cbc_sp_get_i8();
+__code cbc_sp_get_n();
+__code cbc_sp_get_s();
+__code cbc_sp_bind_o();
+__code cbc_sp_bind_i64();
+__code cbc_sp_bind_i32();
+__code cbc_sp_bind_i16();
+__code cbc_sp_bind_i8();
+__code cbc_sp_bind_n();
+__code cbc_sp_bind_s();
+__code cbc_sp_p6oget_o();
+__code cbc_sp_p6ogetvt_o();
+__code cbc_sp_p6ogetvc_o();
+__code cbc_sp_p6oget_i();
+__code cbc_sp_p6oget_n();
+__code cbc_sp_p6oget_s();
+__code cbc_sp_p6obind_o();
+__code cbc_sp_p6obind_i();
+__code cbc_sp_p6obind_n();
+__code cbc_sp_p6obind_s();
+__code cbc_sp_deref_get_i64();
+__code cbc_sp_deref_get_n();
+__code cbc_sp_deref_bind_i64();
+__code cbc_sp_deref_bind_n();
+__code cbc_sp_getlexvia_o();
+__code cbc_sp_getlexvia_ins();
+__code cbc_sp_getstringfrom();
+__code cbc_sp_getwvalfrom();
+__code cbc_sp_jit_enter();
+__code cbc_sp_boolify_iter();
+__code cbc_sp_boolify_iter_arr();
+__code cbc_sp_boolify_iter_hash();
+__code cbc_sp_cas_o();
+__code cbc_sp_atomicload_o();
+__code cbc_sp_atomicstore_o();
+__code cbc_prof_enter();
+__code cbc_prof_enterspesh();
+__code cbc_prof_enterinline();
+__code cbc_prof_enternative();
+__code cbc_prof_exit();
+__code cbc_prof_allocated();
+__code cbc_ctw_check();
+__code cbc_coverage_log();
+__code cbc_breakpoint();
+
+__code (* CODES[])() = {
+   cbc_no_op,
+   cbc_const_i8,
+   cbc_const_i16,
+   cbc_const_i32,
+   cbc_const_i64,
+   cbc_const_n32,
+   cbc_const_n64,
+   cbc_const_s,
+   cbc_set,
+   cbc_extend_u8,
+   cbc_extend_u16,
+   cbc_extend_u32,
+   cbc_extend_i8,
+   cbc_extend_i16,
+   cbc_extend_i32,
+   cbc_trunc_u8,
+   cbc_trunc_u16,
+   cbc_trunc_u32,
+   cbc_trunc_i8,
+   cbc_trunc_i16,
+   cbc_trunc_i32,
+   cbc_extend_n32,
+   cbc_trunc_n32,
+   cbc_goto,
+   cbc_if_i,
+   cbc_unless_i,
+   cbc_if_n,
+   cbc_unless_n,
+   cbc_if_s,
+   cbc_unless_s,
+   cbc_if_s0,
+   cbc_unless_s0,
+   cbc_if_o,
+   cbc_unless_o,
+   cbc_jumplist,
+   cbc_getlex,
+   cbc_bindlex,
+   cbc_getlex_ni,
+   cbc_getlex_nn,
+   cbc_getlex_ns,
+   cbc_getlex_no,
+   cbc_bindlex_ni,
+   cbc_bindlex_nn,
+   cbc_bindlex_ns,
+   cbc_bindlex_no,
+   cbc_getlex_ng,
+   cbc_bindlex_ng,
+   cbc_getdynlex,
+   cbc_binddynlex,
+   cbc_setlexvalue,
+   cbc_lexprimspec,
+   cbc_return_i,
+   cbc_return_n,
+   cbc_return_s,
+   cbc_return_o,
+   cbc_return,
+   cbc_eq_i,
+   cbc_ne_i,
+   cbc_lt_i,
+   cbc_le_i,
+   cbc_gt_i,
+   cbc_ge_i,
+   cbc_cmp_i,
+   cbc_add_i,
+   cbc_sub_i,
+   cbc_mul_i,
+   cbc_div_i,
+   cbc_div_u,
+   cbc_mod_i,
+   cbc_mod_u,
+   cbc_neg_i,
+   cbc_abs_i,
+   cbc_inc_i,
+   cbc_inc_u,
+   cbc_dec_i,
+   cbc_dec_u,
+   cbc_band_i,
+   cbc_bor_i,
+   cbc_bxor_i,
+   cbc_bnot_i,
+   cbc_blshift_i,
+   cbc_brshift_i,
+   cbc_pow_i,
+   cbc_not_i,
+   cbc_gcd_i,
+   cbc_lcm_i,
+   cbc_eq_n,
+   cbc_ne_n,
+   cbc_lt_n,
+   cbc_le_n,
+   cbc_gt_n,
+   cbc_ge_n,
+   cbc_cmp_n,
+   cbc_add_n,
+   cbc_sub_n,
+   cbc_mul_n,
+   cbc_div_n,
+   cbc_mod_n,
+   cbc_neg_n,
+   cbc_abs_n,
+   cbc_pow_n,
+   cbc_ceil_n,
+   cbc_floor_n,
+   cbc_sin_n,
+   cbc_asin_n,
+   cbc_cos_n,
+   cbc_acos_n,
+   cbc_tan_n,
+   cbc_atan_n,
+   cbc_atan2_n,
+   cbc_sec_n,
+   cbc_asec_n,
+   cbc_sinh_n,
+   cbc_cosh_n,
+   cbc_tanh_n,
+   cbc_sech_n,
+   cbc_sqrt_n,
+   cbc_log_n,
+   cbc_exp_n,
+   cbc_coerce_in,
+   cbc_coerce_ni,
+   cbc_coerce_is,
+   cbc_coerce_ns,
+   cbc_coerce_si,
+   cbc_coerce_sn,
+   cbc_smrt_numify,
+   cbc_smrt_strify,
+   cbc_prepargs,
+   cbc_arg_i,
+   cbc_arg_n,
+   cbc_arg_s,
+   cbc_arg_o,
+   cbc_argconst_i,
+   cbc_argconst_n,
+   cbc_argconst_s,
+   cbc_invoke_v,
+   cbc_invoke_i,
+   cbc_invoke_n,
+   cbc_invoke_s,
+   cbc_invoke_o,
+   cbc_checkarity,
+   cbc_param_rp_i,
+   cbc_param_rp_n,
+   cbc_param_rp_s,
+   cbc_param_rp_o,
+   cbc_param_op_i,
+   cbc_param_op_n,
+   cbc_param_op_s,
+   cbc_param_op_o,
+   cbc_param_rn_i,
+   cbc_param_rn_n,
+   cbc_param_rn_s,
+   cbc_param_rn_o,
+   cbc_param_on_i,
+   cbc_param_on_n,
+   cbc_param_on_s,
+   cbc_param_on_o,
+   cbc_param_sp,
+   cbc_param_sn,
+   cbc_getcode,
+   cbc_caller,
+   cbc_capturelex,
+   cbc_takeclosure,
+   cbc_exception,
+   cbc_bindexmessage,
+   cbc_bindexpayload,
+   cbc_bindexcategory,
+   cbc_getexmessage,
+   cbc_getexpayload,
+   cbc_getexcategory,
+   cbc_throwdyn,
+   cbc_throwlex,
+   cbc_throwlexotic,
+   cbc_throwcatdyn,
+   cbc_throwcatlex,
+   cbc_throwcatlexotic,
+   cbc_die,
+   cbc_rethrow,
+   cbc_resume,
+   cbc_takehandlerresult,
+   cbc_DEPRECATED_33,
+   cbc_DEPRECATED_34,
+   cbc_backtracestrings,
+   cbc_usecapture,
+   cbc_savecapture,
+   cbc_captureposelems,
+   cbc_captureposarg,
+   cbc_captureposarg_i,
+   cbc_captureposarg_n,
+   cbc_captureposarg_s,
+   cbc_captureposprimspec,
+   cbc_captureexistsnamed,
+   cbc_capturehasnameds,
+   cbc_invokewithcapture,
+   cbc_multicacheadd,
+   cbc_multicachefind,
+   cbc_null_s,
+   cbc_isnull_s,
+   cbc_eq_s,
+   cbc_ne_s,
+   cbc_gt_s,
+   cbc_ge_s,
+   cbc_lt_s,
+   cbc_le_s,
+   cbc_cmp_s,
+   cbc_eqat_s,
+   cbc_eqatic_s,
+   cbc_haveat_s,
+   cbc_concat_s,
+   cbc_repeat_s,
+   cbc_substr_s,
+   cbc_index_s,
+   cbc_graphs_s,
+   cbc_codes_s,
+   cbc_getcp_s,
+   cbc_indexcp_s,
+   cbc_uc,
+   cbc_lc,
+   cbc_tc,
+   cbc_split,
+   cbc_join,
+   cbc_getcpbyname,
+   cbc_indexat,
+   cbc_indexnat,
+   cbc_unipropcode,
+   cbc_unipvalcode,
+   cbc_hasuniprop,
+   cbc_hasunipropc,
+   cbc_chars,
+   cbc_chr,
+   cbc_ordfirst,
+   cbc_ordat,
+   cbc_rindexfrom,
+   cbc_escape,
+   cbc_flip,
+   cbc_setbuffersize_fh,
+   cbc_iscclass,
+   cbc_findcclass,
+   cbc_findnotcclass,
+   cbc_nfafromstatelist,
+   cbc_nfarunproto,
+   cbc_nfarunalt,
+   cbc_radix,
+   cbc_encode,
+   cbc_decode,
+   cbc_istrue_s,
+   cbc_isfalse_s,
+   cbc_null,
+   cbc_isnull,
+   cbc_ifnonnull,
+   cbc_findmeth,
+   cbc_findmeth_s,
+   cbc_can,
+   cbc_can_s,
+   cbc_create,
+   cbc_clone,
+   cbc_isconcrete,
+   cbc_rebless,
+   cbc_istype,
+   cbc_objprimspec,
+   cbc_gethow,
+   cbc_getwhat,
+   cbc_getwho,
+   cbc_setwho,
+   cbc_reprname,
+   cbc_getwhere,
+   cbc_eqaddr,
+   cbc_bindattr_i,
+   cbc_bindattr_n,
+   cbc_bindattr_s,
+   cbc_bindattr_o,
+   cbc_bindattrs_i,
+   cbc_bindattrs_n,
+   cbc_bindattrs_s,
+   cbc_bindattrs_o,
+   cbc_getattr_i,
+   cbc_getattr_n,
+   cbc_getattr_s,
+   cbc_getattr_o,
+   cbc_getattrs_i,
+   cbc_getattrs_n,
+   cbc_getattrs_s,
+   cbc_getattrs_o,
+   cbc_attrinited,
+   cbc_box_i,
+   cbc_box_n,
+   cbc_box_s,
+   cbc_unbox_i,
+   cbc_unbox_n,
+   cbc_unbox_s,
+   cbc_atpos_i,
+   cbc_atpos_n,
+   cbc_atpos_s,
+   cbc_atpos_o,
+   cbc_bindpos_i,
+   cbc_bindpos_n,
+   cbc_bindpos_s,
+   cbc_bindpos_o,
+   cbc_push_i,
+   cbc_push_n,
+   cbc_push_s,
+   cbc_push_o,
+   cbc_pop_i,
+   cbc_pop_n,
+   cbc_pop_s,
+   cbc_pop_o,
+   cbc_shift_i,
+   cbc_shift_n,
+   cbc_shift_s,
+   cbc_shift_o,
+   cbc_unshift_i,
+   cbc_unshift_n,
+   cbc_unshift_s,
+   cbc_unshift_o,
+   cbc_splice,
+   cbc_setelemspos,
+   cbc_existspos,
+   cbc_atkey_i,
+   cbc_atkey_n,
+   cbc_atkey_s,
+   cbc_atkey_o,
+   cbc_bindkey_i,
+   cbc_bindkey_n,
+   cbc_bindkey_s,
+   cbc_bindkey_o,
+   cbc_existskey,
+   cbc_deletekey,
+   cbc_elems,
+   cbc_knowhow,
+   cbc_knowhowattr,
+   cbc_newtype,
+   cbc_composetype,
+   cbc_setmethcache,
+   cbc_setmethcacheauth,
+   cbc_settypecache,
+   cbc_settypecheckmode,
+   cbc_setboolspec,
+   cbc_istrue,
+   cbc_isfalse,
+   cbc_bootint,
+   cbc_bootnum,
+   cbc_bootstr,
+   cbc_bootarray,
+   cbc_bootintarray,
+   cbc_bootnumarray,
+   cbc_bootstrarray,
+   cbc_boothash,
+   cbc_isint,
+   cbc_isnum,
+   cbc_isstr,
+   cbc_islist,
+   cbc_ishash,
+   cbc_sethllconfig,
+   cbc_hllboxtype_i,
+   cbc_hllboxtype_n,
+   cbc_hllboxtype_s,
+   cbc_hlllist,
+   cbc_hllhash,
+   cbc_getcomp,
+   cbc_bindcomp,
+   cbc_getcurhllsym,
+   cbc_bindcurhllsym,
+   cbc_gethllsym,
+   cbc_bindhllsym,
+   cbc_settypehll,
+   cbc_settypehllrole,
+   cbc_hllize,
+   cbc_hllizefor,
+   cbc_usecompileehllconfig,
+   cbc_usecompilerhllconfig,
+   cbc_iter,
+   cbc_iterkey_s,
+   cbc_iterval,
+   cbc_getcodename,
+   cbc_iscoderef,
+   cbc_getcodeobj,
+   cbc_setcodeobj,
+   cbc_setcodename,
+   cbc_forceouterctx,
+   cbc_setinvokespec,
+   cbc_isinvokable,
+   cbc_freshcoderef,
+   cbc_markcodestatic,
+   cbc_markcodestub,
+   cbc_getstaticcode,
+   cbc_getcodecuid,
+   cbc_setdispatcher,
+   cbc_takedispatcher,
+   cbc_assign,
+   cbc_assignunchecked,
+   cbc_iscont,
+   cbc_decont,
+   cbc_setcontspec,
+   cbc_sha1,
+   cbc_createsc,
+   cbc_scsetobj,
+   cbc_scsetcode,
+   cbc_scgetobj,
+   cbc_scgethandle,
+   cbc_scgetobjidx,
+   cbc_scsetdesc,
+   cbc_scobjcount,
+   cbc_setobjsc,
+   cbc_getobjsc,
+   cbc_serialize,
+   cbc_deserialize,
+   cbc_wval,
+   cbc_wval_wide,
+   cbc_scwbdisable,
+   cbc_scwbenable,
+   cbc_pushcompsc,
+   cbc_popcompsc,
+   cbc_scgetdesc,
+   cbc_loadbytecode,
+   cbc_masttofile,
+   cbc_masttocu,
+   cbc_iscompunit,
+   cbc_compunitmainline,
+   cbc_compunitcodes,
+   cbc_ctx,
+   cbc_ctxouter,
+   cbc_ctxcaller,
+   cbc_ctxlexpad,
+   cbc_curcode,
+   cbc_callercode,
+   cbc_add_I,
+   cbc_sub_I,
+   cbc_mul_I,
+   cbc_div_I,
+   cbc_mod_I,
+   cbc_neg_I,
+   cbc_abs_I,
+   cbc_cmp_I,
+   cbc_eq_I,
+   cbc_ne_I,
+   cbc_lt_I,
+   cbc_le_I,
+   cbc_gt_I,
+   cbc_ge_I,
+   cbc_bor_I,
+   cbc_bxor_I,
+   cbc_band_I,
+   cbc_bnot_I,
+   cbc_blshift_I,
+   cbc_brshift_I,
+   cbc_pow_I,
+   cbc_gcd_I,
+   cbc_lcm_I,
+   cbc_expmod_I,
+   cbc_isprime_I,
+   cbc_rand_I,
+   cbc_coerce_In,
+   cbc_coerce_Is,
+   cbc_coerce_nI,
+   cbc_coerce_sI,
+   cbc_isbig_I,
+   cbc_bool_I,
+   cbc_base_I,
+   cbc_radix_I,
+   cbc_div_In,
+   cbc_copy_f,
+   cbc_append_f,
+   cbc_rename_f,
+   cbc_delete_f,
+   cbc_chmod_f,
+   cbc_exists_f,
+   cbc_mkdir,
+   cbc_rmdir,
+   cbc_open_dir,
+   cbc_read_dir,
+   cbc_close_dir,
+   cbc_open_fh,
+   cbc_close_fh,
+   cbc_DEPRECATED_23,
+   cbc_DEPRECATED_27,
+   cbc_DEPRECATED_28,
+   cbc_DEPRECATED_18,
+   cbc_seek_fh,
+   cbc_lock_fh,
+   cbc_unlock_fh,
+   cbc_sync_fh,
+   cbc_trunc_fh,
+   cbc_eof_fh,
+   cbc_getstdin,
+   cbc_getstdout,
+   cbc_getstderr,
+   cbc_connect_sk,
+   cbc_socket,
+   cbc_bind_sk,
+   cbc_DEPRECATED_24,
+   cbc_accept_sk,
+   cbc_decodetocodes,
+   cbc_encodefromcodes,
+   cbc_DEPRECATED_17,
+   cbc_print,
+   cbc_say,
+   cbc_DEPRECATED_22,
+   cbc_tell_fh,
+   cbc_stat,
+   cbc_tryfindmeth,
+   cbc_tryfindmeth_s,
+   cbc_chdir,
+   cbc_srand,
+   cbc_rand_i,
+   cbc_rand_n,
+   cbc_time_i,
+   cbc_sleep,
+   cbc_newthread,
+   cbc_threadjoin,
+   cbc_time_n,
+   cbc_exit,
+   cbc_DEPRECATED_30,
+   cbc_cwd,
+   cbc_clargs,
+   cbc_getenvhash,
+   cbc_loadlib,
+   cbc_freelib,
+   cbc_findsym,
+   cbc_dropsym,
+   cbc_loadext,
+   cbc_backendconfig,
+   cbc_getlexouter,
+   cbc_getlexrel,
+   cbc_getlexreldyn,
+   cbc_getlexrelcaller,
+   cbc_getlexcaller,
+   cbc_bitand_s,
+   cbc_bitor_s,
+   cbc_bitxor_s,
+   cbc_isnanorinf,
+   cbc_inf,
+   cbc_neginf,
+   cbc_nan,
+   cbc_getpid,
+   cbc_DEPRECATED_29,
+   cbc_filereadable,
+   cbc_filewritable,
+   cbc_fileexecutable,
+   cbc_DEPRECATED_19,
+   cbc_capturenamedshash,
+   cbc_read_fhb,
+   cbc_write_fhb,
+   cbc_replace,
+   cbc_newexception,
+   cbc_permit,
+   cbc_backtrace,
+   cbc_symlink,
+   cbc_link,
+   cbc_gethostname,
+   cbc_exreturnafterunwind,
+   cbc_DEPRECATED_13,
+   cbc_continuationreset,
+   cbc_continuationcontrol,
+   cbc_continuationinvoke,
+   cbc_randscale_n,
+   cbc_uniisblock,
+   cbc_assertparamcheck,
+   cbc_hintfor,
+   cbc_paramnamesused,
+   cbc_getuniname,
+   cbc_getuniprop_int,
+   cbc_getuniprop_bool,
+   cbc_getuniprop_str,
+   cbc_matchuniprop,
+   cbc_nativecallbuild,
+   cbc_nativecallinvoke,
+   cbc_nativecallrefresh,
+   cbc_threadrun,
+   cbc_threadid,
+   cbc_threadyield,
+   cbc_currentthread,
+   cbc_lock,
+   cbc_unlock,
+   cbc_semacquire,
+   cbc_semtryacquire,
+   cbc_semrelease,
+   cbc_getlockcondvar,
+   cbc_condwait,
+   cbc_condsignalone,
+   cbc_condsignalall,
+   cbc_queuepoll,
+   cbc_setmultispec,
+   cbc_ctxouterskipthunks,
+   cbc_ctxcallerskipthunks,
+   cbc_timer,
+   cbc_cancel,
+   cbc_signal,
+   cbc_watchfile,
+   cbc_asyncconnect,
+   cbc_asynclisten,
+   cbc_DEPRECATED_14,
+   cbc_asyncwritebytes,
+   cbc_DEPRECATED_16,
+   cbc_asyncreadbytes,
+   cbc_getlexstatic_o,
+   cbc_getlexperinvtype_o,
+   cbc_execname,
+   cbc_const_i64_16,
+   cbc_const_i64_32,
+   cbc_isnonnull,
+   cbc_param_rn2_i,
+   cbc_param_rn2_n,
+   cbc_param_rn2_s,
+   cbc_param_rn2_o,
+   cbc_param_on2_i,
+   cbc_param_on2_n,
+   cbc_param_on2_s,
+   cbc_param_on2_o,
+   cbc_osrpoint,
+   cbc_nativecallcast,
+   cbc_spawnprocasync,
+   cbc_killprocasync,
+   cbc_startprofile,
+   cbc_endprofile,
+   cbc_objectid,
+   cbc_settypefinalize,
+   cbc_force_gc,
+   cbc_nativecallglobal,
+   cbc_DEPRECATED_32,
+   cbc_setparameterizer,
+   cbc_parameterizetype,
+   cbc_typeparameterized,
+   cbc_typeparameters,
+   cbc_typeparameterat,
+   cbc_readlink,
+   cbc_lstat,
+   cbc_iscont_i,
+   cbc_iscont_n,
+   cbc_iscont_s,
+   cbc_assign_i,
+   cbc_assign_n,
+   cbc_assign_s,
+   cbc_decont_i,
+   cbc_decont_n,
+   cbc_decont_s,
+   cbc_getrusage,
+   cbc_threadlockcount,
+   cbc_DEPRECATED_4,
+   cbc_getlexref_i,
+   cbc_getlexref_n,
+   cbc_getlexref_s,
+   cbc_getlexref_ni,
+   cbc_getlexref_nn,
+   cbc_getlexref_ns,
+   cbc_atposref_i,
+   cbc_atposref_n,
+   cbc_atposref_s,
+   cbc_getattrref_i,
+   cbc_getattrref_n,
+   cbc_getattrref_s,
+   cbc_getattrsref_i,
+   cbc_getattrsref_n,
+   cbc_getattrsref_s,
+   cbc_nativecallsizeof,
+   cbc_encodenorm,
+   cbc_normalizecodes,
+   cbc_strfromcodes,
+   cbc_strtocodes,
+   cbc_getcodelocation,
+   cbc_eqatim_s,
+   cbc_ordbaseat,
+   cbc_neverrepossess,
+   cbc_scdisclaim,
+   cbc_DEPRECATED_31,
+   cbc_atpos2d_i,
+   cbc_atpos2d_n,
+   cbc_atpos2d_s,
+   cbc_atpos2d_o,
+   cbc_atpos3d_i,
+   cbc_atpos3d_n,
+   cbc_atpos3d_s,
+   cbc_atpos3d_o,
+   cbc_atposnd_i,
+   cbc_atposnd_n,
+   cbc_atposnd_s,
+   cbc_atposnd_o,
+   cbc_bindpos2d_i,
+   cbc_bindpos2d_n,
+   cbc_bindpos2d_s,
+   cbc_bindpos2d_o,
+   cbc_bindpos3d_i,
+   cbc_bindpos3d_n,
+   cbc_bindpos3d_s,
+   cbc_bindpos3d_o,
+   cbc_bindposnd_i,
+   cbc_bindposnd_n,
+   cbc_bindposnd_s,
+   cbc_bindposnd_o,
+   cbc_dimensions,
+   cbc_setdimensions,
+   cbc_numdimensions,
+   cbc_ctxcode,
+   cbc_isrwcont,
+   cbc_fc,
+   cbc_DEPRECATED_25,
+   cbc_DEPRECATED_21,
+   cbc_encoderep,
+   cbc_istty_fh,
+   cbc_multidimref_i,
+   cbc_multidimref_n,
+   cbc_multidimref_s,
+   cbc_fileno_fh,
+   cbc_asyncudp,
+   cbc_DEPRECATED_15,
+   cbc_asyncwritebytesto,
+   cbc_objprimbits,
+   cbc_objprimunsigned,
+   cbc_DEPRECATED_5,
+   cbc_DEPRECATED_6,
+   cbc_DEPRECATED_7,
+   cbc_DEPRECATED_8,
+   cbc_getlexref_i32,
+   cbc_getlexref_i16,
+   cbc_getlexref_i8,
+   cbc_getlexref_n32,
+   cbc_box_u,
+   cbc_unbox_u,
+   cbc_coerce_iu,
+   cbc_coerce_ui,
+   cbc_coerce_nu,
+   cbc_coerce_un,
+   cbc_decont_u,
+   cbc_DEPRECATED_9,
+   cbc_DEPRECATED_10,
+   cbc_DEPRECATED_11,
+   cbc_DEPRECATED_12,
+   cbc_getlexref_u,
+   cbc_getlexref_u32,
+   cbc_getlexref_u16,
+   cbc_getlexref_u8,
+   cbc_param_rp_u,
+   cbc_param_op_u,
+   cbc_param_rn_u,
+   cbc_param_on_u,
+   cbc_param_rn2_u,
+   cbc_param_on2_u,
+   cbc_stat_time,
+   cbc_lstat_time,
+   cbc_setdebugtypename,
+   cbc_loadbytecodebuffer,
+   cbc_loadbytecodefh,
+   cbc_throwpayloadlex,
+   cbc_throwpayloadlexcaller,
+   cbc_lastexpayload,
+   cbc_cancelnotify,
+   cbc_decoderconfigure,
+   cbc_decodersetlineseps,
+   cbc_decoderaddbytes,
+   cbc_decodertakechars,
+   cbc_decodertakeallchars,
+   cbc_decodertakeavailablechars,
+   cbc_decodertakeline,
+   cbc_decoderbytesavailable,
+   cbc_decodertakebytes,
+   cbc_decoderempty,
+   cbc_indexingoptimized,
+   cbc_captureinnerlex,
+   cbc_unicmp_s,
+   cbc_setdispatcherfor,
+   cbc_getstrfromname,
+   cbc_indexic_s,
+   cbc_getport_sk,
+   cbc_cpucores,
+   cbc_eqaticim_s,
+   cbc_indexicim_s,
+   cbc_decodertakecharseof,
+   cbc_indexim_s,
+   cbc_cas_o,
+   cbc_cas_i,
+   cbc_atomicinc_i,
+   cbc_atomicdec_i,
+   cbc_atomicadd_i,
+   cbc_atomicload_o,
+   cbc_atomicload_i,
+   cbc_atomicstore_o,
+   cbc_atomicstore_i,
+   cbc_barrierfull,
+   cbc_coveragecontrol,
+   cbc_nativeinvoke_v,
+   cbc_nativeinvoke_i,
+   cbc_nativeinvoke_n,
+   cbc_nativeinvoke_s,
+   cbc_nativeinvoke_o,
+   cbc_getarg_i,
+   cbc_getarg_n,
+   cbc_getarg_s,
+   cbc_getarg_o,
+   cbc_coerce_II,
+   cbc_encoderepconf,
+   cbc_encodeconf,
+   cbc_decodeconf,
+   cbc_decoderepconf,
+   cbc_getppid,
+   cbc_getsignals,
+   cbc_sp_guard,
+   cbc_sp_guardconc,
+   cbc_sp_guardtype,
+   cbc_sp_guardsf,
+   cbc_sp_guardsfouter,
+   cbc_sp_rebless,
+   cbc_sp_resolvecode,
+   cbc_sp_decont,
+   cbc_sp_getlex_o,
+   cbc_sp_getlex_ins,
+   cbc_sp_getlex_no,
+   cbc_sp_getarg_o,
+   cbc_sp_getarg_i,
+   cbc_sp_getarg_n,
+   cbc_sp_getarg_s,
+   cbc_sp_fastinvoke_v,
+   cbc_sp_fastinvoke_i,
+   cbc_sp_fastinvoke_n,
+   cbc_sp_fastinvoke_s,
+   cbc_sp_fastinvoke_o,
+   cbc_sp_paramnamesused,
+   cbc_sp_getspeshslot,
+   cbc_sp_findmeth,
+   cbc_sp_fastcreate,
+   cbc_sp_get_o,
+   cbc_sp_get_i64,
+   cbc_sp_get_i32,
+   cbc_sp_get_i16,
+   cbc_sp_get_i8,
+   cbc_sp_get_n,
+   cbc_sp_get_s,
+   cbc_sp_bind_o,
+   cbc_sp_bind_i64,
+   cbc_sp_bind_i32,
+   cbc_sp_bind_i16,
+   cbc_sp_bind_i8,
+   cbc_sp_bind_n,
+   cbc_sp_bind_s,
+   cbc_sp_p6oget_o,
+   cbc_sp_p6ogetvt_o,
+   cbc_sp_p6ogetvc_o,
+   cbc_sp_p6oget_i,
+   cbc_sp_p6oget_n,
+   cbc_sp_p6oget_s,
+   cbc_sp_p6obind_o,
+   cbc_sp_p6obind_i,
+   cbc_sp_p6obind_n,
+   cbc_sp_p6obind_s,
+   cbc_sp_deref_get_i64,
+   cbc_sp_deref_get_n,
+   cbc_sp_deref_bind_i64,
+   cbc_sp_deref_bind_n,
+   cbc_sp_getlexvia_o,
+   cbc_sp_getlexvia_ins,
+   cbc_sp_getstringfrom,
+   cbc_sp_getwvalfrom,
+   cbc_sp_jit_enter,
+   cbc_sp_boolify_iter,
+   cbc_sp_boolify_iter_arr,
+   cbc_sp_boolify_iter_hash,
+   cbc_sp_cas_o,
+   cbc_sp_atomicload_o,
+   cbc_sp_atomicstore_o,
+   cbc_prof_enter,
+   cbc_prof_enterspesh,
+   cbc_prof_enterinline,
+   cbc_prof_enternative,
+   cbc_prof_exit,
+   cbc_prof_allocated,
+   cbc_ctw_check,
+   cbc_coverage_log,
+   cbc_breakpoint,
+};