X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCval.c;h=e0821e1e45129eba22c1d4b2c1979665437b8e71;hb=90bdb43b342189fcb94a398855d43f3f47f96738;hp=c798df04c211b6a9137bb7185b36f347a3161e8d;hpb=6dffeb88c65e2ec0f17e2bc2de9db01129a5e631;p=fw%2Fsdcc

diff --git a/src/SDCCval.c b/src/SDCCval.c
index c798df04..e0821e1e 100644
--- a/src/SDCCval.c
+++ b/src/SDCCval.c
@@ -326,100 +326,298 @@ symbolVal (symbol * sym)
   return val;
 }
 
-#if defined(REDUCE_LITERALS)
 /*--------------------------------------------------------------------*/
-/* cheapestVal - convert a val to the cheapest as possible value      */
+/* cheapestVal - try to reduce 'signed int' to 'char'                 */
 /*--------------------------------------------------------------------*/
-static value *cheapestVal (value *val) {
-  TYPE_DWORD  sval=0;
-  TYPE_UDWORD uval=0;
-
-  if (IS_FLOAT(val->type) || IS_FIXED(val->type) || IS_CHAR(val->type))
+static value *
+cheapestVal (value *val)
+{
+  /* only int can be reduced */
+  if (!IS_INT(val->type))
     return val;
 
-  if (SPEC_LONG(val->type)) {
-    if (SPEC_USIGN(val->type)) {
-      uval=SPEC_CVAL(val->type).v_ulong;
-    } else {
-      sval=SPEC_CVAL(val->type).v_long;
-    }
-  } else {
-    if (SPEC_USIGN(val->type)) {
-      uval=SPEC_CVAL(val->type).v_uint;
-    } else {
-      sval=SPEC_CVAL(val->type).v_int;
-    }
-  }
-
-  if (SPEC_USIGN(val->type)) {
-    if (uval<=0xffff) {
-      SPEC_LONG(val->type)=0;
-      SPEC_CVAL(val->type).v_uint = (TYPE_UWORD)uval;
-      if (uval<=0xff) {
-        SPEC_NOUN(val->type)=V_CHAR;
-      }
-    }
-  } else { // not unsigned
-    if (sval<0) {
-      if (sval>=-32768) {
-        SPEC_LONG(val->type)=0;
-        SPEC_CVAL(val->type).v_int = (TYPE_WORD)sval;
-        if (sval>=-128) {
-          SPEC_NOUN(val->type)=V_CHAR;
-        }
-      }
-    } else { // sval>=0
-      if (sval<=32767) {
-        SPEC_LONG(val->type)=0;
-        SPEC_CVAL(val->type).v_int = (TYPE_WORD)sval;
-        if (sval<=127) {
-          SPEC_NOUN(val->type)=V_CHAR;
-        }
-      }
-    }
-  }
-  return val;
-}
-
-#else
-
-static value *cheapestVal (value *val)
-{
-  if (IS_FLOAT (val->type) || IS_FIXED (val->type) || IS_CHAR (val->type))
+  /* long must not be changed */
+  if (SPEC_LONG(val->type))
     return val;
 
-  /* - signed/unsigned must not be changed.
-     - long must not be changed.
+  /* unsigned must not be changed */
+  if (SPEC_USIGN(val->type))
+    return val;
 
-     the only possible reduction is from signed int to signed char,
+  /* the only possible reduction is from signed int to (un)signed char,
      because it's automatically promoted back to signed int.
 
      a reduction from unsigned int to unsigned char is a bug,
      because an _unsigned_ char is promoted to _signed_ int! */
-  if (IS_INT(val->type) &&
-      !SPEC_USIGN(val->type) &&
-      !SPEC_LONG(val->type) &&
-      SPEC_CVAL(val->type).v_int >= -128 &&
-      SPEC_CVAL(val->type).v_int <     0)
-
+  if (SPEC_CVAL(val->type).v_int < -128 ||
+      SPEC_CVAL(val->type).v_int >  255)
     {
-      SPEC_NOUN(val->type) = V_CHAR;
+      /* not in the range of (un)signed char */
+      return val;
     }
+
+  SPEC_NOUN(val->type) = V_CHAR;
+
   /* 'unsigned char' promotes to 'signed int', so that we can
      reduce it the other way */
-  if (IS_INT(val->type) &&
-      !SPEC_USIGN(val->type) &&
-      !SPEC_LONG(val->type) &&
-      SPEC_CVAL(val->type).v_int >=   0 &&
-      SPEC_CVAL(val->type).v_int <= 255)
-
+  if (SPEC_CVAL(val->type).v_int >= 0)
     {
-      SPEC_NOUN(val->type) = V_CHAR;
       SPEC_USIGN(val->type) = 1;
     }
   return (val);
 }
-#endif
+
+/*--------------------------------------------------------------------*/
+/* checkConstantRange - check if constant fits in numeric range of    */
+/* var type in comparisons and assignments                            */
+/*--------------------------------------------------------------------*/
+CCR_RESULT
+checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight)
+{
+  sym_link *reType;
+  double litVal;
+  int varBits;
+
+  litVal = floatFromVal (valFromType (lit));
+  varBits = bitsForType (var);
+
+  /* sanity checks */
+  if (   IS_FLOAT (var)
+      || IS_FIXED (var))
+    return CCR_OK;
+  if (varBits < 1)
+    return CCR_ALWAYS_FALSE;
+  if (varBits > 32)
+    return CCR_ALWAYS_TRUE;
+
+  /* special: assignment */
+  if (op == '=')
+    {
+      if (IS_BIT (var))
+        return CCR_OK;
+
+      if (getenv ("SDCC_VERY_PEDANTIC"))
+        {
+          if (SPEC_USIGN (var))
+            {
+              TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
+
+              if (   litVal < 0
+                  || litVal > maxVal)
+                return CCR_OVL;
+              return CCR_OK;
+            }
+          else
+            {
+              TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
+              TYPE_TARGET_LONG maxVal = 0x7fffffff >> (32 - varBits);
+
+              if (   litVal < minVal
+                  || litVal > maxVal)
+                return CCR_OVL;
+              return CCR_OK;
+            }
+        }
+      else
+        {
+          /* ignore signedness, e.g. allow everything
+             from -127...+255 for (unsigned) char */
+          TYPE_TARGET_LONG  minVal = 0xffffffff  << (varBits - 1);
+          TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
+
+          if (   litVal < minVal
+              || litVal > maxVal)
+            return CCR_OVL;
+          return CCR_OK;
+        }
+    }
+
+  if (exchangeLeftRight)
+    switch (op)
+      {
+        case EQ_OP:             break;
+        case NE_OP:             break;
+        case '>':   op = '<';   break;
+        case GE_OP: op = LE_OP; break;
+        case '<':   op = '>';   break;
+        case LE_OP: op = GE_OP; break;
+        default:                return CCR_ALWAYS_FALSE;
+      }
+
+  reType = computeType (var, lit, RESULT_TYPE_NONE, op);
+
+  if (SPEC_USIGN (reType))
+    {
+      /* unsigned operation */
+      TYPE_TARGET_ULONG minValP, maxValP, minValM, maxValM;
+      TYPE_TARGET_ULONG opBitsMask = 0xffffffffu >> (32 - bitsForType (reType));
+
+      if (SPEC_USIGN (lit) && SPEC_USIGN (var))
+        {
+          /* both operands are unsigned, this is easy */
+          minValP = 0;
+          maxValP = 0xffffffffu >> (32 - varBits);
+          /* there's only range, just copy it to 2nd set */
+          minValM = minValP;
+          maxValM = maxValP;
+        }
+      else if (SPEC_USIGN (var))
+        {
+          /* lit is casted from signed to unsigned, e.g.:
+               unsigned u;
+                 u == (char) -17
+              -> u == 0xffef'
+          */
+          minValP = 0;
+          maxValP = 0xffffffffu >> (32 - varBits);
+          /* there's only one range, just copy it to 2nd set */
+          minValM = minValP;
+          maxValM = maxValP;
+
+          /* it's an unsigned operation */
+          if (   IS_CHAR (reType)
+              || IS_INT (reType))
+            {
+              /* make signed literal unsigned and
+                 limit no of bits to size of return type */
+              litVal = (TYPE_TARGET_ULONG) litVal & opBitsMask;
+            }
+        }
+      else /* SPEC_USIGN (lit) */
+        {
+          /* var is casted from signed to unsigned, e.g.:
+               signed char c;
+                 c == (unsigned) -17
+              -> c == 0xffef'
+
+             The possible values after casting var
+             split up in two, nonconsecutive ranges:
+
+             minValP =      0;  positive range: 0...127
+             maxValP =   0x7f;
+             minValM = 0xff80;  negative range: -128...-1
+             maxValM = 0xffff;
+          */
+
+          /* positive range */
+          minValP = 0;
+          maxValP = 0x7fffffffu >> (32 - varBits);
+
+          /* negative range */
+          minValM = 0xffffffff  << (varBits - 1);
+          maxValM = 0xffffffffu; /* -1 */
+          /* limit no of bits to size of return type */
+          minValM &= opBitsMask;
+          maxValM &= opBitsMask;
+        }
+
+      switch (op)
+        {
+          case EQ_OP:                   /* var == lit */
+            if (   litVal <= maxValP
+                && litVal >= minValP) /* 0 */
+              return CCR_OK;
+            if (   litVal <= maxValM
+                && litVal >= minValM)
+              return CCR_OK;
+            return CCR_ALWAYS_FALSE;
+          case NE_OP:                   /* var != lit */
+            if (   litVal <= maxValP
+                && litVal >= minValP) /* 0 */
+              return CCR_OK;
+            if (   litVal <= maxValM
+                && litVal >= minValM)
+              return CCR_OK;
+            return CCR_ALWAYS_TRUE;
+          case '>':                     /* var >  lit */
+            if (litVal >= maxValM)
+              return CCR_ALWAYS_FALSE;
+            if (litVal <  minValP) /* 0 */
+              return CCR_ALWAYS_TRUE;
+            return CCR_OK;
+          case GE_OP:                   /* var >= lit */
+            if (litVal >  maxValM)
+              return CCR_ALWAYS_FALSE;
+            if (litVal <= minValP) /* 0 */
+              return CCR_ALWAYS_TRUE;
+            return CCR_OK;
+          case '<':                     /* var <  lit */
+            if (litVal >  maxValM)
+              return CCR_ALWAYS_TRUE;
+            if (litVal <= minValP) /* 0 */
+              return CCR_ALWAYS_FALSE;
+            return CCR_OK;
+          case LE_OP:                   /* var <= lit */
+            if (litVal >= maxValM)
+              return CCR_ALWAYS_TRUE;
+            if (litVal <  minValP) /* 0 */
+              return CCR_ALWAYS_FALSE;
+            return CCR_OK;
+          default:
+            return CCR_ALWAYS_FALSE;
+        }
+    }
+  else
+    {
+      /* signed operation */
+      TYPE_TARGET_LONG minVal, maxVal;
+
+      if (SPEC_USIGN (var))
+        {
+          /* unsigned var, but signed operation. This happens
+             when var is promoted to signed int.
+             Set actual min/max values of var. */
+          minVal = 0;
+          maxVal = 0xffffffff >> (32 - varBits);
+        }
+      else
+        {
+          /* signed var */
+          minVal = 0xffffffff << (varBits - 1);
+          maxVal = 0x7fffffff >> (32 - varBits);
+        }
+
+      switch (op)
+        {
+          case EQ_OP:                   /* var == lit */
+            if (   litVal > maxVal
+                || litVal < minVal)
+              return CCR_ALWAYS_FALSE;
+            return CCR_OK;
+          case NE_OP:                   /* var != lit */
+            if (   litVal > maxVal
+                || litVal < minVal)
+              return CCR_ALWAYS_TRUE;
+            return CCR_OK;
+          case '>':                     /* var >  lit */
+            if (litVal >= maxVal)
+              return CCR_ALWAYS_FALSE;
+            if (litVal <  minVal)
+              return CCR_ALWAYS_TRUE;
+            return CCR_OK;
+          case GE_OP:                   /* var >= lit */
+            if (litVal >  maxVal)
+              return CCR_ALWAYS_FALSE;
+            if (litVal <= minVal)
+              return CCR_ALWAYS_TRUE;
+            return CCR_OK;
+          case '<':                     /* var <  lit */
+            if (litVal >  maxVal)
+              return CCR_ALWAYS_TRUE;
+            if (litVal <= minVal)
+              return CCR_ALWAYS_FALSE;
+            return CCR_OK;
+          case LE_OP:                   /* var <= lit */
+            if (litVal >= maxVal)
+              return CCR_ALWAYS_TRUE;
+            if (litVal <  minVal)
+              return CCR_ALWAYS_FALSE;
+            return CCR_OK;
+          default:
+            return CCR_ALWAYS_FALSE;
+        }
+    }
+}
 
 /*-----------------------------------------------------------------*/
 /* valueFromLit - creates a value from a literal                   */
