| 1 |
15 |
hellwig |
#include "c.h"
|
| 2 |
|
|
|
| 3 |
|
|
static char rcsid[] = "$Id: expr.c,v 1.1 2002/08/28 23:12:43 drh Exp $";
|
| 4 |
|
|
|
| 5 |
|
|
static char prec[] = {
|
| 6 |
|
|
#define xx(a,b,c,d,e,f,g) c,
|
| 7 |
|
|
#define yy(a,b,c,d,e,f,g) c,
|
| 8 |
|
|
#include "token.h"
|
| 9 |
|
|
};
|
| 10 |
|
|
static int oper[] = {
|
| 11 |
|
|
#define xx(a,b,c,d,e,f,g) d,
|
| 12 |
|
|
#define yy(a,b,c,d,e,f,g) d,
|
| 13 |
|
|
#include "token.h"
|
| 14 |
|
|
};
|
| 15 |
|
|
float refinc = 1.0;
|
| 16 |
|
|
static Tree expr2(void);
|
| 17 |
|
|
static Tree expr3(int);
|
| 18 |
|
|
static Tree nullcheck(Tree);
|
| 19 |
|
|
static Tree postfix(Tree);
|
| 20 |
|
|
static Tree unary(void);
|
| 21 |
|
|
static Tree primary(void);
|
| 22 |
|
|
static Type super(Type ty);
|
| 23 |
|
|
|
| 24 |
|
|
static Type super(Type ty) {
|
| 25 |
|
|
switch (ty->op) {
|
| 26 |
|
|
case INT:
|
| 27 |
|
|
if (ty->size < inttype->size)
|
| 28 |
|
|
return inttype;
|
| 29 |
|
|
break;
|
| 30 |
|
|
case UNSIGNED:
|
| 31 |
|
|
if (ty->size < unsignedtype->size)
|
| 32 |
|
|
return unsignedtype;
|
| 33 |
|
|
break;
|
| 34 |
|
|
case POINTER:
|
| 35 |
|
|
return unsignedptr;
|
| 36 |
|
|
}
|
| 37 |
|
|
return ty;
|
| 38 |
|
|
}
|
| 39 |
|
|
Tree expr(int tok) {
|
| 40 |
|
|
static char stop[] = { IF, ID, '}', 0 };
|
| 41 |
|
|
Tree p = expr1(0);
|
| 42 |
|
|
|
| 43 |
|
|
while (t == ',') {
|
| 44 |
|
|
Tree q;
|
| 45 |
|
|
t = gettok();
|
| 46 |
|
|
q = pointer(expr1(0));
|
| 47 |
|
|
p = tree(RIGHT, q->type, root(value(p)), q);
|
| 48 |
|
|
}
|
| 49 |
|
|
if (tok)
|
| 50 |
|
|
test(tok, stop);
|
| 51 |
|
|
return p;
|
| 52 |
|
|
}
|
| 53 |
|
|
Tree expr0(int tok) {
|
| 54 |
|
|
return root(expr(tok));
|
| 55 |
|
|
}
|
| 56 |
|
|
Tree expr1(int tok) {
|
| 57 |
|
|
static char stop[] = { IF, ID, 0 };
|
| 58 |
|
|
Tree p = expr2();
|
| 59 |
|
|
|
| 60 |
|
|
if (t == '='
|
| 61 |
|
|
|| (prec[t] >= 6 && prec[t] <= 8)
|
| 62 |
|
|
|| (prec[t] >= 11 && prec[t] <= 13)) {
|
| 63 |
|
|
int op = t;
|
| 64 |
|
|
t = gettok();
|
| 65 |
|
|
if (oper[op] == ASGN)
|
| 66 |
|
|
p = asgntree(ASGN, p, value(expr1(0)));
|
| 67 |
|
|
else
|
| 68 |
|
|
{
|
| 69 |
|
|
expect('=');
|
| 70 |
|
|
p = incr(op, p, expr1(0));
|
| 71 |
|
|
}
|
| 72 |
|
|
}
|
| 73 |
|
|
if (tok)
|
| 74 |
|
|
test(tok, stop);
|
| 75 |
|
|
return p;
|
| 76 |
|
|
}
|
| 77 |
|
|
Tree incr(int op, Tree v, Tree e) {
|
| 78 |
|
|
return asgntree(ASGN, v, (*optree[op])(oper[op], v, e));
|
| 79 |
|
|
}
|
| 80 |
|
|
static Tree expr2(void) {
|
| 81 |
|
|
Tree p = expr3(4);
|
| 82 |
|
|
|
| 83 |
|
|
if (t == '?') {
|
| 84 |
|
|
Tree l, r;
|
| 85 |
|
|
Coordinate pts[2];
|
| 86 |
|
|
if (Aflag > 1 && isfunc(p->type))
|
| 87 |
|
|
warning("%s used in a conditional expression\n",
|
| 88 |
|
|
funcname(p));
|
| 89 |
|
|
p = pointer(p);
|
| 90 |
|
|
t = gettok();
|
| 91 |
|
|
pts[0] = src;
|
| 92 |
|
|
l = pointer(expr(':'));
|
| 93 |
|
|
pts[1] = src;
|
| 94 |
|
|
r = pointer(expr2());
|
| 95 |
|
|
if (generic(p->op) != CNST && events.points)
|
| 96 |
|
|
{
|
| 97 |
|
|
apply(events.points, &pts[0], &l);
|
| 98 |
|
|
apply(events.points, &pts[1], &r);
|
| 99 |
|
|
}
|
| 100 |
|
|
p = condtree(p, l, r);
|
| 101 |
|
|
}
|
| 102 |
|
|
return p;
|
| 103 |
|
|
}
|
| 104 |
|
|
Tree value(Tree p) {
|
| 105 |
|
|
int op = generic(rightkid(p)->op);
|
| 106 |
|
|
|
| 107 |
|
|
if (p->type != voidtype
|
| 108 |
|
|
&& (op==AND || op==OR || op==NOT || op==EQ || op==NE
|
| 109 |
|
|
|| op== LE || op==LT || op== GE || op==GT))
|
| 110 |
|
|
p = condtree(p, consttree(1, inttype),
|
| 111 |
|
|
consttree(0, inttype));
|
| 112 |
|
|
return p;
|
| 113 |
|
|
}
|
| 114 |
|
|
static Tree expr3(int k) {
|
| 115 |
|
|
int k1;
|
| 116 |
|
|
Tree p = unary();
|
| 117 |
|
|
|
| 118 |
|
|
for (k1 = prec[t]; k1 >= k; k1--)
|
| 119 |
|
|
while (prec[t] == k1 && *cp != '=') {
|
| 120 |
|
|
Tree r;
|
| 121 |
|
|
Coordinate pt;
|
| 122 |
|
|
int op = t;
|
| 123 |
|
|
t = gettok();
|
| 124 |
|
|
pt = src;
|
| 125 |
|
|
p = pointer(p);
|
| 126 |
|
|
if (op == ANDAND || op == OROR) {
|
| 127 |
|
|
r = pointer(expr3(k1));
|
| 128 |
|
|
if (events.points)
|
| 129 |
|
|
apply(events.points, &pt, &r);
|
| 130 |
|
|
} else
|
| 131 |
|
|
r = pointer(expr3(k1 + 1));
|
| 132 |
|
|
p = (*optree[op])(oper[op], p, r);
|
| 133 |
|
|
}
|
| 134 |
|
|
return p;
|
| 135 |
|
|
}
|
| 136 |
|
|
static Tree unary(void) {
|
| 137 |
|
|
Tree p;
|
| 138 |
|
|
|
| 139 |
|
|
switch (t) {
|
| 140 |
|
|
case '*': t = gettok(); p = unary(); p = pointer(p);
|
| 141 |
|
|
if (isptr(p->type)
|
| 142 |
|
|
&& (isfunc(p->type->type) || isarray(p->type->type)))
|
| 143 |
|
|
p = retype(p, p->type->type);
|
| 144 |
|
|
else {
|
| 145 |
|
|
if (YYnull)
|
| 146 |
|
|
p = nullcheck(p);
|
| 147 |
|
|
p = rvalue(p);
|
| 148 |
|
|
} break;
|
| 149 |
|
|
case '&': t = gettok(); p = unary(); if (isarray(p->type) || isfunc(p->type))
|
| 150 |
|
|
p = retype(p, ptr(p->type));
|
| 151 |
|
|
else
|
| 152 |
|
|
p = lvalue(p);
|
| 153 |
|
|
if (isaddrop(p->op) && p->u.sym->sclass == REGISTER)
|
| 154 |
|
|
error("invalid operand of unary &; `%s' is declared register\n", p->u.sym->name);
|
| 155 |
|
|
|
| 156 |
|
|
else if (isaddrop(p->op))
|
| 157 |
|
|
p->u.sym->addressed = 1;
|
| 158 |
|
|
break;
|
| 159 |
|
|
case '+': t = gettok(); p = unary(); p = pointer(p);
|
| 160 |
|
|
if (isarith(p->type))
|
| 161 |
|
|
p = cast(p, promote(p->type));
|
| 162 |
|
|
else
|
| 163 |
|
|
typeerror(ADD, p, NULL); break;
|
| 164 |
|
|
case '-': t = gettok(); p = unary(); p = pointer(p);
|
| 165 |
|
|
if (isarith(p->type)) {
|
| 166 |
|
|
Type ty = promote(p->type);
|
| 167 |
|
|
p = cast(p, ty);
|
| 168 |
|
|
if (isunsigned(ty)) {
|
| 169 |
|
|
warning("unsigned operand of unary -\n");
|
| 170 |
|
|
p = simplify(ADD, ty, simplify(BCOM, ty, p, NULL), cnsttree(ty, 1UL));
|
| 171 |
|
|
} else
|
| 172 |
|
|
p = simplify(NEG, ty, p, NULL);
|
| 173 |
|
|
} else
|
| 174 |
|
|
typeerror(SUB, p, NULL); break;
|
| 175 |
|
|
case '~': t = gettok(); p = unary(); p = pointer(p);
|
| 176 |
|
|
if (isint(p->type)) {
|
| 177 |
|
|
Type ty = promote(p->type);
|
| 178 |
|
|
p = simplify(BCOM, ty, cast(p, ty), NULL);
|
| 179 |
|
|
} else
|
| 180 |
|
|
typeerror(BCOM, p, NULL); break;
|
| 181 |
|
|
case '!': t = gettok(); p = unary(); p = pointer(p);
|
| 182 |
|
|
if (isscalar(p->type))
|
| 183 |
|
|
p = simplify(NOT, inttype, cond(p), NULL);
|
| 184 |
|
|
else
|
| 185 |
|
|
typeerror(NOT, p, NULL); break;
|
| 186 |
|
|
case INCR: t = gettok(); p = unary(); p = incr(INCR, pointer(p), consttree(1, inttype)); break;
|
| 187 |
|
|
case DECR: t = gettok(); p = unary(); p = incr(DECR, pointer(p), consttree(1, inttype)); break;
|
| 188 |
|
|
case TYPECODE: case SIZEOF: { int op = t;
|
| 189 |
|
|
Type ty;
|
| 190 |
|
|
p = NULL;
|
| 191 |
|
|
t = gettok();
|
| 192 |
|
|
if (t == '(') {
|
| 193 |
|
|
t = gettok();
|
| 194 |
|
|
if (istypename(t, tsym)) {
|
| 195 |
|
|
ty = typename();
|
| 196 |
|
|
expect(')');
|
| 197 |
|
|
} else {
|
| 198 |
|
|
p = postfix(expr(')'));
|
| 199 |
|
|
ty = p->type;
|
| 200 |
|
|
}
|
| 201 |
|
|
} else {
|
| 202 |
|
|
p = unary();
|
| 203 |
|
|
ty = p->type;
|
| 204 |
|
|
}
|
| 205 |
|
|
assert(ty);
|
| 206 |
|
|
if (op == TYPECODE)
|
| 207 |
|
|
p = cnsttree(inttype, (long)ty->op);
|
| 208 |
|
|
else {
|
| 209 |
|
|
if (isfunc(ty) || ty->size == 0)
|
| 210 |
|
|
error("invalid type argument `%t' to `sizeof'\n", ty);
|
| 211 |
|
|
else if (p && rightkid(p)->op == FIELD)
|
| 212 |
|
|
error("`sizeof' applied to a bit field\n");
|
| 213 |
|
|
p = cnsttree(unsignedlong, (unsigned long)ty->size);
|
| 214 |
|
|
} } break;
|
| 215 |
|
|
case '(':
|
| 216 |
|
|
t = gettok();
|
| 217 |
|
|
if (istypename(t, tsym)) {
|
| 218 |
|
|
Type ty, ty1 = typename(), pty;
|
| 219 |
|
|
expect(')');
|
| 220 |
|
|
ty = unqual(ty1);
|
| 221 |
|
|
if (isenum(ty)) {
|
| 222 |
|
|
Type ty2 = ty->type;
|
| 223 |
|
|
if (isconst(ty1))
|
| 224 |
|
|
ty2 = qual(CONST, ty2);
|
| 225 |
|
|
if (isvolatile(ty1))
|
| 226 |
|
|
ty2 = qual(VOLATILE, ty2);
|
| 227 |
|
|
ty1 = ty2;
|
| 228 |
|
|
ty = ty->type;
|
| 229 |
|
|
}
|
| 230 |
|
|
p = pointer(unary());
|
| 231 |
|
|
pty = p->type;
|
| 232 |
|
|
if (isenum(pty))
|
| 233 |
|
|
pty = pty->type;
|
| 234 |
|
|
if (isarith(pty) && isarith(ty)
|
| 235 |
|
|
|| isptr(pty) && isptr(ty)) {
|
| 236 |
|
|
explicitCast++;
|
| 237 |
|
|
p = cast(p, ty);
|
| 238 |
|
|
explicitCast--;
|
| 239 |
|
|
} else if (isptr(pty) && isint(ty)
|
| 240 |
|
|
|| isint(pty) && isptr(ty)) {
|
| 241 |
|
|
if (Aflag >= 1 && ty->size < pty->size)
|
| 242 |
|
|
warning("conversion from `%t' to `%t' is compiler dependent\n", p->type, ty);
|
| 243 |
|
|
|
| 244 |
|
|
p = cast(p, ty);
|
| 245 |
|
|
} else if (ty != voidtype) {
|
| 246 |
|
|
error("cast from `%t' to `%t' is illegal\n",
|
| 247 |
|
|
p->type, ty1);
|
| 248 |
|
|
ty1 = inttype;
|
| 249 |
|
|
}
|
| 250 |
|
|
if (generic(p->op) == INDIR || ty->size == 0)
|
| 251 |
|
|
p = tree(RIGHT, ty1, NULL, p);
|
| 252 |
|
|
else
|
| 253 |
|
|
p = retype(p, ty1);
|
| 254 |
|
|
} else
|
| 255 |
|
|
p = postfix(expr(')'));
|
| 256 |
|
|
break;
|
| 257 |
|
|
default:
|
| 258 |
|
|
p = postfix(primary());
|
| 259 |
|
|
}
|
| 260 |
|
|
return p;
|
| 261 |
|
|
}
|
| 262 |
|
|
|
| 263 |
|
|
static Tree postfix(Tree p) {
|
| 264 |
|
|
for (;;)
|
| 265 |
|
|
switch (t) {
|
| 266 |
|
|
case INCR: p = tree(RIGHT, p->type,
|
| 267 |
|
|
tree(RIGHT, p->type,
|
| 268 |
|
|
p,
|
| 269 |
|
|
incr(t, p, consttree(1, inttype))),
|
| 270 |
|
|
p);
|
| 271 |
|
|
t = gettok(); break;
|
| 272 |
|
|
case DECR: p = tree(RIGHT, p->type,
|
| 273 |
|
|
tree(RIGHT, p->type,
|
| 274 |
|
|
p,
|
| 275 |
|
|
incr(t, p, consttree(1, inttype))),
|
| 276 |
|
|
p);
|
| 277 |
|
|
t = gettok(); break;
|
| 278 |
|
|
case '[': {
|
| 279 |
|
|
Tree q;
|
| 280 |
|
|
t = gettok();
|
| 281 |
|
|
q = expr(']');
|
| 282 |
|
|
if (YYnull)
|
| 283 |
|
|
if (isptr(p->type))
|
| 284 |
|
|
p = nullcheck(p);
|
| 285 |
|
|
else if (isptr(q->type))
|
| 286 |
|
|
q = nullcheck(q);
|
| 287 |
|
|
p = (*optree['+'])(ADD, pointer(p), pointer(q));
|
| 288 |
|
|
if (isptr(p->type) && isarray(p->type->type))
|
| 289 |
|
|
p = retype(p, p->type->type);
|
| 290 |
|
|
else
|
| 291 |
|
|
p = rvalue(p);
|
| 292 |
|
|
} break;
|
| 293 |
|
|
case '(': {
|
| 294 |
|
|
Type ty;
|
| 295 |
|
|
Coordinate pt;
|
| 296 |
|
|
p = pointer(p);
|
| 297 |
|
|
if (isptr(p->type) && isfunc(p->type->type))
|
| 298 |
|
|
ty = p->type->type;
|
| 299 |
|
|
else {
|
| 300 |
|
|
error("found `%t' expected a function\n", p->type);
|
| 301 |
|
|
ty = func(voidtype, NULL, 1);
|
| 302 |
|
|
p = retype(p, ptr(ty));
|
| 303 |
|
|
}
|
| 304 |
|
|
pt = src;
|
| 305 |
|
|
t = gettok();
|
| 306 |
|
|
p = call(p, ty, pt);
|
| 307 |
|
|
} break;
|
| 308 |
|
|
case '.': t = gettok();
|
| 309 |
|
|
if (t == ID) {
|
| 310 |
|
|
if (isstruct(p->type)) {
|
| 311 |
|
|
Tree q = addrof(p);
|
| 312 |
|
|
p = field(q, token);
|
| 313 |
|
|
q = rightkid(q);
|
| 314 |
|
|
if (isaddrop(q->op) && q->u.sym->temporary)
|
| 315 |
|
|
p = tree(RIGHT, p->type, p, NULL);
|
| 316 |
|
|
} else
|
| 317 |
|
|
error("left operand of . has incompatible type `%t'\n",
|
| 318 |
|
|
p->type);
|
| 319 |
|
|
t = gettok();
|
| 320 |
|
|
} else
|
| 321 |
|
|
error("field name expected\n"); break;
|
| 322 |
|
|
case DEREF: t = gettok();
|
| 323 |
|
|
p = pointer(p);
|
| 324 |
|
|
if (t == ID) {
|
| 325 |
|
|
if (isptr(p->type) && isstruct(p->type->type)) {
|
| 326 |
|
|
if (YYnull)
|
| 327 |
|
|
p = nullcheck(p);
|
| 328 |
|
|
p = field(p, token);
|
| 329 |
|
|
} else
|
| 330 |
|
|
error("left operand of -> has incompatible type `%t'\n", p->type);
|
| 331 |
|
|
|
| 332 |
|
|
t = gettok();
|
| 333 |
|
|
} else
|
| 334 |
|
|
error("field name expected\n"); break;
|
| 335 |
|
|
default:
|
| 336 |
|
|
return p;
|
| 337 |
|
|
}
|
| 338 |
|
|
}
|
| 339 |
|
|
static Tree primary(void) {
|
| 340 |
|
|
Tree p;
|
| 341 |
|
|
|
| 342 |
|
|
assert(t != '(');
|
| 343 |
|
|
switch (t) {
|
| 344 |
|
|
case ICON:
|
| 345 |
|
|
case FCON: p = tree(mkop(CNST,tsym->type), tsym->type, NULL, NULL);
|
| 346 |
|
|
p->u.v = tsym->u.c.v;
|
| 347 |
|
|
break;
|
| 348 |
|
|
case SCON: if (ischar(tsym->type->type))
|
| 349 |
|
|
tsym->u.c.v.p = stringn(tsym->u.c.v.p, tsym->type->size);
|
| 350 |
|
|
else
|
| 351 |
|
|
tsym->u.c.v.p = memcpy(allocate((tsym->type->size/widechar->size)*sizeof (int), PERM),
|
| 352 |
|
|
tsym->u.c.v.p, (tsym->type->size/widechar->size)*sizeof (int));
|
| 353 |
|
|
tsym = constant(tsym->type, tsym->u.c.v);
|
| 354 |
|
|
if (tsym->u.c.loc == NULL)
|
| 355 |
|
|
tsym->u.c.loc = genident(STATIC, tsym->type, GLOBAL);
|
| 356 |
|
|
p = idtree(tsym->u.c.loc); break;
|
| 357 |
|
|
case ID: if (tsym == NULL)
|
| 358 |
|
|
{
|
| 359 |
|
|
Symbol p = install(token, &identifiers, level, PERM);
|
| 360 |
|
|
p->src = src;
|
| 361 |
|
|
if (getchr() == '(') {
|
| 362 |
|
|
Symbol q = lookup(token, externals);
|
| 363 |
|
|
p->type = func(inttype, NULL, 1);
|
| 364 |
|
|
p->sclass = EXTERN;
|
| 365 |
|
|
if (Aflag >= 1)
|
| 366 |
|
|
warning("missing prototype\n");
|
| 367 |
|
|
if (q && !eqtype(q->type, p->type, 1))
|
| 368 |
|
|
warning("implicit declaration of `%s' does not match previous declaration at %w\n", q->name, &q->src);
|
| 369 |
|
|
|
| 370 |
|
|
if (q == NULL) {
|
| 371 |
|
|
q = install(p->name, &externals, GLOBAL, PERM);
|
| 372 |
|
|
q->type = p->type;
|
| 373 |
|
|
q->sclass = EXTERN;
|
| 374 |
|
|
q->src = src;
|
| 375 |
|
|
(*IR->defsymbol)(q);
|
| 376 |
|
|
}
|
| 377 |
|
|
p->u.alias = q;
|
| 378 |
|
|
} else {
|
| 379 |
|
|
error("undeclared identifier `%s'\n", p->name);
|
| 380 |
|
|
p->sclass = AUTO;
|
| 381 |
|
|
p->type = inttype;
|
| 382 |
|
|
if (p->scope == GLOBAL)
|
| 383 |
|
|
(*IR->defsymbol)(p);
|
| 384 |
|
|
else
|
| 385 |
|
|
addlocal(p);
|
| 386 |
|
|
}
|
| 387 |
|
|
t = gettok();
|
| 388 |
|
|
if (xref)
|
| 389 |
|
|
use(p, src);
|
| 390 |
|
|
return idtree(p);
|
| 391 |
|
|
}
|
| 392 |
|
|
if (xref)
|
| 393 |
|
|
use(tsym, src);
|
| 394 |
|
|
if (tsym->sclass == ENUM)
|
| 395 |
|
|
p = consttree(tsym->u.value, inttype);
|
| 396 |
|
|
else {
|
| 397 |
|
|
if (tsym->sclass == TYPEDEF)
|
| 398 |
|
|
error("illegal use of type name `%s'\n", tsym->name);
|
| 399 |
|
|
p = idtree(tsym);
|
| 400 |
|
|
} break;
|
| 401 |
|
|
case FIRSTARG:
|
| 402 |
|
|
if (level > PARAM && cfunc && cfunc->u.f.callee[0])
|
| 403 |
|
|
p = idtree(cfunc->u.f.callee[0]);
|
| 404 |
|
|
else {
|
| 405 |
|
|
error("illegal use of `%k'\n", FIRSTARG);
|
| 406 |
|
|
p = cnsttree(inttype, 0L);
|
| 407 |
|
|
}
|
| 408 |
|
|
break;
|
| 409 |
|
|
default:
|
| 410 |
|
|
error("illegal expression\n");
|
| 411 |
|
|
p = cnsttree(inttype, 0L);
|
| 412 |
|
|
}
|
| 413 |
|
|
t = gettok();
|
| 414 |
|
|
return p;
|
| 415 |
|
|
}
|
| 416 |
|
|
Tree idtree(Symbol p) {
|
| 417 |
|
|
int op;
|
| 418 |
|
|
Tree e;
|
| 419 |
|
|
Type ty = p->type ? unqual(p->type) : voidptype;
|
| 420 |
|
|
|
| 421 |
|
|
if (p->scope == GLOBAL || p->sclass == STATIC)
|
| 422 |
|
|
op = ADDRG;
|
| 423 |
|
|
else if (p->scope == PARAM) {
|
| 424 |
|
|
op = ADDRF;
|
| 425 |
|
|
if (isstruct(p->type) && !IR->wants_argb)
|
| 426 |
|
|
{
|
| 427 |
|
|
e = tree(mkop(op,voidptype), ptr(ptr(p->type)), NULL, NULL);
|
| 428 |
|
|
e->u.sym = p;
|
| 429 |
|
|
return rvalue(rvalue(e));
|
| 430 |
|
|
}
|
| 431 |
|
|
} else if (p->sclass == EXTERN) {
|
| 432 |
|
|
assert(p->u.alias);
|
| 433 |
|
|
p = p->u.alias;
|
| 434 |
|
|
op = ADDRG;
|
| 435 |
|
|
} else
|
| 436 |
|
|
op = ADDRL;
|
| 437 |
|
|
p->ref += refinc;
|
| 438 |
|
|
if (isarray(ty))
|
| 439 |
|
|
e = tree(mkop(op,voidptype), p->type, NULL, NULL);
|
| 440 |
|
|
else if (isfunc(ty))
|
| 441 |
|
|
e = tree(mkop(op,funcptype), p->type, NULL, NULL);
|
| 442 |
|
|
else
|
| 443 |
|
|
e = tree(mkop(op,voidptype), ptr(p->type), NULL, NULL);
|
| 444 |
|
|
e->u.sym = p;
|
| 445 |
|
|
if (isptr(e->type))
|
| 446 |
|
|
e = rvalue(e);
|
| 447 |
|
|
return e;
|
| 448 |
|
|
}
|
| 449 |
|
|
|
| 450 |
|
|
Tree rvalue(Tree p) {
|
| 451 |
|
|
Type ty = deref(p->type);
|
| 452 |
|
|
|
| 453 |
|
|
ty = unqual(ty);
|
| 454 |
|
|
return tree(mkop(INDIR,ty), ty, p, NULL);
|
| 455 |
|
|
}
|
| 456 |
|
|
Tree lvalue(Tree p) {
|
| 457 |
|
|
if (generic(p->op) != INDIR) {
|
| 458 |
|
|
error("lvalue required\n");
|
| 459 |
|
|
return value(p);
|
| 460 |
|
|
} else if (unqual(p->type) == voidtype)
|
| 461 |
|
|
warning("`%t' used as an lvalue\n", p->type);
|
| 462 |
|
|
return p->kids[0];
|
| 463 |
|
|
}
|
| 464 |
|
|
Tree retype(Tree p, Type ty) {
|
| 465 |
|
|
Tree q;
|
| 466 |
|
|
|
| 467 |
|
|
if (p->type == ty)
|
| 468 |
|
|
return p;
|
| 469 |
|
|
q = tree(p->op, ty, p->kids[0], p->kids[1]);
|
| 470 |
|
|
q->node = p->node;
|
| 471 |
|
|
q->u = p->u;
|
| 472 |
|
|
return q;
|
| 473 |
|
|
}
|
| 474 |
|
|
Tree rightkid(Tree p) {
|
| 475 |
|
|
while (p && p->op == RIGHT)
|
| 476 |
|
|
if (p->kids[1])
|
| 477 |
|
|
p = p->kids[1];
|
| 478 |
|
|
else if (p->kids[0])
|
| 479 |
|
|
p = p->kids[0];
|
| 480 |
|
|
else
|
| 481 |
|
|
assert(0);
|
| 482 |
|
|
assert(p);
|
| 483 |
|
|
return p;
|
| 484 |
|
|
}
|
| 485 |
|
|
int hascall(Tree p) {
|
| 486 |
|
|
if (p == 0)
|
| 487 |
|
|
return 0;
|
| 488 |
|
|
if (generic(p->op) == CALL || (IR->mulops_calls &&
|
| 489 |
|
|
(p->op == DIV+I || p->op == MOD+I || p->op == MUL+I
|
| 490 |
|
|
|| p->op == DIV+U || p->op == MOD+U || p->op == MUL+U)))
|
| 491 |
|
|
return 1;
|
| 492 |
|
|
return hascall(p->kids[0]) || hascall(p->kids[1]);
|
| 493 |
|
|
}
|
| 494 |
|
|
Type binary(Type xty, Type yty) {
|
| 495 |
|
|
#define xx(t) if (xty == t || yty == t) return t
|
| 496 |
|
|
xx(longdouble);
|
| 497 |
|
|
xx(doubletype);
|
| 498 |
|
|
xx(floattype);
|
| 499 |
|
|
xx(unsignedlonglong);
|
| 500 |
|
|
xx(longlong);
|
| 501 |
|
|
xx(unsignedlong);
|
| 502 |
|
|
if (xty == longtype && yty == unsignedtype
|
| 503 |
|
|
|| xty == unsignedtype && yty == longtype)
|
| 504 |
|
|
if (longtype->size > unsignedtype->size)
|
| 505 |
|
|
return longtype;
|
| 506 |
|
|
else
|
| 507 |
|
|
return unsignedlong;
|
| 508 |
|
|
xx(longtype);
|
| 509 |
|
|
xx(unsignedtype);
|
| 510 |
|
|
return inttype;
|
| 511 |
|
|
#undef xx
|
| 512 |
|
|
}
|
| 513 |
|
|
Tree pointer(Tree p) {
|
| 514 |
|
|
if (isarray(p->type))
|
| 515 |
|
|
/* assert(p->op != RIGHT || p->u.sym == NULL), */
|
| 516 |
|
|
p = retype(p, atop(p->type));
|
| 517 |
|
|
else if (isfunc(p->type))
|
| 518 |
|
|
p = retype(p, ptr(p->type));
|
| 519 |
|
|
return p;
|
| 520 |
|
|
}
|
| 521 |
|
|
Tree cond(Tree p) {
|
| 522 |
|
|
int op = generic(rightkid(p)->op);
|
| 523 |
|
|
|
| 524 |
|
|
if (op == AND || op == OR || op == NOT
|
| 525 |
|
|
|| op == EQ || op == NE
|
| 526 |
|
|
|| op == LE || op == LT || op == GE || op == GT)
|
| 527 |
|
|
return p;
|
| 528 |
|
|
p = pointer(p);
|
| 529 |
|
|
return (*optree[NEQ])(NE, p, consttree(0, inttype));
|
| 530 |
|
|
}
|
| 531 |
|
|
Tree cast(Tree p, Type type) {
|
| 532 |
|
|
Type src, dst;
|
| 533 |
|
|
|
| 534 |
|
|
p = value(p);
|
| 535 |
|
|
if (p->type == type)
|
| 536 |
|
|
return p;
|
| 537 |
|
|
dst = unqual(type);
|
| 538 |
|
|
src = unqual(p->type);
|
| 539 |
|
|
if (src->op != dst->op || src->size != dst->size) {
|
| 540 |
|
|
switch (src->op) {
|
| 541 |
|
|
case INT:
|
| 542 |
|
|
if (src->size < inttype->size)
|
| 543 |
|
|
p = simplify(CVI, inttype, p, NULL);
|
| 544 |
|
|
break;
|
| 545 |
|
|
case UNSIGNED:
|
| 546 |
|
|
if (src->size < inttype->size)
|
| 547 |
|
|
p = simplify(CVU, inttype, p, NULL);
|
| 548 |
|
|
else if (src->size < unsignedtype->size)
|
| 549 |
|
|
p = simplify(CVU, unsignedtype, p, NULL);
|
| 550 |
|
|
break;
|
| 551 |
|
|
case ENUM:
|
| 552 |
|
|
p = retype(p, inttype);
|
| 553 |
|
|
break;
|
| 554 |
|
|
case POINTER:
|
| 555 |
|
|
if (isint(dst) && src->size > dst->size)
|
| 556 |
|
|
warning("conversion from `%t' to `%t' is undefined\n", p->type, type);
|
| 557 |
|
|
p = simplify(CVP, super(src), p, NULL);
|
| 558 |
|
|
break;
|
| 559 |
|
|
case FLOAT:
|
| 560 |
|
|
break;
|
| 561 |
|
|
default: assert(0);
|
| 562 |
|
|
}
|
| 563 |
|
|
{
|
| 564 |
|
|
src = unqual(p->type);
|
| 565 |
|
|
dst = super(dst);
|
| 566 |
|
|
if (src->op != dst->op)
|
| 567 |
|
|
switch (src->op) {
|
| 568 |
|
|
case INT:
|
| 569 |
|
|
p = simplify(CVI, dst, p, NULL);
|
| 570 |
|
|
break;
|
| 571 |
|
|
case UNSIGNED:
|
| 572 |
|
|
if (isfloat(dst)) {
|
| 573 |
|
|
Type ssrc = signedint(src);
|
| 574 |
|
|
Tree two = cnsttree(longdouble, (long double)2.0);
|
| 575 |
|
|
p = (*optree['+'])(ADD,
|
| 576 |
|
|
(*optree['*'])(MUL,
|
| 577 |
|
|
two,
|
| 578 |
|
|
simplify(CVU, ssrc,
|
| 579 |
|
|
simplify(RSH, src,
|
| 580 |
|
|
p, consttree(1, inttype)), NULL)),
|
| 581 |
|
|
simplify(CVU, ssrc,
|
| 582 |
|
|
simplify(BAND, src,
|
| 583 |
|
|
p, consttree(1, unsignedtype)), NULL));
|
| 584 |
|
|
} else
|
| 585 |
|
|
p = simplify(CVU, dst, p, NULL);
|
| 586 |
|
|
break;
|
| 587 |
|
|
case FLOAT:
|
| 588 |
|
|
if (isunsigned(dst)) {
|
| 589 |
|
|
Type sdst = signedint(dst);
|
| 590 |
|
|
Tree c = cast(cnsttree(longdouble, (long double)sdst->u.sym->u.limits.max.i + 1), src);
|
| 591 |
|
|
p = condtree(
|
| 592 |
|
|
simplify(GE, src, p, c),
|
| 593 |
|
|
(*optree['+'])(ADD,
|
| 594 |
|
|
cast(cast(simplify(SUB, src, p, c), sdst), dst),
|
| 595 |
|
|
cast(cnsttree(unsignedlong, (unsigned long)sdst->u.sym->u.limits.max.i + 1), dst)),
|
| 596 |
|
|
simplify(CVF, sdst, p, NULL));
|
| 597 |
|
|
} else
|
| 598 |
|
|
p = simplify(CVF, dst, p, NULL);
|
| 599 |
|
|
break;
|
| 600 |
|
|
default: assert(0);
|
| 601 |
|
|
}
|
| 602 |
|
|
dst = unqual(type);
|
| 603 |
|
|
}
|
| 604 |
|
|
}
|
| 605 |
|
|
src = unqual(p->type);
|
| 606 |
|
|
switch (src->op) {
|
| 607 |
|
|
case INT:
|
| 608 |
|
|
if (src->op != dst->op || src->size != dst->size)
|
| 609 |
|
|
p = simplify(CVI, dst, p, NULL);
|
| 610 |
|
|
break;
|
| 611 |
|
|
case UNSIGNED:
|
| 612 |
|
|
if (src->op != dst->op || src->size != dst->size)
|
| 613 |
|
|
p = simplify(CVU, dst, p, NULL);
|
| 614 |
|
|
break;
|
| 615 |
|
|
case FLOAT:
|
| 616 |
|
|
if (src->op != dst->op || src->size != dst->size)
|
| 617 |
|
|
p = simplify(CVF, dst, p, NULL);
|
| 618 |
|
|
break;
|
| 619 |
|
|
case POINTER:
|
| 620 |
|
|
if (src->op != dst->op)
|
| 621 |
|
|
p = simplify(CVP, dst, p, NULL);
|
| 622 |
|
|
else {
|
| 623 |
|
|
if (isfunc(src->type) && !isfunc(dst->type)
|
| 624 |
|
|
|| !isfunc(src->type) && isfunc(dst->type))
|
| 625 |
|
|
warning("conversion from `%t' to `%t' is compiler dependent\n", p->type, type);
|
| 626 |
|
|
|
| 627 |
|
|
if (src->size != dst->size)
|
| 628 |
|
|
p = simplify(CVP, dst, p, NULL);
|
| 629 |
|
|
}
|
| 630 |
|
|
break;
|
| 631 |
|
|
default: assert(0);
|
| 632 |
|
|
}
|
| 633 |
|
|
return retype(p, type);
|
| 634 |
|
|
}
|
| 635 |
|
|
Tree field(Tree p, const char *name) {
|
| 636 |
|
|
Field q;
|
| 637 |
|
|
Type ty1, ty = p->type;
|
| 638 |
|
|
|
| 639 |
|
|
if (isptr(ty))
|
| 640 |
|
|
ty = deref(ty);
|
| 641 |
|
|
ty1 = ty;
|
| 642 |
|
|
ty = unqual(ty);
|
| 643 |
|
|
if ((q = fieldref(name, ty)) != NULL) {
|
| 644 |
|
|
if (isarray(q->type)) {
|
| 645 |
|
|
ty = q->type->type;
|
| 646 |
|
|
if (isconst(ty1) && !isconst(ty))
|
| 647 |
|
|
ty = qual(CONST, ty);
|
| 648 |
|
|
if (isvolatile(ty1) && !isvolatile(ty))
|
| 649 |
|
|
ty = qual(VOLATILE, ty);
|
| 650 |
|
|
ty = array(ty, q->type->size/ty->size, q->type->align);
|
| 651 |
|
|
} else {
|
| 652 |
|
|
ty = q->type;
|
| 653 |
|
|
if (isconst(ty1) && !isconst(ty))
|
| 654 |
|
|
ty = qual(CONST, ty);
|
| 655 |
|
|
if (isvolatile(ty1) && !isvolatile(ty))
|
| 656 |
|
|
ty = qual(VOLATILE, ty);
|
| 657 |
|
|
ty = ptr(ty);
|
| 658 |
|
|
}
|
| 659 |
|
|
if (YYcheck && !isaddrop(p->op) && q->offset > 0) /* omit */
|
| 660 |
|
|
p = nullcall(ty, YYcheck, p, consttree(q->offset, inttype)); /* omit */
|
| 661 |
|
|
else /* omit */
|
| 662 |
|
|
p = simplify(ADD+P, ty, p, consttree(q->offset, signedptr));
|
| 663 |
|
|
|
| 664 |
|
|
if (q->lsb) {
|
| 665 |
|
|
p = tree(FIELD, ty->type, rvalue(p), NULL);
|
| 666 |
|
|
p->u.field = q;
|
| 667 |
|
|
} else if (!isarray(q->type))
|
| 668 |
|
|
p = rvalue(p);
|
| 669 |
|
|
|
| 670 |
|
|
} else {
|
| 671 |
|
|
error("unknown field `%s' of `%t'\n", name, ty);
|
| 672 |
|
|
p = rvalue(retype(p, ptr(inttype)));
|
| 673 |
|
|
}
|
| 674 |
|
|
return p;
|
| 675 |
|
|
}
|
| 676 |
|
|
/* funcname - return name of function f or a function' */
|
| 677 |
|
|
char *funcname(Tree f) {
|
| 678 |
|
|
if (isaddrop(f->op))
|
| 679 |
|
|
return stringf("`%s'", f->u.sym->name);
|
| 680 |
|
|
return "a function";
|
| 681 |
|
|
}
|
| 682 |
|
|
static Tree nullcheck(Tree p) {
|
| 683 |
|
|
if (!needconst && YYnull && isptr(p->type)) {
|
| 684 |
|
|
p = value(p);
|
| 685 |
|
|
if (strcmp(YYnull->name, "_YYnull") == 0) {
|
| 686 |
|
|
Symbol t1 = temporary(REGISTER, voidptype);
|
| 687 |
|
|
p = tree(RIGHT, p->type,
|
| 688 |
|
|
tree(OR, voidtype,
|
| 689 |
|
|
cond(asgn(t1, cast(p, voidptype))),
|
| 690 |
|
|
vcall(YYnull, voidtype, (file && *file ? pointer(idtree(mkstr(file)->u.c.loc)) : cnsttree(voidptype, NULL)), cnsttree(inttype, (long)lineno) , NULL)),
|
| 691 |
|
|
idtree(t1));
|
| 692 |
|
|
}
|
| 693 |
|
|
|
| 694 |
|
|
else
|
| 695 |
|
|
p = nullcall(p->type, YYnull, p, cnsttree(inttype, 0L));
|
| 696 |
|
|
|
| 697 |
|
|
}
|
| 698 |
|
|
return p;
|
| 699 |
|
|
}
|
| 700 |
|
|
Tree nullcall(Type pty, Symbol f, Tree p, Tree e) {
|
| 701 |
|
|
Type ty;
|
| 702 |
|
|
|
| 703 |
|
|
if (isarray(pty))
|
| 704 |
|
|
return retype(nullcall(atop(pty), f, p, e), pty);
|
| 705 |
|
|
ty = unqual(unqual(p->type)->type);
|
| 706 |
|
|
return vcall(f, pty,
|
| 707 |
|
|
p, e,
|
| 708 |
|
|
cnsttree(inttype, (long)ty->size),
|
| 709 |
|
|
cnsttree(inttype, (long)ty->align),
|
| 710 |
|
|
(file && *file ? pointer(idtree(mkstr(file)->u.c.loc)) : cnsttree(voidptype, NULL)), cnsttree(inttype, (long)lineno) , NULL);
|
| 711 |
|
|
}
|
