/*-----------------------------------------------------------------*/
int printOperand (operand *op, FILE *file)
{
- link *opetype;
+ sym_link *opetype;
int pnl = 0;
if (!op)
/*-----------------------------------------------------------------*/
/* newiTempOperand - new intermediate temp operand */
/*-----------------------------------------------------------------*/
-operand *newiTempOperand (link *type, char throwType)
+operand *newiTempOperand (sym_link *type, char throwType)
{
symbol *itmp;
operand *op = newOperand();
- link *etype;
+ sym_link *etype;
op->type = SYMBOL ;
itmp = newiTemp(NULL);
/*-----------------------------------------------------------------*/
/* operandType - returns the type chain for an operand */
/*-----------------------------------------------------------------*/
-link *operandType (operand *op)
+sym_link *operandType (operand *op)
{
/* depending on type of operand */
switch (op->type) {
" operand type not known ");
assert (0) ; /* should never come here */
/* Just to keep the compiler happy */
- return (link *)0;
+ return (sym_link *)0;
}
}
/*-----------------------------------------------------------------*/
int isOperandVolatile ( operand *op , bool chkTemp)
{
- link *optype ;
- link *opetype ;
+ sym_link *optype ;
+ sym_link *opetype ;
if (IS_ITEMP(op) && !chkTemp)
return 0;
/*-----------------------------------------------------------------*/
int isOperandLiteral ( operand *op )
{
- link *opetype ;
+ sym_link *opetype ;
if (!op)
return 0;
/*-----------------------------------------------------------------*/
bool isOperandInFarSpace (operand *op)
{
- link *etype;
+ sym_link *etype;
if (!op)
return FALSE;
return (IN_FARSPACE(SPEC_OCLS(etype)) ? TRUE : FALSE);
}
+/*-----------------------------------------------------------------*/
+/* isOperandOnStack - will return true if operand is on stack */
+/*-----------------------------------------------------------------*/
+bool isOperandOnStack(operand *op)
+{
+ sym_link *etype;
+
+ if (!op)
+ return FALSE;
+
+ if (!IS_SYMOP(op))
+ return FALSE ;
+
+ etype = getSpec(operandType(op));
+
+ return ((IN_STACK(etype)) ? TRUE : FALSE);
+}
+
/*-----------------------------------------------------------------*/
/* operandLitValue - literal value of an operand */
/*-----------------------------------------------------------------*/
/* operandOperation - perforoms operations on operands */
/*-----------------------------------------------------------------*/
operand *operandOperation (operand *left,operand *right,
- int op, link *type)
+ int op, sym_link *type)
{
operand *retval = (operand *)0;
/*-----------------------------------------------------------------*/
/* operandFromLink - operand from typeChain */
/*-----------------------------------------------------------------*/
-operand *operandFromLink (link *type)
+operand *operandFromLink (sym_link *type)
{
operand *op ;
- /* operand from link */
+ /* operand from sym_link */
if ( ! type )
return NULL ;
/*-----------------------------------------------------------------*/
/* setOperandType - sets the operand's type to the given type */
/*-----------------------------------------------------------------*/
-void setOperandType (operand *op, link *type)
+void setOperandType (operand *op, sym_link *type)
{
/* depending on the type of operand */
switch (op->type) {
}
+/*-----------------------------------------------------------------*/
+/* perform "usual unary conversions" */
+/*-----------------------------------------------------------------*/
+operand *usualUnaryConversions(operand *op)
+{
+ if (IS_INTEGRAL(operandType(op)))
+ {
+ if (getSize(operandType(op)) < INTSIZE)
+ {
+ /* Widen to int. */
+ return geniCodeCast(INTTYPE,op,TRUE);
+ }
+ }
+ return op;
+}
+
+/*-----------------------------------------------------------------*/
+/* perform "usual binary conversions" */
+/*-----------------------------------------------------------------*/
+sym_link * usualBinaryConversions(operand **op1, operand **op2)
+{
+ if (!options.ANSIint)
+ {
+ /* "Classic" SDCC behavior. */
+ sym_link *ctype;
+ sym_link *rtype = operandType(*op2);
+ sym_link *ltype = operandType(*op1);
+
+ ctype = computeType(ltype,rtype);
+ *op1 = geniCodeCast(ctype,*op1,TRUE);
+ *op2= geniCodeCast(ctype,*op2,TRUE);
+
+ return ctype;
+ }
+
+ *op1 = usualUnaryConversions(*op1);
+ *op2 = usualUnaryConversions(*op2);
+
+ /* Try to make the two operands of the same type, following
+ * the "usual binary conversions" promotion rules.
+ *
+ * NB: floating point types are not yet properly handled; we
+ * follow the "classic" behavior.
+ */
+
+ if (IS_FLOAT(operandType(*op1)) || IS_FLOAT(operandType(*op2)))
+ {
+ return newFloatLink();
+ }
+
+ if (!IS_INTEGRAL(operandType(*op1)) || !IS_INTEGRAL(operandType(*op2)))
+ {
+ /* if either is not an integer type, we're done. */
+ return copyLinkChain(operandType(*op1)); /* Punt! we should never get here. */
+ }
+
+ /* If either is an unsigned long, make sure both are. */
+ if (SPEC_USIGN(operandType(*op1)) && IS_LONG(operandType(*op1)))
+ {
+ if (!SPEC_USIGN(operandType(*op2)) || !IS_LONG(operandType(*op2)))
+ {
+ *op2 = geniCodeCast(ULONGTYPE,*op2,TRUE);
+ }
+ return copyLinkChain(operandType(*op1));
+ }
+
+ if (SPEC_USIGN(operandType(*op2)) && IS_LONG(operandType(*op2)))
+ {
+ if (!SPEC_USIGN(operandType(*op1)) || !IS_LONG(operandType(*op1)))
+ {
+ *op1 = geniCodeCast(ULONGTYPE,*op1,TRUE);
+ }
+ return copyLinkChain(operandType(*op2));
+ }
+
+ /* Next, if one is long and the other is int (signed or un),
+ * cast both to long.
+ *
+ * Note that because in our environment a long can hold all
+ * the values of an unsigned int, the "long/unsigned int" pair
+ * in the ANSI conversion table is unnecessary; this test
+ * handles that case implicitly.
+ */
+ if (IS_LONG(operandType(*op1)))
+ {
+ /* NB: because of the unary conversions, op2 cannot
+ * be smaller than int. Therefore, if it is not
+ * long, it is a regular int.
+ */
+ if (!IS_LONG(operandType(*op2)))
+ {
+ *op2 = geniCodeCast(LONGTYPE,*op2,TRUE);
+ }
+ return copyLinkChain(operandType(*op1));
+ }
+
+ if (IS_LONG(operandType(*op2)))
+ {
+ /* NB: because of the unary conversions, op2 cannot
+ * be smaller than int. Therefore, if it is not
+ * long, it is a regular int.
+ */
+ if (!IS_LONG(operandType(*op1)))
+ {
+ *op1 = geniCodeCast(LONGTYPE,*op1,TRUE);
+ }
+ return copyLinkChain(operandType(*op2));
+ }
+
+ /* All right, neither is long; they must both be integers.
+ *
+ * Only remaining issue is signed vs. unsigned; if one is unsigned
+ * and the other isn't, convert both to unsigned.
+ */
+ if (SPEC_USIGN(operandType(*op1)))
+ {
+ if (!SPEC_USIGN(operandType(*op2)))
+ {
+ *op2 = geniCodeCast(UINTTYPE,*op2,TRUE);
+ }
+ return copyLinkChain(operandType(*op1));
+ }
+
+ if (SPEC_USIGN(operandType(*op2)))
+ {
+ if (!SPEC_USIGN(operandType(*op1)))
+ {
+ *op1 = geniCodeCast(UINTTYPE,*op1,TRUE);
+ }
+ return copyLinkChain(operandType(*op2));
+ }
+
+ /* Done! */
+ return copyLinkChain(operandType(*op1));
+}
+
+
/*-----------------------------------------------------------------*/
/* geniCodeValueAtAddress - generate intermeditate code for value */
/* at address */
operand *geniCodeRValue (operand *op, bool force)
{
iCode *ic ;
- link *type = operandType(op);
- link *etype= getSpec(type);
+ sym_link *type = operandType(op);
+ sym_link *etype= getSpec(type);
/* if this is an array & already */
/* an address then return this */
/* if this is not a temp symbol then */
if (!IS_ITEMP(op) &&
- !force &&
+ !force &&
!IN_FARSPACE(SPEC_OCLS(etype))) {
op = operandFromOperand(op);
op->isaddr = 0;
if (IS_SPEC(type) &&
IS_TRUE_SYMOP(op) &&
- !IN_FARSPACE(SPEC_OCLS(etype))) {
+ (!IN_FARSPACE(SPEC_OCLS(etype)) || IS_DS390_PORT)) {
op = operandFromOperand(op);
op->isaddr = 0;
return op;
/*-----------------------------------------------------------------*/
/* geniCodeCast - changes the value from one type to another */
/*-----------------------------------------------------------------*/
-operand *geniCodeCast (link *type, operand *op, bool implicit)
+operand *geniCodeCast (sym_link *type, operand *op, bool implicit)
{
iCode *ic ;
- link *optype ;
- link *opetype = getSpec(optype = operandType(op));
- link *restype ;
+ sym_link *optype ;
+ sym_link *opetype = getSpec(optype = operandType(op));
+ sym_link *restype ;
/* one of them has size zero then error */
if (IS_VOID(optype)) {
{
iCode *ic ;
int p2 = 0;
- link *resType ;
+ sym_link *resType ;
LRTYPE ;
/* if they are both literal then we know the result */
return operandFromValue (valMult(left->operand.valOperand,
right->operand.valOperand));
- resType = computeType (ltype,rtype) ;
- left = geniCodeCast(resType,left,TRUE);
- right= geniCodeCast(resType,right,TRUE);
+ resType = usualBinaryConversions(&left, &right);
/* if the right is a literal & power of 2 */
/* then make it a left shift */
{
iCode *ic ;
int p2 = 0;
- link *resType;
- link *rtype = operandType(right);
- link *retype= getSpec(rtype);
- link *ltype = operandType(left);
- link *letype= getSpec(ltype);
+ sym_link *resType;
+ sym_link *rtype = operandType(right);
+ sym_link *retype= getSpec(rtype);
+ sym_link *ltype = operandType(left);
+ sym_link *letype= getSpec(ltype);
- resType = computeType (ltype,rtype) ;
- left = geniCodeCast(resType,left,TRUE);
- right= geniCodeCast(resType,right,TRUE);
+ resType = usualBinaryConversions(&left, &right);
/* if the right is a literal & power of 2 */
/* then make it a right shift */
operand *geniCodeModulus (operand *left, operand *right)
{
iCode *ic ;
- link *resType;
+ sym_link *resType;
LRTYPE ;
/* if they are both literal then we know the result */
return operandFromValue (valMod(left->operand.valOperand,
right->operand.valOperand));
- resType = computeType (ltype,rtype) ;
- left = geniCodeCast(resType,left,TRUE);
- right= geniCodeCast(resType,right,TRUE);
+ resType = usualBinaryConversions(&left, &right);
/* now they are the same size */
ic = newiCode('%',left,right);
{
iCode *ic ;
int isarray= 0;
- link *resType;
+ sym_link *resType;
LRTYPE ;
/* if they both pointers then */
resType = copyLinkChain(IS_ARRAY(ltype) ? ltype->next : ltype);
}
else { /* make them the same size */
- resType = computeType (ltype,rtype) ;
- left = geniCodeCast(resType,left,TRUE);
- right= geniCodeCast(resType,right,TRUE);
+ resType = usualBinaryConversions(&left, &right);
}
ic = newiCode('-',left,right);
operand *geniCodeAdd (operand *left, operand *right )
{
iCode *ic ;
- link *resType ;
+ sym_link *resType ;
operand *size ;
int isarray = 0;
LRTYPE ;
isarray = left->isaddr;
size =
operandFromLit(getSize(ltype->next));
+ if (getSize(ltype) > 1 && (getSize(rtype) < INTSIZE))
+ {
+ right = geniCodeCast(INTTYPE,right,TRUE);
+ }
right = geniCodeMultiply (right ,size);
- if (getSize(ltype) > 1)
- right = geniCodeCast(INTTYPE,right,TRUE);
+
resType = copyLinkChain(ltype);
}
else { /* make them the same size */
- resType = computeType (ltype,rtype) ;
- left = geniCodeCast(resType,left,TRUE);
- right= geniCodeCast(resType,right,TRUE);
+ resType = usualBinaryConversions(&left, &right);
}
/* if they are both literals then we know */
/*-----------------------------------------------------------------*/
/* aggrToPtr - changes an aggregate to pointer to an aggregate */
/*-----------------------------------------------------------------*/
-link *aggrToPtr ( link *type, bool force)
+sym_link *aggrToPtr ( sym_link *type, bool force)
{
- link *etype ;
- link *ptype ;
+ sym_link *etype ;
+ sym_link *ptype ;
if (IS_PTR(type) && !force)
/*-----------------------------------------------------------------*/
operand *geniCodeArray2Ptr (operand *op)
{
- link *optype = operandType(op);
- link *opetype = getSpec(optype);
+ sym_link *optype = operandType(op);
+ sym_link *opetype = getSpec(optype);
/* set the pointer depending on the storage class */
if ((DCL_TYPE(optype) = PTR_TYPE(SPEC_OCLS(opetype))) == CPOINTER)
return op;
}
+
/*-----------------------------------------------------------------*/
/* geniCodeArray - array access */
/*-----------------------------------------------------------------*/
operand *geniCodeArray (operand *left,operand *right)
{
iCode *ic;
- link *ltype = operandType(left);
+ sym_link *ltype = operandType(left);
if (IS_PTR(ltype)) {
if (IS_PTR(ltype->next) && left->isaddr)
+ {
left = geniCodeRValue(left,FALSE);
+ }
return geniCodeDerefPtr(geniCodeAdd(left,right));
}
/* array access */
+ right = usualUnaryConversions(right);
right = geniCodeMultiply(right,
operandFromLit(getSize(ltype->next)));
operand *geniCodeStruct (operand *left, operand *right, bool islval)
{
iCode *ic ;
- link *type = operandType(left);
- link *etype = getSpec(type);
- link *retype ;
+ sym_link *type = operandType(left);
+ sym_link *etype = getSpec(type);
+ sym_link *retype ;
symbol *element = getStructElement(SPEC_STRUCT(etype),
right->operand.symOperand);
{
iCode *ic ;
operand *rOp ;
- link *optype = operandType(op);
+ sym_link *optype = operandType(op);
operand *result ;
operand *rv = (IS_ITEMP(op) ?
geniCodeRValue(op,(IS_PTR(optype) ? TRUE : FALSE)) :
op);
- link *rvtype = operandType(rv);
+ sym_link *rvtype = operandType(rv);
int size = 0;
/* if this is not an address we have trouble */
operand *geniCodePreInc (operand *op)
{
iCode *ic ;
- link *optype = operandType(op);
+ sym_link *optype = operandType(op);
operand *rop = (IS_ITEMP(op) ?
geniCodeRValue (op,(IS_PTR(optype) ? TRUE : FALSE)) :
op);
- link *roptype = operandType(rop);
+ sym_link *roptype = operandType(rop);
operand *result;
int size = 0;
{
iCode *ic ;
operand *rOp ;
- link *optype = operandType(op);
+ sym_link *optype = operandType(op);
operand *result ;
operand *rv = (IS_ITEMP(op) ?
geniCodeRValue(op,(IS_PTR(optype) ? TRUE : FALSE)) :
op);
- link *rvtype = operandType(rv);
+ sym_link *rvtype = operandType(rv);
int size = 0;
/* if this is not an address we have trouble */
operand *geniCodePreDec (operand *op)
{
iCode *ic ;
- link *optype = operandType(op);
+ sym_link *optype = operandType(op);
operand *rop = (IS_ITEMP(op) ?
geniCodeRValue (op,(IS_PTR(optype) ? TRUE : FALSE)) :
op);
- link *roptype = operandType(rop);
+ sym_link *roptype = operandType(rop);
operand *result;
int size = 0;
/* geniCodeBitwise - gen int code for bitWise operators */
/*-----------------------------------------------------------------*/
operand *geniCodeBitwise (operand *left, operand *right,
- int oper, link *resType)
+ int oper, sym_link *resType)
{
iCode *ic;
operand *geniCodeAddressOf (operand *op)
{
iCode *ic;
- link *p ;
- link *optype = operandType(op);
- link *opetype= getSpec(optype);
+ sym_link *p ;
+ sym_link *optype = operandType(op);
+ sym_link *opetype= getSpec(optype);
/* lvalue check already done in decorateType */
/* this must be a lvalue */
/*-----------------------------------------------------------------*/
/* setOClass - sets the output class depending on the pointer type */
/*-----------------------------------------------------------------*/
-void setOClass (link *ptr, link *spec)
+void setOClass (sym_link *ptr, sym_link *spec)
{
switch (DCL_TYPE(ptr)) {
case POINTER:
/*-----------------------------------------------------------------*/
operand *geniCodeDerefPtr (operand *op)
{
- link *rtype , *retype ;
- link *optype = operandType(op);
+ sym_link *rtype , *retype ;
+ sym_link *optype = operandType(op);
/* if this is a pointer then generate the rvalue */
if (IS_PTR(optype)) {
operand *geniCodeUnaryMinus (operand *op)
{
iCode *ic ;
- link *optype = operandType(op);
+ sym_link *optype = operandType(op);
if (IS_LITERAL(optype))
return operandFromLit(- floatFromVal(op->operand.valOperand));
operand *geniCodeLeftShift (operand *left, operand *right)
{
iCode *ic;
- link *ltype = operandType(left);
-
+
+ /* Note that we don't use the usual binary conversions for the
+ * shift operations, in accordance with our ANSI friends.
+ */
+ if (options.ANSIint)
+ {
+ right = usualUnaryConversions(right);
+ left = usualUnaryConversions(left);
+ }
+
ic = newiCode(LEFT_OP,left,right);
- IC_RESULT(ic) = newiTempOperand(ltype,0);
+ IC_RESULT(ic) = newiTempOperand(operandType(left),0);
ADDTOCHAIN(ic);
return IC_RESULT(ic) ;
}
operand *geniCodeRightShift (operand *left, operand *right)
{
iCode *ic;
- link *ltype = operandType(left);
+
+ /* Note that we don't use the usual binary conversions for the
+ * shift operations, in accordance with our ANSI friends.
+ */
+ if (options.ANSIint)
+ {
+ right = usualUnaryConversions(right);
+ left = usualUnaryConversions(left);
+ }
ic = newiCode(RIGHT_OP,left,right);
- IC_RESULT(ic) = newiTempOperand(ltype,0);
+ IC_RESULT(ic) = newiTempOperand(operandType(left),0);
ADDTOCHAIN(ic);
return IC_RESULT(ic) ;
}
-#ifdef __BORLANDC__
+#if defined(__BORLANDC__) || defined(_MSC_VER)
#define LONG_LONG __int64
#else
#define LONG_LONG long long
operand *geniCodeLogic (operand *left, operand *right, int op )
{
iCode *ic ;
- link *ctype;
- link *rtype = operandType(right);
- link *ltype = operandType(left);
+ sym_link *ctype;
+ sym_link *rtype = operandType(right);
+ sym_link *ltype = operandType(left);
/* left is integral type and right is literal then
check if the literal value is within bounds */
werror(W_CONST_RANGE," compare operation ");
}
- ctype = computeType(ltype,rtype);
- left = geniCodeCast(ctype,left,TRUE);
- right= geniCodeCast(ctype,right,TRUE);
+ ctype = usualBinaryConversions(&left, &right);
ic = newiCode(op,left,right);
IC_RESULT(ic) = newiTempOperand (newCharLink(),1);
operand *geniCodeAssign (operand *left, operand *right, int nosupdate)
{
iCode *ic ;
- link *ltype = operandType(left);
- link *rtype = operandType(right);
+ sym_link *ltype = operandType(left);
+ sym_link *rtype = operandType(right);
if (!left->isaddr && !IS_ITEMP(left)) {
werror(E_LVALUE_REQUIRED,"assignment");
/*-----------------------------------------------------------------*/
/* geniCodeParms - generates parameters */
/*-----------------------------------------------------------------*/
-static void geniCodeParms ( ast *parms , int *stack, link *fetype)
+static void geniCodeParms ( ast *parms , int *stack, sym_link *fetype, symbol *func)
{
iCode *ic ;
operand *pval ;
/* if this is a param node then do the left & right */
if (parms->type == EX_OP && parms->opval.op == PARAM) {
- geniCodeParms (parms->left, stack,fetype) ;
- geniCodeParms (parms->right, stack,fetype);
+ geniCodeParms (parms->left, stack,fetype,func) ;
+ geniCodeParms (parms->right, stack,fetype,func);
return ;
}
/* if register parm then make it a send */
if (((parms->argSym && IS_REGPARM(parms->argSym->etype)) ||
- IS_REGPARM(parms->etype)) &&
- !IS_RENT(fetype)) {
+ IS_REGPARM(parms->etype)) && !func->hasVargs ) {
ic = newiCode(SEND,pval,NULL);
ADDTOCHAIN(ic);
} else {
geniCodeAssign(top,pval,1);
}
else {
- link *p = operandType(pval);
+ sym_link *p = operandType(pval);
/* push */
ic = newiCode(IPUSH,pval,NULL);
ic->parmPush = 1;
{
iCode *ic ;
operand *result ;
- link *type, *etype;
+ sym_link *type, *etype;
int stack = 0 ;
/* take care of parameters with side-effecting
geniCodeSEParms ( parms );
/* first the parameters */
- geniCodeParms ( parms , &stack , getSpec(operandType(left)));
+ geniCodeParms ( parms , &stack , getSpec(operandType(left)), OP_SYMBOL(left));
/* now call : if symbol then pcall */
if (IS_ITEMP(left))
{
iCode *ic ;
operand *func ;
- link *fetype ;
+ sym_link *fetype ;
int savelineno ;
/* reset the auto generation */
{
iCode *ic;
operand *condition = ast2iCode(tree->left);
- link *cetype;
+ sym_link *cetype;
/* if condition is null then exit */
if (!condition)
/* first we rule out the boundary conditions */
/* if only optimization says so */
if ( ! optimize.noJTabBoundary ) {
- link *cetype = getSpec(operandType(cond));
+ sym_link *cetype = getSpec(operandType(cond));
/* no need to check the lower bound if
the condition is unsigned & minimum value is zero */
if (!( min == 0 && SPEC_USIGN(cetype))) {
case '[' : /* array operation */
{
- link *ltype = operandType(left);
+ sym_link *ltype = operandType(left);
left= geniCodeRValue (left,IS_PTR(ltype->next) ? TRUE : FALSE);
right=geniCodeRValue (right,TRUE);
}
case PTR_OP: /* structure pointer dereference */
{
- link *pType;
+ sym_link *pType;
pType = operandType(left);
left = geniCodeRValue(left,TRUE);
case '=' :
{
- link *rtype = operandType(right);
- link *ltype = operandType(left);
+ sym_link *rtype = operandType(right);
+ sym_link *ltype = operandType(left);
if (IS_PTR(rtype) && IS_ITEMP(right)
&& right->isaddr && checkType(rtype->next,ltype)==1)
right = geniCodeRValue(right,TRUE);
geniCodeRValue(right,FALSE)),0);
case ADD_ASSIGN:
{
- link *rtype = operandType(right);
- link *ltype = operandType(left);
+ sym_link *rtype = operandType(right);
+ sym_link *ltype = operandType(left);
if (IS_PTR(rtype) && IS_ITEMP(right)
&& right->isaddr && checkType(rtype->next,ltype)==1)
right = geniCodeRValue(right,TRUE);
}
case SUB_ASSIGN:
{
- link *rtype = operandType(right);
- link *ltype = operandType(left);
+ sym_link *rtype = operandType(right);
+ sym_link *ltype = operandType(left);
if (IS_PTR(rtype) && IS_ITEMP(right)
&& right->isaddr && checkType(rtype->next,ltype)==1) {
right = geniCodeRValue(right,TRUE);
projects / fw / sdcc / blobdiff