@@ -429,9 +627,9 @@ valueFromLit (double lit)
 {
   char buffer[50];
 
-  if ((((TYPE_DWORD) lit) - lit) == 0)
+  if ((((TYPE_TARGET_LONG) lit) - lit) == 0)
     {
-      SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_DWORD) lit);
+      SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_TARGET_LONG) lit);
       return constVal (buffer);
     }
 
@@ -585,22 +783,22 @@ value *constVal (char *s)
     {
       if (SPEC_USIGN (val->type))
         {
-          SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD)dval;
+          SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG)dval;
         }
       else
         {
-          SPEC_CVAL (val->type).v_long = (TYPE_DWORD)dval;
+          SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG)dval;
         }
     }
   else
     {
       if (SPEC_USIGN (val->type))
         {
-          SPEC_CVAL (val->type).v_uint = (TYPE_UWORD)dval;
+          SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT)dval;
         }
       else
         {
-          SPEC_CVAL (val->type).v_int = (TYPE_WORD)dval;
+          SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT)dval;
         }
     }
 
@@ -1017,6 +1215,56 @@ floatFromVal (value * val)
   return 0;
 }
 
+/*-----------------------------------------------------------------*/
+/* doubleFromFixed16x16 - convert a fixed16x16 to double           */
+/*-----------------------------------------------------------------*/
+double doubleFromFixed16x16(TYPE_TARGET_ULONG value)
+{
+#if 0
+  /* This version is incorrect negative values. */
+  double tmp=0, exp=2;
+
+    tmp = (value & 0xffff0000) >> 16;
+    
+    while(value) {
+      value &= 0xffff;
+      if(value & 0x8000)tmp += 1/exp;
+      exp *= 2;
+      value <<= 1;
+    }
+  
+  return (tmp);
+#else
+  return ((double)(value * 1.0) / (double)(1UL << 16));
+#endif
+}
+
+TYPE_TARGET_ULONG fixed16x16FromDouble(double value)
+{
+#if 0
+  /* This version is incorrect negative values. */
+  unsigned int tmp=0, pos=16;
+  TYPE_TARGET_ULONG res;
+
+    tmp = floor( value );
+    res = tmp << 16;
+    value -= tmp;
+    
+    tmp = 0;
+    while(pos--) {
+      value *= 2;
+      if(value >= 1.0)tmp |= (1 << pos);
+      value -= floor( value );
+    }
+  
+    res |= tmp;
+
+  return (res);
+#else
+  return  (TYPE_TARGET_ULONG)(value * (double)(1UL << 16));
+#endif
+}
+
 /*------------------------------------------------------------------*/
 /* valUnaryPM - does the unary +/- operation on a constant          */
 /*------------------------------------------------------------------*/
