From 9e3df070c8022aa20b3761a9d213a185eb27ed99 Mon Sep 17 00:00:00 2001 From: MaartenBrock Date: Wed, 29 Aug 2007 13:02:10 +0000 Subject: [PATCH] * src/ds390/gen.c (genFarPointerSet), * src/hc08/ralloc.c (packRegisters), * src/mcs51/ralloc.c (packRegisters), * src/SDCCcse.c (cseBBlock): check if result is a symbol first to fix bug 1750318 * src/SDCCicode.h: POINTER_SET can be true for literals too * support/regression/tests/bug1750318.c: new, added git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@4905 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- ChangeLog | 10 + src/SDCCcse.c | 25 +- src/SDCCicode.h | 10 +- src/ds390/gen.c | 3 +- src/hc08/ralloc.c | 1723 +++++++++++++------------ src/mcs51/ralloc.c | 5 +- support/regression/tests/bug1750318.c | 21 + 7 files changed, 917 insertions(+), 880 deletions(-) create mode 100644 support/regression/tests/bug1750318.c diff --git a/ChangeLog b/ChangeLog index 960fb7c1..227792e7 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,13 @@ +2007-08-29 Maarten Brock + + * src/ds390/gen.c (genFarPointerSet), + * src/hc08/ralloc.c (packRegisters), + * src/mcs51/ralloc.c (packRegisters), + * src/SDCCcse.c (cseBBlock): check if result is a symbol first to fix + bug 1750318 + * src/SDCCicode.h: POINTER_SET can be true for literals too + * support/regression/tests/bug1750318.c: new, added + 2007-08-23 Borut Razem * debugger/mcs51/sdcdb.c: fixed compilation with older readline diff --git a/src/SDCCcse.c b/src/SDCCcse.c index d33632ab..f7fca2af 100644 --- a/src/SDCCcse.c +++ b/src/SDCCcse.c @@ -2023,7 +2023,7 @@ cseBBlock (eBBlock * ebb, int computeOnly, /* update the spill location for this */ updateSpillLocation (ic,0); - if (POINTER_SET (ic) && + if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)) && !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype))) { pdop = NULL; @@ -2132,7 +2132,7 @@ cseBBlock (eBBlock * ebb, int computeOnly, IS_ITEMP (IC_RESULT (ic)) && !computeOnly) { - applyToSet (cseSet, findPrevIc, ic, &pdic); + applyToSet (cseSet, findPrevIc, ic, &pdic); if (pdic && compareType (operandType (IC_RESULT (pdic)), operandType (IC_RESULT (ic))) != 1) pdic = NULL; @@ -2169,6 +2169,7 @@ cseBBlock (eBBlock * ebb, int computeOnly, mine and type is a pointer then delete pointerGets to take care of aliasing */ if (ASSIGNMENT (ic) && + IS_SYMOP (IC_RESULT (ic)) && OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))) && IS_PTR (operandType (IC_RESULT (ic)))) { @@ -2197,7 +2198,7 @@ cseBBlock (eBBlock * ebb, int computeOnly, /* delete from the cseSet anything that has */ /* operands matching the result of this */ /* except in case of pointer access */ - if (!(POINTER_SET (ic)) && IC_RESULT (ic)) + if (!(POINTER_SET (ic)) && IS_SYMOP (IC_RESULT (ic))) { deleteItemIf (&cseSet, ifOperandsHave, IC_RESULT (ic)); /* delete any previous definitions */ @@ -2221,7 +2222,7 @@ cseBBlock (eBBlock * ebb, int computeOnly, /* for the result it is special case, put the result */ /* in the defuseSet if it a pointer or array access */ - if (POINTER_SET (defic)) + if (POINTER_SET (defic) && IS_SYMOP (IC_RESULT (ic))) { OP_USES(IC_RESULT (ic))= bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key); @@ -2240,16 +2241,18 @@ cseBBlock (eBBlock * ebb, int computeOnly, addSetHead (&ptrSetSet, newCseDef (IC_RESULT (ic), ic)); } else - /* add the result to defintion set */ if (IC_RESULT (ic)) { - OP_DEFS(IC_RESULT (ic))= - bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key); - ebb->defSet = bitVectSetBit (ebb->defSet, ic->key); - ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic))); - ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key); + /* add the result to definition set */ + if (IS_SYMOP (IC_RESULT (ic))) + { + OP_DEFS(IC_RESULT (ic))= + bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key); + ebb->defSet = bitVectSetBit (ebb->defSet, ic->key); + ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic))); + ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key); + } } - /* if this is an addressof instruction then */ /* put the symbol in the address of list & */ /* delete it from the cseSet */ diff --git a/src/SDCCicode.h b/src/SDCCicode.h index 30e730a8..48ef88fe 100644 --- a/src/SDCCicode.h +++ b/src/SDCCicode.h @@ -105,8 +105,8 @@ extern operand *validateOpType(operand *op, const char *file, unsigned line); -#define OP_SYMBOL(op) validateOpType(op, "OP_SYMBOL", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand -#define OP_VALUE(op) validateOpType(op, "OP_VALUE", #op, VALUE, __FILE__, __LINE__)->operand.valOperand +#define OP_SYMBOL(op) validateOpType(op, "OP_SYMBOL", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand +#define OP_VALUE(op) validateOpType(op, "OP_VALUE", #op, VALUE, __FILE__, __LINE__)->operand.valOperand #define OP_SYM_TYPE(op) validateOpType(op, "OP_SYM_TYPE", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->type #define OP_SYM_ETYPE(op) validateOpType(op, "OP_SYM_ETYPE", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->etype #define SPIL_LOC(op) validateOpType(op, "SPIL_LOC", #op, SYMBOL, __FILE__, __LINE__)->operand.symOperand->usl.spillLoc @@ -241,12 +241,12 @@ iCodeTable; #define IS_TRUE_SYMOP(op) (op && IS_SYMOP(op) && !IS_ITEMP(op)) #define POINTER_SET(ic) ( ic && ic->op == '=' \ - && IS_ITEMP(IC_RESULT(ic)) \ + && (IS_ITEMP(IC_RESULT(ic)) || IS_OP_LITERAL(IC_RESULT(ic)))\ && IC_RESULT(ic)->isaddr ) #define POINTER_GET(ic) ( ic && ic->op == GET_VALUE_AT_ADDRESS \ - && (IS_ITEMP(IC_LEFT(ic)) || IS_OP_LITERAL(IC_LEFT(ic)))\ - && IC_LEFT(ic)->isaddr ) + && (IS_ITEMP(IC_LEFT(ic)) || IS_OP_LITERAL(IC_LEFT(ic)))\ + && IC_LEFT(ic)->isaddr ) #define IS_ARITHMETIC_OP(x) (x && (x->op == '+' || \ x->op == '-' || \ diff --git a/src/ds390/gen.c b/src/ds390/gen.c index 24385894..9b4ba0a2 100644 --- a/src/ds390/gen.c +++ b/src/ds390/gen.c @@ -11592,7 +11592,8 @@ genFarPointerSet (operand * right, _endLazyDPSEvaluation (); } pi->generated=1; - } else if ((OP_SYMBOL(result)->ruonly || AOP_INDPTRn(result)) && + } else if (IS_SYMOP (result) && + (OP_SYMBOL(result)->ruonly || AOP_INDPTRn(result)) && AOP_SIZE(right) > 1 && (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) { diff --git a/src/hc08/ralloc.c b/src/hc08/ralloc.c index 3cba4a60..f109c275 100644 --- a/src/hc08/ralloc.c +++ b/src/hc08/ralloc.c @@ -48,14 +48,14 @@ static struct bitVect *totRegAssigned; /* final set of LRs that got into registers */ short blockSpil; int slocNum; - bitVect *funcrUsed; /* registers used in a function */ + bitVect *funcrUsed; /* registers used in a function */ int stackExtend; int dataExtend; } _G; /* Shared with gen.c */ -int hc08_ptrRegReq; /* one byte pointer register required */ +int hc08_ptrRegReq; /* one byte pointer register required */ /* 8051 registers */ regs regshc08[] = @@ -94,8 +94,8 @@ allocReg (short type) { regshc08[HX_IDX].isFree = 0; if (currFunc) - currFunc->regsUsed = - bitVectSetBit (currFunc->regsUsed, HX_IDX); + currFunc->regsUsed = + bitVectSetBit (currFunc->regsUsed, HX_IDX); return ®shc08[HX_IDX]; } return NULL; @@ -114,7 +114,7 @@ hc08_regWithIdx (int idx) return ®shc08[i]; werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "regWithIdx not found"); + "regWithIdx not found"); exit (1); } @@ -127,7 +127,7 @@ hc08_freeReg (regs * reg) if (!reg) { werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "hc08_freeReg - Freeing NULL register"); + "hc08_freeReg - Freeing NULL register"); exit (1); } @@ -194,7 +194,7 @@ nfreeRegsType (int type) if (type == REG_PTR) { if ((nfr = nFreeRegs (type)) == 0) - return nFreeRegs (REG_GPR); + return nFreeRegs (REG_GPR); } return nFreeRegs (type); @@ -213,7 +213,7 @@ hc08_useReg (regs * reg) case A_IDX: hc08_reg_xa->aop = NULL; hc08_reg_xa->isFree = 0; - break; + break; case X_IDX: hc08_reg_xa->aop = NULL; hc08_reg_xa->isFree = 0; @@ -294,9 +294,9 @@ computeSpillable (iCode * ic) spillable = bitVectCopy (ic->rlive); spillable = - bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */ + bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */ spillable = - bitVectCplAnd (spillable, ic->uses); /* used in this one */ + bitVectCplAnd (spillable, ic->uses); /* used in this one */ bitVectUnSetBit (spillable, ic->defKey); spillable = bitVectIntersect (spillable, _G.regAssigned); return spillable; @@ -360,7 +360,7 @@ static int notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic) { return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) && - allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq)); + allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq)); } /*-----------------------------------------------------------------*/ @@ -377,7 +377,7 @@ allLRs (symbol * sym, eBBlock * ebp, iCode * ic) /*-----------------------------------------------------------------*/ static set * liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *), - eBBlock * ebp, iCode * ic) + eBBlock * ebp, iCode * ic) { set *rset = NULL; int i; @@ -389,19 +389,19 @@ liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *), { symbol *sym; if (!bitVectBitValue (lrs, i)) - continue; + continue; /* if we don't find it in the live range hash table we are in serious trouble */ if (!(sym = hTabItemWithKey (liveRanges, i))) - { - werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "liveRangesWith could not find liveRange"); - exit (1); - } + { + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, + "liveRangesWith could not find liveRange"); + exit (1); + } if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key)) - addSetHead (&rset, sym); + addSetHead (&rset, sym); } return rset; @@ -427,12 +427,12 @@ leastUsedLR (set * sset) /* if usage is the same then prefer the spill the smaller of the two */ if (lsym->used == sym->used) - if (getSize (lsym->type) < getSize (sym->type)) - sym = lsym; + if (getSize (lsym->type) < getSize (sym->type)) + sym = lsym; /* if less usage */ if (lsym->used < sym->used) - sym = lsym; + sym = lsym; } @@ -453,7 +453,7 @@ noOverLap (set * itmpStack, symbol * fsym) for (sym = setFirstItem (itmpStack); sym; sym = setNextItem (itmpStack)) { - if (bitVectBitValue(sym->clashes,fsym->key)) return 0; + if (bitVectBitValue(sym->clashes,fsym->key)) return 0; } return 1; @@ -515,17 +515,17 @@ spillLRWithPtrReg (symbol * forSym) not need to spill it */ if (lrsym->isspilt || !lrsym->nRegs || - (lrsym->liveTo < forSym->liveFrom)) - continue; + (lrsym->liveTo < forSym->liveFrom)) + continue; /* go thru the registers : if it is either r0 or r1 then spil it */ for (j = 0; j < lrsym->nRegs; j++) - if (lrsym->regs[j] == hx) - { - spillThis (lrsym); - break; - } + if (lrsym->regs[j] == hx) + { + spillThis (lrsym); + break; + } } } @@ -560,7 +560,7 @@ createStackSpil (symbol * sym) if (sprintf (slocBuffer, "sloc%d", _G.slocNum++) >= sizeof (slocBuffer)) { fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n", - __FILE__, __LINE__); + __FILE__, __LINE__); exit (1); } @@ -593,7 +593,7 @@ createStackSpil (symbol * sym) options.useXstack = useXstack; options.model = model; /* options.noOverlay = noOverlay; */ - sloc->isref = 1; /* to prevent compiler warning */ + sloc->isref = 1; /* to prevent compiler warning */ /* if it is on the stack then update the stack */ if (IN_STACK (sloc->etype)) @@ -666,8 +666,8 @@ spillThis (symbol * sym) if (sym->regs[i]) { - hc08_freeReg (sym->regs[i]); - sym->regs[i] = NULL; + hc08_freeReg (sym->regs[i]); + sym->regs[i] = NULL; } /* if spilt on stack then free up r0 & r1 @@ -710,8 +710,8 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) { sym = leastUsedLR (selectS); strcpy (sym->rname, (sym->usl.spillLoc->rname[0] ? - sym->usl.spillLoc->rname : - sym->usl.spillLoc->name)); + sym->usl.spillLoc->rname : + sym->usl.spillLoc->name)); sym->spildir = 1; /* mark it as allocation required */ sym->usl.spillLoc->allocreq++; @@ -725,34 +725,34 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) /* check if there are any live ranges allocated to registers that are not used in this block */ if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic))) - { - sym = leastUsedLR (selectS); - /* if this is not rematerializable */ - if (!sym->remat) - { - _G.blockSpil++; - sym->blockSpil = 1; - } - return sym; - } + { + sym = leastUsedLR (selectS); + /* if this is not rematerializable */ + if (!sym->remat) + { + _G.blockSpil++; + sym->blockSpil = 1; + } + return sym; + } /* check if there are any live ranges that not used in the remainder of the block */ if (!_G.blockSpil && - !isiCodeInFunctionCall (ic) && + !isiCodeInFunctionCall (ic) && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic))) - { - sym = leastUsedLR (selectS); - if (sym != forSym) - { - if (!sym->remat) - { - sym->remainSpil = 1; - _G.blockSpil++; - } - return sym; - } - } + { + sym = leastUsedLR (selectS); + if (sym != forSym) + { + if (!sym->remat) + { + sym->remainSpil = 1; + _G.blockSpil++; + } + return sym; + } + } } /* find live ranges with spillocation && not used as pointers */ @@ -834,7 +834,7 @@ spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym) iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL); /* add push to the start of the block */ addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ? - ebp->sch->next : ebp->sch)); + ebp->sch->next : ebp->sch)); nic = newiCode (IPOP, operandFromSymbol (ssym), NULL); /* add pop to the end of the block */ addiCodeToeBBlock (ebp, nic, NULL); @@ -987,89 +987,89 @@ deassignLRs (iCode * ic, eBBlock * ebp) symbol *psym = NULL; /* if it does not end here */ if (sym->liveTo > ic->seq) - continue; + continue; /* if it was spilt on stack then we can mark the stack spil location as free */ if (sym->isspilt) - { - if (sym->stackSpil) - { - sym->usl.spillLoc->isFree = 1; - sym->stackSpil = 0; - } - continue; - } + { + if (sym->stackSpil) + { + sym->usl.spillLoc->isFree = 1; + sym->stackSpil = 0; + } + continue; + } if (!bitVectBitValue (_G.regAssigned, sym->key)) - continue; + continue; /* special case check if this is an IFX & the privious one was a pop and the previous one was not spilt then keep track of the symbol */ if (ic->op == IFX && ic->prev && - ic->prev->op == IPOP && - !ic->prev->parmPush && - !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt) - psym = OP_SYMBOL (IC_LEFT (ic->prev)); + ic->prev->op == IPOP && + !ic->prev->parmPush && + !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt) + psym = OP_SYMBOL (IC_LEFT (ic->prev)); if (sym->nRegs) - { - int i = 0; - - bitVectUnSetBit (_G.regAssigned, sym->key); - - /* if the result of this one needs registers - and does not have it then assign it right - away */ - if (IC_RESULT (ic) && - !(SKIP_IC2 (ic) || /* not a special icode */ - ic->op == JUMPTABLE || - ic->op == IFX || - ic->op == IPUSH || - ic->op == IPOP || - ic->op == RETURN || - POINTER_SET (ic)) && - (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */ - result->liveTo > ic->seq && /* and will live beyond this */ - result->liveTo <= ebp->lSeq && /* does not go beyond this block */ - result->liveFrom == ic->seq && /* does not start before here */ - result->regType == sym->regType && /* same register types */ - result->nRegs && /* which needs registers */ - !result->isspilt && /* and does not already have them */ - !result->remat && - !bitVectBitValue (_G.regAssigned, result->key) && - /* the number of free regs + number of regs in this LR - can accomodate the what result Needs */ - ((nfreeRegsType (result->regType) + - sym->nRegs) >= result->nRegs) - ) - { - - for (i = 0; i < result->nRegs; i++) - if (i < sym->nRegs) - result->regs[i] = sym->regs[i]; - else - result->regs[i] = getRegGpr (ic, ebp, result); - - _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key); - _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key); - - } - - /* free the remaining */ - for (; i < sym->nRegs; i++) - { - if (psym) - { - if (!symHasReg (psym, sym->regs[i])) - hc08_freeReg (sym->regs[i]); - } - else - hc08_freeReg (sym->regs[i]); - } - } + { + int i = 0; + + bitVectUnSetBit (_G.regAssigned, sym->key); + + /* if the result of this one needs registers + and does not have it then assign it right + away */ + if (IC_RESULT (ic) && + !(SKIP_IC2 (ic) || /* not a special icode */ + ic->op == JUMPTABLE || + ic->op == IFX || + ic->op == IPUSH || + ic->op == IPOP || + ic->op == RETURN || + POINTER_SET (ic)) && + (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */ + result->liveTo > ic->seq && /* and will live beyond this */ + result->liveTo <= ebp->lSeq && /* does not go beyond this block */ + result->liveFrom == ic->seq && /* does not start before here */ + result->regType == sym->regType && /* same register types */ + result->nRegs && /* which needs registers */ + !result->isspilt && /* and does not already have them */ + !result->remat && + !bitVectBitValue (_G.regAssigned, result->key) && + /* the number of free regs + number of regs in this LR + can accomodate the what result Needs */ + ((nfreeRegsType (result->regType) + + sym->nRegs) >= result->nRegs) + ) + { + + for (i = 0; i < result->nRegs; i++) + if (i < sym->nRegs) + result->regs[i] = sym->regs[i]; + else + result->regs[i] = getRegGpr (ic, ebp, result); + + _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key); + _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key); + + } + + /* free the remaining */ + for (; i < sym->nRegs; i++) + { + if (psym) + { + if (!symHasReg (psym, sym->regs[i])) + hc08_freeReg (sym->regs[i]); + } + else + hc08_freeReg (sym->regs[i]); + } + } } } @@ -1110,23 +1110,23 @@ willCauseSpill (int nr, int rt) if pointer type not avlb then check for type gpr */ if (nFreeRegs (rt) >= nr) - return 0; + return 0; if (nFreeRegs (REG_GPR) >= nr) - return 0; + return 0; } else { if (hc08_ptrRegReq) - { - if (nFreeRegs (rt) >= nr) - return 0; - } + { + if (nFreeRegs (rt) >= nr) + return 0; + } else - { - if (nFreeRegs (REG_PTR) + - nFreeRegs (REG_GPR) >= nr) - return 0; - } + { + if (nFreeRegs (REG_PTR) + + nFreeRegs (REG_GPR) >= nr) + return 0; + } } /* it will cause a spil */ @@ -1154,13 +1154,13 @@ again: for (i = 0; i < count; i++) { for (j = 0; j < count; j++) - { - if (result->regs[i] == opsym->regs[j] && i != j) - { - shared = 1; - goto xchgPositions; - } - } + { + if (result->regs[i] == opsym->regs[j] && i != j) + { + shared = 1; + goto xchgPositions; + } + } } xchgPositions: if (shared) @@ -1194,7 +1194,7 @@ verifyRegsAssigned (operand *op, iCode * ic) if (sym->regs[0]) return; werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT, - sym->prereqv ? sym->prereqv->name : sym->name); + sym->prereqv ? sym->prereqv->name : sym->name); spillThis (sym); } @@ -1211,202 +1211,202 @@ serialRegAssign (eBBlock ** ebbs, int count) /* for all blocks */ for (i = 0; i < count; i++) { - iCode *ic; + iCode *ic; - if (ebbs[i]->noPath && - (ebbs[i]->entryLabel != entryLabel && - ebbs[i]->entryLabel != returnLabel)) - continue; + if (ebbs[i]->noPath && + (ebbs[i]->entryLabel != entryLabel && + ebbs[i]->entryLabel != returnLabel)) + continue; - /* of all instructions do */ - for (ic = ebbs[i]->sch; ic; ic = ic->next) { + /* of all instructions do */ + for (ic = ebbs[i]->sch; ic; ic = ic->next) { #if 1 - int reg; - - // update the registers in use at the start of this icode - for (reg=0; regriu &= ~(regshc08[reg].mask); - } else { - ic->riu |= (regshc08[reg].mask); - } - } + int reg; + + // update the registers in use at the start of this icode + for (reg=0; regriu &= ~(regshc08[reg].mask); + } else { + ic->riu |= (regshc08[reg].mask); + } + } #endif - /* if this is an ipop that means some live - range will have to be assigned again */ - if (ic->op == IPOP) - reassignLR (IC_LEFT (ic)); - - /* if result is present && is a true symbol */ - if (IC_RESULT (ic) && ic->op != IFX && - IS_TRUE_SYMOP (IC_RESULT (ic))) - OP_SYMBOL (IC_RESULT (ic))->allocreq++; - - /* take away registers from live - ranges that end at this instruction */ - deassignLRs (ic, ebbs[i]); - - /* some don't need registers */ - if (SKIP_IC2 (ic) || - ic->op == JUMPTABLE || - ic->op == IFX || - ic->op == IPUSH || - ic->op == IPOP || - (IC_RESULT (ic) && POINTER_SET (ic))) - continue; - - /* now we need to allocate registers - only for the result */ - if (IC_RESULT (ic)) { - symbol *sym = OP_SYMBOL (IC_RESULT (ic)); - bitVect *spillable; - int willCS; - int j; - int ptrRegSet = 0; - - /* Make sure any spill location is definately allocated */ - if (sym->isspilt && !sym->remat && sym->usl.spillLoc && - !sym->usl.spillLoc->allocreq) { - sym->usl.spillLoc->allocreq++; - } + /* if this is an ipop that means some live + range will have to be assigned again */ + if (ic->op == IPOP) + reassignLR (IC_LEFT (ic)); + + /* if result is present && is a true symbol */ + if (IC_RESULT (ic) && ic->op != IFX && + IS_TRUE_SYMOP (IC_RESULT (ic))) + OP_SYMBOL (IC_RESULT (ic))->allocreq++; + + /* take away registers from live + ranges that end at this instruction */ + deassignLRs (ic, ebbs[i]); + + /* some don't need registers */ + if (SKIP_IC2 (ic) || + ic->op == JUMPTABLE || + ic->op == IFX || + ic->op == IPUSH || + ic->op == IPOP || + (IC_RESULT (ic) && POINTER_SET (ic))) + continue; + + /* now we need to allocate registers + only for the result */ + if (IC_RESULT (ic)) { + symbol *sym = OP_SYMBOL (IC_RESULT (ic)); + bitVect *spillable; + int willCS; + int j; + int ptrRegSet = 0; + + /* Make sure any spill location is definately allocated */ + if (sym->isspilt && !sym->remat && sym->usl.spillLoc && + !sym->usl.spillLoc->allocreq) { + sym->usl.spillLoc->allocreq++; + } /* if it does not need or is spilt - or is already assigned to registers - or will not live beyond this instructions */ - if (!sym->nRegs || - sym->isspilt || - bitVectBitValue (_G.regAssigned, sym->key) || - sym->liveTo <= ic->seq) - continue; - - /* if some liverange has been spilt at the block level - and this one live beyond this block then spil this - to be safe */ - if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq) { - spillThis (sym); - continue; - } - /* if trying to allocate this will cause - a spill and there is nothing to spill - or this one is rematerializable then - spill this one */ - willCS = willCauseSpill (sym->nRegs, sym->regType); - spillable = computeSpillable (ic); - if (sym->remat || (willCS && bitVectIsZero (spillable))) { - spillThis (sym); - continue; - } - - /* If the live range preceeds the point of definition - then ideally we must take into account registers that - have been allocated after sym->liveFrom but freed - before ic->seq. This is complicated, so spill this - symbol instead and let fillGaps handle the allocation. */ - if (sym->liveFrom < ic->seq) { - spillThis (sym); - continue; - } - - /* if it has a spillocation & is used less than - all other live ranges then spill this */ - if (willCS) { - if (sym->usl.spillLoc) { - symbol *leastUsed = leastUsedLR (liveRangesWith (spillable, - allLRs, ebbs[i], ic)); - if (leastUsed && leastUsed->used > sym->used) { - spillThis (sym); - continue; - } - } else { - /* if none of the liveRanges have a spillLocation then better - to spill this one than anything else already assigned to registers */ - if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) { - /* if this is local to this block then we might find a block spil */ - if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) { - spillThis (sym); - continue; - } - } - } - } - /* if we need ptr regs for the right side - then mark it */ - if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)) - && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE) { - hc08_ptrRegReq++; - ptrRegSet = 1; - } - /* else we assign registers to it */ - _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key); - _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key); - - for (j = 0; j < sym->nRegs; j++) { - if (sym->regType == REG_PTR) - sym->regs[j] = getRegPtr (ic, ebbs[i], sym); - else - sym->regs[j] = getRegGpr (ic, ebbs[i], sym); - - /* if the allocation failed which means - this was spilt then break */ - if (!sym->regs[j]) { - break; - } - } - - /* if it shares registers with operands make sure - that they are in the same position */ - if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) && - OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=') { - positionRegs (OP_SYMBOL (IC_RESULT (ic)), - OP_SYMBOL (IC_LEFT (ic))); - } - /* do the same for the right operand */ - if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) && - OP_SYMBOL (IC_RIGHT (ic))->nRegs) { - positionRegs (OP_SYMBOL (IC_RESULT (ic)), - OP_SYMBOL (IC_RIGHT (ic))); - } - - if (ptrRegSet) { - hc08_ptrRegReq--; - ptrRegSet = 0; - } - - } - } + or is already assigned to registers + or will not live beyond this instructions */ + if (!sym->nRegs || + sym->isspilt || + bitVectBitValue (_G.regAssigned, sym->key) || + sym->liveTo <= ic->seq) + continue; + + /* if some liverange has been spilt at the block level + and this one live beyond this block then spil this + to be safe */ + if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq) { + spillThis (sym); + continue; + } + /* if trying to allocate this will cause + a spill and there is nothing to spill + or this one is rematerializable then + spill this one */ + willCS = willCauseSpill (sym->nRegs, sym->regType); + spillable = computeSpillable (ic); + if (sym->remat || (willCS && bitVectIsZero (spillable))) { + spillThis (sym); + continue; + } + + /* If the live range preceeds the point of definition + then ideally we must take into account registers that + have been allocated after sym->liveFrom but freed + before ic->seq. This is complicated, so spill this + symbol instead and let fillGaps handle the allocation. */ + if (sym->liveFrom < ic->seq) { + spillThis (sym); + continue; + } + + /* if it has a spillocation & is used less than + all other live ranges then spill this */ + if (willCS) { + if (sym->usl.spillLoc) { + symbol *leastUsed = leastUsedLR (liveRangesWith (spillable, + allLRs, ebbs[i], ic)); + if (leastUsed && leastUsed->used > sym->used) { + spillThis (sym); + continue; + } + } else { + /* if none of the liveRanges have a spillLocation then better + to spill this one than anything else already assigned to registers */ + if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) { + /* if this is local to this block then we might find a block spil */ + if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) { + spillThis (sym); + continue; + } + } + } + } + /* if we need ptr regs for the right side + then mark it */ + if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)) + && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE) { + hc08_ptrRegReq++; + ptrRegSet = 1; + } + /* else we assign registers to it */ + _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key); + _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key); + + for (j = 0; j < sym->nRegs; j++) { + if (sym->regType == REG_PTR) + sym->regs[j] = getRegPtr (ic, ebbs[i], sym); + else + sym->regs[j] = getRegGpr (ic, ebbs[i], sym); + + /* if the allocation failed which means + this was spilt then break */ + if (!sym->regs[j]) { + break; + } + } + + /* if it shares registers with operands make sure + that they are in the same position */ + if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) && + OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=') { + positionRegs (OP_SYMBOL (IC_RESULT (ic)), + OP_SYMBOL (IC_LEFT (ic))); + } + /* do the same for the right operand */ + if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) && + OP_SYMBOL (IC_RIGHT (ic))->nRegs) { + positionRegs (OP_SYMBOL (IC_RESULT (ic)), + OP_SYMBOL (IC_RIGHT (ic))); + } + + if (ptrRegSet) { + hc08_ptrRegReq--; + ptrRegSet = 0; + } + + } + } } /* Check for and fix any problems with uninitialized operands */ for (i = 0; i < count; i++) { - iCode *ic; - - if (ebbs[i]->noPath && - (ebbs[i]->entryLabel != entryLabel && - ebbs[i]->entryLabel != returnLabel)) - continue; - - for (ic = ebbs[i]->sch; ic; ic = ic->next) - { - if (SKIP_IC2 (ic)) - continue; - - if (ic->op == IFX) - { - verifyRegsAssigned (IC_COND (ic), ic); - continue; - } - - if (ic->op == JUMPTABLE) - { - verifyRegsAssigned (IC_JTCOND (ic), ic); - continue; - } - - verifyRegsAssigned (IC_RESULT (ic), ic); - verifyRegsAssigned (IC_LEFT (ic), ic); - verifyRegsAssigned (IC_RIGHT (ic), ic); + iCode *ic; + + if (ebbs[i]->noPath && + (ebbs[i]->entryLabel != entryLabel && + ebbs[i]->entryLabel != returnLabel)) + continue; + + for (ic = ebbs[i]->sch; ic; ic = ic->next) + { + if (SKIP_IC2 (ic)) + continue; + + if (ic->op == IFX) + { + verifyRegsAssigned (IC_COND (ic), ic); + continue; + } + + if (ic->op == JUMPTABLE) + { + verifyRegsAssigned (IC_JTCOND (ic), ic); + continue; + } + + verifyRegsAssigned (IC_RESULT (ic), ic); + verifyRegsAssigned (IC_LEFT (ic), ic); + verifyRegsAssigned (IC_RIGHT (ic), ic); } } @@ -1424,99 +1424,99 @@ static void fillGaps() /* look for liveranges that were spilt by the allocator */ for (sym = hTabFirstItem(liveRanges,&key) ; sym ; - sym = hTabNextItem(liveRanges,&key)) { - - int i; - int pdone = 0; - - if (!sym->spillA || !sym->clashes || sym->remat) continue ; - - /* find the liveRanges this one clashes with, that are - still assigned to registers & mark the registers as used*/ - for ( i = 0 ; i < sym->clashes->size ; i ++) { - int k; - symbol *clr; - - if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */ - bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */ - continue ; - - clr = hTabItemWithKey(liveRanges,i); - assert(clr); - - /* mark these registers as used */ - for (k = 0 ; k < clr->nRegs ; k++ ) - hc08_useReg(clr->regs[k]); - } - - if (willCauseSpill(sym->nRegs,sym->regType)) { - /* NOPE :( clear all registers & and continue */ - freeAllRegs(); - continue ; - } - - /* THERE IS HOPE !!!! */ - for (i=0; i < sym->nRegs ; i++ ) { - if (sym->regType == REG_PTR) - sym->regs[i] = getRegPtrNoSpil (); - else - sym->regs[i] = getRegGprNoSpil (); - } - - /* for all its definitions check if the registers - allocated needs positioning NOTE: we can position - only ONCE if more than One positioning required - then give up */ - sym->isspilt = 0; - for (i = 0 ; i < sym->defs->size ; i++ ) { - if (bitVectBitValue(sym->defs,i)) { - iCode *ic; - if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ; - if (SKIP_IC(ic)) continue; - assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */ - /* if left is assigned to registers */ - if (IS_SYMOP(IC_LEFT(ic)) && - bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) { - pdone += positionRegs(sym,OP_SYMBOL(IC_LEFT(ic))); - } - if (IS_SYMOP(IC_RIGHT(ic)) && - bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) { - pdone += positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic))); - } - if (pdone > 1) break; - } - } - for (i = 0 ; i < sym->uses->size ; i++ ) { - if (bitVectBitValue(sym->uses,i)) { - iCode *ic; - if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ; - if (SKIP_IC(ic)) continue; - if (!IS_ASSIGN_ICODE(ic)) continue ; - - /* if result is assigned to registers */ - if (IS_SYMOP(IC_RESULT(ic)) && - bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) { - pdone += positionRegs(sym,OP_SYMBOL(IC_RESULT(ic))); - } - if (pdone > 1) break; - } - } - /* had to position more than once GIVE UP */ - if (pdone > 1) { - /* UNDO all the changes we made to try this */ - sym->isspilt = 1; - for (i=0; i < sym->nRegs ; i++ ) { - sym->regs[i] = NULL; - } - freeAllRegs(); - D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN")); - continue ; - } - D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN")); - _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key); - sym->isspilt = sym->spillA = 0 ; - sym->usl.spillLoc->allocreq--; - freeAllRegs(); + sym = hTabNextItem(liveRanges,&key)) { + + int i; + int pdone = 0; + + if (!sym->spillA || !sym->clashes || sym->remat) continue ; + + /* find the liveRanges this one clashes with, that are + still assigned to registers & mark the registers as used*/ + for ( i = 0 ; i < sym->clashes->size ; i ++) { + int k; + symbol *clr; + + if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */ + bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */ + continue ; + + clr = hTabItemWithKey(liveRanges,i); + assert(clr); + + /* mark these registers as used */ + for (k = 0 ; k < clr->nRegs ; k++ ) + hc08_useReg(clr->regs[k]); + } + + if (willCauseSpill(sym->nRegs,sym->regType)) { + /* NOPE :( clear all registers & and continue */ + freeAllRegs(); + continue ; + } + + /* THERE IS HOPE !!!! */ + for (i=0; i < sym->nRegs ; i++ ) { + if (sym->regType == REG_PTR) + sym->regs[i] = getRegPtrNoSpil (); + else + sym->regs[i] = getRegGprNoSpil (); + } + + /* for all its definitions check if the registers + allocated needs positioning NOTE: we can position + only ONCE if more than One positioning required + then give up */ + sym->isspilt = 0; + for (i = 0 ; i < sym->defs->size ; i++ ) { + if (bitVectBitValue(sym->defs,i)) { + iCode *ic; + if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ; + if (SKIP_IC(ic)) continue; + assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */ + /* if left is assigned to registers */ + if (IS_SYMOP(IC_LEFT(ic)) && + bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) { + pdone += positionRegs(sym,OP_SYMBOL(IC_LEFT(ic))); + } + if (IS_SYMOP(IC_RIGHT(ic)) && + bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) { + pdone += positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic))); + } + if (pdone > 1) break; + } + } + for (i = 0 ; i < sym->uses->size ; i++ ) { + if (bitVectBitValue(sym->uses,i)) { + iCode *ic; + if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ; + if (SKIP_IC(ic)) continue; + if (!IS_ASSIGN_ICODE(ic)) continue ; + + /* if result is assigned to registers */ + if (IS_SYMOP(IC_RESULT(ic)) && + bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) { + pdone += positionRegs(sym,OP_SYMBOL(IC_RESULT(ic))); + } + if (pdone > 1) break; + } + } + /* had to position more than once GIVE UP */ + if (pdone > 1) { + /* UNDO all the changes we made to try this */ + sym->isspilt = 1; + for (i=0; i < sym->nRegs ; i++ ) { + sym->regs[i] = NULL; + } + freeAllRegs(); + D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN")); + continue ; + } + D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN")); + _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key); + sym->isspilt = sym->spillA = 0 ; + sym->usl.spillLoc->allocreq--; + freeAllRegs(); } } @@ -1546,7 +1546,7 @@ hc08_rUmaskForOp (operand * op) for (j = 0; j < sym->nRegs; j++) { rumask = bitVectSetBit (rumask, - sym->regs[j]->rIdx); + sym->regs[j]->rIdx); } return rumask; @@ -1564,7 +1564,7 @@ regsUsedIniCode (iCode * ic) if (ic->op == IFX) { rmask = bitVectUnion (rmask, - hc08_rUmaskForOp (IC_COND (ic))); + hc08_rUmaskForOp (IC_COND (ic))); goto ret; } @@ -1572,7 +1572,7 @@ regsUsedIniCode (iCode * ic) if (ic->op == JUMPTABLE) { rmask = bitVectUnion (rmask, - hc08_rUmaskForOp (IC_JTCOND (ic))); + hc08_rUmaskForOp (IC_JTCOND (ic))); goto ret; } @@ -1580,16 +1580,16 @@ regsUsedIniCode (iCode * ic) /* of all other cases */ if (IC_LEFT (ic)) rmask = bitVectUnion (rmask, - hc08_rUmaskForOp (IC_LEFT (ic))); + hc08_rUmaskForOp (IC_LEFT (ic))); if (IC_RIGHT (ic)) rmask = bitVectUnion (rmask, - hc08_rUmaskForOp (IC_RIGHT (ic))); + hc08_rUmaskForOp (IC_RIGHT (ic))); if (IC_RESULT (ic)) rmask = bitVectUnion (rmask, - hc08_rUmaskForOp (IC_RESULT (ic))); + hc08_rUmaskForOp (IC_RESULT (ic))); ret: return rmask; @@ -1609,59 +1609,59 @@ createRegMask (eBBlock ** ebbs, int count) iCode *ic; if (ebbs[i]->noPath && - (ebbs[i]->entryLabel != entryLabel && - ebbs[i]->entryLabel != returnLabel)) - continue; + (ebbs[i]->entryLabel != entryLabel && + ebbs[i]->entryLabel != returnLabel)) + continue; /* for all instructions */ for (ic = ebbs[i]->sch; ic; ic = ic->next) - { - - int j; - - if (SKIP_IC2 (ic) || !ic->rlive) - continue; - - /* first mark the registers used in this - instruction */ - ic->rUsed = regsUsedIniCode (ic); - _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed); - - /* now create the register mask for those - registers that are in use : this is a - super set of ic->rUsed */ - ic->rMask = newBitVect (hc08_nRegs + 1); - - /* for all live Ranges alive at this point */ - for (j = 1; j < ic->rlive->size; j++) - { - symbol *sym; - int k; - - /* if not alive then continue */ - if (!bitVectBitValue (ic->rlive, j)) - continue; - - /* find the live range we are interested in */ - if (!(sym = hTabItemWithKey (liveRanges, j))) - { - werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "createRegMask cannot find live range"); - fprintf(stderr, "\tmissing live range: key=%d\n", j); - exit (0); - } - - /* if no register assigned to it */ - if (!sym->nRegs || sym->isspilt) - continue; - - /* for all the registers allocated to it */ - for (k = 0; k < sym->nRegs; k++) - if (sym->regs[k]) - ic->rMask = - bitVectSetBit (ic->rMask, sym->regs[k]->rIdx); - } - } + { + + int j; + + if (SKIP_IC2 (ic) || !ic->rlive) + continue; + + /* first mark the registers used in this + instruction */ + ic->rUsed = regsUsedIniCode (ic); + _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed); + + /* now create the register mask for those + registers that are in use : this is a + super set of ic->rUsed */ + ic->rMask = newBitVect (hc08_nRegs + 1); + + /* for all live Ranges alive at this point */ + for (j = 1; j < ic->rlive->size; j++) + { + symbol *sym; + int k; + + /* if not alive then continue */ + if (!bitVectBitValue (ic->rlive, j)) + continue; + + /* find the live range we are interested in */ + if (!(sym = hTabItemWithKey (liveRanges, j))) + { + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, + "createRegMask cannot find live range"); + fprintf(stderr, "\tmissing live range: key=%d\n", j); + exit (0); + } + + /* if no register assigned to it */ + if (!sym->nRegs || sym->isspilt) + continue; + + /* for all the registers allocated to it */ + for (k = 0; k < sym->nRegs; k++) + if (sym->regs[k]) + ic->rMask = + bitVectSetBit (ic->rMask, sym->regs[k]->rIdx); + } + } } } @@ -1680,7 +1680,7 @@ rematStr (symbol * sym) if (ic->op == '+') { offset += (int) operandLitValue (IC_RIGHT (ic)); - ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode; + ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode; continue; } @@ -1688,14 +1688,14 @@ rematStr (symbol * sym) if (ic->op == '-') { offset -= (int) operandLitValue (IC_RIGHT (ic)); - ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode; + ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode; continue; } /* cast then continue */ if (IS_CAST_ICODE(ic)) { - ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode; - continue; + ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode; + continue; } /* we reached the end */ break; @@ -1743,74 +1743,74 @@ regTypeNum (eBBlock *ebbs) /* if used zero times then no registers needed */ if ((sym->liveTo - sym->liveFrom) == 0) - continue; + continue; /* if the live range is a temporary */ if (sym->isitmp) - { - - /* if the type is marked as a conditional */ - if (sym->regType == REG_CND) - continue; - - /* if used in return only then we don't - need registers */ - if (sym->ruonly || sym->accuse) - { - if (IS_AGGREGATE (sym->type) || sym->isptr) - sym->type = aggrToPtr (sym->type, FALSE); - continue; - } - - /* if the symbol has only one definition & - that definition is a get_pointer */ - if (bitVectnBitsOn (sym->defs) == 1 && - (ic = hTabItemWithKey (iCodehTab, - bitVectFirstBit (sym->defs))) && - POINTER_GET (ic) && - !IS_BITVAR (sym->etype) && - (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER)) - { - - if (ptrPseudoSymSafe (sym, ic)) - { - ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic)))); - continue; - } - - /* if in data space or idata space then try to - allocate pointer register */ - - } - - /* if not then we require registers */ - sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ? - getSize (sym->type = aggrToPtr (sym->type, FALSE)) : - getSize (sym->type)); - - if (sym->nRegs > 4) - { - fprintf (stderr, "allocated more than 4 or 0 registers for type "); - printTypeChain (sym->type, stderr); - fprintf (stderr, "\n"); - } - - /* determine the type of register required */ - if (sym->nRegs == 1 && - IS_PTR (sym->type) && - sym->uptr) - sym->regType = REG_PTR; - else - sym->regType = REG_GPR; - - } + { + + /* if the type is marked as a conditional */ + if (sym->regType == REG_CND) + continue; + + /* if used in return only then we don't + need registers */ + if (sym->ruonly || sym->accuse) + { + if (IS_AGGREGATE (sym->type) || sym->isptr) + sym->type = aggrToPtr (sym->type, FALSE); + continue; + } + + /* if the symbol has only one definition & + that definition is a get_pointer */ + if (bitVectnBitsOn (sym->defs) == 1 && + (ic = hTabItemWithKey (iCodehTab, + bitVectFirstBit (sym->defs))) && + POINTER_GET (ic) && + !IS_BITVAR (sym->etype) && + (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER)) + { + + if (ptrPseudoSymSafe (sym, ic)) + { + ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic)))); + continue; + } + + /* if in data space or idata space then try to + allocate pointer register */ + + } + + /* if not then we require registers */ + sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ? + getSize (sym->type = aggrToPtr (sym->type, FALSE)) : + getSize (sym->type)); + + if (sym->nRegs > 4) + { + fprintf (stderr, "allocated more than 4 or 0 registers for type "); + printTypeChain (sym->type, stderr); + fprintf (stderr, "\n"); + } + + /* determine the type of register required */ + if (sym->nRegs == 1 && + IS_PTR (sym->type) && + sym->uptr) + sym->regType = REG_PTR; + else + sym->regType = REG_GPR; + + } else - /* for the first run we don't provide */ - /* registers for true symbols we will */ - /* see how things go */ - sym->nRegs = 0; - } + /* for the first run we don't provide */ + /* registers for true symbols we will */ + /* see how things go */ + sym->nRegs = 0; + } } @@ -1855,55 +1855,55 @@ farSpacePackable (iCode * ic) { /* if the definition is a call then no */ if ((dic->op == CALL || dic->op == PCALL) && - IC_RESULT (dic)->key == IC_RIGHT (ic)->key) - { - return NULL; - } + IC_RESULT (dic)->key == IC_RIGHT (ic)->key) + { + return NULL; + } /* if shift by unknown amount then not */ if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) && - IC_RESULT (dic)->key == IC_RIGHT (ic)->key) - return NULL; + IC_RESULT (dic)->key == IC_RIGHT (ic)->key) + return NULL; #if 0 /* if pointer get and size > 1 */ if (POINTER_GET (dic) && - getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1) - return NULL; + getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1) + return NULL; if (POINTER_SET (dic) && - getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1) - return NULL; + getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1) + return NULL; #endif /* if any three is a true symbol in far space */ if (IC_RESULT (dic) && - IS_TRUE_SYMOP (IC_RESULT (dic)) /* && - isOperandInFarSpace (IC_RESULT (dic)) */) - return NULL; + IS_TRUE_SYMOP (IC_RESULT (dic)) /* && + isOperandInFarSpace (IC_RESULT (dic)) */) + return NULL; if (IC_RIGHT (dic) && - IS_TRUE_SYMOP (IC_RIGHT (dic)) /* && - isOperandInFarSpace (IC_RIGHT (dic)) */ && - !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic))) - return NULL; + IS_TRUE_SYMOP (IC_RIGHT (dic)) /* && + isOperandInFarSpace (IC_RIGHT (dic)) */ && + !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic))) + return NULL; if (IC_LEFT (dic) && - IS_TRUE_SYMOP (IC_LEFT (dic)) /* && - isOperandInFarSpace (IC_LEFT (dic)) */ && - !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic))) - return NULL; + IS_TRUE_SYMOP (IC_LEFT (dic)) /* && + isOperandInFarSpace (IC_LEFT (dic)) */ && + !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic))) + return NULL; if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic))) - { - if ((dic->op == LEFT_OP || - dic->op == RIGHT_OP || - dic->op == '-') && - IS_OP_LITERAL (IC_RIGHT (dic))) - return NULL; - else - return dic; - } + { + if ((dic->op == LEFT_OP || + dic->op == RIGHT_OP || + dic->op == '-') && + IS_OP_LITERAL (IC_RIGHT (dic))) + return NULL; + else + return dic; + } } return NULL; @@ -1933,14 +1933,14 @@ packRegsForLiteral (iCode * ic) if (!uic) continue; if (uic->op != IFX && uic->op != JUMPTABLE) - { - if (IC_LEFT (uic) && IC_LEFT (uic)->key == IC_RESULT (ic)->key) - ReplaceOpWithCheaperOp(&IC_LEFT(uic), IC_RIGHT(ic)); - if (IC_RIGHT (uic) && IC_RIGHT (uic)->key == IC_RESULT (ic)->key) - ReplaceOpWithCheaperOp(&IC_RIGHT(uic), IC_RIGHT(ic)); - if (IC_RESULT (uic) && IC_RESULT (uic)->key == IC_RESULT (ic)->key) - ReplaceOpWithCheaperOp(&IC_RESULT(uic), IC_RIGHT(ic)); - } + { + if (IC_LEFT (uic) && IC_LEFT (uic)->key == IC_RESULT (ic)->key) + ReplaceOpWithCheaperOp(&IC_LEFT(uic), IC_RIGHT(ic)); + if (IC_RIGHT (uic) && IC_RIGHT (uic)->key == IC_RESULT (ic)->key) + ReplaceOpWithCheaperOp(&IC_RIGHT(uic), IC_RIGHT(ic)); + if (IC_RESULT (uic) && IC_RESULT (uic)->key == IC_RESULT (ic)->key) + ReplaceOpWithCheaperOp(&IC_RESULT(uic), IC_RIGHT(ic)); + } } } @@ -1977,69 +1977,69 @@ packRegsForAssign (iCode * ic, eBBlock * ebp) { #if 0 /* jwk: This collides with 1.43 but I really see no need for - this anymore. It fixes bug #716790 and substantially improves - redundant register usage around function calls. + this anymore. It fixes bug #716790 and substantially improves + redundant register usage around function calls. */ /* if there is a function call then don't pack it */ if ((dic->op == CALL || dic->op == PCALL)) - { - dic = NULL; - break; - } + { + dic = NULL; + break; + } #endif /* Don't move an assignment out of a critical block */ if (dic->op == CRITICAL) - { - dic = NULL; - break; - } + { + dic = NULL; + break; + } if (SKIP_IC2 (dic)) - continue; + continue; if (IS_TRUE_SYMOP (IC_RESULT (dic)) && - IS_OP_VOLATILE (IC_RESULT (dic))) - { - dic = NULL; - break; - } + IS_OP_VOLATILE (IC_RESULT (dic))) + { + dic = NULL; + break; + } if (IS_SYMOP (IC_RESULT (dic)) && - IC_RESULT (dic)->key == IC_RIGHT (ic)->key) - { - if (POINTER_SET (dic)) - dic = NULL; + IC_RESULT (dic)->key == IC_RIGHT (ic)->key) + { + if (POINTER_SET (dic)) + dic = NULL; - break; - } + break; + } if (IS_SYMOP (IC_RIGHT (dic)) && - (IC_RIGHT (dic)->key == IC_RESULT (ic)->key || - IC_RIGHT (dic)->key == IC_RIGHT (ic)->key)) - { - dic = NULL; - break; - } + (IC_RIGHT (dic)->key == IC_RESULT (ic)->key || + IC_RIGHT (dic)->key == IC_RIGHT (ic)->key)) + { + dic = NULL; + break; + } if (IS_SYMOP (IC_LEFT (dic)) && - (IC_LEFT (dic)->key == IC_RESULT (ic)->key || - IC_LEFT (dic)->key == IC_RIGHT (ic)->key)) - { - dic = NULL; - break; - } + (IC_LEFT (dic)->key == IC_RESULT (ic)->key || + IC_LEFT (dic)->key == IC_RIGHT (ic)->key)) + { + dic = NULL; + break; + } if (POINTER_SET (dic) && - IC_RESULT (dic)->key == IC_RESULT (ic)->key) - { - dic = NULL; - break; - } + IC_RESULT (dic)->key == IC_RESULT (ic)->key) + { + dic = NULL; + break; + } } if (!dic) - return 0; /* did not find */ + return 0; /* did not find */ /* if assignment then check that right is not a bit */ if (ASSIGNMENT (ic) && !POINTER_SET (ic)) @@ -2064,14 +2064,14 @@ packRegsForAssign (iCode * ic, eBBlock * ebp) /* the operation has only one symbol operator then we can pack */ if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) || - (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic)))) - goto pack; + (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic)))) + goto pack; if (!((IC_LEFT (dic) && - IC_RESULT (ic)->key == IC_LEFT (dic)->key) || - (IC_RIGHT (dic) && - IC_RESULT (ic)->key == IC_RIGHT (dic)->key))) - return 0; + IC_RESULT (ic)->key == IC_LEFT (dic)->key) || + (IC_RIGHT (dic) && + IC_RESULT (ic)->key == IC_RIGHT (dic)->key))) + return 0; } pack: /* found the definition */ @@ -2093,7 +2093,7 @@ pack: { bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key); if (IS_ITEMP (IC_RESULT (dic))) - bitVectSetBit (sic->rlive, IC_RESULT (dic)->key); + bitVectSetBit (sic->rlive, IC_RESULT (dic)->key); } remiCodeFromeBBlock (ebp, ic); @@ -2127,21 +2127,21 @@ findAssignToSym (operand * op, iCode * ic) /* if definition by assignment */ if (dic->op == '=' && - !POINTER_SET (dic) && - IC_RESULT (dic)->key == op->key + !POINTER_SET (dic) && + IC_RESULT (dic)->key == op->key && IS_TRUE_SYMOP(IC_RIGHT(dic)) - ) - break; /* found where this temp was defined */ + ) + break; /* found where this temp was defined */ /* if we find an usage then we cannot delete it */ if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key) - return NULL; + return NULL; if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key) - return NULL; + return NULL; if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key) - return NULL; + return NULL; } if (!dic) @@ -2174,9 +2174,9 @@ findAssignToSym (operand * op, iCode * ic) { if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key && - IC_LEFT (ic)->key != IC_RIGHT (dic)->key && - IC_RIGHT (ic)->key != IC_RIGHT (dic)->key) - return NULL; + IC_LEFT (ic)->key != IC_RIGHT (dic)->key && + IC_RIGHT (ic)->key != IC_RIGHT (dic)->key) + return NULL; } #endif @@ -2187,9 +2187,9 @@ findAssignToSym (operand * op, iCode * ic) iCode *sic = dic->next; for (; sic != ic; sic = sic->next) - if (IC_RESULT (sic) && - IC_RESULT (sic)->key == IC_RIGHT (dic)->key) - return NULL; + if (IC_RESULT (sic) && + IC_RESULT (sic)->key == IC_RIGHT (dic)->key) + return NULL; } return dic; @@ -2253,11 +2253,11 @@ packRegsForSupport (iCode * ic, eBBlock * ebp) dic = findAssignToSym (IC_LEFT (ic), ic); if (dic) - { - /* found it we need to remove it from the block */ - reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic)); - changes++; - } + { + /* found it we need to remove it from the block */ + reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic)); + changes++; + } } /* do the same for the right operand */ @@ -2267,11 +2267,11 @@ packRegsForSupport (iCode * ic, eBBlock * ebp) iCode *dic = findAssignToSym (IC_RIGHT (ic), ic); if (dic) - { - /* found it we need to remove it from the block */ - reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic)); - changes++; - } + { + /* found it we need to remove it from the block */ + reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic)); + changes++; + } } return changes; @@ -2315,25 +2315,25 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp) function or does not contain any variables in far space */ uses = bitVectCopy (OP_USES (op)); - bitVectUnSetBit (uses, ic->key); /* take away this iCode */ - if (!bitVectIsZero (uses)) /* has other uses */ + bitVectUnSetBit (uses, ic->key); /* take away this iCode */ + if (!bitVectIsZero (uses)) /* has other uses */ return NULL; /* if it has only one defintion */ if (bitVectnBitsOn (OP_DEFS (op)) > 1) - return NULL; /* has more than one definition */ + return NULL; /* has more than one definition */ /* get that definition */ if (!(dic = - hTabItemWithKey (iCodehTab, - bitVectFirstBit (OP_DEFS (op))))) + hTabItemWithKey (iCodehTab, + bitVectFirstBit (OP_DEFS (op))))) return NULL; /* if that only usage is a cast */ if (dic->op == CAST) { /* to a bigger type */ if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) > - getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) { + getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) { /* than we can not, since we cannot predict the usage of b & acc */ return NULL; } @@ -2342,18 +2342,18 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp) /* found the definition now check if it is local */ if (dic->seq < ebp->fSeq || dic->seq > ebp->lSeq) - return NULL; /* non-local */ + return NULL; /* non-local */ /* now check if it is the return from a function call */ if (dic->op == CALL || dic->op == PCALL) { if (ic->op != SEND && ic->op != RETURN && - !POINTER_SET(ic) && !POINTER_GET(ic)) - { - OP_SYMBOL (op)->ruonly = 1; - return dic; - } + !POINTER_SET(ic) && !POINTER_GET(ic)) + { + OP_SYMBOL (op)->ruonly = 1; + return dic; + } dic = dic->next; } @@ -2389,47 +2389,47 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp) /* if there is an intervening function call then no */ if (dic->op == CALL || dic->op == PCALL) - return NULL; + return NULL; /* if pointer set then make sure the pointer is one byte */ #if 0 if (POINTER_SET (dic) && - !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE))) - return NULL; + !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE))) + return NULL; if (POINTER_GET (dic) && - !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE))) - return NULL; + !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE))) + return NULL; #endif /* if address of & the result is remat the okay */ if (dic->op == ADDRESS_OF && - OP_SYMBOL (IC_RESULT (dic))->remat) - continue; + OP_SYMBOL (IC_RESULT (dic))->remat) + continue; /* if operand has size of three or more & this operation is a '*','/' or '%' then 'b' may cause a problem */ #if 0 if ((dic->op == '%' || dic->op == '/' || dic->op == '*') && - getSize (operandType (op)) >= 3) - return NULL; + getSize (operandType (op)) >= 3) + return NULL; #endif /* if left or right or result is in far space */ // if (isOperandInFarSpace (IC_LEFT (dic)) || -// isOperandInFarSpace (IC_RIGHT (dic)) || -// isOperandInFarSpace (IC_RESULT (dic)) || -// IS_OP_RUONLY (IC_LEFT (dic)) || -// IS_OP_RUONLY (IC_RIGHT (dic)) || -// IS_OP_RUONLY (IC_RESULT (dic))) -// { -// return NULL; -// } +// isOperandInFarSpace (IC_RIGHT (dic)) || +// isOperandInFarSpace (IC_RESULT (dic)) || +// IS_OP_RUONLY (IC_LEFT (dic)) || +// IS_OP_RUONLY (IC_RIGHT (dic)) || +// IS_OP_RUONLY (IC_RESULT (dic))) +// { +// return NULL; +// } // /* if left or right or result is on stack */ // if (isOperandOnStack(IC_LEFT(dic)) || -// isOperandOnStack(IC_RIGHT(dic)) || -// isOperandOnStack(IC_RESULT(dic))) { -// return NULL; +// isOperandOnStack(IC_RIGHT(dic)) || +// isOperandOnStack(IC_RESULT(dic))) { +// return NULL; // } } @@ -2497,16 +2497,16 @@ bool operandUsesAcc2(operand *op) return TRUE; /* duh! */ // if (IN_STACK(sym->etype) || sym->onStack || -// (SPIL_LOC(op) && SPIL_LOC(op)->onStack)) +// (SPIL_LOC(op) && SPIL_LOC(op)->onStack)) // return TRUE; /* acc is used to calc stack offset */ if (IS_ITEMP(op)) { - if (SPIL_LOC(op)) { - sym = SPIL_LOC(op); /* if spilled, look at spill location */ - } else { - return FALSE; /* more checks? */ - } + if (SPIL_LOC(op)) { + sym = SPIL_LOC(op); /* if spilled, look at spill location */ + } else { + return FALSE; /* more checks? */ + } } symspace = SPEC_OCLS(sym->etype); @@ -2533,7 +2533,7 @@ canDefAccResult (iCode * ic) { int size; - if (ic->op == IFX || ic->op == JUMPTABLE) /* these iCodes have no result */ + if (ic->op == IFX || ic->op == JUMPTABLE) /* these iCodes have no result */ return 0; if (POINTER_SET (ic)) @@ -2706,7 +2706,7 @@ packForPush (iCode * ic, eBBlock ** ebpp, int blockno) /* find the definition */ if (!(dic = hTabItemWithKey (iCodehTab, - bitVectFirstBit (OP_DEFS (IC_LEFT (ic)))))) + bitVectFirstBit (OP_DEFS (IC_LEFT (ic)))))) return; if (dic->op != '=' || POINTER_SET (dic)) @@ -2716,8 +2716,8 @@ packForPush (iCode * ic, eBBlock ** ebpp, int blockno) int i; for (i=0; iseq >= ebpp[i]->fSeq && dic->seq <= ebpp[i]->lSeq) { - ebp=ebpp[i]; - break; + ebp=ebpp[i]; + break; } } wassert (i!=blockno); // no way to recover from here @@ -2729,7 +2729,7 @@ packForPush (iCode * ic, eBBlock ** ebpp, int blockno) dbv = OP_DEFS(IC_RIGHT(dic)); for (lic = ic; lic && lic != dic ; lic = lic->prev) { if (bitVectBitValue(dbv,lic->key)) - return ; + return ; } /* make sure they have the same type */ if (IS_SPEC(operandType(IC_LEFT(ic)))) @@ -2738,8 +2738,8 @@ packForPush (iCode * ic, eBBlock ** ebpp, int blockno) sym_link *ditype=operandType(IC_RIGHT(dic)); if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) || - SPEC_LONG(itype)!=SPEC_LONG(ditype)) - return; + SPEC_LONG(itype)!=SPEC_LONG(ditype)) + return; } /* extend the live range of replaced operand if needed */ if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) { @@ -2776,14 +2776,14 @@ packRegisters (eBBlock ** ebpp, int blockno) /* .... */ /* TrueSym := iTempNN:1 */ for (ic = ebp->sch; ic; ic = ic->next) - { - /* find assignment of the form TrueSym := iTempNN:1 */ - if (ic->op == '=' && !POINTER_SET (ic) ) - change += packRegsForAssign (ic, ebp); - } + { + /* find assignment of the form TrueSym := iTempNN:1 */ + if (ic->op == '=' && !POINTER_SET (ic) ) + change += packRegsForAssign (ic, ebp); + } if (!change) - break; + break; } for (ic = ebp->sch; ic; ic = ic->next) @@ -2793,130 +2793,131 @@ packRegisters (eBBlock ** ebpp, int blockno) /* if this is an itemp & result of an address of a true sym then mark this as rematerialisable */ if (ic->op == ADDRESS_OF && - IS_ITEMP (IC_RESULT (ic)) && - IS_TRUE_SYMOP (IC_LEFT (ic)) && - bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 && - !OP_SYMBOL (IC_LEFT (ic))->onStack ) - { + IS_ITEMP (IC_RESULT (ic)) && + IS_TRUE_SYMOP (IC_LEFT (ic)) && + bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 && + !OP_SYMBOL (IC_LEFT (ic))->onStack ) + { - OP_SYMBOL (IC_RESULT (ic))->remat = 1; - OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; - OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; + OP_SYMBOL (IC_RESULT (ic))->remat = 1; + OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; + OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; - } + } #if 1 if (ic->op == '=' && !POINTER_SET (ic) && - IS_ITEMP (IC_RESULT (ic)) && - IS_VALOP (IC_RIGHT (ic)) && - bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) - { + IS_ITEMP (IC_RESULT (ic)) && + IS_VALOP (IC_RIGHT (ic)) && + bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) + { - OP_SYMBOL (IC_RESULT (ic))->remat = 1; - OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; - OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; + OP_SYMBOL (IC_RESULT (ic))->remat = 1; + OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; + OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; - } + } #endif /* if straight assignment then carry remat flag if this is the only definition */ if (ic->op == '=' && - !POINTER_SET (ic) && - IS_SYMOP (IC_RIGHT (ic)) && - OP_SYMBOL (IC_RIGHT (ic))->remat && - !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) && - bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1) - { - - OP_SYMBOL (IC_RESULT (ic))->remat = - OP_SYMBOL (IC_RIGHT (ic))->remat; - OP_SYMBOL (IC_RESULT (ic))->rematiCode = - OP_SYMBOL (IC_RIGHT (ic))->rematiCode; - } + !POINTER_SET (ic) && + IS_SYMOP (IC_RIGHT (ic)) && + OP_SYMBOL (IC_RIGHT (ic))->remat && + !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) && + bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1) + { + + OP_SYMBOL (IC_RESULT (ic))->remat = + OP_SYMBOL (IC_RIGHT (ic))->remat; + OP_SYMBOL (IC_RESULT (ic))->rematiCode = + OP_SYMBOL (IC_RIGHT (ic))->rematiCode; + } /* if cast to a generic pointer & the pointer being - cast is remat, then we can remat this cast as well */ + cast is remat, then we can remat this cast as well */ if (ic->op == CAST && - IS_SYMOP(IC_RIGHT(ic)) && - OP_SYMBOL(IC_RIGHT(ic))->remat && - bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) { - sym_link *to_type = operandType(IC_LEFT(ic)); - sym_link *from_type = operandType(IC_RIGHT(ic)); - if (IS_GENPTR(to_type) && IS_PTR(from_type)) { - OP_SYMBOL (IC_RESULT (ic))->remat = 1; - OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; - OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; - } + IS_SYMOP(IC_RIGHT(ic)) && + OP_SYMBOL(IC_RIGHT(ic))->remat && + bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) { + sym_link *to_type = operandType(IC_LEFT(ic)); + sym_link *from_type = operandType(IC_RIGHT(ic)); + if (IS_GENPTR(to_type) && IS_PTR(from_type)) { + OP_SYMBOL (IC_RESULT (ic))->remat = 1; + OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; + OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; + } } /* if this is a +/- operation with a rematerizable then mark this as rematerializable as well */ if ((ic->op == '+' || ic->op == '-') && - (IS_SYMOP (IC_LEFT (ic)) && - IS_ITEMP (IC_RESULT (ic)) && - IS_OP_LITERAL (IC_RIGHT (ic))) && - OP_SYMBOL (IC_LEFT (ic))->remat && - (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) && - bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) - { - OP_SYMBOL (IC_RESULT (ic))->remat = 1; - OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; - OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; - } + (IS_SYMOP (IC_LEFT (ic)) && + IS_ITEMP (IC_RESULT (ic)) && + IS_OP_LITERAL (IC_RIGHT (ic))) && + OP_SYMBOL (IC_LEFT (ic))->remat && + (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) && + bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) + { + OP_SYMBOL (IC_RESULT (ic))->remat = 1; + OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; + OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; + } /* mark the pointer usages */ - if (POINTER_SET (ic)) - OP_SYMBOL (IC_RESULT (ic))->uptr = 1; + if (POINTER_SET (ic) && + IS_SYMOP(IC_RESULT (ic))) + OP_SYMBOL (IC_RESULT (ic))->uptr = 1; if (POINTER_GET (ic) && - IS_SYMOP(IC_LEFT (ic))) - OP_SYMBOL (IC_LEFT (ic))->uptr = 1; + IS_SYMOP(IC_LEFT (ic))) + OP_SYMBOL (IC_LEFT (ic))->uptr = 1; if (!SKIP_IC2 (ic)) - { + { #if 0 - /* if we are using a symbol on the stack - then we should say hc08_ptrRegReq */ - if (ic->op == IFX && IS_SYMOP (IC_COND (ic))) - hc08_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack || - OP_SYMBOL (IC_COND (ic))->iaccess) ? 1 : 0); - else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic))) - hc08_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack || - OP_SYMBOL (IC_JTCOND (ic))->iaccess) ? 1 : 0); - else - { - if (IS_SYMOP (IC_LEFT (ic))) - hc08_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack || - OP_SYMBOL (IC_LEFT (ic))->iaccess) ? 1 : 0); - if (IS_SYMOP (IC_RIGHT (ic))) - hc08_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack || - OP_SYMBOL (IC_RIGHT (ic))->iaccess) ? 1 : 0); - if (IS_SYMOP (IC_RESULT (ic))) - hc08_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack || - OP_SYMBOL (IC_RESULT (ic))->iaccess) ? 1 : 0); - } + /* if we are using a symbol on the stack + then we should say hc08_ptrRegReq */ + if (ic->op == IFX && IS_SYMOP (IC_COND (ic))) + hc08_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack || + OP_SYMBOL (IC_COND (ic))->iaccess) ? 1 : 0); + else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic))) + hc08_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack || + OP_SYMBOL (IC_JTCOND (ic))->iaccess) ? 1 : 0); + else + { + if (IS_SYMOP (IC_LEFT (ic))) + hc08_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack || + OP_SYMBOL (IC_LEFT (ic))->iaccess) ? 1 : 0); + if (IS_SYMOP (IC_RIGHT (ic))) + hc08_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack || + OP_SYMBOL (IC_RIGHT (ic))->iaccess) ? 1 : 0); + if (IS_SYMOP (IC_RESULT (ic))) + hc08_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack || + OP_SYMBOL (IC_RESULT (ic))->iaccess) ? 1 : 0); + } #endif - } + } /* if the condition of an if instruction is defined in the previous instruction and - this is the only usage then + this is the only usage then mark the itemp as a conditional */ if ((IS_CONDITIONAL (ic) || - (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) && - ic->next && ic->next->op == IFX && - bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 && - isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) && - OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq) - { - OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND; - continue; - } + (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) && + ic->next && ic->next->op == IFX && + bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 && + isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) && + OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq) + { + OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND; + continue; + } #if 0 /* if the condition of an if instruction is defined in the previous GET_POINTER instruction and - this is the only usage then + this is the only usage then mark the itemp as accumulator use */ if ((POINTER_GET (ic) && getSize (operandType (IC_RESULT (ic))) <=1) && ic->next && ic->next->op == IFX && @@ -2966,34 +2967,34 @@ packRegisters (eBBlock ** ebpp, int blockno) /* reduce for support function calls */ if (ic->supportRtn || (ic->op != IFX && ic->op != JUMPTABLE)) - packRegsForSupport (ic, ebp); + packRegsForSupport (ic, ebp); #if 0 /* some cases the redundant moves can can be eliminated for return statements */ if ((ic->op == RETURN || (ic->op == SEND && ic->argreg == 1)) && - /* !isOperandInFarSpace (IC_LEFT (ic)) && */ - options.model == MODEL_SMALL) { - packRegsForOneuse (ic, IC_LEFT (ic), ebp); + /* !isOperandInFarSpace (IC_LEFT (ic)) && */ + options.model == MODEL_SMALL) { + packRegsForOneuse (ic, IC_LEFT (ic), ebp); } /* if pointer set & left has a size more than one and right is not in far space */ if (POINTER_SET (ic) && - /* !isOperandInFarSpace (IC_RIGHT (ic)) && */ - !OP_SYMBOL (IC_RESULT (ic))->remat && - !IS_OP_RUONLY (IC_RIGHT (ic)) - /* && getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1 */ ) - packRegsForOneuse (ic, IC_RESULT (ic), ebp); + /* !isOperandInFarSpace (IC_RIGHT (ic)) && */ + !OP_SYMBOL (IC_RESULT (ic))->remat && + !IS_OP_RUONLY (IC_RIGHT (ic)) + /* && getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1 */ ) + packRegsForOneuse (ic, IC_RESULT (ic), ebp); /* if pointer get */ if (POINTER_GET (ic) && - IS_SYMOP (IC_LEFT (ic)) && - /* !isOperandInFarSpace (IC_RESULT (ic)) && */ - !OP_SYMBOL (IC_LEFT (ic))->remat && - !IS_OP_RUONLY (IC_RESULT (ic)) - /* && getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1 */) - packRegsForOneuse (ic, IC_LEFT (ic), ebp); + IS_SYMOP (IC_LEFT (ic)) && + /* !isOperandInFarSpace (IC_RESULT (ic)) && */ + !OP_SYMBOL (IC_LEFT (ic))->remat && + !IS_OP_RUONLY (IC_RESULT (ic)) + /* && getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1 */) + packRegsForOneuse (ic, IC_LEFT (ic), ebp); /* if this is cast for intergral promotion then @@ -3002,54 +3003,54 @@ packRegisters (eBBlock ** ebpp, int blockno) the result of that arithmetic operation with this result and get rid of the cast */ if (ic->op == CAST) - { - sym_link *fromType = operandType (IC_RIGHT (ic)); - sym_link *toType = operandType (IC_LEFT (ic)); - - if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) && - getSize (fromType) != getSize (toType) && - SPEC_USIGN (fromType) == SPEC_USIGN (toType)) - { - - iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp); - if (dic) - { - if (IS_ARITHMETIC_OP (dic)) - { - bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key); - ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic)); - remiCodeFromeBBlock (ebp, ic); - bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key); - hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL); - OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key); - ic = ic->prev; - } - else - OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0; - } - } - else - { - - /* if the type from and type to are the same - then if this is the only use then packit */ - if (compareType (operandType (IC_RIGHT (ic)), - operandType (IC_LEFT (ic))) == 1) - { - iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp); - if (dic) - { - bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key); - ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic)); - remiCodeFromeBBlock (ebp, ic); - bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key); - hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL); - OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key); - ic = ic->prev; - } - } - } - } + { + sym_link *fromType = operandType (IC_RIGHT (ic)); + sym_link *toType = operandType (IC_LEFT (ic)); + + if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) && + getSize (fromType) != getSize (toType) && + SPEC_USIGN (fromType) == SPEC_USIGN (toType)) + { + + iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp); + if (dic) + { + if (IS_ARITHMETIC_OP (dic)) + { + bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key); + ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic)); + remiCodeFromeBBlock (ebp, ic); + bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key); + hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL); + OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key); + ic = ic->prev; + } + else + OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0; + } + } + else + { + + /* if the type from and type to are the same + then if this is the only use then packit */ + if (compareType (operandType (IC_RIGHT (ic)), + operandType (IC_LEFT (ic))) == 1) + { + iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp); + if (dic) + { + bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key); + ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic)); + remiCodeFromeBBlock (ebp, ic); + bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key); + hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL); + OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key); + ic = ic->prev; + } + } + } + } #endif /* pack for PUSH @@ -3059,9 +3060,9 @@ packRegisters (eBBlock ** ebpp, int blockno) push V1 */ if (ic->op == IPUSH) - { - packForPush (ic, ebpp, blockno); - } + { + packForPush (ic, ebpp, blockno); + } packRegsForAccUse (ic); } diff --git a/src/mcs51/ralloc.c b/src/mcs51/ralloc.c index 1334894e..d4d3ad42 100644 --- a/src/mcs51/ralloc.c +++ b/src/mcs51/ralloc.c @@ -3048,10 +3048,10 @@ packRegisters (eBBlock ** ebpp, int blockno) } /* mark the pointer usages */ - if (POINTER_SET (ic)) + if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic))) OP_SYMBOL (IC_RESULT (ic))->uptr = 1; - if (POINTER_GET (ic) && IS_SYMOP(IC_LEFT (ic))) + if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))) OP_SYMBOL (IC_LEFT (ic))->uptr = 1; if (!SKIP_IC2 (ic)) @@ -3136,6 +3136,7 @@ packRegisters (eBBlock ** ebpp, int blockno) /* if pointer set & left has a size more than one and right is not in far space */ if (POINTER_SET (ic) && + IS_SYMOP (IC_RESULT (ic)) && !isOperandInFarSpace (IC_RIGHT (ic)) && !OP_SYMBOL (IC_RESULT (ic))->remat && !IS_OP_RUONLY (IC_RIGHT (ic)) && diff --git a/support/regression/tests/bug1750318.c b/support/regression/tests/bug1750318.c new file mode 100644 index 00000000..1124ee10 --- /dev/null +++ b/support/regression/tests/bug1750318.c @@ -0,0 +1,21 @@ +/* + bug 1750318 +*/ + +#include + +xdata at(0x1234) char bar; + +// no need to call this, it generates compiler error: +// Internal error: validateOpType failed in +// OP_SYMBOL(IC_RESULT (ic)) @ SDCCcse.c:2172: +// expected symbol, got value +void foo(void) { + *(char volatile xdata *) &bar = 0x80; +} + +void +testBug(void) +{ + ASSERT(1); +} -- 2.30.2