X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Fi386%2Fcodegen.c;h=7d64347c3844b519b1f46b5d949d8867680fdc6a;hb=7659949229c634784f7d27aa8b679fdd4c8351ab;hp=5dcc2191da0af9d55f57518d0f5aa6184d59f799;hpb=6742bfb5845cc9c7932291620b4e8c90b67b1878;p=cacao.git diff --git a/src/vm/jit/i386/codegen.c b/src/vm/jit/i386/codegen.c index 5dcc2191d..7d64347c3 100644 --- a/src/vm/jit/i386/codegen.c +++ b/src/vm/jit/i386/codegen.c @@ -1,9 +1,7 @@ /* src/vm/jit/i386/codegen.c - machine code generator for i386 - 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: codegen.c 7754 2007-04-17 23:18:15Z twisti $ - */ #include "config.h" #include +#include #include #include "vm/types.h" @@ -41,28 +38,31 @@ #include "mm/memory.h" #include "native/jni.h" +#include "native/localref.h" #include "native/native.h" -#if defined(ENABLE_THREADS) -# include "threads/native/lock.h" -#endif +#include "threads/lock-common.h" #include "vm/builtin.h" #include "vm/exceptions.h" #include "vm/global.h" +#include "vm/primitive.hpp" #include "vm/stringlocal.h" #include "vm/vm.h" +#include "vm/jit/abi.h" #include "vm/jit/asmpart.h" #include "vm/jit/codegen-common.h" #include "vm/jit/dseg.h" #include "vm/jit/emit-common.h" #include "vm/jit/jit.h" +#include "vm/jit/linenumbertable.h" #include "vm/jit/parse.h" -#include "vm/jit/patcher.h" +#include "vm/jit/patcher-common.h" #include "vm/jit/reg.h" #include "vm/jit/replace.h" #include "vm/jit/stacktrace.h" +#include "vm/jit/trap.h" #if defined(ENABLE_SSA) # include "vm/jit/optimizing/lsra.h" @@ -82,12 +82,6 @@ *******************************************************************************/ -#if defined(ENABLE_SSA) -void cg_move(codegendata *cd, s4 type, s4 src_regoff, s4 src_flags, - s4 dst_regoff, s4 dst_flags); -void codegen_insert_phi_moves(jitdata *jd, basicblock *bptr); -#endif - bool codegen_emit(jitdata *jd) { methodinfo *m; @@ -95,10 +89,10 @@ bool codegen_emit(jitdata *jd) codegendata *cd; registerdata *rd; s4 len, s1, s2, s3, d, disp; + int align_off; /* offset for alignment compensation */ varinfo *var, *var1; basicblock *bptr; instruction *iptr; - exception_entry *ex; u2 currentline; methodinfo *lm; /* local methodinfo for ICMD_INVOKE* */ builtintable_entry *bte; @@ -139,9 +133,7 @@ bool codegen_emit(jitdata *jd) /* space to save used callee saved registers */ savedregs_num += (INT_SAV_CNT - rd->savintreguse); - - /* float register are saved on 2 4-byte stackslots */ - savedregs_num += (FLT_SAV_CNT - rd->savfltreguse) * 2; + savedregs_num += (FLT_SAV_CNT - rd->savfltreguse); cd->stackframesize = rd->memuse + savedregs_num; @@ -149,61 +141,36 @@ bool codegen_emit(jitdata *jd) #if defined(ENABLE_THREADS) /* space to save argument of monitor_enter */ - if (checksync && (m->flags & ACC_SYNCHRONIZED)) { - /* reserve 2 slots for long/double return values for monitorexit */ - - if (IS_2_WORD_TYPE(m->parseddesc->returntype.type)) - cd->stackframesize += 2; - else - cd->stackframesize++; - } + if (checksync && code_is_synchronized(code)) + cd->stackframesize++; #endif /* create method header */ /* Keep stack of non-leaf functions 16-byte aligned. */ - if (!jd->isleafmethod) - cd->stackframesize |= 0x3; + if (!code_is_leafmethod(code)) { + ALIGN_ODD(cd->stackframesize); + } + + align_off = cd->stackframesize ? 4 : 0; (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */ - (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */ + (void) dseg_add_unique_s4( + cd, cd->stackframesize * 8 + align_off); /* FrameSize */ -#if defined(ENABLE_THREADS) - /* IsSync contains the offset relative to the stack pointer for the - argument of monitor_exit used in the exception handler. Since the - offset could be zero and give a wrong meaning of the flag it is - offset by one. - */ - - if (checksync && (m->flags & ACC_SYNCHRONIZED)) - (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 4); /* IsSync */ + code->synchronizedoffset = rd->memuse * 8; + + /* REMOVEME: We still need it for exception handling in assembler. */ + + if (code_is_leafmethod(code)) + (void) dseg_add_unique_s4(cd, 1); /* IsLeaf */ else -#endif - (void) dseg_add_unique_s4(cd, 0); /* IsSync */ - - (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */ + (void) dseg_add_unique_s4(cd, 0); /* IsLeaf */ + (void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */ (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */ - /* adds a reference for the length of the line number counter. We don't - know the size yet, since we evaluate the information during code - generation, to save one additional iteration over the whole - instructions. During code optimization the position could have changed - to the information gotten from the class file */ - (void) dseg_addlinenumbertablesize(cd); - - (void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize */ - - /* create exception table */ - - for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) { - dseg_add_target(cd, ex->start); - dseg_add_target(cd, ex->end); - dseg_add_target(cd, ex->handler); - (void) dseg_add_unique_address(cd, ex->catchtype.any); - } - #if defined(ENABLE_PROFILING) /* generate method profiling code */ @@ -218,16 +185,17 @@ bool codegen_emit(jitdata *jd) /* create stack frame (if necessary) */ if (cd->stackframesize) - M_ASUB_IMM(cd->stackframesize * 4, REG_SP); + /* align_off == 4 */ + M_ASUB_IMM(cd->stackframesize * 8 + 4, REG_SP); /* save return address and used callee saved registers */ p = cd->stackframesize; for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) { - p--; M_AST(rd->savintregs[i], REG_SP, p * 4); + p--; M_AST(rd->savintregs[i], REG_SP, p * 8); } for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) { - p-=2; emit_fld_reg(cd, rd->savfltregs[i]); emit_fstpl_membase(cd, REG_SP, p * 4); + p--; emit_fld_reg(cd, rd->savfltregs[i]); emit_fstpl_membase(cd, REG_SP, p * 8); } /* take arguments out of register or stack frame */ @@ -238,12 +206,15 @@ bool codegen_emit(jitdata *jd) for (p = 0, l = 0; p < md->paramcount; p++) { t = md->paramtypes[p].type; + varindex = jd->local_map[l * 5 + t]; #if defined(ENABLE_SSA) if ( ls != NULL ) { - l = ls->local_0[p]; + if (varindex != UNUSED) + varindex = ls->var_0[varindex]; + if ((varindex != UNUSED) && (ls->lifetime[varindex].type == UNUSED)) + varindex = UNUSED; } #endif - varindex = jd->local_map[l * 5 + t]; l++; if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */ l++; @@ -252,8 +223,8 @@ bool codegen_emit(jitdata *jd) continue; var = VAR(varindex); - - s1 = md->params[p].regoff; + s1 = md->params[p].regoff; + d = var->vv.regoff; if (IS_INT_LNG_TYPE(t)) { /* integer args */ if (!md->params[p].inmemory) { /* register arguments */ @@ -266,27 +237,28 @@ bool codegen_emit(jitdata *jd) /* rd->argintregs[md->params[p].regoff -> var->vv.regoff * 4 */ } } - else { /* stack arguments */ - if (!(var->flags & INMEMORY)) { /* stack arg -> register */ - emit_mov_membase_reg( /* + 4 for return address */ - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4, var->vv.regoff); - /* + 4 for return address */ + else { + if (!(var->flags & INMEMORY)) { + M_ILD(d, REG_SP, + cd->stackframesize * 8 + 4 + align_off + s1); } - else { /* stack arg -> spilled */ + else { if (!IS_2_WORD_TYPE(t)) { #if defined(ENABLE_SSA) /* no copy avoiding by now possible with SSA */ if (ls != NULL) { emit_mov_membase_reg( /* + 4 for return address */ - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4, - REG_ITMP1); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off, + REG_ITMP1); emit_mov_reg_membase( - cd, REG_ITMP1, REG_SP, var->vv.regoff * 4); + cd, REG_ITMP1, REG_SP, var->vv.regoff); } else #endif /*defined(ENABLE_SSA)*/ - /* reuse Stackslotand avoid copying */ - var->vv.regoff = cd->stackframesize + s1 + 1; + /* reuse stackslot */ + var->vv.regoff = cd->stackframesize * 8 + 4 + + align_off + s1; } else { @@ -294,20 +266,22 @@ bool codegen_emit(jitdata *jd) /* no copy avoiding by now possible with SSA */ if (ls != NULL) { emit_mov_membase_reg( /* + 4 for return address */ - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4, - REG_ITMP1); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off, + REG_ITMP1); emit_mov_reg_membase( - cd, REG_ITMP1, REG_SP, var->vv.regoff * 4); + cd, REG_ITMP1, REG_SP, var->vv.regoff); emit_mov_membase_reg( /* + 4 for return address */ - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4 + 4, - REG_ITMP1); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + 4 + align_off, + REG_ITMP1); emit_mov_reg_membase( - cd, REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4); + cd, REG_ITMP1, REG_SP, var->vv.regoff + 4); } else #endif /*defined(ENABLE_SSA)*/ - /* reuse Stackslotand avoid copying */ - var->vv.regoff = cd->stackframesize + s1 + 1; + /* reuse stackslot */ + var->vv.regoff = cd->stackframesize * 8 + 8 + s1; } } } @@ -319,7 +293,7 @@ bool codegen_emit(jitdata *jd) if (!(var->flags & INMEMORY)) { /* reg arg -> register */ /* rd->argfltregs[md->params[p].regoff -> var->vv.regoff */ } else { /* reg arg -> spilled */ - /* rd->argfltregs[md->params[p].regoff -> var->vv.regoff * 4 */ + /* rd->argfltregs[md->params[p].regoff -> var->vv.regoff * 8 */ } } @@ -327,14 +301,16 @@ bool codegen_emit(jitdata *jd) if (!(var->flags & INMEMORY)) { /* stack-arg -> register */ if (t == TYPE_FLT) { emit_flds_membase( - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off); assert(0); /* emit_fstp_reg(cd, var->vv.regoff + fpu_st_offset); */ } else { emit_fldl_membase( - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off); assert(0); /* emit_fstp_reg(cd, var->vv.regoff + fpu_st_offset); */ } @@ -344,46 +320,51 @@ bool codegen_emit(jitdata *jd) /* no copy avoiding by now possible with SSA */ if (ls != NULL) { emit_mov_membase_reg( - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4, REG_ITMP1); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off, + REG_ITMP1); emit_mov_reg_membase( - cd, REG_ITMP1, REG_SP, var->vv.regoff * 4); + cd, REG_ITMP1, REG_SP, var->vv.regoff); if (t == TYPE_FLT) { emit_flds_membase( - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4); - emit_fstps_membase(cd, REG_SP, var->vv.regoff * 4); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off); + emit_fstps_membase(cd, REG_SP, var->vv.regoff); } else { emit_fldl_membase( - cd, REG_SP, (cd->stackframesize + s1) * 4 + 4); - emit_fstpl_membase(cd, REG_SP, var->vv.regoff * 4); + cd, REG_SP, + cd->stackframesize * 8 + s1 + 4 + align_off); + emit_fstpl_membase(cd, REG_SP, var->vv.regoff); } } else #endif /*defined(ENABLE_SSA)*/ - /* reuse Stackslotand avoid copying */ - var->vv.regoff = cd->stackframesize + s1 + 1; + /* reuse stackslot */ + var->vv.regoff = cd->stackframesize * 8 + 4 + + align_off + s1; } } } - } /* end for */ + } /* call monitorenter function */ #if defined(ENABLE_THREADS) - if (checksync && (m->flags & ACC_SYNCHRONIZED)) { + if (checksync && code_is_synchronized(code)) { s1 = rd->memuse; if (m->flags & ACC_STATIC) { - M_MOV_IMM(&m->class->object.header, REG_ITMP1); + M_MOV_IMM(&m->clazz->object.header, REG_ITMP1); } else { - M_ALD(REG_ITMP1, REG_SP, cd->stackframesize * 4 + 4); + M_ALD(REG_ITMP1, REG_SP, cd->stackframesize * 8 + 4 + align_off); M_TEST(REG_ITMP1); M_BNE(6); - M_ALD_MEM(REG_ITMP1, EXCEPTION_HARDWARE_NULLPOINTER); + M_ALD_MEM(REG_ITMP1, TRAP_NullPointerException); } - M_AST(REG_ITMP1, REG_SP, s1 * 4); + M_AST(REG_ITMP1, REG_SP, s1 * 8); M_AST(REG_ITMP1, REG_SP, 0 * 4); M_MOV_IMM(LOCK_monitor_enter, REG_ITMP3); M_CALL(REG_ITMP3); @@ -397,9 +378,9 @@ bool codegen_emit(jitdata *jd) } #if defined(ENABLE_SSA) - /* with SSA Header is Basic Block 0 - insert phi Moves if necessary */ + /* with SSA the Header is Basic Block 0 - insert phi Moves if necessary */ if ( ls != NULL) - codegen_insert_phi_moves(jd, ls->basicblocks[0]); + codegen_emit_phi_moves(jd, ls->basicblocks[0]); #endif /* end of header generation */ @@ -427,9 +408,7 @@ bool codegen_emit(jitdata *jd) if (bptr->bitflags & BBFLAG_REPLACEMENT) { if (cd->replacementpoint[-1].flags & RPLPOINT_FLAG_COUNTDOWN) { MCODECHECK(32); - disp = (s4) &(m->hitcountdown); - M_ISUB_IMM_MEMABS(1, disp); - M_BS(0); + emit_trap_countdown(cd, &(m->hitcountdown)); } } #endif @@ -463,11 +442,13 @@ bool codegen_emit(jitdata *jd) var = VAR(bptr->invars[len]); if (bptr->type != BBTYPE_STD) { if (!IS_2_WORD_TYPE(var->type)) { +#if !defined(ENABLE_SSA) if (bptr->type == BBTYPE_EXH) { d = codegen_reg_of_var(0, var, REG_ITMP1); M_INTMOVE(REG_ITMP1, d); emit_store(jd, NULL, var, d); } +#endif } else { log_text("copy interface registers(EXH, SBR): longs \ @@ -512,7 +493,7 @@ bool codegen_emit(jitdata *jd) for (iptr = bptr->iinstr; len > 0; len--, iptr++) { if (iptr->line != currentline) { - dseg_addlinenumber(cd, iptr->line); + linenumbertable_list_entry_add(cd, iptr->line); currentline = iptr->line; } @@ -532,14 +513,14 @@ bool codegen_emit(jitdata *jd) case ICMD_INLINE_BODY: REPLACEMENT_POINT_INLINE_BODY(cd, iptr); - dseg_addlinenumber_inline_start(cd, iptr); - dseg_addlinenumber(cd, iptr->line); + linenumbertable_list_entry_add_inline_start(cd, iptr); + linenumbertable_list_entry_add(cd, iptr->line); break; case ICMD_INLINE_END: - dseg_addlinenumber_inline_end(cd, iptr); - dseg_addlinenumber(cd, iptr->line); + linenumbertable_list_entry_add_inline_end(cd, iptr); + linenumbertable_list_entry_add(cd, iptr->line); break; case ICMD_CHECKNULL: /* ..., objectref ==> ..., objectref */ @@ -625,7 +606,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - codegen_addpatchref(cd, PATCHER_aconst, + patcher_add_patch_ref(jd, PATCHER_aconst, iptr->sx.val.c.ref, 0); M_MOV_IMM(NULL, d); @@ -1044,9 +1025,9 @@ bool codegen_emit(jitdata *jd) if (iptr->s1.var->flags & INMEMORY) { /* Alpha algorithm */ disp = 3; - CALCOFFSETBYTES(disp, REG_SP, iptr->s1.var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, iptr->s1.var->vv.regoff * 8); disp += 3; - CALCOFFSETBYTES(disp, REG_SP, iptr->s1.var->vv.regoff * 4 + 4); + CALCOFFSETBYTES(disp, REG_SP, iptr->s1.var->vv.regoff * 8 + 4); disp += 2; disp += 3; @@ -1062,16 +1043,16 @@ bool codegen_emit(jitdata *jd) disp += 3; disp += 2; - emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 4, REG_ITMP1); - emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 4 + 4, REG_ITMP2); + emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 8, REG_ITMP1); + emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 8 + 4, REG_ITMP2); emit_alu_imm_reg(cd, ALU_AND, iptr->sx.val.l, REG_ITMP1); emit_alu_imm_reg(cd, ALU_AND, iptr->sx.val.l >> 32, REG_ITMP2); - emit_alu_imm_membase(cd, ALU_CMP, 0, REG_SP, iptr->s1.var->vv.regoff * 4 + 4); + emit_alu_imm_membase(cd, ALU_CMP, 0, REG_SP, iptr->s1.var->vv.regoff * 8 + 4); emit_jcc(cd, CC_GE, disp); - emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 4, REG_ITMP1); - emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 4 + 4, REG_ITMP2); + emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 8, REG_ITMP1); + emit_mov_membase_reg(cd, REG_SP, iptr->s1.var->vv.regoff * 8 + 4, REG_ITMP2); emit_neg_reg(cd, REG_ITMP1); emit_alu_imm_reg(cd, ALU_ADC, 0, REG_ITMP2); @@ -1084,8 +1065,8 @@ bool codegen_emit(jitdata *jd) emit_alu_imm_reg(cd, ALU_ADC, 0, REG_ITMP2); emit_neg_reg(cd, REG_ITMP2); - emit_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst.var->vv.regoff * 4); - emit_mov_reg_membase(cd, REG_ITMP2, REG_SP, iptr->dst.var->vv.regoff * 4 + 4); + emit_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst.var->vv.regoff * 8); + emit_mov_reg_membase(cd, REG_ITMP2, REG_SP, iptr->dst.var->vv.regoff * 8 + 4); } } @@ -1577,7 +1558,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_FTMP1); if (var->flags & INMEMORY) { - emit_fildl_membase(cd, REG_SP, var->vv.regoff * 4); + emit_fildl_membase(cd, REG_SP, var->vv.regoff); } else { /* XXX not thread safe! */ disp = dseg_add_unique_s4(cd, 0); @@ -1596,7 +1577,7 @@ bool codegen_emit(jitdata *jd) var = VAROP(iptr->s1); d = codegen_reg_of_dst(jd, iptr, REG_FTMP1); if (var->flags & INMEMORY) { - emit_fildll_membase(cd, REG_SP, var->vv.regoff * 4); + emit_fildll_membase(cd, REG_SP, var->vv.regoff); } else { log_text("L2F: longs have to be in memory"); @@ -1621,19 +1602,19 @@ bool codegen_emit(jitdata *jd) var1 = VAROP(iptr->s1); if (var->flags & INMEMORY) { - emit_fistpl_membase(cd, REG_SP, var->vv.regoff * 4); + emit_fistpl_membase(cd, REG_SP, var->vv.regoff); /* Round to nearest, 53-bit mode, exceptions masked */ disp = dseg_add_s4(cd, 0x027f); emit_fldcw_membase(cd, REG_ITMP1, disp); emit_alu_imm_membase(cd, ALU_CMP, 0x80000000, - REG_SP, var->vv.regoff * 4); + REG_SP, var->vv.regoff); disp = 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2 + 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); } else { /* XXX not thread safe! */ @@ -1648,19 +1629,19 @@ bool codegen_emit(jitdata *jd) emit_alu_imm_reg(cd, ALU_CMP, 0x80000000, var->vv.regoff); disp = 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2 + ((REG_RESULT == var->vv.regoff) ? 0 : 2); } emit_jcc(cd, CC_NE, disp); /* XXX: change this when we use registers */ - emit_flds_membase(cd, REG_SP, var1->vv.regoff * 4); + emit_flds_membase(cd, REG_SP, var1->vv.regoff); emit_mov_imm_reg(cd, (ptrint) asm_builtin_f2i, REG_ITMP1); emit_call_reg(cd, REG_ITMP1); if (var->flags & INMEMORY) { - emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff * 4); + emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff); } else { M_INTMOVE(REG_RESULT, var->vv.regoff); @@ -1683,19 +1664,19 @@ bool codegen_emit(jitdata *jd) var1 = VAROP(iptr->s1); if (var->flags & INMEMORY) { - emit_fistpl_membase(cd, REG_SP, var->vv.regoff * 4); + emit_fistpl_membase(cd, REG_SP, var->vv.regoff); /* Round to nearest, 53-bit mode, exceptions masked */ disp = dseg_add_s4(cd, 0x027f); emit_fldcw_membase(cd, REG_ITMP1, disp); emit_alu_imm_membase(cd, ALU_CMP, 0x80000000, - REG_SP, var->vv.regoff * 4); + REG_SP, var->vv.regoff); disp = 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2 + 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); } else { /* XXX not thread safe! */ @@ -1710,19 +1691,19 @@ bool codegen_emit(jitdata *jd) emit_alu_imm_reg(cd, ALU_CMP, 0x80000000, var->vv.regoff); disp = 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2 + ((REG_RESULT == var->vv.regoff) ? 0 : 2); } emit_jcc(cd, CC_NE, disp); /* XXX: change this when we use registers */ - emit_fldl_membase(cd, REG_SP, var1->vv.regoff * 4); + emit_fldl_membase(cd, REG_SP, var1->vv.regoff); emit_mov_imm_reg(cd, (ptrint) asm_builtin_d2i, REG_ITMP1); emit_call_reg(cd, REG_ITMP1); if (var->flags & INMEMORY) { - emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff * 4); + emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff); } else { M_INTMOVE(REG_RESULT, var->vv.regoff); } @@ -1744,44 +1725,44 @@ bool codegen_emit(jitdata *jd) var1 = VAROP(iptr->s1); if (var->flags & INMEMORY) { - emit_fistpll_membase(cd, REG_SP, var->vv.regoff * 4); + emit_fistpll_membase(cd, REG_SP, var->vv.regoff); /* Round to nearest, 53-bit mode, exceptions masked */ disp = dseg_add_s4(cd, 0x027f); emit_fldcw_membase(cd, REG_ITMP1, disp); emit_alu_imm_membase(cd, ALU_CMP, 0x80000000, - REG_SP, var->vv.regoff * 4 + 4); + REG_SP, var->vv.regoff + 4); disp = 6 + 4; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); disp += 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2; disp += 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); disp += 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4 + 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff + 4); emit_jcc(cd, CC_NE, disp); emit_alu_imm_membase(cd, ALU_CMP, 0, - REG_SP, var->vv.regoff * 4); + REG_SP, var->vv.regoff); disp = 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2 + 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); emit_jcc(cd, CC_NE, disp); /* XXX: change this when we use registers */ - emit_flds_membase(cd, REG_SP, var1->vv.regoff * 4); + emit_flds_membase(cd, REG_SP, var1->vv.regoff); emit_mov_imm_reg(cd, (ptrint) asm_builtin_f2l, REG_ITMP1); emit_call_reg(cd, REG_ITMP1); - emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff * 4); + emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff); emit_mov_reg_membase(cd, REG_RESULT2, - REG_SP, var->vv.regoff * 4 + 4); + REG_SP, var->vv.regoff + 4); } else { log_text("F2L: longs have to be in memory"); @@ -1805,43 +1786,43 @@ bool codegen_emit(jitdata *jd) var1 = VAROP(iptr->s1); if (var->flags & INMEMORY) { - emit_fistpll_membase(cd, REG_SP, var->vv.regoff * 4); + emit_fistpll_membase(cd, REG_SP, var->vv.regoff); /* Round to nearest, 53-bit mode, exceptions masked */ disp = dseg_add_s4(cd, 0x027f); emit_fldcw_membase(cd, REG_ITMP1, disp); emit_alu_imm_membase(cd, ALU_CMP, 0x80000000, - REG_SP, var->vv.regoff * 4 + 4); + REG_SP, var->vv.regoff + 4); disp = 6 + 4; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); disp += 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2; disp += 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); disp += 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4 + 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff + 4); emit_jcc(cd, CC_NE, disp); - emit_alu_imm_membase(cd, ALU_CMP, 0, REG_SP, var->vv.regoff * 4); + emit_alu_imm_membase(cd, ALU_CMP, 0, REG_SP, var->vv.regoff); disp = 3; - CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var1->vv.regoff); disp += 5 + 2 + 3; - CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff * 4); + CALCOFFSETBYTES(disp, REG_SP, var->vv.regoff); emit_jcc(cd, CC_NE, disp); /* XXX: change this when we use registers */ - emit_fldl_membase(cd, REG_SP, var1->vv.regoff * 4); + emit_fldl_membase(cd, REG_SP, var1->vv.regoff); emit_mov_imm_reg(cd, (ptrint) asm_builtin_d2l, REG_ITMP1); emit_call_reg(cd, REG_ITMP1); - emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff * 4); + emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff); emit_mov_reg_membase(cd, REG_RESULT2, - REG_SP, var->vv.regoff * 4 + 4); + REG_SP, var->vv.regoff + 4); } else { log_text("D2L: longs have to be in memory"); @@ -1919,7 +1900,7 @@ bool codegen_emit(jitdata *jd) s1 = emit_load_s1(jd, iptr, REG_ITMP1); d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); /* implicit null-pointer check */ - M_ILD(d, s1, OFFSET(java_arrayheader, size)); + M_ILD(d, s1, OFFSET(java_array_t, size)); emit_store_dst(jd, iptr, d); break; @@ -1930,7 +1911,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_movsbl_memindex_reg(cd, OFFSET(java_bytearray, data[0]), + emit_movsbl_memindex_reg(cd, OFFSET(java_bytearray_t, data[0]), s1, s2, 0, d); emit_store_dst(jd, iptr, d); break; @@ -1942,7 +1923,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_movzwl_memindex_reg(cd, OFFSET(java_chararray, data[0]), + emit_movzwl_memindex_reg(cd, OFFSET(java_chararray_t, data[0]), s1, s2, 1, d); emit_store_dst(jd, iptr, d); break; @@ -1954,7 +1935,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_movswl_memindex_reg(cd, OFFSET(java_shortarray, data[0]), + emit_movswl_memindex_reg(cd, OFFSET(java_shortarray_t, data[0]), s1, s2, 1, d); emit_store_dst(jd, iptr, d); break; @@ -1966,7 +1947,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_mov_memindex_reg(cd, OFFSET(java_intarray, data[0]), + emit_mov_memindex_reg(cd, OFFSET(java_intarray_t, data[0]), s1, s2, 2, d); emit_store_dst(jd, iptr, d); break; @@ -1982,12 +1963,12 @@ bool codegen_emit(jitdata *jd) var = VAROP(iptr->dst); assert(var->flags & INMEMORY); - emit_mov_memindex_reg(cd, OFFSET(java_longarray, data[0]), + emit_mov_memindex_reg(cd, OFFSET(java_longarray_t, data[0]), s1, s2, 3, REG_ITMP3); - emit_mov_reg_membase(cd, REG_ITMP3, REG_SP, var->vv.regoff * 4); - emit_mov_memindex_reg(cd, OFFSET(java_longarray, data[0]) + 4, + emit_mov_reg_membase(cd, REG_ITMP3, REG_SP, var->vv.regoff); + emit_mov_memindex_reg(cd, OFFSET(java_longarray_t, data[0]) + 4, s1, s2, 3, REG_ITMP3); - emit_mov_reg_membase(cd, REG_ITMP3, REG_SP, var->vv.regoff * 4 + 4); + emit_mov_reg_membase(cd, REG_ITMP3, REG_SP, var->vv.regoff + 4); break; case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */ @@ -1997,7 +1978,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_FTMP1); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_flds_memindex(cd, OFFSET(java_floatarray, data[0]), s1, s2, 2); + emit_flds_memindex(cd, OFFSET(java_floatarray_t, data[0]), s1, s2, 2); emit_store_dst(jd, iptr, d); break; @@ -2008,7 +1989,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_FTMP3); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_fldl_memindex(cd, OFFSET(java_doublearray, data[0]), s1, s2,3); + emit_fldl_memindex(cd, OFFSET(java_doublearray_t, data[0]), s1, s2,3); emit_store_dst(jd, iptr, d); break; @@ -2019,7 +2000,7 @@ bool codegen_emit(jitdata *jd) d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); - emit_mov_memindex_reg(cd, OFFSET(java_objectarray, data[0]), + emit_mov_memindex_reg(cd, OFFSET(java_objectarray_t, data[0]), s1, s2, 2, d); emit_store_dst(jd, iptr, d); break; @@ -2037,7 +2018,7 @@ bool codegen_emit(jitdata *jd) M_INTMOVE(s3, REG_ITMP3); s3 = REG_ITMP3; } - emit_movb_reg_memindex(cd, s3, OFFSET(java_bytearray, data[0]), + emit_movb_reg_memindex(cd, s3, OFFSET(java_bytearray_t, data[0]), s1, s2, 0); break; @@ -2048,7 +2029,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); s3 = emit_load_s3(jd, iptr, REG_ITMP3); - emit_movw_reg_memindex(cd, s3, OFFSET(java_chararray, data[0]), + emit_movw_reg_memindex(cd, s3, OFFSET(java_chararray_t, data[0]), s1, s2, 1); break; @@ -2059,7 +2040,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); s3 = emit_load_s3(jd, iptr, REG_ITMP3); - emit_movw_reg_memindex(cd, s3, OFFSET(java_shortarray, data[0]), + emit_movw_reg_memindex(cd, s3, OFFSET(java_shortarray_t, data[0]), s1, s2, 1); break; @@ -2070,7 +2051,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); s3 = emit_load_s3(jd, iptr, REG_ITMP3); - emit_mov_reg_memindex(cd, s3, OFFSET(java_intarray, data[0]), + emit_mov_reg_memindex(cd, s3, OFFSET(java_intarray_t, data[0]), s1, s2, 2); break; @@ -2084,12 +2065,12 @@ bool codegen_emit(jitdata *jd) var = VAROP(iptr->sx.s23.s3); assert(var->flags & INMEMORY); - emit_mov_membase_reg(cd, REG_SP, var->vv.regoff * 4, REG_ITMP3); - emit_mov_reg_memindex(cd, REG_ITMP3, OFFSET(java_longarray, data[0]) + emit_mov_membase_reg(cd, REG_SP, var->vv.regoff, REG_ITMP3); + emit_mov_reg_memindex(cd, REG_ITMP3, OFFSET(java_longarray_t, data[0]) , s1, s2, 3); - emit_mov_membase_reg(cd, REG_SP, var->vv.regoff * 4 + 4, REG_ITMP3); + emit_mov_membase_reg(cd, REG_SP, var->vv.regoff + 4, REG_ITMP3); emit_mov_reg_memindex(cd, REG_ITMP3, - OFFSET(java_longarray, data[0]) + 4, s1, s2, 3); + OFFSET(java_longarray_t, data[0]) + 4, s1, s2, 3); break; case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */ @@ -2099,7 +2080,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); s3 = emit_load_s3(jd, iptr, REG_FTMP1); - emit_fstps_memindex(cd, OFFSET(java_floatarray, data[0]), s1, s2,2); + emit_fstps_memindex(cd, OFFSET(java_floatarray_t, data[0]), s1, s2,2); break; case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */ @@ -2109,7 +2090,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); s3 = emit_load_s3(jd, iptr, REG_FTMP1); - emit_fstpl_memindex(cd, OFFSET(java_doublearray, data[0]), + emit_fstpl_memindex(cd, OFFSET(java_doublearray_t, data[0]), s1, s2, 3); break; @@ -2123,14 +2104,14 @@ bool codegen_emit(jitdata *jd) M_AST(s1, REG_SP, 0 * 4); M_AST(s3, REG_SP, 1 * 4); - M_MOV_IMM(BUILTIN_canstore, REG_ITMP1); + M_MOV_IMM(BUILTIN_FAST_canstore, REG_ITMP1); M_CALL(REG_ITMP1); - emit_exception_check(cd, iptr); + emit_arraystore_check(cd, iptr); s1 = emit_load_s1(jd, iptr, REG_ITMP1); s2 = emit_load_s2(jd, iptr, REG_ITMP2); s3 = emit_load_s3(jd, iptr, REG_ITMP3); - emit_mov_reg_memindex(cd, s3, OFFSET(java_objectarray, data[0]), + emit_mov_reg_memindex(cd, s3, OFFSET(java_objectarray_t, data[0]), s1, s2, 2); break; @@ -2141,7 +2122,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); emit_movb_imm_memindex(cd, iptr->sx.s23.s3.constval, - OFFSET(java_bytearray, data[0]), s1, s2, 0); + OFFSET(java_bytearray_t, data[0]), s1, s2, 0); break; case ICMD_CASTORECONST: /* ..., arrayref, index ==> ... */ @@ -2151,7 +2132,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); emit_movw_imm_memindex(cd, iptr->sx.s23.s3.constval, - OFFSET(java_chararray, data[0]), s1, s2, 1); + OFFSET(java_chararray_t, data[0]), s1, s2, 1); break; case ICMD_SASTORECONST: /* ..., arrayref, index ==> ... */ @@ -2161,7 +2142,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); emit_movw_imm_memindex(cd, iptr->sx.s23.s3.constval, - OFFSET(java_shortarray, data[0]), s1, s2, 1); + OFFSET(java_shortarray_t, data[0]), s1, s2, 1); break; case ICMD_IASTORECONST: /* ..., arrayref, index ==> ... */ @@ -2171,7 +2152,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); emit_mov_imm_memindex(cd, iptr->sx.s23.s3.constval, - OFFSET(java_intarray, data[0]), s1, s2, 2); + OFFSET(java_intarray_t, data[0]), s1, s2, 2); break; case ICMD_LASTORECONST: /* ..., arrayref, index ==> ... */ @@ -2182,10 +2163,10 @@ bool codegen_emit(jitdata *jd) emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); emit_mov_imm_memindex(cd, (u4) (iptr->sx.s23.s3.constval & 0x00000000ffffffff), - OFFSET(java_longarray, data[0]), s1, s2, 3); + OFFSET(java_longarray_t, data[0]), s1, s2, 3); emit_mov_imm_memindex(cd, ((s4)iptr->sx.s23.s3.constval) >> 31, - OFFSET(java_longarray, data[0]) + 4, s1, s2, 3); + OFFSET(java_longarray_t, data[0]) + 4, s1, s2, 3); break; case ICMD_AASTORECONST: /* ..., arrayref, index ==> ... */ @@ -2195,7 +2176,7 @@ bool codegen_emit(jitdata *jd) /* implicit null-pointer check */ emit_arrayindexoutofbounds_check(cd, iptr, s1, s2); emit_mov_imm_memindex(cd, 0, - OFFSET(java_objectarray, data[0]), s1, s2, 2); + OFFSET(java_objectarray_t, data[0]), s1, s2, 2); break; @@ -2206,16 +2187,16 @@ bool codegen_emit(jitdata *jd) fieldtype = uf->fieldref->parseddesc.fd->type; disp = 0; - codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0); + patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, 0); } else { fi = iptr->sx.s23.s3.fmiref->p.field; fieldtype = fi->type; - disp = (ptrint) &(fi->value); + disp = (intptr_t) fi->value; - if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) - codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0); + if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->clazz)) + patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->clazz, 0); } M_MOV_IMM(disp, REG_ITMP1); @@ -2242,21 +2223,21 @@ bool codegen_emit(jitdata *jd) break; case ICMD_PUTSTATIC: /* ..., value ==> ... */ - + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { uf = iptr->sx.s23.s3.uf; fieldtype = uf->fieldref->parseddesc.fd->type; disp = 0; - codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0); + patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, 0); } else { fi = iptr->sx.s23.s3.fmiref->p.field; fieldtype = fi->type; - disp = (ptrint) &(fi->value); + disp = (intptr_t) fi->value; - if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) - codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0); + if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->clazz)) + patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->clazz, 0); } M_MOV_IMM(disp, REG_ITMP1); @@ -2290,15 +2271,15 @@ bool codegen_emit(jitdata *jd) fieldtype = uf->fieldref->parseddesc.fd->type; disp = 0; - codegen_addpatchref(cd, PATCHER_get_putstatic, uf, 0); + patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, 0); } else { fi = iptr->sx.s23.s3.fmiref->p.field; fieldtype = fi->type; - disp = (ptrint) &(fi->value); + disp = (intptr_t) fi->value; - if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) - codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0); + if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->clazz)) + patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->clazz, 0); } M_MOV_IMM(disp, REG_ITMP1); @@ -2321,22 +2302,22 @@ bool codegen_emit(jitdata *jd) s1 = emit_load_s1(jd, iptr, REG_ITMP1); emit_nullpointer_check(cd, iptr, s1); - if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - unresolved_field *uf = iptr->sx.s23.s3.uf; +#if defined(ENABLE_ESCAPE_CHECK) + /*emit_escape_check(cd, s1);*/ +#endif + if (INSTRUCTION_IS_UNRESOLVED(iptr)) { + uf = iptr->sx.s23.s3.uf; fieldtype = uf->fieldref->parseddesc.fd->type; + disp = 0; - codegen_addpatchref(cd, PATCHER_getfield, + patcher_add_patch_ref(jd, PATCHER_getfield, iptr->sx.s23.s3.uf, 0); - - disp = 0; - } else { - fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field; - + fi = iptr->sx.s23.s3.fmiref->p.field; fieldtype = fi->type; - disp = fi->offset; + disp = fi->offset; } switch (fieldtype) { @@ -2369,13 +2350,11 @@ bool codegen_emit(jitdata *jd) /* must be done here because of code patching */ if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - unresolved_field *uf = iptr->sx.s23.s3.uf; - + uf = iptr->sx.s23.s3.uf; fieldtype = uf->fieldref->parseddesc.fd->type; } else { - fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field; - + fi = iptr->sx.s23.s3.fmiref->p.field; fieldtype = fi->type; } @@ -2389,16 +2368,15 @@ bool codegen_emit(jitdata *jd) s2 = emit_load_s2(jd, iptr, REG_FTMP2); if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - unresolved_field *uf = iptr->sx.s23.s3.uf; - - codegen_addpatchref(cd, PATCHER_putfield, uf, 0); - + /* XXX */ + uf = iptr->sx.s23.s3.uf; disp = 0; + patcher_add_patch_ref(jd, PATCHER_putfield, uf, 0); } else { - fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field; - + /* XXX */ + fi = iptr->sx.s23.s3.fmiref->p.field; disp = fi->offset; } @@ -2427,25 +2405,19 @@ bool codegen_emit(jitdata *jd) emit_nullpointer_check(cd, iptr, s1); if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - unresolved_field *uf = iptr->sx.s23.s3.uf; - + uf = iptr->sx.s23.s3.uf; fieldtype = uf->fieldref->parseddesc.fd->type; + disp = 0; - codegen_addpatchref(cd, PATCHER_putfieldconst, + patcher_add_patch_ref(jd, PATCHER_putfieldconst, uf, 0); - - disp = 0; - } - else - { - fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field; - + else { + fi = iptr->sx.s23.s3.fmiref->p.field; fieldtype = fi->type; - disp = fi->offset; + disp = fi->offset; } - switch (fieldtype) { case TYPE_INT: case TYPE_ADR: @@ -2470,7 +2442,7 @@ bool codegen_emit(jitdata *jd) #ifdef ENABLE_VERIFIER if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - codegen_addpatchref(cd, PATCHER_athrow_areturn, + patcher_add_patch_ref(jd, PATCHER_resolve_class, iptr->sx.s23.s2.uc, 0); } #endif /* ENABLE_VERIFIER */ @@ -2488,9 +2460,11 @@ bool codegen_emit(jitdata *jd) #if defined(ENABLE_SSA) if ( ls != NULL ) { last_cmd_was_goto = true; + /* In case of a Goto phimoves have to be inserted before the */ /* jump */ - codegen_insert_phi_moves(jd, bptr); + + codegen_emit_phi_moves(jd, bptr); } #endif emit_br(cd, iptr->dst.block); @@ -2738,7 +2712,7 @@ bool codegen_emit(jitdata *jd) #ifdef ENABLE_VERIFIER if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - codegen_addpatchref(cd, PATCHER_athrow_areturn, + patcher_add_patch_ref(jd, PATCHER_resolve_class, iptr->sx.s23.s2.uc, 0); } #endif /* ENABLE_VERIFIER */ @@ -2766,26 +2740,26 @@ nowperformreturn: #endif #if defined(ENABLE_THREADS) - if (checksync && (m->flags & ACC_SYNCHRONIZED)) { - M_ALD(REG_ITMP2, REG_SP, rd->memuse * 4); + if (checksync && code_is_synchronized(code)) { + M_ALD(REG_ITMP2, REG_SP, rd->memuse * 8); /* we need to save the proper return value */ switch (iptr->opc) { case ICMD_IRETURN: case ICMD_ARETURN: - M_IST(REG_RESULT, REG_SP, rd->memuse * 4); + M_IST(REG_RESULT, REG_SP, rd->memuse * 8); break; case ICMD_LRETURN: - M_LST(REG_RESULT_PACKED, REG_SP, rd->memuse * 4); + M_LST(REG_RESULT_PACKED, REG_SP, rd->memuse * 8); break; case ICMD_FRETURN: - emit_fstps_membase(cd, REG_SP, rd->memuse * 4); + emit_fstps_membase(cd, REG_SP, rd->memuse * 8); break; case ICMD_DRETURN: - emit_fstpl_membase(cd, REG_SP, rd->memuse * 4); + emit_fstpl_membase(cd, REG_SP, rd->memuse * 8); break; } @@ -2797,19 +2771,19 @@ nowperformreturn: switch (iptr->opc) { case ICMD_IRETURN: case ICMD_ARETURN: - M_ILD(REG_RESULT, REG_SP, rd->memuse * 4); + M_ILD(REG_RESULT, REG_SP, rd->memuse * 8); break; case ICMD_LRETURN: - M_LLD(REG_RESULT_PACKED, REG_SP, rd->memuse * 4); + M_LLD(REG_RESULT_PACKED, REG_SP, rd->memuse * 8); break; case ICMD_FRETURN: - emit_flds_membase(cd, REG_SP, rd->memuse * 4); + emit_flds_membase(cd, REG_SP, rd->memuse * 8); break; case ICMD_DRETURN: - emit_fldl_membase(cd, REG_SP, rd->memuse * 4); + emit_fldl_membase(cd, REG_SP, rd->memuse * 8); break; } } @@ -2818,12 +2792,12 @@ nowperformreturn: /* restore saved registers */ for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) { - p--; M_ALD(rd->savintregs[i], REG_SP, p * 4); + p--; M_ALD(rd->savintregs[i], REG_SP, p * 8); } for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) { p--; - emit_fldl_membase(cd, REG_SP, p * 4); + emit_fldl_membase(cd, REG_SP, p * 8); if (iptr->opc == ICMD_FRETURN || iptr->opc == ICMD_DRETURN) { assert(0); /* emit_fstp_reg(cd, rd->savfltregs[i] + fpu_st_offset + 1); */ @@ -2836,9 +2810,9 @@ nowperformreturn: /* deallocate stack */ if (cd->stackframesize) - M_AADD_IMM(cd->stackframesize * 4, REG_SP); + M_AADD_IMM(cd->stackframesize * 8 + 4, REG_SP); - emit_ret(cd); + M_RET; } break; @@ -2911,8 +2885,25 @@ nowperformreturn: case ICMD_BUILTIN: /* ..., [arg1, [arg2 ...]] ==> ... */ + REPLACEMENT_POINT_FORGC_BUILTIN(cd, iptr); + bte = iptr->sx.s23.s3.bte; md = bte->md; + +#if defined(ENABLE_ESCAPE_REASON) + if (bte->fp == BUILTIN_escape_reason_new) { + void set_escape_reasons(void *); + M_ASUB_IMM(8, REG_SP); + M_MOV_IMM(iptr->escape_reasons, REG_ITMP1); + M_AST(EDX, REG_SP, 4); + M_AST(REG_ITMP1, REG_SP, 0); + M_MOV_IMM(set_escape_reasons, REG_ITMP1); + M_CALL(REG_ITMP1); + M_ALD(EDX, REG_SP, 4); + M_AADD_IMM(8, REG_SP); + } +#endif + goto gen_method; case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */ @@ -2953,10 +2944,10 @@ gen_method: } else { if (IS_2_WORD_TYPE(var->type)) { d = emit_load(jd, iptr, var, REG_ITMP12_PACKED); - M_LST(d, REG_SP, md->params[s3].regoff * 4); + M_LST(d, REG_SP, md->params[s3].regoff); } else { d = emit_load(jd, iptr, var, REG_ITMP1); - M_IST(d, REG_SP, md->params[s3].regoff * 4); + M_IST(d, REG_SP, md->params[s3].regoff); } } @@ -2969,26 +2960,34 @@ gen_method: } else { d = emit_load(jd, iptr, var, REG_FTMP1); if (IS_2_WORD_TYPE(var->type)) - M_DST(d, REG_SP, md->params[s3].regoff * 4); + M_DST(d, REG_SP, md->params[s3].regoff); else - M_FST(d, REG_SP, md->params[s3].regoff * 4); + M_FST(d, REG_SP, md->params[s3].regoff); } } } /* end of for */ switch (iptr->opc) { case ICMD_BUILTIN: - disp = (ptrint) bte->fp; d = md->returntype.type; - M_MOV_IMM(disp, REG_ITMP1); + if (bte->stub == NULL) { + M_MOV_IMM(bte->fp, REG_ITMP1); + } + else { + M_MOV_IMM(bte->stub, REG_ITMP1); + } M_CALL(REG_ITMP1); - emit_exception_check(cd, iptr); +#if defined(ENABLE_ESCAPE_CHECK) + if (bte->opcode == ICMD_NEW || bte->opcode == ICMD_NEWARRAY) { + /*emit_escape_annotate_object(cd, m);*/ + } +#endif break; case ICMD_INVOKESPECIAL: - M_ALD(REG_ITMP1, REG_SP, 0 * 4); + M_ALD(REG_ITMP1, REG_SP, 0 * 8); emit_nullpointer_check(cd, iptr, REG_ITMP1); /* fall through */ @@ -2996,7 +2995,7 @@ gen_method: if (lm == NULL) { unresolved_method *um = iptr->sx.s23.s3.um; - codegen_addpatchref(cd, PATCHER_invokestatic_special, + patcher_add_patch_ref(jd, PATCHER_invokestatic_special, um, 0); disp = 0; @@ -3012,13 +3011,13 @@ gen_method: break; case ICMD_INVOKEVIRTUAL: - M_ALD(REG_ITMP1, REG_SP, 0 * 4); + M_ALD(REG_ITMP1, REG_SP, 0 * 8); emit_nullpointer_check(cd, iptr, s1); if (lm == NULL) { unresolved_method *um = iptr->sx.s23.s3.um; - codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0); + patcher_add_patch_ref(jd, PATCHER_invokevirtual, um, 0); s1 = 0; d = md->returntype.type; @@ -3030,19 +3029,19 @@ gen_method: } M_ALD(REG_METHODPTR, REG_ITMP1, - OFFSET(java_objectheader, vftbl)); + OFFSET(java_object_t, vftbl)); M_ALD32(REG_ITMP3, REG_METHODPTR, s1); M_CALL(REG_ITMP3); break; case ICMD_INVOKEINTERFACE: - M_ALD(REG_ITMP1, REG_SP, 0 * 4); + M_ALD(REG_ITMP1, REG_SP, 0 * 8); emit_nullpointer_check(cd, iptr, s1); if (lm == NULL) { unresolved_method *um = iptr->sx.s23.s3.um; - codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0); + patcher_add_patch_ref(jd, PATCHER_invokeinterface, um, 0); s1 = 0; s2 = 0; @@ -3050,15 +3049,15 @@ gen_method: } else { s1 = OFFSET(vftbl_t, interfacetable[0]) - - sizeof(methodptr) * lm->class->index; + sizeof(methodptr) * lm->clazz->index; - s2 = sizeof(methodptr) * (lm - lm->class->methods); + s2 = sizeof(methodptr) * (lm - lm->clazz->methods); d = md->returntype.type; } M_ALD(REG_METHODPTR, REG_ITMP1, - OFFSET(java_objectheader, vftbl)); + OFFSET(java_object_t, vftbl)); M_ALD32(REG_METHODPTR, REG_METHODPTR, s1); M_ALD32(REG_ITMP3, REG_METHODPTR, s2); M_CALL(REG_ITMP3); @@ -3068,13 +3067,14 @@ gen_method: /* store size of call code in replacement point */ REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr); + REPLACEMENT_POINT_FORGC_BUILTIN_RETURN(cd, iptr); /* d contains return type */ if (d != TYPE_VOID) { #if defined(ENABLE_SSA) - if ((ls == NULL) || (!IS_TEMPVAR_INDEX(iptr->dst.varindex)) || - (ls->lifetime[-iptr->dst.varindex-1].type != -1)) + if ((ls == NULL) /* || (!IS_TEMPVAR_INDEX(iptr->dst.varindex)) */ || + (ls->lifetime[iptr->dst.varindex].type != UNUSED)) /* a "living" stackslot */ #endif { @@ -3098,20 +3098,6 @@ gen_method: case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */ - /* val.a: (classinfo*) superclass */ - - /* superclass is an interface: - * - * OK if ((sub == NULL) || - * (sub->vftbl->interfacetablelength > super->index) && - * (sub->vftbl->interfacetable[-super->index] != NULL)); - * - * superclass is a class: - * - * OK if ((sub == NULL) || (0 - * <= (sub->vftbl->baseval - super->vftbl->baseval) <= - * super->vftbl->diffval)); - */ if (!(iptr->flags.bits & INS_FLAG_ARRAY)) { /* object type cast-check */ @@ -3131,9 +3117,6 @@ gen_method: supervftbl = super->vftbl; } -#if defined(ENABLE_THREADS) - codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase); -#endif s1 = emit_load_s1(jd, iptr, REG_ITMP1); /* if class is not resolved, check which code to call */ @@ -3142,7 +3125,7 @@ gen_method: M_TEST(s1); emit_label_beq(cd, BRANCH_LABEL_1); - codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags, + patcher_add_patch_ref(jd, PATCHER_checkcast_instanceof_flags, iptr->sx.s23.s3.c.ref, 0); M_MOV_IMM(0, REG_ITMP2); /* super->flags */ @@ -3158,10 +3141,10 @@ gen_method: emit_label_beq(cd, BRANCH_LABEL_3); } - M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl)); + M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl)); if (super == NULL) { - codegen_addpatchref(cd, PATCHER_checkcast_interface, + patcher_add_patch_ref(jd, PATCHER_checkcast_interface, iptr->sx.s23.s3.c.ref, 0); } @@ -3196,18 +3179,16 @@ gen_method: emit_label_beq(cd, BRANCH_LABEL_5); } - M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl)); + M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl)); if (super == NULL) { - codegen_addpatchref(cd, PATCHER_checkcast_class, + patcher_add_patch_ref(jd, PATCHER_checkcast_class, iptr->sx.s23.s3.c.ref, 0); } M_MOV_IMM(supervftbl, REG_ITMP3); -#if defined(ENABLE_THREADS) - codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase); -#endif + M_ILD32(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval)); /* if (s1 != REG_ITMP1) { */ @@ -3223,9 +3204,7 @@ gen_method: M_ISUB(REG_ITMP3, REG_ITMP2); M_MOV_IMM(supervftbl, REG_ITMP3); M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, diffval)); -#if defined(ENABLE_THREADS) - codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase); -#endif + /* } */ M_CMP(REG_ITMP3, REG_ITMP2); @@ -3249,7 +3228,7 @@ gen_method: M_AST(s1, REG_SP, 0 * 4); if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - codegen_addpatchref(cd, PATCHER_builtin_arraycheckcast, + patcher_add_patch_ref(jd, PATCHER_builtin_arraycheckcast, iptr->sx.s23.s3.c.ref, 0); } @@ -3269,20 +3248,6 @@ gen_method: break; case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult */ - /* val.a: (classinfo*) superclass */ - - /* superclass is an interface: - * - * return (sub != NULL) && - * (sub->vftbl->interfacetablelength > super->index) && - * (sub->vftbl->interfacetable[-super->index] != NULL); - * - * superclass is a class: - * - * return ((sub != NULL) && (0 - * <= (sub->vftbl->baseval - super->vftbl->baseval) <= - * super->vftbl->diffvall)); - */ { classinfo *super; @@ -3300,10 +3265,6 @@ gen_method: supervftbl = super->vftbl; } -#if defined(ENABLE_THREADS) - codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase); -#endif - s1 = emit_load_s1(jd, iptr, REG_ITMP1); d = codegen_reg_of_dst(jd, iptr, REG_ITMP2); @@ -3320,7 +3281,7 @@ gen_method: M_TEST(s1); emit_label_beq(cd, BRANCH_LABEL_1); - codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags, + patcher_add_patch_ref(jd, PATCHER_checkcast_instanceof_flags, iptr->sx.s23.s3.c.ref, 0); M_MOV_IMM(0, REG_ITMP3); /* super->flags */ @@ -3336,10 +3297,10 @@ gen_method: emit_label_beq(cd, BRANCH_LABEL_3); } - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); + M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl)); if (super == NULL) { - codegen_addpatchref(cd, PATCHER_instanceof_interface, + patcher_add_patch_ref(jd, PATCHER_instanceof_interface, iptr->sx.s23.s3.c.ref, 0); } @@ -3378,23 +3339,19 @@ gen_method: emit_label_beq(cd, BRANCH_LABEL_5); } - M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl)); + M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl)); if (super == NULL) { - codegen_addpatchref(cd, PATCHER_instanceof_class, + patcher_add_patch_ref(jd, PATCHER_instanceof_class, iptr->sx.s23.s3.c.ref, 0); } M_MOV_IMM(supervftbl, REG_ITMP2); -#if defined(ENABLE_THREADS) - codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase); -#endif + M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl_t, baseval)); M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, diffval)); M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval)); -#if defined(ENABLE_THREADS) - codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase); -#endif + M_ISUB(REG_ITMP2, REG_ITMP1); M_CLR(d); /* may be REG_ITMP2 */ M_CMP(REG_ITMP3, REG_ITMP1); @@ -3427,7 +3384,7 @@ gen_method: /* Already Preallocated? */ if (!(var->flags & PREALLOC)) { if (var->flags & INMEMORY) { - M_ILD(REG_ITMP1, REG_SP, var->vv.regoff * 4); + M_ILD(REG_ITMP1, REG_SP, var->vv.regoff); M_IST(REG_ITMP1, REG_SP, (s1 + 3) * 4); } else @@ -3438,7 +3395,7 @@ gen_method: /* is a patcher function set? */ if (INSTRUCTION_IS_UNRESOLVED(iptr)) { - codegen_addpatchref(cd, PATCHER_builtin_multianewarray, + patcher_add_patch_ref(jd, PATCHER_builtin_multianewarray, iptr->sx.s23.s3.c.ref, 0); disp = 0; @@ -3473,6 +3430,13 @@ gen_method: emit_store_dst(jd, iptr, s1); break; +#if defined(ENABLE_SSA) + case ICMD_GETEXCEPTION: + d = codegen_reg_of_dst(jd, iptr, REG_ITMP1); + M_INTMOVE(REG_ITMP1, d); + emit_store_dst(jd, iptr, d); + break; +#endif default: exceptions_throw_internalerror("Unknown ICMD %d during code generation", iptr->opc); @@ -3488,10 +3452,12 @@ gen_method: #endif #if defined(ENABLE_SSA) if ( ls != NULL ) { + /* by edge splitting, in Blocks with phi moves there can only */ /* be a goto as last command, no other Jump/Branch Command */ + if (!last_cmd_was_goto) - codegen_insert_phi_moves(jd, bptr); + codegen_emit_phi_moves(jd, bptr); } #endif @@ -3510,211 +3476,15 @@ gen_method: } /* if (bptr -> flags >= BBREACHED) */ } /* for basic block */ - dseg_createlinenumbertable(cd); - /* generate stubs */ - emit_patcher_stubs(jd); - REPLACEMENT_EMIT_STUBS(jd); + emit_patcher_traps(jd); /* everything's ok */ return true; } -#if defined(ENABLE_SSA) -void codegen_insert_phi_moves(jitdata *jd, basicblock *bptr) { - /* look for phi moves */ - int t_a,s_a,i, type; - int t_lt, s_lt; /* lifetime indices of phi_moves */ - s4 t_regoff, s_regoff, s_flags, t_flags; - codegendata *cd; - lsradata *ls; - - MCODECHECK(512); - - ls = jd->ls; - cd = jd->cd; - - /* Moves from phi functions with highest indices have to be */ - /* inserted first, since this is the order as is used for */ - /* conflict resolution */ - for(i = ls->num_phi_moves[bptr->nr] - 1; i >= 0 ; i--) { - t_a = ls->phi_moves[bptr->nr][i][0]; - s_a = ls->phi_moves[bptr->nr][i][1]; -#if defined(SSA_DEBUG_VERBOSE) - if (compileverbose) - printf("BB %3i Move %3i <- %3i ", bptr->nr, t_a, s_a); -#endif - if (t_a >= 0) { - /* local var lifetimes */ - t_lt = ls->maxlifetimes + t_a; - type = ls->lifetime[t_lt].type; - } - else { - t_lt = -t_a-1; - type = ls->lifetime[t_lt].local_ss->s->type; - /* stackslot lifetime */ - } - - if (type == -1) { -#if defined(SSA_DEBUG_VERBOSE) - if (compileverbose) - printf("...returning - phi lifetimes where joined\n"); -#endif - return; - } - - if (s_a >= 0) { - /* local var lifetimes */ - s_lt = ls->maxlifetimes + s_a; - type = ls->lifetime[s_lt].type; - } - else { - s_lt = -s_a-1; - type = ls->lifetime[s_lt].type; - /* stackslot lifetime */ - } - - if (type == -1) { -#if defined(SSA_DEBUG_VERBOSE) - if (compileverbose) - printf("...returning - phi lifetimes where joined\n"); -#endif - return; - } - - if (t_a >= 0) { - t_flags = VAR(t_a)->flags; - t_regoff = VAR(t_a)->vv.regoff; - - } - else { - t_flags = ls->lifetime[t_lt].local_ss->s->flags; - t_regoff = ls->lifetime[t_lt].local_ss->s->regoff; - } - - if (s_a >= 0) { - /* local var move */ - s_flags = VAR(s_a)->flags; - s_regoff = VAR(s_a)->vv.regoff; - } else { - /* stackslot lifetime */ - s_flags = ls->lifetime[s_lt].local_ss->s->flags; - s_regoff = ls->lifetime[s_lt].local_ss->s->regoff; - } - - if (type == -1) { -#if defined(SSA_DEBUG_VERBOSE) - if (compileverbose) - printf("...returning - phi lifetimes where joined\n"); -#endif - return; - } - - cg_move(cd, type, s_regoff, s_flags, t_regoff, t_flags); - -#if defined(SSA_DEBUG_VERBOSE) - if (compileverbose) { - if (IS_INMEMORY(t_flags) && IS_INMEMORY(s_flags)) { - /* mem -> mem */ - printf("M%3i <- M%3i",t_regoff,s_regoff); - } - else if (IS_INMEMORY(s_flags)) { - /* mem -> reg */ - printf("R%3i <- M%3i",t_regoff,s_regoff); - } - else if (IS_INMEMORY(t_flags)) { - /* reg -> mem */ - printf("M%3i <- R%3i",t_regoff,s_regoff); - } - else { - /* reg -> reg */ - printf("R%3i <- R%3i",t_regoff,s_regoff); - } - printf("\n"); - } -#endif /* defined(SSA_DEBUG_VERBOSE) */ - } -} - -void cg_move(codegendata *cd, s4 type, s4 src_regoff, s4 src_flags, - s4 dst_regoff, s4 dst_flags) { - if ((IS_INMEMORY(dst_flags)) && (IS_INMEMORY(src_flags))) { - /* mem -> mem */ - if (dst_regoff != src_regoff) { - if (!IS_2_WORD_TYPE(type)) { - if (IS_FLT_DBL_TYPE(type)) { - emit_flds_membase(cd, REG_SP, src_regoff * 4); - emit_fstps_membase(cd, REG_SP, dst_regoff * 4); - } else{ - emit_mov_membase_reg(cd, REG_SP, src_regoff * 4, - REG_ITMP1); - emit_mov_reg_membase(cd, REG_ITMP1, REG_SP, dst_regoff * 4); - } - } else { /* LONG OR DOUBLE */ - if (IS_FLT_DBL_TYPE(type)) { - emit_fldl_membase( cd, REG_SP, src_regoff * 4); - emit_fstpl_membase(cd, REG_SP, dst_regoff * 4); - } else { - emit_mov_membase_reg(cd, REG_SP, src_regoff * 4, - REG_ITMP1); - emit_mov_reg_membase(cd, REG_ITMP1, REG_SP, dst_regoff * 4); - emit_mov_membase_reg(cd, REG_SP, src_regoff * 4 + 4, - REG_ITMP1); - emit_mov_reg_membase(cd, REG_ITMP1, REG_SP, - dst_regoff * 4 + 4); - } - } - } - } else { - if (IS_FLT_DBL_TYPE(type)) { - log_text("cg_move: flt/dbl type have to be in memory\n"); -/* assert(0); */ - } - if (IS_2_WORD_TYPE(type)) { - log_text("cg_move: longs have to be in memory\n"); -/* assert(0); */ - } - if (IS_INMEMORY(src_flags)) { - /* mem -> reg */ - emit_mov_membase_reg(cd, REG_SP, src_regoff * 4, dst_regoff); - } else if (IS_INMEMORY(dst_flags)) { - /* reg -> mem */ - emit_mov_reg_membase(cd, src_regoff, REG_SP, dst_regoff * 4); - } else { - /* reg -> reg */ - /* only ints can be in regs on i386 */ - M_INTMOVE(src_regoff,dst_regoff); - } - } -} -#endif /* defined(ENABLE_SSA) */ - - -/* codegen_emit_stub_compiler ************************************************** - - Emit a stub routine which calls the compiler. - -*******************************************************************************/ - -void codegen_emit_stub_compiler(jitdata *jd) -{ - methodinfo *m; - codegendata *cd; - - /* get required compiler data */ - - m = jd->m; - cd = jd->cd; - - /* code for the stub */ - - M_MOV_IMM(m, REG_ITMP1); - M_MOV_IMM(asm_call_jit_compiler, REG_ITMP3); - M_JMP(REG_ITMP3); -} - /* codegen_emit_stub_native **************************************************** @@ -3722,16 +3492,15 @@ void codegen_emit_stub_compiler(jitdata *jd) *******************************************************************************/ -void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f) +void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f, int skipparams) { methodinfo *m; codeinfo *code; codegendata *cd; methoddesc *md; - s4 nativeparams; - s4 i, j; /* count variables */ - s4 t; - s4 s1, s2; + int i, j; /* count variables */ + int s1, s2; + int disp; /* get required compiler data */ @@ -3742,31 +3511,26 @@ void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f) /* set some variables */ md = m->parseddesc; - nativeparams = (m->flags & ACC_STATIC) ? 2 : 1; /* calculate stackframe size */ cd->stackframesize = - sizeof(stackframeinfo) / SIZEOF_VOID_P + + sizeof(stackframeinfo_t) / SIZEOF_VOID_P + sizeof(localref_table) / SIZEOF_VOID_P + - 1 + /* function pointer */ 4 + /* 4 arguments (start_native_call) */ nmd->memuse; /* keep stack 16-byte aligned */ - cd->stackframesize |= 0x3; + ALIGN_ODD(cd->stackframesize); /* create method header */ (void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */ - (void) dseg_add_unique_s4(cd, cd->stackframesize * 4); /* FrameSize */ - (void) dseg_add_unique_s4(cd, 0); /* IsSync */ + (void) dseg_add_unique_s4(cd, cd->stackframesize * 8 + 4); /* FrameSize */ (void) dseg_add_unique_s4(cd, 0); /* IsLeaf */ (void) dseg_add_unique_s4(cd, 0); /* IntSave */ (void) dseg_add_unique_s4(cd, 0); /* FltSave */ - (void) dseg_addlinenumbertablesize(cd); - (void) dseg_add_unique_s4(cd, 0); /* ExTableSize */ #if defined(ENABLE_PROFILING) /* generate native method profiling code */ @@ -3781,20 +3545,7 @@ void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f) /* calculate stackframe size for native function */ - M_ASUB_IMM(cd->stackframesize * 4, REG_SP); - -#if !defined(NDEBUG) - emit_verbosecall_enter(jd); -#endif - - /* get function address (this must happen before the stackframeinfo) */ - -#if !defined(WITH_STATIC_CLASSPATH) - if (f == NULL) - codegen_addpatchref(cd, PATCHER_resolve_native, m, 0); -#endif - - M_AST_IMM((ptrint) f, REG_SP, 4 * 4); + M_ASUB_IMM(cd->stackframesize * 8 + 4, REG_SP); /* Mark the whole fpu stack as free for native functions (only for saved */ /* register count == 0). */ @@ -3808,89 +3559,120 @@ void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f) emit_ffree_reg(cd, 6); emit_ffree_reg(cd, 7); +#if defined(ENABLE_GC_CACAO) + /* remember callee saved int registers in stackframeinfo (GC may need to */ + /* recover them during a collection). */ + + disp = cd->stackframesize * 8 - sizeof(stackframeinfo_t) + + OFFSET(stackframeinfo_t, intregs); + + for (i = 0; i < INT_SAV_CNT; i++) + M_AST(abi_registers_integer_saved[i], REG_SP, disp + i * 4); +#endif + /* prepare data structures for native function call */ M_MOV(REG_SP, REG_ITMP1); - M_AADD_IMM(cd->stackframesize * 4, REG_ITMP1); - M_AST(REG_ITMP1, REG_SP, 0 * 4); M_IST_IMM(0, REG_SP, 1 * 4); dseg_adddata(cd); - M_MOV(REG_SP, REG_ITMP2); - M_AADD_IMM(cd->stackframesize * 4 + SIZEOF_VOID_P, REG_ITMP2); - - M_AST(REG_ITMP2, REG_SP, 2 * 4); - M_ALD(REG_ITMP3, REG_SP, cd->stackframesize * 4); - M_AST(REG_ITMP3, REG_SP, 3 * 4); M_MOV_IMM(codegen_start_native_call, REG_ITMP1); M_CALL(REG_ITMP1); - M_ALD(REG_ITMP3, REG_SP, 4 * 4); + /* remember class argument */ + + if (m->flags & ACC_STATIC) + M_MOV(REG_RESULT, REG_ITMP3); + + /* Copy or spill arguments to new locations. */ - /* copy arguments into new stackframe */ + for (i = md->paramcount - 1, j = i + skipparams; i >= 0; i--, j--) { + if (!md->params[i].inmemory) + assert(0); - for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) { - t = md->paramtypes[i].type; + s1 = md->params[i].regoff + cd->stackframesize * 8 + 8; + s2 = nmd->params[j].regoff; - if (!md->params[i].inmemory) { - /* no integer argument registers */ - } else { /* float/double in memory can be copied like int/longs */ - s1 = (md->params[i].regoff + cd->stackframesize + 1) * 4; - s2 = nmd->params[j].regoff * 4; + /* float/double in memory can be copied like int/longs */ + switch (md->paramtypes[i].type) { + case TYPE_INT: + case TYPE_FLT: + case TYPE_ADR: M_ILD(REG_ITMP1, REG_SP, s1); M_IST(REG_ITMP1, REG_SP, s2); - if (IS_2_WORD_TYPE(t)) { - M_ILD(REG_ITMP1, REG_SP, s1 + 4); - M_IST(REG_ITMP1, REG_SP, s2 + 4); - } + break; + case TYPE_LNG: + case TYPE_DBL: + M_LLD(REG_ITMP12_PACKED, REG_SP, s1); + M_LST(REG_ITMP12_PACKED, REG_SP, s2); + break; } } - /* if function is static, put class into second argument */ + /* Handle native Java methods. */ - if (m->flags & ACC_STATIC) - M_AST_IMM(m->class, REG_SP, 1 * 4); + if (m->flags & ACC_NATIVE) { + /* if function is static, put class into second argument */ - /* put env into first argument */ + if (m->flags & ACC_STATIC) + M_AST(REG_ITMP3, REG_SP, 1 * 4); - M_AST_IMM(_Jv_env, REG_SP, 0 * 4); + /* put env into first argument */ - /* call the native function */ + M_AST_IMM(_Jv_env, REG_SP, 0 * 4); + } - M_CALL(REG_ITMP3); + /* Call the native function. */ + + disp = dseg_add_functionptr(cd, f); + emit_mov_imm_reg(cd, 0, REG_ITMP3); + dseg_adddata(cd); + M_ALD(REG_ITMP1, REG_ITMP3, disp); + M_CALL(REG_ITMP1); /* save return value */ switch (md->returntype.type) { case TYPE_INT: case TYPE_ADR: - M_IST(REG_RESULT, REG_SP, 1 * 4); + switch (md->returntype.decltype) { + case PRIMITIVETYPE_BOOLEAN: + M_BZEXT(REG_RESULT, REG_RESULT); + break; + case PRIMITIVETYPE_BYTE: + M_BSEXT(REG_RESULT, REG_RESULT); + break; + case PRIMITIVETYPE_CHAR: + M_CZEXT(REG_RESULT, REG_RESULT); + break; + case PRIMITIVETYPE_SHORT: + M_SSEXT(REG_RESULT, REG_RESULT); + break; + } + M_IST(REG_RESULT, REG_SP, 1 * 8); break; case TYPE_LNG: - M_LST(REG_RESULT_PACKED, REG_SP, 1 * 4); + M_LST(REG_RESULT_PACKED, REG_SP, 1 * 8); break; case TYPE_FLT: - emit_fsts_membase(cd, REG_SP, 1 * 4); + emit_fsts_membase(cd, REG_SP, 1 * 8); break; case TYPE_DBL: - emit_fstl_membase(cd, REG_SP, 1 * 4); + emit_fstl_membase(cd, REG_SP, 1 * 8); break; case TYPE_VOID: break; } -#if !defined(NDEBUG) - emit_verbosecall_exit(jd); -#endif - /* remove native stackframe info */ M_MOV(REG_SP, REG_ITMP1); - M_AADD_IMM(cd->stackframesize * 4, REG_ITMP1); - M_AST(REG_ITMP1, REG_SP, 0 * 4); + M_IST_IMM(0, REG_SP, 1 * 4); + dseg_adddata(cd); + M_MOV_IMM(codegen_finish_native_call, REG_ITMP1); M_CALL(REG_ITMP1); M_MOV(REG_RESULT, REG_ITMP2); /* REG_ITMP3 == REG_RESULT2 */ @@ -3900,22 +3682,33 @@ void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f) switch (md->returntype.type) { case TYPE_INT: case TYPE_ADR: - M_ILD(REG_RESULT, REG_SP, 1 * 4); + M_ILD(REG_RESULT, REG_SP, 1 * 8); break; case TYPE_LNG: - M_LLD(REG_RESULT_PACKED, REG_SP, 1 * 4); + M_LLD(REG_RESULT_PACKED, REG_SP, 1 * 8); break; case TYPE_FLT: - emit_flds_membase(cd, REG_SP, 1 * 4); + emit_flds_membase(cd, REG_SP, 1 * 8); break; case TYPE_DBL: - emit_fldl_membase(cd, REG_SP, 1 * 4); + emit_fldl_membase(cd, REG_SP, 1 * 8); break; case TYPE_VOID: break; } - M_AADD_IMM(cd->stackframesize * 4, REG_SP); +#if defined(ENABLE_GC_CACAO) + /* restore callee saved int registers from stackframeinfo (GC might have */ + /* modified them during a collection). */ + + disp = cd->stackframesize * 8 - sizeof(stackframeinfo_t) + + OFFSET(stackframeinfo_t, intregs); + + for (i = 0; i < INT_SAV_CNT; i++) + M_ALD(abi_registers_integer_saved[i], REG_SP, disp + i * 4); +#endif + + M_AADD_IMM(cd->stackframesize * 8 + 4, REG_SP); /* check for exception */ @@ -3932,10 +3725,6 @@ void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f) M_MOV_IMM(asm_handle_nat_exception, REG_ITMP3); M_JMP(REG_ITMP3); - - /* generate patcher stubs */ - - emit_patcher_stubs(jd); }