return 1;
}
+void ReplaceOpWithCheaperOp(operand **op, operand *cop) {
+#ifdef RANGEHUNT
+ printf ("ReplaceOpWithCheaperOp %s with %s: ",
+ IS_SYMOP((*op)) ? OP_SYMBOL((*op))->name : "!SYM",
+ IS_SYMOP(cop) ? OP_SYMBOL(cop)->name : "!SYM");
+ // if op is a register equivalent
+ if (IS_ITEMP(cop) && OP_SYMBOL((*op))->isreqv) {
+ operand **rop = &OP_SYMBOL((*op))->usl.spillLoc->reqv;
+ if (isOperandEqual(*rop, *op)) {
+ printf ("true");
+ *rop=cop;
+ OP_SYMBOL((*op))->isreqv=0;
+ OP_SYMBOL(cop)->isreqv=1;
+ } else {
+ printf ("false");
+ }
+ }
+ printf ("\n");
+#endif
+ *op=cop;
+}
+
/*-----------------------------------------------------------------*/
/* replaceAllSymBySym - replaces all operands by operand in an */
/* instruction chain */
/*-----------------------------------------------------------------*/
-void
+void
replaceAllSymBySym (iCode * ic, operand * from, operand * to, bitVect ** ndpset)
{
iCode *lic;
{
bitVectUnSetBit (OP_USES (from), lic->key);
- OP_USES_SET ((to), bitVectSetBit (OP_USES (to), lic->key));
+ OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
siaddr = IC_COND (lic)->isaddr;
IC_COND (lic) = operandFromOperand (to);
IC_COND (lic)->isaddr = siaddr;
{
bitVectUnSetBit (OP_USES (from), lic->key);
- OP_USES_SET ((to), bitVectSetBit (OP_USES (to), lic->key));
+ OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
siaddr = IC_COND (lic)->isaddr;
IC_JTCOND (lic) = operandFromOperand (to);
IC_JTCOND (lic)->isaddr = siaddr;
continue;
}
- if (IC_RESULT (lic) && IC_RESULT (lic)->key == from->key)
+ if (IS_SYMOP(to) &&
+ IC_RESULT (lic) && IC_RESULT (lic)->key == from->key)
{
/* maintain du chains */
if (POINTER_SET (lic))
{
bitVectUnSetBit (OP_USES (from), lic->key);
- OP_USES_SET ((to), bitVectSetBit (OP_USES (to), lic->key));
+ OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
/* also check if the "from" was in the non-dominating
pointer sets and replace it with "to" in the bitVector */
else
{
bitVectUnSetBit (OP_DEFS (from), lic->key);
- OP_DEFS_SET ((to), bitVectSetBit (OP_DEFS (to), lic->key));
+ OP_DEFS(to)=bitVectSetBit (OP_DEFS (to), lic->key);
}
siaddr = IC_RESULT (lic)->isaddr;
IC_RESULT (lic) = operandFromOperand (to);
IC_RIGHT (lic) && IC_RIGHT (lic)->key == from->key)
{
bitVectUnSetBit (OP_USES (from), lic->key);
- OP_USES_SET ((to), bitVectSetBit (OP_USES (to), lic->key));
+ OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
siaddr = IC_RIGHT (lic)->isaddr;
IC_RIGHT (lic) = operandFromOperand (to);
IC_RIGHT (lic)->isaddr = siaddr;
IC_LEFT (lic) && IC_LEFT (lic)->key == from->key)
{
bitVectUnSetBit (OP_USES (from), lic->key);
- OP_USES_SET ((to), bitVectSetBit (OP_USES (to), lic->key));
+ OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
siaddr = IC_LEFT (lic)->isaddr;
IC_LEFT (lic) = operandFromOperand (to);
IC_LEFT (lic)->isaddr = siaddr;
/* if the result is volatile then return result */
if (IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
*opp = IC_RESULT (cdp->diCode);
- else
+ else
/* if this is a straight assignment and
left is a temp then prefer the temporary to the
true symbol */
IS_ITEMP (IC_RESULT (cdp->diCode)))
*opp = IC_RESULT (cdp->diCode);
- if ((*opp) &&
- (isOperandLiteral(*opp) || !checkSign ||
+ if ((*opp) &&
+ (isOperandLiteral(*opp) || !checkSign ||
(checkSign &&
+ IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp)) &&
(SPEC_USIGN(operandType (cop))==SPEC_USIGN(operandType (*opp)) &&
(SPEC_LONG(operandType (cop))==SPEC_LONG(operandType (*opp)))))))
{
(*opp)->isaddr = cop->isaddr;
}
+ if (IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp)) &&
+ SPEC_NOUN(operandType(cop)) != SPEC_NOUN(operandType(*opp)))
+ {
+ // special case: we can make an unsigned char literal
+ // into an int literal with no cost.
+ if (isOperandLiteral(*opp)
+ && SPEC_NOUN(operandType(*opp)) == V_CHAR
+ && SPEC_NOUN(operandType(cop)) == V_INT)
+ {
+ *opp = operandFromOperand (*opp);
+ SPEC_NOUN(operandType(*opp)) = V_INT;
+ }
+ else
+ {
+ // No clue...
+ *opp = NULL;
+ return 0;
+ }
+
+ }
+
return 1;
}
if (isiCodeEqual (ic, cdp->diCode) &&
isOperandEqual (cdp->sym, IC_RESULT (cdp->diCode)))
{
- *icp = cdp->diCode;
+ *icp = cdp->diCode;
return 1;
}
/*-----------------------------------------------------------------*/
/* ifDefSymIs - if a definition is found in the set */
/*-----------------------------------------------------------------*/
-int
+int
ifDefSymIs (set * cseSet, operand * sym)
{
cseDef *loop;
/*-----------------------------------------------------------------*/
/* ifDiCodeIs - returns truw if diCode is same */
/*-----------------------------------------------------------------*/
-int
+int
ifDiCodeIs (set * cseSet, iCode * ic)
{
cseDef *loop;
iCode *lic;
for (lic = ic; lic ; lic = lic->prev) {
- if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic)))
+ if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic)))
return lic;
}
return NULL;
/*-----------------------------------------------------------------*/
/* algebraicOpts - does some algebraic optimizations */
/*-----------------------------------------------------------------*/
-void
-algebraicOpts (iCode * ic)
+static void
+algebraicOpts (iCode * ic, eBBlock * ebp)
{
/* we don't deal with the following iCodes
here */
}
if (operandLitValue (IC_LEFT (ic)) == 1.0)
{
- ic->op = '=';
- IC_LEFT (ic) = NULL;
- SET_RESULT_RIGHT (ic);
+ /* '*' can have two unsigned chars as operands */
+ /* and an unsigned int as result. */
+ if (compareType (operandType (IC_RESULT (ic)),
+ operandType (IC_RIGHT (ic))) == 1)
+ {
+ ic->op = '=';
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ }
+ else
+ {
+ ic->op = CAST;
+ IC_LEFT (ic)->type = TYPE;
+ IC_LEFT (ic)->isLiteral = 0;
+ setOperandType (IC_LEFT (ic), operandType (IC_RESULT (ic)));
+ }
return;
}
}
if (operandLitValue (IC_RIGHT (ic)) == 1.0)
{
- ic->op = '=';
- IC_RIGHT (ic) = IC_LEFT (ic);
- IC_LEFT (ic) = NULL;
- SET_RESULT_RIGHT (ic);
+ /* '*' can have two unsigned chars as operands */
+ /* and an unsigned int as result. */
+ if (compareType (operandType (IC_RESULT (ic)),
+ operandType (IC_LEFT (ic))) == 1)
+ {
+ ic->op = '=';
+ IC_RIGHT (ic) = IC_LEFT (ic);
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ }
+ else
+ {
+ operand *op;
+
+ ic->op = CAST;
+ op = IC_RIGHT (ic);
+ IC_RIGHT (ic) = IC_LEFT (ic);
+ IC_LEFT (ic) = op;
+ IC_LEFT (ic)->type = TYPE;
+ IC_LEFT (ic)->isLiteral = 0;
+ setOperandType (IC_LEFT (ic), operandType (IC_RESULT (ic)));
+ }
return;
}
}
IC_LEFT (ic) = NULL;
SET_ISADDR (IC_RESULT (ic), 0);
}
+ break;
+ case BITWISEAND:
+ /* if both operands are equal */
+ /* if yes turn it into assignment */
+ if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
+ {
+ if (IS_OP_VOLATILE (IC_LEFT (ic)))
+ {
+ iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+ IC_RESULT (newic) = IC_LEFT (ic);
+ newic->lineno = ic->lineno;
+ addiCodeToeBBlock (ebp, newic, ic->next);
+ }
+ ic->op = '=';
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ /* swap literal to right ic */
+ if (IS_OP_LITERAL (IC_LEFT (ic)))
+ {
+ operand *op;
+
+ op = IC_LEFT (ic);
+ IC_LEFT (ic) = IC_RIGHT (ic);
+ IC_RIGHT (ic) = op;
+ }
+ if (IS_OP_LITERAL (IC_RIGHT (ic)))
+ {
+ /* if BITWISEAND then check if one of them is a zero */
+ /* if yes turn it into 0 assignment */
+ if (operandLitValue (IC_RIGHT (ic)) == 0.0)
+ {
+ if (IS_OP_VOLATILE (IC_LEFT (ic)))
+ {
+ iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+ IC_RESULT (newic) = IC_LEFT (ic);
+ newic->lineno = ic->lineno;
+ addiCodeToeBBlock (ebp, newic, ic->next);
+ }
+ ic->op = '=';
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ /* if BITWISEAND then check if one of them is 0xff... */
+ /* if yes turn it into assignment */
+ {
+ unsigned val;
+
+ switch (getSize (operandType (IC_RIGHT (ic))))
+ {
+ case 1:
+ val = 0xff;
+ break;
+ case 2:
+ val = 0xffff;
+ break;
+ case 4:
+ val = 0xffffffff;
+ break;
+ default:
+ return;
+ }
+ if (((unsigned) operandLitValue (IC_RIGHT (ic)) & val) == val)
+ {
+ ic->op = '=';
+ IC_RIGHT (ic) = IC_LEFT (ic);
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ }
+ }
+ break;
+ case '|':
+ /* if both operands are equal */
+ /* if yes turn it into assignment */
+ if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
+ {
+ if (IS_OP_VOLATILE (IC_LEFT (ic)))
+ {
+ iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+ IC_RESULT (newic) = IC_LEFT (ic);
+ newic->lineno = ic->lineno;
+ addiCodeToeBBlock (ebp, newic, ic->next);
+ }
+ ic->op = '=';
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ /* swap literal to right ic */
+ if (IS_OP_LITERAL (IC_LEFT (ic)))
+ {
+ operand *op;
+
+ op = IC_LEFT (ic);
+ IC_LEFT (ic) = IC_RIGHT (ic);
+ IC_RIGHT (ic) = op;
+ }
+ if (IS_OP_LITERAL (IC_RIGHT (ic)))
+ {
+ /* if BITWISEOR then check if one of them is a zero */
+ /* if yes turn it into assignment */
+ if (operandLitValue (IC_RIGHT (ic)) == 0.0)
+ {
+ ic->op = '=';
+ IC_RIGHT (ic) = IC_LEFT (ic);
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ /* if BITWISEOR then check if one of them is 0xff... */
+ /* if yes turn it into 0xff... assignment */
+ {
+ unsigned val;
+
+ switch (getSize (operandType (IC_RIGHT (ic))))
+ {
+ case 1:
+ val = 0xff;
+ break;
+ case 2:
+ val = 0xffff;
+ break;
+ case 4:
+ val = 0xffffffff;
+ break;
+ default:
+ return;
+ }
+ if (((unsigned) operandLitValue (IC_RIGHT (ic)) & val) == val)
+ {
+ if (IS_OP_VOLATILE (IC_LEFT (ic)))
+ {
+ iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+ IC_RESULT (newic) = IC_LEFT (ic);
+ newic->lineno = ic->lineno;
+ addiCodeToeBBlock (ebp, newic, ic->next);
+ }
+ ic->op = '=';
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ }
+ }
+ break;
+ case '^':
+ /* if both operands are equal */
+ /* if yes turn it into 0 assignment */
+ if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
+ {
+ if (IS_OP_VOLATILE (IC_LEFT (ic)))
+ {
+ iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+ IC_RESULT (newic) = IC_LEFT (ic);
+ newic->lineno = ic->lineno;
+ addiCodeToeBBlock (ebp, newic, ic->next);
+
+ newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+ IC_RESULT (newic) = IC_LEFT (ic);
+ newic->lineno = ic->lineno;
+ addiCodeToeBBlock (ebp, newic, ic->next);
+ }
+ ic->op = '=';
+ IC_RIGHT (ic) = operandFromLit (0);
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ /* swap literal to right ic */
+ if (IS_OP_LITERAL (IC_LEFT (ic)))
+ {
+ operand *op;
+
+ op = IC_LEFT (ic);
+ IC_LEFT (ic) = IC_RIGHT (ic);
+ IC_RIGHT (ic) = op;
+ }
+ /* if XOR then check if one of them is a zero */
+ /* if yes turn it into assignment */
+ if (IS_OP_LITERAL (IC_RIGHT (ic)))
+ {
+ if (operandLitValue (IC_RIGHT (ic)) == 0.0)
+ {
+ ic->op = '=';
+ IC_RIGHT (ic) = IC_LEFT (ic);
+ IC_LEFT (ic) = NULL;
+ SET_RESULT_RIGHT (ic);
+ return;
+ }
+ }
+ break;
}
return;
/*-----------------------------------------------------------------*/
/* updateSpillLocation - keeps track of register spill location */
/*-----------------------------------------------------------------*/
-void
+void
updateSpillLocation (iCode * ic, int induction)
{
-
sym_link *setype;
if (POINTER_SET (ic))
if (ic->nosupdate)
return;
+#if 0
/* for the form true_symbol := iTempNN */
if (ASSIGN_ITEMP_TO_SYM (ic) &&
!SPIL_LOC (IC_RIGHT (ic))) {
!IS_VOLATILE (setype) &&
!IN_FARSPACE (SPEC_OCLS (setype)) &&
!OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
-
+ {
+ wassert(IS_SYMOP(IC_RESULT (ic)));
+ wassert(IS_SYMOP(IC_RIGHT (ic)));
SPIL_LOC (IC_RIGHT (ic)) =
IC_RESULT (ic)->operand.symOperand;
+ }
+
}
+#endif
#if 0 /* this needs furthur investigation can save a lot of code */
if (ASSIGN_SYM_TO_ITEMP(ic) &&
applyToSetFTrue (cseSet, findCheaperOp, IC_COND (ic), &pdop, 0);
if (pdop)
{
- IC_COND (ic) = pdop;
+ ReplaceOpWithCheaperOp(&IC_COND (ic), pdop);
(*change)++;
}
}
isinSet (ebb->succList, eBBWithEntryLabel (ebbs, label, count)))
{
- remiCodeFromeBBlock (ebb, ic);
- computeControlFlow (ebbs, count, 1);
if (!options.lessPedantic) {
werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
}
- return;
+ if (IS_OP_VOLATILE (IC_COND (ic)))
+ {
+ IC_RIGHT (ic) = IC_COND (ic);
+ IC_LEFT (ic) = NULL;
+ IC_RESULT (ic) = NULL;
+ ic->op = DUMMY_READ_VOLATILE;
+ }
+ else
+ {
+ remiCodeFromeBBlock (ebb, ic);
+ computeControlFlow (ebbs, count, 1);
+ return;
+ }
}
/* if it remains an IFX the update the use Set */
- OP_USES_SET ((IC_COND (ic)), bitVectSetBit (OP_USES (IC_COND (ic)), ic->key));
- setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
+ if (ic->op == IFX)
+ {
+ OP_USES(IC_COND (ic))=bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
+ setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
+ }
+ else if (ic->op == DUMMY_READ_VOLATILE)
+ {
+ OP_USES(IC_RIGHT (ic))=bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
+ setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
+ }
return;
}
list . This will take care of situations like
iTemp1 = iTemp0 + 8;
iTemp2 = iTemp1 + 8; */
- if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
+ if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
(insetwithFunc)isOperandEqual) ||
- isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
+ isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
(insetwithFunc)isOperandEqual))
{
addSet (&compItems, IC_RESULT (cdp->diCode));
/*-----------------------------------------------------------------*/
/* fixUpTypes - KLUGE HACK fixup a lowering problem */
/*-----------------------------------------------------------------*/
-static void
+static void
fixUpTypes (iCode * ic)
{
sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
return 0;
}
}
+
/*-----------------------------------------------------------------*/
/* cseBBlock - common subexpression elimination for basic blocks */
/* this is the hackiest kludgiest routine in the whole */
/* system. also the most important, since almost all */
/* data flow related information is computed by it */
/*-----------------------------------------------------------------*/
-int
+int
cseBBlock (eBBlock * ebb, int computeOnly,
eBBlock ** ebbs, int count)
{
/* if this block is not reachable */
if (ebb->noPath)
- return change;
+ return 0;
/* set of common subexpressions */
cseSet = setFromSet (ebb->inExprs);
/* these will be computed by this routine */
- setToNull ((void **) &ebb->outDefs);
- setToNull ((void **) &ebb->defSet);
- setToNull ((void **) &ebb->usesDefs);
- setToNull ((void **) &ebb->ptrsSet);
- setToNull ((void **) &ebb->addrOf);
- setToNull ((void **) &ebb->ldefs);
+ setToNull ((void *) &ebb->outDefs);
+ setToNull ((void *) &ebb->defSet);
+ setToNull ((void *) &ebb->usesDefs);
+ setToNull ((void *) &ebb->ptrsSet);
+ setToNull ((void *) &ebb->addrOf);
+ setToNull ((void *) &ebb->ldefs);
ebb->outDefs = bitVectCopy (ebb->inDefs);
bitVectDefault = iCodeKey;
/* for all the instructions in this block do */
for (ic = ebb->sch; ic; ic = ic->next)
{
-
iCode *pdic;
operand *pdop;
iCode *defic;
if (ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE)
{
/* add to defSet of the symbol */
- OP_DEFS_SET ((IC_RESULT (ic)),
- bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key));
+ OP_DEFS(IC_RESULT (ic))=
+ bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
/* add to the definition set of this block */
ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
pdop = NULL;
applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, 0);
if (pdop)
- IC_LEFT (ic) = pdop;
+ ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
}
/* the lookup could have changed it */
if (IS_SYMOP (IC_LEFT (ic)))
{
- OP_USES_SET ((IC_LEFT (ic)),
- bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key));
+ OP_USES(IC_LEFT (ic))=
+ bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
setUsesDefs (IC_LEFT (ic), ebb->defSet,
ebb->outDefs, &ebb->usesDefs);
}
/* if jumptable then mark the usage */
if (ic->op == JUMPTABLE)
{
- OP_USES_SET ((IC_JTCOND (ic)),
- bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key));
- setUsesDefs (IC_JTCOND (ic), ebb->defSet,
- ebb->outDefs, &ebb->usesDefs);
+ if (IS_SYMOP (IC_JTCOND (ic)))
+ {
+ OP_USES(IC_JTCOND (ic)) =
+ bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
+ setUsesDefs (IC_JTCOND (ic), ebb->defSet,
+ ebb->outDefs, &ebb->usesDefs);
+ }
continue;
}
if (SKIP_IC (ic))
continue;
- /* do some algebraic optimizations if possible */
- algebraicOpts (ic);
- while (constFold (ic, cseSet));
+ if (!computeOnly) {
+ /* do some algebraic optimizations if possible */
+ algebraicOpts (ic, ebb);
+ while (constFold (ic, cseSet));
+ }
/* small klugde */
if (POINTER_GET (ic) && !IS_PTR (operandType (IC_LEFT (ic))))
aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
}
- /* if this is a condition statment then */
+ /* if this is a condition statement then */
/* check if the condition can be replaced */
if (ic->op == IFX)
{
/* if the assignment & result is a temp */
/* see if we can replace it */
- if (ic->op == '=')
+ if (!computeOnly && ic->op == '=')
{
/* update the spill location for this */
{
pdop = NULL;
applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop, 0);
- if (pdop && IS_ITEMP (pdop) && !computeOnly)
- IC_RESULT (ic) = pdop;
+ if (pdop && !computeOnly &&
+ IS_ITEMP (pdop) && IS_PTR(operandType(pdop)))
+ ReplaceOpWithCheaperOp (&IC_RESULT(ic), pdop);
}
}
this variable .. unsafe to remove any POINTER_GETs */
if (bitVectBitValue(ebb->ndompset,IC_LEFT(ic)->key))
ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,pdop->key);
- IC_LEFT (ic) = pdop;
+ ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
change = 1;
}
/* check if there is a pointer set
{
ic->op = '=';
IC_LEFT (ic) = NULL;
- IC_RIGHT (ic) = pdop;
+ ReplaceOpWithCheaperOp(&IC_RIGHT(ic), pdop);
SET_ISADDR (IC_RESULT (ic), 0);
}
}
else
{
- IC_LEFT (ic) = pdop;
+ ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
change = 1;
}
}
pdop = NULL;
applyToSetFTrue (cseSet, findCheaperOp, IC_RIGHT (ic), &pdop, checkSign);
- if (pdop)
- {
- IC_RIGHT (ic) = pdop;
- change = 1;
- }
+ if (pdop) {
+ ReplaceOpWithCheaperOp(&IC_RIGHT(ic), pdop);
+ change = 1;
+ }
}
/* if left or right changed then do algebraic */
- if (change)
+ if (!computeOnly && change)
{
- algebraicOpts (ic);
+ algebraicOpts (ic, ebb);
while (constFold (ic, cseSet));
}
- /* if after all this it becomes a assignment to self
+ /* if after all this it becomes an assignment to self
then delete it and continue */
- if (ASSIGNMENT_TO_SELF (ic) && !OTHERS_PARM(OP_SYMBOL(IC_RESULT(ic))))
+ if (ASSIGNMENT_TO_SELF (ic))
{
remiCodeFromeBBlock (ebb, ic);
continue;
if (pdic && compareType (operandType (IC_RESULT (pdic)),
operandType (IC_RESULT (ic))) != 1)
pdic = NULL;
- if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
+ if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
pdic = NULL;
}
/* Alternate code */
if (pdic && IS_ITEMP(IC_RESULT(ic))) {
if (POINTER_GET(ic) && bitVectBitValue(ebb->ptrsSet,IC_LEFT(ic)->key)) {
- /* Mmm, found an equivalent pointer get at a lower level.
- This could be a loop however with the same pointer set
+ /* Mmm, found an equivalent pointer get at a lower level.
+ This could be a loop however with the same pointer set
later on */
} else {
/* if previous definition found change this to an assignment */
IC_LEFT(ic) = NULL;
IC_RIGHT(ic) = operandFromOperand(IC_RESULT(pdic));
SET_ISADDR(IC_RESULT(ic),0);
- SET_ISADDR(IC_RIGHT (ic),0);
+ SET_ISADDR(IC_RIGHT (ic),0);
}
}
/* add the left & right to the defUse set */
if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
{
- OP_USES_SET ((IC_LEFT (ic)),
- bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key));
+ OP_USES(IC_LEFT (ic))=
+ bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
setUsesDefs (IC_LEFT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
}
if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
{
- OP_USES_SET ((IC_RIGHT (ic)),
- bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key));
+ OP_USES(IC_RIGHT (ic))=
+ bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
}
/* in the defuseSet if it a pointer or array access */
if (POINTER_SET (defic))
{
- OP_USES_SET ((IC_RESULT (ic)),
- bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key));
+ OP_USES(IC_RESULT (ic))=
+ bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
deleteItemIf (&cseSet, ifPointerGet, IC_RESULT (ic));
ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RESULT (ic)->key);
else
/* add the result to defintion set */ if (IC_RESULT (ic))
{
- OP_DEFS_SET ((IC_RESULT (ic)),
- bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key));
+ 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);
}
}
- setToNull ((void **) &ebb->outExprs);
+ setToNull ((void *) &ebb->outExprs);
ebb->outExprs = cseSet;
ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
/*-----------------------------------------------------------------*/
/* cseAllBlocks - will sequentially go thru & do cse for all blocks */
/*-----------------------------------------------------------------*/
-int
-cseAllBlocks (eBBlock ** ebbs, int count)
+int
+cseAllBlocks (eBBlock ** ebbs, int count, int computeOnly)
{
int i;
int change = 0;
/* if optimization turned off */
for (i = 0; i < count; i++)
- change += cseBBlock (ebbs[i], FALSE, ebbs, count);
+ change += cseBBlock (ebbs[i], computeOnly, ebbs, count);
return change;
}
projects / fw / sdcc / blobdiff