# HG changeset patch # User Takahiro SHIMIZU # Date 1539838911 -32400 # Node ID 5dad2b2a4da3da17423ebdc19f3b42a3846a548c # Parent e8ab4ff0220799a4997bf9057760d207e092698e fix INTERP instance values and add __CODES array diff -r e8ab4ff02207 -r 5dad2b2a4da3 cbctools/change_OPS_h_to_cbc.pl --- 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"; diff -r e8ab4ff02207 -r 5dad2b2a4da3 src/core/cbc-interp.cbc --- 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 = ®_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) 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() { diff -r e8ab4ff02207 -r 5dad2b2a4da3 src/core/oplables-cbc-codes.h --- /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, +};