#if 0 // temporary disabled, leaving the warning as a reminder
if (warnings) {
- SNPRINTF (message, sizeof(message), "for %s %s in %s",
+ SNPRINTF (message, sizeof(message), "for %s %s in %s",
IS_UNSIGNED(ltype) ? "unsigned" : "signed",
nounName(ltype), msg);
werror (W_CONST_RANGE, message);
/*-----------------------------------------------------------------*/
/* operandName - returns the name of the operand */
/*-----------------------------------------------------------------*/
-int
+int
printOperand (operand * op, FILE * file)
{
sym_link *opetype;
op->key,
OP_LIVEFROM (op), OP_LIVETO (op),
OP_SYMBOL (op)->stack,
- op->isaddr, op->aggr2ptr, OP_SYMBOL (op)->isreqv,
+ op->isaddr, op->aggr2ptr, OP_SYMBOL (op)->isreqv,
OP_SYMBOL (op)->remat,OP_SYMBOL(op)->noSpilLoc,
OP_SYMBOL(op)->ruonly,OP_SYMBOL(op)->dptr
);
{
SNPRINTF (buffer, sizeof(buffer), "iTemp%d", iTempNum++);
}
-
+
itmp = newSymbol (buffer, 1);
strncpyz (itmp->rname, itmp->name, SDCC_NAME_MAX);
itmp->isitmp = 1;
/*-----------------------------------------------------------------*/
/* initiCode - initialises some iCode related stuff */
/*-----------------------------------------------------------------*/
-void
+void
initiCode ()
{
/*-----------------------------------------------------------------*/
/* isParamterToCall - will return 1 if op is a parameter to args */
/*-----------------------------------------------------------------*/
-int
+int
isParameterToCall (value * args, operand * op)
{
value *tval = args;
wassert (IS_SYMOP(op));
-
+
while (tval)
{
if (tval->sym &&
/*-----------------------------------------------------------------*/
/* isOperandGlobal - return 1 if operand is a global variable */
/*-----------------------------------------------------------------*/
-int
+int
isOperandGlobal (operand * op)
{
if (!op)
/*-----------------------------------------------------------------*/
/* isOperandVolatile - return 1 if the operand is volatile */
/*-----------------------------------------------------------------*/
-int
+int
isOperandVolatile (operand * op, bool chkTemp)
{
sym_link *optype;
return 0;
opetype = getSpec (optype = operandType (op));
-
- if (IS_PTR (optype) && DCL_PTR_VOLATILE (optype))
- return 1;
-
- if (IS_VOLATILE (opetype))
- return 1;
- return 0;
+
+ if (IS_PTR (optype) && DCL_PTR_VOLATILE (optype))
+ return 1;
+
+ if (IS_VOLATILE (opetype))
+ return 1;
+ return 0;
}
/*-----------------------------------------------------------------*/
/* isOperandLiteral - returns 1 if an operand contains a literal */
/*-----------------------------------------------------------------*/
-int
+int
isOperandLiteral (operand * op)
{
sym_link *opetype;
/*-----------------------------------------------------------------*/
/* isOperandInFarSpace - will return true if operand is in farSpace */
/*-----------------------------------------------------------------*/
-bool
+bool
isOperandInFarSpace (operand * op)
{
sym_link *etype;
/*------------------------------------------------------------------*/
/* isOperandInDirSpace - will return true if operand is in dirSpace */
/*------------------------------------------------------------------*/
-bool
+bool
isOperandInDirSpace (operand * op)
{
sym_link *etype;
/*--------------------------------------------------------------------*/
/* isOperandInCodeSpace - will return true if operand is in codeSpace */
/*--------------------------------------------------------------------*/
-bool
+bool
isOperandInCodeSpace (operand * op)
{
sym_link *etype;
/*-----------------------------------------------------------------*/
/* isOperandOnStack - will return true if operand is on stack */
/*-----------------------------------------------------------------*/
-bool
+bool
isOperandOnStack (operand * op)
{
sym_link *etype;
/* isOclsExpensive - will return true if accesses to an output */
/* storage class are expensive */
/*-----------------------------------------------------------------*/
-bool
+bool
isOclsExpensive (struct memmap *oclass)
{
if (port->oclsExpense)
isiCodeInFunctionCall (iCode * ic)
{
iCode * lic = ic;
-
+
/* Find the next CALL/PCALL */
while (lic)
{
break;
lic = lic->next;
}
-
+
if (!lic)
return FALSE;
return TRUE;
ic = ic->prev;
}
-
+
return FALSE;
}
return (compareType (left->operand.valOperand->type,
right->operand.valOperand->type) &&
(floatFromVal (left->operand.valOperand) ==
- floatFromVal (right->operand.valOperand)))
+ floatFromVal (right->operand.valOperand)));
case TYPE:
if (compareType (left->operand.typeOperand,
right->operand.typeOperand) == 1)
/*-------------------------------------------------------------------*/
/* isiCodeEqual - compares two iCodes are equal, returns true if yes */
/*-------------------------------------------------------------------*/
-int
+int
isiCodeEqual (iCode * left, iCode * right)
{
/* if the same pointer */
if (!isSymbolEqual (IC_FALSE (left), IC_FALSE (right)))
return 0;
}
-
+
return 1;
}
return 0;
nop->isLiteral = op->isLiteral;
nop->usesDefs = op->usesDefs;
nop->isParm = op->isParm;
-
+
switch (nop->type)
{
case SYMBOL:
ok && /* farspace check */
!IS_BITVAR (sym->etype) /* not a bit variable */
)
- {
+ {
/* we will use it after all optimizations
and before liveRange calculation */
default:
assert (0);
}
-
+
/* Just to keep the compiler happy */
return (operand *) 0;
}
/*-----------------------------------------------------------------*/
/* setOperandType - sets the operand's type to the given type */
/*-----------------------------------------------------------------*/
-void
+void
setOperandType (operand * op, sym_link * type)
{
/* depending on the type of operand */
*op1 = geniCodeCast (ctype, *op1, TRUE);
*op2 = geniCodeCast (ctype, *op2, TRUE);
-
+
return ctype;
}
geniCodeArray2Ptr (op);
op->isaddr = 0;
}
-
+
/* if the operand is already the desired type then do nothing */
if (compareType (type, optype) == 1)
return op;
}
/* if they are the same size create an assignment */
-
+
/* This seems very dangerous to me, since there are several */
/* optimizations (for example, gcse) that don't notice the */
/* cast hidden in this assignement and may simplify an */
if (IS_VOID(ltype->next) || IS_VOID(rtype->next)) {
return result;
}
-
+
// should we really do this? is this ANSI?
return geniCodeDivision (result,
operandFromLit (getSize (ltype->next)),
op->isaddr = 0;
return op;
}
-
+
/* lvalue check already done in decorateType */
/* this must be a lvalue */
/* if (!op->isaddr && !IS_AGGREGATE(optype)) { */
/*-----------------------------------------------------------------*/
/* setOClass - sets the output class depending on the pointer type */
/*-----------------------------------------------------------------*/
-void
+void
setOClass (sym_link * ptr, sym_link * spec)
{
switch (DCL_TYPE (ptr))
/* outputclass needs 2b updated */
setOClass (optype, retype);
}
-
+
op->isGptr = IS_GENPTR (optype);
op->isaddr = (IS_PTR (rtype) ||
ic = setNextItem (iCodeChain);
}
/* if casting literal to generic pointer, then cast to rtype instead */
- if (ic && (ic->op == CAST) && isOperandLiteral(IC_RIGHT (ic)))
+ if (ic && (ic->op == CAST) && isOperandLiteral(IC_RIGHT (ic)))
{
left = operandFromValue (valCastLiteral (rtype, operandLitValue (IC_RIGHT (ic))));
ltype = operandType(left);
ic = setNextItem (iCodeChain);
}
/* if casting literal to generic pointer, then cast to rtype instead */
- if (ic && (ic->op == CAST) && isOperandLiteral(IC_RIGHT (ic)))
+ if (ic && (ic->op == CAST) && isOperandLiteral(IC_RIGHT (ic)))
{
right = operandFromValue (valCastLiteral (ltype, operandLitValue (IC_RIGHT (ic))));
rtype = operandType(right);
else /* OR_OP */
ic = newiCodeCondition (op, trueLabel, NULL);
ADDTOCHAIN (ic);
-
+
/* evaluate right operand */
condition = ast2iCode (tree->right, lvl + 1);
op = geniCodeRValue (condition, FALSE);
-
+
/* test right operand */
ic = newiCodeCondition (op, trueLabel, NULL);
ADDTOCHAIN (ic);
-
+
/* store 0 or 1 in result */
result = newiTempOperand (newCharLink(), 1);
-
+
geniCodeLabel (falseLabel);
geniCodeAssign (result, operandFromLit (0), 0, 0);
/* generate an unconditional goto */
check if the literal value is within bounds */
if (IS_INTEGRAL (ltype) && right->type == VALUE && IS_LITERAL (rtype))
{
- checkConstantRange(ltype,
+ checkConstantRange(ltype,
OP_VALUE(right), "= operation", 0);
}
if (!IS_VOLATILE(type))
return;
-
+
ic = newiCode (DUMMY_READ_VOLATILE, NULL, op);
ADDTOCHAIN (ic);
/*-----------------------------------------------------------------*/
/* geniCodeSEParms - generate code for side effecting fcalls */
/*-----------------------------------------------------------------*/
-static void
+static void
geniCodeSEParms (ast * parms,int lvl)
{
if (!parms)
IS_ADDRESS_OF_OP (parms->right))
parms->right->left->lvalue = 1;
- parms->opval.oprnd =
+ parms->opval.oprnd =
geniCodeRValue (ast2iCode (parms,lvl+1), FALSE);
-
+
parms->type = EX_OPERAND;
AST_ARGREG(parms) = parms->etype ? SPEC_ARGREG(parms->etype) :
SPEC_ARGREG(parms->ftype);
/* geniCodeParms - generates parameters */
/*-----------------------------------------------------------------*/
value *
-geniCodeParms (ast * parms, value *argVals, int *stack,
+geniCodeParms (ast * parms, value *argVals, int *stack,
sym_link * ftype, int lvl)
{
iCode *ic;
sym_link *ftype;
int stack = 0;
- if (!IS_FUNC(OP_SYMBOL(left)->type) &&
+ if (!IS_FUNC(OP_SYMBOL(left)->type) &&
!IS_CODEPTR(OP_SYMBOL(left)->type)) {
werror (E_FUNCTION_EXPECTED);
return operandFromValue(valueFromLit(0));
ftype = operandType (left);
if (IS_CODEPTR (ftype))
ftype = ftype->next;
-
+
/* first the parameters */
geniCodeParms (parms, NULL, &stack, ftype, lvl);
/*-----------------------------------------------------------------*/
/* geniCodeReceive - generate intermediate code for "receive" */
/*-----------------------------------------------------------------*/
-static void
+static void
geniCodeReceive (value * args)
{
unsigned char paramByteCounter = 0;
}
}
- ic = newiCode (RECEIVE, NULL, NULL);
+ ic = newiCode (RECEIVE, NULL, NULL);
ic->argreg = SPEC_ARGREG(args->etype);
if (first) {
currFunc->recvSize = getSize (sym->type);
first = 0;
}
IC_RESULT (ic) = opr;
-
- /* misuse of parmBytes (normally used for functions)
+
+ /* misuse of parmBytes (normally used for functions)
* to save estimated stack position of this argument.
* Normally this should be zero for RECEIVE iCodes.
* No idea if this causes side effects on other ports. - dw
*/
ic->parmBytes = paramByteCounter;
-
+
/* what stack position do we have? */
paramByteCounter += getSize (sym->type);
/*-----------------------------------------------------------------*/
/* geniCodeFunctionBody - create the function body */
/*-----------------------------------------------------------------*/
-void
+void
geniCodeFunctionBody (ast * tree,int lvl)
{
iCode *ic;
/*-----------------------------------------------------------------*/
/* geniCodeReturn - gen icode for 'return' statement */
/*-----------------------------------------------------------------*/
-void
+void
geniCodeReturn (operand * op)
{
iCode *ic;
/*-----------------------------------------------------------------*/
/* geniCodeIfx - generates code for extended if statement */
/*-----------------------------------------------------------------*/
-void
+void
geniCodeIfx (ast * tree,int lvl)
{
iCode *ic;
/*-----------------------------------------------------------------*/
/* geniCodeJumpTable - tries to create a jump table for switch */
/*-----------------------------------------------------------------*/
-int
+int
geniCodeJumpTable (operand * cond, value * caseVals, ast * tree)
{
int min, max, cnt = 1;
case 4: sizeIndex = 2; break;
default: return 0;
}
-
+
/* Compute the size cost of the range check and subtraction. */
sizeofMinCost = 0;
sizeofZeroMinCost = 0;
}
if (min)
sizeofMinCost += port->jumptableCost.sizeofSubtract;
-
+
/* If the size cost of handling a non-zero minimum exceeds the */
/* cost of extending the range down to zero, then it might be */
/* better to extend the range to zero. */
sizeofMinCost = port->jumptableCost.sizeofRangeCompare[sizeIndex];
}
}
-
+
/* Compute the total size cost of a jump table. */
sizeofJumpTable = (1 + max - min) * port->jumptableCost.sizeofElement
+ port->jumptableCost.sizeofDispatch
return 0;
/* The jump table is preferable. */
-
+
/* First, a label for the default or missing cases. */
if (tree->values.switchVals.swDefault)
{
if (vch && t==i)
{
/* Explicit case: make a new label for it. */
- SNPRINTF (buffer, sizeof(buffer),
+ SNPRINTF (buffer, sizeof(buffer),
"_case_%d_%d",
tree->values.switchVals.swNum,
i);
operand *cond = geniCodeRValue (ast2iCode (tree->left,lvl+1), FALSE);
value *caseVals = tree->values.switchVals.swVals;
symbol *trueLabel, *falseLabel;
-
+
/* If the condition is a literal, then just jump to the */
/* appropriate case label. */
if (IS_LITERAL(getSpec(operandType(cond))))
{
int switchVal, caseVal;
-
+
switchVal = (int) floatFromVal (cond->operand.valOperand);
while (caseVals)
{
}
goto defaultOrBreak;
}
-
+
/* If cond is volatile, it might change while we are trying to */
/* find the matching case. To avoid this possibility, make a */
/* non-volatile copy to use instead. */
{
operand * newcond;
iCode * ic;
-
+
newcond = newiTempOperand (operandType (cond), TRUE);
newcond->isvolatile = 0;
ic = newiCode ('=', NULL, cond);
/*-----------------------------------------------------------------*/
/* geniCodeInline - intermediate code for inline assembler */
/*-----------------------------------------------------------------*/
-static void
+static void
geniCodeInline (ast * tree)
{
iCode *ic;
}
ADDTOCHAIN (ic);
}
-
+
/*-----------------------------------------------------------------*/
/* geniCodeCritical - intermediate code for a critical statement */
/*-----------------------------------------------------------------*/
-static void
+static void
geniCodeCritical (ast *tree, int lvl)
{
iCode *ic;
/* If op is NULL, the original interrupt state will saved on */
/* the stack. Otherwise, it will be saved in op. */
-
+
/* Generate a save of the current interrupt state & disable */
ic = newiCode (CRITICAL, NULL, NULL);
IC_RESULT (ic) = op;
ADDTOCHAIN (ic);
-
+
/* Generate the critical code sequence */
if (tree->left && tree->left->type == EX_VALUE)
geniCodeDummyRead (ast2iCode (tree->left,lvl+1));
else
ast2iCode (tree->left,lvl+1);
-
+
/* Generate a restore of the original interrupt state */
ic = newiCode (ENDCRITICAL, NULL, op);
ADDTOCHAIN (ic);
geniCodeAssign (left,
geniCodeMultiply (geniCodeRValue (operandFromOperand (left),
FALSE),
- geniCodeRValue (right, FALSE),
+ geniCodeRValue (right, FALSE),
getResultTypeFromType (tree->ftype)),
0, 1);
case INLINEASM:
geniCodeInline (tree);
return NULL;
-
+
case ARRAYINIT:
geniCodeArrayInit(tree, ast2iCode (tree->left,lvl+1));
return NULL;
-
+
case CRITICAL:
geniCodeCritical (tree, lvl);
}
case VALUE: return "value";
case TYPE: return "type";
}
- return "undefined type";
+ return "undefined type";
}
-operand *validateOpType(operand *op,
+operand *validateOpType(operand *op,
const char *macro,
const char *args,
OPTYPE type,
- const char *file,
+ const char *file,
unsigned line)
-{
+{
if (op && op->type == type)
{
return op;
}
- fprintf(stderr,
+ fprintf(stderr,
"Internal error: validateOpType failed in %s(%s) @ %s:%u:"
" expected %s, got %s\n",
- macro, args, file, line,
+ macro, args, file, line,
opTypeToStr(type), op ? opTypeToStr(op->type) : "null op");
exit(-1);
return op; // never reached, makes compiler happy.
projects / fw / sdcc / commitdiff