Changes:
- $Id: arch.h 2340 2005-04-22 13:33:21Z twisti $
+ $Id: arch.h 2356 2005-04-22 17:33:35Z christian $
*/
#define CONDITIONAL_LOADCONST 1
-/* #define CONSECUTIVE_INTARGS */
-/* #define CONSECUTIVE_FLOATARGS */
+#define HAS_4BYTE_STACKSLOT
+/* define SUPPORT_COMBINE_INTEGER_REGISTERS */
+
+/* #define CONSECUTIVE_INTEGER_ARGS */
+/* #define CONSECUTIVE_FLOAT_ARGS */
#endif /* _ARCH_H */
Changes:
- $Id: codegen.h 2339 2005-04-22 13:31:01Z twisti $
+ $Id: codegen.h 2356 2005-04-22 17:33:35Z christian $
*/
rd->ifmemuse: max. number of stackslots used for spilling parameters
so far
************************************************************************/
+#if defined(HAS_4BYTE_STACKSLOT)
+#define SET_ARG_STACKSLOTS { \
+ s4 stacksize = 0; \
+ copy = curstack; \
+ while (--i >= 0) { \
+ stacksize+=IS_2_WORD_TYPE(copy->type)?2:1; \
+ copy = copy->prev; \
+ } \
+ i=call_argcount; \
+ copy=curstack; \
+ if (stacksize > rd->ifmemuse) \
+ rd->ifmemuse = stacksize; \
+ while (--i >= 0) { \
+ stacksize -= IS_2_WORD_TYPE(copy->type)?2:1; \
+ if (!(copy->flags & SAVEDVAR)) { \
+ copy->varkind = ARGVAR; \
+ copy->varnum = i; \
+ copy->flags |= INMEMORY; \
+ copy->regoff = stacksize; \
+ } \
+ copy = copy->prev; \
+ } \
+ }
+#else
#define SET_ARG_STACKSLOTS { \
copy = curstack; \
if (i > rd->ifmemuse) \
copy = copy->prev; \
} \
}
-
+#endif /* defined(HAS_4BYTE_STACKSLOTS) */
/* additional functions and macros to generate code ***************************/
#define gen_div_check(v) \
if (checknull) { \
if ((v)->flags & INMEMORY) { \
- i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 8); \
+ i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 4); \
} else { \
i386_test_reg_reg(cd, src->regoff, src->regoff); \
} \
#define M_LNGMEMMOVE(reg,dreg) \
do { \
- i386_mov_membase_reg(cd, REG_SP, (reg) * 8, REG_ITMP1); \
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, (dreg) * 8); \
- i386_mov_membase_reg(cd, REG_SP, (reg) * 8 + 4, REG_ITMP1); \
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, (dreg) * 8 + 4); \
+ i386_mov_membase_reg(cd, REG_SP, (reg) * 4, REG_ITMP1); \
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, (dreg) * 4); \
+ i386_mov_membase_reg(cd, REG_SP, (reg) * 4 + 4, REG_ITMP1); \
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, (dreg) * 4 + 4); \
} while (0)
#define var_to_reg_int(regnr,v,tempnr) \
if ((v)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_mov_membase_reg(cd, REG_SP, (v)->regoff * 8, tempnr); \
+ i386_mov_membase_reg(cd, REG_SP, (v)->regoff * 4, tempnr); \
regnr = tempnr; \
} else { \
regnr = (v)->regoff; \
if ((v)->type == TYPE_FLT) { \
if ((v)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_flds_membase(cd, REG_SP, (v)->regoff * 8); \
+ i386_flds_membase(cd, REG_SP, (v)->regoff * 4); \
fpu_st_offset++; \
regnr = tempnr; \
} else { \
} else { \
if ((v)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_fldl_membase(cd, REG_SP, (v)->regoff * 8); \
+ i386_fldl_membase(cd, REG_SP, (v)->regoff * 4); \
fpu_st_offset++; \
regnr = tempnr; \
} else { \
if ((v)->type == TYPE_FLT) { \
if ((v)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_flds_membase(cd, REG_SP, (v)->regoff * 8); \
+ i386_flds_membase(cd, REG_SP, (v)->regoff * 4); \
fpu_st_offset++; \
regnr = tempnr; \
} else { \
} else { \
if ((v)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_fldl_membase(cd, REG_SP, (v)->regoff * 8); \
+ i386_fldl_membase(cd, REG_SP, (v)->regoff * 4); \
fpu_st_offset++; \
regnr = tempnr; \
} else { \
#define store_reg_to_var_int(sptr, tempregnum) \
if ((sptr)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_mov_reg_membase(cd, tempregnum, REG_SP, (sptr)->regoff * 8); \
+ i386_mov_reg_membase(cd, tempregnum, REG_SP, (sptr)->regoff * 4); \
}
if ((sptr)->type == TYPE_FLT) { \
if ((sptr)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_fstps_membase(cd, REG_SP, (sptr)->regoff * 8); \
+ i386_fstps_membase(cd, REG_SP, (sptr)->regoff * 4); \
fpu_st_offset--; \
} else { \
/* i386_fxch_reg((sptr)->regoff);*/ \
} else { \
if ((sptr)->flags & INMEMORY) { \
COUNT_SPILLS; \
- i386_fstpl_membase(cd, REG_SP, (sptr)->regoff * 8); \
+ i386_fstpl_membase(cd, REG_SP, (sptr)->regoff * 4); \
fpu_st_offset--; \
} else { \
/* i386_fxch_reg((sptr)->regoff);*/ \
if (!IS_2_WORD_TYPE(from->type)) { \
if (to->flags & INMEMORY) { \
if (from->flags & INMEMORY) { \
- i386_mov_membase_reg(cd, REG_SP, from->regoff * 8, REG_ITMP1); \
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, to->regoff * 8); \
+ i386_mov_membase_reg(cd, REG_SP, from->regoff * 4, REG_ITMP1); \
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, to->regoff * 4); \
} else { \
- i386_mov_reg_membase(cd, from->regoff, REG_SP, to->regoff * 8); \
+ i386_mov_reg_membase(cd, from->regoff, REG_SP, to->regoff * 4); \
} \
} else { \
if (from->flags & INMEMORY) { \
- i386_mov_membase_reg(cd, REG_SP, from->regoff * 8, to->regoff); \
+ i386_mov_membase_reg(cd, REG_SP, from->regoff * 4, to->regoff); \
} else { \
i386_mov_reg_reg(cd, from->regoff, to->regoff); \
} \
Authors: Christian Thalinger
- $Id: emitfuncs.c 2338 2005-04-22 13:30:40Z twisti $
+ $Id: emitfuncs.c 2356 2005-04-22 17:33:35Z christian $
*/
if (iptr->dst->flags & INMEMORY) {
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
if (src->regoff == iptr->dst->regoff) {
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
- i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
+ i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
} else if (src->prev->regoff == iptr->dst->regoff) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
- i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, REG_ITMP1);
+ i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
- i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
+ i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 4, REG_ITMP1);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
if (src->regoff == iptr->dst->regoff) {
- i386_alu_reg_membase(cd, alu_op, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
+ i386_alu_reg_membase(cd, alu_op, src->prev->regoff, REG_SP, iptr->dst->regoff * 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, REG_ITMP1);
i386_alu_reg_reg(cd, alu_op, src->prev->regoff, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
if (src->prev->regoff == iptr->dst->regoff) {
- i386_alu_reg_membase(cd, alu_op, src->regoff, REG_SP, iptr->dst->regoff * 8);
+ i386_alu_reg_membase(cd, alu_op, src->regoff, REG_SP, iptr->dst->regoff * 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
i386_alu_reg_reg(cd, alu_op, src->regoff, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else {
- i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
- i386_alu_reg_membase(cd, alu_op, src->regoff, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 4);
+ i386_alu_reg_membase(cd, alu_op, src->regoff, REG_SP, iptr->dst->regoff * 4);
}
} else {
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
- i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, iptr->dst->regoff);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, iptr->dst->regoff);
+ i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 4, iptr->dst->regoff);
} else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
if (src->prev->regoff != iptr->dst->regoff)
i386_mov_reg_reg(cd, src->prev->regoff, iptr->dst->regoff);
- i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, iptr->dst->regoff);
+ i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 4, iptr->dst->regoff);
} else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
if (src->regoff != iptr->dst->regoff)
i386_mov_reg_reg(cd, src->regoff, iptr->dst->regoff);
- i386_alu_membase_reg(cd, alu_op, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
+ i386_alu_membase_reg(cd, alu_op, REG_SP, src->prev->regoff * 4, iptr->dst->regoff);
} else {
if (src->regoff == iptr->dst->regoff) {
if (iptr->dst->flags & INMEMORY) {
if (src->flags & INMEMORY) {
if (src->regoff == iptr->dst->regoff) {
- i386_alu_imm_membase(cd, alu_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
+ i386_alu_imm_membase(cd, alu_op, iptr->val.i, REG_SP, iptr->dst->regoff * 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, REG_ITMP1);
i386_alu_imm_reg(cd, alu_op, iptr->val.i, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else {
- i386_mov_reg_membase(cd, src->regoff, REG_SP, iptr->dst->regoff * 8);
- i386_alu_imm_membase(cd, alu_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, src->regoff, REG_SP, iptr->dst->regoff * 4);
+ i386_alu_imm_membase(cd, alu_op, iptr->val.i, REG_SP, iptr->dst->regoff * 4);
}
} else {
if (src->flags & INMEMORY) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, iptr->dst->regoff);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, iptr->dst->regoff);
i386_alu_imm_reg(cd, alu_op, iptr->val.i, iptr->dst->regoff);
} else {
if (iptr->dst->flags & INMEMORY) {
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
if (src->regoff == iptr->dst->regoff) {
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
- i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8 + 4, REG_ITMP1);
- i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
+ i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4 + 4, REG_ITMP1);
+ i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 4 + 4);
} else if (src->prev->regoff == iptr->dst->regoff) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
- i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8 + 4, REG_ITMP1);
- i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, REG_ITMP1);
+ i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4 + 4, REG_ITMP1);
+ i386_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, iptr->dst->regoff * 4 + 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
- i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8 + 4, REG_ITMP1);
- i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 8 + 4, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
+ i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 4, REG_ITMP1);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4 + 4, REG_ITMP1);
+ i386_alu_membase_reg(cd, alu_op, REG_SP, src->regoff * 4 + 4, REG_ITMP1);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4 + 4);
}
}
}
if (iptr->dst->flags & INMEMORY) {
if (src->flags & INMEMORY) {
if (src->regoff == iptr->dst->regoff) {
- i386_alu_imm_membase(cd, alu_op, iptr->val.l, REG_SP, iptr->dst->regoff * 8);
- i386_alu_imm_membase(cd, alu_op, iptr->val.l >> 32, REG_SP, iptr->dst->regoff * 8 + 4);
+ i386_alu_imm_membase(cd, alu_op, iptr->val.l, REG_SP, iptr->dst->regoff * 4);
+ i386_alu_imm_membase(cd, alu_op, iptr->val.l >> 32, REG_SP, iptr->dst->regoff * 4 + 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, REG_ITMP1);
i386_alu_imm_reg(cd, alu_op, iptr->val.l, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8 + 4, REG_ITMP1);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4 + 4, REG_ITMP1);
i386_alu_imm_reg(cd, alu_op, iptr->val.l >> 32, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8 + 4);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4 + 4);
}
}
}
if (iptr->dst->flags & INMEMORY) {
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
if (src->prev->regoff == iptr->dst->regoff) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
- i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, ECX);
+ i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, ECX);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
i386_shift_reg(cd, shift_op, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
- i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
- i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, ECX);
+ i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 4);
+ i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 4);
} else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
if (src->prev->regoff == iptr->dst->regoff) {
if (src->regoff != ECX)
i386_mov_reg_reg(cd, src->regoff, ECX);
- i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
+ i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 4);
} else {
if (src->regoff != ECX)
i386_mov_reg_reg(cd, src->regoff, ECX);
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, REG_ITMP1);
i386_shift_reg(cd, shift_op, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else {
if (src->regoff != ECX)
i386_mov_reg_reg(cd, src->regoff, ECX);
- i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 8);
- i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, src->prev->regoff, REG_SP, iptr->dst->regoff * 4);
+ i386_shift_membase(cd, shift_op, REG_SP, iptr->dst->regoff * 4);
}
} else {
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, ECX);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, iptr->dst->regoff);
i386_shift_reg(cd, shift_op, iptr->dst->regoff);
} else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, ECX);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, ECX);
if (src->prev->regoff != iptr->dst->regoff)
i386_mov_reg_reg(cd, src->prev->regoff, iptr->dst->regoff);
if (src->regoff != ECX)
i386_mov_reg_reg(cd, src->regoff, ECX);
- i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 8, iptr->dst->regoff);
+ i386_mov_membase_reg(cd, REG_SP, src->prev->regoff * 4, iptr->dst->regoff);
i386_shift_reg(cd, shift_op, iptr->dst->regoff);
} else {
{
if ((src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
if (src->regoff == iptr->dst->regoff) {
- i386_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
+ i386_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, iptr->dst->regoff * 4);
} else {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, REG_ITMP1);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, REG_ITMP1);
i386_shift_imm_reg(cd, shift_op, iptr->val.i, REG_ITMP1);
- i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, REG_ITMP1, REG_SP, iptr->dst->regoff * 4);
}
} else if ((src->flags & INMEMORY) && !(iptr->dst->flags & INMEMORY)) {
- i386_mov_membase_reg(cd, REG_SP, src->regoff * 8, iptr->dst->regoff);
+ i386_mov_membase_reg(cd, REG_SP, src->regoff * 4, iptr->dst->regoff);
i386_shift_imm_reg(cd, shift_op, iptr->val.i, iptr->dst->regoff);
} else if (!(src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
- i386_mov_reg_membase(cd, src->regoff, REG_SP, iptr->dst->regoff * 8);
- i386_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_reg_membase(cd, src->regoff, REG_SP, iptr->dst->regoff * 4);
+ i386_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, iptr->dst->regoff * 4);
} else {
if (src->regoff != iptr->dst->regoff)
s4 offset = 0;
if (src->flags & INMEMORY) {
- i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 8);
+ i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 4);
} else {
i386_test_reg_reg(cd, src->regoff, src->regoff);
}
offset += 7;
- CALCOFFSETBYTES(offset, REG_SP, iptr->dst->regoff * 8);
+ CALCOFFSETBYTES(offset, REG_SP, iptr->dst->regoff * 4);
i386_jcc(cd, if_op, offset + (iptr[1].opc == ICMD_ELSE_ICONST) ? 5 + offset : 0);
- i386_mov_imm_membase(cd, iptr->val.i, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_imm_membase(cd, iptr->val.i, REG_SP, iptr->dst->regoff * 4);
if (iptr[1].opc == ICMD_ELSE_ICONST) {
i386_jmp_imm(cd, offset);
- i386_mov_imm_membase(cd, iptr[1].val.i, REG_SP, iptr->dst->regoff * 8);
+ i386_mov_imm_membase(cd, iptr[1].val.i, REG_SP, iptr->dst->regoff * 4);
}
} else {
if (src->flags & INMEMORY) {
- i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 8);
+ i386_alu_imm_membase(cd, I386_CMP, 0, REG_SP, src->regoff * 4);
} else {
i386_test_reg_reg(cd, src->regoff, src->regoff);
Changes:
- $Id: arch.h 2039 2005-03-20 11:24:19Z twisti $
+ $Id: arch.h 2356 2005-04-22 17:33:35Z christian $
*/
/* #define CONDITIONAL_LOADCONST 1 */
#define NOLONG_CONDITIONAL
-/* #define CONSECUTIVE_INTARGS */
-#define CONSECUTIVE_FLOATARGS
+/* #define CONSECUTIVE_INTEGER_ARGS */
+#define CONSECUTIVE_FLOAT_ARGS
#define SPECIALMEMUSE
-#define USETWOREGS
-
+#define HAS_4BYTE_STACKSLOT
+#define SUPPORT_COMBINE_INTEGER_REGISTERS
#endif /* _ARCH_H */
Changes: Christian Thalinger
- $Id: codegen.c 2297 2005-04-13 12:50:07Z christian $
+ $Id: codegen.c 2356 2005-04-22 17:33:35Z christian $
*/
stackframesize = 24+32;
}
stackframesize = stackframesize + 8; /* Reserve Space to store Result registers */
+ stackframesize = (stackframesize + 3) & ~3; /* Keep Stack 16 Byte aligned */
M_STWU(REG_SP, REG_SP, -stackframesize); /* build up stackframe */
/* if function is static, check for initialized */
Authors: Christian Thalinger
- $Id: reg.h 2297 2005-04-13 12:50:07Z christian $
+ $Id: reg.h 2356 2005-04-22 17:33:35Z christian $
*/
#define _REG_H
/* #define INVOKE_NEW_DEBUG */
+/* #define NEW_MEMORY */
+
/* preliminary define for testing of the new creation of ARGVAR Stackslots in stack.c */
/* Changes affect handling of ARGVAR Stackslots in reg_of_var in codegen.inc */
int freeargadrtop; /* free argument address register count */
#endif
-#ifdef USETWOREGS
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
int *secondregs; /* used for longs in 2 32 bit registers */
#endif
+#if defined(NEW_MEMORY) && defined(HAS_4BYTE_STACKSLOT)
+ int *freemem_2;
+ int freememtop_2;
+#endif
int *freemem; /* free scratch memory */
int memuse; /* used memory count */
int ifmemuse; /* interface used memory count */
Changes: Stefan Ring
Christian Thalinger
- $Id: reg.inc 2333 2005-04-22 13:26:36Z twisti $
+ $Id: reg.inc 2356 2005-04-22 17:33:35Z christian $
*/
rd->freeargintregs = DMNEW(s4, rd->intreg_argnum);
rd->freetmpintregs = DMNEW(s4, rd->tmpintregcnt);
rd->freesavintregs = DMNEW(s4, rd->savintregcnt);
-#ifdef USETWOREGS
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
rd->secondregs = DMNEW(s4, rd->intregsnum);
#endif
rd->argintregs[1] = i;
#endif
-#ifdef USETWOREGS
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
for (i = 1; i < rd->intreg_argnum; i++)
rd->secondregs[rd->argintregs[i - 1]] = rd->argintregs[i];
for (i = 1; i < rd->tmpintregcnt; i++)
rd->freemem = DMNEW(s4, id->cummaxstack);
+#if defined(NEW_MEMORY) && defined(HAS_4BYTE_STACKSLOT)
+ rd->freemem_2 = DMNEW(s4, id->cummaxstack);
+#endif
rd->locals = DMNEW(varinfo5, id->cumlocals);
rd->interfaces = DMNEW(varinfo5, id->cummaxstack);
int s, t, saved;
int intalloc, fltalloc; /* ?per Interface slot only one flt or one int type can be allocated to a register? */
varinfo *v;
- int regsneeded = 0;
+ int intregsneeded = 0;
+ int memneeded = 0;
/* allocate stack space for passing arguments to called methods */
#ifdef INVOKE_NEW_DEBUG
for (t = TYPE_INT; t <= TYPE_ADR; t++) {
v = &rd->interfaces[s][t];
if (v->type >= 0) {
-#ifdef USETWOREGS
- regsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
+ intregsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#endif
+#if defined(HAS_4BYTE_STACKSLOT)
+ memneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
#endif
if (!saved) {
-#ifdef HAS_ADDRESS_REGISTER_FILE
- if (t == TYPE_ADR) {
#if defined(HAS_ADDRESS_REGISTER_FILE)
+ if (t == TYPE_ADR) {
if (!m->isleafmethod &&(rd->ifargadrregcnt < rd->adrreg_argnum)) {
v->regoff = rd->argadrregs[rd->ifargadrregcnt++];
} else
-#endif
- if (rd->iftmpadrregcnt > 0) {
- rd->iftmpadrregcnt--;
- v->regoff = rd->tmpadrregs[rd->iftmpadrregcnt];
- }
- else if (rd->ifsavadrregcnt > 0) {
- rd->ifsavadrregcnt--;
- v->regoff = rd->savadrregs[rd->ifsavadrregcnt];
- }
- else {
- v->flags |= INMEMORY;
- v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
- }
+ if (rd->iftmpadrregcnt > 0) {
+ rd->iftmpadrregcnt--;
+ v->regoff = rd->tmpadrregs[rd->iftmpadrregcnt];
+ }
+ else if (rd->ifsavadrregcnt > 0) {
+ rd->ifsavadrregcnt--;
+ v->regoff = rd->savadrregs[rd->ifsavadrregcnt];
+ }
+ else {
+ v->flags |= INMEMORY;
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse++;
+ }
} else {
-#endif
- if (IS_FLT_DBL_TYPE(t)) {
- if (fltalloc >= 0) {
- v->flags |= rd->interfaces[s][fltalloc].flags & INMEMORY;
- v->regoff = rd->interfaces[s][fltalloc].regoff;
- }
- else if (!m->isleafmethod &&(rd->ifargfltregcnt < rd->fltreg_argnum)) {
- v->regoff = rd->argfltregs[rd->ifargfltregcnt++];
- }
- else if (rd->iftmpfltregcnt > 0) {
- rd->iftmpfltregcnt--;
- v->regoff = rd->tmpfltregs[rd->iftmpfltregcnt];
- }
- else if (rd->ifsavfltregcnt > 0) {
- rd->ifsavfltregcnt--;
- v->regoff = rd->savfltregs[rd->ifsavfltregcnt];
- }
- else {
- v->flags |= INMEMORY;
- v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
- }
- fltalloc = t;
- }
- else {
-#if defined(__I386__)
- /*
- * for i386 put all longs in memory
- */
- if (IS_2_WORD_TYPE(t)) {
- v->flags |= INMEMORY;
- v->regoff = rd->ifmemuse++;
- } else {
-#endif
- if (intalloc >= 0) {
- v->flags |= rd->interfaces[s][intalloc].flags & INMEMORY;
- v->regoff = rd->interfaces[s][intalloc].regoff;
+#endif /* defined(HAS_ADDRESS_REGISTER_FILE) */
+ if (IS_FLT_DBL_TYPE(t)) {
+ if (fltalloc >= 0) {
+ v->flags |= rd->interfaces[s][fltalloc].flags & INMEMORY;
+ v->regoff = rd->interfaces[s][fltalloc].regoff;
}
- else if (!m->isleafmethod &&(rd->ifargintregcnt +regsneeded < rd->intreg_argnum)) {
- v->regoff = rd->argintregs[rd->ifargintregcnt];
- rd->ifargintregcnt+=regsneeded+1;
+ else if (!m->isleafmethod &&(rd->ifargfltregcnt < rd->fltreg_argnum)) {
+ v->regoff = rd->argfltregs[rd->ifargfltregcnt++];
}
- else if (rd->iftmpintregcnt > regsneeded) {
- rd->iftmpintregcnt -= regsneeded + 1;
- v->regoff = rd->tmpintregs[rd->iftmpintregcnt];
+ else if (rd->iftmpfltregcnt > 0) {
+ rd->iftmpfltregcnt--;
+ v->regoff = rd->tmpfltregs[rd->iftmpfltregcnt];
}
- else if (rd->ifsavintregcnt > regsneeded) {
- rd->ifsavintregcnt -= regsneeded + 1;
- v->regoff = rd->savintregs[rd->ifsavintregcnt];
+ else if (rd->ifsavfltregcnt > 0) {
+ rd->ifsavfltregcnt--;
+ v->regoff = rd->savfltregs[rd->ifsavfltregcnt];
}
else {
v->flags |= INMEMORY;
v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
+ rd->ifmemuse += memneeded + 1;
}
-#if defined(__I386__)
+ fltalloc = t;
+ }
+ else {
+ /* #if defined(__I386__) */
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
+ /*
+ * for i386 put all longs in memory
+ */
+ if (IS_2_WORD_TYPE(t)) {
+ v->flags |= INMEMORY;
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse += memneeded + 1;
+ } else
+#endif /* defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS) */
+#if !defined(HAS_4BYTE_STACKSLOT)
+ if (intalloc >= 0) {
+ v->flags |= rd->interfaces[s][intalloc].flags & INMEMORY;
+ v->regoff = rd->interfaces[s][intalloc].regoff;
+ }
+ else
+#endif /* !defined(HAS_4BYTE_STACKSLOT) */
+ if (!m->isleafmethod &&(rd->ifargintregcnt + intregsneeded < rd->intreg_argnum)) {
+ v->regoff = rd->argintregs[rd->ifargintregcnt];
+ rd->ifargintregcnt += intregsneeded + 1;
+ }
+ else if (rd->iftmpintregcnt > intregsneeded) {
+ rd->iftmpintregcnt -= intregsneeded + 1;
+ v->regoff = rd->tmpintregs[rd->iftmpintregcnt];
+ }
+ else if (rd->ifsavintregcnt > intregsneeded) {
+ rd->ifsavintregcnt -= intregsneeded + 1;
+ v->regoff = rd->savintregs[rd->ifsavintregcnt];
+ }
+ else {
+ v->flags |= INMEMORY;
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse += memneeded + 1;
+ }
+
+ intalloc = t;
}
-#endif
- intalloc = t;
- }
#ifdef HAS_ADDRESS_REGISTER_FILE
}
#endif
else {
v->flags |= INMEMORY;
v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
+ rd->ifmemuse++;
}
} else {
#endif
if (fltalloc >= 0) {
v->flags |= rd->interfaces[s][fltalloc].flags & INMEMORY;
v->regoff = rd->interfaces[s][fltalloc].regoff;
- }
- else if (rd->ifsavfltregcnt > 0) {
+ } else
+ if (rd->ifsavfltregcnt > 0) {
rd->ifsavfltregcnt--;
v->regoff = rd->savfltregs[rd->ifsavfltregcnt];
}
else {
v->flags |= INMEMORY;
v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
+ rd->ifmemuse += memneeded + 1;
}
fltalloc = t;
}
else {
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/*
* for i386 put all longs in memory
*/
if (IS_2_WORD_TYPE(t)) {
v->flags |= INMEMORY;
- v->regoff = rd->ifmemuse++;
- } else {
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse += memneeded + 1;
+ } else
#endif
+#if !defined(HAS_4BYTE_STACKSLOT)
if (intalloc >= 0) {
v->flags |= rd->interfaces[s][intalloc].flags & INMEMORY;
v->regoff = rd->interfaces[s][intalloc].regoff;
- }
- else if (rd->ifsavintregcnt > regsneeded) {
- rd->ifsavintregcnt -= regsneeded + 1;
+ } else
+#endif
+ if (rd->ifsavintregcnt > intregsneeded) {
+ rd->ifsavintregcnt -= intregsneeded + 1;
v->regoff = rd->savintregs[rd->ifsavintregcnt];
}
else {
v->flags |= INMEMORY;
v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
+ rd->ifmemuse += memneeded + 1;
}
-#if defined(__I386__)
- }
-#endif
intalloc = t;
}
#ifdef HAS_ADDRESS_REGISTER_FILE
static void local_regalloc(methodinfo *m, codegendata *cd, registerdata *rd)
{
- int s, t, tt;
- int intalloc, fltalloc;
+ int s, t, tt;
+ int intalloc, fltalloc;
varinfo *v;
- int regsneeded = 0;
- int typeloop[] = { TYPE_LNG, TYPE_DBL, TYPE_INT, TYPE_FLT, TYPE_ADR };
+ int intregsneeded = 0;
+ int memneeded = 0;
+ int typeloop[] = { TYPE_LNG, TYPE_DBL, TYPE_INT, TYPE_FLT, TYPE_ADR };
if (m->isleafmethod) {
int arg, doublewordarg, iargcnt, fargcnt;
v = &rd->locals[s][t];
if (v->type >= 0) {
-#ifdef USETWOREGS
- regsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
+ intregsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#endif
+#if defined(HAS_4BYTE_STACKSLOT)
+ memneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
#endif
#ifdef HAS_ADDRESS_REGISTER_FILE
if (t == TYPE_ADR) {
- /* doublewordarg not possible for xdsp */
-#if !defined(CONSECUTIVE_ADDRESSARGS)
+#if !defined(CONSECUTIVE_ADDRESS_ARGS)
aargcnt = arg;
#endif
if ((arg < m->paramcount) && (aargcnt < rd->adrreg_argnum)) {
else {
v->flags |= INMEMORY;
v->regoff = rd->ifmemuse;
- rd->ifmemuse += regsneeded + 1;
+ rd->ifmemuse ++;
}
} else {
#endif
if (IS_FLT_DBL_TYPE(t)) {
-#if !defined(CONSECUTIVE_FLOATARGS)
+#if !defined(CONSECUTIVE_FLOAT_ARGS)
fargcnt = arg;
#endif
if (fltalloc >= 0) {
else {
v->flags = INMEMORY;
v->regoff = rd->maxmemuse;
- rd->maxmemuse += regsneeded + 1;
+ rd->maxmemuse += memneeded + 1;
}
fltalloc = t;
} else {
int regtouse;
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/*
* for i386 put all longs in memory
*/
if (IS_2_WORD_TYPE(t)) {
v->flags = INMEMORY;
- v->regoff = rd->maxmemuse++;
+ v->regoff = rd->maxmemuse;
+ rd->maxmemuse += memneeded + 1;
} else {
#endif
-#if !defined(CONSECUTIVE_INTARGS)
+#if !defined(CONSECUTIVE_INTEGER_ARGS)
iargcnt = arg;
#endif
if (intalloc >= 0) {
v->regoff = rd->locals[s][intalloc].regoff;
}
else if (!doublewordarg && (arg < m->paramcount)
-#ifndef USETWOREGS
+#ifndef SUPPORT_COMBINE_INTEGER_REGISTERS
&& ((regtouse = iargcnt) < rd->intreg_argnum)
#else
- && ((regtouse = s) < rd->intreg_argnum - regsneeded)
+ && ((regtouse = s) < rd->intreg_argnum - intregsneeded)
#endif
) {
v->flags = 0;
v->regoff = rd->argintregs[regtouse];
}
- else if (rd->maxtmpintreguse > regsneeded) {
- rd->maxtmpintreguse -= regsneeded + 1;
+ else if (rd->maxtmpintreguse > intregsneeded) {
+ rd->maxtmpintreguse -= intregsneeded + 1;
v->flags = 0;
v->regoff = rd->tmpintregs[rd->maxtmpintreguse];
}
- else if (rd->maxsavintreguse > regsneeded) {
- rd->maxsavintreguse -= regsneeded + 1;
+ else if (rd->maxsavintreguse > intregsneeded) {
+ rd->maxsavintreguse -= intregsneeded + 1;
v->flags = 0;
v->regoff = rd->savintregs[rd->maxsavintreguse];
}
else {
v->flags = INMEMORY;
v->regoff = rd->maxmemuse;
- rd->maxmemuse += regsneeded + 1;
+ rd->maxmemuse += memneeded + 1;
}
#if defined(__I386__)
}
t = typeloop[tt];
v = &rd->locals[s][t];
if (v->type >= 0) {
-#ifdef USETWOREGS
- regsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
+ intregsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#endif
+#if defined(HAS_4BYTE_STACKSLOT)
+ memneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
#endif
#ifdef HAS_ADDRESS_REGISTER_FILE
if ( t == TYPE_ADR ) {
else {
v->flags = INMEMORY;
v->regoff = rd->maxmemuse;
- rd->maxmemuse += regsneeded + 1;
+ rd->maxmemuse++;
}
} else {
#endif
}
else {
v->flags = INMEMORY;
+#if defined(NEW_MEMORY)
+ if ( (memneeded) && (rd->maxmemuse&1))
+ rd->maxmemuse++;
+#endif
v->regoff = rd->maxmemuse;
- rd->maxmemuse += regsneeded + 1;
+ rd->maxmemuse += memneeded + 1;
}
fltalloc = t;
}
else {
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/*
* for i386 put all longs in memory
*/
if (IS_2_WORD_TYPE(t)) {
v->flags = INMEMORY;
- v->regoff = rd->maxmemuse++;
+ v->regoff = rd->maxmemuse;
+ rd->maxmemuse += memneeded + 1;
} else {
#endif
if (intalloc >= 0) {
v->flags = rd->locals[s][intalloc].flags;
v->regoff = rd->locals[s][intalloc].regoff;
}
- else if (rd->maxsavintreguse > regsneeded) {
- rd->maxsavintreguse -= regsneeded+1;
+ else if (rd->maxsavintreguse > intregsneeded) {
+ rd->maxsavintreguse -= intregsneeded+1;
v->flags = 0;
v->regoff = rd->savintregs[rd->maxsavintreguse];
}
else {
v->flags = INMEMORY;
v->regoff = rd->maxmemuse;
- rd->maxmemuse += regsneeded + 1;
+ rd->maxmemuse += memneeded + 1;
}
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
}
#endif
intalloc = t;
static void reg_init_temp(methodinfo *m, registerdata *rd)
{
rd->freememtop = 0;
+#if defined(NEW_MEMORY) && defined(HAS_4BYTE_STACKSLOT)
+ rd->freememtop_2 = 0;
+#endif
rd->memuse = rd->ifmemuse;
rd->freetmpinttop = 0;
static void reg_new_temp_func(registerdata *rd, stackptr s)
{
- s4 regsneeded;
+ s4 intregsneeded;
+ s4 memneeded;
s4 tryagain;
/* Try to allocate a saved register if there is no temporary one */
/* available. This is what happens during the second run. */
tryagain = (s->flags & SAVEDVAR) ? 1 : 2;
-#ifdef USETWOREGS
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
regsneeded = (IS_2_WORD_TYPE(s->type)) ? 1 : 0;
#else
- regsneeded = 0;
+ intregsneeded=0;
+#endif
+#if defined(HAS_4BYTE_STACKSLOT)
+ memneeded = (IS_2_WORD_TYPE(s->type)) ? 1 : 0;
+#else
+ memneeded=0;
#endif
for(; tryagain; --tryagain) {
}
} else {
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/*
* for i386 put all longs in memory
*/
if (!IS_2_WORD_TYPE(s->type)) {
#endif
- if (rd->freesavinttop > regsneeded) {
- rd->freesavinttop -= regsneeded + 1;
+ if (rd->freesavinttop > intregsneeded) {
+ rd->freesavinttop -= intregsneeded + 1;
s->regoff = rd->freesavintregs[rd->freesavinttop];
return;
- } else if (rd->savintreguse > regsneeded) {
- rd->savintreguse -= regsneeded + 1;
+ } else if (rd->savintreguse > intregsneeded) {
+ rd->savintreguse -= intregsneeded + 1;
if (rd->savintreguse < rd->maxsavintreguse)
rd->maxsavintreguse = rd->savintreguse;
s->regoff = rd->savintregs[rd->savintreguse];
return;
}
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
}
#endif
}
}
} else {
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
/*
* for i386 put all longs in memory
*/
if (!IS_2_WORD_TYPE(s->type)) {
#endif
- if (rd->freearginttop > regsneeded) {
- rd->freearginttop -= regsneeded + 1;
+ if (rd->freearginttop > intregsneeded) {
+ rd->freearginttop -= intregsneeded + 1;
s->regoff = rd->freeargintregs[rd->freearginttop];
s->flags |= TMPARG;
return;
- } else if (rd->argintreguse < rd->intreg_argnum - regsneeded) {
+ } else if (rd->argintreguse < rd->intreg_argnum - intregsneeded) {
if (rd->argintreguse > rd->maxargintreguse)
rd->maxargintreguse = rd->argintreguse;
s->regoff = rd->argintregs[rd->argintreguse];
s->flags |= TMPARG;
- rd->argintreguse += regsneeded + 1;
+ rd->argintreguse += intregsneeded + 1;
return;
- } else if (rd->freetmpinttop > regsneeded) {
- rd->freetmpinttop -= regsneeded + 1;
+ } else if (rd->freetmpinttop > intregsneeded) {
+ rd->freetmpinttop -= intregsneeded + 1;
s->regoff = rd->freetmpintregs[rd->freetmpinttop];
return;
- } else if (rd->tmpintreguse > regsneeded) {
- rd->tmpintreguse -= regsneeded + 1;
+ } else if (rd->tmpintreguse > intregsneeded) {
+ rd->tmpintreguse -= intregsneeded + 1;
if (rd->tmpintreguse < rd->maxtmpintreguse)
rd->maxtmpintreguse = rd->tmpintreguse;
s->regoff = rd->tmpintregs[rd->tmpintreguse];
return;
}
-#if defined(__I386__)
+#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
}
#endif
}
}
}
- if (rd->freememtop > regsneeded) {
- rd->freememtop -= regsneeded + 1;
+#if defined(NEW_MEMORY)
+#if defined(HAS_4BYTE_STACKSLOT)
+ if ((memneeded>0) && (rd->freememtop_2 > memneeded)) {
+ rd->freememtop_2--;
+ s->regoff = rd->freemem_2[rd->freememtop_2];
+ } else
+#endif /*defined(HAS_4BYTE_STACKSLOT) */
+ if ((memneeded == 0) && (rd->freememtop > memneeded)) {
+ rd->freememtop--;;
+ s->regoff = rd->freemem[rd->freememtop];
+ } else {
+#if defined(HAS_4BYTE_STACKSLOT)
+/* align 2 Word Types */
+/* if ((memneeded) && (rd->memuse & 1 == 1)) { */
+/* rd->freemem[rd->freememtop] = rd->memuse; */
+/* rd->freememtop++; */
+/* rd->memuse++; */
+/* } */
+#endif /*defined(HAS_4BYTE_STACKSLOT) */
+ s->regoff = rd->memuse;
+ rd->memuse += memneeded + 1;
+ if (rd->memuse > rd->maxmemuse)
+ rd->maxmemuse = rd->memuse;
+ }
+#else /* defined(NEW_MEMORY) */
+ if ((rd->freememtop > memneeded) && (memneeded == 0)) {
+ rd->freememtop -= memneeded + 1;
s->regoff = rd->freemem[rd->freememtop];
-
} else {
s->regoff = rd->memuse;
- rd->memuse += regsneeded + 1;
+ rd->memuse += memneeded + 1;
if (rd->memuse > rd->maxmemuse)
rd->maxmemuse = rd->memuse;
}
+#endif /* defined(NEW_MEMORY) */
s->flags |= INMEMORY;
}
static void reg_free_temp_func(registerdata *rd, stackptr s)
{
- s4 regsneeded;
+ s4 intregsneeded;
+ s4 memneeded;
-#ifdef USETWOREGS
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
regsneeded = (IS_2_WORD_TYPE(s->type)) ? 1 : 0;
#else
- regsneeded = 0;
+ intregsneeded=0;
+#endif
+#if defined(HAS_4BYTE_STACKSLOT)
+ memneeded = (IS_2_WORD_TYPE(s->type)) ? 1 : 0;
+#else
+ memneeded=0;
#endif
if (s->flags & INMEMORY) {
+#if defined(NEW_MEMORY) && defined(HAS_4BYTE_STACKSLOT)
+ if (memneeded > 0) {
+ rd->freemem_2[rd->freememtop_2] = s->regoff;
+ rd->freememtop_2++;
+ } else {
+ rd->freemem[rd->freememtop] = s->regoff;
+ rd->freememtop++;
+ }
+#else
rd->freemem[rd->freememtop] = s->regoff;
- if (regsneeded)
+ if (memneeded)
rd->freemem[rd->freememtop + 1] = s->regoff + 1;
- rd->freememtop += regsneeded + 1;
-
+ rd->freememtop += memneeded + 1;
+#endif /* defined(NEW_MEMORY) && defined(HAS_4BYTE_STACKSLOT */
#ifdef HAS_ADDRESS_REGISTER_FILE
} else if (s->type == TYPE_ADR) {
if (s->flags & (SAVEDVAR | SAVEDTMP)) {
if (s->flags & (SAVEDVAR | SAVEDTMP)) {
s->flags &= ~SAVEDTMP;
rd->freesavintregs[rd->freesavinttop] = s->regoff;
-#ifdef USETWOREGS
- if (regsneeded)
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
+ if (intregsneeded)
rd->freesavintregs[rd->freesavinttop + 1] = rd->secondregs[s->regoff];
#endif
- rd->freesavinttop += regsneeded + 1;
+ rd->freesavinttop += intregsneeded + 1;
} else if (s->flags & TMPARG) {
s->flags &= ~TMPARG;
rd->freeargintregs[rd->freearginttop] = s->regoff;
-#ifdef USETWOREGS
- if (regsneeded)
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
+ if (intregsneeded)
rd->freeargintregs[rd->freearginttop + 1] = rd->secondregs[s->regoff];
#endif
- rd->freearginttop += regsneeded + 1;
+ rd->freearginttop += intregsneeded + 1;
} else {
rd->freetmpintregs[rd->freetmpinttop] = s->regoff;
-#ifdef USETWOREGS
- if (regsneeded)
+#ifdef SUPPORT_COMBINE_INTEGER_REGISTERS
+ if (intregsneeded)
rd->freetmpintregs[rd->freetmpinttop + 1] = rd->secondregs[s->regoff];
#endif
- rd->freetmpinttop += regsneeded + 1;
+ rd->freetmpinttop += intregsneeded + 1;
}
}
}
Changes: Edwin Steiner
Christian Thalinger
- $Id: stack.c 2333 2005-04-22 13:26:36Z twisti $
+ $Id: stack.c 2356 2005-04-22 17:33:35Z christian $
*/
rd->argintreguse = 3;
i = iptr->op1;
+
REQUIRE(i);
#ifdef SPECIALMEMUSE
if (rd->ifmemuse < (i + rd->intreg_argnum + 6))
rd->ifmemuse = i + rd->intreg_argnum + 6;
#else
+# if defined(__I386__)
+ if (rd->ifmemuse < i + 3)
+ rd->ifmemuse = i + 3; /* n integer args spilled on stack */
+# else
if (rd->ifmemuse < i)
rd->ifmemuse = i; /* n integer args spilled on stack */
+# endif /* defined(__I386__) */
#endif
if ((i + INT_ARG_CNT) > rd->arguments_num)
rd->arguments_num = i + INT_ARG_CNT;
copy->varkind = ARGVAR;
copy->varnum = i + INT_ARG_CNT;
copy->flags|=INMEMORY;
-#ifdef SPECIALMEMUSE
+#if defined(SPECIALMEMUSE)
copy->regoff = i + rd->intreg_argnum + 6;
#else
+# if defined(__I386__)
+ copy->regoff = i + 3;
+# else
copy->regoff = i;
-#endif
+# endif /* defined(__I386__) */
+#endif /* defined(SPECIALMEMUSE) */
}
copy = copy->prev;
}
Authors: Andreas Krall
Christian Thalinger
- $Id: codegen.c 2352 2005-04-22 13:55:26Z twisti $
+ $Id: codegen.c 2356 2005-04-22 17:33:35Z christian $
*/
if (!(var->flags & INMEMORY)) { /* stack arg -> register */
x86_64_mov_membase_reg(cd, REG_SP, (parentargs_base + pa) * 8 + 8, var->regoff); /* + 8 for return address */
} else { /* stack arg -> spilled */
- x86_64_mov_membase_reg(cd, REG_SP, (parentargs_base + pa) * 8 + 8, REG_ITMP1); /* + 8 for return address */
- x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, var->regoff * 8);
+ /* x86_64_mov_membase_reg(cd, REG_SP, (parentargs_base + pa) * 8 + 8, REG_ITMP1); */ /* + 8 for return address */
+/* x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, var->regoff * 8); */
+ var->regoff = parentargs_base + pa + 1;
}
}
s1++;
x86_64_movq_membase_reg(cd, REG_SP, (parentargs_base + pa) * 8 + 8, var->regoff);
} else {
- x86_64_movq_membase_reg(cd, REG_SP, (parentargs_base + pa) * 8 + 8, REG_FTMP1);
- x86_64_movq_reg_membase(cd, REG_FTMP1, REG_SP, var->regoff * 8);
+/* x86_64_movq_membase_reg(cd, REG_SP, (parentargs_base + pa) * 8 + 8, REG_FTMP1); */
+/* x86_64_movq_reg_membase(cd, REG_FTMP1, REG_SP, var->regoff * 8); */
+ var->regoff = parentargs_base + pa + 1;
}
}
s2++;
projects / cacao.git / commitdiff