* src/vm/jit/allocator/lsra.c,
src/vm/jit/allocator/simplereg.c,
src/vm/jit/alpha/codegen.c,
src/vm/jit/alpha/emit.c,
src/vm/jit/arm/codegen.c,
src/vm/jit/arm/md-abi.c,
src/vm/jit/i386/codegen.c,
src/vm/jit/i386/emit.c,
src/vm/jit/inline/inline.c,
src/vm/jit/jit.c,
src/vm/jit/m68k/codegen.c,
src/vm/jit/mips/codegen.c,
src/vm/jit/mips/emit.c,
src/vm/jit/optimizing/lsra.c,
src/vm/jit/optimizing/ssa.c,
src/vm/jit/parse.c,
src/vm/jit/parse.h,
src/vm/jit/powerpc/codegen.c,
src/vm/jit/powerpc/darwin/md-abi.c,
src/vm/jit/powerpc/linux/md-abi.c,
src/vm/jit/powerpc64/codegen.c,
src/vm/jit/powerpc64/linux/md-abi.c,
src/vm/jit/replace.c,
src/vm/jit/s390/codegen.c,
src/vm/jit/s390/emit.c,
src/vm/jit/s390/md-abi.c,
src/vm/jit/show.c,
src/vm/jit/sparc64/codegen.c,
src/vm/jit/sparc64/emit.c,
src/vm/jit/stack.c,
src/vm/jit/x86_64/codegen.c,
src/vm/jit/x86_64/emit.c,
src/vm/jit/x86_64/md-abi.c: Replaced jd->isleafmethod with
code_is_leafmethod.
34 files changed:
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Christian Ullrich
- Christian Thalinger
- Edwin Steiner
-
int_reg->nregdesc = nregdescint;
flt_reg->nregdesc = nregdescfloat;
int_reg->nregdesc = nregdescint;
flt_reg->nregdesc = nregdescfloat;
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
/* Temp and Argumentregister can be used as saved registers */
int_reg->sav_top = INT_ARG_CNT + INT_TMP_CNT + INT_SAV_CNT;
/* Temp and Argumentregister can be used as saved registers */
int_reg->sav_top = INT_ARG_CNT + INT_TMP_CNT + INT_SAV_CNT;
lsra_expire_old_intervalls(jd, lt, reg);
reg_index = -1;
temp = false;
lsra_expire_old_intervalls(jd, lt, reg);
reg_index = -1;
temp = false;
- if (lt->savedvar || jd->isleafmethod) {
+ if (lt->savedvar || code_is_leafmethod(code)) {
/* use Saved Reg (in case of leafmethod all regs are saved regs) */
if (reg->sav_top > regsneeded) {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/* use Saved Reg (in case of leafmethod all regs are saved regs) */
if (reg->sav_top > regsneeded) {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
if (active[i]->i_end > lt->i_start) break;
/* make active[i]->reg available again */
if (active[i]->i_end > lt->i_start) break;
/* make active[i]->reg available again */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
/* leafmethod -> don't care about type -> put all again into */
/* reg->sav_reg */
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/* leafmethod -> don't care about type -> put all again into */
/* reg->sav_reg */
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
void spill_at_intervall(jitdata *jd, struct lifetime *lt )
{
void spill_at_intervall(jitdata *jd, struct lifetime *lt )
{
- if (lt->savedvar || jd->isleafmethod) {
+ if (lt->savedvar || code_is_leafmethod(code)) {
_spill_at_intervall(lt, jd->ls->active_sav, &(jd->ls->active_sav_top));
} else {
_spill_at_intervall(lt, jd->ls->active_tmp, &(jd->ls->active_tmp_top));
_spill_at_intervall(lt, jd->ls->active_sav, &(jd->ls->active_sav_top));
} else {
_spill_at_intervall(lt, jd->ls->active_tmp, &(jd->ls->active_tmp_top));
static void simplereg_allocate_interfaces(jitdata *jd)
{
methodinfo *m;
static void simplereg_allocate_interfaces(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
registerdata *rd;
codegendata *cd;
registerdata *rd;
/* get required compiler data */
/* get required compiler data */
- m = jd->m;
- cd = jd->cd;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ cd = jd->cd;
+ rd = jd->rd;
/* rd->memuse was already set in stack.c to allocate stack space
for passing arguments to called methods. */
/* rd->memuse was already set in stack.c to allocate stack space
for passing arguments to called methods. */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
/* Reserve argument register, which will be used for Locals acting */
/* as Parameters */
if (rd->argintreguse < m->parseddesc->argintreguse)
/* Reserve argument register, which will be used for Locals acting */
/* as Parameters */
if (rd->argintreguse < m->parseddesc->argintreguse)
if (!saved) {
#if defined(HAS_ADDRESS_REGISTER_FILE)
if (IS_ADR_TYPE(t)) {
if (!saved) {
#if defined(HAS_ADDRESS_REGISTER_FILE)
if (IS_ADR_TYPE(t)) {
- if (!jd->isleafmethod && AVAIL_ARG_ADR) {
+ if (!code_is_leafmethod(code) && AVAIL_ARG_ADR) {
flags |= ARGREG;
TAKE_ARG_ADR(regoff);
}
flags |= ARGREG;
TAKE_ARG_ADR(regoff);
}
static void simplereg_allocate_locals(jitdata *jd)
{
static void simplereg_allocate_locals(jitdata *jd)
{
codegendata *cd;
registerdata *rd;
codegendata *cd;
registerdata *rd;
/* get required compiler data */
/* get required compiler data */
- cd = jd->cd;
- rd = jd->rd;
+ code = jd->code;
+ cd = jd->cd;
+ rd = jd->rd;
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
simplereg_allocate_locals_leafmethod(jd);
return;
}
simplereg_allocate_locals_leafmethod(jd);
return;
}
s4 i, p, t, l;
s4 savedregs_num;
s4 i, p, t, l;
s4 savedregs_num;
- savedregs_num = (jd->isleafmethod) ? 0 : 1; /* space to save the RA */
+ savedregs_num = code_is_leafmethod(code) ? 0 : 1; /* space to save the RA */
/* space to save used callee saved registers */
/* space to save used callee saved registers */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
/* save return address and used callee saved registers */
p = cd->stackframesize;
/* save return address and used callee saved registers */
p = cd->stackframesize;
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
p--; M_AST(REG_RA, REG_SP, p * 8);
}
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
p--; M_AST(REG_RA, REG_SP, p * 8);
}
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
/* restore return address */
/* restore return address */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
p--; M_LLD(REG_RA, REG_SP, p * 8);
}
p--; M_LLD(REG_RA, REG_SP, p * 8);
}
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
registerdata *rd;
methoddesc *md;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
/* get required compiler data */
- m = jd->m;
- cd = jd->cd;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ cd = jd->cd;
+ rd = jd->rd;
/* save all argument and temporary registers for leaf methods */
/* save all argument and temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
j = 1 + md->paramcount;
for (i = 0; i < INT_ARG_CNT; i++, j++)
j = 1 + md->paramcount;
for (i = 0; i < INT_ARG_CNT; i++, j++)
/* restore all argument and temporary registers for leaf methods */
/* restore all argument and temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
j = 1 + md->paramcount;
for (i = 0; i < INT_ARG_CNT; i++, j++)
j = 1 + md->paramcount;
for (i = 0; i < INT_ARG_CNT; i++, j++)
/* space to save used callee saved registers */
/* space to save used callee saved registers */
- savedregs_num = (jd->isleafmethod) ? 0 : 1; /* space to save the LR */
+ savedregs_num = code_is_leafmethod(code) ? 0 : 1; /* space to save the LR */
+
savedregs_num += (INT_SAV_CNT - rd->savintreguse);
/*savedregs_num += (FLT_SAV_CNT - rd->savfltreguse);*/
assert((FLT_SAV_CNT - rd->savfltreguse) == 0);
savedregs_num += (INT_SAV_CNT - rd->savintreguse);
/*savedregs_num += (FLT_SAV_CNT - rd->savfltreguse);*/
assert((FLT_SAV_CNT - rd->savfltreguse) == 0);
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
(void) dseg_addlinenumbertablesize(cd);
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
(void) dseg_addlinenumbertablesize(cd);
+ if (!code_is_leafmethod(code))
savedregs_bitmask = (1<<REG_LR);
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--)
savedregs_bitmask = (1<<REG_LR);
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--)
/* restore callee saved registers + do return */
if (savedregs_bitmask) {
/* restore callee saved registers + do return */
if (savedregs_bitmask) {
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
savedregs_bitmask &= ~(1<<REG_LR);
savedregs_bitmask |= (1<<REG_PC);
}
savedregs_bitmask &= ~(1<<REG_LR);
savedregs_bitmask |= (1<<REG_PC);
}
/* if LR was not on stack, we need to return manually */
/* if LR was not on stack, we need to return manually */
+ if (code_is_leafmethod(code))
M_MOV(REG_PC, REG_LR);
break;
M_MOV(REG_PC, REG_LR);
break;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
their argument register -> so leafmethods with paramcount > 0
could already use R0 == a00! */
their argument register -> so leafmethods with paramcount > 0
could already use R0 == a00! */
- if (!jd->isleafmethod || (md->paramcount == 0)) {
+ if (!code_is_leafmethod(code) || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
/* Keep stack of non-leaf functions 16-byte aligned. */
/* 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 */
}
ALIGN_ODD(cd->stackframesize); /* XXX this is wrong, +4 is missing */
}
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1); /* IsLeaf */
+ else
+ (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 */
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
registerdata *rd;
methoddesc *md;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
/* get required compiler data */
- m = jd->m;
- cd = jd->cd;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ cd = jd->cd;
+ rd = jd->rd;
/* save temporary registers for leaf methods */
/* save temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_TMP_CNT; i++)
M_IST(rd->tmpintregs[i], REG_SP, (2 + i) * 8);
}
for (i = 0; i < INT_TMP_CNT; i++)
M_IST(rd->tmpintregs[i], REG_SP, (2 + i) * 8);
}
/* restore temporary registers for leaf methods */
/* restore temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_TMP_CNT; i++)
M_ILD(rd->tmpintregs[i], REG_SP, (2 + i) * 8);
}
for (i = 0; i < INT_TMP_CNT; i++)
M_ILD(rd->tmpintregs[i], REG_SP, (2 + i) * 8);
}
static void inline_post_process(jitdata *jd)
{
static void inline_post_process(jitdata *jd)
{
basicblock *bptr;
instruction *iptr;
instruction *iend;
basicblock *bptr;
instruction *iptr;
instruction *iend;
methoddesc *md;
builtintable_entry *bte;
methoddesc *md;
builtintable_entry *bte;
+ /* Get required compiler data. */
+
+ code = jd->code;
+
/* reset the SAVEDVAR flag of all variables */
for (i=0; i<jd->vartop; ++i)
/* reset the SAVEDVAR flag of all variables */
for (i=0; i<jd->vartop; ++i)
POSTPROCESS_SRCOP(s1);
case DF_0_TO_0:
if (icmdt->flags & ICMDTABLE_CALLS) {
POSTPROCESS_SRCOP(s1);
case DF_0_TO_0:
if (icmdt->flags & ICMDTABLE_CALLS) {
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
POSTPROCESS_SRCOP(s1);
case DF_0_TO_1:
if (icmdt->flags & ICMDTABLE_CALLS) {
POSTPROCESS_SRCOP(s1);
case DF_0_TO_1:
if (icmdt->flags & ICMDTABLE_CALLS) {
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
MARK_ALL_SAVED;
}
case DF_COPY:
MARK_ALL_SAVED;
}
case DF_COPY:
POSTPROCESS_SRC(iptr->sx.s23.s2.args[i]);
}
if (icmdt->flags & ICMDTABLE_CALLS) {
POSTPROCESS_SRC(iptr->sx.s23.s2.args[i]);
}
if (icmdt->flags & ICMDTABLE_CALLS) {
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
MARK_ALL_SAVED;
}
POSTPROCESS_DSTOP(dst);
MARK_ALL_SAVED;
}
POSTPROCESS_DSTOP(dst);
case DF_INVOKE:
INSTRUCTION_GET_METHODDESC(iptr, md);
post_process_call:
case DF_INVOKE:
INSTRUCTION_GET_METHODDESC(iptr, md);
post_process_call:
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
for (i=0; i<md->paramcount; ++i) {
POSTPROCESS_SRC(iptr->sx.s23.s2.args[i]);
}
for (i=0; i<md->paramcount; ++i) {
POSTPROCESS_SRC(iptr->sx.s23.s2.args[i]);
}
jitdata *jit_jitdata_new(methodinfo *m)
{
jitdata *jit_jitdata_new(methodinfo *m)
{
+ jitdata *jd;
+ codeinfo *code;
/* allocate jitdata structure and fill it */
/* allocate jitdata structure and fill it */
/* Allocate codeinfo memory from the heap as we need to keep them. */
/* Allocate codeinfo memory from the heap as we need to keep them. */
- jd->code = code_codeinfo_new(m);
+ code = code_codeinfo_new(m);
+
+ /* Set codeinfo flags. */
+
+#if defined(ENABLE_THREADS)
+ if (checksync && (m->flags & ACC_SYNCHRONIZED))
+ code_flag_synchronized(code);
+
+ if (checksync && (m->flags & ACC_SYNCHRONIZED))
+ code_unflag_leafmethod(code);
+#endif
+ else
+ code_flag_leafmethod(code);
/* initialize variables */
/* initialize variables */
jd->flags = 0;
jd->exceptiontable = NULL;
jd->exceptiontablelength = 0;
jd->flags = 0;
jd->exceptiontable = NULL;
jd->exceptiontablelength = 0;
jd->returnblock = NULL;
jd->maxlocals = m->maxlocals;
jd->returnblock = NULL;
jd->maxlocals = m->maxlocals;
-#if defined(ENABLE_THREADS)
- if (checksync && (m->flags & ACC_SYNCHRONIZED))
- jd->isleafmethod = false;
- else
-#endif
- jd->isleafmethod = true;
-
#endif
u4 flags; /* contains JIT compiler flags */
#endif
u4 flags; /* contains JIT compiler flags */
- bool isleafmethod; /* true, if no subroutines are called */
instruction *instructions; /* ICMDs, valid between parse and stack */
basicblock *basicblocks; /* start of basic block list */
instruction *instructions; /* ICMDs, valid between parse and stack */
basicblock *basicblocks; /* start of basic block list */
else
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
else
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
/* XXX we use the IntSave a split field for the adr now */
(void) dseg_add_unique_s4(cd, (ADR_SAV_CNT - rd->savadrreguse) << 16 | (INT_SAV_CNT - rd->savintreguse)); /* IntSave */
/* XXX we use the IntSave a split field for the adr now */
(void) dseg_add_unique_s4(cd, (ADR_SAV_CNT - rd->savadrreguse) << 16 | (INT_SAV_CNT - rd->savintreguse)); /* IntSave */
/* restore return address */
#if 0
/* restore return address */
#if 0
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
/* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
may have a displacement overflow. */
/* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
may have a displacement overflow. */
s4 i, p, t, l;
s4 savedregs_num;
s4 i, p, t, l;
s4 savedregs_num;
- savedregs_num = (jd->isleafmethod) ? 0 : 1; /* space to save the RA */
+ savedregs_num = code_is_leafmethod(code) ? 0 : 1; /* space to save the RA */
/* space to save used callee saved registers */
/* space to save used callee saved registers */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
dseg_addlinenumbertablesize(cd);
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
dseg_addlinenumbertablesize(cd);
/* save return address and used callee saved registers */
p = cd->stackframesize;
/* save return address and used callee saved registers */
p = cd->stackframesize;
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
p--; M_AST(REG_RA, REG_SP, p * 8);
}
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
p--; M_AST(REG_RA, REG_SP, p * 8);
}
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
/* restore return address */
/* restore return address */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
p--; M_ALD(REG_RA, REG_SP, p * 8);
}
p--; M_ALD(REG_RA, REG_SP, p * 8);
}
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
registerdata *rd;
methoddesc *md;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
/* get required compiler data */
- m = jd->m;
- cd = jd->cd;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ cd = jd->cd;
+ rd = jd->rd;
/* save temporary registers for leaf methods */
/* save temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_TMP_CNT; i++)
M_AST(rd->tmpintregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + i) * 8);
for (i = 0; i < INT_TMP_CNT; i++)
M_AST(rd->tmpintregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + i) * 8);
/* restore temporary registers for leaf methods */
/* restore temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_TMP_CNT; i++)
M_ALD(rd->tmpintregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + i) * 8);
for (i = 0; i < INT_TMP_CNT; i++)
M_ALD(rd->tmpintregs[i], REG_SP, PA_SIZE + (2 + ARG_CNT + i) * 8);
/* src/vm/jit/optimizing/lsra.inc - linear scan register allocator
/* src/vm/jit/optimizing/lsra.inc - linear scan register allocator
- Copyright (C) 2005, 2006 R. Grafl, A. Krall, C. Kruegel, C. Oates,
+ Copyright (C) 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
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
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
- Contact: cacao@complang.tuwien.ac.at
-
- Authors: Christian Ullrich
#include "config.h"
#include <stdio.h>
#include "config.h"
#include <stdio.h>
#if defined(LSRA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",m->class->name->text, m->name->text);
#if defined(LSRA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",m->class->name->text, m->name->text);
+ if (code_is_leafmethod(code))
printf("**Leafmethod**");
printf("\n");
}
printf("**Leafmethod**");
printf("\n");
}
int_reg->nregdesc = nregdescint;
flt_reg->nregdesc = nregdescfloat;
int_reg->nregdesc = nregdescint;
flt_reg->nregdesc = nregdescfloat;
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
/* Temp and Argumentregister can be used as saved registers */
int_reg->sav_top = INT_ARG_CNT + INT_TMP_CNT + INT_SAV_CNT;
/* Temp and Argumentregister can be used as saved registers */
int_reg->sav_top = INT_ARG_CNT + INT_TMP_CNT + INT_SAV_CNT;
#ifdef LSRA_SAVEDVAR
lt->savedvar = SAVEDVAR;
#endif
#ifdef LSRA_SAVEDVAR
lt->savedvar = SAVEDVAR;
#endif
- if (lt->savedvar || jd->isleafmethod) {
+ if (lt->savedvar || code_is_leafmethod(code)) {
/* use Saved Reg (in case of leafmethod all regs are saved regs) */
if (reg->sav_top > regsneeded) {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/* use Saved Reg (in case of leafmethod all regs are saved regs) */
if (reg->sav_top > regsneeded) {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
if (active[i]->i_end > lt->i_start) break;
/* make active[i]->reg available again */
if (active[i]->i_end > lt->i_start) break;
/* make active[i]->reg available again */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
/* leafmethod -> don't care about type -> put all again into */
/* reg->sav_reg */
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/* leafmethod -> don't care about type -> put all again into */
/* reg->sav_reg */
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
- if (lt->savedvar || jd->isleafmethod) {
+ if (lt->savedvar || code_is_leafmethod(code)) {
_spill_at_intervall(lt, ls->active_sav, &(ls->active_sav_top));
} else {
_spill_at_intervall(lt, ls->active_tmp, &(ls->active_tmp_top));
_spill_at_intervall(lt, ls->active_sav, &(ls->active_sav_top));
} else {
_spill_at_intervall(lt, ls->active_tmp, &(ls->active_tmp_top));
/* src/vm/jit/optimizing/ssa.c - static single-assignment form
/* src/vm/jit/optimizing/ssa.c - static single-assignment form
- Copyright (C) 2005, 2006 R. Grafl, A. Krall, C. Kruegel, C. Oates,
+ Copyright (C) 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
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
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
- Contact: cacao@complang.tuwien.ac.at
- Authors: Christian Ullrich
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
# if defined(SSA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",m->class->name->text, m->name->text);
# if defined(SSA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",m->class->name->text, m->name->text);
+ if (code_is_leafmethod(code))
printf("**Leafmethod**");
printf("\n");
}
printf("**Leafmethod**");
printf("\n");
}
# if defined(SSA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",jd->m->class->name->text, jd->m->name->text);
# if defined(SSA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",jd->m->class->name->text, jd->m->name->text);
+ if (code_is_leafmethod(code))
printf("**Leafmethod**");
printf("\n");
}
printf("**Leafmethod**");
printf("\n");
}
bool parse(jitdata *jd)
{
methodinfo *m; /* method being parsed */
bool parse(jitdata *jd)
{
methodinfo *m; /* method being parsed */
parsedata_t pd;
instruction *iptr; /* current ptr into instruction array */
parsedata_t pd;
instruction *iptr; /* current ptr into instruction array */
/* get required compiler data */
/* get required compiler data */
+ m = jd->m;
+ code = jd->code;
/* allocate buffers for local variable renaming */
/* allocate buffers for local variable renaming */
break;
case JAVA_MULTIANEWARRAY:
break;
case JAVA_MULTIANEWARRAY:
- jd->isleafmethod = false;
i = SUCK_BE_U2(m->jcode + bcindex + 1);
j = SUCK_BE_U1(m->jcode + bcindex + 3);
i = SUCK_BE_U2(m->jcode + bcindex + 1);
j = SUCK_BE_U1(m->jcode + bcindex + 3);
iptr->s1.argcount = j;
OP_S3_CLASSINFO_OR_CLASSREF(opcode, c, cr, INS_FLAG_CHECK);
iptr->s1.argcount = j;
OP_S3_CLASSINFO_OR_CLASSREF(opcode, c, cr, INS_FLAG_CHECK);
+ code_unflag_leafmethod(code);
break;
/* control flow instructions ******************************************/
break;
/* control flow instructions ******************************************/
case JAVA_AASTORE:
OP(opcode);
case JAVA_AASTORE:
OP(opcode);
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
break;
case JAVA_GETSTATIC:
break;
case JAVA_GETSTATIC:
return false;
invoke_method:
return false;
invoke_method:
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
iptr->sx.s23.s3.fmiref = fmi;
iptr->sx.s23.s3.fmiref = fmi;
if (cr->name->text[0] == '[') {
/* array type cast-check */
flags = INS_FLAG_CHECK | INS_FLAG_ARRAY;
if (cr->name->text[0] == '[') {
/* array type cast-check */
flags = INS_FLAG_CHECK | INS_FLAG_ARRAY;
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
}
else {
/* object type cast-check */
}
else {
/* object type cast-check */
} while (0)
#define OP_BUILTIN_CHECK_EXCEPTION(bte) \
} while (0)
#define OP_BUILTIN_CHECK_EXCEPTION(bte) \
- jd->isleafmethod = false; \
+ code_unflag_leafmethod(code); \
OP_PREPARE_FLAGS(ICMD_BUILTIN, INS_FLAG_CHECK); \
iptr->sx.s23.s3.bte = (bte); \
PINC
#define OP_BUILTIN_NO_EXCEPTION(bte) \
OP_PREPARE_FLAGS(ICMD_BUILTIN, INS_FLAG_CHECK); \
iptr->sx.s23.s3.bte = (bte); \
PINC
#define OP_BUILTIN_NO_EXCEPTION(bte) \
- jd->isleafmethod = false; \
+ code_unflag_leafmethod(code); \
OP_PREPARE_ZEROFLAGS(ICMD_BUILTIN); \
iptr->sx.s23.s3.bte = (bte); \
PINC
#define OP_BUILTIN_ARITHMETIC(opcode, bte) \
OP_PREPARE_ZEROFLAGS(ICMD_BUILTIN); \
iptr->sx.s23.s3.bte = (bte); \
PINC
#define OP_BUILTIN_ARITHMETIC(opcode, bte) \
- jd->isleafmethod = false; \
+ code_unflag_leafmethod(code); \
OP_PREPARE_FLAGS(opcode, INS_FLAG_CHECK); \
iptr->sx.s23.s3.bte = (bte); \
PINC
OP_PREPARE_FLAGS(opcode, INS_FLAG_CHECK); \
iptr->sx.s23.s3.bte = (bte); \
PINC
/* align stack to 16-bytes */
/* align stack to 16-bytes */
- if (!jd->isleafmethod || JITDATA_HAS_FLAG_VERBOSECALL(jd))
+ if (!code_is_leafmethod(code) || JITDATA_HAS_FLAG_VERBOSECALL(jd))
ALIGN_2(cd->stackframesize);
ALIGN_2(cd->stackframesize);
- else if (jd->isleafmethod && (cd->stackframesize == LA_SIZE_IN_POINTERS))
+ else if (code_is_leafmethod(code) && (cd->stackframesize == LA_SIZE_IN_POINTERS))
cd->stackframesize = 0;
(void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
cd->stackframesize = 0;
(void) dseg_add_unique_address(cd, code); /* CodeinfoPointer */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
/* create stack frame (if necessary) */
/* create stack frame (if necessary) */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
M_MFLR(REG_ZERO);
M_AST(REG_ZERO, REG_SP, LA_LR_OFFSET);
}
M_MFLR(REG_ZERO);
M_AST(REG_ZERO, REG_SP, LA_LR_OFFSET);
}
M_ALD(REG_ITMP2, REG_PV, disp);
M_MTCTR(REG_ITMP2);
M_ALD(REG_ITMP2, REG_PV, disp);
M_MTCTR(REG_ITMP2);
+ if (code_is_leafmethod(code))
M_MFLR(REG_ITMP3); /* save LR */
M_BL(0); /* get current PC */
M_MFLR(REG_ITMP2_XPC);
M_MFLR(REG_ITMP3); /* save LR */
M_BL(0); /* get current PC */
M_MFLR(REG_ITMP2_XPC);
+ if (code_is_leafmethod(code))
M_MTLR(REG_ITMP3); /* restore LR */
M_RTS; /* jump to CTR */
M_MTLR(REG_ITMP3); /* restore LR */
M_RTS; /* jump to CTR */
/* restore return address */
/* restore return address */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
/* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
may have a displacement overflow. */
/* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
may have a displacement overflow. */
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
- if (!jd->isleafmethod || (md->paramcount == 0)) {
+ if (!code_is_leafmethod(code) || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
- if (!jd->isleafmethod || (md->paramcount == 0)) {
+ if (!code_is_leafmethod(code) || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
else
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
else
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
/* create stack frame (if necessary) */
/* create stack frame (if necessary) */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
M_MFLR(REG_ZERO);
M_AST(REG_ZERO, REG_SP, LA_LR_OFFSET);
}
M_MFLR(REG_ZERO);
M_AST(REG_ZERO, REG_SP, LA_LR_OFFSET);
}
M_ALD(REG_ITMP2, REG_PV, disp);
M_MTCTR(REG_ITMP2);
M_ALD(REG_ITMP2, REG_PV, disp);
M_MTCTR(REG_ITMP2);
- if (jd->isleafmethod) M_MFLR(REG_ITMP3); /* save LR */
+ if (code_is_leafmethod(code))
+ M_MFLR(REG_ITMP3); /* save LR */
+
M_BL(0); /* get current PC */
M_MFLR(REG_ITMP2_XPC);
M_BL(0); /* get current PC */
M_MFLR(REG_ITMP2_XPC);
- if (jd->isleafmethod) M_MTLR(REG_ITMP3); /* restore LR */
- M_RTS; /* jump to CTR */
+ if (code_is_leafmethod(code))
+ M_MTLR(REG_ITMP3); /* restore LR */
+
+ M_RTS; /* jump to CTR */
/* restore return address */
/* restore return address */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
/* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
may have a displacement overflow. */
/* ATTENTION: Don't use REG_ZERO (r0) here, as M_ALD
may have a displacement overflow. */
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
- methodinfo *m;
- codeinfo *code;
+ methodinfo *m;
+ codeinfo *code;
/* get required compiler data */
/* get required compiler data */
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
- if (!jd->isleafmethod || (md->paramcount == 0)) {
+ if (!code_is_leafmethod(code) || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
m = code->m;
/* set codeinfo flags */
m = code->m;
/* set codeinfo flags */
- /* REMOVE ME */
- if (jd->isleafmethod)
- code_flag_leafmethod(code);
+
+ code_flag_leafmethod(code);
/* in instance methods, we may need a rplpoint at the method entry */
/* in instance methods, we may need a rplpoint at the method entry */
native code e.g. libc or jni (alignment problems with
movaps). */
native code e.g. libc or jni (alignment problems with
movaps). */
- if (!jd->isleafmethod || opt_verbosecall )
+ if (!code_is_leafmethod(code) || opt_verbosecall )
/* TODO really 16 bytes ? */
cd->stackframesize = (cd->stackframesize + 2) & ~2;
/* TODO really 16 bytes ? */
cd->stackframesize = (cd->stackframesize + 2) & ~2;
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
methoddesc *md;
s4 stackframesize;
s4 i, off, disp, s;
codegendata *cd;
methoddesc *md;
s4 stackframesize;
s4 i, off, disp, s;
- m = jd->m;
- cd = jd->cd;
- md = m->parseddesc;
+ m = jd->m;
+ code = jd->code;
+ cd = jd->cd;
+
+ md = m->parseddesc;
/* for leaf methods we need to store unused argument and temporary registers */
/* for leaf methods we need to store unused argument and temporary registers */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
stackframesize += (ARG_CNT + TMP_CNT) * 8;
}
stackframesize += (ARG_CNT + TMP_CNT) * 8;
}
/* save unused (currently all) argument registers for leaf methods */
/* save temporary registers for leaf methods */
/* save unused (currently all) argument registers for leaf methods */
/* save temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_ARG_CNT; ++i, off += 8) {
M_IST(abi_registers_integer_argument[i], REG_SP, off);
for (i = 0; i < INT_ARG_CNT; ++i, off += 8) {
M_IST(abi_registers_integer_argument[i], REG_SP, off);
/* restore used argument registers */
/* for leaf methods restore all argument and temporary registers */
/* restore used argument registers */
/* for leaf methods restore all argument and temporary registers */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
off = 96 + (8 * md->paramcount);
for (i = 0; i < INT_ARG_CNT; ++i, off += 8) {
off = 96 + (8 * md->paramcount);
for (i = 0; i < INT_ARG_CNT; ++i, off += 8) {
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
their argument register -> so leafmethods with paramcount > 0
could already use R3 == a00! */
- if (!jd->isleafmethod || (md->paramcount == 0)) {
+ if (!code_is_leafmethod(code) || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
/* Only precolor the stackslot, if it is not a SAVEDVAR <->
has not to survive method invokations. */
+ if (code_is_leafmethod(code))
printf("LEAFMETHOD\n");
printf("\nBasic blocks: %d\n", jd->basicblockcount);
printf("LEAFMETHOD\n");
printf("\nBasic blocks: %d\n", jd->basicblockcount);
s4 framesize_disp;
#if 0 /* no leaf optimization yet */
s4 framesize_disp;
#if 0 /* no leaf optimization yet */
- savedregs_num = (jd->isleafmethod) ? 0 : 1; /* space to save the RA */
+ savedregs_num = (code_is_leafmethod(code)) ? 0 : 1; /* space to save the RA */
#endif
savedregs_num = WINSAVE_CNT + ABIPARAMS_CNT; /* register-window save area */
#endif
savedregs_num = WINSAVE_CNT + ABIPARAMS_CNT; /* register-window save area */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ /* REMOVEME: We still need it for exception handling in assembler. */
+
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1);
+ else
+ (void) dseg_add_unique_s4(cd, 0);
+
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
dseg_addlinenumbertablesize(cd);
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
dseg_addlinenumbertablesize(cd);
/* save temporary registers for leaf methods */
/* XXX no leaf optimization yet
/* save temporary registers for leaf methods */
/* XXX no leaf optimization yet
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_TMP_CNT; i++)
M_LST(rd->tmpintregs[i], REG_SP, (2 + ARG_CNT + i) * 8);
for (i = 0; i < INT_TMP_CNT; i++)
M_LST(rd->tmpintregs[i], REG_SP, (2 + ARG_CNT + i) * 8);
/* restore temporary registers for leaf methods */
/* XXX no leaf optimization yet
/* restore temporary registers for leaf methods */
/* XXX no leaf optimization yet
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_TMP_CNT; i++)
M_LLD(rd->tmpintregs[i], REG_SP, (2 + ARG_CNT + i) * 8);
for (i = 0; i < INT_TMP_CNT; i++)
M_LLD(rd->tmpintregs[i], REG_SP, (2 + ARG_CNT + i) * 8);
bool stack_analyse(jitdata *jd)
{
methodinfo *m; /* method being analyzed */
bool stack_analyse(jitdata *jd)
{
methodinfo *m; /* method being analyzed */
registerdata *rd;
stackdata_t sd;
int stackdepth;
registerdata *rd;
stackdata_t sd;
int stackdepth;
/* get required compiler data - initialization */
m = jd->m;
/* get required compiler data - initialization */
m = jd->m;
rd = jd->rd;
/* initialize the stackdata_t struct */
rd = jd->rd;
/* initialize the stackdata_t struct */
iptr->flags.bits &= INS_FLAG_ID_MASK;
iptr->sx.s23.s3.bte = bte;
/* iptr->line is already set */
iptr->flags.bits &= INS_FLAG_ID_MASK;
iptr->sx.s23.s3.bte = bte;
/* iptr->line is already set */
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
#include <assert.h>
#include <stdio.h>
#include <assert.h>
#include <stdio.h>
#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
+#include "vm/jit/code.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/dseg.h"
#include "vm/jit/emit-common.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/dseg.h"
#include "vm/jit/emit-common.h"
native code e.g. libc or jni (alignment problems with
movaps). */
native code e.g. libc or jni (alignment problems with
movaps). */
- if (!jd->isleafmethod || opt_verbosecall)
+ if (!code_is_leafmethod(code) || opt_verbosecall)
cd->stackframesize |= 0x1;
/* create method header */
cd->stackframesize |= 0x1;
/* create method header */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
#endif
(void) dseg_add_unique_s4(cd, 0); /* IsSync */
- (void) dseg_add_unique_s4(cd, jd->isleafmethod); /* IsLeaf */
+ if (code_is_leafmethod(code))
+ (void) dseg_add_unique_s4(cd, 1); /* IsLeaf */
+ else
+ (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 */
(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
registerdata *rd;
methoddesc *md;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
/* get required compiler data */
- m = jd->m;
- cd = jd->cd;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ cd = jd->cd;
+ rd = jd->rd;
/* save all argument and temporary registers for leaf methods */
/* save all argument and temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_ARG_CNT; i++)
M_LST(abi_registers_integer_argument[i], REG_SP, (md->paramcount + i) * 8);
for (i = 0; i < INT_ARG_CNT; i++)
M_LST(abi_registers_integer_argument[i], REG_SP, (md->paramcount + i) * 8);
/* restore all argument and temporary registers for leaf methods */
/* restore all argument and temporary registers for leaf methods */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(code)) {
for (i = 0; i < INT_ARG_CNT; i++)
M_LLD(abi_registers_integer_argument[i], REG_SP, (md->paramcount + i) * 8);
for (i = 0; i < INT_ARG_CNT; i++)
M_LLD(abi_registers_integer_argument[i], REG_SP, (md->paramcount + i) * 8);
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
to their argument register -> so leafmethods with
paramcount > 0 could already use a00! */
to their argument register -> so leafmethods with
paramcount > 0 could already use a00! */
- if (!jd->isleafmethod || (md->paramcount == 0)) {
+ if (!code_is_leafmethod(code) || (md->paramcount == 0)) {
/* Only precolor the stackslot, if it is not a SAVEDVAR
<-> has not to survive method invokations */
/* Only precolor the stackslot, if it is not a SAVEDVAR
<-> has not to survive method invokations */