Christian Ullrich
Edwin Steiner
- $Id: codegen.c 5488 2006-09-13 00:21:40Z edwin $
+ $Id: codegen.c 5522 2006-09-15 17:05:58Z christian $
*/
s4 len, s1, s2, s3, d, disp;
ptrint a;
s4 fieldtype;
- stackptr src;
- varinfo *var;
+ varinfo *var, *var1, *var2;
basicblock *bptr;
instruction *iptr;
exceptiontable *ex;
builtintable_entry *bte;
methoddesc *md;
rplpoint *replacementpoint;
+ s4 varindex;
/* get required compiler data */
for (p = 0, l = 0; p < md->paramcount; p++) {
t = md->paramtypes[p].type;
- var = &(rd->locals[l][t]);
+ varindex = jd->local_map[l * 5 + t];
+
l++;
if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
l++;
- if (var->type < 0)
- continue;
+
+ if (varindex == UNUSED)
+ continue;
+
+ var = VAR(varindex);
+
s1 = md->params[p].regoff;
if (IS_INT_LNG_TYPE(t)) { /* integer args */
if (IS_2_WORD_TYPE(t))
if (!md->params[p].inmemory) { /* register arguments */
if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
if (IS_2_WORD_TYPE(t))
- M_LNGMOVE(s2, var->regoff);
+ M_LNGMOVE(s2, var->vv.regoff);
else
- M_INTMOVE(s2, var->regoff);
+ M_INTMOVE(s2, var->vv.regoff);
} else { /* reg arg -> spilled */
if (IS_2_WORD_TYPE(t))
- M_LST(s2, REG_SP, var->regoff * 4);
+ M_LST(s2, REG_SP, var->vv.regoff * 4);
else
- M_IST(s2, REG_SP, var->regoff * 4);
+ M_IST(s2, REG_SP, var->vv.regoff * 4);
}
} else { /* stack arguments */
if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
if (IS_2_WORD_TYPE(t))
- M_LLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 4);
+ M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
else
- M_ILD(var->regoff, REG_SP, (cd->stackframesize + s1) * 4);
+ M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
} else { /* stack arg -> spilled */
#if 1
M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4);
- M_IST(REG_ITMP1, REG_SP, var->regoff * 4);
+ M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
if (IS_2_WORD_TYPE(t)) {
M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4 +4);
- M_IST(REG_ITMP1, REG_SP, var->regoff * 4 + 4);
+ M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4 + 4);
}
#else
/* Reuse Memory Position on Caller Stack */
- var->regoff = cd->stackframesize + s1;
+ var->vv.regoff = cd->stackframesize + s1;
#endif
}
}
if (!md->params[p].inmemory) { /* register arguments */
s2 = rd->argfltregs[s1];
if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_FLTMOVE(s2, var->regoff);
+ M_FLTMOVE(s2, var->vv.regoff);
} else { /* reg arg -> spilled */
if (IS_2_WORD_TYPE(t))
- M_DST(s2, REG_SP, var->regoff * 4);
+ M_DST(s2, REG_SP, var->vv.regoff * 4);
else
- M_FST(s2, REG_SP, var->regoff * 4);
+ M_FST(s2, REG_SP, var->vv.regoff * 4);
}
} else { /* stack arguments */
if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
if (IS_2_WORD_TYPE(t))
- M_DLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 4);
+ M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
else
- M_FLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 4);
+ M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
} else { /* stack-arg -> spilled */
#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->regoff * 4);
- var->regoff = cd->stackframesize + s1;
+ 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->regoff * 4);
+ M_FST(REG_FTMP1, REG_SP, var->vv.regoff * 4);
}
#else
/* Reuse Memory Position on Caller Stack */
- var->regoff = cd->stackframesize + s1;
+ var->vv.regoff = cd->stackframesize + s1;
#endif
}
}
}
/* handle replacement points */
-
+#if 0
if (bptr->bitflags & BBFLAG_REPLACEMENT) {
replacementpoint->pc = (u1*)(ptrint)bptr->mpc; /* will be resolved later */
replacementpoint++;
}
-
+#endif
/* generate basicblock profiling code */
if (JITDATA_HAS_FLAG_INSTRUMENT(jd)) {
/* copy interface registers to their destination */
- src = bptr->instack;
len = bptr->indepth;
MCODECHECK(64+len);
if ((len == 0) && (bptr->type != BBTYPE_STD)) {
/* d = reg_of_var(m, src, REG_ITMP1); */
if (!IS_INMEMORY(src->flags))
- d = src->regoff;
+ d = src->vv.regoff;
else
d = REG_ITMP1;
M_INTMOVE(REG_ITMP1, d);
}
} else {
#endif
- while (src != NULL) {
+ while (len > 0) {
len--;
- if ((len == 0) && (bptr->type != BBTYPE_STD)) {
- d = codegen_reg_of_var(rd, 0, src, REG_ITMP1);
+ varindex = bptr->invars[len];
+ var = VAR(varindex);
+ if ((len == bptr->indepth-1) && (bptr->type != BBTYPE_STD)) {
+ d = codegen_reg_of_var(0, var, REG_ITMP1);
M_INTMOVE(REG_ITMP1, d);
- emit_store(jd, NULL, src, d);
+ emit_store(jd, NULL, var, d);
}
else {
- if (src->type == TYPE_LNG)
- d = codegen_reg_of_var(rd, 0, src, REG_ITMP12_PACKED);
- else
- d = codegen_reg_of_var(rd, 0, src, REG_IFTMP);
- if ((src->varkind != STACKVAR)) {
- s2 = src->type;
- if (IS_FLT_DBL_TYPE(s2)) {
- if (!IS_INMEMORY(rd->interfaces[len][s2].flags)) {
- s1 = rd->interfaces[len][s2].regoff;
- M_FLTMOVE(s1, d);
- }
- else {
- if (IS_2_WORD_TYPE(s2)) {
- M_DLD(d, REG_SP,
- rd->interfaces[len][s2].regoff * 4);
- }
- else {
- M_FLD(d, REG_SP,
- rd->interfaces[len][s2].regoff * 4);
- }
- }
- emit_store(jd, NULL, src, d);
- }
- else {
- if (!IS_INMEMORY(rd->interfaces[len][s2].flags)) {
- s1 = rd->interfaces[len][s2].regoff;
- if (IS_2_WORD_TYPE(s2))
- M_LNGMOVE(s1, d);
- else
- M_INTMOVE(s1, d);
- }
- else {
- if (IS_2_WORD_TYPE(s2))
- M_LLD(d, REG_SP,
- rd->interfaces[len][s2].regoff * 4);
- else
- M_ILD(d, REG_SP,
- rd->interfaces[len][s2].regoff * 4);
- }
- emit_store(jd, NULL, src, d);
- }
- }
+ assert((var->flags & OUTVAR));
+ /* will be done directly in simplereg lateron */
+ /* for now codegen_reg_of_var has to be called here to */
+ /* set the regoff and flags for all bptr->invars[] */
+ d = codegen_reg_of_var(0, var, REG_ITMP1);
}
- src = src->prev;
}
#if defined(ENABLE_LSRA)
#endif
/* walk through all instructions */
- src = bptr->instack;
len = bptr->icount;
currentline = 0;
/* load/store operations **********************************************/
case ICMD_ILOAD: /* ... ==> ..., content of local variable */
- case ICMD_ALOAD: /* op1 = local variable */
-
- var = &(rd->locals[iptr->s1.localindex][iptr->opc - ICMD_ILOAD]);
- d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
- if ((iptr->dst.var->varkind == LOCALVAR) &&
- (iptr->dst.var->varnum == iptr->s1.localindex))
- break;
- if (IS_INMEMORY(var->flags))
- M_ILD(d, REG_SP, var->regoff * 4);
- else
- M_INTMOVE(var->regoff, d);
- emit_store_dst(jd, iptr, d);
- break;
-
- case ICMD_LLOAD: /* ... ==> ..., content of local variable */
- /* s1.localindex = local variable */
-
- var = &(rd->locals[iptr->s1.localindex][iptr->opc - ICMD_ILOAD]);
- d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
- if ((iptr->dst.var->varkind == LOCALVAR) &&
- (iptr->dst.var->varnum == iptr->s1.localindex))
- break;
- if (IS_INMEMORY(var->flags))
- M_LLD(d, REG_SP, var->regoff * 4);
- else
- M_LNGMOVE(var->regoff, d);
- emit_store_dst(jd, iptr, d);
- break;
-
- case ICMD_FLOAD: /* ... ==> ..., content of local variable */
- /* s1.localindex = local variable */
-
- d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
- if ((iptr->dst.var->varkind == LOCALVAR) &&
- (iptr->dst.var->varnum == iptr->s1.localindex))
- break;
- var = &(rd->locals[iptr->s1.localindex][iptr->opc - ICMD_ILOAD]);
- if (IS_INMEMORY(var->flags))
- M_FLD(d, REG_SP, var->regoff * 4);
- else
- M_FLTMOVE(var->regoff, d);
- emit_store_dst(jd, iptr, d);
- break;
-
- case ICMD_DLOAD: /* ... ==> ..., content of local variable */
- /* s1.localindex = local variable */
-
- d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
- if ((iptr->dst.var->varkind == LOCALVAR) &&
- (iptr->dst.var->varnum == iptr->s1.localindex))
- break;
- var = &(rd->locals[iptr->s1.localindex][iptr->opc - ICMD_ILOAD]);
- if (IS_INMEMORY(var->flags))
- M_DLD(d, REG_SP, var->regoff * 4);
- else
- M_FLTMOVE(var->regoff, d);
- emit_store_dst(jd, iptr, d);
- break;
-
-
+ case ICMD_ALOAD: /* s1 = local variable */
+ case ICMD_LLOAD:
+ case ICMD_FLOAD:
+ case ICMD_DLOAD:
case ICMD_ISTORE: /* ..., value ==> ... */
- case ICMD_ASTORE: /* op1 = local variable */
-
- if ((iptr->s1.var->varkind == LOCALVAR) &&
- (iptr->s1.var->varnum == iptr->dst.localindex))
- break;
- var = &(rd->locals[iptr->dst.localindex][iptr->opc - ICMD_ISTORE]);
- if (IS_INMEMORY(var->flags)) {
- s1 = emit_load_s1(jd, iptr, REG_ITMP1);
- M_IST(s1, REG_SP, var->regoff * 4);
- } else {
- s1 = emit_load_s1(jd, iptr, var->regoff);
- M_INTMOVE(s1, var->regoff);
- }
- break;
-
- case ICMD_LSTORE: /* ..., value ==> ... */
- /* dst.localindex = local variable */
-
- if ((iptr->s1.var->varkind == LOCALVAR) &&
- (iptr->s1.var->varnum == iptr->dst.localindex))
- break;
- var = &(rd->locals[iptr->dst.localindex][iptr->opc - ICMD_ISTORE]);
- if (IS_INMEMORY(var->flags)) {
- s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
- M_LST(s1, REG_SP, var->regoff * 4);
- } else {
- s1 = emit_load_s1(jd, iptr, var->regoff);
- M_LNGMOVE(s1, var->regoff);
- }
- break;
-
- case ICMD_FSTORE: /* ..., value ==> ... */
- /* dst.localindex = local variable */
-
- if ((iptr->s1.var->varkind == LOCALVAR) &&
- (iptr->s1.var->varnum == iptr->dst.localindex))
- break;
- var = &(rd->locals[iptr->dst.localindex][iptr->opc - ICMD_ISTORE]);
- if (IS_INMEMORY(var->flags)) {
- s1 = emit_load_s1(jd, iptr, REG_FTMP1);
- M_FST(s1, REG_SP, var->regoff * 4);
- } else {
- s1 = emit_load_s1(jd, iptr, var->regoff);
- M_FLTMOVE(s1, var->regoff);
- }
- break;
-
- case ICMD_DSTORE: /* ..., value ==> ... */
- /* dst.localindex = local variable */
-
- if ((iptr->s1.var->varkind == LOCALVAR) &&
- (iptr->s1.var->varnum == iptr->dst.localindex))
- break;
- var = &(rd->locals[iptr->dst.localindex][iptr->opc - ICMD_ISTORE]);
- if (IS_INMEMORY(var->flags)) {
- s1 = emit_load_s1(jd, iptr, REG_FTMP1);
- M_DST(s1, REG_SP, var->regoff * 4);
- } else {
- s1 = emit_load_s1(jd, iptr, var->regoff);
- M_FLTMOVE(s1, var->regoff);
- }
+ case ICMD_ASTORE: /* dst = local variable */
+ case ICMD_LSTORE:
+ case ICMD_FSTORE:
+ case ICMD_DSTORE:
+
+ emit_copy(jd, iptr, VAROP(iptr->s1),
+ VAROP(iptr->dst));
break;
-
/* pop/dup/swap operations ********************************************/
/* attention: double and longs are only one entry in CACAO ICMDs */
case ICMD_POP2: /* ..., value, value ==> ... */
break;
- case ICMD_DUP: /* ..., a ==> ..., a, a */
-
- M_COPY(iptr->s1.var, iptr->dst.var);
- break;
-
- case ICMD_DUP_X1: /* ..., a, b ==> ..., b, a, b */
-
- M_COPY(iptr->dst.dupslots[ 1], iptr->dst.dupslots[2+2]);
- M_COPY(iptr->dst.dupslots[ 0], iptr->dst.dupslots[2+1]);
- M_COPY(iptr->dst.dupslots[2+2], iptr->dst.dupslots[2+0]);
- break;
-
- case ICMD_DUP_X2: /* ..., a, b, c ==> ..., c, a, b, c */
-
- M_COPY(iptr->dst.dupslots[ 2], iptr->dst.dupslots[3+3]);
- M_COPY(iptr->dst.dupslots[ 1], iptr->dst.dupslots[3+2]);
- M_COPY(iptr->dst.dupslots[ 0], iptr->dst.dupslots[3+1]);
- M_COPY(iptr->dst.dupslots[3+3], iptr->dst.dupslots[3+0]);
- break;
-
- case ICMD_DUP2: /* ..., a, b ==> ..., a, b, a, b */
-
- M_COPY(iptr->dst.dupslots[ 1], iptr->dst.dupslots[2+1]);
- M_COPY(iptr->dst.dupslots[ 0], iptr->dst.dupslots[2+0]);
- break;
-
- case ICMD_DUP2_X1: /* ..., a, b, c ==> ..., b, c, a, b, c */
-
- M_COPY(iptr->dst.dupslots[ 2], iptr->dst.dupslots[3+4]);
- M_COPY(iptr->dst.dupslots[ 1], iptr->dst.dupslots[3+3]);
- M_COPY(iptr->dst.dupslots[ 0], iptr->dst.dupslots[3+2]);
- M_COPY(iptr->dst.dupslots[3+4], iptr->dst.dupslots[3+1]);
- M_COPY(iptr->dst.dupslots[3+3], iptr->dst.dupslots[3+0]);
- break;
-
- case ICMD_DUP2_X2: /* ..., a, b, c, d ==> ..., c, d, a, b, c, d */
-
- M_COPY(iptr->dst.dupslots[ 3], iptr->dst.dupslots[4+5]);
- M_COPY(iptr->dst.dupslots[ 2], iptr->dst.dupslots[4+4]);
- M_COPY(iptr->dst.dupslots[ 1], iptr->dst.dupslots[4+3]);
- M_COPY(iptr->dst.dupslots[ 0], iptr->dst.dupslots[4+2]);
- M_COPY(iptr->dst.dupslots[4+5], iptr->dst.dupslots[4+1]);
- M_COPY(iptr->dst.dupslots[4+4], iptr->dst.dupslots[4+0]);
- break;
-
- case ICMD_SWAP: /* ..., a, b ==> ..., b, a */
+ case ICMD_COPY:
+ case ICMD_MOVE:
- M_COPY(iptr->dst.dupslots[ 1], iptr->dst.dupslots[2+0]);
- M_COPY(iptr->dst.dupslots[ 0], iptr->dst.dupslots[2+1]);
+ M_COPY(iptr->s1.varindex, iptr->dst.varindex);
break;
-
/* integer operations *************************************************/
case ICMD_INEG: /* ..., value ==> ..., - value */
int dreg;
u1 *br1;
- if (IS_INMEMORY(iptr->s1.var->flags)) {
+ var1 = VAROP(iptr->s1);
+ var2 = VAROP(iptr->sx.s23.s2);
+
+ if (IS_INMEMORY(var1->flags)) {
tempreg = tempreg || (d == REG_ITMP3) || (d == REG_ITMP2);
} else {
- tempreg = tempreg || (d == GET_HIGH_REG(iptr->s1.var->regoff))
- || (d == GET_LOW_REG(iptr->s1.var->regoff));
+ tempreg = tempreg || (d == GET_HIGH_REG(var1->vv.regoff))
+ || (d == GET_LOW_REG(var1->vv.regoff));
}
- if (IS_INMEMORY(iptr->sx.s23.s2.var->flags)) {
+ if (IS_INMEMORY(var2->flags)) {
tempreg = tempreg || (d == REG_ITMP3) || (d == REG_ITMP2);
} else {
- tempreg = tempreg || (d == GET_HIGH_REG(iptr->sx.s23.s2.var->regoff))
- || (d == GET_LOW_REG(iptr->sx.s23.s2.var->regoff));
+ tempreg = tempreg || (d == GET_HIGH_REG(var2->vv.regoff))
+ || (d == GET_LOW_REG(var2->vv.regoff));
}
dreg = tempreg ? REG_ITMP1 : d;
case ICMD_IINC: /* ..., value ==> ..., value + constant */
/* s1.localindex = variable, sx.val.i = constant*/
- var = &(rd->locals[iptr->s1.localindex][TYPE_INT]);
- if (IS_INMEMORY(var->flags)) {
- s1 = REG_ITMP1;
- M_ILD(s1, REG_SP, var->regoff * 4);
- } else
- s1 = var->regoff;
+ d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
+ s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+
{
u4 m = iptr->sx.val.i;
if (m & 0x8000)
m += 65536;
if (m & 0xffff0000)
- M_ADDIS(s1, m >> 16, s1);
+ M_ADDIS(s1, m >> 16, d);
if (m & 0xffff)
- M_IADD_IMM(s1, m & 0xffff, s1);
+ M_IADD_IMM(s1, m & 0xffff, d);
}
- if (IS_INMEMORY(var->flags))
- M_IST(s1, REG_SP, var->regoff * 4);
+ emit_store_dst(jd, iptr, d);
break;
case ICMD_RET: /* ... ==> ... */
/* s1.localindex = local variable */
- var = &(rd->locals[iptr->s1.localindex][TYPE_ADR]);
- if (IS_INMEMORY(var->flags)) {
- M_ALD(REG_ITMP1, REG_SP, var->regoff * 4);
- M_MTCTR(REG_ITMP1);
- }
- else
- M_MTCTR(var->regoff);
- M_RTS;
+ M_BR(0);
+ codegen_addreference(cd, iptr->dst.block);
ALIGNCODENOP;
break;
/* copy arguments to registers or stack location */
for (s3 = s3 - 1; s3 >= 0; s3--) {
- src = iptr->sx.s23.s2.args[s3];
+ var1 = VAR(iptr->sx.s23.s2.args[s3]);
- if (src->varkind == ARGVAR)
+ /* Already Preallocated (ARGVAR) ? */
+ if (var1->flags & PREALLOC)
continue;
- if (IS_INT_LNG_TYPE(src->type)) {
+ if (IS_INT_LNG_TYPE(var1->type)) {
if (!md->params[s3].inmemory) {
- if (IS_2_WORD_TYPE(src->type)) {
+ if (IS_2_WORD_TYPE(var1->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, src, s1);
+ d = emit_load(jd, iptr, var1, s1);
M_LNGMOVE(d, s1);
}
else {
s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, src, s1);
+ d = emit_load(jd, iptr, var1, s1);
M_INTMOVE(d, s1);
}
}
else {
- if (IS_2_WORD_TYPE(src->type)) {
- d = emit_load(jd, iptr, src, REG_ITMP12_PACKED);
+ if (IS_2_WORD_TYPE(var1->type)) {
+ d = emit_load(jd, iptr, var1, REG_ITMP12_PACKED);
M_LST(d, REG_SP, md->params[s3].regoff * 4);
}
else {
- d = emit_load(jd, iptr, src, REG_ITMP1);
+ d = emit_load(jd, iptr, var1, REG_ITMP1);
M_IST(d, REG_SP, md->params[s3].regoff * 4);
}
}
else {
if (!md->params[s3].inmemory) {
s1 = rd->argfltregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, src, s1);
+ d = emit_load(jd, iptr, var1, s1);
M_FLTMOVE(d, s1);
}
else {
- d = emit_load(jd, iptr, src, REG_FTMP1);
- if (IS_2_WORD_TYPE(src->type))
+ d = emit_load(jd, iptr, var1, REG_FTMP1);
+ if (IS_2_WORD_TYPE(var1->type))
M_DST(d, REG_SP, md->params[s3].regoff * 4);
else
M_FST(d, REG_SP, md->params[s3].regoff * 4);
MCODECHECK((iptr->s1.argcount << 1) + 64);
for (s1 = iptr->s1.argcount; --s1 >= 0;) {
- src = iptr->sx.s23.s2.args[s1];
+ var1 = VAR(iptr->sx.s23.s2.args[s1]);
/* copy SAVEDVAR sizes to stack */
- if (src->varkind != ARGVAR) {
- s2 = emit_load(jd, iptr, src, REG_ITMP1);
+ /* Already Preallocated (ARGVAR) ? */
+ if (!(var1->flags & PREALLOC)) {
+ s2 = emit_load(jd, iptr, var1, REG_ITMP1);
#if defined(__DARWIN__)
M_IST(s2, REG_SP, LA_SIZE + (s1 + INT_ARG_CNT) * 4);
#else
/* copy values to interface registers */
- src = bptr->outstack;
- len = bptr->outdepth;
MCODECHECK(64 + len);
-#if defined(ENABLE_LSRA)
- if (!opt_lsra)
-#endif
- while (src) {
- len--;
- if ((src->varkind != STACKVAR)) {
- s2 = src->type;
- if (IS_FLT_DBL_TYPE(s2)) {
- s1 = emit_load(jd, iptr, src, REG_FTMP1);
- if (!IS_INMEMORY(rd->interfaces[len][s2].flags))
- M_FLTMOVE(s1, rd->interfaces[len][s2].regoff);
- else
- M_DST(s1, REG_SP, rd->interfaces[len][s2].regoff * 4);
-
- } else {
- s1 = emit_load(jd, iptr, src, REG_ITMP1);
- if (!IS_INMEMORY(rd->interfaces[len][s2].flags)) {
- if (IS_2_WORD_TYPE(s2))
- M_LNGMOVE(s1, rd->interfaces[len][s2].regoff);
- else
- M_INTMOVE(s1, rd->interfaces[len][s2].regoff);
- } else {
- if (IS_2_WORD_TYPE(s2))
- M_LST(s1, REG_SP, rd->interfaces[len][s2].regoff * 4);
- else
- M_IST(s1, REG_SP, rd->interfaces[len][s2].regoff * 4);
- }
- }
- }
- src = src->prev;
- }
} /* if (bptr -> flags >= BBREACHED) */
} /* for basic block */
*******************************************************************************/
-s4 emit_load(jitdata *jd, instruction *iptr, stackptr src, s4 tempreg)
+s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
{
codegendata *cd;
s4 disp;
cd = jd->cd;
- if (src->flags & INMEMORY) {
+ if (IS_INMEMORY(src->flags)) {
COUNT_SPILLS;
- disp = src->regoff * 4;
+ disp = src->vv.regoff * 4;
if (IS_FLT_DBL_TYPE(src->type)) {
if (IS_2_WORD_TYPE(src->type))
reg = tempreg;
}
else
- reg = src->regoff;
+ reg = src->vv.regoff;
return reg;
}
*******************************************************************************/
-s4 emit_load_low(jitdata *jd, instruction *iptr, stackptr src, s4 tempreg)
+s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
{
codegendata *cd;
s4 disp;
cd = jd->cd;
- if (src->flags & INMEMORY) {
+ if (IS_INMEMORY(src->flags)) {
COUNT_SPILLS;
- disp = src->regoff * 4;
+ disp = src->vv.regoff * 4;
M_ILD(tempreg, REG_SP, disp + 4);
reg = tempreg;
}
else
- reg = GET_LOW_REG(src->regoff);
+ reg = GET_LOW_REG(src->vv.regoff);
return reg;
}
*******************************************************************************/
-s4 emit_load_high(jitdata *jd, instruction *iptr, stackptr src, s4 tempreg)
+s4 emit_load_high(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
{
codegendata *cd;
s4 disp;
cd = jd->cd;
- if (src->flags & INMEMORY) {
+ if (IS_INMEMORY(src->flags)) {
COUNT_SPILLS;
- disp = src->regoff * 4;
+ disp = src->vv.regoff * 4;
M_ILD(tempreg, REG_SP, disp);
reg = tempreg;
}
else
- reg = GET_HIGH_REG(src->regoff);
+ reg = GET_HIGH_REG(src->vv.regoff);
return reg;
}
s4 emit_load_s1(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->s1.var;
+ src = VAROP(iptr->s1);
reg = emit_load(jd, iptr, src, tempreg);
s4 emit_load_s2(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->sx.s23.s2.var;
+ src = VAROP(iptr->sx.s23.s2);
reg = emit_load(jd, iptr, src, tempreg);
s4 emit_load_s3(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->sx.s23.s3.var;
+ src = VAROP(iptr->sx.s23.s3);
reg = emit_load(jd, iptr, src, tempreg);
s4 emit_load_s1_low(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->s1.var;
+ src = VAROP(iptr->s1);
reg = emit_load_low(jd, iptr, src, tempreg);
s4 emit_load_s2_low(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->sx.s23.s2.var;
+ src = VAROP(iptr->sx.s23.s2);
reg = emit_load_low(jd, iptr, src, tempreg);
s4 emit_load_s3_low(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->sx.s23.s3.var;
+ src = VAROP(iptr->sx.s23.s3);
reg = emit_load_low(jd, iptr, src, tempreg);
s4 emit_load_s1_high(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->s1.var;
+ src = VAROP(iptr->s1);
reg = emit_load_high(jd, iptr, src, tempreg);
s4 emit_load_s2_high(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->sx.s23.s2.var;
+ src = VAROP(iptr->sx.s23.s2);
reg = emit_load_high(jd, iptr, src, tempreg);
s4 emit_load_s3_high(jitdata *jd, instruction *iptr, s4 tempreg)
{
- stackptr src;
+ varinfo *src;
s4 reg;
- src = iptr->sx.s23.s3.var;
+ src = VAROP(iptr->sx.s23.s3);
reg = emit_load_high(jd, iptr, src, tempreg);
*******************************************************************************/
-void emit_store(jitdata *jd, instruction *iptr, stackptr dst, s4 d)
+void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
{
codegendata *cd;
cd = jd->cd;
- if (dst->flags & INMEMORY) {
+ if (IS_INMEMORY(dst->flags)) {
COUNT_SPILLS;
if (IS_FLT_DBL_TYPE(dst->type)) {
if (IS_2_WORD_TYPE(dst->type))
- M_DST(d, REG_SP, dst->regoff * 4);
+ M_DST(d, REG_SP, dst->vv.regoff * 4);
else
- M_FST(d, REG_SP, dst->regoff * 4);
+ M_FST(d, REG_SP, dst->vv.regoff * 4);
}
else {
if (IS_2_WORD_TYPE(dst->type))
- M_LST(d, REG_SP, dst->regoff * 4);
+ M_LST(d, REG_SP, dst->vv.regoff * 4);
else
- M_IST(d, REG_SP, dst->regoff * 4);
+ M_IST(d, REG_SP, dst->vv.regoff * 4);
}
}
}
void emit_store_dst(jitdata *jd, instruction *iptr, s4 d)
{
- emit_store(jd, iptr, iptr->dst.var, d);
+ varinfo *dst;
+
+ dst = VAROP(iptr->dst);
+
+ emit_store(jd, iptr, dst, d);
}
*******************************************************************************/
-void emit_copy(jitdata *jd, instruction *iptr, stackptr src, stackptr dst)
+void emit_copy(jitdata *jd, instruction *iptr, varinfo *src, varinfo *dst)
{
codegendata *cd;
- registerdata *rd;
s4 s1, d;
/* get required compiler data */
cd = jd->cd;
- rd = jd->rd;
- if ((src->regoff != dst->regoff) ||
- ((src->flags ^ dst->flags) & INMEMORY)) {
+ if ((src->vv.regoff != dst->vv.regoff) ||
+ (IS_INMEMORY(src->flags ^ dst->flags))) {
/* If one of the variables resides in memory, we can eliminate
the register move from/to the temporary register with the
if (IS_INMEMORY(src->flags)) {
if (IS_LNG_TYPE(src->type))
- d = codegen_reg_of_var(rd, iptr->opc, dst, REG_ITMP12_PACKED);
+ d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
else
- d = codegen_reg_of_var(rd, iptr->opc, dst, REG_IFTMP);
+ d = codegen_reg_of_var(iptr->opc, dst, REG_IFTMP);
s1 = emit_load(jd, iptr, src, d);
}
else
s1 = emit_load(jd, iptr, src, REG_IFTMP);
- d = codegen_reg_of_var(rd, iptr->opc, dst, s1);
+ d = codegen_reg_of_var(iptr->opc, dst, s1);
}
if (s1 != d) {
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[p].inmemory) {
if (IS_2_WORD_TYPE(t)) {
- M_ILD(rd->argintregs[GET_HIGH_REG(md->params[p].regoff)]
+ M_ILD(rd->argintregs[GET_HIGH_REG(md->params[p].vv.regoff)]
, REG_SP, stack_off);
- M_ILD(rd->argintregs[GET_LOW_REG(md->params[p].regoff)]
+ M_ILD(rd->argintregs[GET_LOW_REG(md->params[p].vv.regoff)]
, REG_SP, stack_off + 4);
} else {
- M_ILD(rd->argintregs[md->params[p].regoff]
+ M_ILD(rd->argintregs[md->params[p].vv.regoff]
, REG_SP, stack_off + 4);
}
}
projects / cacao.git / commitdiff