PRINTFUNC (picJumpTable);
PRINTFUNC (picInline);
PRINTFUNC (picReceive);
+PRINTFUNC (picDummyRead);
iCodeTable codeTable[] =
{
{RECEIVE, "recv", picReceive, NULL},
{SEND, "send", picGenericOne, NULL},
{ARRAYINIT, "arrayInit", picGenericOne, NULL},
+ {DUMMY_READ_VOLATILE, "dummy = (volatile)", picDummyRead, NULL}
};
-// this makes it more easy to catch bugs
-struct bitVect *OP_DEFS(struct operand *op) {
- wassert (IS_SYMOP(op));
- return OP_SYMBOL(op)->defs;
-}
-struct bitVect *OP_DEFS_SET(struct operand *op, struct bitVect *bv) {
- wassert (IS_SYMOP(op));
- OP_SYMBOL(op)->defs=bv;
- return bv;
-}
-struct bitVect *OP_USES(struct operand *op) {
- wassert (IS_SYMOP(op));
- return OP_SYMBOL(op)->uses;
-}
-struct bitVect *OP_USES_SET(struct operand *op, struct bitVect *bv) {
- wassert (IS_SYMOP(op));
- OP_SYMBOL(op)->uses=bv;
- return bv;
-}
-
/*-----------------------------------------------------------------*/
/* checkConstantRange: check a constant against the type */
/*-----------------------------------------------------------------*/
pedantic>1: "char c=200" is not allowed (evaluates to -56)
*/
-void checkConstantRange(sym_link *ltype, value *val, char *msg,
+void checkConstantRange(sym_link *ltype, value *val, char *msg,
int pedantic) {
double max;
int warnings=0;
if (SPEC_NOUN (opetype) == V_FLOAT)
fprintf (file, "%g {", SPEC_CVAL (opetype).v_float);
else
- fprintf (file, "0x%x {", (int) floatFromVal (op->operand.valOperand));
+ fprintf (file, "0x%x {", (unsigned) floatFromVal (op->operand.valOperand));
printTypeChain (operandType (op), file);
fprintf (file, "}");
break;
fprintf (of, "\n");
}
+PRINTFUNC (picDummyRead)
+{
+ fprintf (of, "\t");
+ fprintf (of, "%s ", s);
+ printOperand (IC_RIGHT (ic), of);
+ fprintf (of, "\n");
+}
+
/*-----------------------------------------------------------------*/
/* piCode - prints one iCode */
/*-----------------------------------------------------------------*/
-int
+int
piCode (void *item, FILE * of)
{
iCode *ic = item;
/*-----------------------------------------------------------------*/
/* printiCChain - prints intermediate code for humans */
/*-----------------------------------------------------------------*/
-void
+void
printiCChain (iCode * icChain, FILE * of)
{
iCode *loop;
{
if ((icTab = getTableEntry (loop->op)))
{
- fprintf (of, "%s(%d:%d:%d:%d:%d)\t",
+ fprintf (of, "%s(l%d:s%d:k%d:d%d:s%d)\t",
loop->filename, loop->lineno,
loop->seq, loop->key, loop->depth, loop->supportRtn);
ic = newiCode (op, NULL, NULL);
ic->op = op;
- ic->argLabel.label = label;
+ ic->label = label;
IC_LEFT (ic) = NULL;
IC_RIGHT (ic) = NULL;
IC_RESULT (ic) = NULL;
iCodeTable *
getTableEntry (int oper)
{
- int i;
+ unsigned i;
for (i = 0; i < (sizeof (codeTable) / sizeof (iCodeTable)); i++)
if (oper == codeTable[i].icode)
return 0;
opetype = getSpec (optype = operandType (op));
-
- if (IS_PTR (optype) && DCL_PTR_VOLATILE (optype))
- return 1;
-
- if (IS_VOLATILE (opetype))
- return 1;
- return 0;
+
+ if (IS_PTR (optype) && DCL_PTR_VOLATILE (optype))
+ return 1;
+
+ if (IS_VOLATILE (opetype))
+ return 1;
+ return 0;
}
/*-----------------------------------------------------------------*/
{
sym_link *let , *ret=NULL;
operand *retval = (operand *) 0;
-
+
assert (isOperandLiteral (left));
let = getSpec(operandType(left));
if (right) {
werror (E_DIVIDE_BY_ZERO);
retval = right;
}
- else
- retval = operandFromLit ((SPEC_USIGN(let) ?
+ else
+ retval = operandFromLit ((SPEC_USIGN(let) ?
(unsigned long) operandLitValue (left) :
(long) operandLitValue (left)) %
- (SPEC_USIGN(ret) ?
+ (SPEC_USIGN(ret) ?
(unsigned long) operandLitValue (right) :
(long) operandLitValue (right)));
break;
case LEFT_OP:
- retval = operandFromLit ((SPEC_USIGN(let) ?
+ retval = operandFromLit ((SPEC_USIGN(let) ?
(unsigned long) operandLitValue (left) :
(long) operandLitValue (left)) <<
- (SPEC_USIGN(ret) ?
+ (SPEC_USIGN(ret) ?
(unsigned long) operandLitValue (right) :
(long) operandLitValue (right)));
break;
case RIGHT_OP: {
double lval = operandLitValue(left), rval = operandLitValue(right);
double res=0;
- switch ((SPEC_USIGN(let) ? 2 : 0) + (SPEC_USIGN(ret) ? 1 : 0))
+ switch ((SPEC_USIGN(let) ? 2 : 0) + (SPEC_USIGN(ret) ? 1 : 0))
{
case 0: // left=unsigned right=unsigned
res=(unsigned long)lval >> (unsigned long)rval;
operandLitValue (right));
break;
case BITWISEAND:
- retval = operandFromLit ((long)operandLitValue(left) &
- (long)operandLitValue(right));
+ retval = operandFromValue (valCastLiteral (type,
+ (unsigned long)operandLitValue(left) &
+ (unsigned long)operandLitValue(right)));
break;
case '|':
- retval = operandFromLit ((long)operandLitValue (left) |
- (long)operandLitValue (right));
+ retval = operandFromValue (valCastLiteral (type,
+ (unsigned long)operandLitValue(left) |
+ (unsigned long)operandLitValue(right)));
break;
case '^':
- retval = operandFromLit ((long)operandLitValue (left) ^
- (long)operandLitValue (right));
+ retval = operandFromValue (valCastLiteral (type,
+ (unsigned long)operandLitValue(left) ^
+ (unsigned long)operandLitValue(right)));
break;
case AND_OP:
retval = operandFromLit (operandLitValue (left) &&
break;
case RRC:
{
- long i = (long) operandLitValue (left);
+ unsigned long i = (unsigned long) operandLitValue (left);
retval = operandFromLit ((i >> (getSize (operandType (left)) * 8 - 1)) |
(i << 1));
break;
case RLC:
{
- long i = (long) operandLitValue (left);
+ unsigned long i = (unsigned long) operandLitValue (left);
retval = operandFromLit ((i << (getSize (operandType (left)) * 8 - 1)) |
(i >> 1));
break;
case '~':
- retval = operandFromLit (~((long) operandLitValue (left)));
+ retval = operandFromLit (~((unsigned long) operandLitValue (left)));
break;
case '!':
case EX_LINK:
return operandFromLink (tree->opval.lnk);
- }
+ break;
- assert (0);
- /* Just to keep the comiler happy */
+ default:
+ assert (0);
+ }
+
+ /* Just to keep the compiler happy */
return (operand *) 0;
}
int isarray = 0;
LRTYPE;
-#if 0
- /* if left is an array then array access */
- if (IS_ARRAY (ltype))
- return geniCodeArray (left, right,lvl);
-#endif
-
/* if the right side is LITERAL zero */
/* return the left side */
if (IS_LITERAL (retype) && right->isLiteral && !floatFromVal (valFromType (retype)))
return type;
etype = getSpec (type);
- ptype = newLink ();
+ ptype = newLink (DECLARATOR);
ptype->next = type;
- /* if the output class is generic */
+
+ /* if the output class is code */
if ((DCL_TYPE (ptype) = PTR_TYPE (SPEC_OCLS (etype))) == CPOINTER)
DCL_PTR_CONST (ptype) = port->mem.code_ro;
/* the variable was volatile then pointer to volatile */
if (IS_VOLATILE (etype))
DCL_PTR_VOLATILE (ptype) = 1;
+
return ptype;
}
if ((DCL_TYPE (optype) = PTR_TYPE (SPEC_OCLS (opetype))) == CPOINTER)
DCL_PTR_CONST (optype) = port->mem.code_ro;
-
/* if the variable was declared a constant */
/* then the pointer points to a constant */
if (IS_CONSTANT (opetype))
/* the variable was volatile then pointer to volatile */
if (IS_VOLATILE (opetype))
DCL_PTR_VOLATILE (optype) = 1;
+
op->isaddr = 0;
return op;
}
/* return op; */
/* } */
- p = newLink ();
- p->class = DECLARATOR;
+ p = newLink (DECLARATOR);
/* set the pointer depending on the storage class */
if ((DCL_TYPE (p) = PTR_TYPE (SPEC_OCLS (opetype))) == CPOINTER)
sym_link *rtype, *retype;
sym_link *optype = operandType (op);
- /* if this is a pointer then generate the rvalue */
- if (IS_PTR (optype))
+ // if this is an array then array access
+ if (IS_ARRAY (optype)) {
+ // don't worry, this will be optimized out later
+ return geniCodeArray (op, operandFromLit (0), lvl);
+ }
+
+ // just in case someone screws up
+ wassert (IS_PTR (optype));
+
+ if (IS_TRUE_SYMOP (op))
{
- if (IS_TRUE_SYMOP (op))
- {
- op->isaddr = 1;
- op = geniCodeRValue (op, TRUE);
- }
- else
- op = geniCodeRValue (op, TRUE);
+ op->isaddr = 1;
+ op = geniCodeRValue (op, TRUE);
}
/* now get rid of the pointer part */
retype = getSpec (rtype = copyLinkChain (optype->next));
}
- /* if this is a pointer then outputclass needs 2b updated */
- if (IS_PTR (optype))
- setOClass (optype, retype);
+ /* outputclass needs 2b updated */
+ setOClass (optype, retype);
op->isGptr = IS_GENPTR (optype);
/* assign */
operand *top = operandFromSymbol (argVals->sym);
/* clear useDef and other bitVectors */
- OP_USES_SET ((top), OP_DEFS_SET ((top), OP_SYMBOL(top)->clashes = NULL));
+ OP_USES(top)=OP_DEFS(top)=OP_SYMBOL(top)->clashes = NULL;
geniCodeAssign (top, pval, 1);
}
else
case RIGHT_OP:
return geniCodeRightShift (geniCodeRValue (left, FALSE),
geniCodeRValue (right, FALSE));
- case CAST:
+ case CAST:
+#if 0 // this indeed needs a second thought
+ {
+ operand *op;
+
+ // let's keep this simple: get the rvalue we need
+ op=geniCodeRValue (right, FALSE);
+ // now cast it to whatever we want
+ op=geniCodeCast (operandType(left), op, FALSE);
+ // if this is going to be used as an lvalue, make it so
+ if (tree->lvalue) {
+ op->isaddr=1;
+ }
+ return op;
+ }
+#else // bug #604575, is it a bug ????
return geniCodeCast (operandType (left),
geniCodeRValue (right, FALSE), FALSE);
+#endif
case '~':
case '!':
projects / fw / sdcc / blobdiff