/*-----------------------------------------------------------------*/
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) {
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 */
/*-----------------------------------------------------------------*/
/* 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 */
{
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);
operand *geniCodeModulus (operand *left, operand *right)
{
iCode *ic ;
- link *resType;
+ sym_link *resType;
LRTYPE ;
/* if they are both literal then we know the result */
{
iCode *ic ;
int isarray= 0;
- link *resType;
+ sym_link *resType;
LRTYPE ;
/* if they both pointers then */
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 */
/*-----------------------------------------------------------------*/
/* 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)
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 */
+ if (getSize(operandType(right)) < INTSIZE)
+ {
+ /* Widen the index type to int first. */
+ right = geniCodeCast(INTTYPE,right,TRUE);
+ }
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);
+
+ /* Operands must be promoted to int, according to ISO. */
+ if (getSize(operandType(right)) < INTSIZE)
+ {
+ right = geniCodeCast(INTTYPE,right,TRUE);
+ }
+
+ if (getSize(operandType(left)) < INTSIZE)
+ {
+ left = geniCodeCast(INTTYPE,left,TRUE);
+ }
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);
+
+ /* Operands must be promoted to int, according to ISO. */
+ if (getSize(operandType(right)) < INTSIZE)
+ {
+ right = geniCodeCast(INTTYPE,right,TRUE);
+ }
+
+ if (getSize(operandType(left)) < INTSIZE)
+ {
+ left = geniCodeCast(INTTYPE,left,TRUE);
+ }
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 */
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);