@@ -1043,16 +1291,16 @@ valUnaryPM (value * val)
             SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint;
           else
             SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int;
+
+          if (SPEC_NOUN(val->etype) == V_CHAR)
+            {
+              /* promote to 'signed int', cheapestVal() might reduce it again */
+              SPEC_USIGN(val->etype) = 0;
+              SPEC_NOUN(val->etype) = V_INT;
+            }
+          return cheapestVal (val);
         }
     }
-  // -(unsigned 3) now really is signed
-  SPEC_USIGN(val->etype)=0;
-  // -(unsigned char)135 now really is an int
-  if (SPEC_NOUN(val->etype) == V_CHAR) {
-    if (SPEC_CVAL(val->etype).v_int < -128) {
-      SPEC_NOUN(val->etype) = V_INT;
-    }
-  }
   return val;
 }
 
@@ -1076,13 +1324,15 @@ valComplement (value * val)
         SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint;
       else
         SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int;
+
       if (SPEC_NOUN(val->etype) == V_CHAR)
-        if (   SPEC_CVAL(val->etype).v_int < -128
-            || SPEC_CVAL(val->etype).v_int >  127)
+        {
+          /* promote to 'signed int', cheapestVal() might reduce it again */
+          SPEC_USIGN(val->etype) = 0;
           SPEC_NOUN(val->etype) = V_INT;
+        }
+      return cheapestVal (val);
     }
