}
- setToNull ((void **) &sset);
+ setToNull ((void *) &sset);
sym->blockSpil = 0;
return sym;
}
ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
continue;
}
+
/*
if (ic->op == '+')
{
continue;
}
/* we reached the end */
- sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
+ if (ic->op == ADDRESS_OF)
+ sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
+ else if (ic->op == '=');
+ sprintf (s, "0x%04x", (int) operandLitValue (IC_RIGHT (ic)) );
break;
}
return 0;
}
+#if 0
/*-----------------------------------------------------------------*/
/* farSpacePackable - returns the packable icode for far variables */
/*-----------------------------------------------------------------*/
return NULL;
}
+#endif
+
+#if 0
+static void
+packRegsForLiteral (iCode * ic)
+{
+ int k;
+ iCode *uic;
+
+ if (ic->op != '=')
+ return;
+ if (POINTER_SET (ic))
+ return;
+ if (!IS_LITERAL (getSpec (operandType (IC_RIGHT (ic)))))
+ return;
+ if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
+ return;
+
+ for (k=0; k< OP_USES (IC_RESULT (ic))->size; k++)
+ if (bitVectBitValue (OP_USES (IC_RESULT (ic)), k))
+ {
+ 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)
+ 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));
+ }
+ }
+
+}
+#endif
+
/*-----------------------------------------------------------------*/
/* packRegsForAssign - register reduction for assignment */
return 1;
}
+
/*------------------------------------------------------------------*/
/* findAssignToSym : scanning backwards looks for first assig found */
/*------------------------------------------------------------------*/
packRegsForSupport (iCode * ic, eBBlock * ebp)
{
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
{
/* found it we need to remove it from the block */
reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic));
- return 1;
+ changes++;
}
}
if (dic)
{
- /* if this is a subtraction & the result
- is a true symbol in far space then don't pack */
-#if 0
- if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
- {
- sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
- if (IN_FARSPACE (SPEC_OCLS (etype)))
- return 0;
- }
-#endif
- /* found it we need to remove it from the
- block */
+ /* found it we need to remove it from the block */
reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic));
-
- return 1;
+ changes++;
}
}
- return 0;
+ return changes;
}
#define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
+#if 0
/*-----------------------------------------------------------------*/
/* packRegsForOneuse : - will reduce some registers for single Use */
/*-----------------------------------------------------------------*/
if (!IS_SYMOP (op))
return NULL;
- /* only upto 2 bytes since we cannot predict
- the usage of b, & acc */
+ /* only up to 2 bytes */
if (getSize (operandType (op)) > (fReturnSizeHC08 - 2))
return NULL;
OP_SYMBOL (op)->ruonly = 1;
return sic;
}
+#endif
/*-----------------------------------------------------------------*/
/* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
!IS_BITWISE_OP (uic) &&
(uic->op != LEFT_OP) &&
(uic->op != RIGHT_OP) &&
- (uic->op != GETHBIT))
+ (uic->op != GETHBIT) &&
+ (uic->op != RETURN) &&
+ (uic->op != '~') &&
+ (uic->op != '!'))
return;
#if 0
for (ic = ebp->sch; ic; ic = ic->next)
{
+ //packRegsForLiteral (ic);
+
/* 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 )
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)
+ {
+ 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 == '=' &&
}
/* reduce for support function calls */
- if (ic->supportRtn || ic->op == '+' || ic->op == '-')
+ if (ic->supportRtn || (ic->op != IFX && ic->op != JUMPTABLE))
packRegsForSupport (ic, ebp);
#if 0
}
- #if 0
+ #if 1
/* pack registers for accumulator use, when the
result of an arithmetic or bit wise operation
has only one use, that use is immediately following
the defintion and the using iCode has only one
operand or has two operands but one is literal &
the result of that operation is not on stack then
- we can leave the result of this operation in acc:b
+ we can leave the result of this operation in x:a
combination */
if ((IS_ARITHMETIC_OP (ic)
|| IS_CONDITIONAL(ic)
|| IS_BITWISE_OP (ic)
|| ic->op == '='
+ || ic->op == '!'
+ || ic->op == '~'
|| ic->op == GETHBIT
|| ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
|| (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
+ || ic->op == RECEIVE
) &&
IS_ITEMP (IC_RESULT (ic)) &&
- getSize (operandType (IC_RESULT (ic))) <= 2)
+ getSize (operandType (IC_RESULT (ic))) <= 1)
packRegsForAccUse (ic);
#endif
for (i = 0; i < count; i++)
packRegisters (ebbs, i);
+ /* liveranges probably changed by register packing
+ so we compute them again */
+ recomputeLiveRanges (ebbs, count);
+
if (options.dump_pack)
dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
projects / fw / sdcc / blobdiff