cdp->diCode->key);
if (bitVectBitsInCommon (outs, OP_DEFS (cdp->sym)))
{
- setToNull ((void **) &outs);
+ setToNull ((void *) &outs);
return 1;
}
- setToNull ((void **) &outs);
+ setToNull ((void *) &outs);
/* if the operands of this one was changed in the block */
/* then delete it */
(IS_SYMOP (IC_RIGHT (cdp->diCode)) &&
bitVectBitsInCommon (src->defSet, OP_DEFS (IC_RIGHT (cdp->diCode))))))
return 1;
+
+ /* kill if cseBBlock() found a case we missed here */
+ if (isinSetWith(src->killedExprs, cdp, isCseDefEqual))
+ return 1;
return 0;
}
V_ARG (eBBlock *, dest);
V_ARG (int *, firstTime);
+ dest->killedExprs = unionSets (dest->killedExprs, ebp->killedExprs, THROW_DEST);
+
/* if in the dominator list then */
if (bitVectBitValue (dest->domVect, ebp->bbnum) && dest != ebp)
{
}
else
{
- /* delete only if killed in this block */
+ //if (dest != ebp)
+ // dest->inExprs = intersectSets (dest->inExprs, ebp->outExprs, THROW_DEST);
+
+ /* delete only if killed in this block*/
deleteItemIf (&dest->inExprs, ifKilledInBlock, ebp);
/* union the ndompset with pointers set in this block */
dest->ndompset = bitVectUnion (dest->ndompset, ebp->ptrsSet);
}
-
*firstTime = 0;
return 0;
}
+
/*-----------------------------------------------------------------*/
/* mergeInDefs - merge in incoming definitions */
/*-----------------------------------------------------------------*/
/* computeDataFlow - does computations for data flow accross blocks */
/*-----------------------------------------------------------------*/
void
-computeDataFlow (eBBlock ** ebbs, int count)
+computeDataFlow (ebbIndex * ebbi)
{
+ eBBlock ** ebbs = ebbi->dfOrder;
+ int count = ebbi->count;
int i;
int change = 1;
-
+
+ for (i = 0; i < count; i++)
+ ebbs[i]->killedExprs = NULL;
+
while (change)
{
-
change = 0;
/* for all blocks */
set *pred;
set *oldOutExprs = NULL;
+ set *oldKilledExprs = NULL;
bitVect *oldOutDefs = NULL;
int firstTime;
eBBlock *pBlock;
/* get blocks that can come to this block */
pred = edgesTo (ebbs[i]);
- /* make a copy of the outExpressions or outDefs : to be */
+ /* make a copy of the outExpressions and outDefs : to be */
/* used for iteration */
if (optimize.global_cse)
- oldOutExprs = setFromSet (ebbs[i]->outExprs);
- else
- oldOutDefs = bitVectCopy (ebbs[i]->outDefs);
- setToNull ((void **) &ebbs[i]->inDefs);
+ {
+ oldOutExprs = setFromSet (ebbs[i]->outExprs);
+ oldKilledExprs = setFromSet (ebbs[i]->killedExprs);
+ }
+ oldOutDefs = bitVectCopy (ebbs[i]->outDefs);
+ setToNull ((void *) &ebbs[i]->inDefs);
/* indefitions are easy just merge them by union */
/* these are the definitions that can possibly */
/* get the immediate dominator and put it there */
if (!pBlock)
{
- eBBlock *idom = immedDom (ebbs, ebbs[i]);
+ eBBlock *idom = immedDom (ebbi, ebbs[i]);
if (idom)
addSetHead (&pred, idom);
}
-
+
/* figure out the incoming expressions */
/* this is a little more complex */
- setToNull ((void **) &ebbs[i]->inExprs);
+ setToNull ((void *) &ebbs[i]->inExprs);
if (optimize.global_cse)
{
firstTime = 1;
applyToSet (pred, mergeInExprs, ebbs[i], &firstTime);
}
- setToNull ((void **) &pred);
+ setToNull ((void *) &pred);
/* do cse with computeOnly flag set to TRUE */
/* this by far the quickest way of computing */
- cseBBlock (ebbs[i], TRUE, ebbs, count);
+ cseBBlock (ebbs[i], TRUE, ebbi);
/* if it change we will need to iterate */
if (optimize.global_cse)
- change += !isSetsEqualWith (ebbs[i]->outExprs, oldOutExprs, isCseDefEqual);
- else
- change += !bitVectEqual (ebbs[i]->outDefs, oldOutDefs);
+ {
+ change += !isSetsEqualWith (ebbs[i]->outExprs, oldOutExprs, isCseDefEqual);
+ change += !isSetsEqualWith (ebbs[i]->killedExprs, oldKilledExprs, isCseDefEqual);
+ }
+ change += !bitVectEqual (ebbs[i]->outDefs, oldOutDefs);
}
- if (!change) /* iterate till no change */
- break;
+ if (!change) /* iterate till no change */
+ break;
}
return;