X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCicode.c;h=a8de6938a9e3c3789d90908af04a2991c86f663a;hb=4c527a8dc0a11d9bb33bebfe2fafa42e34b2895b;hp=30af1cd43f1c7745d73dd45834fe179ad73b9618;hpb=aa0ca082f440cf7b9cf126faf97e03fbbf0c0bc2;p=fw%2Fsdcc

diff --git a/src/SDCCicode.c b/src/SDCCicode.c
index 30af1cd4..a8de6938 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       */
@@ -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);
@@ -133,37 +134,53 @@ iCodeTable codeTable[] =
 int
 printOperand (operand * op, FILE * file)
 {
-  sym_link *opetype;
+  struct dbuf_s dbuf;
+  int ret;
   int pnl = 0;
 
-  if (!op)
-    return 1;
-
   if (!file)
     {
       file = stdout;
       pnl = 1;
     }
+  dbuf_init (&dbuf, 1024);
+  ret = dbuf_printOperand(op, &dbuf);
+  dbuf_write_and_destroy (&dbuf, file);
+
+  if (pnl)
+    putc ('\n', file);
+
+  return ret;
+}
+
+int
+dbuf_printOperand (operand * op, struct dbuf_s *dbuf)
+{
+  sym_link *opetype;
+
+  if (!op)
+    return 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),
@@ -173,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, '}');
 
       }
 
@@ -188,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 */
@@ -233,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                /* } */
@@ -255,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;
 }
 
@@ -272,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');
 }
 
 /*-----------------------------------------------------------------*/
@@ -473,6 +486,7 @@ piCode (void *item, FILE * of)
 {
   iCode *ic = item;
   iCodeTable *icTab;
+  struct dbuf_s dbuf;
 
   if (!of)
     of = stdout;
@@ -481,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;
 }
 
@@ -497,6 +513,7 @@ printiCChain (iCode * icChain, FILE * of)
 {
   iCode *loop;
   iCodeTable *icTab;
+  struct dbuf_s dbuf;
 
   if (!of)
     of = stdout;
@@ -508,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);
         }
     }
 }
@@ -1156,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);
             }
         }
@@ -1186,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;
@@ -1199,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
             {
@@ -1211,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;
@@ -1219,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))
@@ -1259,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
@@ -1271,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);
         }
@@ -1299,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) &&
@@ -1322,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));
@@ -1330,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;
 
@@ -1361,7 +1380,7 @@ operandOperation (operand * left, operand * right,
 
     case '~':
       retval = operandFromValue (valCastLiteral (type,
-                                                 ~((TYPE_UDWORD)
+                                                 ~((TYPE_TARGET_ULONG)
                                                    operandLitValue (left))));
       break;
 
@@ -2098,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, '*');
@@ -2130,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);
 
@@ -2165,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 */
   }
@@ -4475,6 +4502,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.
 }