/*------------------------------------------------------------------------
- SDCCralloc.c - source file for register allocation. (8051) specific
+ SDCCralloc.c - source file for register allocation. 68HC08 specific
Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
+
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
- what you give them. Help stamp out software-hoarding!
+ what you give them. Help stamp out software-hoarding!
-------------------------------------------------------------------------*/
#include "common.h"
allocReg (short type)
{
return NULL;
-
+
if ((type==REG_PTR) && (regshc08[HX_IDX].isFree))
{
regshc08[HX_IDX].isFree = 0;
}
reg->isFree = 1;
-
+
switch (reg->rIdx)
{
case A_IDX:
{
bitVect *spillable;
- /* spillable live ranges are those that are live at this
+ /* spillable live ranges are those that are live at this
point . the following categories need to be subtracted
- from this set.
+ from this set.
a) - those that are already spilt
b) - if being used by this one
c) - defined by this one */
if (!bitVectBitValue (lrs, i))
continue;
- /* if we don't find it in the live range
+ /* if we don't find it in the live range
hash table we are in serious trouble */
if (!(sym = hTabItemWithKey (liveRanges, i)))
{
int j;
/* if no registers assigned to it or spilt */
- /* if it does not overlap with this then
+ /* if it does not overlap with this then
not need to spill it */
if (lrsym->isspilt || !lrsym->nRegs ||
char slocBuffer[30];
- /* first go try and find a free one that is already
+ /* first go try and find a free one that is already
existing on the stack */
if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
{
sym->usl.spillLoc = sloc;
sym->stackSpil = 1;
- /* add it to the set of itempStack set
+ /* add it to the set of itempStack set
of the spill location */
addSetHead (&sloc->usl.itmpStack, sym);
return sym;
if (!(sym->remat || sym->usl.spillLoc))
createStackSpil (sym);
- /* mark it has spilt & put it in the spilt set */
+ /* mark it as spilt & put it in the spilt set */
sym->isspilt = sym->spillA = 1;
_G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
sym->regs[i] = NULL;
}
- /* if spilt on stack then free up r0 & r1
+ /* if spilt on stack then free up r0 & r1
if they could have been assigned to some
LIVE ranges */
// if (!hc08_ptrRegReq && isSpiltOnStack (sym))
/* check if there are any live ranges that not
used in the remainder of the block */
- if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
+ if (!_G.blockSpil &&
+ !isiCodeInFunctionCall (ic) &&
+ (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
{
sym = leastUsedLR (selectS);
if (sym != forSym)
spillLRWithPtrReg (ssym);
}
- /* if this was a block level spil then insert push & pop
+ /* if this was a block level spil then insert push & pop
at the start & end of block respectively */
if (ssym->blockSpil)
{
if (!spilSomething (ic, ebp, sym))
return NULL;
- /* this looks like an infinite loop but
+ /* this looks like an infinite loop but
in really selectSpil will abort */
goto tryAgain;
}
if (!spilSomething (ic, ebp, sym))
return NULL;
- /* this looks like an infinite loop but
+ /* this looks like an infinite loop but
in really selectSpil will abort */
goto tryAgain;
}
if (sym->liveTo > ic->seq)
continue;
- /* if it was spilt on stack then we can
+ /* if it was spilt on stack then we can
mark the stack spil location as free */
if (sym->isspilt)
{
continue;
/* special case check if this is an IFX &
- the privious one was a pop and the
+ 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 &&
of te type required */
if (rt == REG_PTR)
{
- /* special case for pointer type
- if pointer type not avlb then
+ /* special case for pointer type
+ if pointer type not avlb then
check for type gpr */
if (nFreeRegs (rt) >= nr)
return 0;
verifyRegsAssigned (operand *op, iCode * ic)
{
symbol * sym;
-
+
if (!op) return;
if (!IS_ITEMP (op)) return;
-
+
sym = OP_SYMBOL (op);
if (sym->isspilt) return;
if (!sym->nRegs) return;
if (sym->regs[0]) return;
-
- werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
+
+ werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
sym->prereqv ? sym->prereqv->name : sym->name);
spillThis (sym);
}
int j;
int ptrRegSet = 0;
- /* if it does not need or is spilt
+ /* 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 ||
continue;
}
/* if trying to allocate this will cause
- a spill and there is nothing to spill
+ 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))) {
+ if (sym->remat || (willCS && bitVectIsZero (spillable))) {
spillThis (sym);
- continue;
+ continue;
}
- /* If the live range preceeds the point of definition
- then ideally we must take into account registers that
+ /* 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;
+ continue;
}
/* if it has a spillocation & is used less than
verifyRegsAssigned (IC_LEFT (ic), ic);
verifyRegsAssigned (IC_RIGHT (ic), ic);
}
- }
+ }
}
static void fillGaps()
{
symbol *sym =NULL;
- int key =0;
-
+ int key =0;
+
if (getenv("DISABLE_FILL_GAPS")) return;
-
- /* look for livernages that was spilt by the allocator */
- for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
+
+ /* look for liveranges that were spilt by the allocator */
+ for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
sym = hTabNextItem(liveRanges,&key)) {
int i;
clr = hTabItemWithKey(liveRanges,i);
assert(clr);
-
+
/* mark these registers as used */
- for (k = 0 ; k < clr->nRegs ; k++ )
+ for (k = 0 ; k < clr->nRegs ; k++ )
hc08_useReg(clr->regs[k]);
}
if (sym->regType == REG_PTR)
sym->regs[i] = getRegPtrNoSpil ();
else
- sym->regs[i] = getRegGprNoSpil ();
+ 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
+ only ONCE if more than One positioning required
then give up */
sym->isspilt = 0;
for (i = 0 ; i < sym->defs->size ; i++ ) {
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)) &&
+ 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)) &&
+ if (IS_SYMOP(IC_RIGHT(ic)) &&
bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
pdone += positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)));
}
if (!IS_ASSIGN_ICODE(ic)) continue ;
/* if result is assigned to registers */
- if (IS_SYMOP(IC_RESULT(ic)) &&
+ if (IS_SYMOP(IC_RESULT(ic)) &&
bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
pdone += positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)));
}
}
freeAllRegs();
D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
- continue ;
+ continue ;
}
D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
_G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
ic->rUsed = regsUsedIniCode (ic);
_G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
- /* now create the register mask for those
+ /* 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);
char *s = buffer;
iCode *ic = sym->rematiCode;
// int offset = 0;
-
+
while (1)
{
/* if plus or minus print the right hand side */
continue;
}
-/*
+/*
if (ic->op == '+')
{
offset += operandLitValue (IC_RIGHT (ic));
if (sym->regType == REG_CND)
continue;
- /* if used in return only then we don't
+ /* if used in return only then we don't
need registers */
if (sym->ruonly || sym->accuse)
{
{
int k;
iCode *uic;
-
+
if (ic->op != '=')
return;
if (POINTER_SET (ic))
{
uic = hTabItemWithKey (iCodehTab, k);
if (!uic) continue;
-
+
if (uic->op != IFX && uic->op != JUMPTABLE)
{
if (IC_LEFT (uic) && IC_LEFT (uic)->key == IC_RESULT (ic)->key)
return 0;
}
-
/* if the true symbol is defined in far space or on stack
then we should not since this will increase register pressure */
#if 0
}
#endif
- /* find the definition of iTempNN scanning backwards if we find a
- a use of the true symbol in before we find the definition then
+ /* find the definition of iTempNN scanning backwards if we find a
+ a use of the true symbol in before we find the definition then
we cannot */
for (dic = ic->prev; dic; dic = dic->prev)
{
#if 0 /* jwk: This collides with 1.43 but I really see no need for
- this anymore. It fixes bug #716790 and substantially improves
+ this anymore. It fixes bug #716790 and substantially improves
redundant register usage around function calls.
*/
return 0; /* did not find */
/* if assignment then check that right is not a bit */
- if (ASSIGNMENT (dic) && !POINTER_SET (dic))
+ if (ASSIGNMENT (ic) && !POINTER_SET (ic))
{
- sym_link *etype = operandType (IC_RIGHT (dic));
+ sym_link *etype = operandType (IC_RESULT (dic));
if (IS_BITFIELD (etype))
{
/* if result is a bit too then it's ok */
- etype = operandType (IC_RESULT (dic));
+ etype = operandType (IC_RESULT (ic));
if (!IS_BITFIELD (etype))
- return 0;
- }
+ {
+ return 0;
+ }
+ }
}
/* if the result is on stack or iaccess then it must be
the same atleast one of the operands */
}
// TODO: and the otherway around?
- /* delete from liverange table also
+ /* delete from liverange table also
delete from all the points inbetween and the new
one */
for (sic = dic; sic != ic; sic = sic->next)
and eliminate the use of iTempAA, freeing up its register for
other uses.
*/
-
+
for (dic = ic->prev; dic; dic = dic->prev)
{
if (dic->op == '=' &&
!POINTER_SET (dic) &&
IC_RESULT (dic)->key == op->key
- && IS_TRUE_SYMOP(IC_RIGHT(dic))
+ && IS_TRUE_SYMOP(IC_RIGHT(dic))
)
break; /* found where this temp was defined */
/* we are interested only if defined in far space */
/* or in stack space in case of + & - */
-
+
/* if assigned to a non-symbol then don't repack regs */
if (!IS_SYMOP (IC_RIGHT (dic)))
return NULL;
-
+
/* if the symbol is volatile then we should not */
if (isOperandVolatile (IC_RIGHT (dic), TRUE))
return NULL;
/* if the symbol is in far space then we should not */
/* if (isOperandInFarSpace (IC_RIGHT (dic)))
return NULL; */
-
+
/* for + & - operations make sure that
if it is on the stack it is the same
as one of the three operands */
if ((ic->op == '+' || ic->op == '-') &&
OP_SYMBOL (IC_RIGHT (dic))->onStack)
{
-
+
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;
}
#endif
-
+
/* now make sure that the right side of dic
is not defined between ic & dic */
if (dic)
bitVectUnSetBit(OP_SYMBOL(IC_RESULT(assignment))->defs, assignment->key);
hTabDeleteItem (&iCodehTab, assignment->key, assignment, DELETE_ITEM, NULL);
}
-
+
/*-----------------------------------------------------------------*/
/* packRegsForSupport :- reduce some registers for support calls */
{
iCode *dic;
int changes = 0;
-
+
/* for the left & right operand :- look to see if the
left was assigned a true symbol in far space in that
case replace them */
return NULL;
return NULL;
-
+
if (ic->op != SEND //RETURN
&& ic->op != SEND
&& !POINTER_SET (ic)
&& !POINTER_GET (ic) )
return NULL;
-
+
if (ic->op == SEND && ic->argreg != 1) return NULL;
- /* this routine will mark the a symbol as used in one
- instruction use only && if the defintion is local
+ /* this routine will mark the a symbol as used in one
+ instruction use only && if the defintion is local
(ie. within the basic block) && has only one definition &&
- that definiion is either a return value from a
+ that definiion is either a return value from a
function or does not contain any variables in
far space */
uses = bitVectCopy (OP_USES (op));
/* if that only usage is a cast */
if (dic->op == CAST) {
/* to a bigger type */
- if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) >
+ if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) >
getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) {
/* than we can not, since we cannot predict the usage of b & acc */
return NULL;
if (POINTER_GET (dic) &&
!IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
return NULL;
-#endif
+#endif
sic = dic;
sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
/* bitwise operations are considered optimizable
- under the following conditions (Jean-Louis VERN)
+ under the following conditions (Jean-Louis VERN)
x & lit
bit & bit
// if (sym->iaccess && symspace->paged)
// return TRUE; /* must fetch paged indirect sym via accumulator */
-
+
if (IN_BITSPACE(symspace))
return TRUE; /* fetching bit vars uses the accumulator */
-
- if (IN_FARSPACE(symspace) || IN_CODESPACE(symspace))
+
+ if (IN_FARSPACE(symspace) || IN_CODESPACE(symspace))
return TRUE; /* fetched via accumulator and dptr */
}
}
/*-----------------------------------------------------------------*/
-/* canUseAccOperand - return 1 if the iCode can gemerate a result */
-/* in A or XA */
+/* canDefAccResult - return 1 if the iCode can generate a result */
+/* in A or XA */
/*-----------------------------------------------------------------*/
static int
canDefAccResult (iCode * ic)
{
int size;
-
+
if (ic->op == IFX || ic->op == JUMPTABLE) /* these iCodes have no result */
return 0;
if (!IS_ITEMP (IC_RESULT (ic)))
return 0;
-
+
/* I don't think an iTemp can be an aggregate, but just in case */
if (IS_AGGREGATE(operandType(IC_RESULT(ic))))
return 0;
{
case LEFT_OP:
case RIGHT_OP:
- return isOperandLiteral (IC_RIGHT (ic));
+ return isOperandLiteral (IC_RIGHT (ic))
+ && SPEC_USIGN (operandType (IC_RESULT (ic)));
case CALL:
case PCALL:
case '*':
return 0;
}
}
-
+
return 0;
}
{
int size;
operand * otherOp;
-
+
if (ic->op == IFX)
{
if (isOperandEqual (op, IC_COND (ic)))
else
return 0;
}
-
+
if (ic->op == JUMPTABLE)
{
if (isOperandEqual (op, IC_JTCOND (ic)))
/* Generation of SEND is deferred until CALL; not safe */
/* if there are intermediate iCodes */
- if (ic->op == SEND && ic->next && ic->next != CALL)
+ if (ic->op == SEND && ic->next && ic->next->op != CALL)
return 0;
-
+
size = getSize (operandType (op));
if (size == 1)
{
return 0;
}
}
-
+
return 0;
}
if (!canDefAccResult (ic))
return 0;
-
+
op = IC_RESULT (ic);
-
+
/* has only one definition */
if (bitVectnBitsOn (OP_DEFS (op)) > 1)
return 0;
uic = ic->next;
if (!uic)
return 0;
-
+
if (!canUseAccOperand (uic, op))
return 0;
-
+
#if 0
if ((POINTER_GET(uic))
|| (ic->op == ADDRESS_OF && uic->op == '+' && IS_OP_LITERAL (IC_RIGHT (uic))))
return;
}
#endif
-
+
OP_SYMBOL (IC_RESULT (ic))->accuse = ACCUSE_XA;
return 1;
}
inbetween */
dbv = OP_DEFS(IC_RIGHT(dic));
for (lic = ic; lic && lic != dic ; lic = lic->prev) {
- if (bitVectBitValue(dbv,lic->key))
+ if (bitVectBitValue(dbv,lic->key))
return ;
}
/* make sure they have the same type */
{
sym_link *itype=operandType(IC_LEFT(ic));
sym_link *ditype=operandType(IC_RIGHT(dic));
-
+
if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
SPEC_LONG(itype)!=SPEC_LONG(ditype))
return;
OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
}
bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- }
+ }
/* we now we know that it has one & only one def & use
and the that the definition is an assignment */
for (ic = ebp->sch; ic; ic = ic->next)
{
//packRegsForLiteral (ic);
-
- /* if this is an itemp & result of an address of a true sym
+
+ /* 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_ITEMP (IC_RESULT (ic)) &&
IS_TRUE_SYMOP (IC_LEFT (ic)) &&
bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
!OP_SYMBOL (IC_LEFT (ic))->onStack )
/* if cast to a generic pointer & the pointer being
cast is remat, then we can remat this cast as well */
- if (ic->op == CAST &&
+ 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)) {
+ 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
+ /* 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)) &&
OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
continue;
}
-
+
if (ic->op != IFX && ic->op !=JUMPTABLE && !POINTER_SET (ic)
&& IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic))
&& getSize (operandType (IC_RESULT (ic))) == 1
&& OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
{
int accuse = 0;
-
+
if (ic->next->op == IFX)
{
if (isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)))
if (isOperandEqual (IC_RESULT (ic), IC_RIGHT (ic->next)))
accuse = 1;
}
-
+
if (accuse)
{
OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
continue;
}
-
+
}
#endif
-
+
/* reduce for support function calls */
if (ic->supportRtn || (ic->op != IFX && ic->op != JUMPTABLE))
packRegsForSupport (ic, ebp);
if (POINTER_SET (ic) &&
/* !isOperandInFarSpace (IC_RIGHT (ic)) && */
!OP_SYMBOL (IC_RESULT (ic))->remat &&
- !IS_OP_RUONLY (IC_RIGHT (ic))
+ !IS_OP_RUONLY (IC_RIGHT (ic))
/* && getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1 */ )
packRegsForOneuse (ic, IC_RESULT (ic), ebp);
IS_SYMOP (IC_LEFT (ic)) &&
/* !isOperandInFarSpace (IC_RESULT (ic)) && */
!OP_SYMBOL (IC_LEFT (ic))->remat &&
- !IS_OP_RUONLY (IC_RESULT (ic))
+ !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
- check if only use of the definition of the
+ check if only use of the definition of the
operand being casted/ if yes then replace
- the result of that arithmetic operation with
+ the result of that arithmetic operation with
this result and get rid of the cast */
if (ic->op == CAST)
{
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);
}
}
#endif
-
- /* pack for PUSH
+
+ /* pack for PUSH
iTempNN := (some variable in farspace) V1
push iTempNN ;
-------------
/* assignRegisters - assigns registers to each live range as need */
/*-----------------------------------------------------------------*/
void
-hc08_assignRegisters (eBBlock ** ebbs, int count)
+hc08_assignRegisters (ebbIndex * ebbi)
{
+ eBBlock ** ebbs = ebbi->bbOrder;
+ int count = ebbi->count;
iCode *ic;
int i;
/* liveranges probably changed by register packing
so we compute them again */
recomputeLiveRanges (ebbs, count);
-
+
if (options.dump_pack)
- dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
+ dumpEbbsToFileExt (DUMP_PACK, ebbi);
- /* first determine for each live range the number of
+ /* first determine for each live range the number of
registers & the type of registers required for each */
regTypeNum (*ebbs);
if (options.dump_rassgn)
{
- dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
+ dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
dumpLiveRanges (DUMP_LRANGE, liveRanges);
}