X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCicode.c;h=9dde59a1a8856cee8eada9086a2db63caab71173;hb=d5e163c45df3f0603c1f52c7d4467b60a5e0afee;hp=c2feabde7fb799ac69ea0dbec88f4471b4f25fbd;hpb=cb437439dfe19810a8b7529c9af6289afaaf4ca1;p=fw%2Fsdcc diff --git a/src/SDCCicode.c b/src/SDCCicode.c index c2feabde..9dde59a1 100644 --- a/src/SDCCicode.c +++ b/src/SDCCicode.c @@ -180,7 +180,7 @@ void checkConstantRange(sym_link *ltype, value *val, char *msg, #if 0 // temporary disabled, leaving the warning as a reminder if (warnings) { - sprintf (message, "for %s %s in %s", + SNPRINTF (message, sizeof(message), "for %s %s in %s", SPEC_USIGN(ltype) ? "unsigned" : "signed", nounName(ltype), msg); werror (W_CONST_RANGE, message); @@ -224,13 +224,14 @@ printOperand (operand * op, FILE * file) case SYMBOL: #define REGA 1 #ifdef REGA - fprintf (file, "%s [k%d lr%d:%d so:%d]{ ia%d re%d rm%d nos%d ru%d}", /*{ar%d rm%d ru%d p%d a%d u%d i%d au%d k%d ks%d}" , */ + fprintf (file, "%s [k%d lr%d:%d so:%d]{ ia%d re%d rm%d nos%d ru%d dp%d}", /*{ar%d rm%d ru%d p%d a%d u%d i%d au%d k%d ks%d}" , */ (OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name), op->key, OP_LIVEFROM (op), OP_LIVETO (op), OP_SYMBOL (op)->stack, - op->isaddr, OP_SYMBOL (op)->isreqv, OP_SYMBOL (op)->remat,OP_SYMBOL(op)->noSpilLoc, - OP_SYMBOL(op)->ruonly + op->isaddr, OP_SYMBOL (op)->isreqv, + OP_SYMBOL (op)->remat,OP_SYMBOL(op)->noSpilLoc, + OP_SYMBOL(op)->ruonly,OP_SYMBOL(op)->dptr ); { fprintf (file, "{"); @@ -385,6 +386,9 @@ PRINTFUNC (picGenericOne) if (!IC_RESULT (ic) && !IC_LEFT (ic)) fprintf (of, s); + if (ic->op == SEND || ic->op == RECEIVE) { + fprintf(of,"{argreg = %d}",ic->argreg); + } fprintf (of, "\n"); } @@ -496,7 +500,7 @@ printiCChain (iCode * icChain, FILE * of) { if ((icTab = getTableEntry (loop->op))) { - fprintf (of, "%s(%d:%d:%d:%d:%d)\t", + fprintf (of, "%s(l%d:s%d:k%d:d%d:s%d)\t", loop->filename, loop->lineno, loop->seq, loop->key, loop->depth, loop->supportRtn); @@ -573,7 +577,7 @@ newiCodeLabelGoto (int op, symbol * label) ic = newiCode (op, NULL, NULL); ic->op = op; - ic->argLabel.label = label; + ic->label = label; IC_LEFT (ic) = NULL; IC_RIGHT (ic) = NULL; IC_RESULT (ic) = NULL; @@ -589,11 +593,16 @@ newiTemp (char *s) symbol *itmp; if (s) - sprintf (buffer, "%s", s); + { + SNPRINTF (buffer, sizeof(buffer), "%s", s); + } else - sprintf (buffer, "iTemp%d", iTempNum++); + { + SNPRINTF (buffer, sizeof(buffer), "iTemp%d", iTempNum++); + } + itmp = newSymbol (buffer, 1); - strcpy (itmp->rname, itmp->name); + strncpyz (itmp->rname, itmp->name, SDCC_NAME_MAX); itmp->isitmp = 1; return itmp; @@ -612,10 +621,12 @@ newiTempLabel (char *s) return itmplbl; if (s) - itmplbl = newSymbol (s, 1); + { + itmplbl = newSymbol (s, 1); + } else { - sprintf (buffer, "iTempLbl%d", iTempLblNum++); + SNPRINTF (buffer, sizeof(buffer), "iTempLbl%d", iTempLblNum++); itmplbl = newSymbol (buffer, 1); } @@ -634,7 +645,7 @@ newiTempPreheaderLabel () { symbol *itmplbl; - sprintf (buffer, "preHeaderLbl%d", iTempLblNum++); + SNPRINTF (buffer, sizeof(buffer), "preHeaderLbl%d", iTempLblNum++); itmplbl = newSymbol (buffer, 1); itmplbl->isitmp = 1; @@ -788,6 +799,8 @@ isParameterToCall (value * args, operand * op) { value *tval = args; + wassert (IS_SYMOP(op)); + while (tval) { if (tval->sym && @@ -810,7 +823,7 @@ isOperandGlobal (operand * op) if (IS_ITEMP (op)) return 0; - if (op->type == SYMBOL && + if (IS_SYMOP(op) && (op->operand.symOperand->level == 0 || IS_STATIC (op->operand.symOperand->etype) || IS_EXTERN (op->operand.symOperand->etype)) @@ -833,13 +846,13 @@ isOperandVolatile (operand * op, bool chkTemp) 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; } /*-----------------------------------------------------------------*/ @@ -917,12 +930,11 @@ isOperandInDirSpace (operand * op) return (IN_DIRSPACE (SPEC_OCLS (etype)) ? TRUE : FALSE); } -/*-----------------------------------------------------------------*/ -/* isOperandOnStack - will return true if operand is on stack */ -/*-----------------------------------------------------------------*/ -#if 0 +/*--------------------------------------------------------------------*/ +/* isOperandInCodeSpace - will return true if operand is in codeSpace */ +/*--------------------------------------------------------------------*/ bool -isOperandOnStack (operand * op) +isOperandInCodeSpace (operand * op) { sym_link *etype; @@ -934,9 +946,23 @@ isOperandOnStack (operand * op) etype = getSpec (operandType (op)); - return ((IN_STACK (etype)) ? TRUE : FALSE); + if (!IS_TRUE_SYMOP (op)) + { + if (SPIL_LOC (op)) + etype = SPIL_LOC (op)->etype; + else + return FALSE; + } + else + { + etype = getSpec (operandType (op)); + } + return (IN_CODESPACE (SPEC_OCLS (etype)) ? TRUE : FALSE); } -#else + +/*-----------------------------------------------------------------*/ +/* isOperandOnStack - will return true if operand is on stack */ +/*-----------------------------------------------------------------*/ bool isOperandOnStack (operand * op) { @@ -956,7 +982,6 @@ isOperandOnStack (operand * op) return FALSE; } -#endif /*-----------------------------------------------------------------*/ /* operandLitValue - literal value of an operand */ @@ -1062,14 +1087,27 @@ operandOperation (operand * left, operand * right, (unsigned long) operandLitValue (right) : (long) operandLitValue (right))); break; - case RIGHT_OP: - retval = operandFromLit ((SPEC_USIGN(let) ? - (unsigned long) operandLitValue (left) : - (long) operandLitValue (left)) >> - (SPEC_USIGN(ret) ? - (unsigned long) operandLitValue (right) : - (long) operandLitValue (right))); + case RIGHT_OP: { + double lval = operandLitValue(left), rval = operandLitValue(right); + double res=0; + switch ((SPEC_USIGN(let) ? 2 : 0) + (SPEC_USIGN(ret) ? 1 : 0)) + { + case 0: // left=unsigned right=unsigned + res=(unsigned long)lval >> (unsigned long)rval; + break; + case 1: // left=unsigned right=signed + res=(unsigned long)lval >> (signed long)rval; + break; + case 2: // left=signed right=unsigned + res=(signed long)lval >> (unsigned long)rval; + break; + case 3: // left=signed right=signed + res=(signed long)lval >> (signed long)rval; + break; + } + retval = operandFromLit (res); break; + } case EQ_OP: retval = operandFromLit (operandLitValue (left) == operandLitValue (right)); @@ -1483,10 +1521,13 @@ operandFromAst (ast * tree,int lvl) case EX_LINK: return operandFromLink (tree->opval.lnk); - } + break; - assert (0); - /* Just to keep the comiler happy */ + default: + assert (0); + } + + /* Just to keep the compiler happy */ return (operand *) 0; } @@ -1581,15 +1622,16 @@ usualUnaryConversions (operand * op) /* perform "usual binary conversions" */ /*-----------------------------------------------------------------*/ sym_link * -usualBinaryConversions (operand ** op1, operand ** op2, int implicit) +usualBinaryConversions (operand ** op1, operand ** op2) { sym_link *ctype; sym_link *rtype = operandType (*op2); sym_link *ltype = operandType (*op1); ctype = computeType (ltype, rtype); - *op1 = geniCodeCast (ctype, *op1, implicit); - *op2 = geniCodeCast (ctype, *op2, implicit); + + *op1 = geniCodeCast (ctype, *op1, TRUE); + *op2 = geniCodeCast (ctype, *op2, TRUE); return ctype; } @@ -1629,7 +1671,6 @@ geniCodeRValue (operand * op, bool force) if (IS_SPEC (type) && IS_TRUE_SYMOP (op) && (!IN_FARSPACE (SPEC_OCLS (etype)) || - /* TARGET_IS_DS390)) */ (options.model == MODEL_FLAT24) )) { op = operandFromOperand (op); @@ -1686,9 +1727,7 @@ geniCodeCast (sym_link * type, operand * op, bool implicit) if (!IS_PTR(optype) && !IS_FUNC(optype) && !IS_AGGREGATE(optype)) { // from a non pointer if (IS_INTEGRAL(optype)) { // maybe this is NULL, than it's ok. - // !implicit is always ok, e.g. "(char *) = (char *) + 3;" - if (implicit && - !(IS_LITERAL(optype) && (SPEC_CVAL(optype).v_ulong ==0))) { + if (!(IS_LITERAL(optype) && (SPEC_CVAL(optype).v_ulong ==0))) { if (!TARGET_IS_Z80 && !TARGET_IS_GBZ80 && IS_GENPTR(type)) { // no way to set the storage if (IS_LITERAL(optype)) { @@ -1698,7 +1737,7 @@ geniCodeCast (sym_link * type, operand * op, bool implicit) werror(E_NONPTR2_GENPTR); errors++; } - } else { + } else if (implicit) { werror(W_INTEGRAL2PTR_NOCAST); errors++; } @@ -1767,7 +1806,8 @@ geniCodeCast (sym_link * type, operand * op, bool implicit) /* preserve the storage class & output class */ /* of the original variable */ restype = getSpec (operandType (IC_RESULT (ic))); - SPEC_SCLS (restype) = SPEC_SCLS (opetype); + if (!IS_LITERAL(opetype)) + SPEC_SCLS (restype) = SPEC_SCLS (opetype); SPEC_OCLS (restype) = SPEC_OCLS (opetype); ADDTOCHAIN (ic); @@ -1818,7 +1858,7 @@ geniCodeMultiply (operand * left, operand * right,int resultIsInt) p2 = powof2 ((unsigned long) floatFromVal (right->operand.valOperand)); } - resType = usualBinaryConversions (&left, &right, TRUE); + resType = usualBinaryConversions (&left, &right); #if 1 rtype = operandType (right); retype = getSpec (rtype); @@ -1875,12 +1915,14 @@ geniCodeDivision (operand * left, operand * right) sym_link *ltype = operandType (left); sym_link *letype = getSpec (ltype); - resType = usualBinaryConversions (&left, &right, TRUE); + resType = usualBinaryConversions (&left, &right); - /* if the right is a literal & power of 2 */ - /* then make it a right shift */ + /* if the right is a literal & power of 2 + and left is unsigned then make it a + right shift */ if (IS_LITERAL (retype) && !IS_FLOAT (letype) && + SPEC_USIGN(letype) && (p2 = powof2 ((unsigned long) floatFromVal (right->operand.valOperand)))) { ic = newiCode (RIGHT_OP, left, operandFromLit (p2)); /* right shift */ @@ -1912,7 +1954,7 @@ geniCodeModulus (operand * left, operand * right) return operandFromValue (valMod (left->operand.valOperand, right->operand.valOperand)); - resType = usualBinaryConversions (&left, &right, TRUE); + resType = usualBinaryConversions (&left, &right); /* now they are the same size */ ic = newiCode ('%', left, right); @@ -1950,6 +1992,11 @@ geniCodePtrPtrSubtract (operand * left, operand * right) ADDTOCHAIN (ic); subtractExit: + 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))); } @@ -1986,7 +2033,7 @@ geniCodeSubtract (operand * left, operand * right) } else { /* make them the same size */ - resType = usualBinaryConversions (&left, &right, TRUE); + resType = usualBinaryConversions (&left, &right); } ic = newiCode ('-', left, right); @@ -2006,7 +2053,7 @@ geniCodeSubtract (operand * left, operand * right) /* geniCodeAdd - generates iCode for addition */ /*-----------------------------------------------------------------*/ operand * -geniCodeAdd (operand * left, operand * right, int lvl, int ptrMath) +geniCodeAdd (operand * left, operand * right, int lvl) { iCode *ic; sym_link *resType; @@ -2014,10 +2061,6 @@ geniCodeAdd (operand * left, operand * right, int lvl, int ptrMath) int isarray = 0; LRTYPE; - /* if left is an array then array access */ - if (IS_ARRAY (ltype)) - return geniCodeArray (left, right,lvl); - /* if the right side is LITERAL zero */ /* return the left side */ if (IS_LITERAL (retype) && right->isLiteral && !floatFromVal (valFromType (retype))) @@ -2027,8 +2070,8 @@ geniCodeAdd (operand * left, operand * right, int lvl, int ptrMath) if (IS_LITERAL (letype) && left->isLiteral && !floatFromVal (valFromType (letype))) return right; - /* if left is an array or pointer then size */ - if (ptrMath && IS_PTR (ltype)) + /* if left is a pointer then size */ + if (IS_PTR (ltype) || IS_ARRAY(ltype)) { isarray = left->isaddr; // there is no need to multiply with 1 @@ -2040,7 +2083,7 @@ geniCodeAdd (operand * left, operand * right, int lvl, int ptrMath) } else { // make them the same size - resType = usualBinaryConversions (&left, &right, FALSE); + resType = usualBinaryConversions (&left, &right); } /* if they are both literals then we know */ @@ -2079,10 +2122,11 @@ aggrToPtr (sym_link * type, bool force) return type; etype = getSpec (type); - ptype = newLink (); + ptype = newLink (DECLARATOR); ptype->next = type; - /* if the output class is generic */ + + /* if the output class is code */ if ((DCL_TYPE (ptype) = PTR_TYPE (SPEC_OCLS (etype))) == CPOINTER) DCL_PTR_CONST (ptype) = port->mem.code_ro; @@ -2094,6 +2138,7 @@ aggrToPtr (sym_link * type, bool force) /* the variable was volatile then pointer to volatile */ if (IS_VOLATILE (etype)) DCL_PTR_VOLATILE (ptype) = 1; + return ptype; } @@ -2110,7 +2155,6 @@ geniCodeArray2Ptr (operand * op) if ((DCL_TYPE (optype) = PTR_TYPE (SPEC_OCLS (opetype))) == CPOINTER) DCL_PTR_CONST (optype) = port->mem.code_ro; - /* if the variable was declared a constant */ /* then the pointer points to a constant */ if (IS_CONSTANT (opetype)) @@ -2119,6 +2163,7 @@ geniCodeArray2Ptr (operand * op) /* the variable was volatile then pointer to volatile */ if (IS_VOLATILE (opetype)) DCL_PTR_VOLATILE (optype) = 1; + op->isaddr = 0; return op; } @@ -2139,7 +2184,7 @@ geniCodeArray (operand * left, operand * right,int lvl) { left = geniCodeRValue (left, FALSE); } - return geniCodeDerefPtr (geniCodeAdd (left, right, lvl, 1), lvl); + return geniCodeDerefPtr (geniCodeAdd (left, right, lvl), lvl); } right = geniCodeMultiply (right, @@ -2180,6 +2225,8 @@ geniCodeStruct (operand * left, operand * right, bool islval) symbol *element = getStructElement (SPEC_STRUCT (etype), right->operand.symOperand); + wassert(IS_SYMOP(right)); + /* add the offset */ ic = newiCode ('+', left, operandFromLit (element->offset)); @@ -2400,8 +2447,7 @@ geniCodeAddressOf (operand * op) /* return op; */ /* } */ - p = newLink (); - p->class = DECLARATOR; + p = newLink (DECLARATOR); /* set the pointer depending on the storage class */ if ((DCL_TYPE (p) = PTR_TYPE (SPEC_OCLS (opetype))) == CPOINTER) @@ -2482,16 +2528,19 @@ geniCodeDerefPtr (operand * op,int lvl) sym_link *rtype, *retype; sym_link *optype = operandType (op); - /* if this is a pointer then generate the rvalue */ - if (IS_PTR (optype)) + // if this is an array then array access + if (IS_ARRAY (optype)) { + // don't worry, this will be optimized out later + return geniCodeArray (op, operandFromLit (0), lvl); + } + + // just in case someone screws up + wassert (IS_PTR (optype)); + + if (IS_TRUE_SYMOP (op)) { - if (IS_TRUE_SYMOP (op)) - { - op->isaddr = 1; - op = geniCodeRValue (op, TRUE); - } - else - op = geniCodeRValue (op, TRUE); + op->isaddr = 1; + op = geniCodeRValue (op, TRUE); } /* now get rid of the pointer part */ @@ -2504,9 +2553,8 @@ geniCodeDerefPtr (operand * op,int lvl) retype = getSpec (rtype = copyLinkChain (optype->next)); } - /* if this is a pointer then outputclass needs 2b updated */ - if (IS_PTR (optype)) - setOClass (optype, retype); + /* outputclass needs 2b updated */ + setOClass (optype, retype); op->isGptr = IS_GENPTR (optype); @@ -2594,7 +2642,7 @@ geniCodeLogic (operand * left, operand * right, int op) OP_VALUE(right), "compare operation", 1); } - ctype = usualBinaryConversions (&left, &right, TRUE); + ctype = usualBinaryConversions (&left, &right); ic = newiCode (op, left, right); IC_RESULT (ic) = newiTempOperand (newCharLink (), 1); @@ -2760,10 +2808,12 @@ geniCodeSEParms (ast * parms,int lvl) 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); } /*-----------------------------------------------------------------*/ @@ -2816,6 +2866,7 @@ geniCodeParms (ast * parms, value *argVals, int *stack, IFFUNC_ISBUILTIN(func->type)) { ic = newiCode (SEND, pval, NULL); + ic->argreg = SPEC_ARGREG(parms->etype); ic->builtinSEND = FUNC_ISBUILTIN(func->type); ADDTOCHAIN (ic); } @@ -2828,7 +2879,7 @@ geniCodeParms (ast * parms, value *argVals, int *stack, /* assign */ operand *top = operandFromSymbol (argVals->sym); /* clear useDef and other bitVectors */ - OP_USES (top) = OP_DEFS (top) = OP_SYMBOL(top)->clashes = NULL; + OP_USES(top)=OP_DEFS(top)=OP_SYMBOL(top)->clashes = NULL; geniCodeAssign (top, pval, 1); } else @@ -2873,10 +2924,11 @@ geniCodeCall (operand * left, ast * parms,int lvl) geniCodeParms (parms, NULL, &stack, getSpec (operandType (left)), OP_SYMBOL (left),lvl); /* now call : if symbol then pcall */ - if (IS_OP_POINTER (left) || IS_ITEMP(left)) + if (IS_OP_POINTER (left) || IS_ITEMP(left)) { ic = newiCode (PCALL, left, NULL); - else + } else { ic = newiCode (CALL, left, NULL); + } type = copyLinkChain (operandType (left)->next); etype = getSpec (type); @@ -2900,7 +2952,7 @@ geniCodeReceive (value * args) /* for all arguments that are passed in registers */ while (args) { - + int first = 1; if (IS_REGPARM (args->etype)) { operand *opr = operandFromValue (args); @@ -2915,7 +2967,6 @@ geniCodeReceive (value * args) if (IN_FARSPACE (SPEC_OCLS (sym->etype)) && options.stackAuto == 0 && - /* !TARGET_IS_DS390) */ (!(options.model == MODEL_FLAT24)) ) { } @@ -2931,8 +2982,12 @@ geniCodeReceive (value * args) } } - ic = newiCode (RECEIVE, NULL, NULL); - currFunc->recvSize = getSize (sym->etype); + ic = newiCode (RECEIVE, NULL, NULL); + ic->argreg = SPEC_ARGREG(args->etype); + if (first) { + currFunc->recvSize = getSize (sym->type); + first = 0; + } IC_RESULT (ic) = opr; ADDTOCHAIN (ic); } @@ -2969,7 +3024,7 @@ geniCodeFunctionBody (ast * tree,int lvl) /* create a proc icode */ ic = newiCode (FUNCTION, func, NULL); - ic->lineno = OP_SYMBOL (func)->lineDef; + lineno=ic->lineno = OP_SYMBOL (func)->lineDef; ADDTOCHAIN (ic); @@ -3084,7 +3139,8 @@ geniCodeJumpTable (operand * cond, value * caseVals, ast * tree) /* all integer numbers between the maximum & minimum must */ /* be present , the maximum value should not exceed 255 */ min = max = (int) floatFromVal (vch = caseVals); - sprintf (buffer, "_case_%d_%d", + SNPRINTF (buffer, sizeof(buffer), + "_case_%d_%d", tree->values.switchVals.swNum, min); addSet (&labels, newiTempLabel (buffer)); @@ -3097,7 +3153,8 @@ geniCodeJumpTable (operand * cond, value * caseVals, ast * tree) { if (((t = (int) floatFromVal (vch)) - max) != 1) return 0; - sprintf (buffer, "_case_%d_%d", + SNPRINTF (buffer, sizeof(buffer), + "_case_%d_%d", tree->values.switchVals.swNum, t); addSet (&labels, newiTempLabel (buffer)); @@ -3113,9 +3170,14 @@ geniCodeJumpTable (operand * cond, value * caseVals, ast * tree) return 0; if (tree->values.switchVals.swDefault) - sprintf (buffer, "_default_%d", tree->values.switchVals.swNum); + { + SNPRINTF (buffer, sizeof(buffer), "_default_%d", tree->values.switchVals.swNum); + } else - sprintf (buffer, "_swBrk_%d", tree->values.switchVals.swNum); + { + SNPRINTF (buffer, sizeof(buffer), "_swBrk_%d", tree->values.switchVals.swNum); + } + falseLabel = newiTempLabel (buffer); @@ -3178,7 +3240,7 @@ geniCodeSwitch (ast * tree,int lvl) operandFromValue (caseVals), EQ_OP); - sprintf (buffer, "_case_%d_%d", + SNPRINTF (buffer, sizeof(buffer), "_case_%d_%d", tree->values.switchVals.swNum, (int) floatFromVal (caseVals)); trueLabel = newiTempLabel (buffer); @@ -3192,9 +3254,13 @@ geniCodeSwitch (ast * tree,int lvl) /* if default is present then goto break else break */ if (tree->values.switchVals.swDefault) - sprintf (buffer, "_default_%d", tree->values.switchVals.swNum); + { + SNPRINTF (buffer, sizeof(buffer), "_default_%d", tree->values.switchVals.swNum); + } else - sprintf (buffer, "_swBrk_%d", tree->values.switchVals.swNum); + { + SNPRINTF (buffer, sizeof(buffer), "_swBrk_%d", tree->values.switchVals.swNum); + } falseLabel = newiTempLabel (buffer); geniCodeGoto (falseLabel); @@ -3309,6 +3375,7 @@ ast2iCode (ast * tree,int lvl) operand *right = NULL; if (!tree) return NULL; + /* set the global variables for filename & line number */ if (tree->filename) filename = tree->filename; @@ -3466,7 +3533,7 @@ ast2iCode (ast * tree,int lvl) case '+': if (right) return geniCodeAdd (geniCodeRValue (left, FALSE), - geniCodeRValue (right, FALSE),lvl, 0); + geniCodeRValue (right, FALSE),lvl); else return geniCodeRValue (left, FALSE); /* unary '+' has no meaning */ @@ -3477,9 +3544,25 @@ ast2iCode (ast * tree,int lvl) case RIGHT_OP: return geniCodeRightShift (geniCodeRValue (left, FALSE), geniCodeRValue (right, FALSE)); - case CAST: + case CAST: +#if 0 // this indeed needs a second thought + { + operand *op; + + // let's keep this simple: get the rvalue we need + op=geniCodeRValue (right, FALSE); + // now cast it to whatever we want + op=geniCodeCast (operandType(left), op, FALSE); + // if this is going to be used as an lvalue, make it so + if (tree->lvalue) { + op->isaddr=1; + } + return op; + } +#else // bug #604575, is it a bug ???? return geniCodeCast (operandType (left), geniCodeRValue (right, FALSE), FALSE); +#endif case '~': case '!': @@ -3556,7 +3639,7 @@ ast2iCode (ast * tree,int lvl) return geniCodeAssign (left, geniCodeAdd (geniCodeRValue (operandFromOperand (left), FALSE), - right,lvl,1), 0); + right,lvl), 0); } case SUB_ASSIGN: { @@ -3687,3 +3770,35 @@ iCodeFromAst (ast * tree) ast2iCode (tree,0); return reverseiCChain (); } + +static const char *opTypeToStr(OPTYPE op) +{ + switch(op) + { + case SYMBOL: return "symbol"; + case VALUE: return "value"; + case TYPE: return "type"; + } + return "undefined type"; +} + + +operand *validateOpType(operand *op, + const char *macro, + const char *args, + OPTYPE type, + const char *file, + unsigned line) +{ + if (op && op->type == type) + { + return op; + } + fprintf(stderr, + "Internal error: validateOpType failed in %s(%s) @ %s:%u:" + " expected %s, got %s\n", + macro, args, file, line, + opTypeToStr(type), op ? opTypeToStr(op->type) : "null op"); + exit(-1); + return op; // never reached, makes compiler happy. +}