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;
- 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;
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)
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)
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));
static void simplereg_allocate_interfaces(jitdata *jd)
{
methodinfo *m;
+ codeinfo *code;
codegendata *cd;
registerdata *rd;
/* 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. */
}
#endif
- 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)
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);
}
static void simplereg_allocate_locals(jitdata *jd)
{
+ codeinfo *code;
codegendata *cd;
registerdata *rd;
/* 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;
}
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 */
#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 */
/* 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--) {
/* restore return address */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
p--; M_LLD(REG_RA, REG_SP, p * 8);
}
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
+ codeinfo *code;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* 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;
md = m->parseddesc;
/* 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++)
/* 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++)
/* 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);
#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);
savedregs_bitmask = 0;
- if (!jd->isleafmethod)
+ if (!code_is_leafmethod(code))
savedregs_bitmask = (1<<REG_LR);
for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--)
/* 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);
}
/* if LR was not on stack, we need to return manually */
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
M_MOV(REG_PC, REG_LR);
break;
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
+ codeinfo *code;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
md = m->parseddesc;
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. */
/* 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 */
}
#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 emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
+ codeinfo *code;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* 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;
md = m->parseddesc;
/* 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);
}
/* 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);
}
static void inline_post_process(jitdata *jd)
{
+ codeinfo *code;
basicblock *bptr;
instruction *iptr;
instruction *iend;
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)
POSTPROCESS_SRCOP(s1);
case DF_0_TO_0:
if (icmdt->flags & ICMDTABLE_CALLS) {
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
MARK_ALL_SAVED;
}
break;
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:
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);
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]);
}
jitdata *jit_jitdata_new(methodinfo *m)
{
- jitdata *jd;
+ jitdata *jd;
+ codeinfo *code;
/* allocate jitdata structure and fill it */
/* 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 */
+ jd->code = code;
jd->flags = 0;
jd->exceptiontable = NULL;
jd->exceptiontablelength = 0;
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;
-
return jd;
}
#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 */
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 */
/* 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. */
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 */
#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);
/* 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--) {
/* restore return address */
- if (!jd->isleafmethod) {
+ if (!code_is_leafmethod(code)) {
p--; M_ALD(REG_RA, REG_SP, p * 8);
}
void emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
+ codeinfo *code;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* 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;
md = m->parseddesc;
/* 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);
/* 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);
/* 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
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>
#if defined(LSRA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",m->class->name->text, m->name->text);
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
printf("**Leafmethod**");
printf("\n");
}
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;
#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)
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)
ls = jd->ls;
- 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));
/* 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
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 <stdlib.h>
# if defined(SSA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",m->class->name->text, m->name->text);
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
printf("**Leafmethod**");
printf("\n");
}
# if defined(SSA_DEBUG_VERBOSE)
if (compileverbose) {
printf("%s %s ",jd->m->class->name->text, jd->m->name->text);
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
printf("**Leafmethod**");
printf("\n");
}
bool parse(jitdata *jd)
{
methodinfo *m; /* method being parsed */
+ codeinfo *code;
parsedata_t pd;
instruction *iptr; /* current ptr into instruction array */
/* get required compiler data */
- m = jd->m;
+ m = jd->m;
+ code = jd->code;
/* allocate buffers for local variable renaming */
break;
case JAVA_MULTIANEWARRAY:
- jd->isleafmethod = false;
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);
+ code_unflag_leafmethod(code);
break;
/* control flow instructions ******************************************/
case JAVA_AASTORE:
OP(opcode);
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
break;
case JAVA_GETSTATIC:
return false;
invoke_method:
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
iptr->sx.s23.s3.fmiref = fmi;
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 */
} 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) \
- 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) \
- jd->isleafmethod = false; \
+ code_unflag_leafmethod(code); \
OP_PREPARE_FLAGS(opcode, INS_FLAG_CHECK); \
iptr->sx.s23.s3.bte = (bte); \
PINC
/* 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);
- 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 */
#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 */
/* 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_ALD(REG_ITMP2, REG_PV, disp);
M_MTCTR(REG_ITMP2);
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
M_MFLR(REG_ITMP3); /* save LR */
M_BL(0); /* get current PC */
M_MFLR(REG_ITMP2_XPC);
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
M_MTLR(REG_ITMP3); /* restore LR */
M_RTS; /* jump to CTR */
/* 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. */
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
+ codeinfo *code;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
md = m->parseddesc;
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. */
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
+ codeinfo *code;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
md = m->parseddesc;
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. */
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 */
/* 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_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);
- 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 */
ALIGNCODENOP;
break;
/* 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. */
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
- methodinfo *m;
- codeinfo *code;
+ methodinfo *m;
+ codeinfo *code;
registerdata *rd;
- methoddesc *md;
+ methoddesc *md;
/* get required compiler data */
- m = jd->m;
+ m = jd->m;
code = jd->code;
- rd = jd->rd;
+ rd = jd->rd;
md = m->parseddesc;
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. */
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 */
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;
#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 emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
+ codeinfo *code;
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;
/* mark trace code */
/* 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;
}
/* 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);
/* 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) {
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
+ codeinfo *code;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
md = m->parseddesc;
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. */
method_println(m);
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
printf("LEAFMETHOD\n");
printf("\nBasic blocks: %d\n", jd->basicblockcount);
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
(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);
/* 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);
/* 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);
bool stack_analyse(jitdata *jd)
{
methodinfo *m; /* method being analyzed */
+ codeinfo *code;
registerdata *rd;
stackdata_t sd;
int stackdepth;
/* get required compiler data - initialization */
m = jd->m;
+ code = jd->code;
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 */
- jd->isleafmethod = false;
+ code_unflag_leafmethod(code);
goto icmd_BUILTIN;
}
#include <assert.h>
#include <stdio.h>
+#include <stdint.h>
#include "vm/types.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"
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 */
#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 emit_verbosecall_enter(jitdata *jd)
{
methodinfo *m;
+ codeinfo *code;
codegendata *cd;
registerdata *rd;
methoddesc *md;
/* 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;
md = m->parseddesc;
/* 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);
/* 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);
void md_return_alloc(jitdata *jd, stackptr stackslot)
{
methodinfo *m;
+ codeinfo *code;
registerdata *rd;
methoddesc *md;
/* get required compiler data */
- m = jd->m;
- rd = jd->rd;
+ m = jd->m;
+ code = jd->code;
+ rd = jd->rd;
md = m->parseddesc;
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 */
projects / cacao.git / commitdiff