-  // ~(unsigned 3) now really is signed
-  SPEC_USIGN(val->etype)=0;
   return val;
 }
 
@@ -1096,17 +1346,23 @@ valNot (value * val)
   if (SPEC_LONG (val->etype))
     {
       if (SPEC_USIGN (val->etype))
-        SPEC_CVAL (val->etype).v_ulong = !SPEC_CVAL (val->etype).v_ulong;
+        SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_ulong;
       else
-        SPEC_CVAL (val->etype).v_long = !SPEC_CVAL (val->etype).v_long;
+        SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_long;
     }
   else
     {
       if (SPEC_USIGN (val->etype))
-        SPEC_CVAL (val->etype).v_uint = !SPEC_CVAL (val->etype).v_uint;
+        SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_uint;
       else
         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int;
+
     }
+  /* ANSI: result type is int, value is 0 or 1 */
+  /* sdcc will hold this in an 'unsigned char' */
+  SPEC_USIGN(val->etype) = 1;
+  SPEC_LONG (val->etype) = 0;
+  SPEC_NOUN(val->etype) = V_CHAR;
   return val;
 }
 
@@ -1134,24 +1390,24 @@ valMult (value * lval, value * rval)
       /* signed and unsigned mul are the same, as long as the precision of the
          result isn't bigger than the precision of the operands. */
   else if (SPEC_LONG (val->type))
