X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Farm%2Femit.c;h=f5617cd85cbc926b79e2e4d6c300c7eee1f81a93;hb=f703b1265fbfb70a3de51067803b6b211d5c5d4d;hp=10f80399ff23cbcafb8be7d27f75d4759e75cfb4;hpb=e43fc4543199b53e28099528f658a525bac7200b;p=cacao.git diff --git a/src/vm/jit/arm/emit.c b/src/vm/jit/arm/emit.c index 10f80399f..f5617cd85 100644 --- a/src/vm/jit/arm/emit.c +++ b/src/vm/jit/arm/emit.c @@ -1,9 +1,7 @@ /* src/vm/jit/arm/emit.c - Arm code emitter functions - Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel, - C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring, - E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, - J. Wenninger, Institut f. Computersprachen - TU Wien + Copyright (C) 1996-2005, 2006, 2007, 2008 + CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO This file is part of CACAO. @@ -22,14 +20,13 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - $Id: emit.c 4398 2006-01-31 23:43:08Z twisti $ - */ #include "config.h" #include +#include #include "vm/types.h" @@ -37,21 +34,22 @@ #include "vm/jit/arm/codegen.h" -#include "mm/memory.h" +#include "mm/memory.hpp" -#include "threads/lock-common.h" +#include "threads/lock.hpp" -#include "vm/builtin.h" -#include "vm/exceptions.h" #include "vm/global.h" #include "vm/jit/abi.h" #include "vm/jit/asmpart.h" -#include "vm/jit/emit-common.h" -#include "vm/jit/jit.h" -#include "vm/jit/replace.h" +#include "vm/jit/emit-common.hpp" +#include "vm/jit/jit.hpp" +#include "vm/jit/patcher-common.hpp" +#include "vm/jit/replace.hpp" +#include "vm/jit/trace.hpp" +#include "vm/jit/trap.hpp" -#include "toolbox/logging.h" /* XXX for debugging only */ +#include "toolbox/logging.hpp" /* XXX for debugging only */ /* emit_load ******************************************************************* @@ -73,7 +71,7 @@ s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg) if (src->flags & INMEMORY) { COUNT_SPILLS; - disp = src->vv.regoff * 4; + disp = src->vv.regoff; #if defined(ENABLE_SOFTFLOAT) switch (src->type) { @@ -139,7 +137,7 @@ s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg) if (src->flags & INMEMORY) { COUNT_SPILLS; - disp = src->vv.regoff * 4; + disp = src->vv.regoff; #if defined(__ARMEL__) M_ILD(tempreg, REG_SP, disp); @@ -177,7 +175,7 @@ s4 emit_load_high(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg) if (src->flags & INMEMORY) { COUNT_SPILLS; - disp = src->vv.regoff * 4; + disp = src->vv.regoff; #if defined(__ARMEL__) M_ILD(tempreg, REG_SP, disp + 4); @@ -212,7 +210,7 @@ void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d) if (dst->flags & INMEMORY) { COUNT_SPILLS; - disp = dst->vv.regoff * 4; + disp = dst->vv.regoff; #if defined(ENABLE_SOFTFLOAT) switch (dst->type) { @@ -385,6 +383,27 @@ void emit_iconst(codegendata *cd, s4 d, s4 value) } +/** + * Emits code updating the condition register by comparing one integer + * register to an immediate integer value. + */ +void emit_icmp_imm(codegendata* cd, int reg, int32_t value) +{ + int32_t disp; + + if (IS_IMM(value)) { + M_CMP_IMM(reg, value); + } else if (IS_IMM(-value)) { + M_CMN_IMM(reg, -value); + } else { + assert(reg != REG_ITMP3); + disp = dseg_add_s4(cd, value); + M_DSEG_LOAD(REG_ITMP3, disp); + M_CMP(reg, REG_ITMP3); + } +} + + /* emit_branch ***************************************************************** Emits the code for conditional and unconditional branchs. @@ -475,7 +494,7 @@ void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg) if (INSTRUCTION_MUST_CHECK(iptr)) { CHECK_INT_REG(reg); M_TEQ_IMM(reg, 0); - M_TRAPEQ(0, EXCEPTION_HARDWARE_ARITHMETIC); + M_TRAPEQ(0, TRAP_ArithmeticException); } } @@ -490,14 +509,14 @@ void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg) { if (INSTRUCTION_MUST_CHECK(iptr)) { M_TST(reg, reg); - M_TRAPEQ(0, EXCEPTION_HARDWARE_NULLPOINTER); + M_TRAPEQ(0, TRAP_NullPointerException); } } void emit_nullpointer_check_force(codegendata *cd, instruction *iptr, s4 reg) { M_TST(reg, reg); - M_TRAPEQ(0, EXCEPTION_HARDWARE_NULLPOINTER); + M_TRAPEQ(0, TRAP_NullPointerException); } @@ -510,9 +529,24 @@ void emit_nullpointer_check_force(codegendata *cd, instruction *iptr, s4 reg) void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2) { if (INSTRUCTION_MUST_CHECK(iptr)) { - M_ILD_INTERN(REG_ITMP3, s1, OFFSET(java_arrayheader, size)); + M_ILD_INTERN(REG_ITMP3, s1, OFFSET(java_array_t, size)); M_CMP(s2, REG_ITMP3); - M_TRAPHS(s2, EXCEPTION_HARDWARE_ARRAYINDEXOUTOFBOUNDS); + M_TRAPHS(s2, TRAP_ArrayIndexOutOfBoundsException); + } +} + + +/* emit_arraystore_check ******************************************************* + + Emit an ArrayStoreException check. + +*******************************************************************************/ + +void emit_arraystore_check(codegendata *cd, instruction *iptr) +{ + if (INSTRUCTION_MUST_CHECK(iptr)) { + M_TST(REG_RESULT, REG_RESULT); + M_TRAPEQ(0, TRAP_ArrayStoreException); } } @@ -528,15 +562,23 @@ void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 r if (INSTRUCTION_MUST_CHECK(iptr)) { switch (condition) { case BRANCH_EQ: - M_TRAPEQ(s1, EXCEPTION_HARDWARE_CLASSCAST); + M_TRAPEQ(s1, TRAP_ClassCastException); + break; + + case BRANCH_NE: + M_TRAPNE(s1, TRAP_ClassCastException); + break; + + case BRANCH_LT: + M_TRAPLT(s1, TRAP_ClassCastException); break; case BRANCH_LE: - M_TRAPLE(s1, EXCEPTION_HARDWARE_CLASSCAST); + M_TRAPLE(s1, TRAP_ClassCastException); break; case BRANCH_UGT: - M_TRAPHI(s1, EXCEPTION_HARDWARE_CLASSCAST); + M_TRAPHI(s1, TRAP_ClassCastException); break; default: @@ -555,159 +597,162 @@ void emit_exception_check(codegendata *cd, instruction *iptr) { if (INSTRUCTION_MUST_CHECK(iptr)) { M_TST(REG_RESULT, REG_RESULT); - M_TRAPEQ(0, EXCEPTION_HARDWARE_EXCEPTION); + M_TRAPEQ(0, TRAP_CHECK_EXCEPTION); } } -/* emit_patcher_stubs ********************************************************** +/* emit_trap_compiler ********************************************************** - Generates the code for the patcher stubs. + Emit a trap instruction which calls the JIT compiler. *******************************************************************************/ -void emit_patcher_stubs(jitdata *jd) +void emit_trap_compiler(codegendata *cd) { - codegendata *cd; - patchref *pref; - u4 mcode; - u1 *savedmcodeptr; - u1 *tmpmcodeptr; - s4 targetdisp; - s4 disp; - - /* get required compiler data */ - - cd = jd->cd; - - /* generate patcher stub call code */ - - targetdisp = 0; - - for (pref = cd->patchrefs; pref != NULL; pref = pref->next) { - /* check code segment size */ - - MCODECHECK(100); - - /* Get machine code which is patched back in later. The - call is 1 instruction word long. */ - - tmpmcodeptr = (u1 *) (cd->mcodebase + pref->branchpos); - - mcode = *((u4 *) tmpmcodeptr); + M_TRAP(REG_METHODPTR, TRAP_COMPILER); +} - /* Patch in the call to call the following code (done at - compile time). */ - savedmcodeptr = cd->mcodeptr; /* save current mcodeptr */ - cd->mcodeptr = tmpmcodeptr; /* set mcodeptr to patch position */ +/* emit_trap ******************************************************************* - disp = ((u4 *) savedmcodeptr) - (((u4 *) tmpmcodeptr) + 2); - M_B(disp); + Emit a trap instruction and return the original machine code. - cd->mcodeptr = savedmcodeptr; /* restore the current mcodeptr */ +*******************************************************************************/ - /* create stack frame (align stack to 8-byte) */ +uint32_t emit_trap(codegendata *cd) +{ + uint32_t mcode; - M_SUB_IMM(REG_SP, REG_SP, 8 * 4); + /* Get machine code which is patched back in later. The + trap is 1 instruction word long. */ - /* save itmp3 onto stack */ + mcode = *((uint32_t *) cd->mcodeptr); - M_STR_INTERN(REG_ITMP3, REG_SP, 6 * 4); + M_TRAP(0, TRAP_PATCHER); - /* calculate return address and move it onto stack */ - /* ATTENTION: we can not use BL to branch to patcher stub, */ - /* ATTENTION: because we need to preserve LR for leaf methods */ + return mcode; +} - disp = (s4) (((u4 *) cd->mcodeptr) - (((u4 *) tmpmcodeptr) + 1) + 2); - M_SUB_IMM_EXT_MUL4(REG_ITMP3, REG_PC, disp); - M_STR_INTERN(REG_ITMP3, REG_SP, 4 * 4); +/** + * Emit code to recompute the procedure vector. + */ +void emit_recompute_pv(codegendata *cd) +{ + // This is used to recompute our PV (we use the IP for this) out + // of the current PC. + int32_t disp = (int32_t) (cd->mcodeptr - cd->mcodebase); + + // We use PC relative addressing. + disp += 8; + + // Sanity checks. + assert((disp & 0x03) == 0); + assert(disp >= 0 && disp <= 0x03ffffff); + + // ATTENTION: If you change this, you have to look at other functions + // as well! Following things depend on it: md_codegen_get_pv_from_pc(); + if (disp > 0x0003ffff) { + M_SUB_IMM(REG_PV, REG_PC, IMM_ROTL(disp >> 18, 9)); + M_SUB_IMM(REG_PV, REG_PV, IMM_ROTL(disp >> 10, 5)); + M_SUB_IMM(REG_PV, REG_PV, IMM_ROTL(disp >> 2, 1)); + } else if (disp > 0x000003ff) { + M_SUB_IMM(REG_PV, REG_PC, IMM_ROTL(disp >> 10, 5)); + M_SUB_IMM(REG_PV, REG_PV, IMM_ROTL(disp >> 2, 1)); + } else { + M_SUB_IMM(REG_PV, REG_PC, IMM_ROTL(disp >> 2, 1)); + } +} - /* move pointer to java_objectheader onto stack */ +/** + * Generates synchronization code to enter a monitor. + */ #if defined(ENABLE_THREADS) - /* order reversed because of data segment layout */ +void emit_monitor_enter(jitdata* jd, int32_t syncslot_offset) +{ + int32_t disp; - (void) dseg_add_unique_address(cd, NULL); /* flcword */ - (void) dseg_add_unique_address(cd, lock_get_initial_lock_word()); - disp = dseg_add_unique_address(cd, NULL); /* vftbl */ + // Get required compiler data. + methodinfo* m = jd->m; + codegendata* cd = jd->cd; - M_SUB_IMM_EXT_MUL4(REG_ITMP3, REG_PV, -disp / 4); - M_STR_INTERN(REG_ITMP3, REG_SP, 3 * 4); -#else - M_EOR(REG_ITMP3, REG_ITMP3, REG_ITMP3); - M_STR_INTERN(REG_ITMP3, REG_SP, 3 * 4); -#endif - - /* move machine code onto stack */ +# if !defined(NDEBUG) + if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) { + M_STMFD(BITMASK_ARGS, REG_SP); + syncslot_offset += 4 * 4; + } +# endif - disp = dseg_add_unique_s4(cd, mcode); - M_DSEG_LOAD(REG_ITMP3, disp); - M_STR_INTERN(REG_ITMP3, REG_SP, 2 * 4); + /* get the correct lock object */ - /* move class/method/field reference onto stack */ + if (m->flags & ACC_STATIC) { + disp = dseg_add_address(cd, &m->clazz->object.header); + M_DSEG_LOAD(REG_A0, disp); + } + else { + emit_nullpointer_check_force(cd, NULL, REG_A0); + } - disp = dseg_add_unique_address(cd, pref->ref); - M_DSEG_LOAD(REG_ITMP3, disp); - M_STR_INTERN(REG_ITMP3, REG_SP, 1 * 4); + M_STR(REG_A0, REG_SP, syncslot_offset); + disp = dseg_add_functionptr(cd, LOCK_monitor_enter); + M_DSEG_BRANCH(disp); + emit_recompute_pv(cd); - /* move data segment displacement onto stack */ +# if !defined(NDEBUG) + if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) + M_LDMFD(BITMASK_ARGS, REG_SP); +# endif +} +#endif - disp = dseg_add_unique_s4(cd, pref->disp); - M_DSEG_LOAD(REG_ITMP3, disp); - M_STR_INTERN(REG_ITMP3, REG_SP, 5 * 4); - /* move patcher function pointer onto stack */ +/** + * Generates synchronization code to leave a monitor. + */ +#if defined(ENABLE_THREADS) +void emit_monitor_exit(jitdata* jd, int32_t syncslot_offset) +{ + int32_t disp; - disp = dseg_add_functionptr(cd, pref->patcher); - M_DSEG_LOAD(REG_ITMP3, disp); - M_STR_INTERN(REG_ITMP3, REG_SP, 0 * 4); + // Get required compiler data. + methodinfo* m = jd->m; + codegendata* cd = jd->cd; - /* finally call the patcher via asm_patcher_wrapper */ - /* ATTENTION: don't use REG_PV here, because some patchers need it */ + /* we need to save the proper return value */ - if (targetdisp == 0) { - targetdisp = ((u4 *) cd->mcodeptr) - ((u4 *) cd->mcodebase); + methoddesc* md = m->parseddesc; - disp = dseg_add_functionptr(cd, asm_patcher_wrapper); - /*M_DSEG_BRANCH_NOLINK(REG_PC, REG_PV, a);*/ - /* TODO: this is only a hack */ - M_DSEG_LOAD(REG_ITMP3, disp); - M_MOV(REG_PC, REG_ITMP3); - } - else { - disp = (((u4 *) cd->mcodebase) + targetdisp) - - (((u4 *) cd->mcodeptr) + 2); - - M_B(disp); - } + switch (md->returntype.type) { + case TYPE_INT: + case TYPE_ADR: + case TYPE_LNG: + case TYPE_FLT: /* XXX TWISTI: is that correct? */ + case TYPE_DBL: + M_STMFD(BITMASK_RESULT, REG_SP); + syncslot_offset += 2 * 4; + break; } -} + M_LDR(REG_A0, REG_SP, syncslot_offset); + disp = dseg_add_functionptr(cd, LOCK_monitor_exit); + M_DSEG_BRANCH(disp); -/* emit_replacement_stubs ****************************************************** + /* we no longer need PV here, no more loading */ + /*emit_recompute_pv(cd);*/ - Generates the code for the replacement stubs. - -*******************************************************************************/ - -#if defined(ENABLE_REPLACEMENT) -void emit_replacement_stubs(jitdata *jd) -{ - codegendata *cd; - codeinfo *code; - rplpoint *rplp; - u1 *savedmcodeptr; - s4 disp; - s4 i; - - /* get required compiler data */ - - cd = jd->cd; - code = jd->code; + switch (md->returntype.type) { + case TYPE_INT: + case TYPE_ADR: + case TYPE_LNG: + case TYPE_FLT: /* XXX TWISTI: is that correct? */ + case TYPE_DBL: + M_LDMFD(BITMASK_RESULT, REG_SP); + break; + } } -#endif /* defined(ENABLE_REPLACEMENT) */ +#endif /* emit_verbosecall_enter ****************************************************** @@ -723,9 +768,8 @@ void emit_verbosecall_enter(jitdata *jd) codegendata *cd; registerdata *rd; methoddesc *md; - s4 stackframesize; s4 disp; - s4 i, t, s1, s2; + s4 i, s; /* get required compiler data */ @@ -735,87 +779,65 @@ void emit_verbosecall_enter(jitdata *jd) md = m->parseddesc; - /* stackframesize is changed below */ - - stackframesize = cd->stackframesize; - /* mark trace code */ M_NOP; - /* Save argument registers to stack (including LR and PV). Keep - stack 8-byte aligned. */ - - M_STMFD(BITMASK_ARGS | (1<paramcount - 1; - - if (i > 3) - i = 3; + /* Keep stack 8-byte aligned. */ - for (; i >= 0; i--) { - t = md->paramtypes[i].type; + M_STMFD((1<paramcount * 8); - /* load argument into register (s1) and make it of TYPE_LNG */ + /* save argument registers */ + for (i = 0; i < md->paramcount; i++) { if (!md->params[i].inmemory) { - s1 = md->params[i].regoff; + s = md->params[i].regoff; - if (!IS_2_WORD_TYPE(t)) { - M_MOV_IMM(REG_ITMP1, 0); - s1 = PACK_REGS(s1, REG_ITMP1); - } - } - else { - s1 = REG_ITMP12_PACKED; - s2 = md->params[i].regoff + stackframesize; - - if (IS_2_WORD_TYPE(t)) - M_LLD(s1, REG_SP, s2 * 4); - else { - M_ILD(GET_LOW_REG(s1), REG_SP, s2 * 4); - M_MOV_IMM(GET_HIGH_REG(s1), 0); + switch (md->paramtypes[i].type) { + case TYPE_INT: + case TYPE_FLT: + case TYPE_ADR: + M_IST(s, REG_SP, i * 8); + break; + case TYPE_LNG: + case TYPE_DBL: + M_LST(s, REG_SP, i * 8); + break; } } - - /* place argument for tracer */ - - if (i < 2) { -#if defined(__ARMEL__) - s2 = PACK_REGS(abi_registers_integer_argument[i * 2], - abi_registers_integer_argument[i * 2 + 1]); -#else /* defined(__ARMEB__) */ - s2 = PACK_REGS(abi_registers_integer_argument[i * 2 + 1], - abi_registers_integer_argument[i * 2]); -#endif - M_LNGMOVE(s1, s2); - } - else { - s2 = (i - 2) * 2; - M_LST(s1, REG_SP, s2 * 4); - } } - /* prepare methodinfo pointer for tracer */ - disp = dseg_add_address(cd, m); - M_DSEG_LOAD(REG_ITMP1, disp); - M_STR_INTERN(REG_ITMP1, REG_SP, 16); + M_DSEG_LOAD(REG_A0, disp); + M_MOV(REG_A1, REG_SP); + M_ADD_IMM(REG_A2, REG_SP, md->paramcount * 8 + 2 * 4 + cd->stackframesize * 8); + M_LONGBRANCH(trace_java_call_enter); - /* call tracer here (we use a long branch) */ + /* restore argument registers */ - M_LONGBRANCH(builtin_verbosecall_enter); + for (i = 0; i < md->paramcount; i++) { + if (!md->params[i].inmemory) { + s = md->params[i].regoff; - /* Restore argument registers from stack. Keep stack 8-byte - aligned. */ + switch (md->paramtypes[i].type) { + case TYPE_INT: + case TYPE_FLT: + case TYPE_ADR: + M_ILD(s, REG_SP, i * 8); + break; + case TYPE_LNG: + case TYPE_DBL: + M_LLD(s, REG_SP, i * 8); + break; + } + } + } - M_ADD_IMM(REG_SP, REG_SP, (2 + 2 + 1 + 1) * 4); /* free argument stack */ - M_LDMFD(BITMASK_ARGS | (1<paramcount * 8); + M_LDMFD((1<returntype.type) { case TYPE_ADR: case TYPE_INT: - M_INTMOVE(REG_RESULT, GET_LOW_REG(REG_A0_A1_PACKED)); - M_MOV_IMM(GET_HIGH_REG(REG_A0_A1_PACKED), 0); + case TYPE_FLT: + M_IST(REG_RESULT, REG_SP, 0 * 8); break; - case TYPE_LNG: - M_LNGMOVE(REG_RESULT_PACKED, REG_A0_A1_PACKED); + case TYPE_DBL: + M_LST(REG_RESULT_PACKED, REG_SP, 0 * 8); break; + } + + disp = dseg_add_address(cd, m); + M_DSEG_LOAD(REG_A0, disp); + M_MOV(REG_A1, REG_SP); + M_LONGBRANCH(trace_java_call_exit); + + /* restore return value */ + switch (md->returntype.type) { + case TYPE_ADR: + case TYPE_INT: case TYPE_FLT: - M_IST(REG_RESULT, REG_SP, 0 * 4); + M_ILD(REG_RESULT, REG_SP, 0 * 8); break; - + case TYPE_LNG: case TYPE_DBL: - M_LNGMOVE(REG_RESULT_PACKED, REG_A2_A3_PACKED); + M_LLD(REG_RESULT_PACKED, REG_SP, 0 * 8); break; } - disp = dseg_add_address(cd, m); - M_DSEG_LOAD(REG_ITMP1, disp); - M_AST(REG_ITMP1, REG_SP, 1 * 4); - M_LONGBRANCH(builtin_verbosecall_exit); - /* Keep stack 8-byte aligned. */ - M_ADD_IMM(REG_SP, REG_SP, (1 + 1) * 4); /* free argument stack */ - M_LDMFD(BITMASK_RESULT | (1<