/* 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.
#include "vm/jit/i386/emit.h"
#include "mm/memory.h"
-#include "native/jni.h"
-#include "native/localref.h"
-#include "native/native.h"
-#include "threads/lock-common.h"
+#include "native/localref.hpp"
+#include "native/native.hpp"
-#include "vm/builtin.h"
-#include "vm/exceptions.h"
+#include "threads/lock.hpp"
+
+#include "vm/jit/builtin.hpp"
+#include "vm/exceptions.hpp"
#include "vm/global.h"
-#include "vm/stringlocal.h"
-#include "vm/vm.h"
+#include "vm/loader.hpp"
+#include "vm/options.h"
+#include "vm/primitive.hpp"
+#include "vm/utf8.h"
+#include "vm/vm.hpp"
#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
-#include "vm/jit/codegen-common.h"
+#include "vm/jit/codegen-common.hpp"
#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-common.h"
+#include "vm/jit/emit-common.hpp"
+#include "vm/jit/jit.hpp"
+#include "vm/jit/jitcache.hpp"
+#include "vm/jit/linenumbertable.hpp"
+#include "vm/jit/parse.hpp"
+#include "vm/jit/patcher-common.hpp"
#include "vm/jit/reg.h"
-#include "vm/jit/replace.h"
-#include "vm/jit/stacktrace.h"
+#include "vm/jit/replace.hpp"
+#include "vm/jit/stacktrace.hpp"
+#include "vm/jit/trap.h"
#if defined(ENABLE_SSA)
# include "vm/jit/optimizing/lsra.h"
# include "vm/jit/allocator/lsra.h"
#endif
-#include "vmcore/loader.h"
-#include "vmcore/options.h"
-#include "vmcore/utf8.h"
-
/* codegen_emit ****************************************************************
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;
savedregs_num += (FLT_SAV_CNT - rd->savfltreguse);
cd->stackframesize = rd->memuse + savedregs_num;
-
#if defined(ENABLE_THREADS)
/* space to save argument of monitor_enter */
/* Keep stack of non-leaf functions 16-byte aligned. */
if (!code_is_leafmethod(code)) {
- ALIGN_ODD(cd->stackframesize); /* XXX this is wrong, +4 is missing */
+ ALIGN_ODD(cd->stackframesize);
}
+ align_off = cd->stackframesize ? 4 : 0;
+
+#if defined(ENABLE_JITCACHE)
+ disp = dseg_add_unique_address(cd, code); /* CodeinfoPointer */
+ jitcache_add_cached_ref(code, CRT_CODEINFO, 0, disp);
+#else
(void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
- (void) dseg_add_unique_s4(cd, cd->stackframesize * 8); /* FrameSize */
+#endif
+ (void) dseg_add_unique_s4(
+ cd, cd->stackframesize * 8 + align_off); /* FrameSize */
code->synchronizedoffset = rd->memuse * 8;
/* count frequency */
M_MOV_IMM(code, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CODEINFO, NULL);
+
M_IADD_IMM_MEMBASE(1, REG_ITMP3, OFFSET(codeinfo, frequency));
}
#endif
/* create stack frame (if necessary) */
if (cd->stackframesize)
- M_ASUB_IMM(cd->stackframesize * 8, REG_SP);
+ /* align_off == 4 */
+ M_ASUB_IMM(cd->stackframesize * 8 + 4, REG_SP);
/* save return address and used callee saved registers */
}
else {
if (!(var->flags & INMEMORY)) {
- M_ILD(d, REG_SP, cd->stackframesize * 8 + 4 + s1);
+ M_ILD(d, REG_SP,
+ cd->stackframesize * 8 + 4 + align_off + s1);
}
else {
if (!IS_2_WORD_TYPE(t)) {
/* no copy avoiding by now possible with SSA */
if (ls != NULL) {
emit_mov_membase_reg( /* + 4 for return address */
- cd, REG_SP, cd->stackframesize * 8 + s1 + 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);
+ cd, REG_ITMP1, REG_SP, var->vv.regoff);
}
else
#endif /*defined(ENABLE_SSA)*/
/* reuse stackslot */
- var->vv.regoff = cd->stackframesize * 8 + 4 + s1;
+ var->vv.regoff = cd->stackframesize * 8 + 4 +
+ align_off + s1;
}
else {
/* no copy avoiding by now possible with SSA */
if (ls != NULL) {
emit_mov_membase_reg( /* + 4 for return address */
- cd, REG_SP, cd->stackframesize * 8 + s1 + 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);
+ cd, REG_ITMP1, REG_SP, var->vv.regoff);
emit_mov_membase_reg( /* + 4 for return address */
- cd, REG_SP, cd->stackframesize * 8 + s1 + 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);
+ cd, REG_ITMP1, REG_SP, var->vv.regoff + 4);
}
else
#endif /*defined(ENABLE_SSA)*/
/* reuse stackslot */
- var->vv.regoff = cd->stackframesize * 8 + 4 + s1;
+ var->vv.regoff = cd->stackframesize * 8 + 8 + s1;
}
}
}
if (!(var->flags & INMEMORY)) { /* stack-arg -> register */
if (t == TYPE_FLT) {
emit_flds_membase(
- cd, REG_SP, cd->stackframesize * 8 + s1 + 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 * 8 + s1 + 4);
+ cd, REG_SP,
+ cd->stackframesize * 8 + s1 + 4 + align_off);
assert(0);
/* emit_fstp_reg(cd, var->vv.regoff + fpu_st_offset); */
}
/* no copy avoiding by now possible with SSA */
if (ls != NULL) {
emit_mov_membase_reg(
- cd, REG_SP, cd->stackframesize * 8 + s1 + 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);
+ cd, REG_ITMP1, REG_SP, var->vv.regoff);
if (t == TYPE_FLT) {
emit_flds_membase(
- cd, REG_SP, cd->stackframesize * 8 + s1 + 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 * 8 + s1 + 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 stackslot */
- var->vv.regoff = cd->stackframesize * 8 + 4 + s1;
+ var->vv.regoff = cd->stackframesize * 8 + 4 +
+ align_off + s1;
}
}
}
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);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_OBJECT_HEADER, m->clazz);
}
else {
- M_ALD(REG_ITMP1, REG_SP, cd->stackframesize * 8 + 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 * 8);
M_AST(REG_ITMP1, REG_SP, 0 * 4);
M_MOV_IMM(LOCK_monitor_enter, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(LOCK_monitor_enter));
M_CALL(REG_ITMP3);
}
#endif
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
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 \
disp = dseg_add_float(cd, iptr->sx.val.f);
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
emit_flds_membase(cd, REG_ITMP1, disp);
}
emit_store_dst(jd, iptr, d);
disp = dseg_add_double(cd, iptr->sx.val.d);
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
emit_fldl_membase(cd, REG_ITMP1, disp);
}
emit_store_dst(jd, iptr, d);
if (iptr->sx.val.anyptr == NULL)
M_CLR(d);
else
+ {
M_MOV_IMM(iptr->sx.val.anyptr, d);
+ JITCACHE_ADD_CACHED_REF_JD(
+ jd,
+ (iptr->flags.bits & INS_FLAG_CLASS) ? CRT_CLASSINFO
+ : CRT_STRING,
+ (iptr->flags.bits & INS_FLAG_CLASS) ? (void*) iptr->sx.val.c.cls
+ : (void*) iptr->sx.val.stringconst);
+ }
}
emit_store_dst(jd, iptr, d);
break;
M_LST(s1, REG_SP, 0 * 4);
M_MOV_IMM(bte->fp, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP, bte);
M_CALL(REG_ITMP3);
emit_store_dst(jd, iptr, d);
break;
disp = dseg_add_unique_s4(cd, 0);
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
emit_mov_reg_membase(cd, var->vv.regoff, REG_ITMP1, disp);
emit_fildl_membase(cd, REG_ITMP1, disp);
}
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
/* Round to zero, 53-bit mode, exception masked */
disp = dseg_add_s4(cd, 0x0e7f);
/* XXX: change this when we use registers */
emit_flds_membase(cd, REG_SP, var1->vv.regoff);
emit_mov_imm_reg(cd, (ptrint) asm_builtin_f2i, REG_ITMP1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_f2i));
emit_call_reg(cd, REG_ITMP1);
if (var->flags & INMEMORY) {
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
/* Round to zero, 53-bit mode, exception masked */
disp = dseg_add_s4(cd, 0x0e7f);
/* XXX: change this when we use registers */
emit_fldl_membase(cd, REG_SP, var1->vv.regoff);
emit_mov_imm_reg(cd, (ptrint) asm_builtin_d2i, REG_ITMP1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_d2i));
emit_call_reg(cd, REG_ITMP1);
if (var->flags & INMEMORY) {
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
/* Round to zero, 53-bit mode, exception masked */
disp = dseg_add_s4(cd, 0x0e7f);
/* XXX: change this when we use registers */
emit_flds_membase(cd, REG_SP, var1->vv.regoff);
emit_mov_imm_reg(cd, (ptrint) asm_builtin_f2l, REG_ITMP1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_f2l));
emit_call_reg(cd, REG_ITMP1);
emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff);
emit_mov_reg_membase(cd, REG_RESULT2,
emit_mov_imm_reg(cd, 0, REG_ITMP1);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
/* Round to zero, 53-bit mode, exception masked */
disp = dseg_add_s4(cd, 0x0e7f);
/* XXX: change this when we use registers */
emit_fldl_membase(cd, REG_SP, var1->vv.regoff);
emit_mov_imm_reg(cd, (ptrint) asm_builtin_d2l, REG_ITMP1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_d2l));
emit_call_reg(cd, REG_ITMP1);
emit_mov_reg_membase(cd, REG_RESULT, REG_SP, var->vv.regoff);
emit_mov_reg_membase(cd, REG_RESULT2,
M_AST(s1, REG_SP, 0 * 4);
M_AST(s3, REG_SP, 1 * 4);
M_MOV_IMM(BUILTIN_FAST_canstore, REG_ITMP1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_FAST_canstore));
M_CALL(REG_ITMP1);
emit_arraystore_check(cd, iptr);
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
fieldtype = fi->type;
+
disp = (intptr_t) fi->value;
- if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
- patcher_add_patch_ref(jd, PATCHER_initialize_class, 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);
+ JITCACHE_ADD_CACHED_REF_JD_COND(jd, CRT_FIELDINFO_VALUE, fi, disp);
switch (fieldtype) {
case TYPE_INT:
case TYPE_ADR:
break;
case ICMD_PUTSTATIC: /* ..., value ==> ... */
-
+
if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
uf = iptr->sx.s23.s3.uf;
fieldtype = uf->fieldref->parseddesc.fd->type;
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
fieldtype = fi->type;
+
disp = (intptr_t) fi->value;
- if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
- patcher_add_patch_ref(jd, PATCHER_initialize_class, 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);
+ JITCACHE_ADD_CACHED_REF_JD_COND(jd, CRT_FIELDINFO_VALUE, fi, disp);
switch (fieldtype) {
case TYPE_INT:
case TYPE_ADR:
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
fieldtype = fi->type;
+
disp = (intptr_t) fi->value;
- if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
- patcher_add_patch_ref(jd, PATCHER_initialize_class, 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);
+ JITCACHE_ADD_CACHED_REF_JD_COND(jd, CRT_FIELDINFO_VALUE, fi, disp);
switch (fieldtype) {
case TYPE_INT:
case TYPE_ADR:
s1 = emit_load_s1(jd, iptr, REG_ITMP1);
emit_nullpointer_check(cd, iptr, s1);
+#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;
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
fieldtype = fi->type;
+
disp = fi->offset;
+
}
switch (fieldtype) {
M_POP(REG_ITMP2_XPC);
M_MOV_IMM(asm_handle_exception, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ASM_HANDLE_EXCEPTION, 1);
M_JMP(REG_ITMP3);
break;
M_AST(REG_ITMP2, REG_SP, 0);
M_MOV_IMM(LOCK_monitor_exit, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(LOCK_monitor_exit));
M_CALL(REG_ITMP3);
/* and now restore the proper return value */
/* deallocate stack */
if (cd->stackframesize)
- M_AADD_IMM(cd->stackframesize * 8, REG_SP);
+ M_AADD_IMM(cd->stackframesize * 8 + 4, REG_SP);
M_RET;
}
M_MOV_IMM(0, REG_ITMP2);
dseg_adddata(cd);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_ENTRYPOINT, NULL);
emit_mov_memindex_reg(cd, -(cd->dseglen), REG_ITMP2, REG_ITMP1, 2, REG_ITMP1);
M_JMP(REG_ITMP1);
}
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 ...]] ==> ... */
else {
M_MOV_IMM(bte->stub, REG_ITMP1);
}
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN, bte);
M_CALL(REG_ITMP1);
+
+#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:
}
else {
disp = (ptrint) lm->stubroutine;
+
d = lm->parseddesc->returntype.type;
}
-
M_MOV_IMM(disp, REG_ITMP2);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_METHODINFO_STUBROUTINE, lm);
M_CALL(REG_ITMP2);
break;
else {
s1 = OFFSET(vftbl_t, table[0]) +
sizeof(methodptr) * lm->vftblindex;
+
d = md->returntype.type;
}
M_ALD(REG_METHODPTR, REG_ITMP1,
OFFSET(java_object_t, vftbl));
M_ALD32(REG_ITMP3, REG_METHODPTR, s1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_METHODINFO_TABLE, lm);
M_CALL(REG_ITMP3);
break;
}
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_object_t, vftbl));
M_ALD32(REG_METHODPTR, REG_METHODPTR, s1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_METHODINFO_INTERFACETABLE, lm);
M_ALD32(REG_ITMP3, REG_METHODPTR, s2);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_METHODINFO_METHODOFFSET, lm);
M_CALL(REG_ITMP3);
break;
}
superindex = super->index;
supervftbl = super->vftbl;
}
-
- if ((super == NULL) || !(super->flags & ACC_INTERFACE))
- CODEGEN_CRITICAL_SECTION_NEW;
-
s1 = emit_load_s1(jd, iptr, REG_ITMP1);
/* if class is not resolved, check which code to call */
-
if (super == NULL) {
M_TEST(s1);
emit_label_beq(cd, BRANCH_LABEL_1);
M_ILD32(REG_ITMP3,
REG_ITMP2, OFFSET(vftbl_t, interfacetablelength));
M_ISUB_IMM32(superindex, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO_INDEX, super);
/* XXX do we need this one? */
M_TEST(REG_ITMP3);
emit_classcast_check(cd, iptr, BRANCH_LE, REG_ITMP3, s1);
M_ALD32(REG_ITMP3, REG_ITMP2,
OFFSET(vftbl_t, interfacetable[0]) -
superindex * sizeof(methodptr*));
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO_INTERFACETABLE, super);
M_TEST(REG_ITMP3);
emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ITMP3, s1);
}
M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl));
-
if (super == NULL) {
patcher_add_patch_ref(jd, PATCHER_checkcast_class,
iptr->sx.s23.s3.c.ref,
0);
}
-
M_MOV_IMM(supervftbl, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO_VFTBL, super);
- CODEGEN_CRITICAL_SECTION_START;
+ if (super == NULL || super->vftbl->subtype_depth >= DISPLAY_SIZE) {
+ M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, subtype_offset));
+ M_CMP_MEMINDEX(REG_ITMP2, 0, REG_ITMP1, 0, REG_ITMP3);
+ emit_label_beq(cd, BRANCH_LABEL_6); /* good */
- M_ILD32(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval));
+ if (super == NULL) {
+ M_ICMP_IMM(OFFSET(vftbl_t, subtype_display[DISPLAY_SIZE]), REG_ITMP1);
+ emit_label_bne(cd, BRANCH_LABEL_10); /* throw */
+ }
- /* if (s1 != REG_ITMP1) { */
- /* emit_mov_membase_reg(cd, REG_ITMP3, OFFSET(vftbl_t, baseval), REG_ITMP1); */
- /* emit_mov_membase_reg(cd, REG_ITMP3, OFFSET(vftbl_t, diffval), REG_ITMP3); */
- /* #if defined(ENABLE_THREADS) */
- /* codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase); */
- /* #endif */
- /* emit_alu_reg_reg(cd, ALU_SUB, REG_ITMP1, REG_ITMP2); */
+ M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, subtype_depth));
+ M_CMP_MEMBASE(REG_ITMP2, OFFSET(vftbl_t, subtype_depth), REG_ITMP1);
+ emit_label_bgt(cd, BRANCH_LABEL_9); /* throw */
- /* } else { */
- M_ILD32(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, baseval));
- M_ISUB(REG_ITMP3, REG_ITMP2);
- M_MOV_IMM(supervftbl, REG_ITMP3);
- M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, diffval));
+ M_ALD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, subtype_overflow));
+ M_CMP_MEMINDEX(REG_ITMP2, -4*DISPLAY_SIZE, REG_ITMP1, 2, REG_ITMP3);
+ emit_label_beq(cd, BRANCH_LABEL_7); /* good */
- CODEGEN_CRITICAL_SECTION_END;
+ emit_label(cd, BRANCH_LABEL_9);
+ if (super == NULL)
+ emit_label(cd, BRANCH_LABEL_10);
- /* } */
+ /* reload s1, might have been destroyed */
+ emit_load_s1(jd, iptr, REG_ITMP1);
+ M_ALD_MEM(s1, TRAP_ClassCastException);
- M_CMP(REG_ITMP3, REG_ITMP2);
- emit_classcast_check(cd, iptr, BRANCH_ULE, REG_ITMP3, s1);
+ emit_label(cd, BRANCH_LABEL_7);
+ emit_label(cd, BRANCH_LABEL_6);
+ /* reload s1, might have been destroyed */
+ emit_load_s1(jd, iptr, REG_ITMP1);
+ }
+ else {
+ M_CMP_MEMBASE(REG_ITMP2, super->vftbl->subtype_offset, REG_ITMP3);
+
+ emit_classcast_check(cd, iptr, BRANCH_NE, REG_ITMP3, s1);
+ }
if (super != NULL)
emit_label(cd, BRANCH_LABEL_5);
if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
patcher_add_patch_ref(jd, PATCHER_builtin_arraycheckcast,
iptr->sx.s23.s3.c.ref, 0);
+ disp = 0;
}
+ else {
+ disp = (ptrint) iptr->sx.s23.s3.c.cls;
+ }
+
+ M_AST_IMM(disp, REG_SP, 1 * 4);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO, disp);
- M_AST_IMM(iptr->sx.s23.s3.c.cls, REG_SP, 1 * 4);
M_MOV_IMM(BUILTIN_arraycheckcast, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_arraycheckcast));
M_CALL(REG_ITMP3);
s1 = emit_load_s1(jd, iptr, REG_ITMP2);
supervftbl = super->vftbl;
}
- if ((super == NULL) || !(super->flags & ACC_INTERFACE))
- CODEGEN_CRITICAL_SECTION_NEW;
-
s1 = emit_load_s1(jd, iptr, REG_ITMP1);
d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
emit_label_beq(cd, BRANCH_LABEL_3);
}
+
M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl));
if (super == NULL) {
M_ILD32(REG_ITMP3,
REG_ITMP1, OFFSET(vftbl_t, interfacetablelength));
M_ISUB_IMM32(superindex, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO_INDEX, super);
+
M_TEST(REG_ITMP3);
disp = (2 + 4 /* mov_membase32_reg */ + 2 /* test */ +
M_ALD32(REG_ITMP1, REG_ITMP1,
OFFSET(vftbl_t, interfacetable[0]) -
superindex * sizeof(methodptr*));
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO_INTERFACETABLE, super);
M_TEST(REG_ITMP1);
/* emit_setcc_reg(cd, CC_A, d); */
/* emit_jcc(cd, CC_BE, 5); */
emit_label_beq(cd, BRANCH_LABEL_5);
}
- M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl));
-
+ M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl));
if (super == NULL) {
patcher_add_patch_ref(jd, PATCHER_instanceof_class,
iptr->sx.s23.s3.c.ref, 0);
}
+ M_MOV_IMM(supervftbl, REG_ITMP3);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO_VFTBL, super);
+
+ if (super == NULL || super->vftbl->subtype_depth >= DISPLAY_SIZE) {
+ M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, subtype_offset));
+ M_CMP_MEMINDEX(REG_ITMP2, 0, REG_ITMP1, 0, REG_ITMP3);
+ emit_label_bne(cd, BRANCH_LABEL_8); /* jump over INC/SETE */
+ if (d == REG_ITMP2) {
+ M_SETE(d);
+ M_BSEXT(d, d);
+ } else
+ M_IINC(d);
+ emit_label_br(cd, BRANCH_LABEL_6); /* true */
+ emit_label(cd, BRANCH_LABEL_8);
- M_MOV_IMM(supervftbl, REG_ITMP2);
+ if (super == NULL) {
+ M_ICMP_IMM(OFFSET(vftbl_t, subtype_display[DISPLAY_SIZE]), REG_ITMP1);
+ emit_label_bne(cd, BRANCH_LABEL_10); /* false */
+ }
- CODEGEN_CRITICAL_SECTION_START;
+ M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, subtype_depth));
+ M_CMP_MEMBASE(REG_ITMP2, OFFSET(vftbl_t, subtype_depth), REG_ITMP1);
+ emit_label_bgt(cd, BRANCH_LABEL_9); /* false */
- 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));
+ M_ALD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, subtype_overflow));
+ M_CMP_MEMINDEX(REG_ITMP2, -4*DISPLAY_SIZE, REG_ITMP1, 2, REG_ITMP3);
+ M_SETE(d);
+ if (d == REG_ITMP2) {
+ M_BSEXT(d, d);
- CODEGEN_CRITICAL_SECTION_END;
+ emit_label_br(cd, BRANCH_LABEL_7); /* jump over M_CLR */
+ }
- M_ISUB(REG_ITMP2, REG_ITMP1);
- M_CLR(d); /* may be REG_ITMP2 */
- M_CMP(REG_ITMP3, REG_ITMP1);
- M_BA(5);
- M_MOV_IMM(1, d);
+ emit_label(cd, BRANCH_LABEL_9);
+ if (super == NULL)
+ emit_label(cd, BRANCH_LABEL_10);
+ if (d == REG_ITMP2) {
+ M_CLR(d);
+
+ emit_label(cd, BRANCH_LABEL_7);
+ }
+ emit_label(cd, BRANCH_LABEL_6);
+ }
+ else {
+ M_CMP_MEMBASE(REG_ITMP2, super->vftbl->subtype_offset, REG_ITMP3);
+
+ M_SETE(d);
+ if (d == REG_ITMP2)
+ M_BSEXT(d, d);
+ }
if (super != NULL)
emit_label(cd, BRANCH_LABEL_5);
/* a1 = arraydescriptor */
M_IST_IMM(disp, REG_SP, 1 * 4);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CLASSINFO, disp);
/* a2 = pointer to dimensions = stack pointer */
M_AST(REG_ITMP1, REG_SP, 2 * 4);
M_MOV_IMM(BUILTIN_multianewarray, REG_ITMP1);
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_BUILTIN_FP,
+ builtintable_get_internal(BUILTIN_multianewarray));
M_CALL(REG_ITMP1);
/* check for exception before result assignment */
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);
methoddesc *md;
int i, j; /* count variables */
int s1, s2;
- int funcdisp;
-#if defined(ENABLE_GC_CACAO)
int disp;
-#endif
/* get required compiler data */
/* keep stack 16-byte aligned */
- ALIGN_ODD(cd->stackframesize); /* XXX this is wrong, +4 is missing */
+ ALIGN_ODD(cd->stackframesize);
/* create method header */
(void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
- (void) dseg_add_unique_s4(cd, cd->stackframesize * 8); /* FrameSize */
+ (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 */
M_MOV_IMM(code, REG_ITMP1);
M_IADD_IMM_MEMBASE(1, REG_ITMP1, OFFSET(codeinfo, frequency));
+ JITCACHE_ADD_CACHED_REF_JD(jd, CRT_CODEINFO, 0);
}
#endif
/* calculate stackframe size for native function */
- M_ASUB_IMM(cd->stackframesize * 8, REG_SP);
-
- /* get function address (this must happen before the stackframeinfo) */
-
- funcdisp = dseg_add_functionptr(cd, f);
-
- if (f == NULL)
- patcher_add_patch_ref(jd, PATCHER_resolve_native_function, m, funcdisp);
+ 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). */
if (!md->params[i].inmemory)
assert(0);
- s1 = md->params[i].regoff + cd->stackframesize * 8 + 4;
+ s1 = md->params[i].regoff + cd->stackframesize * 8 + 8;
s2 = nmd->params[j].regoff;
/* float/double in memory can be copied like int/longs */
/* put env into first argument */
- M_AST_IMM(_Jv_env, REG_SP, 0 * 4);
+ M_AST_IMM(VM_get_jnienv(), REG_SP, 0 * 4);
}
- /* call the native function */
+ /* 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, funcdisp);
+ M_ALD(REG_ITMP1, REG_ITMP3, disp);
M_CALL(REG_ITMP1);
/* save return value */
switch (md->returntype.type) {
case TYPE_INT:
case TYPE_ADR:
+ switch (md->returntype.primitivetype) {
+ 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_ALD(abi_registers_integer_saved[i], REG_SP, disp + i * 4);
#endif
- M_AADD_IMM(cd->stackframesize * 8, REG_SP);
+ M_AADD_IMM(cd->stackframesize * 8 + 4, REG_SP);
/* check for exception */
M_MOV_IMM(asm_handle_nat_exception, REG_ITMP3);
M_JMP(REG_ITMP3);
-
- /* generate patcher stubs */
-
- emit_patcher_traps(jd);
}