-    SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) *
-                                    (TYPE_UDWORD) floatFromVal (rval);
+    SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) *
+                                    (TYPE_TARGET_ULONG) floatFromVal (rval);
   else if (SPEC_USIGN (val->type)) /* unsigned int */
     {
-      TYPE_UDWORD ul = (TYPE_UWORD) floatFromVal (lval) *
-                       (TYPE_UWORD) floatFromVal (rval);
+      TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) floatFromVal (lval) *
+                             (TYPE_TARGET_UINT) floatFromVal (rval);
 
-      SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) ul;
-      if (ul != (TYPE_UWORD) ul)
+      SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ul;
+      if (ul != (TYPE_TARGET_UINT) ul)
         werror (W_INT_OVL);
     }
   else /* signed int */
     {
-      TYPE_DWORD l = (TYPE_WORD) floatFromVal (lval) *
-                     (TYPE_WORD) floatFromVal (rval);
+      TYPE_TARGET_LONG l = (TYPE_TARGET_INT) floatFromVal (lval) *
+                           (TYPE_TARGET_INT) floatFromVal (rval);
 
-      SPEC_CVAL (val->type).v_int = (TYPE_WORD) l;
-      if (l != (TYPE_WORD) l)
+      SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) l;
+      if (l != (TYPE_TARGET_INT) l)
         werror (W_INT_OVL);
     }
   return cheapestVal (val);
@@ -1187,20 +1443,20 @@ valDiv (value * lval, value * rval)
   else if (SPEC_LONG (val->type))
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) /
-          (TYPE_UDWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) /
+          (TYPE_TARGET_ULONG) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) /
-          (TYPE_DWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) /
+          (TYPE_TARGET_LONG) floatFromVal (rval);
     }
   else
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) /
-          (TYPE_UWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) /
+          (TYPE_TARGET_UINT) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) /
-          (TYPE_WORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) /
+          (TYPE_TARGET_INT) floatFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1224,20 +1480,20 @@ valMod (value * lval, value * rval)
   if (SPEC_LONG (val->type))
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) %
-          (TYPE_UDWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) %
+          (TYPE_TARGET_ULONG) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) %
-          (TYPE_DWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) %
+          (TYPE_TARGET_LONG) floatFromVal (rval);
     }
   else
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) %
-          (TYPE_UWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) %
+          (TYPE_TARGET_UINT) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) %
-          (TYPE_WORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) %
+          (TYPE_TARGET_INT) floatFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1266,20 +1522,20 @@ valPlus (value * lval, value * rval)
   else  if (SPEC_LONG (val->type))
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) +
-         (TYPE_UDWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) +
+         (TYPE_TARGET_ULONG) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) +
-          (TYPE_DWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) +
+          (TYPE_TARGET_LONG) floatFromVal (rval);
     }
   else
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) +
-          (TYPE_UWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) +
+          (TYPE_TARGET_UINT) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) +
-          (TYPE_WORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) +
+          (TYPE_TARGET_INT) floatFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1308,20 +1564,20 @@ valMinus (value * lval, value * rval)
   else  if (SPEC_LONG (val->type))
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) -
-          (TYPE_UDWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) -
+          (TYPE_TARGET_ULONG) floatFromVal (rval);
       else
