| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Alexander V. Astapchuk |
| */ |
| #include "compiler.h" |
| #include "trace.h" |
| #include "stats.h" |
| |
| #include "open/vm_class_info.h" |
| #include "open/vm_class_loading.h" |
| #include "jit_import.h" |
| //#include "jit_intf.h" |
| #include "open/vm_ee.h" |
| |
| /** |
| * @file |
| * @brief Mostly a huge switch(OPCODE), separated to several groups. |
| */ |
| |
| namespace Jitrino { |
| namespace Jet { |
| |
| |
| void Compiler::handle_inst(void) |
| { |
| // is it last instruction in basic block ? |
| //const bool last = m_bbinfo->last_pc == jinst.pc; |
| const JInst& jinst = m_insts[m_pc]; |
| unsigned bc_size = m_infoBlock.get_bc_size(); |
| bool lastInBB = jinst.next>=bc_size || (m_insts[jinst.next].flags & OPF_STARTS_BB); |
| |
| if (is_set(DBG_CHECK_STACK)) { |
| gen_dbg_check_stack(true); |
| } |
| |
| // First test if this is a magic. If not, then proceed with regular |
| // code gen. |
| if (!gen_magic()) { |
| const InstrDesc& idesc = instrs[jinst.opcode]; |
| switch (idesc.ik) { |
| case ik_a: |
| handle_ik_a(jinst); |
| break; |
| case ik_cf: |
| handle_ik_cf(jinst); |
| break; |
| case ik_cnv: |
| handle_ik_cnv(jinst); |
| break; |
| case ik_ls: |
| handle_ik_ls(jinst); |
| break; |
| case ik_meth: |
| handle_ik_meth(jinst); |
| break; |
| case ik_obj: |
| handle_ik_obj(jinst); |
| break; |
| case ik_stack: |
| handle_ik_stack(jinst); |
| break; |
| case ik_throw: |
| gen_athrow(); |
| break; |
| default: |
| assert(jinst.opcode == OPCODE_NOP); |
| break; |
| } // ~switch(opcodegroup) |
| } else { // if (!gen_magic()) { |
| // no op. Just check stack (if applicable) and do mem manipulations |
| } |
| |
| if (is_set(DBG_CHECK_STACK)) { |
| gen_dbg_check_stack(false); |
| } |
| |
| if (g_jvmtiMode) { |
| // Do not allow values to cross instruction boundaries |
| // on a temporary registers |
| vpark(); |
| // We must have GC info at every bytecode instruction |
| // to support possible enumeration at a breakpoint |
| gen_gc_stack(-1, false); |
| } |
| |
| const bool has_fall_through = !jinst.is_set(OPF_DEAD_END); |
| if (lastInBB && has_fall_through && jinst.get_num_targets() == 0) { |
| gen_bb_leave(jinst.next); |
| } |
| } |
| |
| void Compiler::handle_ik_a(const JInst& jinst) { |
| |
| if (jinst.opcode == OPCODE_IINC) { |
| gen_iinc(jinst.op0, jinst.op1); |
| return; |
| } |
| |
| switch(jinst.opcode) { |
| case OPCODE_LCMP: |
| gen_x_cmp(jinst.opcode, i64); |
| return; |
| case OPCODE_FCMPL: |
| case OPCODE_FCMPG: |
| gen_x_cmp(jinst.opcode, flt32); |
| return; |
| case OPCODE_DCMPL: |
| case OPCODE_DCMPG: |
| gen_x_cmp(jinst.opcode, dbl64); |
| return; |
| default: break; |
| } |
| |
| jtype opnd = jvoid; |
| JavaByteCodes inst = jinst.opcode; |
| |
| switch(jinst.opcode) { |
| case OPCODE_IADD: opnd = i32; inst = OPCODE_IADD; break; |
| case OPCODE_LADD: opnd = i64; inst = OPCODE_IADD; break; |
| case OPCODE_FADD: opnd = flt32; inst = OPCODE_IADD; break; |
| case OPCODE_DADD: opnd = dbl64; inst = OPCODE_IADD; break; |
| |
| case OPCODE_ISUB: opnd = i32; inst = OPCODE_ISUB; break; |
| case OPCODE_LSUB: opnd = i64; inst = OPCODE_ISUB; break; |
| case OPCODE_FSUB: opnd = flt32; inst = OPCODE_ISUB; break; |
| case OPCODE_DSUB: opnd = dbl64; inst = OPCODE_ISUB; break; |
| |
| case OPCODE_IMUL: opnd = i32; inst = OPCODE_IMUL; break; |
| case OPCODE_LMUL: opnd = i64; inst = OPCODE_IMUL; break; |
| case OPCODE_FMUL: opnd = flt32; inst = OPCODE_IMUL; break; |
| case OPCODE_DMUL: opnd = dbl64; inst = OPCODE_IMUL; break; |
| |
| case OPCODE_IDIV: opnd = i32; inst = OPCODE_IDIV; break; |
| case OPCODE_LDIV: opnd = i64; inst = OPCODE_IDIV; break; |
| case OPCODE_FDIV: opnd = flt32; inst = OPCODE_IDIV; break; |
| case OPCODE_DDIV: opnd = dbl64; inst = OPCODE_IDIV; break; |
| |
| case OPCODE_IREM: opnd = i32; inst = OPCODE_IREM; break; |
| case OPCODE_LREM: opnd = i64; inst = OPCODE_IREM; break; |
| case OPCODE_FREM: opnd = flt32; inst = OPCODE_IREM; break; |
| case OPCODE_DREM: opnd = dbl64; inst = OPCODE_IREM; break; |
| |
| case OPCODE_INEG: opnd = i32; inst = OPCODE_INEG; break; |
| case OPCODE_LNEG: opnd = i64; inst = OPCODE_INEG; break; |
| case OPCODE_FNEG: opnd = flt32; inst = OPCODE_INEG; break; |
| case OPCODE_DNEG: opnd = dbl64; inst = OPCODE_INEG; break; |
| |
| case OPCODE_ISHL: opnd = i32; inst = OPCODE_ISHL; break; |
| case OPCODE_LSHL: opnd = i64; inst = OPCODE_ISHL; break; |
| |
| case OPCODE_ISHR: opnd = i32; inst = OPCODE_ISHR; break; |
| case OPCODE_LSHR: opnd = i64; inst = OPCODE_ISHR; break; |
| |
| case OPCODE_IUSHR: opnd = i32; inst = OPCODE_IUSHR; break; |
| case OPCODE_LUSHR: opnd = i64; inst = OPCODE_IUSHR; break; |
| |
| case OPCODE_IAND: opnd = i32; inst = OPCODE_IAND; break; |
| case OPCODE_LAND: opnd = i64; inst = OPCODE_IAND; break; |
| |
| case OPCODE_IOR: opnd = i32; inst = OPCODE_IOR; break; |
| case OPCODE_LOR: opnd = i64; inst = OPCODE_IOR; break; |
| |
| case OPCODE_IXOR: opnd = i32; inst = OPCODE_IXOR; break; |
| case OPCODE_LXOR: opnd = i64; inst = OPCODE_IXOR; break; |
| default: assert(false); break; |
| } |
| |
| if ((inst == OPCODE_IDIV || inst == OPCODE_IREM ) && |
| (opnd == i32 || opnd == i64)) { |
| gen_check_div_by_zero(opnd, 0); |
| } |
| gen_a(inst, opnd); |
| } |
| |
| void Compiler::handle_ik_cf(const JInst& jinst) { |
| switch(jinst.opcode) { |
| case OPCODE_IFNULL: |
| case OPCODE_IFNONNULL: |
| case OPCODE_IFEQ: |
| case OPCODE_IFNE: |
| case OPCODE_IFLT: |
| case OPCODE_IFGE: |
| case OPCODE_IFGT: |
| case OPCODE_IFLE: |
| gen_if(jinst.opcode, jinst.get_target(0)); |
| break; |
| case OPCODE_IF_ACMPEQ: |
| case OPCODE_IF_ACMPNE: |
| case OPCODE_IF_ICMPEQ: |
| case OPCODE_IF_ICMPNE: |
| case OPCODE_IF_ICMPLT: |
| case OPCODE_IF_ICMPGE: |
| case OPCODE_IF_ICMPGT: |
| case OPCODE_IF_ICMPLE: |
| gen_if_icmp(jinst.opcode, jinst.get_target(0)); |
| break; |
| case OPCODE_GOTO: |
| case OPCODE_GOTO_W: |
| gen_goto(jinst.get_target(0)); |
| break; |
| case OPCODE_JSR: |
| case OPCODE_JSR_W: |
| gen_jsr(jinst.get_target(0)); |
| break; |
| case OPCODE_RET: |
| gen_ret(jinst.op0); |
| break; |
| case OPCODE_TABLESWITCH: |
| case OPCODE_LOOKUPSWITCH: |
| gen_switch(jinst); |
| break; |
| default: assert(false); break; |
| } |
| } |
| |
| |
| void Compiler::handle_ik_cnv(const JInst& jinst) |
| { |
| jtype from, to; |
| switch(jinst.opcode) { |
| case OPCODE_I2B: from = i32; to = i8; break; |
| case OPCODE_I2C: from = i32; to = u16; break; |
| case OPCODE_I2S: from = i32; to = i16; break; |
| case OPCODE_I2L: from = i32; to = i64; break; |
| case OPCODE_I2F: from = i32; to = flt32; break; |
| case OPCODE_I2D: from = i32; to = dbl64; break; |
| |
| case OPCODE_L2I: from = i64; to = i32; break; |
| case OPCODE_L2F: from = i64; to = flt32; break; |
| case OPCODE_L2D: from = i64; to = dbl64; break; |
| |
| case OPCODE_F2I: from = flt32; to = i32; break; |
| case OPCODE_F2L: from = flt32; to = i64; break; |
| case OPCODE_F2D: from = flt32; to = dbl64; break; |
| |
| case OPCODE_D2I: from = dbl64; to = i32; break; |
| case OPCODE_D2L: from = dbl64; to = i64; break; |
| case OPCODE_D2F: from = dbl64; to = flt32; break; |
| |
| default: assert(false); from = to = jvoid; break; |
| }// ~switch opcode |
| gen_cnv(from, to); |
| } |
| |
| void Compiler::handle_ik_ls(const JInst& jinst) { |
| switch(jinst.opcode) { |
| case OPCODE_ICONST_M1: gen_push((int)-1); break; |
| case OPCODE_ICONST_0: gen_push((int)0); break; |
| case OPCODE_ICONST_1: gen_push((int)1); break; |
| case OPCODE_ICONST_2: gen_push((int)2); break; |
| case OPCODE_ICONST_3: gen_push((int)3); break; |
| case OPCODE_ICONST_4: gen_push((int)4); break; |
| case OPCODE_ICONST_5: gen_push((int)5); break; |
| |
| case OPCODE_LCONST_0: gen_push((jlong)0); break; |
| case OPCODE_LCONST_1: gen_push((jlong)1); break; |
| |
| case OPCODE_FCONST_0: gen_push(flt32, &g_fconst_0); break; |
| case OPCODE_FCONST_1: gen_push(flt32, &g_fconst_1); break; |
| case OPCODE_FCONST_2: gen_push(flt32, &g_fconst_2); break; |
| |
| case OPCODE_DCONST_0: gen_push(dbl64, &g_dconst_0); break; |
| case OPCODE_DCONST_1: gen_push(dbl64, &g_dconst_1); break; |
| |
| case OPCODE_LDC: |
| case OPCODE_LDC_W: |
| case OPCODE_LDC2_W: |
| gen_ldc(); |
| break; |
| case OPCODE_SIPUSH: |
| gen_push((int)(short)(unsigned short)jinst.op0); |
| break; |
| case OPCODE_BIPUSH: |
| gen_push((int)(char)(unsigned char)jinst.op0); |
| break; |
| |
| case OPCODE_ASTORE: |
| assert(m_jframe->top() == jobj || m_jframe->top() == jretAddr); |
| gen_st(m_jframe->top(), jinst.op0); |
| break; |
| case OPCODE_ISTORE: gen_st(i32, jinst.op0); break; |
| case OPCODE_LSTORE: gen_st(i64, jinst.op0); break; |
| |
| case OPCODE_FSTORE: gen_st(flt32, jinst.op0); break; |
| |
| case OPCODE_DSTORE: gen_st(dbl64, jinst.op0); break; |
| |
| case OPCODE_ISTORE_0: |
| case OPCODE_ISTORE_1: |
| case OPCODE_ISTORE_2: |
| case OPCODE_ISTORE_3: |
| gen_st(i32, jinst.opcode-OPCODE_ISTORE_0); |
| break; |
| case OPCODE_LSTORE_0: |
| case OPCODE_LSTORE_1: |
| case OPCODE_LSTORE_2: |
| case OPCODE_LSTORE_3: |
| gen_st(i64, jinst.opcode-OPCODE_LSTORE_0); |
| break; |
| case OPCODE_FSTORE_0: |
| case OPCODE_FSTORE_1: |
| case OPCODE_FSTORE_2: |
| case OPCODE_FSTORE_3: |
| gen_st(flt32, jinst.opcode-OPCODE_FSTORE_0); |
| break; |
| case OPCODE_DSTORE_0: |
| case OPCODE_DSTORE_1: |
| case OPCODE_DSTORE_2: |
| case OPCODE_DSTORE_3: |
| gen_st(dbl64, jinst.opcode-OPCODE_DSTORE_0); |
| break; |
| case OPCODE_ASTORE_0: |
| case OPCODE_ASTORE_1: |
| case OPCODE_ASTORE_2: |
| case OPCODE_ASTORE_3: |
| assert(m_jframe->top() == jobj || m_jframe->top() == jretAddr); |
| gen_st(m_jframe->top(), jinst.opcode-OPCODE_ASTORE_0); |
| break; |
| |
| case OPCODE_ILOAD: gen_ld(i32, jinst.op0); break; |
| case OPCODE_LLOAD: gen_ld(i64, jinst.op0); break; |
| |
| case OPCODE_FLOAD: gen_ld(flt32, jinst.op0); break; |
| |
| case OPCODE_DLOAD: gen_ld(dbl64, jinst.op0); break; |
| case OPCODE_ALOAD: gen_ld(jobj, jinst.op0); break; |
| |
| case OPCODE_ILOAD_0: |
| case OPCODE_ILOAD_1: |
| case OPCODE_ILOAD_2: |
| case OPCODE_ILOAD_3: |
| gen_ld(i32, jinst.opcode-OPCODE_ILOAD_0); |
| break; |
| case OPCODE_LLOAD_0: |
| case OPCODE_LLOAD_1: |
| case OPCODE_LLOAD_2: |
| case OPCODE_LLOAD_3: |
| gen_ld(i64, jinst.opcode-OPCODE_LLOAD_0); |
| break; |
| case OPCODE_FLOAD_0: |
| case OPCODE_FLOAD_1: |
| case OPCODE_FLOAD_2: |
| case OPCODE_FLOAD_3: |
| gen_ld(flt32, jinst.opcode-OPCODE_FLOAD_0); |
| break; |
| case OPCODE_DLOAD_0: |
| case OPCODE_DLOAD_1: |
| case OPCODE_DLOAD_2: |
| case OPCODE_DLOAD_3: |
| gen_ld(dbl64, jinst.opcode-OPCODE_DLOAD_0); |
| break; |
| case OPCODE_ALOAD_0: |
| case OPCODE_ALOAD_1: |
| case OPCODE_ALOAD_2: |
| case OPCODE_ALOAD_3: |
| gen_ld(jobj, jinst.opcode-OPCODE_ALOAD_0); |
| break; |
| case OPCODE_ACONST_NULL: |
| gen_push(jobj, NULL_REF); |
| break; |
| default: assert(false); break; |
| } |
| } |
| |
| void Compiler::handle_ik_meth(const JInst& jinst) { |
| if (jinst.opcode == OPCODE_INVOKESTATIC || |
| jinst.opcode == OPCODE_INVOKESPECIAL || |
| jinst.opcode == OPCODE_INVOKEVIRTUAL || |
| jinst.opcode == OPCODE_INVOKEINTERFACE) { |
| |
| |
| JavaByteCodes opkod = jinst.opcode; |
| ::std::vector<jtype> args; |
| jtype retType; |
| bool is_static = opkod == OPCODE_INVOKESTATIC; |
| get_args_info(is_static, jinst.op0, args, &retType); |
| |
| Method_Handle meth = NULL; |
| unsigned short cpIndex = (unsigned short)jinst.op0; |
| bool lazy = m_lazy_resolution; |
| bool resolve = !lazy || class_cp_is_entry_resolved(m_klass, cpIndex); |
| if (!resolve) { |
| assert(lazy); |
| gen_invoke(opkod, NULL, cpIndex, args, retType); |
| return; |
| } |
| if (opkod == OPCODE_INVOKESTATIC) { |
| meth = resolve_static_method(m_compileHandle, m_klass, |
| jinst.op0); |
| if (meth != NULL) { |
| Class_Handle klass = method_get_class(meth); |
| if (!class_is_initialized(klass)) { |
| gen_call_vm(ci_helper_o, rt_helper_init_class, 0, klass); |
| } |
| } |
| } |
| else if (opkod == OPCODE_INVOKEVIRTUAL) { |
| meth = resolve_virtual_method(m_compileHandle, m_klass, |
| jinst.op0); |
| } |
| else if (opkod == OPCODE_INVOKEINTERFACE) { |
| // BUG and HACK - all in one: |
| // An 'org/eclipse/ui/keys/KeyStroke::hashCode' (e3.0) does |
| // invokeinterface on java/util/SortedSet::hashCode(), but the |
| // entry get resolved into the 'java/lang/Object::hashCode' ! |
| // later: for eclipse 3.1.1 the same problem happens with |
| // org/eclipse/jdt/internal/core/JavaProject::equals |
| // which tries to resolve |
| // 'org/eclipse/core/resources/IProject::equals (Ljava/lang/Object;)Z' |
| meth = resolve_interface_method(m_compileHandle, m_klass, jinst.op0); |
| // |
| //*** workaround here: |
| if (meth != NULL && |
| !class_is_interface(method_get_class(meth))) { |
| opkod = OPCODE_INVOKEVIRTUAL; |
| } |
| } |
| else { |
| assert(opkod == OPCODE_INVOKESPECIAL); |
| meth = resolve_special_method(m_compileHandle, m_klass, jinst.op0); |
| } |
| // if class to call to is available, but method is not found in the class |
| // meth here will be equal to NULL and lazy resolution call will be |
| // generated in gen_invoke |
| gen_invoke(opkod, meth, cpIndex, args, retType); |
| return; |
| } |
| switch(jinst.opcode) { |
| case OPCODE_IRETURN: { |
| SYNC_FIRST(static const CallSig cs(CCONV_MANAGED, i32)); |
| gen_return(cs); |
| break; |
| } |
| case OPCODE_LRETURN: { |
| SYNC_FIRST(static const CallSig cs(CCONV_MANAGED, i64)); |
| gen_return(cs); |
| break; |
| } |
| case OPCODE_FRETURN: { |
| SYNC_FIRST(static const CallSig cs(CCONV_MANAGED, flt32)); |
| gen_return(cs); |
| break; |
| } |
| case OPCODE_DRETURN: { |
| SYNC_FIRST(static const CallSig cs(CCONV_MANAGED, dbl64)); |
| gen_return(cs); |
| break; |
| } |
| case OPCODE_ARETURN: { |
| SYNC_FIRST(static const CallSig cs(CCONV_MANAGED, jobj)); |
| gen_return(cs); |
| break; |
| } |
| case OPCODE_RETURN: { |
| SYNC_FIRST(static const CallSig cs(CCONV_MANAGED, jvoid)); |
| gen_return(cs); |
| break; |
| } |
| default: assert(false); break; |
| }; |
| } |
| |
| void Compiler::handle_ik_obj(const JInst& jinst) { |
| jtype jt = jvoid; |
| bool store = false; |
| switch(jinst.opcode) { |
| case OPCODE_IASTORE: store = true; |
| case OPCODE_IALOAD: jt = i32; break; |
| case OPCODE_LASTORE: store = true; |
| case OPCODE_LALOAD: jt = i64; break; |
| case OPCODE_FASTORE: store = true; |
| case OPCODE_FALOAD: jt = flt32; break; |
| case OPCODE_DASTORE: store = true; |
| case OPCODE_DALOAD: jt = dbl64; break; |
| case OPCODE_AASTORE: store = true; |
| case OPCODE_AALOAD: jt = jobj; break; |
| case OPCODE_BASTORE: store = true; |
| case OPCODE_BALOAD: jt = i8; break; |
| case OPCODE_CASTORE: store = true; |
| case OPCODE_CALOAD: jt = u16; break; |
| case OPCODE_SASTORE: store = true; |
| case OPCODE_SALOAD: jt = i16; break; |
| default: break; |
| } |
| if (jt != jvoid) { |
| // that was indeed *aload/*astore |
| if (store) { |
| gen_arr_store(jt); |
| } |
| else { |
| gen_arr_load(jt); |
| } |
| return; |
| } |
| |
| switch(jinst.opcode) { |
| case OPCODE_NEW: |
| gen_new(m_klass, (unsigned short)jinst.op0); |
| break; |
| case OPCODE_PUTSTATIC: |
| case OPCODE_GETSTATIC: |
| case OPCODE_PUTFIELD: |
| case OPCODE_GETFIELD: |
| gen_field_op(jinst.opcode, m_klass, (unsigned short)jinst.op0); |
| break; |
| case OPCODE_ARRAYLENGTH: |
| gen_array_length(); |
| break; |
| case OPCODE_ANEWARRAY: |
| gen_new_array(m_klass, (unsigned short)jinst.op0); |
| break; |
| case OPCODE_NEWARRAY: |
| { |
| VM_Data_Type atype; |
| switch(jinst.op0) { |
| case 4: atype = VM_DATA_TYPE_BOOLEAN; break; |
| case 5: atype = VM_DATA_TYPE_CHAR; break; |
| case 6: atype = VM_DATA_TYPE_F4; break; |
| case 7: atype = VM_DATA_TYPE_F8; break; |
| case 8: atype = VM_DATA_TYPE_INT8; break; |
| case 9: atype = VM_DATA_TYPE_INT16; break; |
| case 10: atype = VM_DATA_TYPE_INT32; break; |
| case 11: atype = VM_DATA_TYPE_INT64; break; |
| default: assert(false); atype = VM_DATA_TYPE_INVALID; break; |
| } |
| Class_Handle elem_class = class_get_class_of_primitive_type(atype); |
| Class_Handle array_class = class_get_array_of_class(elem_class); |
| Allocation_Handle ah = class_get_allocation_handle(array_class); |
| gen_new_array(ah); |
| } |
| break; |
| case OPCODE_MULTIANEWARRAY: |
| gen_multianewarray(m_klass, (unsigned short)jinst.op0, jinst.op1); |
| break; |
| case OPCODE_MONITORENTER: |
| case OPCODE_MONITOREXIT: |
| gen_monitor_ee(); |
| break; |
| case OPCODE_CHECKCAST: |
| case OPCODE_INSTANCEOF: |
| gen_instanceof_cast(jinst.opcode, m_klass, (unsigned short)jinst.op0); |
| break; |
| default: assert(false); break; |
| } |
| } |
| |
| void Compiler::handle_ik_stack(const JInst& jinst) { |
| switch(jinst.opcode) { |
| case OPCODE_POP: |
| gen_pop(m_jframe->top()); |
| break; |
| case OPCODE_POP2: |
| gen_pop2(); |
| break; |
| case OPCODE_DUP: |
| case OPCODE_DUP_X1: |
| case OPCODE_DUP_X2: |
| case OPCODE_DUP2: |
| case OPCODE_DUP2_X1: |
| case OPCODE_DUP2_X2: |
| case OPCODE_SWAP: |
| gen_dup(jinst.opcode); |
| break; |
| default: assert(false); break; |
| } |
| } |
| |
| } |
| } // ~namespace Jitrino::Jet |
| |
| |
