+ value *val;
+
+ if (!sym)
+ return NULL;
+
+ val = newValue ();
+ val->sym = sym;
+
+ if (sym->type)
+ {
+ val->type = sym->type;
+ val->etype = getSpec (val->type);
+ }
+
+ if (*sym->rname)
+ {
+ SNPRINTF (val->name, sizeof(val->name), "%s", sym->rname);
+ }
+ else
+ {
+ SNPRINTF (val->name, sizeof(val->name), "_%s", sym->name);
+ }
+
+ return val;
+}
+
+/*--------------------------------------------------------------------*/
+/* cheapestVal - try to reduce 'signed int' to 'char' */
+/*--------------------------------------------------------------------*/
+static value *
+cheapestVal (value *val)
+{
+ /* only int can be reduced */
+ if (!IS_INT(val->type))
+ return val;
+
+ /* long must not be changed */
+ if (SPEC_LONG(val->type))
+ return val;
+
+ /* unsigned must not be changed */
+ if (SPEC_USIGN(val->type))
+ return val;
+
+ /* 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 (SPEC_CVAL(val->type).v_int < -128 ||
+ SPEC_CVAL(val->type).v_int > 255)
+ {
+ /* 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 (SPEC_CVAL(val->type).v_int >= 0)
+ {
+ SPEC_USIGN(val->type) = 1;
+ }
+ return (val);
+}
+
+/*--------------------------------------------------------------------*/
+/* 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;
+ }
projects / fw / sdcc / blobdiff