-        SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) -
-          (TYPE_DWORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) -
+          (TYPE_TARGET_LONG) floatFromVal (rval);
     }
   else
    {
      if (SPEC_USIGN (val->type))
-       SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) -
-         (TYPE_UWORD) floatFromVal (rval);
+       SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) -
+         (TYPE_TARGET_UINT) floatFromVal (rval);
      else
-       SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) -
-         (TYPE_WORD) floatFromVal (rval);
+       SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) -
+         (TYPE_TARGET_INT) floatFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1342,7 +1598,7 @@ valShift (value * lval, value * rval, int lr)
                                         'S');
   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
 
-  if (getSize (val->type) * 8 <= (TYPE_UDWORD) floatFromVal (rval) &&
+  if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) floatFromVal (rval) &&
        /* left shift */
       (lr ||
         /* right shift and unsigned */
@@ -1356,14 +1612,14 @@ valShift (value * lval, value * rval, int lr)
       if (SPEC_USIGN (val->type))
         {
           SPEC_CVAL (val->type).v_ulong = lr ?
-            (TYPE_UDWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
-            (TYPE_UDWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
+            (TYPE_TARGET_ULONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
+            (TYPE_TARGET_ULONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
         }
       else
         {
           SPEC_CVAL (val->type).v_long = lr ?
-            (TYPE_DWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
-            (TYPE_DWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
+            (TYPE_TARGET_LONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
+            (TYPE_TARGET_LONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
         }
     }
   else
@@ -1371,14 +1627,14 @@ valShift (value * lval, value * rval, int lr)
       if (SPEC_USIGN (val->type))
         {
           SPEC_CVAL (val->type).v_uint = lr ?
-            (TYPE_UWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
-            (TYPE_UWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
+            (TYPE_TARGET_UINT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
+            (TYPE_TARGET_UINT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
         }
       else
         {
           SPEC_CVAL (val->type).v_int = lr ?
-            (TYPE_WORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
-            (TYPE_WORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
+            (TYPE_TARGET_INT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
+            (TYPE_TARGET_INT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
         }
     }
   return cheapestVal (val);
@@ -1433,10 +1689,10 @@ valCompare (value * lval, value * rval, int ctype)
       else
         {
           /* integrals: ignore signedness */
-          TYPE_UDWORD l, r;
+          TYPE_TARGET_ULONG l, r;
 
-          l = (TYPE_UDWORD) floatFromVal (lval);
-          r = (TYPE_UDWORD) floatFromVal (rval);
+          l = (TYPE_TARGET_ULONG) floatFromVal (lval);
+          r = (TYPE_TARGET_ULONG) floatFromVal (rval);
           /* 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
@@ -1445,8 +1701,8 @@ valCompare (value * lval, value * rval, int ctype)
           if (!IS_LONG (lval->etype) &&
               !IS_LONG (rval->etype))
             {
-              r = (TYPE_UWORD) r;
-              l = (TYPE_UWORD) l;
+              r = (TYPE_TARGET_UINT) r;
+              l = (TYPE_TARGET_UINT) l;
             }
           SPEC_CVAL (val->type).v_int = l == r;
         }
@@ -1466,10 +1722,10 @@ valCompare (value * lval, value * rval, int ctype)
       else
         {
           /* integrals: ignore signedness */
-          TYPE_UDWORD l, r;
+          TYPE_TARGET_ULONG l, r;
 
-          l = (TYPE_UDWORD) floatFromVal (lval);
-          r = (TYPE_UDWORD) floatFromVal (rval);
+          l = (TYPE_TARGET_ULONG) floatFromVal (lval);
+          r = (TYPE_TARGET_ULONG) floatFromVal (rval);
           /* 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
@@ -1478,8 +1734,8 @@ valCompare (value * lval, value * rval, int ctype)
           if (!IS_LONG (lval->etype) &&
               !IS_LONG (rval->etype))
             {
-              r = (TYPE_UWORD) r;
-              l = (TYPE_UWORD) l;
+              r = (TYPE_TARGET_UINT) r;
+              l = (TYPE_TARGET_UINT) l;
             }
           SPEC_CVAL (val->type).v_int = l != r;
         }
@@ -1510,19 +1766,20 @@ valBitwise (value * lval, value * rval, int op)
       if (SPEC_LONG (val->type))
         {
           if (SPEC_USIGN (val->type))
-            SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) &
-              (TYPE_UDWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) &
+              (TYPE_TARGET_ULONG) floatFromVal (rval);
           else
-            SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) &
-              (TYPE_DWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) &
+              (TYPE_TARGET_LONG) floatFromVal (rval);
         }
       else
         {
           if (SPEC_USIGN (val->type))
-            SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) &
-              (TYPE_UWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) &
+              (TYPE_TARGET_UINT) floatFromVal (rval);
           else
-            SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) & (TYPE_WORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) &
+              (TYPE_TARGET_INT) floatFromVal (rval);
         }
       break;
 
@@ -1530,20 +1787,20 @@ valBitwise (value * lval, value * rval, int op)
       if (SPEC_LONG (val->type))
         {
           if (SPEC_USIGN (val->type))
-            SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) |
-              (TYPE_UDWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) |
+              (TYPE_TARGET_ULONG) floatFromVal (rval);
           else
-            SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) |
-              (TYPE_DWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) |
+              (TYPE_TARGET_LONG) floatFromVal (rval);
         }
       else
         {
           if (SPEC_USIGN (val->type))
-            SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) |
-              (TYPE_UWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) |
+              (TYPE_TARGET_UINT) floatFromVal (rval);
           else
             SPEC_CVAL (val->type).v_int =
-              (TYPE_WORD) floatFromVal (lval) | (TYPE_WORD) floatFromVal (rval);
+              (TYPE_TARGET_INT) floatFromVal (lval) | (TYPE_TARGET_INT) floatFromVal (rval);
         }
 
       break;
@@ -1552,20 +1809,20 @@ valBitwise (value * lval, value * rval, int op)
       if (SPEC_LONG (val->type))
         {
           if (SPEC_USIGN (val->type))
-            SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) ^
-              (TYPE_UDWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) ^
+              (TYPE_TARGET_ULONG) floatFromVal (rval);
           else
-            SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) ^
-              (TYPE_DWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) ^
+              (TYPE_TARGET_LONG) floatFromVal (rval);
         }
       else
         {
           if (SPEC_USIGN (val->type))
-            SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) ^
-              (TYPE_UWORD) floatFromVal (rval);
+            SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) ^
+              (TYPE_TARGET_UINT) floatFromVal (rval);
           else
             SPEC_CVAL (val->type).v_int =
-              (TYPE_WORD) floatFromVal (lval) ^ (TYPE_WORD) floatFromVal (rval);
+              (TYPE_TARGET_INT) floatFromVal (lval) ^ (TYPE_TARGET_INT) floatFromVal (rval);
         }
       break;
     }
@@ -1610,7 +1867,7 @@ value *
 valCastLiteral (sym_link * dtype, double fval)
 {
   value *val;
-  TYPE_UDWORD l = (TYPE_UDWORD)fval;
+  TYPE_TARGET_ULONG l = (TYPE_TARGET_ULONG)fval;
 
   if (!dtype)
     return NULL;
@@ -1650,14 +1907,14 @@ valCastLiteral (sym_link * dtype, double fval)
   } else {
       if (SPEC_LONG (val->etype)) {
           if (SPEC_USIGN (val->etype))
-              SPEC_CVAL (val->etype).v_ulong = (TYPE_UDWORD) l;
+              SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
           else
-              SPEC_CVAL (val->etype).v_long = (TYPE_DWORD) l;
+              SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) l;
       } else {
           if (SPEC_USIGN (val->etype))
-              SPEC_CVAL (val->etype).v_uint = (TYPE_UWORD)l;
+              SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT)l;
           else
-              SPEC_CVAL (val->etype).v_int = (TYPE_WORD)l;
+              SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT)l;
       }
   }
   return val;