Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7596 2007-03-28 21:05:53Z twisti $
+ $Id: codegen.c 8216 2007-07-19 13:51:21Z michi $
*/
#include "vm/jit/powerpc/codegen.h"
#include "mm/memory.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/stringlocal.h"
#include "vm/vm.h"
+#include "vm/jit/abi.h"
#include "vm/jit/abi-asm.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/md.h"
#include "vm/jit/methodheader.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"
continue;
var = VAR(varindex);
+ s1 = md->params[p].regoff;
- s1 = md->params[p].regoff;
- if (IS_INT_LNG_TYPE(t)) { /* integer args */
- if (IS_2_WORD_TYPE(t))
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
- else
- s2 = rd->argintregs[s1];
- if (!md->params[p].inmemory) { /* register arguments */
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
+ if (IS_INT_LNG_TYPE(t)) {
+ if (!md->params[p].inmemory) {
+ if (!IS_INMEMORY(var->flags)) {
if (IS_2_WORD_TYPE(t))
- M_LNGMOVE(s2, var->vv.regoff);
+ M_LNGMOVE(s1, var->vv.regoff);
else
- M_INTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
+ M_INTMOVE(s1, var->vv.regoff);
+ }
+ else {
if (IS_2_WORD_TYPE(t))
- M_LST(s2, REG_SP, var->vv.regoff * 4);
+ M_LST(s1, REG_SP, var->vv.regoff);
else
- M_IST(s2, REG_SP, var->vv.regoff * 4);
+ M_IST(s1, REG_SP, var->vv.regoff);
}
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
+ }
+ else {
+ if (!IS_INMEMORY(var->flags)) {
if (IS_2_WORD_TYPE(t))
- M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
+ M_LLD(var->vv.regoff, REG_SP, cd->stackframesize * 4 + s1);
else
- M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
-
- } else { /* stack arg -> spilled */
+ M_ILD(var->vv.regoff, REG_SP, cd->stackframesize * 4 + s1);
+ }
+ else {
#if 1
- M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4);
- M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
+ M_ILD(REG_ITMP1, REG_SP, cd->stackframesize * 4 + s1);
+ M_IST(REG_ITMP1, REG_SP, var->vv.regoff);
if (IS_2_WORD_TYPE(t)) {
- M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4 +4);
- M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
+ M_ILD(REG_ITMP1, REG_SP, cd->stackframesize * 4 + s1 + 4);
+ M_IST(REG_ITMP1, REG_SP, var->vv.regoff + 4);
}
#else
/* Reuse Memory Position on Caller Stack */
- var->vv.regoff = cd->stackframesize + s1;
+ var->vv.regoff = cd->stackframesize * 4 + s1;
#endif
}
}
-
- } else { /* floating args */
- if (!md->params[p].inmemory) { /* register arguments */
- s2 = rd->argfltregs[s1];
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_FLTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
+ }
+ else {
+ if (!md->params[p].inmemory) {
+ if (!IS_INMEMORY(var->flags))
+ M_FLTMOVE(s1, var->vv.regoff);
+ else {
if (IS_2_WORD_TYPE(t))
- M_DST(s2, REG_SP, var->vv.regoff * 4);
+ M_DST(s1, REG_SP, var->vv.regoff);
else
- M_FST(s2, REG_SP, var->vv.regoff * 4);
+ M_FST(s1, REG_SP, var->vv.regoff);
}
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
+ }
+ else {
+ if (!IS_INMEMORY(var->flags)) {
if (IS_2_WORD_TYPE(t))
- M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
-
+ M_DLD(var->vv.regoff, REG_SP, cd->stackframesize * 4 + s1);
else
- M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
-
- } else { /* stack-arg -> spilled */
+ M_FLD(var->vv.regoff, REG_SP, cd->stackframesize * 4 + s1);
+ }
+ else {
#if 1
if (IS_2_WORD_TYPE(t)) {
- M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1) * 4);
- M_DST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
- var->vv.regoff = cd->stackframesize + s1;
-
- } else {
- M_FLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1) * 4);
- M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
+ M_DLD(REG_FTMP1, REG_SP, cd->stackframesize * 4 + s1);
+ M_DST(REG_FTMP1, REG_SP, var->vv.regoff);
+ }
+ else {
+ M_FLD(REG_FTMP1, REG_SP, cd->stackframesize * 4 + s1);
+ M_FST(REG_FTMP1, REG_SP, var->vv.regoff);
}
#else
/* Reuse Memory Position on Caller Stack */
- var->vv.regoff = cd->stackframesize + s1;
+ var->vv.regoff = cd->stackframesize * 4 + s1;
#endif
}
}
}
- } /* end for */
+ }
#if defined(ENABLE_THREADS)
/* call monitorenter function */
M_AADD_IMM(REG_SP, -((LA_SIZE_IN_POINTERS + ARG_CNT) * 8), REG_SP);
for (p = 0; p < INT_ARG_CNT; p++)
- M_IST(rd->argintregs[p], REG_SP, LA_SIZE + p * 8);
+ M_IST(abi_registers_integer_argument[p], REG_SP, LA_SIZE + p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DST(rd->argfltregs[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
+ M_DST(abi_registers_float_argument[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
/* ATTENTION: We multiply here with 2, because we use * 8
above for simplicity and below * 4! */
}
# endif
- p = dseg_add_functionptr(cd, LOCK_monitor_enter);
- M_ALD(REG_ITMP3, REG_PV, p);
+ disp = dseg_add_functionptr(cd, LOCK_monitor_enter);
+ M_ALD(REG_ITMP3, REG_PV, disp);
M_MTCTR(REG_ITMP3);
/* get or test the lock object */
if (m->flags & ACC_STATIC) {
- p = dseg_add_address(cd, &m->class->object.header);
- M_ALD(REG_A0, REG_PV, p);
+ disp = dseg_add_address(cd, &m->class->object.header);
+ M_ALD(REG_A0, REG_PV, disp);
}
else {
M_TST(REG_A0);
# if !defined(NDEBUG)
if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
for (p = 0; p < INT_ARG_CNT; p++)
- M_ILD(rd->argintregs[p], REG_SP, LA_SIZE + p * 8);
+ M_ILD(abi_registers_integer_argument[p], REG_SP, LA_SIZE + p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DLD(rd->argfltregs[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
+ M_DLD(abi_registers_float_argument[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
M_AADD_IMM(REG_SP, (LA_SIZE_IN_POINTERS + ARG_CNT) * 8, REG_SP);
}
disp = dseg_add_unique_address(cd, cr);
- codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
+ patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
cr, disp);
}
else
case ICMD_COPY:
case ICMD_MOVE:
- emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
+ emit_copy(jd, iptr);
break;
case ICMD_ASTORE:
if (!(iptr->flags.bits & INS_FLAG_RETADDR))
- emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
+ emit_copy(jd, iptr);
break;
case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
- bte = iptr->sx.s23.s3.bte;
- md = bte->md;
+ s1 = emit_load_s1(jd, iptr, REG_A0_A1_PACKED);
+ s2 = emit_load_s2(jd, iptr, REG_A2_A3_PACKED);
- s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
+ /* XXX TODO: only do this if arithmetic check is really done! */
M_OR_TST(GET_HIGH_REG(s2), GET_LOW_REG(s2), REG_ITMP3);
/* XXX could be optimized */
emit_arithmetic_check(cd, iptr, REG_ITMP3);
+ bte = iptr->sx.s23.s3.bte;
disp = dseg_add_functionptr(cd, bte->fp);
M_ALD(REG_ITMP3, REG_PV, disp);
M_MTCTR(REG_ITMP3);
- s3 = PACK_REGS(rd->argintregs[GET_LOW_REG(md->params[1].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[1].regoff)]);
- M_LNGMOVE(s2, s3);
-
- s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
- s3 = PACK_REGS(rd->argintregs[GET_LOW_REG(md->params[0].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[0].regoff)]);
- M_LNGMOVE(s1, s3);
+ M_LNGMOVE(s1, REG_A0_A1_PACKED);
+ M_LNGMOVE(s2, REG_A2_A3_PACKED);
M_JSR;
fieldtype = uf->fieldref->parseddesc.fd->type;
disp = dseg_add_unique_address(cd, uf);
- codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
+ patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
}
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
disp = dseg_add_address(cd, &(fi->value));
if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
- codegen_addpatchref(cd, PATCHER_initialize_class,
+ patcher_add_patch_ref(jd, PATCHER_initialize_class,
fi->class, disp);
}
fieldtype = uf->fieldref->parseddesc.fd->type;
disp = dseg_add_unique_address(cd, uf);
- codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
+ patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
}
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
disp = dseg_add_address(cd, &(fi->value));
if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
- codegen_addpatchref(cd, PATCHER_initialize_class,
+ patcher_add_patch_ref(jd, PATCHER_initialize_class,
fi->class, disp);
}
fieldtype = uf->fieldref->parseddesc.fd->type;
disp = 0;
- codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
+ patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
}
else {
fi = iptr->sx.s23.s3.fmiref->p.field;
s2 = emit_load_s2(jd, iptr, REG_FTMP2);
if (INSTRUCTION_IS_UNRESOLVED(iptr))
- codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
+ patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
/* implicit null-pointer check */
switch (fieldtype) {
if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
unresolved_class *uc = iptr->sx.s23.s2.uc;
- codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
+ patcher_add_patch_ref(jd, PATCHER_resolve_class, uc, 0);
}
#endif /* ENABLE_VERIFIER */
if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
unresolved_class *uc = iptr->sx.s23.s2.uc;
- codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
+ patcher_add_patch_ref(jd, PATCHER_resolve_class, uc, 0);
}
#endif /* ENABLE_VERIFIER */
goto nowperformreturn;
for (s3 = s3 - 1; s3 >= 0; s3--) {
var = VAR(iptr->sx.s23.s2.args[s3]);
+ d = md->params[s3].regoff;
/* Already Preallocated? */
if (var->flags & PREALLOC)
if (IS_INT_LNG_TYPE(var->type)) {
if (!md->params[s3].inmemory) {
if (IS_2_WORD_TYPE(var->type)) {
- s1 = PACK_REGS(
- rd->argintregs[GET_LOW_REG(md->params[s3].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[s3].regoff)]);
- d = emit_load(jd, iptr, var, s1);
- M_LNGMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_LNGMOVE(s1, d);
}
else {
- s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_INTMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_INTMOVE(s1, d);
}
}
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);
+ s1 = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
+ M_LST(s1, REG_SP, d);
}
else {
- d = emit_load(jd, iptr, var, REG_ITMP1);
- M_IST(d, REG_SP, md->params[s3].regoff * 4);
+ s1 = emit_load(jd, iptr, var, REG_ITMP1);
+ M_IST(s1, REG_SP, d);
}
}
}
else {
if (!md->params[s3].inmemory) {
- s1 = rd->argfltregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_FLTMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_FLTMOVE(s1, d);
}
else {
- d = emit_load(jd, iptr, var, REG_FTMP1);
+ s1 = 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(s1, REG_SP, d);
else
- M_FST(d, REG_SP, md->params[s3].regoff * 4);
+ M_FST(s1, REG_SP, d);
}
}
}
if (lm == NULL) {
disp = dseg_add_unique_address(cd, um);
- codegen_addpatchref(cd, PATCHER_invokestatic_special,
+ patcher_add_patch_ref(jd, PATCHER_invokestatic_special,
um, disp);
}
else
case ICMD_INVOKEVIRTUAL:
if (lm == NULL) {
- codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
+ patcher_add_patch_ref(jd, PATCHER_invokevirtual, um, 0);
s1 = 0;
}
case ICMD_INVOKEINTERFACE:
if (lm == NULL) {
- codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
+ patcher_add_patch_ref(jd, PATCHER_invokeinterface, um, 0);
s1 = 0;
s2 = 0;
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->diffvall));
- */
if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
/* object type cast-check */
superindex = super->index;
}
-#if defined(ENABLE_THREADS)
- codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+ if ((super == NULL) || !(super->flags & ACC_INTERFACE))
+ CODEGEN_CRITICAL_SECTION_NEW;
s1 = emit_load_s1(jd, iptr, REG_ITMP1);
disp = dseg_add_unique_s4(cd, 0); /* super->flags */
- codegen_addpatchref(cd,
+ patcher_add_patch_ref(jd,
PATCHER_resolve_classref_to_flags,
iptr->sx.s23.s3.c.ref,
disp);
if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
if (super == NULL) {
- codegen_addpatchref(cd,
+ patcher_add_patch_ref(jd,
PATCHER_checkcast_interface,
iptr->sx.s23.s3.c.ref,
0);
disp = dseg_add_unique_address(cd, NULL);
- codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl,
+ patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_vftbl,
iptr->sx.s23.s3.c.ref,
disp);
}
}
M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
-#if defined(ENABLE_THREADS)
- codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+ CODEGEN_CRITICAL_SECTION_START;
+
M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, baseval));
M_ALD(REG_ITMP2, REG_PV, disp);
if (s1 != REG_ITMP1) {
M_ILD(REG_ITMP1, REG_ITMP2, OFFSET(vftbl_t, baseval));
M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
-#if defined(ENABLE_THREADS)
- codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+ CODEGEN_CRITICAL_SECTION_END;
+
M_ISUB(REG_ITMP3, REG_ITMP1, REG_ITMP3);
}
else {
M_ISUB(REG_ITMP3, REG_ITMP2, REG_ITMP3);
M_ALD(REG_ITMP2, REG_PV, disp);
M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
-#if defined(ENABLE_THREADS)
- codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+ CODEGEN_CRITICAL_SECTION_END;
}
M_CMPU(REG_ITMP3, REG_ITMP2);
emit_classcast_check(cd, iptr, BRANCH_GT, REG_ITMP3, s1);
if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
disp = dseg_add_unique_address(cd, NULL);
- codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
+ patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
iptr->sx.s23.s3.c.ref,
disp);
}
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;
superindex = super->index;
}
-#if defined(ENABLE_THREADS)
- codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+ 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);
disp = dseg_add_unique_s4(cd, 0); /* super->flags */
- codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags,
+ patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_flags,
iptr->sx.s23.s3.c.ref, disp);
M_ILD(REG_ITMP3, REG_PV, disp);
if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
if (super == NULL) {
- codegen_addpatchref(cd,
+ patcher_add_patch_ref(jd,
PATCHER_instanceof_interface,
iptr->sx.s23.s3.c.ref, 0);
}
disp = dseg_add_unique_address(cd, NULL);
- codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl,
+ patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_vftbl,
iptr->sx.s23.s3.c.ref,
disp);
}
M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
M_ALD(REG_ITMP2, REG_PV, disp);
-#if defined(ENABLE_THREADS)
- codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+ CODEGEN_CRITICAL_SECTION_START;
+
M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl_t, baseval));
M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, baseval));
M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
-#if defined(ENABLE_THREADS)
- codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+ CODEGEN_CRITICAL_SECTION_END;
+
M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1);
M_CMPU(REG_ITMP1, REG_ITMP2);
M_CLR(d);
if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
disp = dseg_add_unique_address(cd, NULL);
- codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
+ patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
iptr->sx.s23.s3.c.ref, disp);
}
else
dseg_createlinenumbertable(cd);
- /* generate stubs */
+ /* generate traps */
- emit_patcher_stubs(jd);
- REPLACEMENT_EMIT_STUBS(jd);
+ emit_patcher_traps(jd);
/* everything's ok */
}
-/* createcompilerstub **********************************************************
+/* codegen_emit_stub_compiler **************************************************
- Creates a stub routine which calls the compiler.
+ Emits a stub routine which calls the compiler.
*******************************************************************************/
-#define COMPILERSTUB_DATASIZE 3 * SIZEOF_VOID_P
-#define COMPILERSTUB_CODESIZE 4 * 4
-
-#define COMPILERSTUB_SIZE COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE
-
-
-u1 *createcompilerstub(methodinfo *m)
+void codegen_emit_stub_compiler(jitdata *jd)
{
- u1 *s; /* memory to hold the stub */
- ptrint *d;
+ methodinfo *m;
codegendata *cd;
- s4 dumpsize;
-
- s = CNEW(u1, COMPILERSTUB_SIZE);
- /* set data pointer and code pointer */
-
- d = (ptrint *) s;
- s = s + COMPILERSTUB_DATASIZE;
-
- /* mark start of dump memory area */
-
- dumpsize = dump_size();
-
- cd = DNEW(codegendata);
- cd->mcodeptr = s;
+ /* get required compiler data */
- /* The codeinfo pointer is actually a pointer to the
- methodinfo. This fakes a codeinfo structure. */
+ m = jd->m;
+ cd = jd->cd;
- d[0] = (ptrint) asm_call_jit_compiler;
- d[1] = (ptrint) m;
- d[2] = (ptrint) &d[1]; /* fake code->m */
+ /* code for the stub */
M_ALD_INTERN(REG_ITMP1, REG_PV, -2 * SIZEOF_VOID_P);
M_ALD_INTERN(REG_PV, REG_PV, -3 * SIZEOF_VOID_P);
M_MTCTR(REG_PV);
M_RTS;
-
- md_cacheflush((u1 *) d, COMPILERSTUB_SIZE);
-
-#if defined(ENABLE_STATISTICS)
- if (opt_stat)
- count_cstub_len += COMPILERSTUB_SIZE;
-#endif
-
- /* release dump area */
-
- dump_release(dumpsize);
-
- return s;
}
-/* createnativestub ************************************************************
+/* codegen_emit_stub_native ****************************************************
- Creates a stub routine which calls a native method.
+ Emits a stub routine which calls a native method.
*******************************************************************************/
-u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
+void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- methoddesc *md;
- s4 nativeparams;
- s4 i, j; /* count variables */
- s4 t;
- s4 s1, s2, disp;
- s4 funcdisp;
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ methoddesc *md;
+ s4 nativeparams;
+ s4 i, j; /* count variables */
+ s4 t;
+ s4 s1, s2, disp;
+ s4 funcdisp;
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* set some variables */
#if !defined(WITH_STATIC_CLASSPATH)
if (f == NULL)
- codegen_addpatchref(cd, PATCHER_resolve_native_function, m, funcdisp);
+ patcher_add_patch_ref(jd, PATCHER_resolve_native_function, m, funcdisp);
#endif
/* emit trace code */
/* save integer and float argument registers */
- j = 0;
-
for (i = 0; i < md->paramcount; i++) {
- t = md->paramtypes[i].type;
-
- if (IS_INT_LNG_TYPE(t)) {
- if (!md->params[i].inmemory) {
- s1 = md->params[i].regoff;
- if (IS_2_WORD_TYPE(t)) {
- M_IST(rd->argintregs[GET_HIGH_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- j++;
- M_IST(rd->argintregs[GET_LOW_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- } else {
- M_IST(rd->argintregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- }
- j++;
- }
- }
- }
+ if (!md->params[i].inmemory) {
+ s1 = md->params[i].regoff;
- for (i = 0; i < md->paramcount; i++) {
- if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
- if (!md->params[i].inmemory) {
- s1 = md->params[i].regoff;
- M_DST(rd->argfltregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 8);
- j++;
+ switch (md->paramtypes[i].type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_IST(s1, REG_SP, LA_SIZE + 4*4 + i * 8);
+ break;
+ case TYPE_LNG:
+ M_LST(s1, REG_SP, LA_SIZE + 4*4 + i * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DST(s1, REG_SP, LA_SIZE + 4*4 + i * 8);
+ break;
}
}
}
/* restore integer and float argument registers */
- j = 0;
-
for (i = 0; i < md->paramcount; i++) {
- t = md->paramtypes[i].type;
-
- if (IS_INT_LNG_TYPE(t)) {
- if (!md->params[i].inmemory) {
- s1 = md->params[i].regoff;
+ if (!md->params[i].inmemory) {
+ s1 = md->params[i].regoff;
- if (IS_2_WORD_TYPE(t)) {
- M_ILD(rd->argintregs[GET_HIGH_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- j++;
- M_ILD(rd->argintregs[GET_LOW_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- } else {
- M_ILD(rd->argintregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- }
- j++;
+ switch (md->paramtypes[i].type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_ILD(s1, REG_SP, LA_SIZE + 4*4 + i * 8);
+ break;
+ case TYPE_LNG:
+ M_LLD(s1, REG_SP, LA_SIZE + 4*4 + i * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DLD(s1, REG_SP, LA_SIZE + 4*4 + i * 8);
+ break;
}
}
}
- for (i = 0; i < md->paramcount; i++) {
- if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
- if (!md->params[i].inmemory) {
- s1 = md->params[i].regoff;
- M_DLD(rd->argfltregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 8);
- j++;
- }
- }
- }
-
/* copy or spill arguments to new locations */
for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) {
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[i].inmemory) {
- if (IS_2_WORD_TYPE(t))
- s1 = PACK_REGS(
- rd->argintregs[GET_LOW_REG(md->params[i].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]);
- else
- s1 = rd->argintregs[md->params[i].regoff];
+ s1 = md->params[i].regoff;
+ s2 = nmd->params[j].regoff;
if (!nmd->params[j].inmemory) {
- if (IS_2_WORD_TYPE(t)) {
- s2 = PACK_REGS(
- rd->argintregs[GET_LOW_REG(nmd->params[j].regoff)],
- rd->argintregs[GET_HIGH_REG(nmd->params[j].regoff)]);
+ if (IS_2_WORD_TYPE(t))
M_LNGMOVE(s1, s2);
- } else {
- s2 = rd->argintregs[nmd->params[j].regoff];
+ else
M_INTMOVE(s1, s2);
- }
-
- } else {
- s2 = nmd->params[j].regoff;
+ }
+ else {
if (IS_2_WORD_TYPE(t))
- M_LST(s1, REG_SP, s2 * 4);
+ M_LST(s1, REG_SP, s2);
else
- M_IST(s1, REG_SP, s2 * 4);
+ M_IST(s1, REG_SP, s2);
}
-
- } else {
- s1 = md->params[i].regoff + cd->stackframesize;
+ }
+ else {
+ s1 = md->params[i].regoff + cd->stackframesize * 4;
s2 = nmd->params[j].regoff;
- M_ILD(REG_ITMP1, REG_SP, s1 * 4);
+ M_ILD(REG_ITMP1, REG_SP, s1);
if (IS_2_WORD_TYPE(t))
- M_ILD(REG_ITMP2, REG_SP, s1 * 4 + 4);
+ M_ILD(REG_ITMP2, REG_SP, s1 + 4);
- M_IST(REG_ITMP1, REG_SP, s2 * 4);
+ M_IST(REG_ITMP1, REG_SP, s2);
if (IS_2_WORD_TYPE(t))
- M_IST(REG_ITMP2, REG_SP, s2 * 4 + 4);
+ M_IST(REG_ITMP2, REG_SP, s2 + 4);
}
-
- } else {
+ }
+ else {
/* We only copy spilled float arguments, as the float
argument registers keep unchanged. */
if (md->params[i].inmemory) {
- s1 = md->params[i].regoff + cd->stackframesize;
+ s1 = md->params[i].regoff + cd->stackframesize * 4;
s2 = nmd->params[j].regoff;
if (IS_2_WORD_TYPE(t)) {
- M_DLD(REG_FTMP1, REG_SP, s1 * 4);
- M_DST(REG_FTMP1, REG_SP, s2 * 4);
-
- } else {
- M_FLD(REG_FTMP1, REG_SP, s1 * 4);
- M_FST(REG_FTMP1, REG_SP, s2 * 4);
+ M_DLD(REG_FTMP1, REG_SP, s1);
+ M_DST(REG_FTMP1, REG_SP, s2);
+ }
+ else {
+ M_FLD(REG_FTMP1, REG_SP, s1);
+ M_FST(REG_FTMP1, REG_SP, s2);
}
}
}
/* save return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_IST(REG_RESULT2, REG_SP, LA_SIZE + 2 * 4);
- M_IST(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
- }
- else {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_DST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- else
- M_FST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- }
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_IST(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_LNG:
+ M_LST(REG_RESULT_PACKED, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_FLT:
+ M_FST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_DBL:
+ M_DST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_VOID:
+ break;
}
/* remove native stackframe info */
/* restore return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_ILD(REG_RESULT2, REG_SP, LA_SIZE + 2 * 4);
- M_ILD(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
- }
- else {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_DLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- else
- M_FLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- }
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_ILD(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_LNG:
+ M_LLD(REG_RESULT_PACKED, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_FLT:
+ M_FLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_DBL:
+ M_DLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_VOID:
+ break;
}
M_ALD(REG_ITMP2_XPC, REG_SP, cd->stackframesize * 4 + LA_LR_OFFSET);
M_MTCTR(REG_ITMP3);
M_RTS;
- /* generate patcher stubs */
-
- emit_patcher_stubs(jd);
-
- codegen_finish(jd);
+ /* generate patcher traps */
- return code->entrypoint;
+ emit_patcher_traps(jd);
}
projects / cacao.git / blobdiff