{RRC, "rrc", picGenericOne, NULL},
{RLC, "rlc", picGenericOne, NULL},
{GETHBIT, "ghbit", picGenericOne, NULL},
+ {GETABIT, "gabit", picGenericOne, NULL},
+ {GETBYTE, "gbyte", picGenericOne, NULL},
+ {GETWORD, "gword", picGenericOne, NULL},
{UNARYMINUS, "-", picGenericOne, NULL},
{IPUSH, "push", picGenericOne, NULL},
{IPOP, "pop", picGenericOne, NULL},
{SWAP, "swap", picGenericOne, NULL}
};
-/*-----------------------------------------------------------------*/
-/* checkConstantRange: check a constant against the type */
-/*-----------------------------------------------------------------*/
-
-
-/* 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++;
- }
- v=-v;
- }
-
- // if very pedantic: "char c=200" is not allowed
- if (pedantic>1 && !IS_UNSIGNED(ltype)) {
- max = max/2 + negative;
- }
-
- 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 (pedantic>1)
- fatalError++;
- }
-#endif
-}
-
/*-----------------------------------------------------------------*/
/* operandName - returns the name of the operand */
/*-----------------------------------------------------------------*/
opetype = getSpec (operandType (op));
if (IS_FLOAT (opetype))
fprintf (file, "%g {", SPEC_CVAL (opetype).v_float);
- if (IS_FIXED16X16 (opetype))
+ else if (IS_FIXED16X16 (opetype))
fprintf (file, "%g {", doubleFromFixed16x16(SPEC_CVAL (opetype).v_fixed16x16));
else
fprintf (file, "0x%x {", (unsigned) floatFromVal (op->operand.valOperand));
}
/*-----------------------------------------------------------------*/
-/* 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;
return (IN_FARSPACE (SPEC_OCLS (etype)) ? TRUE : FALSE);
}
+/*-----------------------------------------------------------------*/
+/* isOperandInPagedSpace - return true if operand is in pagedSpace */
+/*-----------------------------------------------------------------*/
+bool
+isOperandInPagedSpace (operand * op)
+{
+ sym_link *etype;
+
+ if (!op)
+ return FALSE;
+
+ if (!IS_SYMOP (op))
+ return FALSE;
+
+ if (!IS_TRUE_SYMOP (op))
+ {
+ if (SPIL_LOC (op))
+ etype = SPIL_LOC (op)->etype;
+ else
+ return FALSE;
+ }
+ else
+ {
+ etype = getSpec (operandType (op));
+ }
+ return (IN_PAGEDSPACE (SPEC_OCLS (etype)) ? TRUE : FALSE);
+}
+
/*------------------------------------------------------------------*/
/* isOperandInDirSpace - will return true if operand is in dirSpace */
/*------------------------------------------------------------------*/
(TYPE_UDWORD) operandLitValue (right));
break;
case EQ_OP:
- if (IS_FLOAT (let) ||
- IS_FLOAT (ret))
+ if (IS_FLOAT (let) || IS_FLOAT (ret))
{
retval = operandFromLit (operandLitValue (left) ==
operandLitValue (right));
}
- else
- if (IS_FIXED16X16 (let) ||
- IS_FIXED16X16 (ret))
+ else if (IS_FIXED16X16 (let) || IS_FIXED16X16 (ret))
{
retval = operandFromLit (operandLitValue (left) ==
operandLitValue (right));
(i >> 1));
}
break;
+ case GETABIT:
+ retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >>
+ (TYPE_UDWORD)operandLitValue(right)) & 1);
+ break;
+ case GETBYTE:
+ retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >>
+ (TYPE_UDWORD)operandLitValue(right)) & 0xFF);
+ break;
+ case GETWORD:
+ retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >>
+ (TYPE_UDWORD)operandLitValue(right)) & 0xFFFF);
+ break;
+
+ case GETHBIT:
+ retval = operandFromLit (((TYPE_UDWORD)operandLitValue(left) >>
+ ((getSize (let) * 8) - 1)) & 1);
+ break;
case UNARYMINUS:
retval = operandFromValue (valCastLiteral (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);
/* code generated for 1 byte * 1 byte literal = 2 bytes result is more
efficient in most cases than 2 bytes result = 2 bytes << literal
if port has 1 byte muldiv */
- if (p2 && !IS_FLOAT (letype) && !IS_FIXED (letype)
+ if ((p2 > 0) && !IS_FLOAT (letype) && !IS_FIXED (letype)
&& !((resultType == RESULT_TYPE_INT) && (getSize (resType) != getSize (ltype))
&& (port->support.muldiv == 1))
&& strcmp (port->target, "pic16") != 0 /* don't shift for pic */
!IS_FLOAT (letype) &&
!IS_FIXED (letype) &&
IS_UNSIGNED(letype) &&
- (p2 = powof2 ((TYPE_UDWORD)
- floatFromVal (right->operand.valOperand)))) {
+ ((p2 = powof2 ((TYPE_UDWORD)
+ floatFromVal (right->operand.valOperand))) > 0)) {
ic = newiCode (RIGHT_OP, left, operandFromLit (p2)); /* right shift */
}
else
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: */
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))
{
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)
werror(W_SIZEOF_VOID);
if (IS_FLOAT (rvtype))
ic = newiCode ('+', rv, operandFromValue (constFloatVal ("1.0")));
- else
- if (IS_FIXED16X16 (rvtype))
+ else if (IS_FIXED16X16 (rvtype))
ic = newiCode ('+', rv, operandFromValue (constFixed16x16Val ("1.0")));
else
ic = newiCode ('+', rv, operandFromLit (size));
werror(W_SIZEOF_VOID);
if (IS_FLOAT (roptype))
ic = newiCode ('+', rop, operandFromValue (constFloatVal ("1.0")));
- else
- if (IS_FIXED16X16 (roptype))
+ else if (IS_FIXED16X16 (roptype))
ic = newiCode ('+', rop, operandFromValue (constFixed16x16Val ("1.0")));
else
ic = newiCode ('+', rop, operandFromLit (size));
werror(W_SIZEOF_VOID);
if (IS_FLOAT (rvtype))
ic = newiCode ('-', rv, operandFromValue (constFloatVal ("1.0")));
- else
- if (IS_FIXED16X16 (rvtype))
+ else if (IS_FIXED16X16 (rvtype))
ic = newiCode ('-', rv, operandFromValue (constFixed16x16Val ("1.0")));
else
ic = newiCode ('-', rv, operandFromLit (size));
werror(W_SIZEOF_VOID);
if (IS_FLOAT (roptype))
ic = newiCode ('-', rop, operandFromValue (constFloatVal ("1.0")));
- else
- if (IS_FIXED16X16 (roptype))
+ else if (IS_FIXED16X16 (roptype))
ic = newiCode ('-', rop, operandFromValue (constFixed16x16Val ("1.0")));
else
ic = newiCode ('-', rop, operandFromLit (size));
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;
ADDTOCHAIN (ic);
return IC_RESULT (ic);
}
+
/*-----------------------------------------------------------------*/
/* setOClass - sets the output class depending on the pointer type */
/*-----------------------------------------------------------------*/
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,
}
}
- 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);
}
/*-----------------------------------------------------------------*/
-/* geniCodeUnary - for a a generic unary operation */
+/* geniCodeUnary - for a generic unary operation */
/*-----------------------------------------------------------------*/
operand *
geniCodeUnary (operand * op, int oper)
return IC_RESULT (ic);
}
+/*-----------------------------------------------------------------*/
+/* geniCodeBinary - for a generic binary operation */
+/*-----------------------------------------------------------------*/
+operand *
+geniCodeBinary (operand * left, operand * right, int oper)
+{
+ iCode *ic = newiCode (oper, left, right);
+
+ IC_RESULT (ic) = newiTempOperand (operandType (left), 0);
+ ADDTOCHAIN (ic);
+ return IC_RESULT (ic);
+}
+
/*-----------------------------------------------------------------*/
/* geniCodeConditional - geniCode for '?' ':' operation */
/*-----------------------------------------------------------------*/
/* 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 */
isOperandGlobal (left))
{
symbol *sym = NULL;
+ operand *newRight;
if (IS_TRUE_SYMOP (right))
sym = OP_SYMBOL (right);
ic = newiCode ('=', NULL, right);
- IC_RESULT (ic) = right = newiTempOperand (ltype, 0);
- SPIL_LOC (right) = sym;
+ IC_RESULT (ic) = newRight = newiTempOperand (ltype, 0);
+ /* avoid double fetch from volatile right, see bug 1369874 */
+ if (!isOperandVolatile (right, FALSE))
+ SPIL_LOC (newRight) = sym;
+ right = newRight;
ADDTOCHAIN (ic);
}
/* for all arguments that are passed in registers */
while (args)
{
- int first = 1;
if (IS_REGPARM (args->etype))
{
operand *opr = operandFromValue (args);
ic = newiCode (RECEIVE, func, NULL);
ic->argreg = SPEC_ARGREG(args->etype);
- if (first) {
+ if (ic->argreg == 1) {
currFunc->recvSize = getSize (sym->type);
- first = 0;
}
IC_RESULT (ic) = opr;
{
if (tree->falseLabel)
geniCodeGoto (tree->falseLabel);
- else
- assert (0);
}
goto exit;
}
setOperandType (op, UCHARTYPE);
return op;
}
+ case GETABIT:
+ case GETBYTE:
+ case GETWORD:
+ {
+ operand *op = geniCodeBinary (geniCodeRValue (left, FALSE),
+ geniCodeRValue (right, FALSE),
+ tree->opval.op);
+ setOperandType (op, (tree->opval.op == GETWORD) ? UINTTYPE : UCHARTYPE);
+ return op;
+ }
case AND_OP:
case OR_OP:
return geniCodeLogicAndOr (tree, lvl);
projects / fw / sdcc / blobdiff