static void visit (set **visited, iCode *ic, const int key)
{
symbol *lbl;
while (ic && !isinSet (*visited, ic) && bitVectBitValue (ic->rlive, key))
{
addSet (visited, ic);
switch (ic->op)
{
case GOTO:
ic = hTabItemWithKey (labelDef, (IC_LABEL (ic))->key);
break;
case RETURN:
ic = hTabItemWithKey (labelDef, returnLabel->key);
break;
case JUMPTABLE:
for (lbl = setFirstItem (IC_JTLABELS (ic)); lbl; lbl = setNextItem (IC_JTLABELS (ic)))
visit (visited, hTabItemWithKey (labelDef, lbl->key), key);
break;
case IFX:
visit (visited, hTabItemWithKey (labelDef, (IC_TRUE(ic) ? IC_TRUE (ic) : IC_FALSE (ic))->key), key);
ic = ic->next;
break;
default:
ic = ic->next;
if (!POINTER_SET (ic) && IC_RESULT (ic) && IS_SYMOP (IC_RESULT (ic)) && OP_SYMBOL_CONST (IC_RESULT (ic))->key == key)
{
addSet (visited, ic);
return;
}
}
}
}
void
dumpIcRlive (eBBlock ** ebbs, int count)
{
int i, j;
iCode *ic;
/* for all blocks do */
for (i = 0; i < count; i++)
{
printf ("bb %d %s alive symbols:\n", i, ebbs[i]->entryLabel->name);
/* for all instructions in this block do */
for (ic = ebbs[i]->sch; ic; ic = ic->next)
{
printf ("\tic->key %d\n", ic->key);
if (!ic->rlive)
continue;
/* for all live Ranges alive at this point */
for (j = 1; j < ic->rlive->size; j++)
{
symbol *sym;
if (!bitVectBitValue (ic->rlive, j))
continue;
/* find the live range we are interested in */
if ((sym = hTabItemWithKey (liveRanges, j)))
printf ("\t\tsym->key %2d: %s\n", sym->key, sym->rname[0] ? sym->rname : sym->name);
}
}
}
}
/*-----------------------------------------------------------------*/
static void
markLiveRanges (eBBlock **ebbs, int count)
{
int i, key;
symbol *sym;
for (i = 0; i < count; i++)
{
iCode *ic;
for (ic = ebbs[i]->sch; ic; ic = ic->next)
{
if (ic->op == CALL || ic->op == PCALL)
if (bitVectIsZero (OP_SYMBOL (IC_RESULT (ic))->uses))
bitVectUnSetBit (ebbs[i]->defSet, ic->key);
/* for all iTemps alive at this iCode */
for (key = 1; key < ic->rlive->size; key++)
{
if (!bitVectBitValue(ic->rlive, key))
continue;
sym = hTabItemWithKey(liveRanges, key);
setLiveTo(sym, ic->seq);
setLiveFrom(sym, ic->seq);
}
}
}
}
/*-----------------------------------------------------------------*/
void
hTabAddItemIfNotP (hTab ** htab, int key, void *item)
{
if (!*htab)
{
hTabAddItem (htab, key, item);
return;
}
if (hTabItemWithKey (*htab, key))
return;
hTabAddItem (htab, key, item);
}
/*-----------------------------------------------------------------*/
bool
allDefsOutOfRange (bitVect * defs, int fseq, int toseq)
{
int i;
if (!defs)
return TRUE;
for (i = 0; i < defs->size; i++)
{
iCode *ic;
if (bitVectBitValue (defs, i) &&
(ic = hTabItemWithKey (iCodehTab, i)) &&
(ic->seq >= fseq && ic->seq <= toseq))
return FALSE;
}
return TRUE;
}
static void
pic14_constructAbsMap (struct dbuf_s *oBuf, struct dbuf_s *gloBuf)
{
memmap *maps[] = { data, sfr, NULL };
int i;
hTab *ht = NULL;
symbol *sym;
set *aliases;
int addr, min=-1, max=-1;
int size;
for (i=0; maps[i] != NULL; i++)
{
for (sym = (symbol *)setFirstItem (maps[i]->syms);
sym; sym = setNextItem (maps[i]->syms))
{
if (IS_DEFINED_HERE(sym) && SPEC_ABSA(sym->etype))
{
addr = SPEC_ADDR(sym->etype);
/* handle CONFIG words here */
if (IS_CONFIG_ADDRESS( addr ))
{
//fprintf( stderr, "%s: assignment to CONFIG@0x%x found\n", __FUNCTION__, addr );
//fprintf( stderr, "ival: %p (0x%x)\n", sym->ival, (int)list2int( sym->ival ) );
if (sym->ival) {
pic14_assignConfigWordValue( addr, (int)list2int( sym->ival ) );
} else {
fprintf( stderr, "ERROR: Symbol %s, which is covering a __CONFIG word must be initialized!\n", sym->name );
}
continue;
}
if (max == -1 || addr > max) max = addr;
if (min == -1 || addr < min) min = addr;
//fprintf (stderr, "%s: sym %s @ 0x%x\n", __FUNCTION__, sym->name, addr);
aliases = hTabItemWithKey (ht, addr);
if (aliases) {
/* May not use addSetHead, as we cannot update the
* list's head in the hastable `ht'. */
addSet (&aliases, sym);
#if 0
fprintf( stderr, "%s: now %d aliases for %s @ 0x%x\n",
__FUNCTION__, elementsInSet(aliases), sym->name, addr);
#endif
} else {
addSet (&aliases, sym);
hTabAddItem (&ht, addr, aliases);
} // if
} // if
} // for sym
} // for i
/* now emit definitions for all absolute symbols */
dbuf_printf (oBuf, "%s", iComments2);
dbuf_printf (oBuf, "; absolute symbol definitions\n");
dbuf_printf (oBuf, "%s", iComments2);
for (addr=min; addr <= max; addr++)
{
size = 1;
aliases = hTabItemWithKey (ht, addr);
if (aliases && elementsInSet(aliases)) {
/* Make sure there is no initialized value at this location! */
for (sym = setFirstItem(aliases); sym; sym = setNextItem(aliases)) {
if (sym->ival) break;
} // for
if (sym) continue;
dbuf_printf (oBuf, "UD_abs_%s_%x\tudata_ovr\t0x%04x\n",
moduleName, addr, addr);
for (sym = setFirstItem (aliases); sym;
sym = setNextItem (aliases))
{
if (getSize(sym->type) > size) {
size = getSize(sym->type);
}
/* initialized values are handled somewhere else */
if (sym->ival) continue;
/* emit STATUS as well as _STATUS, required for SFRs only */
//dbuf_printf (oBuf, "%s\tres\t0\n", sym->name);
dbuf_printf (oBuf, "%s\n", sym->rname);
if (IS_GLOBAL(sym) && !IS_STATIC(sym->etype)) {
//emitIfNew(gloBuf, &emitted, "\tglobal\t%s\n", sym->name);
emitIfNew(gloBuf, &emitted, "\tglobal\t%s\n", sym->rname);
} // if
} // for
dbuf_printf (oBuf, "\tres\t%d\n", size);
} // if
} // for i
}
/*-----------------------------------------------------------------*/
void
separateLiveRanges (iCode *sic, ebbIndex *ebbi)
{
iCode *ic;
set *candidates = 0;
symbol *sym;
// printf("separateLiveRanges()\n");
for (ic = sic; ic; ic = ic->next)
{
if (ic->op == IFX || ic->op == GOTO || ic->op == JUMPTABLE || !IC_RESULT (ic) || !IS_ITEMP (IC_RESULT (ic)) || bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) <= 1 || isinSet (candidates, OP_SYMBOL (IC_RESULT (ic))))
continue;
addSet (&candidates, OP_SYMBOL (IC_RESULT (ic)));
}
if (!candidates)
return;
for(sym = setFirstItem (candidates); sym; sym = setNextItem (candidates))
{
// printf("Looking at %s, %d definitions\n", sym->name, bitVectnBitsOn (sym->defs));
int i;
set *defs = 0;
for (i = 0; i < sym->defs->size; i++)
if (bitVectBitValue (sym->defs, i))
{
iCode *dic;
if(dic = hTabItemWithKey (iCodehTab, i))
addSet (&defs, hTabItemWithKey (iCodehTab, i));
else
{
werror (W_INTERNAL_ERROR, __FILE__, __LINE__, "Definition not found");
return;
}
}
do
{
set *visited = 0;
set *newdefs = 0;
int oldsize;
wassert (defs);
wassert (setFirstItem (defs));
// printf("Looking at def at %d now\n", ((iCode *)(setFirstItem (defs)))->key);
if (!bitVectBitValue (((iCode *)(setFirstItem (defs)))->rlive, sym->key))
{
werror (W_INTERNAL_ERROR, __FILE__, __LINE__, "Variable is not alive at one of its definitions");
break;
}
visit (&visited, setFirstItem (defs), sym->key);
addSet (&newdefs, setFirstItem (defs));
do
{
oldsize = elementsInSet(visited);
ic = setFirstItem (defs);
for(ic = setNextItem (defs); ic; ic = setNextItem (defs))
{
// printf("Looking at other def at %d now\n", ic->key);
set *visited2 = 0;
set *intersection = 0;
visit (&visited2, ic, sym->key);
intersection = intersectSets (visited, visited2, THROW_NONE);
intersection = subtractFromSet (intersection, defs, THROW_DEST);
if (intersection)
{
visited = unionSets (visited, visited2, THROW_DEST);
addSet (&newdefs, ic);
}
deleteSet (&intersection);
deleteSet (&visited2);
}
}
while (oldsize < elementsInSet(visited));
defs = subtractFromSet (defs, newdefs, THROW_DEST);
if (newdefs && defs)
{
operand *tmpop = newiTempOperand (operandType (IC_RESULT ((iCode *)(setFirstItem (newdefs)))), TRUE);
// printf("Splitting %s from %s, using def at %d, op %d\n", OP_SYMBOL_CONST(tmpop)->name, sym->name, ((iCode *)(setFirstItem (newdefs)))->key, ((iCode *)(setFirstItem (newdefs)))->op);
for (ic = setFirstItem (visited); ic; ic = setNextItem (visited))
{
if (IC_LEFT (ic) && IS_ITEMP (IC_LEFT (ic)) && OP_SYMBOL (IC_LEFT (ic)) == sym)
IC_LEFT (ic) = operandFromOperand (tmpop);
if (IC_RIGHT (ic) && IS_ITEMP (IC_RIGHT (ic)) && OP_SYMBOL (IC_RIGHT (ic)) == sym)
IC_RIGHT (ic) = operandFromOperand (tmpop);
if (IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic)) && OP_SYMBOL (IC_RESULT (ic)) == sym && !POINTER_SET(ic) && ic->next && !isinSet (visited, ic->next))
continue;
if (IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic)) && OP_SYMBOL (IC_RESULT (ic)) == sym)
{
bool pset = POINTER_SET(ic);
IC_RESULT (ic) = operandFromOperand (tmpop);
if (pset)
IC_RESULT(ic)->isaddr = TRUE;
}
bitVectUnSetBit (sym->uses, ic->key);
}
}
deleteSet (&newdefs);
deleteSet (&visited);
}
while (elementsInSet(defs) > 1);
deleteSet (&defs);
}
deleteSet (&candidates);
}
/*-----------------------------------------------------------------*/
static void
computeClash (eBBlock ** ebbs, int count)
{
int i;
/* for all blocks do */
for (i = 0; i < count; i++)
{
iCode *ic;
/* for every iCode do */
for (ic = ebbs[i]->sch; ic; ic = ic->next)
{
symbol *sym1, *sym2;
int key1, key2;
/* for all iTemps alive at this iCode */
for (key1 = 1; key1 < ic->rlive->size; key1++)
{
if (!bitVectBitValue(ic->rlive, key1))
continue;
sym1 = hTabItemWithKey(liveRanges, key1);
if (!sym1->isitmp)
continue;
/* for all other iTemps alive at this iCode */
for (key2 = key1+1; key2 < ic->rlive->size; key2++)
{
if (!bitVectBitValue(ic->rlive, key2))
continue;
sym2 = hTabItemWithKey(liveRanges, key2);
if (!sym2->isitmp)
continue;
/* if the result and left or right is an iTemp */
/* than possibly the iTemps do not clash */
if ((ic->op != JUMPTABLE) && (ic->op != IFX) &&
IS_ITEMP(IC_RESULT(ic)) &&
(IS_ITEMP(IC_LEFT(ic)) || IS_ITEMP(IC_RIGHT(ic))))
{
if (OP_SYMBOL(IC_RESULT(ic))->key == key1
&& sym1->liveFrom == ic->seq
&& sym2->liveTo == ic->seq)
{
if (IS_SYMOP(IC_LEFT(ic)))
if (OP_SYMBOL(IC_LEFT(ic))->key == key2)
continue;
if (IS_SYMOP(IC_RIGHT(ic)))
if (OP_SYMBOL(IC_RIGHT(ic))->key == key2)
continue;
}
if (OP_SYMBOL(IC_RESULT(ic))->key == key2
&& sym2->liveFrom == ic->seq
&& sym1->liveTo == ic->seq)
{
if (IS_SYMOP(IC_LEFT(ic)))
if (OP_SYMBOL(IC_LEFT(ic))->key == key1)
continue;
if (IS_SYMOP(IC_RIGHT(ic)))
if (OP_SYMBOL(IC_RIGHT(ic))->key == key1)
continue;
}
}
/* the iTemps do clash. set the bits in clashes */
sym1->clashes = bitVectSetBit (sym1->clashes, key2);
sym2->clashes = bitVectSetBit (sym2->clashes, key1);
/* check if they share the same spill location */
/* what is this good for? */
if (SYM_SPIL_LOC(sym1) && SYM_SPIL_LOC(sym2) &&
SYM_SPIL_LOC(sym1) == SYM_SPIL_LOC(sym2))
{
if (sym1->reqv && !sym2->reqv) SYM_SPIL_LOC(sym2)=NULL;
else if (sym2->reqv && !sym1->reqv) SYM_SPIL_LOC(sym1)=NULL;
else if (sym1->used > sym2->used) SYM_SPIL_LOC(sym2)=NULL;
else SYM_SPIL_LOC(sym1)=NULL;
}
}
}
}
}
}
/*-----------------------------------------------------------------*/
static void
rlivePoint (eBBlock ** ebbs, int count, bool emitWarnings)
{
int i, key;
eBBlock *succ;
bitVect *alive;
/* for all blocks do */
for (i = 0; i < count; i++)
{
iCode *ic;
/* for all instructions in this block do */
for (ic = ebbs[i]->sch; ic; ic = ic->next)
{
if (!ic->rlive)
ic->rlive = newBitVect (operandKey);
if (SKIP_IC2(ic))
continue;
if (ic->op == JUMPTABLE && IS_SYMOP(IC_JTCOND(ic)))
{
incUsed (ic, IC_JTCOND(ic));
if (!IS_AUTOSYM(IC_JTCOND(ic)))
continue;
findPrevUse (ebbs[i], ic, IC_JTCOND(ic), ebbs, count, emitWarnings);
if (IS_ITEMP(IC_JTCOND(ic)))
{
unvisitBlocks(ebbs, count);
ic->rlive = bitVectSetBit (ic->rlive, IC_JTCOND(ic)->key);
findNextUse (ebbs[i], ic->next, IC_JTCOND(ic));
}
continue;
}
if (ic->op == IFX && IS_SYMOP(IC_COND(ic)))
{
incUsed (ic, IC_COND(ic));
if (!IS_AUTOSYM(IC_COND(ic)))
continue;
findPrevUse (ebbs[i], ic, IC_COND(ic), ebbs, count, emitWarnings);
if (IS_ITEMP(IC_COND(ic)))
{
unvisitBlocks (ebbs, count);
ic->rlive = bitVectSetBit (ic->rlive, IC_COND(ic)->key);
findNextUse (ebbs[i], ic->next, IC_COND(ic));
}
continue;
}
if (IS_SYMOP(IC_LEFT(ic)))
{
incUsed (ic, IC_LEFT(ic));
if (IS_AUTOSYM(IC_LEFT(ic)) &&
ic->op != ADDRESS_OF)
{
findPrevUse (ebbs[i], ic, IC_LEFT(ic), ebbs, count, emitWarnings);
if (IS_ITEMP(IC_LEFT(ic)))
{
unvisitBlocks(ebbs, count);
ic->rlive = bitVectSetBit (ic->rlive, IC_LEFT(ic)->key);
findNextUse (ebbs[i], ic->next, IC_LEFT(ic));
/* if this is a send extend the LR to the call */
if (ic->op == SEND)
{
iCode *lic;
for (lic = ic; lic; lic = lic->next)
{
if (lic->op == CALL || lic->op == PCALL)
{
markAlive (ic, lic->prev, IC_LEFT (ic)->key);
break;
}
}
}
}
}
}
if (IS_SYMOP(IC_RIGHT(ic)))
{
incUsed (ic, IC_RIGHT(ic));
if (IS_AUTOSYM(IC_RIGHT(ic)))
{
findPrevUse (ebbs[i], ic, IC_RIGHT(ic), ebbs, count, emitWarnings);
if (IS_ITEMP(IC_RIGHT(ic)))
{
unvisitBlocks(ebbs, count);
ic->rlive = bitVectSetBit (ic->rlive, IC_RIGHT(ic)->key);
findNextUse (ebbs[i], ic->next, IC_RIGHT(ic));
}
}
}
if (POINTER_SET(ic) && IS_SYMOP(IC_RESULT(ic)))
incUsed (ic, IC_RESULT(ic));
if (IS_AUTOSYM(IC_RESULT(ic)))
{
if (POINTER_SET(ic))
{
findPrevUse (ebbs[i], ic, IC_RESULT(ic), ebbs, count, emitWarnings);
}
if (IS_ITEMP(IC_RESULT(ic)))
{
unvisitBlocks(ebbs, count);
ic->rlive = bitVectSetBit (ic->rlive, IC_RESULT(ic)->key);
findNextUse (ebbs[i], ic->next, IC_RESULT(ic));
/* findNextUse sometimes returns 0 here, which means that ic is
dead code. Something should be done about this dead code since
e.g. register allocation suffers. */
}
}
if (!POINTER_SET(ic) && IC_RESULT(ic))
ic->defKey = IC_RESULT(ic)->key;
}
/* check all symbols that are alive in the last instruction */
/* but are not alive in all successors */
succ = setFirstItem (ebbs[i]->succList);
if (!succ)
continue;
alive = succ->sch->rlive;
while ((succ = setNextItem (ebbs[i]->succList)))
{
if (succ->sch)
alive = bitVectIntersect (alive, succ->sch->rlive);
}
if (ebbs[i]->ech)
alive = bitVectCplAnd ( bitVectCopy (ebbs[i]->ech->rlive), alive);
if(!alive)
continue;
for (key = 1; key < alive->size; key++)
{
if (!bitVectBitValue (alive, key))
continue;
unvisitBlocks(ebbs, count);
findNextUseSym (ebbs[i], NULL, hTabItemWithKey (liveRanges, key));
}
}
}
