From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/vm.inc | 3353 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3353 insertions(+) create mode 100644 jni/ruby/vm.inc (limited to 'jni/ruby/vm.inc') diff --git a/jni/ruby/vm.inc b/jni/ruby/vm.inc new file mode 100644 index 0000000..ddfaedb --- /dev/null +++ b/jni/ruby/vm.inc @@ -0,0 +1,3353 @@ +/* -*-c-*- *********************************************************/ +/*******************************************************************/ +/*******************************************************************/ +/** + This file is VM main loop. + + ---- + This file is auto generated by insns2vm.rb + DO NOT TOUCH! + + If you want to fix something, you must edit 'insns.def' + */ + + +INSN_ENTRY(nop){ +{ + + + DEBUG_ENTER_INSN("nop"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_nop 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_nop_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(nop)); +{ +#line 40 "insns.def" + /* none */ + +#line 32 "vm.inc" +#undef CURRENT_INSN_nop +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(nop);}}} +INSN_ENTRY(getlocal){ +{ + VALUE val; + rb_num_t level = (rb_num_t)GET_OPERAND(2); + lindex_t idx = (lindex_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getlocal"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getlocal 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getlocal_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getlocal)); + COLLECT_USAGE_OPERAND(BIN(getlocal), 0, idx); + COLLECT_USAGE_OPERAND(BIN(getlocal), 1, level); +{ +#line 60 "insns.def" + int i, lev = (int)level; + VALUE *ep = GET_EP(); + + /* optimized insns generated for level == (0|1) in defs/opt_operand.def */ + for (i = 0; i < lev; i++) { + ep = GET_PREV_EP(ep); + } + val = *(ep - idx); + +#line 65 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getlocal +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getlocal);}}} +INSN_ENTRY(setlocal){ +{ + rb_num_t level = (rb_num_t)GET_OPERAND(2); + lindex_t idx = (lindex_t)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setlocal"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setlocal 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setlocal_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setlocal)); + COLLECT_USAGE_OPERAND(BIN(setlocal), 0, idx); + COLLECT_USAGE_OPERAND(BIN(setlocal), 1, level); +{ +#line 83 "insns.def" + int i, lev = (int)level; + VALUE *ep = GET_EP(); + + /* optimized insns generated for level == (0|1) in defs/opt_operand.def */ + for (i = 0; i < lev; i++) { + ep = GET_PREV_EP(ep); + } + *(ep - idx) = val; + +#line 100 "vm.inc" +#undef CURRENT_INSN_setlocal +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setlocal);}}} +INSN_ENTRY(getspecial){ +{ + VALUE val; + rb_num_t type = (rb_num_t)GET_OPERAND(2); + rb_num_t key = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getspecial"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getspecial 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getspecial_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getspecial)); + COLLECT_USAGE_OPERAND(BIN(getspecial), 0, key); + COLLECT_USAGE_OPERAND(BIN(getspecial), 1, type); +{ +#line 104 "insns.def" + val = vm_getspecial(th, GET_LEP(), key, type); + +#line 126 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getspecial +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getspecial);}}} +INSN_ENTRY(setspecial){ +{ + rb_num_t key = (rb_num_t)GET_OPERAND(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("setspecial"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setspecial 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setspecial_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setspecial)); + COLLECT_USAGE_OPERAND(BIN(setspecial), 0, key); +{ +#line 118 "insns.def" + lep_svar_set(th, GET_LEP(), key, obj); + +#line 152 "vm.inc" +#undef CURRENT_INSN_setspecial +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setspecial);}}} +INSN_ENTRY(getinstancevariable){ +{ + VALUE val; + IC ic = (IC)GET_OPERAND(2); + ID id = (ID)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getinstancevariable"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getinstancevariable 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getinstancevariable_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getinstancevariable)); + COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 0, id); + COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 1, ic); +{ +#line 133 "insns.def" + val = vm_getinstancevariable(GET_SELF(), id, ic); + +#line 178 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getinstancevariable +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getinstancevariable);}}} +INSN_ENTRY(setinstancevariable){ +{ + IC ic = (IC)GET_OPERAND(2); + ID id = (ID)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setinstancevariable"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setinstancevariable 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setinstancevariable_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setinstancevariable)); + COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 0, id); + COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 1, ic); +{ +#line 148 "insns.def" + vm_setinstancevariable(GET_SELF(), id, val, ic); + +#line 206 "vm.inc" +#undef CURRENT_INSN_setinstancevariable +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setinstancevariable);}}} +INSN_ENTRY(getclassvariable){ +{ + VALUE val; + ID id = (ID)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getclassvariable"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getclassvariable 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getclassvariable_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getclassvariable)); + COLLECT_USAGE_OPERAND(BIN(getclassvariable), 0, id); +{ +#line 162 "insns.def" + NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP()); + val = rb_cvar_get(vm_get_cvar_base(cref, GET_CFP()), id); + +#line 231 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getclassvariable +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getclassvariable);}}} +INSN_ENTRY(setclassvariable){ +{ + ID id = (ID)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setclassvariable"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setclassvariable 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setclassvariable_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setclassvariable)); + COLLECT_USAGE_OPERAND(BIN(setclassvariable), 0, id); +{ +#line 177 "insns.def" + NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP()); + rb_cvar_set(vm_get_cvar_base(cref, GET_CFP()), id, val); + +#line 258 "vm.inc" +#undef CURRENT_INSN_setclassvariable +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setclassvariable);}}} +INSN_ENTRY(getconstant){ +{ + VALUE val; + ID id = (ID)GET_OPERAND(1); + VALUE klass = TOPN(0); + DEBUG_ENTER_INSN("getconstant"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_getconstant 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getconstant_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getconstant)); + COLLECT_USAGE_OPERAND(BIN(getconstant), 0, id); +{ +#line 199 "insns.def" + val = vm_get_ev_const(th, GET_ISEQ(), klass, id, 0); + +#line 283 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getconstant +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getconstant);}}} +INSN_ENTRY(setconstant){ +{ + ID id = (ID)GET_OPERAND(1); + VALUE val = TOPN(1); + VALUE cbase = TOPN(0); + DEBUG_ENTER_INSN("setconstant"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_setconstant 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setconstant_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setconstant)); + COLLECT_USAGE_OPERAND(BIN(setconstant), 0, id); +{ +#line 221 "insns.def" + vm_check_if_namespace(cbase); + rb_const_set(cbase, id, val); + +#line 311 "vm.inc" +#undef CURRENT_INSN_setconstant +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setconstant);}}} +INSN_ENTRY(getglobal){ +{ + VALUE val; + GENTRY entry = (GENTRY)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getglobal"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getglobal 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getglobal_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getglobal)); + COLLECT_USAGE_OPERAND(BIN(getglobal), 0, entry); +{ +#line 236 "insns.def" + val = GET_GLOBAL((VALUE)entry); + +#line 335 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getglobal +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getglobal);}}} +INSN_ENTRY(setglobal){ +{ + GENTRY entry = (GENTRY)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setglobal"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setglobal 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setglobal_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setglobal)); + COLLECT_USAGE_OPERAND(BIN(setglobal), 0, entry); +{ +#line 250 "insns.def" + SET_GLOBAL((VALUE)entry, val); + +#line 361 "vm.inc" +#undef CURRENT_INSN_setglobal +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setglobal);}}} +INSN_ENTRY(putnil){ +{ + VALUE val; + + + DEBUG_ENTER_INSN("putnil"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putnil 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putnil_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putnil)); +{ +#line 269 "insns.def" + val = Qnil; + +#line 384 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_putnil +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putnil);}}} +INSN_ENTRY(putself){ +{ + VALUE val; + + + DEBUG_ENTER_INSN("putself"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putself 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putself_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putself)); +{ +#line 283 "insns.def" + val = GET_SELF(); + +#line 409 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_putself +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putself);}}} +INSN_ENTRY(putobject){ +{ + VALUE val = (VALUE)GET_OPERAND(1); + + DEBUG_ENTER_INSN("putobject"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putobject 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putobject_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putobject)); + COLLECT_USAGE_OPERAND(BIN(putobject), 0, val); +{ +#line 299 "insns.def" + /* */ + +#line 434 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_putobject +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putobject);}}} +INSN_ENTRY(putspecialobject){ +{ + VALUE val; + rb_num_t value_type = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("putspecialobject"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putspecialobject 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putspecialobject_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putspecialobject)); + COLLECT_USAGE_OPERAND(BIN(putspecialobject), 0, value_type); +{ +#line 314 "insns.def" + enum vm_special_object_type type = (enum vm_special_object_type)value_type; + + switch (type) { + case VM_SPECIAL_OBJECT_VMCORE: + val = rb_mRubyVMFrozenCore; + break; + case VM_SPECIAL_OBJECT_CBASE: + val = vm_get_cbase(GET_ISEQ(), GET_EP()); + break; + case VM_SPECIAL_OBJECT_CONST_BASE: + val = vm_get_const_base(GET_ISEQ(), GET_EP()); + break; + default: + rb_bug("putspecialobject insn: unknown value_type"); + } + +#line 474 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_putspecialobject +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putspecialobject);}}} +INSN_ENTRY(putiseq){ +{ + VALUE ret; + ISEQ iseq = (ISEQ)GET_OPERAND(1); + + DEBUG_ENTER_INSN("putiseq"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putiseq 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putiseq_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putiseq)); + COLLECT_USAGE_OPERAND(BIN(putiseq), 0, iseq); +{ +#line 342 "insns.def" + ret = iseq->self; + +#line 500 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(ret); +#undef CURRENT_INSN_putiseq +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putiseq);}}} +INSN_ENTRY(putstring){ +{ + VALUE val; + VALUE str = (VALUE)GET_OPERAND(1); + + DEBUG_ENTER_INSN("putstring"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putstring 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putstring_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putstring)); + COLLECT_USAGE_OPERAND(BIN(putstring), 0, str); +{ +#line 356 "insns.def" + val = rb_str_resurrect(str); + +#line 526 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_putstring +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putstring);}}} +INSN_ENTRY(concatstrings){ +{ + VALUE val; + rb_num_t num = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("concatstrings"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_concatstrings 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_concatstrings_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(concatstrings)); + COLLECT_USAGE_OPERAND(BIN(concatstrings), 0, num); +{ +#line 370 "insns.def" + rb_num_t i = num - 1; + + val = rb_str_resurrect(TOPN(i)); + while (i-- > 0) { + const VALUE v = TOPN(i); + rb_str_append(val, v); + } + POPN(num); + +#line 559 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_concatstrings +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(concatstrings);}}} +INSN_ENTRY(tostring){ +{ + + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("tostring"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_tostring 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_tostring_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(tostring)); +{ +#line 391 "insns.def" + val = rb_obj_as_string(val); + +#line 584 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_tostring +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(tostring);}}} +INSN_ENTRY(toregexp){ +{ + VALUE val; + rb_num_t cnt = (rb_num_t)GET_OPERAND(2); + rb_num_t opt = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("toregexp"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_toregexp 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_toregexp_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(toregexp)); + COLLECT_USAGE_OPERAND(BIN(toregexp), 0, opt); + COLLECT_USAGE_OPERAND(BIN(toregexp), 1, cnt); +{ +#line 406 "insns.def" + VALUE rb_reg_new_ary(VALUE ary, int options); + rb_num_t i; + const VALUE ary = rb_ary_tmp_new(cnt); + for (i = 0; i < cnt; i++) { + rb_ary_store(ary, cnt-i-1, TOPN(i)); + } + POPN(cnt); + val = rb_reg_new_ary(ary, (int)opt); + rb_ary_clear(ary); + +#line 620 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_toregexp +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(toregexp);}}} +INSN_ENTRY(newarray){ +{ + VALUE val; + rb_num_t num = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("newarray"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_newarray 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_newarray_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(newarray)); + COLLECT_USAGE_OPERAND(BIN(newarray), 0, num); +{ +#line 428 "insns.def" + val = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num)); + POPN(num); + +#line 647 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_newarray +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(newarray);}}} +INSN_ENTRY(duparray){ +{ + VALUE val; + VALUE ary = (VALUE)GET_OPERAND(1); + + DEBUG_ENTER_INSN("duparray"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_duparray 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_duparray_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(duparray)); + COLLECT_USAGE_OPERAND(BIN(duparray), 0, ary); +{ +#line 443 "insns.def" + val = rb_ary_resurrect(ary); + +#line 673 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_duparray +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(duparray);}}} +INSN_ENTRY(expandarray){ +{ + rb_num_t flag = (rb_num_t)GET_OPERAND(2); + rb_num_t num = (rb_num_t)GET_OPERAND(1); + VALUE ary = TOPN(0); + DEBUG_ENTER_INSN("expandarray"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_expandarray 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_expandarray_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(expandarray)); + COLLECT_USAGE_OPERAND(BIN(expandarray), 0, num); + COLLECT_USAGE_OPERAND(BIN(expandarray), 1, flag); +{ +#line 464 "insns.def" + vm_expandarray(GET_CFP(), ary, num, (int)flag); + +#line 701 "vm.inc" +#undef CURRENT_INSN_expandarray +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(expandarray);}}} +INSN_ENTRY(concatarray){ +{ + VALUE ary; + + VALUE ary1 = TOPN(1); + VALUE ary2st = TOPN(0); + DEBUG_ENTER_INSN("concatarray"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_concatarray 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_concatarray_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(concatarray)); +{ +#line 478 "insns.def" + const VALUE ary2 = ary2st; + VALUE tmp1 = rb_check_convert_type(ary1, T_ARRAY, "Array", "to_a"); + VALUE tmp2 = rb_check_convert_type(ary2, T_ARRAY, "Array", "to_a"); + + if (NIL_P(tmp1)) { + tmp1 = rb_ary_new3(1, ary1); + } + + if (NIL_P(tmp2)) { + tmp2 = rb_ary_new3(1, ary2); + } + + if (tmp1 == ary1) { + tmp1 = rb_ary_dup(ary1); + } + ary = rb_ary_concat(tmp1, tmp2); + +#line 741 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(ary); +#undef CURRENT_INSN_concatarray +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(concatarray);}}} +INSN_ENTRY(splatarray){ +{ + VALUE obj; + VALUE flag = (VALUE)GET_OPERAND(1); + VALUE ary = TOPN(0); + DEBUG_ENTER_INSN("splatarray"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_splatarray 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_splatarray_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(splatarray)); + COLLECT_USAGE_OPERAND(BIN(splatarray), 0, flag); +{ +#line 507 "insns.def" + VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a"); + if (NIL_P(tmp)) { + tmp = rb_ary_new3(1, ary); + } + else if (RTEST(flag)) { + tmp = rb_ary_dup(tmp); + } + obj = tmp; + +#line 775 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(obj); +#undef CURRENT_INSN_splatarray +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(splatarray);}}} +INSN_ENTRY(newhash){ +{ + VALUE val; + rb_num_t num = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("newhash"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_newhash 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_newhash_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(newhash)); + COLLECT_USAGE_OPERAND(BIN(newhash), 0, num); +{ +#line 529 "insns.def" + rb_num_t i; + + if(RUBY_DTRACE_HASH_CREATE_ENABLED()) { + RUBY_DTRACE_HASH_CREATE(num, rb_sourcefile(), rb_sourceline()); + } + + val = rb_hash_new(); + + for (i = num; i > 0; i -= 2) { + const VALUE v = TOPN(i - 2); + const VALUE k = TOPN(i - 1); + rb_hash_aset(val, k, v); + } + POPN(num); + +#line 814 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_newhash +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(newhash);}}} +INSN_ENTRY(newrange){ +{ + VALUE val; + rb_num_t flag = (rb_num_t)GET_OPERAND(1); + VALUE low = TOPN(1); + VALUE high = TOPN(0); + DEBUG_ENTER_INSN("newrange"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_newrange 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_newrange_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(newrange)); + COLLECT_USAGE_OPERAND(BIN(newrange), 0, flag); +{ +#line 556 "insns.def" + val = rb_range_new(low, high, (int)flag); + +#line 842 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_newrange +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(newrange);}}} +INSN_ENTRY(pop){ +{ + + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("pop"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_pop 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_pop_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(pop)); +{ +#line 574 "insns.def" + (void)val; + /* none */ + +#line 868 "vm.inc" +#undef CURRENT_INSN_pop +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(pop);}}} +INSN_ENTRY(dup){ +{ + VALUE val2; + VALUE val1; + + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("dup"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_dup 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_dup_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(dup)); +{ +#line 589 "insns.def" + val1 = val2 = val; + +#line 893 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 2); + PUSH(val1); + PUSH(val2); +#undef CURRENT_INSN_dup +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(dup);}}} +INSN_ENTRY(dupn){ +{ + rb_num_t n = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("dupn"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_dupn 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_dupn_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(dupn)); + COLLECT_USAGE_OPERAND(BIN(dupn), 0, n); +{ +#line 603 "insns.def" + rb_num_t i; + VALUE *sp = STACK_ADDR_FROM_TOP(n); + for (i = 0; i < n; i++) { + GET_SP()[i] = sp[i]; + } + INC_SP(n); + +#line 924 "vm.inc" +#undef CURRENT_INSN_dupn +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(dupn);}}} +INSN_ENTRY(swap){ +{ + + VALUE val = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("swap"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_swap 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_swap_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(swap)); +{ +#line 623 "insns.def" + /* none */ + +#line 948 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 2); + PUSH(obj); + PUSH(val); +#undef CURRENT_INSN_swap +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(swap);}}} +INSN_ENTRY(reput){ +{ + + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("reput"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_reput 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_reput_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(reput)); +{ +#line 637 "insns.def" + /* none */ + +#line 974 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_reput +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(reput);}}} +INSN_ENTRY(topn){ +{ + VALUE val; + rb_num_t n = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("topn"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_topn 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_topn_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(topn)); + COLLECT_USAGE_OPERAND(BIN(topn), 0, n); +{ +#line 651 "insns.def" + val = TOPN(n); + +#line 1000 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_topn +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(topn);}}} +INSN_ENTRY(setn){ +{ + rb_num_t n = (rb_num_t)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setn"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setn 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setn_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setn)); + COLLECT_USAGE_OPERAND(BIN(setn), 0, n); +{ +#line 665 "insns.def" + TOPN(n-1) = val; + +#line 1026 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_setn +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setn);}}} +INSN_ENTRY(adjuststack){ +{ + rb_num_t n = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("adjuststack"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_adjuststack 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_adjuststack_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(adjuststack)); + COLLECT_USAGE_OPERAND(BIN(adjuststack), 0, n); +{ +#line 679 "insns.def" + DEC_SP(n); + +#line 1051 "vm.inc" +#undef CURRENT_INSN_adjuststack +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(adjuststack);}}} +INSN_ENTRY(defined){ +{ + VALUE val; + VALUE needstr = (VALUE)GET_OPERAND(3); + VALUE obj = (VALUE)GET_OPERAND(2); + rb_num_t op_type = (rb_num_t)GET_OPERAND(1); + VALUE v = TOPN(0); + DEBUG_ENTER_INSN("defined"); + ADD_PC(1+3); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_defined 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_defined_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(defined)); + COLLECT_USAGE_OPERAND(BIN(defined), 0, op_type); + COLLECT_USAGE_OPERAND(BIN(defined), 1, obj); + COLLECT_USAGE_OPERAND(BIN(defined), 2, needstr); +{ +#line 698 "insns.def" + VALUE klass; + enum defined_type expr_type = 0; + enum defined_type type = (enum defined_type)op_type; + + val = Qnil; + + switch (type) { + case DEFINED_IVAR: + if (rb_ivar_defined(GET_SELF(), SYM2ID(obj))) { + expr_type = DEFINED_IVAR; + } + break; + case DEFINED_IVAR2: + klass = vm_get_cbase(GET_ISEQ(), GET_EP()); + break; + case DEFINED_GVAR: + if (rb_gvar_defined(rb_global_entry(SYM2ID(obj)))) { + expr_type = DEFINED_GVAR; + } + break; + case DEFINED_CVAR: { + NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP()); + klass = vm_get_cvar_base(cref, GET_CFP()); + if (rb_cvar_defined(klass, SYM2ID(obj))) { + expr_type = DEFINED_CVAR; + } + break; + } + case DEFINED_CONST: + klass = v; + if (vm_get_ev_const(th, GET_ISEQ(), klass, SYM2ID(obj), 1)) { + expr_type = DEFINED_CONST; + } + break; + case DEFINED_FUNC: + klass = CLASS_OF(v); + if (rb_method_boundp(klass, SYM2ID(obj), 0)) { + expr_type = DEFINED_METHOD; + } + break; + case DEFINED_METHOD:{ + VALUE klass = CLASS_OF(v); + const rb_method_entry_t *me = rb_method_entry(klass, SYM2ID(obj), 0); + + if (me) { + if (!(me->flag & NOEX_PRIVATE)) { + if (!((me->flag & NOEX_PROTECTED) && + !rb_obj_is_kind_of(GET_SELF(), + rb_class_real(klass)))) { + expr_type = DEFINED_METHOD; + } + } + } + { + VALUE args[2]; + VALUE r; + + args[0] = obj; args[1] = Qfalse; + r = rb_check_funcall(v, idRespond_to_missing, 2, args); + if (r != Qundef && RTEST(r)) + expr_type = DEFINED_METHOD; + } + break; + } + case DEFINED_YIELD: + if (GET_BLOCK_PTR()) { + expr_type = DEFINED_YIELD; + } + break; + case DEFINED_ZSUPER:{ + rb_call_info_t cit; + if (vm_search_superclass(GET_CFP(), GET_ISEQ(), Qnil, &cit) == 0) { + VALUE klass = cit.klass; + ID id = cit.mid; + if (rb_method_boundp(klass, id, 0)) { + expr_type = DEFINED_ZSUPER; + } + } + break; + } + case DEFINED_REF:{ + val = vm_getspecial(th, GET_LEP(), Qfalse, FIX2INT(obj)); + if (val != Qnil) { + expr_type = DEFINED_GVAR; + } + break; + } + default: + rb_bug("unimplemented defined? type (VM)"); + break; + } + if (expr_type != 0) { + if (needstr != Qfalse) { + val = rb_iseq_defined_string(expr_type); + } + else { + val = Qtrue; + } + } + +#line 1178 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_defined +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(defined);}}} +INSN_ENTRY(checkmatch){ +{ + VALUE result; + rb_num_t flag = (rb_num_t)GET_OPERAND(1); + VALUE target = TOPN(1); + VALUE pattern = TOPN(0); + DEBUG_ENTER_INSN("checkmatch"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_checkmatch 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_checkmatch_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(checkmatch)); + COLLECT_USAGE_OPERAND(BIN(checkmatch), 0, flag); +{ +#line 815 "insns.def" + enum vm_check_match_type checkmatch_type = + (enum vm_check_match_type)(flag & VM_CHECKMATCH_TYPE_MASK); + result = Qfalse; + + if (flag & VM_CHECKMATCH_ARRAY) { + int i; + for (i = 0; i < RARRAY_LEN(pattern); i++) { + if (RTEST(check_match(RARRAY_AREF(pattern, i), target, checkmatch_type))) { + result = Qtrue; + break; + } + } + } + else { + if (RTEST(check_match(pattern, target, checkmatch_type))) { + result = Qtrue; + } + } + +#line 1223 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(result); +#undef CURRENT_INSN_checkmatch +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(checkmatch);}}} +INSN_ENTRY(checkkeyword){ +{ + VALUE ret; + rb_num_t keyword_index = (rb_num_t)GET_OPERAND(2); + lindex_t kw_bits_index = (lindex_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("checkkeyword"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_checkkeyword 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_checkkeyword_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(checkkeyword)); + COLLECT_USAGE_OPERAND(BIN(checkkeyword), 0, kw_bits_index); + COLLECT_USAGE_OPERAND(BIN(checkkeyword), 1, keyword_index); +{ +#line 846 "insns.def" + const VALUE *ep = GET_EP(); + const VALUE kw_bits = *(ep - kw_bits_index); + + if (FIXNUM_P(kw_bits)) { + int bits = FIX2INT(kw_bits); + ret = (bits & (0x01 << keyword_index)) ? Qfalse : Qtrue; + } + else { + assert(RB_TYPE_P(kw_bits, T_HASH)); + ret = rb_hash_has_key(kw_bits, INT2FIX(keyword_index)) ? Qfalse : Qtrue; + } + +#line 1261 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(ret); +#undef CURRENT_INSN_checkkeyword +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(checkkeyword);}}} +INSN_ENTRY(trace){ +{ + rb_num_t nf = (rb_num_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("trace"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_trace 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_trace_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(trace)); + COLLECT_USAGE_OPERAND(BIN(trace), 0, nf); +{ +#line 870 "insns.def" + rb_event_flag_t flag = (rb_event_flag_t)nf; + + if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() || + RUBY_DTRACE_METHOD_RETURN_ENABLED() || + RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() || + RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) { + + switch(flag) { + case RUBY_EVENT_CALL: + RUBY_DTRACE_METHOD_ENTRY_HOOK(th, 0, 0); + break; + case RUBY_EVENT_C_CALL: + RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, 0, 0); + break; + case RUBY_EVENT_RETURN: + RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0); + break; + case RUBY_EVENT_C_RETURN: + RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, 0, 0); + break; + } + } + + EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* id and klass are resolved at callee */, + (flag & (RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN)) ? TOPN(0) : Qundef); + +#line 1310 "vm.inc" +#undef CURRENT_INSN_trace +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(trace);}}} +INSN_ENTRY(defineclass){ +{ + VALUE val; + rb_num_t flags = (rb_num_t)GET_OPERAND(3); + ISEQ class_iseq = (ISEQ)GET_OPERAND(2); + ID id = (ID)GET_OPERAND(1); + VALUE cbase = TOPN(1); + VALUE super = TOPN(0); + DEBUG_ENTER_INSN("defineclass"); + ADD_PC(1+3); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_defineclass 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_defineclass_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(defineclass)); + COLLECT_USAGE_OPERAND(BIN(defineclass), 0, id); + COLLECT_USAGE_OPERAND(BIN(defineclass), 1, class_iseq); + COLLECT_USAGE_OPERAND(BIN(defineclass), 2, flags); +{ +#line 916 "insns.def" + VALUE klass; + rb_vm_defineclass_type_t type = VM_DEFINECLASS_TYPE(flags); + + switch (type) { + case VM_DEFINECLASS_TYPE_CLASS: + /* val is dummy. classdef returns class scope value */ + + if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) && + !RB_TYPE_P(super, T_CLASS)) { + rb_raise(rb_eTypeError, "superclass must be a Class (%s given)", + rb_obj_classname(super)); + } + + if (super == Qnil) { + super = rb_cObject; + } + + vm_check_if_namespace(cbase); + + /* find klass */ + rb_autoload_load(cbase, id); + if ((klass = vm_search_const_defined_class(cbase, id)) != 0) { + /* already exist */ + klass = VM_DEFINECLASS_SCOPED_P(flags) ? + rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id); + if (!RB_TYPE_P(klass, T_CLASS)) { + rb_raise(rb_eTypeError, "%s is not a class", rb_id2name(id)); + } + + if (super != rb_cObject) { + VALUE tmp; + tmp = rb_class_real(RCLASS_SUPER(klass)); + + if (tmp != super) { + rb_raise(rb_eTypeError, "superclass mismatch for class %s", + rb_id2name(id)); + } + } + } + else { + /* new class declaration */ + klass = rb_define_class_id(id, super); + rb_set_class_path_string(klass, cbase, rb_id2str(id)); + rb_const_set(cbase, id, klass); + rb_class_inherited(super, klass); + } + break; + case VM_DEFINECLASS_TYPE_SINGLETON_CLASS: + /* val is dummy. classdef returns class scope value */ + /* super is dummy */ + klass = rb_singleton_class(cbase); + break; + case VM_DEFINECLASS_TYPE_MODULE: + /* val is dummy. classdef returns class scope value */ + /* super is dummy */ + + vm_check_if_namespace(cbase); + + /* find klass */ + if ((klass = vm_search_const_defined_class(cbase, id)) != 0) { + klass = VM_DEFINECLASS_SCOPED_P(flags) ? + rb_public_const_get_at(klass, id) : rb_const_get_at(klass, id); + /* already exist */ + if (!RB_TYPE_P(klass, T_MODULE)) { + rb_raise(rb_eTypeError, "%s is not a module", rb_id2name(id)); + } + } + else { + /* new module declaration */ + klass = rb_define_module_id(id); + rb_set_class_path_string(klass, cbase, rb_id2str(id)); + rb_const_set(cbase, id, klass); + } + break; + default: + rb_bug("unknown defineclass type: %d", (int)type); + } + + COPY_CREF(class_iseq->cref_stack, vm_cref_push(th, klass, NOEX_PUBLIC, NULL)); + + /* enter scope */ + vm_push_frame(th, class_iseq, VM_FRAME_MAGIC_CLASS, + klass, 0, VM_ENVVAL_BLOCK_PTR(GET_BLOCK_PTR()), + class_iseq->iseq_encoded, GET_SP(), + class_iseq->local_size, 0, class_iseq->stack_max); + RESTORE_REGS(); + NEXT_INSN(); + +#line 1426 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_defineclass +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(defineclass);}}} +INSN_ENTRY(send){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + + DEBUG_ENTER_INSN("send"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_send 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_send_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(send)); + COLLECT_USAGE_OPERAND(BIN(send), 0, ci); +{ +#line 1021 "insns.def" + ci->argc = ci->orig_argc; + vm_caller_setup_arg_block(th, reg_cfp, ci, FALSE); + vm_search_method(ci, ci->recv = TOPN(ci->argc)); + CALL_METHOD(ci); + +#line 1455 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_send +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(send);}}} +INSN_ENTRY(opt_str_freeze){ +{ + VALUE val; + VALUE str = (VALUE)GET_OPERAND(1); + + DEBUG_ENTER_INSN("opt_str_freeze"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_opt_str_freeze 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_str_freeze_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_str_freeze)); + COLLECT_USAGE_OPERAND(BIN(opt_str_freeze), 0, str); +{ +#line 1033 "insns.def" + if (BASIC_OP_UNREDEFINED_P(BOP_FREEZE, STRING_REDEFINED_OP_FLAG)) { + val = str; + } + else { + val = rb_funcall(rb_str_resurrect(str), idFreeze, 0); + } + +#line 1486 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_str_freeze +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_str_freeze);}}} +INSN_ENTRY(opt_send_without_block){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + + DEBUG_ENTER_INSN("opt_send_without_block"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_opt_send_without_block 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_send_without_block_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_send_without_block)); + COLLECT_USAGE_OPERAND(BIN(opt_send_without_block), 0, ci); +{ +#line 1052 "insns.def" + ci->argc = ci->orig_argc; + vm_search_method(ci, ci->recv = TOPN(ci->argc)); + CALL_METHOD(ci); + +#line 1514 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_send_without_block +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_send_without_block);}}} +INSN_ENTRY(invokesuper){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + + DEBUG_ENTER_INSN("invokesuper"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_invokesuper 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_invokesuper_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(invokesuper)); + COLLECT_USAGE_OPERAND(BIN(invokesuper), 0, ci); +{ +#line 1068 "insns.def" + ci->argc = ci->orig_argc; + vm_caller_setup_arg_block(th, reg_cfp, ci, TRUE); + ci->recv = GET_SELF(); + vm_search_super_method(th, GET_CFP(), ci); + CALL_METHOD(ci); + +#line 1544 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_invokesuper +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(invokesuper);}}} +INSN_ENTRY(invokeblock){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + + DEBUG_ENTER_INSN("invokeblock"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_invokeblock 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_invokeblock_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(invokeblock)); + COLLECT_USAGE_OPERAND(BIN(invokeblock), 0, ci); +{ +#line 1086 "insns.def" + ci->argc = ci->orig_argc; + ci->blockptr = 0; + ci->recv = GET_SELF(); + val = vm_invoke_block(th, GET_CFP(), ci); + if (val == Qundef) { + RESTORE_REGS(); + NEXT_INSN(); + } + +#line 1577 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_invokeblock +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(invokeblock);}}} +INSN_ENTRY(leave){ +{ + + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("leave"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_leave 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_leave_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(leave)); +{ +#line 1107 "insns.def" + if (OPT_CHECKED_RUN) { + if (reg_cfp->sp != vm_base_ptr(reg_cfp)) { + rb_bug("Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")", + VM_SP_CNT(th, reg_cfp->sp), VM_SP_CNT(th, vm_base_ptr(reg_cfp))); + } + } + + RUBY_VM_CHECK_INTS(th); + + if (UNLIKELY(VM_FRAME_TYPE_FINISH_P(GET_CFP()))) { + vm_pop_frame(th); + +#if OPT_CALL_THREADED_CODE + th->retval = val; + return 0; +#else + return val; +#endif + } + else { + vm_pop_frame(th); + RESTORE_REGS(); + } + +#line 1624 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_leave +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(leave);}}} +INSN_ENTRY(throw){ +{ + VALUE val; + rb_num_t throw_state = (rb_num_t)GET_OPERAND(1); + VALUE throwobj = TOPN(0); + DEBUG_ENTER_INSN("throw"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_throw 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_throw_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(throw)); + COLLECT_USAGE_OPERAND(BIN(throw), 0, throw_state); +{ +#line 1147 "insns.def" + RUBY_VM_CHECK_INTS(th); + val = vm_throw(th, GET_CFP(), throw_state, throwobj); + THROW_EXCEPTION(val); + /* unreachable */ + +#line 1654 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_throw +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(throw);}}} +INSN_ENTRY(jump){ +{ + OFFSET dst = (OFFSET)GET_OPERAND(1); + + DEBUG_ENTER_INSN("jump"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_jump 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_jump_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(jump)); + COLLECT_USAGE_OPERAND(BIN(jump), 0, dst); +{ +#line 1168 "insns.def" + RUBY_VM_CHECK_INTS(th); + JUMP(dst); + +#line 1680 "vm.inc" +#undef CURRENT_INSN_jump +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(jump);}}} +INSN_ENTRY(branchif){ +{ + OFFSET dst = (OFFSET)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("branchif"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_branchif 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_branchif_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(branchif)); + COLLECT_USAGE_OPERAND(BIN(branchif), 0, dst); +{ +#line 1183 "insns.def" + if (RTEST(val)) { + RUBY_VM_CHECK_INTS(th); + JUMP(dst); + } + +#line 1707 "vm.inc" +#undef CURRENT_INSN_branchif +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(branchif);}}} +INSN_ENTRY(branchunless){ +{ + OFFSET dst = (OFFSET)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("branchunless"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_branchunless 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_branchunless_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(branchunless)); + COLLECT_USAGE_OPERAND(BIN(branchunless), 0, dst); +{ +#line 1200 "insns.def" + if (!RTEST(val)) { + RUBY_VM_CHECK_INTS(th); + JUMP(dst); + } + +#line 1734 "vm.inc" +#undef CURRENT_INSN_branchunless +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(branchunless);}}} +INSN_ENTRY(getinlinecache){ +{ + VALUE val; + IC ic = (IC)GET_OPERAND(2); + OFFSET dst = (OFFSET)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getinlinecache"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getinlinecache 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getinlinecache_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getinlinecache)); + COLLECT_USAGE_OPERAND(BIN(getinlinecache), 0, dst); + COLLECT_USAGE_OPERAND(BIN(getinlinecache), 1, ic); +{ +#line 1222 "insns.def" + if (ic->ic_serial == GET_GLOBAL_CONSTANT_STATE()) { + val = ic->ic_value.value; + JUMP(dst); + } + else { + /* none */ + val = Qnil; + } + +#line 1767 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_getinlinecache +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getinlinecache);}}} +INSN_ENTRY(setinlinecache){ +{ + IC ic = (IC)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setinlinecache"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setinlinecache 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setinlinecache_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setinlinecache)); + COLLECT_USAGE_OPERAND(BIN(setinlinecache), 0, ic); +{ +#line 1243 "insns.def" + if (ic->ic_value.value == Qundef) { + rb_iseq_add_mark_object(GET_ISEQ(), val); + } + ic->ic_value.value = val; + ic->ic_serial = GET_GLOBAL_CONSTANT_STATE() - ruby_vm_const_missing_count; + ruby_vm_const_missing_count = 0; + +#line 1798 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_setinlinecache +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setinlinecache);}}} +INSN_ENTRY(once){ +{ + VALUE val; + IC ic = (IC)GET_OPERAND(2); + ISEQ iseq = (ISEQ)GET_OPERAND(1); + + DEBUG_ENTER_INSN("once"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + #define CURRENT_INSN_once 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_once_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(once)); + COLLECT_USAGE_OPERAND(BIN(once), 0, iseq); + COLLECT_USAGE_OPERAND(BIN(once), 1, ic); +{ +#line 1262 "insns.def" + union iseq_inline_storage_entry *is = (union iseq_inline_storage_entry *)ic; + +#define RUNNING_THREAD_ONCE_DONE ((rb_thread_t *)(0x1)) + retry: + if (is->once.running_thread == RUNNING_THREAD_ONCE_DONE) { + val = is->once.value; + } + else if (is->once.running_thread == NULL) { + is->once.running_thread = th; + val = is->once.value = rb_ensure(vm_once_exec, (VALUE)iseq, vm_once_clear, (VALUE)is); + /* is->once.running_thread is cleared by vm_once_clear() */ + is->once.running_thread = RUNNING_THREAD_ONCE_DONE; /* success */ + rb_iseq_add_mark_object(GET_ISEQ(), val); + } + else if (is->once.running_thread == th) { + /* recursive once */ + val = vm_once_exec((VALUE)iseq); + } + else { + /* waiting for finish */ + RUBY_VM_CHECK_INTS(th); + rb_thread_schedule(); + goto retry; + } + +#line 1849 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_once +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(once);}}} +INSN_ENTRY(opt_case_dispatch){ +{ + OFFSET else_offset = (OFFSET)GET_OPERAND(2); + CDHASH hash = (CDHASH)GET_OPERAND(1); + VALUE key = TOPN(0); + DEBUG_ENTER_INSN("opt_case_dispatch"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_case_dispatch 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_case_dispatch_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_case_dispatch)); + COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 0, hash); + COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 1, else_offset); +{ +#line 1299 "insns.def" + switch(TYPE(key)) { + case T_FLOAT: { + double ival; + if (modf(RFLOAT_VALUE(key), &ival) == 0.0) { + key = FIXABLE(ival) ? LONG2FIX((long)ival) : rb_dbl2big(ival); + } + } + case T_SYMBOL: /* fall through */ + case T_FIXNUM: + case T_BIGNUM: + case T_STRING: + if (BASIC_OP_UNREDEFINED_P(BOP_EQQ, + SYMBOL_REDEFINED_OP_FLAG | + FIXNUM_REDEFINED_OP_FLAG | + BIGNUM_REDEFINED_OP_FLAG | + STRING_REDEFINED_OP_FLAG)) { + st_data_t val; + if (st_lookup(RHASH_TBL_RAW(hash), key, &val)) { + JUMP(FIX2INT((VALUE)val)); + } + else { + JUMP(else_offset); + } + break; + } + default: + break; + } + +#line 1904 "vm.inc" +#undef CURRENT_INSN_opt_case_dispatch +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_case_dispatch);}}} +INSN_ENTRY(opt_plus){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_plus"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_plus 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_plus_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_plus)); + COLLECT_USAGE_OPERAND(BIN(opt_plus), 0, ci); +{ +#line 1342 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_PLUS,FIXNUM_REDEFINED_OP_FLAG)) { + /* fixnum + fixnum */ +#ifndef LONG_LONG_VALUE + val = (recv + (obj & (~1))); + if ((~(recv ^ obj) & (recv ^ val)) & + ((VALUE)0x01 << ((sizeof(VALUE) * CHAR_BIT) - 1))) { + val = rb_big_plus(rb_int2big(FIX2LONG(recv)), + rb_int2big(FIX2LONG(obj))); + } +#else + long a, b, c; + a = FIX2LONG(recv); + b = FIX2LONG(obj); + c = a + b; + if (FIXABLE(c)) { + val = LONG2FIX(c); + } + else { + val = rb_big_plus(rb_int2big(a), rb_int2big(b)); + } +#endif + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj)); + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj)); + } + else if (RBASIC_CLASS(recv) == rb_cString && RBASIC_CLASS(obj) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) { + val = rb_str_plus(recv, obj); + } + else if (RBASIC_CLASS(recv) == rb_cArray && + BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) { + val = rb_ary_plus(recv, obj); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 1979 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_plus +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_plus);}}} +INSN_ENTRY(opt_minus){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_minus"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_minus 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_minus_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_minus)); + COLLECT_USAGE_OPERAND(BIN(opt_minus), 0, ci); +{ +#line 1405 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_MINUS, FIXNUM_REDEFINED_OP_FLAG)) { + long a, b, c; + + a = FIX2LONG(recv); + b = FIX2LONG(obj); + c = a - b; + + if (FIXABLE(c)) { + val = LONG2FIX(c); + } + else { + val = rb_big_minus(rb_int2big(a), rb_int2big(b)); + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj)); + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + /* other */ + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2041 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_minus +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_minus);}}} +INSN_ENTRY(opt_mult){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_mult"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_mult 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_mult_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_mult)); + COLLECT_USAGE_OPERAND(BIN(opt_mult), 0, ci); +{ +#line 1453 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_MULT, FIXNUM_REDEFINED_OP_FLAG)) { + long a, b; + + a = FIX2LONG(recv); + if (a == 0) { + val = recv; + } + else { + b = FIX2LONG(obj); + if (MUL_OVERFLOW_FIXNUM_P(a, b)) { + val = rb_big_mul(rb_int2big(a), rb_int2big(b)); + } + else { + val = LONG2FIX(a * b); + } + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj)); + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2105 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_mult +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_mult);}}} +INSN_ENTRY(opt_div){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_div"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_div 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_div_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_div)); + COLLECT_USAGE_OPERAND(BIN(opt_div), 0, ci); +{ +#line 1503 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_DIV, FIXNUM_REDEFINED_OP_FLAG)) { + long x, y, div; + + x = FIX2LONG(recv); + y = FIX2LONG(obj); + { + /* copied from numeric.c#fixdivmod */ + long mod; + if (y == 0) + goto INSN_LABEL(normal_dispatch); + if (y < 0) { + if (x < 0) + div = -x / -y; + else + div = -(x / -y); + } + else { + if (x < 0) + div = -(-x / y); + else + div = x / y; + } + mod = x - div * y; + if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { + mod += y; + div -= 1; + } + } + val = LONG2NUM(div); + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj)); + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2182 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_div +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_div);}}} +INSN_ENTRY(opt_mod){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_mod"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_mod 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_mod_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_mod)); + COLLECT_USAGE_OPERAND(BIN(opt_mod), 0, ci); +{ +#line 1566 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_MOD, FIXNUM_REDEFINED_OP_FLAG )) { + long x, y; + + x = FIX2LONG(recv); + y = FIX2LONG(obj); + if (x > 0 && y > 0) { + val = LONG2FIX(x % y); + } + else { + /* copied from numeric.c#fixdivmod */ + long div, mod; + + if (y == 0) + rb_num_zerodiv(); + if (y < 0) { + if (x < 0) + div = -x / -y; + else + div = -(x / -y); + } + else { + if (x < 0) + div = -(-x / y); + else + div = x / y; + } + mod = x - div * y; + if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { + mod += y; + div -= 1; + } + val = LONG2FIX(mod); + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj))); + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) { + val = DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj))); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2263 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_mod +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_mod);}}} +INSN_ENTRY(opt_eq){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_eq"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_eq 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_eq_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_eq)); + COLLECT_USAGE_OPERAND(BIN(opt_eq), 0, ci); +{ +#line 1633 "insns.def" + val = opt_eq_func(recv, obj, ci); + + if (val == Qundef) { + /* other */ + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2298 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_eq +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_eq);}}} +INSN_ENTRY(opt_neq){ +{ + VALUE val; + CALL_INFO ci_eq = (CALL_INFO)GET_OPERAND(2); + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_neq"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_neq 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_neq_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_neq)); + COLLECT_USAGE_OPERAND(BIN(opt_neq), 0, ci); + COLLECT_USAGE_OPERAND(BIN(opt_neq), 1, ci_eq); +{ +#line 1654 "insns.def" + extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2); + vm_search_method(ci, recv); + val = Qundef; + + if (check_cfunc(ci->me, rb_obj_not_equal)) { + val = opt_eq_func(recv, obj, ci_eq); + + if (val != Qundef) { + val = RTEST(val) ? Qfalse : Qtrue; + } + } + + if (val == Qundef) { + /* other */ + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2345 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_neq +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_neq);}}} +INSN_ENTRY(opt_lt){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_lt"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_lt 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_lt_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_lt)); + COLLECT_USAGE_OPERAND(BIN(opt_lt), 0, ci); +{ +#line 1685 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_LT, FIXNUM_REDEFINED_OP_FLAG)) { + SIGNED_VALUE a = recv, b = obj; + + if (a < b) { + val = Qtrue; + } + else { + val = Qfalse; + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) { + /* flonum is not NaN */ + val = RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj) ? Qtrue : Qfalse; + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) { + val = double_cmp_lt(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2403 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_lt +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_lt);}}} +INSN_ENTRY(opt_le){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_le"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_le 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_le_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_le)); + COLLECT_USAGE_OPERAND(BIN(opt_le), 0, ci); +{ +#line 1729 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_LE, FIXNUM_REDEFINED_OP_FLAG)) { + SIGNED_VALUE a = recv, b = obj; + + if (a <= b) { + val = Qtrue; + } + else { + val = Qfalse; + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) { + /* flonum is not NaN */ + val = RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj) ? Qtrue : Qfalse; + } + else { + /* other */ + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2452 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_le +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_le);}}} +INSN_ENTRY(opt_gt){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_gt"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_gt 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_gt_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_gt)); + COLLECT_USAGE_OPERAND(BIN(opt_gt), 0, ci); +{ +#line 1764 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_GT, FIXNUM_REDEFINED_OP_FLAG)) { + SIGNED_VALUE a = recv, b = obj; + + if (a > b) { + val = Qtrue; + } + else { + val = Qfalse; + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) { + /* flonum is not NaN */ + val = RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj) ? Qtrue : Qfalse; + } + else if (!SPECIAL_CONST_P(recv) && !SPECIAL_CONST_P(obj)) { + if (RBASIC_CLASS(recv) == rb_cFloat && RBASIC_CLASS(obj) == rb_cFloat && + BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) { + val = double_cmp_gt(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2510 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_gt +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_gt);}}} +INSN_ENTRY(opt_ge){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_ge"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_ge 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_ge_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_ge)); + COLLECT_USAGE_OPERAND(BIN(opt_ge), 0, ci); +{ +#line 1808 "insns.def" + if (FIXNUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_GE, FIXNUM_REDEFINED_OP_FLAG)) { + SIGNED_VALUE a = recv, b = obj; + + if (a >= b) { + val = Qtrue; + } + else { + val = Qfalse; + } + } + else if (FLONUM_2_P(recv, obj) && + BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) { + /* flonum is not NaN */ + val = RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj) ? Qtrue : Qfalse; + } + else { + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2558 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_ge +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_ge);}}} +INSN_ENTRY(opt_ltlt){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_ltlt"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_ltlt 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_ltlt_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_ltlt)); + COLLECT_USAGE_OPERAND(BIN(opt_ltlt), 0, ci); +{ +#line 1842 "insns.def" + if (!SPECIAL_CONST_P(recv)) { + if (RBASIC_CLASS(recv) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) { + val = rb_str_concat(recv, obj); + } + else if (RBASIC_CLASS(recv) == rb_cArray && + BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) { + val = rb_ary_push(recv, obj); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2604 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_ltlt +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_ltlt);}}} +INSN_ENTRY(opt_aref){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_aref"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_aref 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_aref_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_aref)); + COLLECT_USAGE_OPERAND(BIN(opt_aref), 0, ci); +{ +#line 1874 "insns.def" + if (!SPECIAL_CONST_P(recv)) { + if (RBASIC_CLASS(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) { + val = rb_ary_entry(recv, FIX2LONG(obj)); + } + else if (RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) { + val = rb_hash_aref(recv, obj); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + CALL_SIMPLE_METHOD(recv); + } + +#line 2648 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_aref +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_aref);}}} +INSN_ENTRY(opt_aset){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(2); + VALUE obj = TOPN(1); + VALUE set = TOPN(0); + DEBUG_ENTER_INSN("opt_aset"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(3); + #define CURRENT_INSN_opt_aset 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_aset_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_aset)); + COLLECT_USAGE_OPERAND(BIN(opt_aset), 0, ci); +{ +#line 1904 "insns.def" + if (!SPECIAL_CONST_P(recv)) { + if (RBASIC_CLASS(recv) == rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) && FIXNUM_P(obj)) { + rb_ary_store(recv, FIX2LONG(obj), set); + val = set; + } + else if (RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) { + rb_hash_aset(recv, obj, set); + val = set; + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + PUSH(obj); + PUSH(set); + CALL_SIMPLE_METHOD(recv); + } + +#line 2696 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_aset +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_aset);}}} +INSN_ENTRY(opt_aset_with){ +{ + VALUE key = (VALUE)GET_OPERAND(2); + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("opt_aset_with"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_aset_with 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_aset_with_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_aset_with)); + COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 0, ci); + COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 1, key); +{ +#line 1937 "insns.def" + if (!SPECIAL_CONST_P(recv) && RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) { + rb_hash_aset(recv, key, val); + } + else { + PUSH(recv); + PUSH(rb_str_resurrect(key)); + PUSH(val); + CALL_SIMPLE_METHOD(recv); + } + +#line 2733 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_aset_with +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_aset_with);}}} +INSN_ENTRY(opt_aref_with){ +{ + VALUE val; + VALUE key = (VALUE)GET_OPERAND(2); + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(0); + DEBUG_ENTER_INSN("opt_aref_with"); + ADD_PC(1+2); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_aref_with 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_aref_with_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_aref_with)); + COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 0, ci); + COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 1, key); +{ +#line 1959 "insns.def" + if (!SPECIAL_CONST_P(recv) && RBASIC_CLASS(recv) == rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) { + val = rb_hash_aref(recv, key); + } + else { + PUSH(recv); + PUSH(rb_str_resurrect(key)); + CALL_SIMPLE_METHOD(recv); + } + +#line 2769 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_aref_with +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_aref_with);}}} +INSN_ENTRY(opt_length){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(0); + DEBUG_ENTER_INSN("opt_length"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_length 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_length_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_length)); + COLLECT_USAGE_OPERAND(BIN(opt_length), 0, ci); +{ +#line 1980 "insns.def" + if (!SPECIAL_CONST_P(recv)) { + if (RBASIC_CLASS(recv) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_LENGTH, STRING_REDEFINED_OP_FLAG)) { + val = rb_str_length(recv); + } + else if (RBASIC_CLASS(recv) == rb_cArray && + BASIC_OP_UNREDEFINED_P(BOP_LENGTH, ARRAY_REDEFINED_OP_FLAG)) { + val = LONG2NUM(RARRAY_LEN(recv)); + } + else if (RBASIC_CLASS(recv) == rb_cHash && + BASIC_OP_UNREDEFINED_P(BOP_LENGTH, HASH_REDEFINED_OP_FLAG)) { + val = INT2FIX(RHASH_SIZE(recv)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + CALL_SIMPLE_METHOD(recv); + } + +#line 2817 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_length +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_length);}}} +INSN_ENTRY(opt_size){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(0); + DEBUG_ENTER_INSN("opt_size"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_size 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_size_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_size)); + COLLECT_USAGE_OPERAND(BIN(opt_size), 0, ci); +{ +#line 2015 "insns.def" + if (!SPECIAL_CONST_P(recv)) { + if (RBASIC_CLASS(recv) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_SIZE, STRING_REDEFINED_OP_FLAG)) { + val = rb_str_length(recv); + } + else if (RBASIC_CLASS(recv) == rb_cArray && + BASIC_OP_UNREDEFINED_P(BOP_SIZE, ARRAY_REDEFINED_OP_FLAG)) { + val = LONG2NUM(RARRAY_LEN(recv)); + } + else if (RBASIC_CLASS(recv) == rb_cHash && + BASIC_OP_UNREDEFINED_P(BOP_SIZE, HASH_REDEFINED_OP_FLAG)) { + val = INT2FIX(RHASH_SIZE(recv)); + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + CALL_SIMPLE_METHOD(recv); + } + +#line 2865 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_size +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_size);}}} +INSN_ENTRY(opt_empty_p){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(0); + DEBUG_ENTER_INSN("opt_empty_p"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_empty_p 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_empty_p_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_empty_p)); + COLLECT_USAGE_OPERAND(BIN(opt_empty_p), 0, ci); +{ +#line 2050 "insns.def" + if (!SPECIAL_CONST_P(recv)) { + if (RBASIC_CLASS(recv) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, STRING_REDEFINED_OP_FLAG)) { + if (RSTRING_LEN(recv) == 0) val = Qtrue; + else val = Qfalse; + } + else if (RBASIC_CLASS(recv) == rb_cArray && + BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, ARRAY_REDEFINED_OP_FLAG)) { + if (RARRAY_LEN(recv) == 0) val = Qtrue; + else val = Qfalse; + } + else if (RBASIC_CLASS(recv) == rb_cHash && + BASIC_OP_UNREDEFINED_P(BOP_EMPTY_P, HASH_REDEFINED_OP_FLAG)) { + if (RHASH_EMPTY_P(recv)) val = Qtrue; + else val = Qfalse; + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + INSN_LABEL(normal_dispatch): + PUSH(recv); + CALL_SIMPLE_METHOD(recv); + } + +#line 2916 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_empty_p +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_empty_p);}}} +INSN_ENTRY(opt_succ){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(0); + DEBUG_ENTER_INSN("opt_succ"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_succ 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_succ_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_succ)); + COLLECT_USAGE_OPERAND(BIN(opt_succ), 0, ci); +{ +#line 2088 "insns.def" + if (SPECIAL_CONST_P(recv)) { + if (FIXNUM_P(recv) && + BASIC_OP_UNREDEFINED_P(BOP_SUCC, FIXNUM_REDEFINED_OP_FLAG)) { + const VALUE obj = INT2FIX(1); + /* fixnum + INT2FIX(1) */ + val = (recv + (obj & (~1))); + if ((~(recv ^ obj) & (recv ^ val)) & ((unsigned long)LONG_MAX + 1)) { + val = rb_big_plus(rb_int2big(FIX2LONG(recv)), + rb_int2big(FIX2LONG(obj))); + } + } + else { + goto INSN_LABEL(normal_dispatch); + } + } + else { + if (RBASIC_CLASS(recv) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) { + val = rb_str_succ(recv); + } + else + { + goto INSN_LABEL(normal_dispatch); + } + } + if (0) { + INSN_LABEL(normal_dispatch): + PUSH(recv); + CALL_SIMPLE_METHOD(recv); + } + +#line 2972 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_succ +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_succ);}}} +INSN_ENTRY(opt_not){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE recv = TOPN(0); + DEBUG_ENTER_INSN("opt_not"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_not 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_not_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_not)); + COLLECT_USAGE_OPERAND(BIN(opt_not), 0, ci); +{ +#line 2131 "insns.def" + extern VALUE rb_obj_not(VALUE obj); + vm_search_method(ci, recv); + + if (check_cfunc(ci->me, rb_obj_not)) { + val = RTEST(recv) ? Qfalse : Qtrue; + } + else { + PUSH(recv); + CALL_SIMPLE_METHOD(recv); + } + +#line 3008 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_not +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_not);}}} +INSN_ENTRY(opt_regexpmatch1){ +{ + VALUE val; + VALUE r = (VALUE)GET_OPERAND(1); + VALUE obj = TOPN(0); + DEBUG_ENTER_INSN("opt_regexpmatch1"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_opt_regexpmatch1 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_regexpmatch1_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_regexpmatch1)); + COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch1), 0, r); +{ +#line 2155 "insns.def" + if (BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG)) { + val = rb_reg_match(r, obj); + } + else { + val = rb_funcall(r, idEqTilde, 1, obj); + } + +#line 3040 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_regexpmatch1 +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_regexpmatch1);}}} +INSN_ENTRY(opt_regexpmatch2){ +{ + VALUE val; + CALL_INFO ci = (CALL_INFO)GET_OPERAND(1); + VALUE obj2 = TOPN(1); + VALUE obj1 = TOPN(0); + DEBUG_ENTER_INSN("opt_regexpmatch2"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(2); + #define CURRENT_INSN_opt_regexpmatch2 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_regexpmatch2_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_regexpmatch2)); + COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch2), 0, ci); +{ +#line 2174 "insns.def" + if (CLASS_OF(obj2) == rb_cString && + BASIC_OP_UNREDEFINED_P(BOP_MATCH, STRING_REDEFINED_OP_FLAG)) { + val = rb_reg_match(obj1, obj2); + } + else { + PUSH(obj2); + PUSH(obj1); + CALL_SIMPLE_METHOD(obj2); + } + +#line 3076 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef CURRENT_INSN_opt_regexpmatch2 +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_regexpmatch2);}}} +INSN_ENTRY(opt_call_c_function){ +{ + rb_insn_func_t funcptr = (rb_insn_func_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("opt_call_c_function"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_opt_call_c_function 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_opt_call_c_function_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(opt_call_c_function)); + COLLECT_USAGE_OPERAND(BIN(opt_call_c_function), 0, funcptr); +{ +#line 2196 "insns.def" + reg_cfp = (funcptr)(th, reg_cfp); + + if (reg_cfp == 0) { + VALUE err = th->errinfo; + th->errinfo = Qnil; + THROW_EXCEPTION(err); + } + + RESTORE_REGS(); + NEXT_INSN(); + +#line 3110 "vm.inc" +#undef CURRENT_INSN_opt_call_c_function +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(opt_call_c_function);}}} +INSN_ENTRY(bitblt){ +{ + VALUE ret; + + + DEBUG_ENTER_INSN("bitblt"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_bitblt 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_bitblt_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(bitblt)); +{ +#line 2219 "insns.def" + ret = rb_str_new2("a bit of bacon, lettuce and tomato"); + +#line 3133 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(ret); +#undef CURRENT_INSN_bitblt +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(bitblt);}}} +INSN_ENTRY(answer){ +{ + VALUE ret; + + + DEBUG_ENTER_INSN("answer"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_answer 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_answer_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(answer)); +{ +#line 2233 "insns.def" + ret = INT2FIX(42); + +#line 3158 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(ret); +#undef CURRENT_INSN_answer +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(answer);}}} +INSN_ENTRY(getlocal_OP__WC__0){ +{ + VALUE val; + #define level 0 + lindex_t idx = (lindex_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getlocal_OP__WC__0"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getlocal_OP__WC__0 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getlocal_OP__WC__0_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__0)); + COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__0), 0, idx); +{ +#line 60 "insns.def" + int i, lev = (int)level; + VALUE *ep = GET_EP(); + + /* optimized insns generated for level == (0|1) in defs/opt_operand.def */ + for (i = 0; i < lev; i++) { + ep = GET_PREV_EP(ep); + } + val = *(ep - idx); + +#line 3192 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef level +#undef CURRENT_INSN_getlocal_OP__WC__0 +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getlocal_OP__WC__0);}}} +INSN_ENTRY(getlocal_OP__WC__1){ +{ + VALUE val; + #define level 1 + lindex_t idx = (lindex_t)GET_OPERAND(1); + + DEBUG_ENTER_INSN("getlocal_OP__WC__1"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + #define CURRENT_INSN_getlocal_OP__WC__1 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_getlocal_OP__WC__1_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__1)); + COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__1), 0, idx); +{ +#line 60 "insns.def" + int i, lev = (int)level; + VALUE *ep = GET_EP(); + + /* optimized insns generated for level == (0|1) in defs/opt_operand.def */ + for (i = 0; i < lev; i++) { + ep = GET_PREV_EP(ep); + } + val = *(ep - idx); + +#line 3227 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef level +#undef CURRENT_INSN_getlocal_OP__WC__1 +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(getlocal_OP__WC__1);}}} +INSN_ENTRY(setlocal_OP__WC__0){ +{ + #define level 0 + lindex_t idx = (lindex_t)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setlocal_OP__WC__0"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setlocal_OP__WC__0 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setlocal_OP__WC__0_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__0)); + COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__0), 0, idx); +{ +#line 83 "insns.def" + int i, lev = (int)level; + VALUE *ep = GET_EP(); + + /* optimized insns generated for level == (0|1) in defs/opt_operand.def */ + for (i = 0; i < lev; i++) { + ep = GET_PREV_EP(ep); + } + *(ep - idx) = val; + +#line 3262 "vm.inc" +#undef level +#undef CURRENT_INSN_setlocal_OP__WC__0 +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setlocal_OP__WC__0);}}} +INSN_ENTRY(setlocal_OP__WC__1){ +{ + #define level 1 + lindex_t idx = (lindex_t)GET_OPERAND(1); + VALUE val = TOPN(0); + DEBUG_ENTER_INSN("setlocal_OP__WC__1"); + ADD_PC(1+1); + PREFETCH(GET_PC()); + POPN(1); + #define CURRENT_INSN_setlocal_OP__WC__1 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_setlocal_OP__WC__1_##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__1)); + COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__1), 0, idx); +{ +#line 83 "insns.def" + int i, lev = (int)level; + VALUE *ep = GET_EP(); + + /* optimized insns generated for level == (0|1) in defs/opt_operand.def */ + for (i = 0; i < lev; i++) { + ep = GET_PREV_EP(ep); + } + *(ep - idx) = val; + +#line 3295 "vm.inc" +#undef level +#undef CURRENT_INSN_setlocal_OP__WC__1 +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(setlocal_OP__WC__1);}}} +INSN_ENTRY(putobject_OP_INT2FIX_O_0_C_){ +{ + #define val INT2FIX(0) + + + DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_0_C_"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_ 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putobject_OP_INT2FIX_O_0_C__##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_0_C_)); +{ +#line 299 "insns.def" + /* */ + +#line 3319 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef val +#undef CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_ +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putobject_OP_INT2FIX_O_0_C_);}}} +INSN_ENTRY(putobject_OP_INT2FIX_O_1_C_){ +{ + #define val INT2FIX(1) + + + DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_1_C_"); + ADD_PC(1+0); + PREFETCH(GET_PC()); + #define CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_ 1 + #define INSN_IS_SC() 0 + #define INSN_LABEL(lab) LABEL_putobject_OP_INT2FIX_O_1_C__##lab + #define LABEL_IS_SC(lab) LABEL_##lab##_##t + COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_1_C_)); +{ +#line 299 "insns.def" + /* */ + +#line 3345 "vm.inc" + CHECK_VM_STACK_OVERFLOW_FOR_INSN(REG_CFP, 1); + PUSH(val); +#undef val +#undef CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_ +#undef INSN_IS_SC +#undef INSN_LABEL +#undef LABEL_IS_SC + END_INSN(putobject_OP_INT2FIX_O_1_C_);}}} + -- cgit v1.2.3