Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 8211 2007-07-18 19:52:23Z michi $
-
*/
#include "config.h"
#include <assert.h>
+#include <stdint.h>
#include <stdio.h>
#include "vm/types.h"
#include "mm/memory.h"
#include "native/jni.h"
+#include "native/localref.h"
#include "native/native.h"
#include "threads/lock-common.h"
#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/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"
#if defined(ENABLE_THREADS)
/* space to save argument of monitor_enter */
- if (checksync && (m->flags & ACC_SYNCHRONIZED))
+ if (checksync && code_is_synchronized(code))
cd->stackframesize++;
#endif
/* Keep stack of non-leaf functions 16-byte aligned. */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
ALIGN_ODD(cd->stackframesize); /* XXX this is wrong, +4 is missing */
}
(void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
(void) dseg_add_unique_s4(cd, cd->stackframesize * 8); /* 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.
*/
+ /* XXX Remove this "offset by one". */
+
+ code->synchronizedoffset = (rd->memuse + 1) * 8;
- if (checksync && (m->flags & ACC_SYNCHRONIZED))
- (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 8); /* IsSync */
+ /* 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 */
/* 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) {
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);
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;
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;
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;
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;
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;
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);
- emit_mov_memindex_reg(cd, OFFSET(java_longarray, data[0]) + 4,
+ 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);
break;
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;
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;
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;
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;
/* 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;
/* 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;
/* 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;
assert(var->flags & INMEMORY);
emit_mov_membase_reg(cd, REG_SP, var->vv.regoff, REG_ITMP3);
- emit_mov_reg_memindex(cd, REG_ITMP3, OFFSET(java_longarray, data[0])
+ 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, 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 ==> ... */
/* 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 ==> ... */
/* 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;
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;
/* 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 ==> ... */
/* 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 ==> ... */
/* 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 ==> ... */
/* 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 ==> ... */
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 ==> ... */
/* 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;
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);
+ patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->class, 0);
}
M_MOV_IMM(disp, REG_ITMP1);
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);
+ patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->class, 0);
}
M_MOV_IMM(disp, REG_ITMP1);
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);
+ patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->class, 0);
}
M_MOV_IMM(disp, REG_ITMP1);
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_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) {
/* 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;
}
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;
}
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:
#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 */
#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 */
#endif
#if defined(ENABLE_THREADS)
- if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
+ if (checksync && code_is_synchronized(code)) {
M_ALD(REG_ITMP2, REG_SP, rd->memuse * 8);
/* we need to save the proper return value */
if (cd->stackframesize)
M_AADD_IMM(cd->stackframesize * 8, REG_SP);
- emit_ret(cd);
+ M_RET;
}
break;
case ICMD_BUILTIN: /* ..., [arg1, [arg2 ...]] ==> ... */
+ REPLACEMENT_POINT_FORGC_BUILTIN(cd, iptr);
+
bte = iptr->sx.s23.s3.bte;
md = bte->md;
goto gen_method;
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);
break;
case ICMD_INVOKESPECIAL:
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;
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;
}
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;
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;
}
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);
/* 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 */
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 */
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);
}
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_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);
}
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 */
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);
}
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);
}
/* 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;
/* generate stubs */
- emit_patcher_stubs(jd);
+ emit_patcher_traps(jd);
/* everything's ok */
return true;
}
-/* 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 ****************************************************
*******************************************************************************/
-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 funcdisp;
+#if defined(ENABLE_GC_CACAO)
+ int disp;
+#endif
/* get required compiler data */
/* 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;
M_ASUB_IMM(cd->stackframesize * 8, 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
+ funcdisp = dseg_add_functionptr(cd, f);
- M_AST_IMM((ptrint) f, REG_SP, 4 * 4);
+ if (f == NULL)
+ patcher_add_patch_ref(jd, PATCHER_resolve_native_function, m, funcdisp);
/* Mark the whole fpu stack as free for native functions (only for saved */
/* register count == 0). */
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 * 8, 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 * 8 + SIZEOF_VOID_P, REG_ITMP2);
-
- M_AST(REG_ITMP2, REG_SP, 2 * 4);
- M_ALD(REG_ITMP3, REG_SP, cd->stackframesize * 8);
- 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 */
- /* copy arguments into new stackframe */
+ if (m->flags & ACC_STATIC)
+ M_MOV(REG_RESULT, REG_ITMP3);
- for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) {
- t = md->paramtypes[i].type;
+ /* Copy or spill arguments to new locations. */
- if (!md->params[i].inmemory) {
- /* no integer argument registers */
- }
- else {
- /* float/double in memory can be copied like int/longs */
+ for (i = md->paramcount - 1, j = i + skipparams; i >= 0; i--, j--) {
+ if (!md->params[i].inmemory)
+ assert(0);
- s1 = md->params[i].regoff + cd->stackframesize * 8 + 4;
- s2 = nmd->params[j].regoff;
+ s1 = md->params[i].regoff + cd->stackframesize * 8 + 4;
+ s2 = nmd->params[j].regoff;
+ /* 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 */
+
+ if (m->flags & ACC_STATIC)
+ M_AST(REG_ITMP3, REG_SP, 1 * 4);
- /* put env into first argument */
+ /* put env into first argument */
- M_AST_IMM(_Jv_env, REG_SP, 0 * 4);
+ M_AST_IMM(_Jv_env, REG_SP, 0 * 4);
+ }
/* call the native function */
- M_CALL(REG_ITMP3);
+ emit_mov_imm_reg(cd, 0, REG_ITMP3);
+ dseg_adddata(cd);
+ M_ALD(REG_ITMP1, REG_ITMP3, funcdisp);
+ M_CALL(REG_ITMP1);
/* save return value */
break;
}
-#if !defined(NDEBUG)
- emit_verbosecall_exit(jd);
-#endif
-
/* remove native stackframe info */
M_MOV(REG_SP, REG_ITMP1);
- M_AADD_IMM(cd->stackframesize * 8, 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 */
break;
}
+#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, REG_SP);
/* check for exception */
/* generate patcher stubs */
- emit_patcher_stubs(jd);
+ emit_patcher_traps(jd);
}
projects / cacao.git / blobdiff