X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCicode.c;h=1a165bbe86a23d37295906335dc6761635ba28a1;hb=3311c3c9eaf37762e3b2b72489756f55048f6def;hp=513c7b6ccee6a2aaf7cc8fe47e7d04f0465d9136;hpb=69446b0469baf2877e1baf54a54d30f9fb8a8e16;p=fw%2Fsdcc diff --git a/src/SDCCicode.c b/src/SDCCicode.c index 513c7b6c..1a165bbe 100644 --- a/src/SDCCicode.c +++ b/src/SDCCicode.c @@ -25,6 +25,7 @@ #include "common.h" #include "newalloc.h" #include "math.h" +#include "dbuf_string.h" /*-----------------------------------------------------------------*/ /* global variables */ @@ -34,8 +35,8 @@ int iTempNum = 0; int iTempLblNum = 0; int operandKey = 0; int iCodeKey = 0; -char *filename; -int lineno; +char *filename; /* current file name */ +int lineno = 1; /* current line number */ int block; int scopeLevel; int seqPoint; @@ -54,7 +55,7 @@ int isLvaluereq(int lvl); void setOClass (sym_link * ptr, sym_link * spec); static operand *geniCodeCast (sym_link *, operand *, bool); -#define PRINTFUNC(x) void x (FILE *of, iCode *ic, char *s) +#define PRINTFUNC(x) void x (struct dbuf_s *dbuf, iCode *ic, char *s) /* forward definition of ic print functions */ PRINTFUNC (picGetValueAtAddr); PRINTFUNC (picSetValueAtAddr); @@ -128,124 +129,58 @@ iCodeTable codeTable[] = }; /*-----------------------------------------------------------------*/ -/* checkConstantRange: check a constant against the type */ +/* operandName - returns the name of the operand */ /*-----------------------------------------------------------------*/ +int +printOperand (operand * op, FILE * file) +{ + struct dbuf_s dbuf; + int ret; + int pnl = 0; - -/* pedantic=0: allmost anything is allowed as long as the absolute - value is within the bit range of the type, and -1 is treated as - 0xf..f for unsigned types (e.g. in assign) - pedantic=1: -1==-1, not allowed for unsigned types (e.g. in compare) - pedantic>1: "char c=200" is not allowed (evaluates to -56) -*/ - -void checkConstantRange(sym_link *ltype, value *val, char *msg, - int pedantic) { - double max; - int warnings=0; - int negative=0; - long v; - - max = pow ((double)2.0, (double)bitsForType(ltype)); - - if (IS_LONG(val->type)) { - if (IS_UNSIGNED(val->type)) { - v=SPEC_CVAL(val->type).v_ulong; - } else { - v=SPEC_CVAL(val->type).v_long; - } - } else { - if (IS_UNSIGNED(val->type)) { - v=SPEC_CVAL(val->type).v_uint; - } else { - v=SPEC_CVAL(val->type).v_int; - } - } - - -#if 0 - // this could be a good idea - if (options.pedantic) - pedantic=2; -#endif - - if (IS_FLOAT(ltype)) { - // anything will do - return; - } - - if (IS_FIXED(ltype)) { - // anything will do - return; - } - - if (!IS_UNSIGNED(val->type) && v<0) { - negative=1; - if (IS_UNSIGNED(ltype) && (pedantic>1)) { - warnings++; + if (!file) + { + file = stdout; + pnl = 1; } - v=-v; - } - - // if very pedantic: "char c=200" is not allowed - if (pedantic>1 && !IS_UNSIGNED(ltype)) { - max = max/2 + negative; - } + dbuf_init (&dbuf, 1024); + ret = dbuf_printOperand(op, &dbuf); + dbuf_write_and_destroy (&dbuf, file); - if (v >= max) { - warnings++; - } - -#if 0 // temporary disabled, leaving the warning as a reminder - if (warnings) { - SNPRINTF (message, sizeof(message), "for %s %s in %s", - IS_UNSIGNED(ltype) ? "unsigned" : "signed", - nounName(ltype), msg); - werror (W_CONST_RANGE, message); + if (pnl) + putc ('\n', file); - if (pedantic>1) - fatalError++; - } -#endif + return ret; } -/*-----------------------------------------------------------------*/ -/* operandName - returns the name of the operand */ -/*-----------------------------------------------------------------*/ int -printOperand (operand * op, FILE * file) +dbuf_printOperand (operand * op, struct dbuf_s *dbuf) { sym_link *opetype; - int pnl = 0; if (!op) return 1; - if (!file) - { - file = stdout; - pnl = 1; - } switch (op->type) { case VALUE: opetype = getSpec (operandType (op)); if (IS_FLOAT (opetype)) - fprintf (file, "%g {", SPEC_CVAL (opetype).v_float); + dbuf_printf (dbuf, "%g {", SPEC_CVAL (opetype).v_float); else if (IS_FIXED16X16 (opetype)) - fprintf (file, "%g {", doubleFromFixed16x16(SPEC_CVAL (opetype).v_fixed16x16)); + dbuf_printf (dbuf, "%g {", doubleFromFixed16x16(SPEC_CVAL (opetype).v_fixed16x16)); else - fprintf (file, "0x%x {", (unsigned) floatFromVal (op->operand.valOperand)); - printTypeChain (operandType (op), file); - fprintf (file, "}"); + dbuf_printf (dbuf, "0x%x {", (unsigned) floatFromVal (op->operand.valOperand)); + dbuf_printTypeChain (operandType (op), dbuf); + dbuf_append_char (dbuf, '}'); break; case SYMBOL: #define REGA 1 //#if REGA /* { */ if(REGA && !getenv("PRINT_SHORT_OPERANDS")) { - fprintf (file, "%s [k%d lr%d:%d so:%d]{ ia%d a2p%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}" , */ + dbuf_printf (dbuf, "%s [k%d lr%d:%d so:%d]{ ia%d a2p%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), @@ -255,11 +190,11 @@ printOperand (operand * op, FILE * file) OP_SYMBOL(op)->ruonly,OP_SYMBOL(op)->dptr ); { - fprintf (file, "{"); - printTypeChain (operandType (op), file); + dbuf_append_char (dbuf, '{'); + dbuf_printTypeChain (operandType (op), dbuf); if (SPIL_LOC (op) && IS_ITEMP (op)) - fprintf (file, "}{ sir@ %s", SPIL_LOC (op)->rname); - fprintf (file, "}"); + dbuf_printf (dbuf, "}{ sir@ %s", SPIL_LOC (op)->rname); + dbuf_append_char (dbuf, '}'); } @@ -270,42 +205,42 @@ printOperand (operand * op, FILE * file) { if (!OP_SYMBOL (op)->remat) if (OP_SYMBOL (op)->usl.spillLoc) - fprintf (file, "[%s]", (OP_SYMBOL (op)->usl.spillLoc->rname[0] ? + dbuf_printf (dbuf, "[%s]", (OP_SYMBOL (op)->usl.spillLoc->rname[0] ? OP_SYMBOL (op)->usl.spillLoc->rname : OP_SYMBOL (op)->usl.spillLoc->name)); else - fprintf (file, "[err]"); + dbuf_append_str (dbuf, "[err]"); else - fprintf (file, "[remat]"); + dbuf_append_str (dbuf, "[remat]"); } else { int i; - fprintf (file, "["); + dbuf_append_char (dbuf, '['); for (i = 0; i < OP_SYMBOL (op)->nRegs; i++) - fprintf (file, "%s ", port->getRegName (OP_SYMBOL (op)->regs[i])); - fprintf (file, "]"); + dbuf_printf (dbuf, "%s ", port->getRegName (OP_SYMBOL (op)->regs[i])); + dbuf_append_char (dbuf, ']'); } } //#else /* } else { */ } else { /* (getenv("PRINT_SHORT_OPERANDS") != NULL) */ - fprintf (file, "%s ", (OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name)); + dbuf_printf (dbuf, "%s ", (OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name)); if(getenv("PRINT_SHORT_OPERANDS")[0] < '1') { - fprintf (file, "[lr%d:%d so:%d]", + dbuf_printf (dbuf, "[lr%d:%d so:%d]", OP_LIVEFROM (op), OP_LIVETO (op), OP_SYMBOL (op)->stack); } if(getenv("PRINT_SHORT_OPERANDS")[0] < '2') { - fprintf (file, "{"); - printTypeChain (operandType (op), file); + dbuf_append_char (dbuf, '{'); + dbuf_printTypeChain (operandType (op), dbuf); if (SPIL_LOC (op) && IS_ITEMP (op)) - fprintf (file, "}{ sir@ %s", SPIL_LOC (op)->rname); - fprintf (file, "}"); + dbuf_printf (dbuf, "}{ sir@ %s", SPIL_LOC (op)->rname); + dbuf_append_char (dbuf, '}'); } /* if assigned to registers */ @@ -315,21 +250,21 @@ printOperand (operand * op, FILE * file) { if (!OP_SYMBOL (op)->remat) if (OP_SYMBOL (op)->usl.spillLoc) - fprintf (file, "[%s]", (OP_SYMBOL (op)->usl.spillLoc->rname[0] ? + dbuf_printf (dbuf, "[%s]", (OP_SYMBOL (op)->usl.spillLoc->rname[0] ? OP_SYMBOL (op)->usl.spillLoc->rname : OP_SYMBOL (op)->usl.spillLoc->name)); else - fprintf (file, "[err]"); + dbuf_append_str (dbuf, "[err]"); else - fprintf (file, "[remat]"); + dbuf_append_str (dbuf, "[remat]"); } else { int i; - fprintf (file, "["); + dbuf_append_char (dbuf, '['); for (i = 0; i < OP_SYMBOL (op)->nRegs; i++) - fprintf (file, "%s ", port->getRegName (OP_SYMBOL (op)->regs[i])); - fprintf (file, "]"); + dbuf_printf (dbuf, "%s ", port->getRegName (OP_SYMBOL (op)->regs[i])); + dbuf_append_char (dbuf, ']'); } } //#endif /* } */ @@ -337,14 +272,12 @@ printOperand (operand * op, FILE * file) break; case TYPE: - fprintf (file, "("); - printTypeChain (op->operand.typeOperand, file); - fprintf (file, ")"); + dbuf_append_char (dbuf, '('); + dbuf_printTypeChain (op->operand.typeOperand, dbuf); + dbuf_append_char (dbuf, ')'); break; } - if (pnl) - fprintf (file, "\n"); return 0; } @@ -354,197 +287,195 @@ printOperand (operand * op, FILE * file) /*-----------------------------------------------------------------*/ PRINTFUNC (picGetValueAtAddr) { - fprintf (of, "\t"); - printOperand (IC_RESULT (ic), of); - fprintf (of, " = "); - fprintf (of, "@["); - printOperand (IC_LEFT (ic), of); - fprintf (of, "]"); - - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\t'); + dbuf_printOperand (IC_RESULT (ic), dbuf); + dbuf_append_str (dbuf, " = "); + dbuf_append_str (dbuf, "@["); + dbuf_printOperand (IC_LEFT (ic), dbuf); + dbuf_append_str (dbuf, "]\n"); } PRINTFUNC (picSetValueAtAddr) { - fprintf (of, "\t"); - fprintf (of, "*["); - printOperand (IC_LEFT (ic), of); - fprintf (of, "] = "); - printOperand (IC_RIGHT (ic), of); - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\t'); + dbuf_append_str (dbuf, "*["); + dbuf_printOperand (IC_LEFT (ic), dbuf); + dbuf_append_str (dbuf, "] = "); + dbuf_printOperand (IC_RIGHT (ic), dbuf); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picAddrOf) { - fprintf (of, "\t"); - printOperand (IC_RESULT (ic), of); + dbuf_append_char (dbuf, '\t'); + dbuf_printOperand (IC_RESULT (ic), dbuf); if (IS_ITEMP (IC_LEFT (ic))) - fprintf (of, " = "); + dbuf_append_str (dbuf, " = "); else - fprintf (of, " = &["); - printOperand (IC_LEFT (ic), of); + dbuf_append_str (dbuf, " = &["); + dbuf_printOperand (IC_LEFT (ic), dbuf); if (IC_RIGHT (ic)) { if (IS_ITEMP (IC_LEFT (ic))) - fprintf (of, " offsetAdd "); + dbuf_append_str (dbuf, " offsetAdd "); else - fprintf (of, " , "); - printOperand (IC_RIGHT (ic), of); + dbuf_append_str (dbuf, " , "); + dbuf_printOperand (IC_RIGHT (ic), dbuf); } if (IS_ITEMP (IC_LEFT (ic))) - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\n'); else - fprintf (of, "]\n"); + dbuf_append_str (dbuf, "]\n"); } PRINTFUNC (picJumpTable) { symbol *sym; - fprintf (of, "\t"); - fprintf (of, "%s\t", s); - printOperand (IC_JTCOND (ic), of); - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\t'); + dbuf_printf (dbuf, "%s\t", s); + dbuf_printOperand (IC_JTCOND (ic), dbuf); + dbuf_append_char (dbuf, '\n'); for (sym = setFirstItem (IC_JTLABELS (ic)); sym; sym = setNextItem (IC_JTLABELS (ic))) - fprintf (of, "\t\t\t%s\n", sym->name); + dbuf_printf (dbuf, "\t\t\t%s\n", sym->name); } PRINTFUNC (picGeneric) { - fprintf (of, "\t"); - printOperand (IC_RESULT (ic), of); - fprintf (of, " = "); - printOperand (IC_LEFT (ic), of); - fprintf (of, " %s ", s); - printOperand (IC_RIGHT (ic), of); - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\t'); + dbuf_printOperand (IC_RESULT (ic), dbuf); + dbuf_append_str (dbuf, " = "); + dbuf_printOperand (IC_LEFT (ic), dbuf); + dbuf_printf (dbuf, " %s ", s); + dbuf_printOperand (IC_RIGHT (ic), dbuf); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picGenericOne) { - fprintf (of, "\t"); + dbuf_append_char (dbuf, '\t'); if (IC_RESULT (ic)) { - printOperand (IC_RESULT (ic), of); - fprintf (of, " = "); + dbuf_printOperand (IC_RESULT (ic), dbuf); + dbuf_append_str (dbuf, " = "); } if (IC_LEFT (ic)) { - fprintf (of, "%s ", s); - printOperand (IC_LEFT (ic), of); + dbuf_printf (dbuf, "%s ", s); + dbuf_printOperand (IC_LEFT (ic), dbuf); } if (!IC_RESULT (ic) && !IC_LEFT (ic)) - fprintf (of, s); + dbuf_append_str (dbuf, s); if (ic->op == SEND || ic->op == RECEIVE) { - fprintf(of,"{argreg = %d}",ic->argreg); + dbuf_printf (dbuf,"{argreg = %d}",ic->argreg); } if (ic->op == IPUSH) { - fprintf(of,"{parmPush = %d}",ic->parmPush); + dbuf_printf (dbuf,"{parmPush = %d}",ic->parmPush); } - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picCast) { - fprintf (of, "\t"); - printOperand (IC_RESULT (ic), of); - fprintf (of, " = "); - printOperand (IC_LEFT (ic), of); - printOperand (IC_RIGHT (ic), of); - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\t'); + dbuf_printOperand (IC_RESULT (ic), dbuf); + dbuf_append_str (dbuf, " = "); + dbuf_printOperand (IC_LEFT (ic), dbuf); + dbuf_printOperand (IC_RIGHT (ic), dbuf); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picAssign) { - fprintf (of, "\t"); + dbuf_append_char (dbuf, '\t'); if (IC_RESULT (ic)->isaddr && IS_ITEMP (IC_RESULT (ic))) - fprintf (of, "*("); + dbuf_append_str (dbuf, "*("); - printOperand (IC_RESULT (ic), of); + dbuf_printOperand (IC_RESULT (ic), dbuf); if (IC_RESULT (ic)->isaddr && IS_ITEMP (IC_RESULT (ic))) - fprintf (of, ")"); + dbuf_append_char (dbuf, ')'); - fprintf (of, " %s ", s); - printOperand (IC_RIGHT (ic), of); + dbuf_printf (dbuf, " %s ", s); + dbuf_printOperand (IC_RIGHT (ic), dbuf); - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picLabel) { - fprintf (of, " %s($%d) :\n", IC_LABEL (ic)->name, IC_LABEL (ic)->key); + dbuf_printf (dbuf, " %s($%d) :\n", IC_LABEL (ic)->name, IC_LABEL (ic)->key); } PRINTFUNC (picGoto) { - fprintf (of, "\t"); - fprintf (of, " goto %s($%d)\n", IC_LABEL (ic)->name, IC_LABEL (ic)->key); + dbuf_append_char (dbuf, '\t'); + dbuf_printf (dbuf, " goto %s($%d)\n", IC_LABEL (ic)->name, IC_LABEL (ic)->key); } PRINTFUNC (picIfx) { - fprintf (of, "\t"); - fprintf (of, "if "); - printOperand (IC_COND (ic), of); + dbuf_append_char (dbuf, '\t'); + dbuf_append_str (dbuf, "if "); + dbuf_printOperand (IC_COND (ic), dbuf); if (!IC_TRUE (ic)) - fprintf (of, " == 0 goto %s($%d)\n", IC_FALSE (ic)->name, IC_FALSE (ic)->key); + dbuf_printf (dbuf, " == 0 goto %s($%d)\n", IC_FALSE (ic)->name, IC_FALSE (ic)->key); else { - fprintf (of, " != 0 goto %s($%d)\n", IC_TRUE (ic)->name, IC_TRUE (ic)->key); + dbuf_printf (dbuf, " != 0 goto %s($%d)\n", IC_TRUE (ic)->name, IC_TRUE (ic)->key); if (IC_FALSE (ic)) - fprintf (of, "\tzzgoto %s\n", IC_FALSE (ic)->name); + dbuf_printf (dbuf, "\tzzgoto %s\n", IC_FALSE (ic)->name); } } PRINTFUNC (picInline) { - fprintf (of, "%s", IC_INLINE (ic)); + dbuf_append_str (dbuf, IC_INLINE (ic)); } PRINTFUNC (picReceive) { - printOperand (IC_RESULT (ic), of); - fprintf (of, " = %s ", s); - printOperand (IC_LEFT (ic), of); - fprintf (of, "\n"); + dbuf_printOperand (IC_RESULT (ic), dbuf); + dbuf_printf (dbuf, " = %s ", s); + dbuf_printOperand (IC_LEFT (ic), dbuf); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picDummyRead) { - fprintf (of, "\t"); - fprintf (of, "%s ", s); - printOperand (IC_RIGHT (ic), of); - fprintf (of, "\n"); + dbuf_append_char (dbuf, '\t'); + dbuf_printf (dbuf, "%s ", s); + dbuf_printOperand (IC_RIGHT (ic), dbuf); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picCritical) { - fprintf (of, "\t"); + dbuf_append_char (dbuf, '\t'); if (IC_RESULT (ic)) - printOperand (IC_RESULT (ic), of); + dbuf_printOperand (IC_RESULT (ic), dbuf); else - fprintf (of, "(stack)"); - fprintf (of, " = %s ", s); - fprintf (of, "\n"); + dbuf_append_str (dbuf, "(stack)"); + dbuf_printf (dbuf, " = %s ", s); + dbuf_append_char (dbuf, '\n'); } PRINTFUNC (picEndCritical) { - fprintf (of, "\t"); - fprintf (of, "%s = ", s); + dbuf_append_char (dbuf, '\t'); + dbuf_printf (dbuf, "%s = ", s); if (IC_RIGHT (ic)) - printOperand (IC_RIGHT (ic), of); + dbuf_printOperand (IC_RIGHT (ic), dbuf); else - fprintf (of, "(stack)"); - fprintf (of, "\n"); + dbuf_append_str (dbuf, "(stack)"); + dbuf_append_char (dbuf, '\n'); } /*-----------------------------------------------------------------*/ @@ -555,6 +486,7 @@ piCode (void *item, FILE * of) { iCode *ic = item; iCodeTable *icTab; + struct dbuf_s dbuf; if (!of) of = stdout; @@ -563,7 +495,9 @@ piCode (void *item, FILE * of) fprintf (of, "%s(%d:%d:%d:%d:%d)\t", ic->filename, ic->lineno, ic->seq, ic->key, ic->depth, ic->supportRtn); - icTab->iCodePrint (of, ic, icTab->printName); + dbuf_init (&dbuf, 1024); + icTab->iCodePrint (&dbuf, ic, icTab->printName); + dbuf_write_and_destroy (&dbuf, of); return 1; } @@ -579,6 +513,7 @@ printiCChain (iCode * icChain, FILE * of) { iCode *loop; iCodeTable *icTab; + struct dbuf_s dbuf; if (!of) of = stdout; @@ -590,7 +525,9 @@ printiCChain (iCode * icChain, FILE * of) loop->filename, loop->lineno, loop->seq, loop->key, loop->depth, loop->supportRtn); - icTab->iCodePrint (of, loop, icTab->printName); + dbuf_init(&dbuf, 1024); + icTab->iCodePrint (&dbuf, loop, icTab->printName); + dbuf_write_and_destroy (&dbuf, of); } } } @@ -725,14 +662,15 @@ newiTempLabel (char *s) } /*-----------------------------------------------------------------*/ -/* newiTempPreheaderLabel - creates a new preheader label */ +/* newiTempLoopHeaderLabel - creates a new loop header label */ /*-----------------------------------------------------------------*/ symbol * -newiTempPreheaderLabel () +newiTempLoopHeaderLabel (bool pre) { symbol *itmplbl; - SNPRINTF (buffer, sizeof(buffer), "preHeaderLbl%d", iTempLblNum++); + SNPRINTF (buffer, sizeof(buffer), pre ? "preHeaderLbl%d" : LOOPEXITLBL "%d", + iTempLblNum++); itmplbl = newSymbol (buffer, 1); itmplbl->isitmp = 1; @@ -1237,26 +1175,26 @@ operandOperation (operand * left, operand * right, /* signed and unsigned mul are the same, as long as the precision of the result isn't bigger than the precision of the operands. */ retval = operandFromValue (valCastLiteral (type, - (TYPE_UDWORD) operandLitValue (left) * - (TYPE_UDWORD) operandLitValue (right))); + (TYPE_TARGET_ULONG) operandLitValue (left) * + (TYPE_TARGET_ULONG) operandLitValue (right))); else if (IS_UNSIGNED (type)) /* unsigned int */ { /* unsigned int is handled here in order to detect overflow */ - TYPE_UDWORD ul = (TYPE_UWORD) operandLitValue (left) * - (TYPE_UWORD) operandLitValue (right); + TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) operandLitValue (left) * + (TYPE_TARGET_UINT) operandLitValue (right); - retval = operandFromValue (valCastLiteral (type, (TYPE_UWORD) ul)); - if (ul != (TYPE_UWORD) ul) + retval = operandFromValue (valCastLiteral (type, (TYPE_TARGET_UINT) ul)); + if (ul != (TYPE_TARGET_UINT) ul) werror (W_INT_OVL); } else /* signed int */ { /* signed int is handled here in order to detect overflow */ - TYPE_DWORD l = (TYPE_WORD) operandLitValue (left) * - (TYPE_WORD) operandLitValue (right); + TYPE_TARGET_LONG l = (TYPE_TARGET_INT) operandLitValue (left) * + (TYPE_TARGET_INT) operandLitValue (right); - retval = operandFromValue (valCastLiteral (type, (TYPE_WORD) l)); - if (l != (TYPE_WORD) l) + retval = operandFromValue (valCastLiteral (type, (TYPE_TARGET_INT) l)); + if (l != (TYPE_TARGET_INT) l) werror (W_INT_OVL); } } @@ -1267,7 +1205,7 @@ operandOperation (operand * left, operand * right, operandLitValue (right))); break; case '/': - if ((TYPE_UDWORD) operandLitValue (right) == 0) + if ((TYPE_TARGET_ULONG) operandLitValue (right) == 0) { werror (E_DIVIDE_BY_ZERO); retval = right; @@ -1280,8 +1218,8 @@ operandOperation (operand * left, operand * right, SPEC_USIGN (let) = 1; SPEC_USIGN (ret) = 1; retval = operandFromValue (valCastLiteral (type, - (TYPE_UDWORD) operandLitValue (left) / - (TYPE_UDWORD) operandLitValue (right))); + (TYPE_TARGET_ULONG) operandLitValue (left) / + (TYPE_TARGET_ULONG) operandLitValue (right))); } else { @@ -1292,7 +1230,7 @@ operandOperation (operand * left, operand * right, } break; case '%': - if ((TYPE_UDWORD) operandLitValue (right) == 0) + if ((TYPE_TARGET_ULONG) operandLitValue (right) == 0) { werror (E_DIVIDE_BY_ZERO); retval = right; @@ -1300,31 +1238,31 @@ operandOperation (operand * left, operand * right, else { if (IS_UNSIGNED (type)) - retval = operandFromLit ((TYPE_UDWORD) operandLitValue (left) % - (TYPE_UDWORD) operandLitValue (right)); + retval = operandFromLit ((TYPE_TARGET_ULONG) operandLitValue (left) % + (TYPE_TARGET_ULONG) operandLitValue (right)); else - retval = operandFromLit ((TYPE_DWORD) operandLitValue (left) % - (TYPE_DWORD) operandLitValue (right)); + retval = operandFromLit ((TYPE_TARGET_LONG) operandLitValue (left) % + (TYPE_TARGET_LONG) operandLitValue (right)); } break; case LEFT_OP: /* The number of left shifts is always unsigned. Signed doesn't make sense here. Shifting by a negative number is impossible. */ retval = operandFromValue (valCastLiteral (type, - ((TYPE_UDWORD) operandLitValue (left) << - (TYPE_UDWORD) operandLitValue (right)))); + ((TYPE_TARGET_ULONG) operandLitValue (left) << + (TYPE_TARGET_ULONG) operandLitValue (right)))); break; case RIGHT_OP: /* The number of right shifts is always unsigned. Signed doesn't make sense here. Shifting by a negative number is impossible. */ if (IS_UNSIGNED(let)) /* unsigned: logic shift right */ - retval = operandFromLit ((TYPE_UDWORD) operandLitValue (left) >> - (TYPE_UDWORD) operandLitValue (right)); + retval = operandFromLit ((TYPE_TARGET_ULONG) operandLitValue (left) >> + (TYPE_TARGET_ULONG) operandLitValue (right)); else /* signed: arithmetic shift right */ - retval = operandFromLit ((TYPE_DWORD ) operandLitValue (left) >> - (TYPE_UDWORD) operandLitValue (right)); + retval = operandFromLit ((TYPE_TARGET_LONG ) operandLitValue (left) >> + (TYPE_TARGET_ULONG) operandLitValue (right)); break; case EQ_OP: if (IS_FLOAT (let) || IS_FLOAT (ret)) @@ -1340,10 +1278,10 @@ operandOperation (operand * left, operand * right, else { /* this op doesn't care about signedness */ - TYPE_UDWORD l, r; + TYPE_TARGET_ULONG l, r; - l = (TYPE_UDWORD) operandLitValue (left); - r = (TYPE_UDWORD) operandLitValue (right); + l = (TYPE_TARGET_ULONG) operandLitValue (left); + r = (TYPE_TARGET_ULONG) operandLitValue (right); /* In order to correctly compare 'signed int' and 'unsigned int' it's neccessary to strip them to 16 bit. Literals are reduced to their cheapest type, therefore left and @@ -1352,8 +1290,8 @@ operandOperation (operand * left, operand * right, if (!IS_LONG (let) && !IS_LONG (ret)) { - r = (TYPE_UWORD) r; - l = (TYPE_UWORD) l; + r = (TYPE_TARGET_UINT) r; + l = (TYPE_TARGET_UINT) l; } retval = operandFromLit (l == r); } @@ -1380,18 +1318,18 @@ operandOperation (operand * left, operand * right, break; case BITWISEAND: retval = operandFromValue (valCastLiteral (type, - (TYPE_UDWORD)operandLitValue(left) & - (TYPE_UDWORD)operandLitValue(right))); + (TYPE_TARGET_ULONG)operandLitValue(left) & + (TYPE_TARGET_ULONG)operandLitValue(right))); break; case '|': retval = operandFromValue (valCastLiteral (type, - (TYPE_UDWORD)operandLitValue(left) | - (TYPE_UDWORD)operandLitValue(right))); + (TYPE_TARGET_ULONG)operandLitValue(left) | + (TYPE_TARGET_ULONG)operandLitValue(right))); break; case '^': retval = operandFromValue (valCastLiteral (type, - (TYPE_UDWORD)operandLitValue(left) ^ - (TYPE_UDWORD)operandLitValue(right))); + (TYPE_TARGET_ULONG)operandLitValue(left) ^ + (TYPE_TARGET_ULONG)operandLitValue(right))); break; case AND_OP: retval = operandFromLit (operandLitValue (left) && @@ -1403,7 +1341,7 @@ operandOperation (operand * left, operand * right, break; case RRC: { - TYPE_UDWORD i = (TYPE_UDWORD) operandLitValue (left); + TYPE_TARGET_ULONG i = (TYPE_TARGET_ULONG) operandLitValue (left); retval = operandFromLit ((i >> (getSize (operandType (left)) * 8 - 1)) | (i << 1)); @@ -1411,27 +1349,27 @@ operandOperation (operand * left, operand * right, break; case RLC: { - TYPE_UDWORD i = (TYPE_UDWORD) operandLitValue (left); + TYPE_TARGET_ULONG i = (TYPE_TARGET_ULONG) operandLitValue (left); retval = operandFromLit ((i << (getSize (operandType (left)) * 8 - 1)) | (i >> 1)); } break; case GETABIT: - retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >> - (TYPE_UDWORD)operandLitValue(right)) & 1); + retval = operandFromLit (((TYPE_TARGET_ULONG)operandLitValue(left) >> + (TYPE_TARGET_ULONG)operandLitValue(right)) & 1); break; case GETBYTE: - retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >> - (TYPE_UDWORD)operandLitValue(right)) & 0xFF); + retval = operandFromLit (((TYPE_TARGET_ULONG)operandLitValue(left) >> + (TYPE_TARGET_ULONG)operandLitValue(right)) & 0xFF); break; case GETWORD: - retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >> - (TYPE_UDWORD)operandLitValue(right)) & 0xFFFF); + retval = operandFromLit (((TYPE_TARGET_ULONG)operandLitValue(left) >> + (TYPE_TARGET_ULONG)operandLitValue(right)) & 0xFFFF); break; case GETHBIT: - retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >> + retval = operandFromLit (((TYPE_TARGET_ULONG)operandLitValue(left) >> ((getSize (let) * 8) - 1)) & 1); break; @@ -1442,7 +1380,7 @@ operandOperation (operand * left, operand * right, case '~': retval = operandFromValue (valCastLiteral (type, - ~((TYPE_UDWORD) + ~((TYPE_TARGET_ULONG) operandLitValue (left)))); break; @@ -1838,7 +1776,7 @@ setOperandType (operand * op, sym_link * type) /*-----------------------------------------------------------------*/ /* Get size in byte of ptr need to access an array */ /*-----------------------------------------------------------------*/ -static int +static unsigned int getArraySizePtr (operand * op) { sym_link *ltype = operandType(op); @@ -2179,7 +2117,7 @@ geniCodeMultiply (operand * left, operand * right, RESULT_TYPE resultType) right->operand.valOperand)); if (IS_LITERAL(retype)) { - p2 = powof2 ((TYPE_UDWORD) floatFromVal (right->operand.valOperand)); + p2 = powof2 ((TYPE_TARGET_ULONG) floatFromVal (right->operand.valOperand)); } resType = usualBinaryConversions (&left, &right, resultType, '*'); @@ -2211,11 +2149,19 @@ geniCodeMultiply (operand * left, operand * right, RESULT_TYPE resultType) } else { - ic = newiCode ('*', left, right); /* normal multiplication */ /* if the size left or right > 1 then support routine */ if (getSize (ltype) > 1 || getSize (rtype) > 1) - ic->supportRtn = 1; - + { + if (IS_LITERAL (retype)) + ic = newiCode ('*', right, left); /* multiplication by support routine with one literal */ + else + ic = newiCode ('*', left, right); /* multiplication by support routine */ + ic->supportRtn = 1; + } + else + { + ic = newiCode ('*', left, right); /* normal multiplication */ + } } IC_RESULT (ic) = newiTempOperand (resType, 1); @@ -2246,7 +2192,7 @@ geniCodeDivision (operand * left, operand * right, RESULT_TYPE resultType) !IS_FLOAT (letype) && !IS_FIXED (letype) && IS_UNSIGNED(letype) && - ((p2 = powof2 ((TYPE_UDWORD) + ((p2 = powof2 ((TYPE_TARGET_ULONG) floatFromVal (right->operand.valOperand))) > 0)) { ic = newiCode (RIGHT_OP, left, operandFromLit (p2)); /* right shift */ } @@ -2409,11 +2355,7 @@ geniCodeAdd (operand * left, operand * right, RESULT_TYPE resultType, int lvl) size = operandFromLit (getSize (ltype->next)); SPEC_USIGN (getSpec (operandType (size))) = 1; indexUnsigned = IS_UNSIGNED (getSpec (operandType (right))); - right = geniCodeMultiply (right, - size, - (getArraySizePtr(left) >= INTSIZE) ? - RESULT_TYPE_INT : - RESULT_TYPE_CHAR); + right = geniCodeMultiply (right, size, resultType); /* Even if right is a 'unsigned char', the result will be a 'signed int' due to the promotion rules. It doesn't make sense when accessing arrays, so let's fix it here: */ @@ -2512,6 +2454,14 @@ geniCodeArray (operand * left, operand * right, int lvl) operand *size; sym_link *ltype = operandType (left); bool indexUnsigned; + RESULT_TYPE resultType; + + resultType = (getArraySizePtr(left) >= INTSIZE) ? RESULT_TYPE_INT : RESULT_TYPE_CHAR; + if (DCL_ELEM (ltype)) + { + if (DCL_ELEM (ltype) * getSize (ltype->next) <= 255) + resultType = RESULT_TYPE_CHAR; + } if (IS_PTR (ltype)) { @@ -2520,22 +2470,13 @@ geniCodeArray (operand * left, operand * right, int lvl) left = geniCodeRValue (left, FALSE); } - return geniCodeDerefPtr (geniCodeAdd (left, - right, - (getArraySizePtr(left) >= INTSIZE) ? - RESULT_TYPE_INT : - RESULT_TYPE_CHAR, - lvl), + return geniCodeDerefPtr (geniCodeAdd (left, right, resultType, lvl), lvl); } size = operandFromLit (getSize (ltype->next)); SPEC_USIGN (getSpec (operandType (size))) = 1; indexUnsigned = IS_UNSIGNED (getSpec (operandType (right))); - right = geniCodeMultiply (right, - size, - (getArraySizePtr(left) >= INTSIZE) ? - RESULT_TYPE_INT : - RESULT_TYPE_CHAR); + right = geniCodeMultiply (right, size, resultType); /* Even if right is a 'unsigned char', the result will be a 'signed int' due to the promotion rules. It doesn't make sense when accessing arrays, so let's fix it here: */ if (indexUnsigned) @@ -2847,7 +2788,7 @@ geniCodeAddressOf (operand * op) return op; } - /* other wise make this of the type coming in */ + /* otherwise make this of the type coming in */ ic = newiCode (ADDRESS_OF, op, NULL); IC_RESULT (ic) = newiTempOperand (p, 1); IC_RESULT (ic)->isaddr = 0; @@ -3014,8 +2955,17 @@ geniCodeLogic (operand * left, operand * right, int op) check if the literal value is within bounds */ if (IS_INTEGRAL (ltype) && IS_VALOP (right) && IS_LITERAL (rtype)) { - checkConstantRange(ltype, - OP_VALUE(right), "compare operation", 1); + CCR_RESULT ccr_result = checkConstantRange (ltype, rtype, op, FALSE); + switch (ccr_result) + { + case CCR_ALWAYS_TRUE: + case CCR_ALWAYS_FALSE: + if (!options.lessPedantic) + werror (W_COMP_RANGE, "true resp. false"); + return operandFromLit (ccr_result == CCR_ALWAYS_TRUE ? 1 : 0); + default: + break; + } } /* if one operand is a pointer and the other is a literal generic void pointer, @@ -3061,7 +3011,7 @@ geniCodeLogic (operand * left, operand * right, int op) } } - ctype = usualBinaryConversions (&left, &right, RESULT_TYPE_NONE, 0); + ctype = usualBinaryConversions (&left, &right, RESULT_TYPE_BIT, 0); ic = newiCode (op, left, right); IC_RESULT (ic) = newiTempOperand (newCharLink (), 1); @@ -3232,10 +3182,11 @@ geniCodeAssign (operand * left, operand * right, int nosupdate, int strictLval) /* left is integral type and right is literal then check if the literal value is within bounds */ - if (IS_INTEGRAL (ltype) && right->type == VALUE && IS_LITERAL (rtype)) + if (IS_INTEGRAL (ltype) && right->type == VALUE && IS_LITERAL (rtype) && + checkConstantRange (ltype, rtype, '=', FALSE) == CCR_OVL && + !options.lessPedantic) { - checkConstantRange(ltype, - OP_VALUE(right), "= operation", 0); + werror (W_LIT_OVERFLOW); } /* if the left & right type don't exactly match */ @@ -3287,7 +3238,9 @@ geniCodeAssign (operand * left, operand * right, int nosupdate, int strictLval) ic->supportRtn = 1; ic->nosupdate = nosupdate; - return left; + /* left could be a pointer assignment, + return the properly casted right instead */ + return right; } /*-----------------------------------------------------------------*/ @@ -3635,8 +3588,6 @@ geniCodeIfx (ast * tree,int lvl) { if (tree->falseLabel) geniCodeGoto (tree->falseLabel); - else - assert (0); } goto exit; } @@ -4341,8 +4292,7 @@ ast2iCode (ast * tree,int lvl) else right = geniCodeRValue (right, FALSE); - geniCodeAssign (left, right, 0, 1); - return right; + return geniCodeAssign (left, right, 0, 1); } case MUL_ASSIGN: return @@ -4553,6 +4503,6 @@ operand *validateOpType(operand *op, " expected %s, got %s\n", macro, args, file, line, opTypeToStr(type), op ? opTypeToStr(op->type) : "null op"); - exit(-1); + exit(EXIT_FAILURE); return op; // never reached, makes compiler happy. }