?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branches 'dump-macros-v2', 'fix-predefined-size', 'fix-bool-context', 'fix...
[smatch.git] / evaluate.c
blob87e28621d0cf41304a68a15e840154f2af7e596f
1 /*
2 * sparse/evaluate.c
3 *
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 *
25 * Evaluate constant expressions.
26 */
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stddef.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <unistd.h>
34 #include <fcntl.h>
35 #include <limits.h>
36
37 #include "lib.h"
38 #include "allocate.h"
39 #include "parse.h"
40 #include "token.h"
41 #include "symbol.h"
42 #include "target.h"
43 #include "expression.h"
44
45 struct symbol *current_fn;
46
47 static struct symbol *degenerate(struct expression *expr);
48 static struct symbol *evaluate_symbol(struct symbol *sym);
49
50 static struct symbol *evaluate_symbol_expression(struct expression *expr)
51 {
52 struct expression *addr;
53 struct symbol *sym = expr->symbol;
54 struct symbol *base_type;
55
56 if (!sym) {
57 expression_error(expr, "undefined identifier '%s'", show_ident(expr->symbol_name));
58 return NULL;
59 }
60
61 examine_symbol_type(sym);
62
63 base_type = get_base_type(sym);
64 if (!base_type) {
65 expression_error(expr, "identifier '%s' has no type", show_ident(expr->symbol_name));
66 return NULL;
67 }
68
69 addr = alloc_expression(expr->pos, EXPR_SYMBOL);
70 addr->symbol = sym;
71 addr->symbol_name = expr->symbol_name;
72 addr->ctype = &lazy_ptr_ctype; /* Lazy evaluation: we need to do a proper job if somebody does &sym */
73 expr->type = EXPR_PREOP;
74 expr->op = '*';
75 expr->unop = addr;
76
77 /* The type of a symbol is the symbol itself! */
78 expr->ctype = sym;
79 return sym;
80 }
81
82 static struct symbol *evaluate_string(struct expression *expr)
83 {
84 struct symbol *sym = alloc_symbol(expr->pos, SYM_NODE);
85 struct symbol *array = alloc_symbol(expr->pos, SYM_ARRAY);
86 struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
87 struct expression *initstr = alloc_expression(expr->pos, EXPR_STRING);
88 unsigned int length = expr->string->length;
89
90 sym->array_size = alloc_const_expression(expr->pos, length);
91 sym->bit_size = bytes_to_bits(length);
92 sym->ctype.alignment = 1;
93 sym->string = 1;
94 sym->ctype.modifiers = MOD_STATIC;
95 sym->ctype.base_type = array;
96 sym->initializer = initstr;
97
98 initstr->ctype = sym;
99 initstr->string = expr->string;
100
101 array->array_size = sym->array_size;
102 array->bit_size = bytes_to_bits(length);
103 array->ctype.alignment = 1;
104 array->ctype.modifiers = MOD_STATIC;
105 array->ctype.base_type = &char_ctype;
106
107 addr->symbol = sym;
108 addr->ctype = &lazy_ptr_ctype;
109
110 expr->type = EXPR_PREOP;
111 expr->op = '*';
112 expr->unop = addr;
113 expr->ctype = sym;
114 return sym;
115 }
116
117 /* type has come from classify_type and is an integer type */
118 static inline struct symbol *integer_promotion(struct symbol *type)
119 {
120 unsigned long mod = type->ctype.modifiers;
121 int width = type->bit_size;
122
123 /*
124 * Bitfields always promote to the base type,
125 * even if the bitfield might be bigger than
126 * an "int".
127 */
128 if (type->type == SYM_BITFIELD) {
129 type = type->ctype.base_type;
130 }
131 mod = type->ctype.modifiers;
132 if (width < bits_in_int)
133 return &int_ctype;
134
135 /* If char/short has as many bits as int, it still gets "promoted" */
136 if (mod & (MOD_CHAR | MOD_SHORT)) {
137 if (mod & MOD_UNSIGNED)
138 return &uint_ctype;
139 return &int_ctype;
140 }
141 return type;
142 }
143
144 /*
145 * integer part of usual arithmetic conversions:
146 * integer promotions are applied
147 * if left and right are identical, we are done
148 * if signedness is the same, convert one with lower rank
149 * unless unsigned argument has rank lower than signed one, convert the
150 * signed one.
151 * if signed argument is bigger than unsigned one, convert the unsigned.
152 * otherwise, convert signed.
153 *
154 * Leaving aside the integer promotions, that is equivalent to
155 * if identical, don't convert
156 * if left is bigger than right, convert right
157 * if right is bigger than left, convert right
158 * otherwise, if signedness is the same, convert one with lower rank
159 * otherwise convert the signed one.
160 */
161 static struct symbol *bigger_int_type(struct symbol *left, struct symbol *right)
162 {
163 unsigned long lmod, rmod;
164
165 left = integer_promotion(left);
166 right = integer_promotion(right);
167
168 if (left == right)
169 goto left;
170
171 if (left->bit_size > right->bit_size)
172 goto left;
173
174 if (right->bit_size > left->bit_size)
175 goto right;
176
177 lmod = left->ctype.modifiers;
178 rmod = right->ctype.modifiers;
179 if ((lmod ^ rmod) & MOD_UNSIGNED) {
180 if (lmod & MOD_UNSIGNED)
181 goto left;
182 } else if ((lmod & ~rmod) & (MOD_LONG_ALL))
183 goto left;
184 right:
185 left = right;
186 left:
187 return left;
188 }
189
190 static int same_cast_type(struct symbol *orig, struct symbol *new)
191 {
192 return orig->bit_size == new->bit_size &&
193 orig->bit_offset == new->bit_offset;
194 }
195
196 static struct symbol *base_type(struct symbol *node, unsigned long *modp, unsigned long *asp)
197 {
198 unsigned long mod, as;
199
200 mod = 0; as = 0;
201 while (node) {
202 mod |= node->ctype.modifiers;
203 as |= node->ctype.as;
204 if (node->type == SYM_NODE) {
205 node = node->ctype.base_type;
206 continue;
207 }
208 break;
209 }
210 *modp = mod & ~MOD_IGNORE;
211 *asp = as;
212 return node;
213 }
214
215 static int is_same_type(struct expression *expr, struct symbol *new)
216 {
217 struct symbol *old = expr->ctype;
218 unsigned long oldmod, newmod, oldas, newas;
219
220 old = base_type(old, &oldmod, &oldas);
221 new = base_type(new, &newmod, &newas);
222
223 /* Same base type, same address space? */
224 if (old == new && oldas == newas) {
225 unsigned long difmod;
226
227 /* Check the modifier bits. */
228 difmod = (oldmod ^ newmod) & ~MOD_NOCAST;
229
230 /* Exact same type? */
231 if (!difmod)
232 return 1;
233
234 /*
235 * Not the same type, but differs only in "const".
236 * Don't warn about MOD_NOCAST.
237 */
238 if (difmod == MOD_CONST)
239 return 0;
240 }
241 if ((oldmod | newmod) & MOD_NOCAST) {
242 const char *tofrom = "to/from";
243 if (!(newmod & MOD_NOCAST))
244 tofrom = "from";
245 if (!(oldmod & MOD_NOCAST))
246 tofrom = "to";
247 warning(expr->pos, "implicit cast %s nocast type", tofrom);
248 }
249 return 0;
250 }
251
252 static void
253 warn_for_different_enum_types (struct position pos,
254 struct symbol *typea,
255 struct symbol *typeb)
256 {
257 if (!Wenum_mismatch)
258 return;
259 if (typea->type == SYM_NODE)
260 typea = typea->ctype.base_type;
261 if (typeb->type == SYM_NODE)
262 typeb = typeb->ctype.base_type;
263
264 if (typea == typeb)
265 return;
266
267 if (typea->type == SYM_ENUM && typeb->type == SYM_ENUM) {
268 warning(pos, "mixing different enum types");
269 info(pos, " %s versus", show_typename(typea));
270 info(pos, " %s", show_typename(typeb));
271 }
272 }
273
274 static struct symbol *cast_to_bool(struct expression *expr);
275
276 /*
277 * This gets called for implicit casts in assignments and
278 * integer promotion. We often want to try to move the
279 * cast down, because the ops involved may have been
280 * implicitly cast up, and we can get rid of the casts
281 * early.
282 */
283 static struct expression * cast_to(struct expression *old, struct symbol *type)
284 {
285 struct expression *expr;
286
287 warn_for_different_enum_types (old->pos, old->ctype, type);
288
289 if (old->ctype != &null_ctype && is_same_type(old, type))
290 return old;
291
292 /*
293 * See if we can simplify the op. Move the cast down.
294 */
295 switch (old->type) {
296 case EXPR_PREOP:
297 if (old->ctype->bit_size < type->bit_size)
298 break;
299 if (old->op == '~') {
300 old->ctype = type;
301 old->unop = cast_to(old->unop, type);
302 return old;
303 }
304 break;
305
306 case EXPR_IMPLIED_CAST:
307 warn_for_different_enum_types(old->pos, old->ctype, type);
308
309 if (old->ctype->bit_size >= type->bit_size) {
310 struct expression *orig = old->cast_expression;
311 if (same_cast_type(orig->ctype, type))
312 return orig;
313 if (old->ctype->bit_offset == type->bit_offset) {
314 old->ctype = type;
315 old->cast_type = type;
316 return old;
317 }
318 }
319 break;
320
321 default:
322 /* nothing */;
323 }
324
325 expr = alloc_expression(old->pos, EXPR_IMPLIED_CAST);
326 expr->flags = old->flags;
327 expr->ctype = type;
328 expr->cast_type = type;
329 expr->cast_expression = old;
330
331 if (is_bool_type(type))
332 cast_to_bool(expr);
333
334 return expr;
335 }
336
337 enum {
338 TYPE_NUM = 1,
339 TYPE_BITFIELD = 2,
340 TYPE_RESTRICT = 4,
341 TYPE_FLOAT = 8,
342 TYPE_PTR = 16,
343 TYPE_COMPOUND = 32,
344 TYPE_FOULED = 64,
345 TYPE_FN = 128,
346 };
347
348 static inline int classify_type(struct symbol *type, struct symbol **base)
349 {
350 static int type_class[SYM_BAD + 1] = {
351 [SYM_PTR] = TYPE_PTR,
352 [SYM_FN] = TYPE_PTR | TYPE_FN,
353 [SYM_ARRAY] = TYPE_PTR | TYPE_COMPOUND,
354 [SYM_STRUCT] = TYPE_COMPOUND,
355 [SYM_UNION] = TYPE_COMPOUND,
356 [SYM_BITFIELD] = TYPE_NUM | TYPE_BITFIELD,
357 [SYM_RESTRICT] = TYPE_NUM | TYPE_RESTRICT,
358 [SYM_FOULED] = TYPE_NUM | TYPE_RESTRICT | TYPE_FOULED,
359 };
360 if (type->type == SYM_NODE)
361 type = type->ctype.base_type;
362 if (type->type == SYM_TYPEOF) {
363 type = evaluate_expression(type->initializer);
364 if (!type)
365 type = &bad_ctype;
366 else if (type->type == SYM_NODE)
367 type = type->ctype.base_type;
368 }
369 if (type->type == SYM_ENUM)
370 type = type->ctype.base_type;
371 *base = type;
372 if (type->type == SYM_BASETYPE) {
373 if (type->ctype.base_type == &int_type)
374 return TYPE_NUM;
375 if (type->ctype.base_type == &fp_type)
376 return TYPE_NUM | TYPE_FLOAT;
377 }
378 return type_class[type->type];
379 }
380
381 #define is_int(class) ((class & (TYPE_NUM | TYPE_FLOAT)) == TYPE_NUM)
382
383 static inline int is_string_type(struct symbol *type)
384 {
385 if (type->type == SYM_NODE)
386 type = type->ctype.base_type;
387 return type->type == SYM_ARRAY && is_byte_type(type->ctype.base_type);
388 }
389
390 static struct symbol *bad_expr_type(struct expression *expr)
391 {
392 sparse_error(expr->pos, "incompatible types for operation (%s)", show_special(expr->op));
393 switch (expr->type) {
394 case EXPR_BINOP:
395 case EXPR_COMPARE:
396 info(expr->pos, " left side has type %s", show_typename(expr->left->ctype));
397 info(expr->pos, " right side has type %s", show_typename(expr->right->ctype));
398 break;
399 case EXPR_PREOP:
400 case EXPR_POSTOP:
401 info(expr->pos, " argument has type %s", show_typename(expr->unop->ctype));
402 break;
403 default:
404 break;
405 }
406
407 expr->flags = 0;
408 return expr->ctype = &bad_ctype;
409 }
410
411 static int restricted_value(struct expression *v, struct symbol *type)
412 {
413 if (v->type != EXPR_VALUE)
414 return 1;
415 if (v->value != 0)
416 return 1;
417 return 0;
418 }
419
420 static int restricted_binop(int op, struct symbol *type)
421 {
422 switch (op) {
423 case '&':
424 case '=':
425 case SPECIAL_AND_ASSIGN:
426 case SPECIAL_OR_ASSIGN:
427 case SPECIAL_XOR_ASSIGN:
428 return 1; /* unfoul */
429 case '|':
430 case '^':
431 case '?':
432 return 2; /* keep fouled */
433 case SPECIAL_EQUAL:
434 case SPECIAL_NOTEQUAL:
435 return 3; /* warn if fouled */
436 default:
437 return 0; /* warn */
438 }
439 }
440
441 static int restricted_unop(int op, struct symbol **type)
442 {
443 if (op == '~') {
444 if ((*type)->bit_size < bits_in_int)
445 *type = befoul(*type);
446 return 0;
447 } if (op == '+')
448 return 0;
449 return 1;
450 }
451
452 /* type should be SYM_FOULED */
453 static inline struct symbol *unfoul(struct symbol *type)
454 {
455 return type->ctype.base_type;
456 }
457
458 static struct symbol *restricted_binop_type(int op,
459 struct expression *left,
460 struct expression *right,
461 int lclass, int rclass,
462 struct symbol *ltype,
463 struct symbol *rtype)
464 {
465 struct symbol *ctype = NULL;
466 if (lclass & TYPE_RESTRICT) {
467 if (rclass & TYPE_RESTRICT) {
468 if (ltype == rtype) {
469 ctype = ltype;
470 } else if (lclass & TYPE_FOULED) {
471 if (unfoul(ltype) == rtype)
472 ctype = ltype;
473 } else if (rclass & TYPE_FOULED) {
474 if (unfoul(rtype) == ltype)
475 ctype = rtype;
476 }
477 } else {
478 if (!restricted_value(right, ltype))
479 ctype = ltype;
480 }
481 } else if (!restricted_value(left, rtype))
482 ctype = rtype;
483
484 if (ctype) {
485 switch (restricted_binop(op, ctype)) {
486 case 1:
487 if ((lclass ^ rclass) & TYPE_FOULED)
488 ctype = unfoul(ctype);
489 break;
490 case 3:
491 if (!(lclass & rclass & TYPE_FOULED))
492 break;
493 case 0:
494 ctype = NULL;
495 default:
496 break;
497 }
498 }
499
500 return ctype;
501 }
502
503 static inline void unrestrict(struct expression *expr,
504 int class, struct symbol **ctype)
505 {
506 if (class & TYPE_RESTRICT) {
507 if (class & TYPE_FOULED)
508 *ctype = unfoul(*ctype);
509 warning(expr->pos, "%s degrades to integer",
510 show_typename(*ctype));
511 *ctype = (*ctype)->ctype.base_type; /* get to arithmetic type */
512 }
513 }
514
515 static struct symbol *usual_conversions(int op,
516 struct expression *left,
517 struct expression *right,
518 int lclass, int rclass,
519 struct symbol *ltype,
520 struct symbol *rtype)
521 {
522 struct symbol *ctype;
523
524 warn_for_different_enum_types(right->pos, left->ctype, right->ctype);
525
526 if ((lclass | rclass) & TYPE_RESTRICT)
527 goto Restr;
528
529 Normal:
530 if (!(lclass & TYPE_FLOAT)) {
531 if (!(rclass & TYPE_FLOAT))
532 return bigger_int_type(ltype, rtype);
533 else
534 return rtype;
535 } else if (rclass & TYPE_FLOAT) {
536 unsigned long lmod = ltype->ctype.modifiers;
537 unsigned long rmod = rtype->ctype.modifiers;
538 if (rmod & ~lmod & (MOD_LONG_ALL))
539 return rtype;
540 else
541 return ltype;
542 } else
543 return ltype;
544
545 Restr:
546 ctype = restricted_binop_type(op, left, right,
547 lclass, rclass, ltype, rtype);
548 if (ctype)
549 return ctype;
550
551 unrestrict(left, lclass, &ltype);
552 unrestrict(right, rclass, &rtype);
553
554 goto Normal;
555 }
556
557 static inline int lvalue_expression(struct expression *expr)
558 {
559 return expr->type == EXPR_PREOP && expr->op == '*';
560 }
561
562 static struct symbol *evaluate_ptr_add(struct expression *expr, struct symbol *itype)
563 {
564 struct expression *index = expr->right;
565 struct symbol *ctype, *base;
566 int multiply;
567
568 classify_type(degenerate(expr->left), &ctype);
569 base = examine_pointer_target(ctype);
570
571 if (!base) {
572 expression_error(expr, "missing type information");
573 return NULL;
574 }
575 if (is_function(base)) {
576 expression_error(expr, "arithmetics on pointers to functions");
577 return NULL;
578 }
579
580 /* Get the size of whatever the pointer points to */
581 multiply = is_void_type(base) ? 1 : bits_to_bytes(base->bit_size);
582
583 if (ctype == &null_ctype)
584 ctype = &ptr_ctype;
585 expr->ctype = ctype;
586
587 if (multiply == 1 && itype->bit_size >= bits_in_pointer)
588 return ctype;
589
590 if (index->type == EXPR_VALUE) {
591 struct expression *val = alloc_expression(expr->pos, EXPR_VALUE);
592 unsigned long long v = index->value, mask;
593 mask = 1ULL << (itype->bit_size - 1);
594 if (v & mask)
595 v |= -mask;
596 else
597 v &= mask - 1;
598 v *= multiply;
599 mask = 1ULL << (bits_in_pointer - 1);
600 v &= mask | (mask - 1);
601 val->value = v;
602 val->ctype = ssize_t_ctype;
603 expr->right = val;
604 return ctype;
605 }
606
607 if (itype->bit_size < bits_in_pointer)
608 index = cast_to(index, ssize_t_ctype);
609
610 if (multiply > 1) {
611 struct expression *val = alloc_expression(expr->pos, EXPR_VALUE);
612 struct expression *mul = alloc_expression(expr->pos, EXPR_BINOP);
613
614 val->ctype = ssize_t_ctype;
615 val->value = multiply;
616
617 mul->op = '*';
618 mul->ctype = ssize_t_ctype;
619 mul->left = index;
620 mul->right = val;
621 index = mul;
622 }
623
624 expr->right = index;
625 return ctype;
626 }
627
628 static void examine_fn_arguments(struct symbol *fn);
629
630 #define MOD_IGN (MOD_VOLATILE | MOD_CONST | MOD_PURE)
631
632 const char *type_difference(struct ctype *c1, struct ctype *c2,
633 unsigned long mod1, unsigned long mod2)
634 {
635 unsigned long as1 = c1->as, as2 = c2->as;
636 struct symbol *t1 = c1->base_type;
637 struct symbol *t2 = c2->base_type;
638 int move1 = 1, move2 = 1;
639 mod1 |= c1->modifiers;
640 mod2 |= c2->modifiers;
641 for (;;) {
642 unsigned long diff;
643 int type;
644 struct symbol *base1 = t1->ctype.base_type;
645 struct symbol *base2 = t2->ctype.base_type;
646
647 /*
648 * FIXME! Collect alignment and context too here!
649 */
650 if (move1) {
651 if (t1 && t1->type != SYM_PTR) {
652 mod1 |= t1->ctype.modifiers;
653 as1 |= t1->ctype.as;
654 }
655 move1 = 0;
656 }
657
658 if (move2) {
659 if (t2 && t2->type != SYM_PTR) {
660 mod2 |= t2->ctype.modifiers;
661 as2 |= t2->ctype.as;
662 }
663 move2 = 0;
664 }
665
666 if (t1 == t2)
667 break;
668 if (!t1 || !t2)
669 return "different types";
670
671 if (t1->type == SYM_NODE || t1->type == SYM_ENUM) {
672 t1 = base1;
673 move1 = 1;
674 if (!t1)
675 return "bad types";
676 continue;
677 }
678
679 if (t2->type == SYM_NODE || t2->type == SYM_ENUM) {
680 t2 = base2;
681 move2 = 1;
682 if (!t2)
683 return "bad types";
684 continue;
685 }
686
687 move1 = move2 = 1;
688 type = t1->type;
689 if (type != t2->type)
690 return "different base types";
691
692 switch (type) {
693 default:
694 sparse_error(t1->pos,
695 "internal error: bad type in derived(%d)",
696 type);
697 return "bad types";
698 case SYM_RESTRICT:
699 return "different base types";
700 case SYM_UNION:
701 case SYM_STRUCT:
702 /* allow definition of incomplete structs and unions */
703 if (t1->ident == t2->ident)
704 return NULL;
705 return "different base types";
706 case SYM_ARRAY:
707 /* XXX: we ought to compare sizes */
708 break;
709 case SYM_PTR:
710 if (as1 != as2)
711 return "different address spaces";
712 /* MOD_SPECIFIER is due to idiocy in parse.c */
713 if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SPECIFIER)
714 return "different modifiers";
715 /* we could be lazier here */
716 base1 = examine_pointer_target(t1);
717 base2 = examine_pointer_target(t2);
718 mod1 = t1->ctype.modifiers;
719 as1 = t1->ctype.as;
720 mod2 = t2->ctype.modifiers;
721 as2 = t2->ctype.as;
722 break;
723 case SYM_FN: {
724 struct symbol *arg1, *arg2;
725 int i;
726
727 if (as1 != as2)
728 return "different address spaces";
729 if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SIGNEDNESS)
730 return "different modifiers";
731 mod1 = t1->ctype.modifiers;
732 as1 = t1->ctype.as;
733 mod2 = t2->ctype.modifiers;
734 as2 = t2->ctype.as;
735
736 if (t1->variadic != t2->variadic)
737 return "incompatible variadic arguments";
738 examine_fn_arguments(t1);
739 examine_fn_arguments(t2);
740 PREPARE_PTR_LIST(t1->arguments, arg1);
741 PREPARE_PTR_LIST(t2->arguments, arg2);
742 i = 1;
743 for (;;) {
744 const char *diffstr;
745 if (!arg1 && !arg2)
746 break;
747 if (!arg1 || !arg2)
748 return "different argument counts";
749 diffstr = type_difference(&arg1->ctype,
750 &arg2->ctype,
751 MOD_IGN, MOD_IGN);
752 if (diffstr) {
753 static char argdiff[80];
754 sprintf(argdiff, "incompatible argument %d (%s)", i, diffstr);
755 return argdiff;
756 }
757 NEXT_PTR_LIST(arg1);
758 NEXT_PTR_LIST(arg2);
759 i++;
760 }
761 FINISH_PTR_LIST(arg2);
762 FINISH_PTR_LIST(arg1);
763 break;
764 }
765 case SYM_BASETYPE:
766 if (as1 != as2)
767 return "different address spaces";
768 if (base1 != base2)
769 return "different base types";
770 diff = (mod1 ^ mod2) & ~MOD_IGNORE;
771 if (!diff)
772 return NULL;
773 if (diff & MOD_SIZE)
774 return "different type sizes";
775 else if (diff & ~MOD_SIGNEDNESS)
776 return "different modifiers";
777 else
778 return "different signedness";
779 }
780 t1 = base1;
781 t2 = base2;
782 }
783 if (as1 != as2)
784 return "different address spaces";
785 if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SIGNEDNESS)
786 return "different modifiers";
787 return NULL;
788 }
789
790 static void bad_null(struct expression *expr)
791 {
792 if (Wnon_pointer_null)
793 warning(expr->pos, "Using plain integer as NULL pointer");
794 }
795
796 static unsigned long target_qualifiers(struct symbol *type)
797 {
798 unsigned long mod = type->ctype.modifiers & MOD_IGN;
799 if (type->ctype.base_type && type->ctype.base_type->type == SYM_ARRAY)
800 mod = 0;
801 return mod;
802 }
803
804 static struct symbol *evaluate_ptr_sub(struct expression *expr)
805 {
806 const char *typediff;
807 struct symbol *ltype, *rtype;
808 struct expression *l = expr->left;
809 struct expression *r = expr->right;
810 struct symbol *lbase;
811
812 classify_type(degenerate(l), &ltype);
813 classify_type(degenerate(r), &rtype);
814
815 lbase = examine_pointer_target(ltype);
816 examine_pointer_target(rtype);
817 typediff = type_difference(&ltype->ctype, &rtype->ctype,
818 target_qualifiers(rtype),
819 target_qualifiers(ltype));
820 if (typediff)
821 expression_error(expr, "subtraction of different types can't work (%s)", typediff);
822
823 if (is_function(lbase)) {
824 expression_error(expr, "subtraction of functions? Share your drugs");
825 return NULL;
826 }
827
828 expr->ctype = ssize_t_ctype;
829 if (lbase->bit_size > bits_in_char) {
830 struct expression *sub = alloc_expression(expr->pos, EXPR_BINOP);
831 struct expression *div = expr;
832 struct expression *val = alloc_expression(expr->pos, EXPR_VALUE);
833 unsigned long value = bits_to_bytes(lbase->bit_size);
834
835 val->ctype = size_t_ctype;
836 val->value = value;
837
838 if (value & (value-1)) {
839 if (Wptr_subtraction_blows)
840 warning(expr->pos, "potentially expensive pointer subtraction");
841 }
842
843 sub->op = '-';
844 sub->ctype = ssize_t_ctype;
845 sub->left = l;
846 sub->right = r;
847
848 div->op = '/';
849 div->left = sub;
850 div->right = val;
851 }
852
853 return ssize_t_ctype;
854 }
855
856 #define is_safe_type(type) ((type)->ctype.modifiers & MOD_SAFE)
857
858 static struct symbol *evaluate_conditional(struct expression *expr, int iterator)
859 {
860 struct symbol *ctype;
861
862 if (!expr)
863 return NULL;
864
865 if (!iterator && expr->type == EXPR_ASSIGNMENT && expr->op == '=')
866 warning(expr->pos, "assignment expression in conditional");
867
868 ctype = evaluate_expression(expr);
869 if (ctype) {
870 if (is_safe_type(ctype))
871 warning(expr->pos, "testing a 'safe expression'");
872 if (is_func_type(ctype)) {
873 if (Waddress)
874 warning(expr->pos, "the address of %s will always evaluate as true", "a function");
875 } else if (is_array_type(ctype)) {
876 if (Waddress)
877 warning(expr->pos, "the address of %s will always evaluate as true", "an array");
878 } else if (!is_scalar_type(ctype)) {
879 sparse_error(expr->pos, "incorrect type in conditional");
880 info(expr->pos, " got %s", show_typename(ctype));
881 ctype = NULL;
882 }
883 }
884 ctype = degenerate(expr);
885
886 return ctype;
887 }
888
889 static struct symbol *evaluate_logical(struct expression *expr)
890 {
891 if (!evaluate_conditional(expr->left, 0))
892 return NULL;
893 if (!evaluate_conditional(expr->right, 0))
894 return NULL;
895
896 /* the result is int [6.5.13(3), 6.5.14(3)] */
897 expr->ctype = &int_ctype;
898 if (expr->flags) {
899 if (!(expr->left->flags & expr->right->flags & Int_const_expr))
900 expr->flags = 0;
901 }
902 return &int_ctype;
903 }
904
905 static struct symbol *evaluate_binop(struct expression *expr)
906 {
907 struct symbol *ltype, *rtype, *ctype;
908 int lclass = classify_type(expr->left->ctype, &ltype);
909 int rclass = classify_type(expr->right->ctype, &rtype);
910 int op = expr->op;
911
912 if (expr->flags) {
913 if (!(expr->left->flags & expr->right->flags & Int_const_expr))
914 expr->flags = 0;
915 }
916
917 /* number op number */
918 if (lclass & rclass & TYPE_NUM) {
919 if ((lclass | rclass) & TYPE_FLOAT) {
920 switch (op) {
921 case '+': case '-': case '*': case '/':
922 break;
923 default:
924 return bad_expr_type(expr);
925 }
926 }
927
928 if (op == SPECIAL_LEFTSHIFT || op == SPECIAL_RIGHTSHIFT) {
929 // shifts do integer promotions, but that's it.
930 unrestrict(expr->left, lclass, &ltype);
931 unrestrict(expr->right, rclass, &rtype);
932 ctype = ltype = integer_promotion(ltype);
933 rtype = integer_promotion(rtype);
934 } else {
935 // The rest do usual conversions
936 const unsigned left_not = expr->left->type == EXPR_PREOP
937 && expr->left->op == '!';
938 const unsigned right_not = expr->right->type == EXPR_PREOP
939 && expr->right->op == '!';
940 if ((op == '&' || op == '|') && (left_not || right_not))
941 warning(expr->pos, "dubious: %sx %c %sy",
942 left_not ? "!" : "",
943 op,
944 right_not ? "!" : "");
945
946 ltype = usual_conversions(op, expr->left, expr->right,
947 lclass, rclass, ltype, rtype);
948 ctype = rtype = ltype;
949 }
950
951 expr->left = cast_to(expr->left, ltype);
952 expr->right = cast_to(expr->right, rtype);
953 expr->ctype = ctype;
954 return ctype;
955 }
956
957 /* pointer (+|-) integer */
958 if (lclass & TYPE_PTR && is_int(rclass) && (op == '+' || op == '-')) {
959 unrestrict(expr->right, rclass, &rtype);
960 return evaluate_ptr_add(expr, rtype);
961 }
962
963 /* integer + pointer */
964 if (rclass & TYPE_PTR && is_int(lclass) && op == '+') {
965 struct expression *index = expr->left;
966 unrestrict(index, lclass, &ltype);
967 expr->left = expr->right;
968 expr->right = index;
969 return evaluate_ptr_add(expr, ltype);
970 }
971
972 /* pointer - pointer */
973 if (lclass & rclass & TYPE_PTR && expr->op == '-')
974 return evaluate_ptr_sub(expr);
975
976 return bad_expr_type(expr);
977 }
978
979 static struct symbol *evaluate_comma(struct expression *expr)
980 {
981 expr->ctype = degenerate(expr->right);
982 if (expr->ctype == &null_ctype)
983 expr->ctype = &ptr_ctype;
984 expr->flags &= expr->left->flags & expr->right->flags;
985 return expr->ctype;
986 }
987
988 static int modify_for_unsigned(int op)
989 {
990 if (op == '<')
991 op = SPECIAL_UNSIGNED_LT;
992 else if (op == '>')
993 op = SPECIAL_UNSIGNED_GT;
994 else if (op == SPECIAL_LTE)
995 op = SPECIAL_UNSIGNED_LTE;
996 else if (op == SPECIAL_GTE)
997 op = SPECIAL_UNSIGNED_GTE;
998 return op;
999 }
1000
1001 static inline int is_null_pointer_constant(struct expression *e)
1002 {
1003 if (e->ctype == &null_ctype)
1004 return 1;
1005 if (!(e->flags & Int_const_expr))
1006 return 0;
1007 return is_zero_constant(e) ? 2 : 0;
1008 }
1009
1010 static struct symbol *evaluate_compare(struct expression *expr)
1011 {
1012 struct expression *left = expr->left, *right = expr->right;
1013 struct symbol *ltype, *rtype, *lbase, *rbase;
1014 int lclass = classify_type(degenerate(left), &ltype);
1015 int rclass = classify_type(degenerate(right), &rtype);
1016 struct symbol *ctype;
1017 const char *typediff;
1018
1019 if (expr->flags) {
1020 if (!(expr->left->flags & expr->right->flags & Int_const_expr))
1021 expr->flags = 0;
1022 }
1023
1024 /* Type types? */
1025 if (is_type_type(ltype) && is_type_type(rtype))
1026 goto OK;
1027
1028 if (is_safe_type(left->ctype) || is_safe_type(right->ctype))
1029 warning(expr->pos, "testing a 'safe expression'");
1030
1031 /* number on number */
1032 if (lclass & rclass & TYPE_NUM) {
1033 ctype = usual_conversions(expr->op, expr->left, expr->right,
1034 lclass, rclass, ltype, rtype);
1035 expr->left = cast_to(expr->left, ctype);
1036 expr->right = cast_to(expr->right, ctype);
1037 if (ctype->ctype.modifiers & MOD_UNSIGNED)
1038 expr->op = modify_for_unsigned(expr->op);
1039 goto OK;
1040 }
1041
1042 /* at least one must be a pointer */
1043 if (!((lclass | rclass) & TYPE_PTR))
1044 return bad_expr_type(expr);
1045
1046 /* equality comparisons can be with null pointer constants */
1047 if (expr->op == SPECIAL_EQUAL || expr->op == SPECIAL_NOTEQUAL) {
1048 int is_null1 = is_null_pointer_constant(left);
1049 int is_null2 = is_null_pointer_constant(right);
1050 if (is_null1 == 2)
1051 bad_null(left);
1052 if (is_null2 == 2)
1053 bad_null(right);
1054 if (is_null1 && is_null2) {
1055 int positive = expr->op == SPECIAL_EQUAL;
1056 expr->type = EXPR_VALUE;
1057 expr->value = positive;
1058 goto OK;
1059 }
1060 if (is_null1 && (rclass & TYPE_PTR)) {
1061 left = cast_to(left, rtype);
1062 goto OK;
1063 }
1064 if (is_null2 && (lclass & TYPE_PTR)) {
1065 right = cast_to(right, ltype);
1066 goto OK;
1067 }
1068 }
1069 /* both should be pointers */
1070 if (!(lclass & rclass & TYPE_PTR))
1071 return bad_expr_type(expr);
1072 expr->op = modify_for_unsigned(expr->op);
1073
1074 lbase = examine_pointer_target(ltype);
1075 rbase = examine_pointer_target(rtype);
1076
1077 /* they also have special treatment for pointers to void */
1078 if (expr->op == SPECIAL_EQUAL || expr->op == SPECIAL_NOTEQUAL) {
1079 if (ltype->ctype.as == rtype->ctype.as) {
1080 if (lbase == &void_ctype) {
1081 right = cast_to(right, ltype);
1082 goto OK;
1083 }
1084 if (rbase == &void_ctype) {
1085 left = cast_to(left, rtype);
1086 goto OK;
1087 }
1088 }
1089 }
1090
1091 typediff = type_difference(&ltype->ctype, &rtype->ctype,
1092 target_qualifiers(rtype),
1093 target_qualifiers(ltype));
1094 if (!typediff)
1095 goto OK;
1096
1097 expression_error(expr, "incompatible types in comparison expression (%s)", typediff);
1098 return NULL;
1099
1100 OK:
1101 /* the result is int [6.5.8(6), 6.5.9(3)]*/
1102 expr->ctype = &int_ctype;
1103 return &int_ctype;
1104 }
1105
1106 /*
1107 * NOTE! The degenerate case of "x ? : y", where we don't
1108 * have a true case, this will possibly promote "x" to the
1109 * same type as "y", and thus _change_ the conditional
1110 * test in the expression. But since promotion is "safe"
1111 * for testing, that's OK.
1112 */
1113 static struct symbol *evaluate_conditional_expression(struct expression *expr)
1114 {
1115 struct expression **true;
1116 struct symbol *ctype, *ltype, *rtype, *lbase, *rbase;
1117 int lclass, rclass;
1118 const char * typediff;
1119 int qual;
1120
1121 if (!evaluate_conditional(expr->conditional, 0))
1122 return NULL;
1123 if (!evaluate_expression(expr->cond_false))
1124 return NULL;
1125
1126 ctype = degenerate(expr->conditional);
1127 rtype = degenerate(expr->cond_false);
1128
1129 true = &expr->conditional;
1130 ltype = ctype;
1131 if (expr->cond_true) {
1132 if (!evaluate_expression(expr->cond_true))
1133 return NULL;
1134 ltype = degenerate(expr->cond_true);
1135 true = &expr->cond_true;
1136 }
1137
1138 if (expr->flags) {
1139 int flags = expr->conditional->flags & Int_const_expr;
1140 flags &= (*true)->flags & expr->cond_false->flags;
1141 if (!flags)
1142 expr->flags = 0;
1143 }
1144
1145 lclass = classify_type(ltype, &ltype);
1146 rclass = classify_type(rtype, &rtype);
1147 if (lclass & rclass & TYPE_NUM) {
1148 ctype = usual_conversions('?', *true, expr->cond_false,
1149 lclass, rclass, ltype, rtype);
1150 *true = cast_to(*true, ctype);
1151 expr->cond_false = cast_to(expr->cond_false, ctype);
1152 goto out;
1153 }
1154
1155 if ((lclass | rclass) & TYPE_PTR) {
1156 int is_null1 = is_null_pointer_constant(*true);
1157 int is_null2 = is_null_pointer_constant(expr->cond_false);
1158
1159 if (is_null1 && is_null2) {
1160 *true = cast_to(*true, &ptr_ctype);
1161 expr->cond_false = cast_to(expr->cond_false, &ptr_ctype);
1162 ctype = &ptr_ctype;
1163 goto out;
1164 }
1165 if (is_null1 && (rclass & TYPE_PTR)) {
1166 if (is_null1 == 2)
1167 bad_null(*true);
1168 *true = cast_to(*true, rtype);
1169 ctype = rtype;
1170 goto out;
1171 }
1172 if (is_null2 && (lclass & TYPE_PTR)) {
1173 if (is_null2 == 2)
1174 bad_null(expr->cond_false);
1175 expr->cond_false = cast_to(expr->cond_false, ltype);
1176 ctype = ltype;
1177 goto out;
1178 }
1179 if (!(lclass & rclass & TYPE_PTR)) {
1180 typediff = "different types";
1181 goto Err;
1182 }
1183 /* OK, it's pointer on pointer */
1184 if (ltype->ctype.as != rtype->ctype.as) {
1185 typediff = "different address spaces";
1186 goto Err;
1187 }
1188
1189 /* need to be lazier here */
1190 lbase = examine_pointer_target(ltype);
1191 rbase = examine_pointer_target(rtype);
1192 qual = target_qualifiers(ltype) | target_qualifiers(rtype);
1193
1194 if (lbase == &void_ctype) {
1195 /* XXX: pointers to function should warn here */
1196 ctype = ltype;
1197 goto Qual;
1198
1199 }
1200 if (rbase == &void_ctype) {
1201 /* XXX: pointers to function should warn here */
1202 ctype = rtype;
1203 goto Qual;
1204 }
1205 /* XXX: that should be pointer to composite */
1206 ctype = ltype;
1207 typediff = type_difference(&ltype->ctype, &rtype->ctype,
1208 qual, qual);
1209 if (!typediff)
1210 goto Qual;
1211 goto Err;
1212 }
1213
1214 /* void on void, struct on same struct, union on same union */
1215 if (ltype == rtype) {
1216 ctype = ltype;
1217 goto out;
1218 }
1219 typediff = "different base types";
1220
1221 Err:
1222 expression_error(expr, "incompatible types in conditional expression (%s)", typediff);
1223 return NULL;
1224
1225 out:
1226 expr->ctype = ctype;
1227 return ctype;
1228
1229 Qual:
1230 if (qual & ~ctype->ctype.modifiers) {
1231 struct symbol *sym = alloc_symbol(ctype->pos, SYM_PTR);
1232 *sym = *ctype;
1233 sym->ctype.modifiers |= qual;
1234 ctype = sym;
1235 }
1236 *true = cast_to(*true, ctype);
1237 expr->cond_false = cast_to(expr->cond_false, ctype);
1238 goto out;
1239 }
1240
1241 /* FP assignments can not do modulo or bit operations */
1242 static int compatible_float_op(int op)
1243 {
1244 return op == SPECIAL_ADD_ASSIGN ||
1245 op == SPECIAL_SUB_ASSIGN ||
1246 op == SPECIAL_MUL_ASSIGN ||
1247 op == SPECIAL_DIV_ASSIGN;
1248 }
1249
1250 static int evaluate_assign_op(struct expression *expr)
1251 {
1252 struct symbol *target = expr->left->ctype;
1253 struct symbol *source = expr->right->ctype;
1254 struct symbol *t, *s;
1255 int tclass = classify_type(target, &t);
1256 int sclass = classify_type(source, &s);
1257 int op = expr->op;
1258
1259 if (tclass & sclass & TYPE_NUM) {
1260 if (tclass & TYPE_FLOAT && !compatible_float_op(op)) {
1261 expression_error(expr, "invalid assignment");
1262 return 0;
1263 }
1264 if (tclass & TYPE_RESTRICT) {
1265 if (!restricted_binop(op, t)) {
1266 warning(expr->pos, "bad assignment (%s) to %s",
1267 show_special(op), show_typename(t));
1268 expr->right = cast_to(expr->right, target);
1269 return 0;
1270 }
1271 /* allowed assignments unfoul */
1272 if (sclass & TYPE_FOULED && unfoul(s) == t)
1273 goto Cast;
1274 if (!restricted_value(expr->right, t))
1275 return 1;
1276 } else if (!(sclass & TYPE_RESTRICT))
1277 goto usual;
1278 /* source and target would better be identical restricted */
1279 if (t == s)
1280 return 1;
1281 warning(expr->pos, "invalid assignment: %s", show_special(op));
1282 info(expr->pos, " left side has type %s", show_typename(t));
1283 info(expr->pos, " right side has type %s", show_typename(s));
1284 expr->right = cast_to(expr->right, target);
1285 return 0;
1286 }
1287 if (tclass == TYPE_PTR && is_int(sclass)) {
1288 if (op == SPECIAL_ADD_ASSIGN || op == SPECIAL_SUB_ASSIGN) {
1289 unrestrict(expr->right, sclass, &s);
1290 evaluate_ptr_add(expr, s);
1291 return 1;
1292 }
1293 expression_error(expr, "invalid pointer assignment");
1294 return 0;
1295 }
1296
1297 expression_error(expr, "invalid assignment");
1298 return 0;
1299
1300 usual:
1301 target = usual_conversions(op, expr->left, expr->right,
1302 tclass, sclass, target, source);
1303 Cast:
1304 expr->right = cast_to(expr->right, target);
1305 return 1;
1306 }
1307
1308 static int whitelist_pointers(struct symbol *t1, struct symbol *t2)
1309 {
1310 if (t1 == t2)
1311 return 0; /* yes, 0 - we don't want a cast_to here */
1312 if (t1 == &void_ctype)
1313 return 1;
1314 if (t2 == &void_ctype)
1315 return 1;
1316 if (classify_type(t1, &t1) != TYPE_NUM)
1317 return 0;
1318 if (classify_type(t2, &t2) != TYPE_NUM)
1319 return 0;
1320 if (t1 == t2)
1321 return 1;
1322 if (t1->ctype.modifiers & t2->ctype.modifiers & MOD_CHAR)
1323 return 1;
1324 if ((t1->ctype.modifiers ^ t2->ctype.modifiers) & MOD_SIZE)
1325 return 0;
1326 return !Wtypesign;
1327 }
1328
1329 static int check_assignment_types(struct symbol *target, struct expression **rp,
1330 const char **typediff)
1331 {
1332 struct symbol *source = degenerate(*rp);
1333 struct symbol *t, *s;
1334 int tclass = classify_type(target, &t);
1335 int sclass = classify_type(source, &s);
1336
1337 if (tclass & sclass & TYPE_NUM) {
1338 if (tclass & TYPE_RESTRICT) {
1339 /* allowed assignments unfoul */
1340 if (sclass & TYPE_FOULED && unfoul(s) == t)
1341 goto Cast;
1342 if (!restricted_value(*rp, target))
1343 return 1;
1344 if (s == t)
1345 return 1;
1346 } else if (!(sclass & TYPE_RESTRICT))
1347 goto Cast;
1348 if (t == &bool_ctype) {
1349 if (is_fouled_type(s))
1350 warning((*rp)->pos, "%s degrades to integer",
1351 show_typename(s->ctype.base_type));
1352 goto Cast;
1353 }
1354 *typediff = "different base types";
1355 return 0;
1356 }
1357
1358 if (tclass == TYPE_PTR) {
1359 unsigned long mod1, mod2;
1360 struct symbol *b1, *b2;
1361 // NULL pointer is always OK
1362 int is_null = is_null_pointer_constant(*rp);
1363 if (is_null) {
1364 if (is_null == 2)
1365 bad_null(*rp);
1366 goto Cast;
1367 }
1368 if (!(sclass & TYPE_PTR)) {
1369 *typediff = "different base types";
1370 return 0;
1371 }
1372 b1 = examine_pointer_target(t);
1373 b2 = examine_pointer_target(s);
1374 mod1 = target_qualifiers(t);
1375 mod2 = target_qualifiers(s);
1376 if (whitelist_pointers(b1, b2)) {
1377 /*
1378 * assignments to/from void * are OK, provided that
1379 * we do not remove qualifiers from pointed to [C]
1380 * or mix address spaces [sparse].
1381 */
1382 if (t->ctype.as != s->ctype.as) {
1383 *typediff = "different address spaces";
1384 return 0;
1385 }
1386 /*
1387 * If this is a function pointer assignment, it is
1388 * actually fine to assign a pointer to const data to
1389 * it, as a function pointer points to const data
1390 * implicitly, i.e., dereferencing it does not produce
1391 * an lvalue.
1392 */
1393 if (b1->type == SYM_FN)
1394 mod1 |= MOD_CONST;
1395 if (mod2 & ~mod1) {
1396 *typediff = "different modifiers";
1397 return 0;
1398 }
1399 goto Cast;
1400 }
1401 /* It's OK if the target is more volatile or const than the source */
1402 *typediff = type_difference(&t->ctype, &s->ctype, 0, mod1);
1403 if (*typediff)
1404 return 0;
1405 return 1;
1406 }
1407
1408 if ((tclass & TYPE_COMPOUND) && s == t)
1409 return 1;
1410
1411 if (tclass & TYPE_NUM) {
1412 /* XXX: need to turn into comparison with NULL */
1413 if (t == &bool_ctype && (sclass & TYPE_PTR))
1414 goto Cast;
1415 *typediff = "different base types";
1416 return 0;
1417 }
1418 *typediff = "invalid types";
1419 return 0;
1420
1421 Cast:
1422 *rp = cast_to(*rp, target);
1423 return 1;
1424 }
1425
1426 static int compatible_assignment_types(struct expression *expr, struct symbol *target,
1427 struct expression **rp, const char *where)
1428 {
1429 const char *typediff;
1430 struct symbol *source = degenerate(*rp);
1431
1432 if (!check_assignment_types(target, rp, &typediff)) {
1433 warning(expr->pos, "incorrect type in %s (%s)", where, typediff);
1434 info(expr->pos, " expected %s", show_typename(target));
1435 info(expr->pos, " got %s", show_typename(source));
1436 *rp = cast_to(*rp, target);
1437 return 0;
1438 }
1439
1440 return 1;
1441 }
1442
1443 static int compatible_transparent_union(struct symbol *target,
1444 struct expression **rp)
1445 {
1446 struct symbol *t, *member;
1447 classify_type(target, &t);
1448 if (t->type != SYM_UNION || !t->transparent_union)
1449 return 0;
1450
1451 FOR_EACH_PTR(t->symbol_list, member) {
1452 const char *typediff;
1453 if (check_assignment_types(member, rp, &typediff))
1454 return 1;
1455 } END_FOR_EACH_PTR(member);
1456
1457 return 0;
1458 }
1459
1460 static int compatible_argument_type(struct expression *expr, struct symbol *target,
1461 struct expression **rp, const char *where)
1462 {
1463 if (compatible_transparent_union(target, rp))
1464 return 1;
1465
1466 return compatible_assignment_types(expr, target, rp, where);
1467 }
1468
1469 static void mark_assigned(struct expression *expr)
1470 {
1471 struct symbol *sym;
1472
1473 if (!expr)
1474 return;
1475 switch (expr->type) {
1476 case EXPR_SYMBOL:
1477 sym = expr->symbol;
1478 if (!sym)
1479 return;
1480 if (sym->type != SYM_NODE)
1481 return;
1482 sym->ctype.modifiers |= MOD_ASSIGNED;
1483 return;
1484
1485 case EXPR_BINOP:
1486 mark_assigned(expr->left);
1487 mark_assigned(expr->right);
1488 return;
1489 case EXPR_CAST:
1490 case EXPR_FORCE_CAST:
1491 mark_assigned(expr->cast_expression);
1492 return;
1493 case EXPR_SLICE:
1494 mark_assigned(expr->base);
1495 return;
1496 default:
1497 /* Hmm? */
1498 return;
1499 }
1500 }
1501
1502 static void evaluate_assign_to(struct expression *left, struct symbol *type)
1503 {
1504 if (type->ctype.modifiers & MOD_CONST)
1505 expression_error(left, "assignment to const expression");
1506
1507 /* We know left is an lvalue, so it's a "preop-*" */
1508 mark_assigned(left->unop);
1509 }
1510
1511 static struct symbol *evaluate_assignment(struct expression *expr)
1512 {
1513 struct expression *left = expr->left;
1514 struct expression *where = expr;
1515 struct symbol *ltype;
1516
1517 if (!lvalue_expression(left)) {
1518 expression_error(expr, "not an lvalue");
1519 return NULL;
1520 }
1521
1522 ltype = left->ctype;
1523
1524 if (expr->op != '=') {
1525 if (!evaluate_assign_op(expr))
1526 return NULL;
1527 } else {
1528 if (!compatible_assignment_types(where, ltype, &expr->right, "assignment"))
1529 return NULL;
1530 }
1531
1532 evaluate_assign_to(left, ltype);
1533
1534 expr->ctype = ltype;
1535 return ltype;
1536 }
1537
1538 static void examine_fn_arguments(struct symbol *fn)
1539 {
1540 struct symbol *s;
1541
1542 FOR_EACH_PTR(fn->arguments, s) {
1543 struct symbol *arg = evaluate_symbol(s);
1544 /* Array/function arguments silently degenerate into pointers */
1545 if (arg) {
1546 struct symbol *ptr;
1547 switch(arg->type) {
1548 case SYM_ARRAY:
1549 case SYM_FN:
1550 ptr = alloc_symbol(s->pos, SYM_PTR);
1551 if (arg->type == SYM_ARRAY)
1552 ptr->ctype = arg->ctype;
1553 else
1554 ptr->ctype.base_type = arg;
1555 ptr->ctype.as |= s->ctype.as;
1556 ptr->ctype.modifiers |= s->ctype.modifiers & MOD_PTRINHERIT;
1557
1558 s->ctype.base_type = ptr;
1559 s->ctype.as = 0;
1560 s->ctype.modifiers &= ~MOD_PTRINHERIT;
1561 s->bit_size = 0;
1562 s->examined = 0;
1563 examine_symbol_type(s);
1564 break;
1565 default:
1566 /* nothing */
1567 break;
1568 }
1569 }
1570 } END_FOR_EACH_PTR(s);
1571 }
1572
1573 static struct symbol *convert_to_as_mod(struct symbol *sym, int as, int mod)
1574 {
1575 /* Take the modifiers of the pointer, and apply them to the member */
1576 mod |= sym->ctype.modifiers;
1577 if (sym->ctype.as != as || sym->ctype.modifiers != mod) {
1578 struct symbol *newsym = alloc_symbol(sym->pos, SYM_NODE);
1579 *newsym = *sym;
1580 newsym->ctype.as = as;
1581 newsym->ctype.modifiers = mod;
1582 sym = newsym;
1583 }
1584 return sym;
1585 }
1586
1587 static struct symbol *create_pointer(struct expression *expr, struct symbol *sym, int degenerate)
1588 {
1589 struct symbol *node = alloc_symbol(expr->pos, SYM_NODE);
1590 struct symbol *ptr = alloc_symbol(expr->pos, SYM_PTR);
1591
1592 node->ctype.base_type = ptr;
1593 ptr->bit_size = bits_in_pointer;
1594 ptr->ctype.alignment = pointer_alignment;
1595
1596 node->bit_size = bits_in_pointer;
1597 node->ctype.alignment = pointer_alignment;
1598
1599 access_symbol(sym);
1600 if (sym->ctype.modifiers & MOD_REGISTER) {
1601 warning(expr->pos, "taking address of 'register' variable '%s'", show_ident(sym->ident));
1602 sym->ctype.modifiers &= ~MOD_REGISTER;
1603 }
1604 if (sym->type == SYM_NODE) {
1605 ptr->ctype.as |= sym->ctype.as;
1606 ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT;
1607 sym = sym->ctype.base_type;
1608 }
1609 if (degenerate && sym->type == SYM_ARRAY) {
1610 ptr->ctype.as |= sym->ctype.as;
1611 ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT;
1612 sym = sym->ctype.base_type;
1613 }
1614 ptr->ctype.base_type = sym;
1615
1616 return node;
1617 }
1618
1619 /* Arrays degenerate into pointers on pointer arithmetic */
1620 static struct symbol *degenerate(struct expression *expr)
1621 {
1622 struct symbol *ctype, *base;
1623
1624 if (!expr)
1625 return NULL;
1626 ctype = expr->ctype;
1627 if (!ctype)
1628 return NULL;
1629 base = examine_symbol_type(ctype);
1630 if (ctype->type == SYM_NODE)
1631 base = ctype->ctype.base_type;
1632 /*
1633 * Arrays degenerate into pointers to the entries, while
1634 * functions degenerate into pointers to themselves.
1635 * If array was part of non-lvalue compound, we create a copy
1636 * of that compound first and then act as if we were dealing with
1637 * the corresponding field in there.
1638 */
1639 switch (base->type) {
1640 case SYM_ARRAY:
1641 if (expr->type == EXPR_SLICE) {
1642 struct symbol *a = alloc_symbol(expr->pos, SYM_NODE);
1643 struct expression *e0, *e1, *e2, *e3, *e4;
1644
1645 a->ctype.base_type = expr->base->ctype;
1646 a->bit_size = expr->base->ctype->bit_size;
1647 a->array_size = expr->base->ctype->array_size;
1648
1649 e0 = alloc_expression(expr->pos, EXPR_SYMBOL);
1650 e0->symbol = a;
1651 e0->ctype = &lazy_ptr_ctype;
1652
1653 e1 = alloc_expression(expr->pos, EXPR_PREOP);
1654 e1->unop = e0;
1655 e1->op = '*';
1656 e1->ctype = expr->base->ctype; /* XXX */
1657
1658 e2 = alloc_expression(expr->pos, EXPR_ASSIGNMENT);
1659 e2->left = e1;
1660 e2->right = expr->base;
1661 e2->op = '=';
1662 e2->ctype = expr->base->ctype;
1663
1664 if (expr->r_bitpos) {
1665 e3 = alloc_expression(expr->pos, EXPR_BINOP);
1666 e3->op = '+';
1667 e3->left = e0;
1668 e3->right = alloc_const_expression(expr->pos,
1669 bits_to_bytes(expr->r_bitpos));
1670 e3->ctype = &lazy_ptr_ctype;
1671 } else {
1672 e3 = e0;
1673 }
1674
1675 e4 = alloc_expression(expr->pos, EXPR_COMMA);
1676 e4->left = e2;
1677 e4->right = e3;
1678 e4->ctype = &lazy_ptr_ctype;
1679
1680 expr->unop = e4;
1681 expr->type = EXPR_PREOP;
1682 expr->op = '*';
1683 }
1684 case SYM_FN:
1685 if (expr->op != '*' || expr->type != EXPR_PREOP) {
1686 expression_error(expr, "strange non-value function or array");
1687 return &bad_ctype;
1688 }
1689 *expr = *expr->unop;
1690 ctype = create_pointer(expr, ctype, 1);
1691 expr->ctype = ctype;
1692 default:
1693 /* nothing */;
1694 }
1695 return ctype;
1696 }
1697
1698 static struct symbol *evaluate_addressof(struct expression *expr)
1699 {
1700 struct expression *op = expr->unop;
1701 struct symbol *ctype;
1702
1703 if (op->op != '*' || op->type != EXPR_PREOP) {
1704 expression_error(expr, "not addressable");
1705 return NULL;
1706 }
1707 ctype = op->ctype;
1708 *expr = *op->unop;
1709 expr->flags = 0;
1710
1711 if (expr->type == EXPR_SYMBOL) {
1712 struct symbol *sym = expr->symbol;
1713 sym->ctype.modifiers |= MOD_ADDRESSABLE;
1714 }
1715
1716 /*
1717 * symbol expression evaluation is lazy about the type
1718 * of the sub-expression, so we may have to generate
1719 * the type here if so..
1720 */
1721 if (expr->ctype == &lazy_ptr_ctype) {
1722 ctype = create_pointer(expr, ctype, 0);
1723 expr->ctype = ctype;
1724 }
1725 return expr->ctype;
1726 }
1727
1728
1729 static struct symbol *evaluate_dereference(struct expression *expr)
1730 {
1731 struct expression *op = expr->unop;
1732 struct symbol *ctype = op->ctype, *node, *target;
1733
1734 /* Simplify: *&(expr) => (expr) */
1735 if (op->type == EXPR_PREOP && op->op == '&') {
1736 *expr = *op->unop;
1737 expr->flags = 0;
1738 return expr->ctype;
1739 }
1740
1741 /* Dereferencing a node drops all the node information. */
1742 if (ctype->type == SYM_NODE)
1743 ctype = ctype->ctype.base_type;
1744
1745 node = alloc_symbol(expr->pos, SYM_NODE);
1746 target = ctype->ctype.base_type;
1747
1748 switch (ctype->type) {
1749 default:
1750 expression_error(expr, "cannot dereference this type");
1751 return NULL;
1752 case SYM_PTR:
1753 node->ctype.modifiers = target->ctype.modifiers & MOD_SPECIFIER;
1754 merge_type(node, ctype);
1755 break;
1756
1757 case SYM_ARRAY:
1758 if (!lvalue_expression(op)) {
1759 expression_error(op, "non-lvalue array??");
1760 return NULL;
1761 }
1762
1763 /* Do the implied "addressof" on the array */
1764 *op = *op->unop;
1765
1766 /*
1767 * When an array is dereferenced, we need to pick
1768 * up the attributes of the original node too..
1769 */
1770 merge_type(node, op->ctype);
1771 merge_type(node, ctype);
1772 break;
1773 }
1774
1775 node->bit_size = target->bit_size;
1776 node->array_size = target->array_size;
1777
1778 expr->ctype = node;
1779 return node;
1780 }
1781
1782 /*
1783 * Unary post-ops: x++ and x--
1784 */
1785 static struct symbol *evaluate_postop(struct expression *expr)
1786 {
1787 struct expression *op = expr->unop;
1788 struct symbol *ctype = op->ctype;
1789 int class = classify_type(ctype, &ctype);
1790 int multiply = 0;
1791
1792 if (!class || class & TYPE_COMPOUND) {
1793 expression_error(expr, "need scalar for ++/--");
1794 return NULL;
1795 }
1796 if (!lvalue_expression(expr->unop)) {
1797 expression_error(expr, "need lvalue expression for ++/--");
1798 return NULL;
1799 }
1800
1801 if ((class & TYPE_RESTRICT) && restricted_unop(expr->op, &ctype))
1802 unrestrict(expr, class, &ctype);
1803
1804 if (class & TYPE_NUM) {
1805 multiply = 1;
1806 } else if (class == TYPE_PTR) {
1807 struct symbol *target = examine_pointer_target(ctype);
1808 if (!is_function(target))
1809 multiply = bits_to_bytes(target->bit_size);
1810 }
1811
1812 if (multiply) {
1813 evaluate_assign_to(op, op->ctype);
1814 expr->op_value = multiply;
1815 expr->ctype = ctype;
1816 return ctype;
1817 }
1818
1819 expression_error(expr, "bad argument type for ++/--");
1820 return NULL;
1821 }
1822
1823 static struct symbol *evaluate_sign(struct expression *expr)
1824 {
1825 struct symbol *ctype = expr->unop->ctype;
1826 int class = classify_type(ctype, &ctype);
1827 if (expr->flags && !(expr->unop->flags & Int_const_expr))
1828 expr->flags = 0;
1829 /* should be an arithmetic type */
1830 if (!(class & TYPE_NUM))
1831 return bad_expr_type(expr);
1832 if (class & TYPE_RESTRICT)
1833 goto Restr;
1834 Normal:
1835 if (!(class & TYPE_FLOAT)) {
1836 ctype = integer_promotion(ctype);
1837 expr->unop = cast_to(expr->unop, ctype);
1838 } else if (expr->op != '~') {
1839 /* no conversions needed */
1840 } else {
1841 return bad_expr_type(expr);
1842 }
1843 if (expr->op == '+')
1844 *expr = *expr->unop;
1845 expr->ctype = ctype;
1846 return ctype;
1847 Restr:
1848 if (restricted_unop(expr->op, &ctype))
1849 unrestrict(expr, class, &ctype);
1850 goto Normal;
1851 }
1852
1853 static struct symbol *evaluate_preop(struct expression *expr)
1854 {
1855 struct symbol *ctype = expr->unop->ctype;
1856
1857 switch (expr->op) {
1858 case '(':
1859 *expr = *expr->unop;
1860 return ctype;
1861
1862 case '+':
1863 case '-':
1864 case '~':
1865 return evaluate_sign(expr);
1866
1867 case '*':
1868 return evaluate_dereference(expr);
1869
1870 case '&':
1871 return evaluate_addressof(expr);
1872
1873 case SPECIAL_INCREMENT:
1874 case SPECIAL_DECREMENT:
1875 /*
1876 * From a type evaluation standpoint the preops are
1877 * the same as the postops
1878 */
1879 return evaluate_postop(expr);
1880
1881 case '!':
1882 if (expr->flags && !(expr->unop->flags & Int_const_expr))
1883 expr->flags = 0;
1884 if (is_safe_type(ctype))
1885 warning(expr->pos, "testing a 'safe expression'");
1886 if (is_float_type(ctype)) {
1887 struct expression *arg = expr->unop;
1888 expr->type = EXPR_COMPARE;
1889 expr->op = SPECIAL_EQUAL;
1890 expr->left = arg;
1891 expr->right = alloc_expression(expr->pos, EXPR_FVALUE);
1892 expr->right->ctype = ctype;
1893 expr->right->fvalue = 0;
1894 } else if (is_fouled_type(ctype)) {
1895 warning(expr->pos, "%s degrades to integer",
1896 show_typename(ctype->ctype.base_type));
1897 }
1898 /* the result is int [6.5.3.3(5)]*/
1899 ctype = &int_ctype;
1900 break;
1901
1902 default:
1903 break;
1904 }
1905 expr->ctype = ctype;
1906 return ctype;
1907 }
1908
1909 static struct symbol *find_identifier(struct ident *ident, struct symbol_list *_list, int *offset)
1910 {
1911 struct ptr_list *head = (struct ptr_list *)_list;
1912 struct ptr_list *list = head;
1913
1914 if (!head)
1915 return NULL;
1916 do {
1917 int i;
1918 for (i = 0; i < list->nr; i++) {
1919 struct symbol *sym = (struct symbol *) list->list[i];
1920 if (sym->ident) {
1921 if (sym->ident != ident)
1922 continue;
1923 *offset = sym->offset;
1924 return sym;
1925 } else {
1926 struct symbol *ctype = sym->ctype.base_type;
1927 struct symbol *sub;
1928 if (!ctype)
1929 continue;
1930 if (ctype->type != SYM_UNION && ctype->type != SYM_STRUCT)
1931 continue;
1932 sub = find_identifier(ident, ctype->symbol_list, offset);
1933 if (!sub)
1934 continue;
1935 *offset += sym->offset;
1936 return sub;
1937 }
1938 }
1939 } while ((list = list->next) != head);
1940 return NULL;
1941 }
1942
1943 static struct expression *evaluate_offset(struct expression *expr, unsigned long offset)
1944 {
1945 struct expression *add;
1946
1947 /*
1948 * Create a new add-expression
1949 *
1950 * NOTE! Even if we just add zero, we need a new node
1951 * for the member pointer, since it has a different
1952 * type than the original pointer. We could make that
1953 * be just a cast, but the fact is, a node is a node,
1954 * so we might as well just do the "add zero" here.
1955 */
1956 add = alloc_expression(expr->pos, EXPR_BINOP);
1957 add->op = '+';
1958 add->left = expr;
1959 add->right = alloc_expression(expr->pos, EXPR_VALUE);
1960 add->right->ctype = &int_ctype;
1961 add->right->value = offset;
1962
1963 /*
1964 * The ctype of the pointer will be lazily evaluated if
1965 * we ever take the address of this member dereference..
1966 */
1967 add->ctype = &lazy_ptr_ctype;
1968 return add;
1969 }
1970
1971 /* structure/union dereference */
1972 static struct symbol *evaluate_member_dereference(struct expression *expr)
1973 {
1974 int offset;
1975 struct symbol *ctype, *member;
1976 struct expression *deref = expr->deref, *add;
1977 struct ident *ident = expr->member;
1978 unsigned int mod;
1979 int address_space;
1980
1981 if (!evaluate_expression(deref))
1982 return NULL;
1983 if (!ident) {
1984 expression_error(expr, "bad member name");
1985 return NULL;
1986 }
1987
1988 ctype = deref->ctype;
1989 examine_symbol_type(ctype);
1990 address_space = ctype->ctype.as;
1991 mod = ctype->ctype.modifiers;
1992 if (ctype->type == SYM_NODE) {
1993 ctype = ctype->ctype.base_type;
1994 address_space |= ctype->ctype.as;
1995 mod |= ctype->ctype.modifiers;
1996 }
1997 if (!ctype || (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION)) {
1998 expression_error(expr, "expected structure or union");
1999 return NULL;
2000 }
2001 offset = 0;
2002 member = find_identifier(ident, ctype->symbol_list, &offset);
2003 if (!member) {
2004 const char *type = ctype->type == SYM_STRUCT ? "struct" : "union";
2005 const char *name = "<unnamed>";
2006 int namelen = 9;
2007 if (ctype->ident) {
2008 name = ctype->ident->name;
2009 namelen = ctype->ident->len;
2010 }
2011 if (ctype->symbol_list)
2012 expression_error(expr, "no member '%s' in %s %.*s",
2013 show_ident(ident), type, namelen, name);
2014 else
2015 expression_error(expr, "using member '%s' in "
2016 "incomplete %s %.*s", show_ident(ident),
2017 type, namelen, name);
2018 return NULL;
2019 }
2020
2021 /*
2022 * The member needs to take on the address space and modifiers of
2023 * the "parent" type.
2024 */
2025 member = convert_to_as_mod(member, address_space, mod);
2026 ctype = get_base_type(member);
2027
2028 if (!lvalue_expression(deref)) {
2029 if (deref->type != EXPR_SLICE) {
2030 expr->base = deref;
2031 expr->r_bitpos = 0;
2032 } else {
2033 expr->base = deref->base;
2034 expr->r_bitpos = deref->r_bitpos;
2035 }
2036 expr->r_bitpos += bytes_to_bits(offset);
2037 expr->type = EXPR_SLICE;
2038 expr->r_nrbits = member->bit_size;
2039 expr->r_bitpos += member->bit_offset;
2040 expr->ctype = member;
2041 return member;
2042 }
2043
2044 deref = deref->unop;
2045 expr->deref = deref;
2046
2047 add = evaluate_offset(deref, offset);
2048 expr->type = EXPR_PREOP;
2049 expr->op = '*';
2050 expr->unop = add;
2051
2052 expr->ctype = member;
2053 return member;
2054 }
2055
2056 static int is_promoted(struct expression *expr)
2057 {
2058 while (1) {
2059 switch (expr->type) {
2060 case EXPR_BINOP:
2061 case EXPR_SELECT:
2062 case EXPR_CONDITIONAL:
2063 return 1;
2064 case EXPR_COMMA:
2065 expr = expr->right;
2066 continue;
2067 case EXPR_PREOP:
2068 switch (expr->op) {
2069 case '(':
2070 expr = expr->unop;
2071 continue;
2072 case '+':
2073 case '-':
2074 case '~':
2075 return 1;
2076 default:
2077 return 0;
2078 }
2079 default:
2080 return 0;
2081 }
2082 }
2083 }
2084
2085
2086 static struct symbol *evaluate_cast(struct expression *);
2087
2088 static struct symbol *evaluate_type_information(struct expression *expr)
2089 {
2090 struct symbol *sym = expr->cast_type;
2091 if (!sym) {
2092 sym = evaluate_expression(expr->cast_expression);
2093 if (!sym)
2094 return NULL;
2095 /*
2096 * Expressions of restricted types will possibly get
2097 * promoted - check that here
2098 */
2099 if (is_restricted_type(sym)) {
2100 if (sym->bit_size < bits_in_int && is_promoted(expr))
2101 sym = &int_ctype;
2102 } else if (is_fouled_type(sym)) {
2103 sym = &int_ctype;
2104 }
2105 }
2106 examine_symbol_type(sym);
2107 if (is_bitfield_type(sym)) {
2108 expression_error(expr, "trying to examine bitfield type");
2109 return NULL;
2110 }
2111 return sym;
2112 }
2113
2114 static struct symbol *evaluate_sizeof(struct expression *expr)
2115 {
2116 struct symbol *type;
2117 int size;
2118
2119 type = evaluate_type_information(expr);
2120 if (!type)
2121 return NULL;
2122
2123 size = type->bit_size;
2124
2125 if (size < 0 && is_void_type(type)) {
2126 warning(expr->pos, "expression using sizeof(void)");
2127 size = bits_in_char;
2128 }
2129
2130 if (size == 1 && is_bool_type(type)) {
2131 if (Wsizeof_bool)
2132 warning(expr->pos, "expression using sizeof bool");
2133 size = bits_in_char;
2134 }
2135
2136 if (is_function(type->ctype.base_type)) {
2137 warning(expr->pos, "expression using sizeof on a function");
2138 size = bits_in_char;
2139 }
2140
2141 if ((size < 0) || (size & (bits_in_char - 1)))
2142 expression_error(expr, "cannot size expression");
2143
2144 expr->type = EXPR_VALUE;
2145 expr->value = bits_to_bytes(size);
2146 expr->taint = 0;
2147 expr->ctype = size_t_ctype;
2148 return size_t_ctype;
2149 }
2150
2151 static struct symbol *evaluate_ptrsizeof(struct expression *expr)
2152 {
2153 struct symbol *type;
2154 int size;
2155
2156 type = evaluate_type_information(expr);
2157 if (!type)
2158 return NULL;
2159
2160 if (type->type == SYM_NODE)
2161 type = type->ctype.base_type;
2162 if (!type)
2163 return NULL;
2164 switch (type->type) {
2165 case SYM_ARRAY:
2166 break;
2167 case SYM_PTR:
2168 type = get_base_type(type);
2169 if (type)
2170 break;
2171 default:
2172 expression_error(expr, "expected pointer expression");
2173 return NULL;
2174 }
2175 size = type->bit_size;
2176 if (size & (bits_in_char-1))
2177 size = 0;
2178 expr->type = EXPR_VALUE;
2179 expr->value = bits_to_bytes(size);
2180 expr->taint = 0;
2181 expr->ctype = size_t_ctype;
2182 return size_t_ctype;
2183 }
2184
2185 static struct symbol *evaluate_alignof(struct expression *expr)
2186 {
2187 struct symbol *type;
2188
2189 type = evaluate_type_information(expr);
2190 if (!type)
2191 return NULL;
2192
2193 expr->type = EXPR_VALUE;
2194 expr->value = type->ctype.alignment;
2195 expr->taint = 0;
2196 expr->ctype = size_t_ctype;
2197 return size_t_ctype;
2198 }
2199
2200 static int evaluate_arguments(struct symbol *fn, struct expression_list *head)
2201 {
2202 struct expression *expr;
2203 struct symbol_list *argument_types = fn->arguments;
2204 struct symbol *argtype;
2205 int i = 1;
2206
2207 PREPARE_PTR_LIST(argument_types, argtype);
2208 FOR_EACH_PTR (head, expr) {
2209 struct expression **p = THIS_ADDRESS(expr);
2210 struct symbol *ctype, *target;
2211 ctype = evaluate_expression(expr);
2212
2213 if (!ctype)
2214 return 0;
2215
2216 target = argtype;
2217 if (!target) {
2218 struct symbol *type;
2219 int class = classify_type(ctype, &type);
2220 if (is_int(class)) {
2221 *p = cast_to(expr, integer_promotion(type));
2222 } else if (class & TYPE_FLOAT) {
2223 unsigned long mod = type->ctype.modifiers;
2224 if (!(mod & (MOD_LONG_ALL)))
2225 *p = cast_to(expr, &double_ctype);
2226 } else if (class & TYPE_PTR) {
2227 if (expr->ctype == &null_ctype)
2228 *p = cast_to(expr, &ptr_ctype);
2229 else
2230 degenerate(expr);
2231 }
2232 } else if (!target->forced_arg){
2233 static char where[30];
2234 examine_symbol_type(target);
2235 sprintf(where, "argument %d", i);
2236 compatible_argument_type(expr, target, p, where);
2237 }
2238
2239 i++;
2240 NEXT_PTR_LIST(argtype);
2241 } END_FOR_EACH_PTR(expr);
2242 FINISH_PTR_LIST(argtype);
2243 return 1;
2244 }
2245
2246 static void convert_index(struct expression *e)
2247 {
2248 struct expression *child = e->idx_expression;
2249 unsigned from = e->idx_from;
2250 unsigned to = e->idx_to + 1;
2251 e->type = EXPR_POS;
2252 e->init_offset = from * bits_to_bytes(e->ctype->bit_size);
2253 e->init_nr = to - from;
2254 e->init_expr = child;
2255 }
2256
2257 static void convert_ident(struct expression *e)
2258 {
2259 struct expression *child = e->ident_expression;
2260 int offset = e->offset;
2261
2262 e->type = EXPR_POS;
2263 e->init_offset = offset;
2264 e->init_nr = 1;
2265 e->init_expr = child;
2266 }
2267
2268 static void convert_designators(struct expression *e)
2269 {
2270 while (e) {
2271 if (e->type == EXPR_INDEX)
2272 convert_index(e);
2273 else if (e->type == EXPR_IDENTIFIER)
2274 convert_ident(e);
2275 else
2276 break;
2277 e = e->init_expr;
2278 }
2279 }
2280
2281 static void excess(struct expression *e, const char *s)
2282 {
2283 warning(e->pos, "excessive elements in %s initializer", s);
2284 }
2285
2286 /*
2287 * implicit designator for the first element
2288 */
2289 static struct expression *first_subobject(struct symbol *ctype, int class,
2290 struct expression **v)
2291 {
2292 struct expression *e = *v, *new;
2293
2294 if (ctype->type == SYM_NODE)
2295 ctype = ctype->ctype.base_type;
2296
2297 if (class & TYPE_PTR) { /* array */
2298 if (!ctype->bit_size)
2299 return NULL;
2300 new = alloc_expression(e->pos, EXPR_INDEX);
2301 new->idx_expression = e;
2302 new->ctype = ctype->ctype.base_type;
2303 } else {
2304 struct symbol *field, *p;
2305 PREPARE_PTR_LIST(ctype->symbol_list, p);
2306 while (p && !p->ident && is_bitfield_type(p))
2307 NEXT_PTR_LIST(p);
2308 field = p;
2309 FINISH_PTR_LIST(p);
2310 if (!field)
2311 return NULL;
2312 new = alloc_expression(e->pos, EXPR_IDENTIFIER);
2313 new->ident_expression = e;
2314 new->field = new->ctype = field;
2315 new->offset = field->offset;
2316 }
2317 *v = new;
2318 return new;
2319 }
2320
2321 /*
2322 * sanity-check explicit designators; return the innermost one or NULL
2323 * in case of error. Assign types.
2324 */
2325 static struct expression *check_designators(struct expression *e,
2326 struct symbol *ctype)
2327 {
2328 struct expression *last = NULL;
2329 const char *err;
2330 while (1) {
2331 if (ctype->type == SYM_NODE)
2332 ctype = ctype->ctype.base_type;
2333 if (e->type == EXPR_INDEX) {
2334 struct symbol *type;
2335 if (ctype->type != SYM_ARRAY) {
2336 err = "array index in non-array";
2337 break;
2338 }
2339 type = ctype->ctype.base_type;
2340 if (ctype->bit_size >= 0 && type->bit_size >= 0) {
2341 unsigned offset = array_element_offset(type->bit_size, e->idx_to);
2342 if (offset >= ctype->bit_size) {
2343 err = "index out of bounds in";
2344 break;
2345 }
2346 }
2347 e->ctype = ctype = type;
2348 ctype = type;
2349 last = e;
2350 if (!e->idx_expression) {
2351 err = "invalid";
2352 break;
2353 }
2354 e = e->idx_expression;
2355 } else if (e->type == EXPR_IDENTIFIER) {
2356 int offset = 0;
2357 if (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION) {
2358 err = "field name not in struct or union";
2359 break;
2360 }
2361 ctype = find_identifier(e->expr_ident, ctype->symbol_list, &offset);
2362 if (!ctype) {
2363 err = "unknown field name in";
2364 break;
2365 }
2366 e->offset = offset;
2367 e->field = e->ctype = ctype;
2368 last = e;
2369 if (!e->ident_expression) {
2370 err = "invalid";
2371 break;
2372 }
2373 e = e->ident_expression;
2374 } else if (e->type == EXPR_POS) {
2375 err = "internal front-end error: EXPR_POS in";
2376 break;
2377 } else
2378 return last;
2379 }
2380 expression_error(e, "%s initializer", err);
2381 return NULL;
2382 }
2383
2384 /*
2385 * choose the next subobject to initialize.
2386 *
2387 * Get designators for next element, switch old ones to EXPR_POS.
2388 * Return the resulting expression or NULL if we'd run out of subobjects.
2389 * The innermost designator is returned in *v. Designators in old
2390 * are assumed to be already sanity-checked.
2391 */
2392 static struct expression *next_designators(struct expression *old,
2393 struct symbol *ctype,
2394 struct expression *e, struct expression **v)
2395 {
2396 struct expression *new = NULL;
2397
2398 if (!old)
2399 return NULL;
2400 if (old->type == EXPR_INDEX) {
2401 struct expression *copy;
2402 unsigned n;
2403
2404 copy = next_designators(old->idx_expression,
2405 old->ctype, e, v);
2406 if (!copy) {
2407 n = old->idx_to + 1;
2408 if (array_element_offset(old->ctype->bit_size, n) == ctype->bit_size) {
2409 convert_index(old);
2410 return NULL;
2411 }
2412 copy = e;
2413 *v = new = alloc_expression(e->pos, EXPR_INDEX);
2414 } else {
2415 n = old->idx_to;
2416 new = alloc_expression(e->pos, EXPR_INDEX);
2417 }
2418
2419 new->idx_from = new->idx_to = n;
2420 new->idx_expression = copy;
2421 new->ctype = old->ctype;
2422 convert_index(old);
2423 } else if (old->type == EXPR_IDENTIFIER) {
2424 struct expression *copy;
2425 struct symbol *field;
2426 int offset = 0;
2427
2428 copy = next_designators(old->ident_expression,
2429 old->ctype, e, v);
2430 if (!copy) {
2431 field = old->field->next_subobject;
2432 if (!field) {
2433 convert_ident(old);
2434 return NULL;
2435 }
2436 copy = e;
2437 *v = new = alloc_expression(e->pos, EXPR_IDENTIFIER);
2438 /*
2439 * We can't necessarily trust "field->offset",
2440 * because the field might be in an anonymous
2441 * union, and the field offset is then the offset
2442 * within that union.
2443 *
2444 * The "old->offset - old->field->offset"
2445 * would be the offset of such an anonymous
2446 * union.
2447 */
2448 offset = old->offset - old->field->offset;
2449 } else {
2450 field = old->field;
2451 new = alloc_expression(e->pos, EXPR_IDENTIFIER);
2452 }
2453
2454 new->field = field;
2455 new->expr_ident = field->ident;
2456 new->ident_expression = copy;
2457 new->ctype = field;
2458 new->offset = field->offset + offset;
2459 convert_ident(old);
2460 }
2461 return new;
2462 }
2463
2464 static int handle_simple_initializer(struct expression **ep, int nested,
2465 int class, struct symbol *ctype);
2466
2467 /*
2468 * deal with traversing subobjects [6.7.8(17,18,20)]
2469 */
2470 static void handle_list_initializer(struct expression *expr,
2471 int class, struct symbol *ctype)
2472 {
2473 struct expression *e, *last = NULL, *top = NULL, *next;
2474 int jumped = 0;
2475
2476 FOR_EACH_PTR(expr->expr_list, e) {
2477 struct expression **v;
2478 struct symbol *type;
2479 int lclass;
2480
2481 if (e->type != EXPR_INDEX && e->type != EXPR_IDENTIFIER) {
2482 struct symbol *struct_sym;
2483 if (!top) {
2484 top = e;
2485 last = first_subobject(ctype, class, &top);
2486 } else {
2487 last = next_designators(last, ctype, e, &top);
2488 }
2489 if (!last) {
2490 excess(e, class & TYPE_PTR ? "array" :
2491 "struct or union");
2492 DELETE_CURRENT_PTR(e);
2493 continue;
2494 }
2495 struct_sym = ctype->type == SYM_NODE ? ctype->ctype.base_type : ctype;
2496 if (Wdesignated_init && struct_sym->designated_init)
2497 warning(e->pos, "%s%.*s%spositional init of field in %s %s, declared with attribute designated_init",
2498 ctype->ident ? "in initializer for " : "",
2499 ctype->ident ? ctype->ident->len : 0,
2500 ctype->ident ? ctype->ident->name : "",
2501 ctype->ident ? ": " : "",
2502 get_type_name(struct_sym->type),
2503 show_ident(struct_sym->ident));
2504 if (jumped) {
2505 warning(e->pos, "advancing past deep designator");
2506 jumped = 0;
2507 }
2508 REPLACE_CURRENT_PTR(e, last);
2509 } else {
2510 next = check_designators(e, ctype);
2511 if (!next) {
2512 DELETE_CURRENT_PTR(e);
2513 continue;
2514 }
2515 top = next;
2516 /* deeper than one designator? */
2517 jumped = top != e;
2518 convert_designators(last);
2519 last = e;
2520 }
2521
2522 found:
2523 lclass = classify_type(top->ctype, &type);
2524 if (top->type == EXPR_INDEX)
2525 v = &top->idx_expression;
2526 else
2527 v = &top->ident_expression;
2528
2529 if (handle_simple_initializer(v, 1, lclass, top->ctype))
2530 continue;
2531
2532 if (!(lclass & TYPE_COMPOUND)) {
2533 warning(e->pos, "bogus scalar initializer");
2534 DELETE_CURRENT_PTR(e);
2535 continue;
2536 }
2537
2538 next = first_subobject(type, lclass, v);
2539 if (next) {
2540 warning(e->pos, "missing braces around initializer");
2541 top = next;
2542 goto found;
2543 }
2544
2545 DELETE_CURRENT_PTR(e);
2546 excess(e, lclass & TYPE_PTR ? "array" : "struct or union");
2547
2548 } END_FOR_EACH_PTR(e);
2549
2550 convert_designators(last);
2551 expr->ctype = ctype;
2552 }
2553
2554 static int is_string_literal(struct expression **v)
2555 {
2556 struct expression *e = *v;
2557 while (e && e->type == EXPR_PREOP && e->op == '(')
2558 e = e->unop;
2559 if (!e || e->type != EXPR_STRING)
2560 return 0;
2561 if (e != *v && Wparen_string)
2562 warning(e->pos,
2563 "array initialized from parenthesized string constant");
2564 *v = e;
2565 return 1;
2566 }
2567
2568 /*
2569 * We want a normal expression, possibly in one layer of braces. Warn
2570 * if the latter happens inside a list (it's legal, but likely to be
2571 * an effect of screwup). In case of anything not legal, we are definitely
2572 * having an effect of screwup, so just fail and let the caller warn.
2573 */
2574 static struct expression *handle_scalar(struct expression *e, int nested)
2575 {
2576 struct expression *v = NULL, *p;
2577 int count = 0;
2578
2579 /* normal case */
2580 if (e->type != EXPR_INITIALIZER)
2581 return e;
2582
2583 FOR_EACH_PTR(e->expr_list, p) {
2584 if (!v)
2585 v = p;
2586 count++;
2587 } END_FOR_EACH_PTR(p);
2588 if (count != 1)
2589 return NULL;
2590 switch(v->type) {
2591 case EXPR_INITIALIZER:
2592 case EXPR_INDEX:
2593 case EXPR_IDENTIFIER:
2594 return NULL;
2595 default:
2596 break;
2597 }
2598 if (nested)
2599 warning(e->pos, "braces around scalar initializer");
2600 return v;
2601 }
2602
2603 /*
2604 * deal with the cases that don't care about subobjects:
2605 * scalar <- assignment expression, possibly in braces [6.7.8(11)]
2606 * character array <- string literal, possibly in braces [6.7.8(14)]
2607 * struct or union <- assignment expression of compatible type [6.7.8(13)]
2608 * compound type <- initializer list in braces [6.7.8(16)]
2609 * The last one punts to handle_list_initializer() which, in turn will call
2610 * us for individual elements of the list.
2611 *
2612 * We do not handle 6.7.8(15) (wide char array <- wide string literal) for
2613 * the lack of support of wide char stuff in general.
2614 *
2615 * One note: we need to take care not to evaluate a string literal until
2616 * we know that we *will* handle it right here. Otherwise we would screw
2617 * the cases like struct { struct {char s[10]; ...} ...} initialized with
2618 * { "string", ...} - we need to preserve that string literal recognizable
2619 * until we dig into the inner struct.
2620 */
2621 static int handle_simple_initializer(struct expression **ep, int nested,
2622 int class, struct symbol *ctype)
2623 {
2624 int is_string = is_string_type(ctype);
2625 struct expression *e = *ep, *p;
2626 struct symbol *type;
2627
2628 if (!e)
2629 return 0;
2630
2631 /* scalar */
2632 if (!(class & TYPE_COMPOUND)) {
2633 e = handle_scalar(e, nested);
2634 if (!e)
2635 return 0;
2636 *ep = e;
2637 if (!evaluate_expression(e))
2638 return 1;
2639 compatible_assignment_types(e, ctype, ep, "initializer");
2640 return 1;
2641 }
2642
2643 /*
2644 * sublist; either a string, or we dig in; the latter will deal with
2645 * pathologies, so we don't need anything fancy here.
2646 */
2647 if (e->type == EXPR_INITIALIZER) {
2648 if (is_string) {
2649 struct expression *v = NULL;
2650 int count = 0;
2651
2652 FOR_EACH_PTR(e->expr_list, p) {
2653 if (!v)
2654 v = p;
2655 count++;
2656 } END_FOR_EACH_PTR(p);
2657 if (count == 1 && is_string_literal(&v)) {
2658 *ep = e = v;
2659 goto String;
2660 }
2661 }
2662 handle_list_initializer(e, class, ctype);
2663 return 1;
2664 }
2665
2666 /* string */
2667 if (is_string_literal(&e)) {
2668 /* either we are doing array of char, or we'll have to dig in */
2669 if (is_string) {
2670 *ep = e;
2671 goto String;
2672 }
2673 return 0;
2674 }
2675 /* struct or union can be initialized by compatible */
2676 if (class != TYPE_COMPOUND)
2677 return 0;
2678 type = evaluate_expression(e);
2679 if (!type)
2680 return 0;
2681 if (ctype->type == SYM_NODE)
2682 ctype = ctype->ctype.base_type;
2683 if (type->type == SYM_NODE)
2684 type = type->ctype.base_type;
2685 if (ctype == type)
2686 return 1;
2687 return 0;
2688
2689 String:
2690 p = alloc_expression(e->pos, EXPR_STRING);
2691 *p = *e;
2692 type = evaluate_expression(p);
2693 if (ctype->bit_size != -1) {
2694 if (ctype->bit_size + bits_in_char < type->bit_size)
2695 warning(e->pos,
2696 "too long initializer-string for array of char");
2697 else if (Winit_cstring && ctype->bit_size + bits_in_char == type->bit_size) {
2698 warning(e->pos,
2699 "too long initializer-string for array of char(no space for nul char)");
2700 }
2701 }
2702 *ep = p;
2703 return 1;
2704 }
2705
2706 static void evaluate_initializer(struct symbol *ctype, struct expression **ep)
2707 {
2708 struct symbol *type;
2709 int class = classify_type(ctype, &type);
2710 if (!handle_simple_initializer(ep, 0, class, ctype))
2711 expression_error(*ep, "invalid initializer");
2712 }
2713
2714 static struct symbol *cast_to_bool(struct expression *expr)
2715 {
2716 struct expression *old = expr->cast_expression;
2717 struct expression *zero;
2718 struct symbol *otype;
2719 int oclass = classify_type(degenerate(old), &otype);
2720 struct symbol *ctype;
2721
2722 if (oclass & TYPE_COMPOUND)
2723 return NULL;
2724
2725 zero = alloc_const_expression(expr->pos, 0);
2726 expr->op = SPECIAL_NOTEQUAL;
2727 ctype = usual_conversions(expr->op, old, zero,
2728 oclass, TYPE_NUM, otype, zero->ctype);
2729 expr->type = EXPR_COMPARE;
2730 expr->left = cast_to(old, ctype);
2731 expr->right = cast_to(zero, ctype);
2732
2733 return expr->ctype;
2734 }
2735
2736 static struct symbol *evaluate_cast(struct expression *expr)
2737 {
2738 struct expression *target = expr->cast_expression;
2739 struct symbol *ctype;
2740 struct symbol *t1, *t2;
2741 int class1, class2;
2742 int as1 = 0, as2 = 0;
2743
2744 if (!target)
2745 return NULL;
2746
2747 /*
2748 * Special case: a cast can be followed by an
2749 * initializer, in which case we need to pass
2750 * the type value down to that initializer rather
2751 * than trying to evaluate it as an expression
2752 *
2753 * A more complex case is when the initializer is
2754 * dereferenced as part of a post-fix expression.
2755 * We need to produce an expression that can be dereferenced.
2756 */
2757 if (target->type == EXPR_INITIALIZER) {
2758 struct symbol *sym = expr->cast_type;
2759 struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
2760
2761 sym->initializer = target;
2762 evaluate_symbol(sym);
2763
2764 addr->ctype = &lazy_ptr_ctype; /* Lazy eval */
2765 addr->symbol = sym;
2766
2767 expr->type = EXPR_PREOP;
2768 expr->op = '*';
2769 expr->unop = addr;
2770 expr->ctype = sym;
2771
2772 return sym;
2773 }
2774
2775 ctype = examine_symbol_type(expr->cast_type);
2776 expr->ctype = ctype;
2777 expr->cast_type = ctype;
2778
2779 evaluate_expression(target);
2780 degenerate(target);
2781
2782 class1 = classify_type(ctype, &t1);
2783
2784 /* cast to non-integer type -> not an integer constant expression */
2785 if (!is_int(class1))
2786 expr->flags = 0;
2787 /* if argument turns out to be not an integer constant expression *and*
2788 it was not a floating literal to start with -> too bad */
2789 else if (expr->flags == Int_const_expr &&
2790 !(target->flags & Int_const_expr))
2791 expr->flags = 0;
2792 /*
2793 * You can always throw a value away by casting to
2794 * "void" - that's an implicit "force". Note that
2795 * the same is _not_ true of "void *".
2796 */
2797 if (t1 == &void_ctype)
2798 goto out;
2799
2800 if (class1 & (TYPE_COMPOUND | TYPE_FN))
2801 warning(expr->pos, "cast to non-scalar");
2802
2803 t2 = target->ctype;
2804 if (!t2) {
2805 expression_error(expr, "cast from unknown type");
2806 goto out;
2807 }
2808 class2 = classify_type(t2, &t2);
2809
2810 if (class2 & TYPE_COMPOUND)
2811 warning(expr->pos, "cast from non-scalar");
2812
2813 if (expr->type == EXPR_FORCE_CAST)
2814 goto out;
2815
2816 /* allowed cast unfouls */
2817 if (class2 & TYPE_FOULED)
2818 t2 = unfoul(t2);
2819
2820 if (t1 != t2) {
2821 if ((class1 & TYPE_RESTRICT) && restricted_value(target, t1))
2822 warning(expr->pos, "cast to %s",
2823 show_typename(t1));
2824 if (class2 & TYPE_RESTRICT)
2825 warning(expr->pos, "cast from %s",
2826 show_typename(t2));
2827 }
2828
2829 if (t1 == &ulong_ctype)
2830 as1 = -1;
2831 else if (class1 == TYPE_PTR) {
2832 examine_pointer_target(t1);
2833 as1 = t1->ctype.as;
2834 }
2835
2836 if (t2 == &ulong_ctype)
2837 as2 = -1;
2838 else if (class2 == TYPE_PTR) {
2839 examine_pointer_target(t2);
2840 as2 = t2->ctype.as;
2841 }
2842
2843 if (!as1 && as2 > 0)
2844 warning(expr->pos, "cast removes address space of expression");
2845 if (as1 > 0 && as2 > 0 && as1 != as2)
2846 warning(expr->pos, "cast between address spaces (<asn:%d>-><asn:%d>)", as2, as1);
2847 if (as1 > 0 && !as2 &&
2848 !is_null_pointer_constant(target) && Wcast_to_as)
2849 warning(expr->pos,
2850 "cast adds address space to expression (<asn:%d>)", as1);
2851
2852 if (!(t1->ctype.modifiers & MOD_PTRINHERIT) && class1 == TYPE_PTR &&
2853 !as1 && (target->flags & Int_const_expr)) {
2854 if (t1->ctype.base_type == &void_ctype) {
2855 if (is_zero_constant(target)) {
2856 /* NULL */
2857 expr->type = EXPR_VALUE;
2858 expr->ctype = &null_ctype;
2859 expr->value = 0;
2860 return expr->ctype;
2861 }
2862 }
2863 }
2864
2865 if (t1 == &bool_ctype)
2866 cast_to_bool(expr);
2867
2868 out:
2869 return ctype;
2870 }
2871
2872 /*
2873 * Evaluate a call expression with a symbol. This
2874 * should expand inline functions, and evaluate
2875 * builtins.
2876 */
2877 static int evaluate_symbol_call(struct expression *expr)
2878 {
2879 struct expression *fn = expr->fn;
2880 struct symbol *ctype = fn->ctype;
2881
2882 if (fn->type != EXPR_PREOP)
2883 return 0;
2884
2885 if (ctype->op && ctype->op->evaluate)
2886 return ctype->op->evaluate(expr);
2887
2888 if (ctype->ctype.modifiers & MOD_INLINE) {
2889 int ret;
2890 struct symbol *curr = current_fn;
2891
2892 if (ctype->definition)
2893 ctype = ctype->definition;
2894
2895 current_fn = ctype->ctype.base_type;
2896
2897 ret = inline_function(expr, ctype);
2898
2899 /* restore the old function */
2900 current_fn = curr;
2901 return ret;
2902 }
2903
2904 return 0;
2905 }
2906
2907 static struct symbol *evaluate_call(struct expression *expr)
2908 {
2909 int args, fnargs;
2910 struct symbol *ctype, *sym;
2911 struct expression *fn = expr->fn;
2912 struct expression_list *arglist = expr->args;
2913
2914 if (!evaluate_expression(fn))
2915 return NULL;
2916 sym = ctype = fn->ctype;
2917 if (ctype->type == SYM_NODE)
2918 ctype = ctype->ctype.base_type;
2919 if (ctype->type == SYM_PTR)
2920 ctype = get_base_type(ctype);
2921
2922 if (ctype->type != SYM_FN) {
2923 struct expression *arg;
2924 expression_error(expr, "not a function %s",
2925 show_ident(sym->ident));
2926 /* do typechecking in arguments */
2927 FOR_EACH_PTR (arglist, arg) {
2928 evaluate_expression(arg);
2929 } END_FOR_EACH_PTR(arg);
2930 return NULL;
2931 }
2932
2933 examine_fn_arguments(ctype);
2934 if (sym->type == SYM_NODE && fn->type == EXPR_PREOP &&
2935 sym->op && sym->op->args) {
2936 if (!sym->op->args(expr))
2937 return NULL;
2938 } else {
2939 if (!evaluate_arguments(ctype, arglist))
2940 return NULL;
2941 args = expression_list_size(expr->args);
2942 fnargs = symbol_list_size(ctype->arguments);
2943 if (args < fnargs)
2944 expression_error(expr,
2945 "not enough arguments for function %s",
2946 show_ident(sym->ident));
2947 if (args > fnargs && !ctype->variadic)
2948 expression_error(expr,
2949 "too many arguments for function %s",
2950 show_ident(sym->ident));
2951 }
2952 if (sym->type == SYM_NODE) {
2953 if (evaluate_symbol_call(expr))
2954 return expr->ctype;
2955 }
2956 expr->ctype = ctype->ctype.base_type;
2957 return expr->ctype;
2958 }
2959
2960 static struct symbol *evaluate_offsetof(struct expression *expr)
2961 {
2962 struct expression *e = expr->down;
2963 struct symbol *ctype = expr->in;
2964 int class;
2965
2966 if (expr->op == '.') {
2967 struct symbol *field;
2968 int offset = 0;
2969 if (!ctype) {
2970 expression_error(expr, "expected structure or union");
2971 return NULL;
2972 }
2973 examine_symbol_type(ctype);
2974 class = classify_type(ctype, &ctype);
2975 if (class != TYPE_COMPOUND) {
2976 expression_error(expr, "expected structure or union");
2977 return NULL;
2978 }
2979
2980 field = find_identifier(expr->ident, ctype->symbol_list, &offset);
2981 if (!field) {
2982 expression_error(expr, "unknown member");
2983 return NULL;
2984 }
2985 ctype = field;
2986 expr->type = EXPR_VALUE;
2987 expr->flags = Int_const_expr;
2988 expr->value = offset;
2989 expr->taint = 0;
2990 expr->ctype = size_t_ctype;
2991 } else {
2992 if (!ctype) {
2993 expression_error(expr, "expected structure or union");
2994 return NULL;
2995 }
2996 examine_symbol_type(ctype);
2997 class = classify_type(ctype, &ctype);
2998 if (class != (TYPE_COMPOUND | TYPE_PTR)) {
2999 expression_error(expr, "expected array");
3000 return NULL;
3001 }
3002 ctype = ctype->ctype.base_type;
3003 if (!expr->index) {
3004 expr->type = EXPR_VALUE;
3005 expr->flags = Int_const_expr;
3006 expr->value = 0;
3007 expr->taint = 0;
3008 expr->ctype = size_t_ctype;
3009 } else {
3010 struct expression *idx = expr->index, *m;
3011 struct symbol *i_type = evaluate_expression(idx);
3012 int i_class = classify_type(i_type, &i_type);
3013 if (!is_int(i_class)) {
3014 expression_error(expr, "non-integer index");
3015 return NULL;
3016 }
3017 unrestrict(idx, i_class, &i_type);
3018 idx = cast_to(idx, size_t_ctype);
3019 m = alloc_const_expression(expr->pos,
3020 bits_to_bytes(ctype->bit_size));
3021 m->ctype = size_t_ctype;
3022 m->flags = Int_const_expr;
3023 expr->type = EXPR_BINOP;
3024 expr->left = idx;
3025 expr->right = m;
3026 expr->op = '*';
3027 expr->ctype = size_t_ctype;
3028 expr->flags = m->flags & idx->flags & Int_const_expr;
3029 }
3030 }
3031 if (e) {
3032 struct expression *copy = __alloc_expression(0);
3033 *copy = *expr;
3034 if (e->type == EXPR_OFFSETOF)
3035 e->in = ctype;
3036 if (!evaluate_expression(e))
3037 return NULL;
3038 expr->type = EXPR_BINOP;
3039 expr->flags = e->flags & copy->flags & Int_const_expr;
3040 expr->op = '+';
3041 expr->ctype = size_t_ctype;
3042 expr->left = copy;
3043 expr->right = e;
3044 }
3045 return size_t_ctype;
3046 }
3047
3048 struct symbol *evaluate_expression(struct expression *expr)
3049 {
3050 if (!expr)
3051 return NULL;
3052 if (expr->ctype)
3053 return expr->ctype;
3054
3055 switch (expr->type) {
3056 case EXPR_VALUE:
3057 case EXPR_FVALUE:
3058 expression_error(expr, "value expression without a type");
3059 return NULL;
3060 case EXPR_STRING:
3061 return evaluate_string(expr);
3062 case EXPR_SYMBOL:
3063 return evaluate_symbol_expression(expr);
3064 case EXPR_BINOP:
3065 if (!evaluate_expression(expr->left))
3066 return NULL;
3067 if (!evaluate_expression(expr->right))
3068 return NULL;
3069 return evaluate_binop(expr);
3070 case EXPR_LOGICAL:
3071 return evaluate_logical(expr);
3072 case EXPR_COMMA:
3073 evaluate_expression(expr->left);
3074 if (!evaluate_expression(expr->right))
3075 return NULL;
3076 return evaluate_comma(expr);
3077 case EXPR_COMPARE:
3078 if (!evaluate_expression(expr->left))
3079 return NULL;
3080 if (!evaluate_expression(expr->right))
3081 return NULL;
3082 return evaluate_compare(expr);
3083 case EXPR_ASSIGNMENT:
3084 if (!evaluate_expression(expr->left))
3085 return NULL;
3086 if (!evaluate_expression(expr->right))
3087 return NULL;
3088 return evaluate_assignment(expr);
3089 case EXPR_PREOP:
3090 if (!evaluate_expression(expr->unop))
3091 return NULL;
3092 return evaluate_preop(expr);
3093 case EXPR_POSTOP:
3094 if (!evaluate_expression(expr->unop))
3095 return NULL;
3096 return evaluate_postop(expr);
3097 case EXPR_CAST:
3098 case EXPR_FORCE_CAST:
3099 case EXPR_IMPLIED_CAST:
3100 return evaluate_cast(expr);
3101 case EXPR_SIZEOF:
3102 return evaluate_sizeof(expr);
3103 case EXPR_PTRSIZEOF:
3104 return evaluate_ptrsizeof(expr);
3105 case EXPR_ALIGNOF:
3106 return evaluate_alignof(expr);
3107 case EXPR_DEREF:
3108 return evaluate_member_dereference(expr);
3109 case EXPR_CALL:
3110 return evaluate_call(expr);
3111 case EXPR_SELECT:
3112 case EXPR_CONDITIONAL:
3113 return evaluate_conditional_expression(expr);
3114 case EXPR_STATEMENT:
3115 expr->ctype = evaluate_statement(expr->statement);
3116 return expr->ctype;
3117
3118 case EXPR_LABEL:
3119 expr->ctype = &ptr_ctype;
3120 return &ptr_ctype;
3121
3122 case EXPR_TYPE:
3123 /* Evaluate the type of the symbol .. */
3124 evaluate_symbol(expr->symbol);
3125 /* .. but the type of the _expression_ is a "type" */
3126 expr->ctype = &type_ctype;
3127 return &type_ctype;
3128
3129 case EXPR_OFFSETOF:
3130 return evaluate_offsetof(expr);
3131
3132 /* These can not exist as stand-alone expressions */
3133 case EXPR_INITIALIZER:
3134 case EXPR_IDENTIFIER:
3135 case EXPR_INDEX:
3136 case EXPR_POS:
3137 expression_error(expr, "internal front-end error: initializer in expression");
3138 return NULL;
3139 case EXPR_SLICE:
3140 expression_error(expr, "internal front-end error: SLICE re-evaluated");
3141 return NULL;
3142 }
3143 return NULL;
3144 }
3145
3146 static void check_duplicates(struct symbol *sym)
3147 {
3148 int declared = 0;
3149 struct symbol *next = sym;
3150 int initialized = sym->initializer != NULL;
3151
3152 while ((next = next->same_symbol) != NULL) {
3153 const char *typediff;
3154 evaluate_symbol(next);
3155 if (initialized && next->initializer) {
3156 sparse_error(sym->pos, "symbol '%s' has multiple initializers (originally initialized at %s:%d)",
3157 show_ident(sym->ident),
3158 stream_name(next->pos.stream), next->pos.line);
3159 /* Only warn once */
3160 initialized = 0;
3161 }
3162 declared++;
3163 typediff = type_difference(&sym->ctype, &next->ctype, 0, 0);
3164 if (typediff) {
3165 sparse_error(sym->pos, "symbol '%s' redeclared with different type (originally declared at %s:%d) - %s",
3166 show_ident(sym->ident),
3167 stream_name(next->pos.stream), next->pos.line, typediff);
3168 return;
3169 }
3170 }
3171 if (!declared) {
3172 unsigned long mod = sym->ctype.modifiers;
3173 if (mod & (MOD_STATIC | MOD_REGISTER))
3174 return;
3175 if (!(mod & MOD_TOPLEVEL))
3176 return;
3177 if (!Wdecl)
3178 return;
3179 if (sym->ident == &main_ident)
3180 return;
3181 warning(sym->pos, "symbol '%s' was not declared. Should it be static?", show_ident(sym->ident));
3182 }
3183 }
3184
3185 static struct symbol *evaluate_symbol(struct symbol *sym)
3186 {
3187 struct symbol *base_type;
3188
3189 if (!sym)
3190 return sym;
3191 if (sym->evaluated)
3192 return sym;
3193 sym->evaluated = 1;
3194
3195 sym = examine_symbol_type(sym);
3196 base_type = get_base_type(sym);
3197 if (!base_type)
3198 return NULL;
3199
3200 /* Evaluate the initializers */
3201 if (sym->initializer)
3202 evaluate_initializer(sym, &sym->initializer);
3203
3204 /* And finally, evaluate the body of the symbol too */
3205 if (base_type->type == SYM_FN) {
3206 struct symbol *curr = current_fn;
3207
3208 if (sym->definition && sym->definition != sym)
3209 return evaluate_symbol(sym->definition);
3210
3211 current_fn = base_type;
3212
3213 examine_fn_arguments(base_type);
3214 if (!base_type->stmt && base_type->inline_stmt)
3215 uninline(sym);
3216 if (base_type->stmt)
3217 evaluate_statement(base_type->stmt);
3218
3219 current_fn = curr;
3220 }
3221
3222 return base_type;
3223 }
3224
3225 void evaluate_symbol_list(struct symbol_list *list)
3226 {
3227 struct symbol *sym;
3228
3229 FOR_EACH_PTR(list, sym) {
3230 evaluate_symbol(sym);
3231 check_duplicates(sym);
3232 } END_FOR_EACH_PTR(sym);
3233 }
3234
3235 static struct symbol *evaluate_return_expression(struct statement *stmt)
3236 {
3237 struct expression *expr = stmt->expression;
3238 struct symbol *fntype;
3239
3240 evaluate_expression(expr);
3241 fntype = current_fn->ctype.base_type;
3242 if (!fntype || fntype == &void_ctype) {
3243 if (expr && expr->ctype != &void_ctype)
3244 expression_error(expr, "return expression in %s function", fntype?"void":"typeless");
3245 if (expr && Wreturn_void)
3246 warning(stmt->pos, "returning void-valued expression");
3247 return NULL;
3248 }
3249
3250 if (!expr) {
3251 sparse_error(stmt->pos, "return with no return value");
3252 return NULL;
3253 }
3254 if (!expr->ctype)
3255 return NULL;
3256 compatible_assignment_types(expr, fntype, &stmt->expression, "return expression");
3257 return NULL;
3258 }
3259
3260 static void evaluate_if_statement(struct statement *stmt)
3261 {
3262 if (!stmt->if_conditional)
3263 return;
3264
3265 evaluate_conditional(stmt->if_conditional, 0);
3266 evaluate_statement(stmt->if_true);
3267 evaluate_statement(stmt->if_false);
3268 }
3269
3270 static void evaluate_iterator(struct statement *stmt)
3271 {
3272 evaluate_symbol_list(stmt->iterator_syms);
3273 evaluate_conditional(stmt->iterator_pre_condition, 1);
3274 evaluate_conditional(stmt->iterator_post_condition,1);
3275 evaluate_statement(stmt->iterator_pre_statement);
3276 evaluate_statement(stmt->iterator_statement);
3277 evaluate_statement(stmt->iterator_post_statement);
3278 }
3279
3280 static void verify_output_constraint(struct expression *expr, const char *constraint)
3281 {
3282 switch (*constraint) {
3283 case '=': /* Assignment */
3284 case '+': /* Update */
3285 break;
3286 default:
3287 expression_error(expr, "output constraint is not an assignment constraint (\"%s\")", constraint);
3288 }
3289 }
3290
3291 static void verify_input_constraint(struct expression *expr, const char *constraint)
3292 {
3293 switch (*constraint) {
3294 case '=': /* Assignment */
3295 case '+': /* Update */
3296 expression_error(expr, "input constraint with assignment (\"%s\")", constraint);
3297 }
3298 }
3299
3300 static void evaluate_asm_statement(struct statement *stmt)
3301 {
3302 struct expression *expr;
3303 struct symbol *sym;
3304 int state;
3305
3306 expr = stmt->asm_string;
3307 if (!expr || expr->type != EXPR_STRING) {
3308 sparse_error(stmt->pos, "need constant string for inline asm");
3309 return;
3310 }
3311
3312 state = 0;
3313 FOR_EACH_PTR(stmt->asm_outputs, expr) {
3314 switch (state) {
3315 case 0: /* Identifier */
3316 state = 1;
3317 continue;
3318
3319 case 1: /* Constraint */
3320 state = 2;
3321 if (!expr || expr->type != EXPR_STRING) {
3322 sparse_error(expr ? expr->pos : stmt->pos, "asm output constraint is not a string");
3323 *THIS_ADDRESS(expr) = NULL;
3324 continue;
3325 }
3326 verify_output_constraint(expr, expr->string->data);
3327 continue;
3328
3329 case 2: /* Expression */
3330 state = 0;
3331 if (!evaluate_expression(expr))
3332 return;
3333 if (!lvalue_expression(expr))
3334 warning(expr->pos, "asm output is not an lvalue");
3335 evaluate_assign_to(expr, expr->ctype);
3336 continue;
3337 }
3338 } END_FOR_EACH_PTR(expr);
3339
3340 state = 0;
3341 FOR_EACH_PTR(stmt->asm_inputs, expr) {
3342 switch (state) {
3343 case 0: /* Identifier */
3344 state = 1;
3345 continue;
3346
3347 case 1: /* Constraint */
3348 state = 2;
3349 if (!expr || expr->type != EXPR_STRING) {
3350 sparse_error(expr ? expr->pos : stmt->pos, "asm input constraint is not a string");
3351 *THIS_ADDRESS(expr) = NULL;
3352 continue;
3353 }
3354 verify_input_constraint(expr, expr->string->data);
3355 continue;
3356
3357 case 2: /* Expression */
3358 state = 0;
3359 if (!evaluate_expression(expr))
3360 return;
3361 continue;
3362 }
3363 } END_FOR_EACH_PTR(expr);
3364
3365 FOR_EACH_PTR(stmt->asm_clobbers, expr) {
3366 if (!expr) {
3367 sparse_error(stmt->pos, "bad asm clobbers");
3368 return;
3369 }
3370 if (expr->type == EXPR_STRING)
3371 continue;
3372 expression_error(expr, "asm clobber is not a string");
3373 } END_FOR_EACH_PTR(expr);
3374
3375 FOR_EACH_PTR(stmt->asm_labels, sym) {
3376 if (!sym || sym->type != SYM_LABEL) {
3377 sparse_error(stmt->pos, "bad asm label");
3378 return;
3379 }
3380 } END_FOR_EACH_PTR(sym);
3381 }
3382
3383 static void evaluate_case_statement(struct statement *stmt)
3384 {
3385 evaluate_expression(stmt->case_expression);
3386 evaluate_expression(stmt->case_to);
3387 evaluate_statement(stmt->case_statement);
3388 }
3389
3390 static void check_case_type(struct expression *switch_expr,
3391 struct expression *case_expr,
3392 struct expression **enumcase)
3393 {
3394 struct symbol *switch_type, *case_type;
3395 int sclass, cclass;
3396
3397 if (!case_expr)
3398 return;
3399
3400 switch_type = switch_expr->ctype;
3401 case_type = evaluate_expression(case_expr);
3402
3403 if (!switch_type || !case_type)
3404 goto Bad;
3405 if (enumcase) {
3406 if (*enumcase)
3407 warn_for_different_enum_types(case_expr->pos, case_type, (*enumcase)->ctype);
3408 else if (is_enum_type(case_type))
3409 *enumcase = case_expr;
3410 }
3411
3412 sclass = classify_type(switch_type, &switch_type);
3413 cclass = classify_type(case_type, &case_type);
3414
3415 /* both should be arithmetic */
3416 if (!(sclass & cclass & TYPE_NUM))
3417 goto Bad;
3418
3419 /* neither should be floating */
3420 if ((sclass | cclass) & TYPE_FLOAT)
3421 goto Bad;
3422
3423 /* if neither is restricted, we are OK */
3424 if (!((sclass | cclass) & TYPE_RESTRICT))
3425 return;
3426
3427 if (!restricted_binop_type(SPECIAL_EQUAL, case_expr, switch_expr,
3428 cclass, sclass, case_type, switch_type)) {
3429 unrestrict(case_expr, cclass, &case_type);
3430 unrestrict(switch_expr, sclass, &switch_type);
3431 }
3432 return;
3433
3434 Bad:
3435 expression_error(case_expr, "incompatible types for 'case' statement");
3436 }
3437
3438 static void evaluate_switch_statement(struct statement *stmt)
3439 {
3440 struct symbol *sym;
3441 struct expression *enumcase = NULL;
3442 struct expression **enumcase_holder = &enumcase;
3443 struct expression *sel = stmt->switch_expression;
3444
3445 evaluate_expression(sel);
3446 evaluate_statement(stmt->switch_statement);
3447 if (!sel)
3448 return;
3449 if (sel->ctype && is_enum_type(sel->ctype))
3450 enumcase_holder = NULL; /* Only check cases against switch */
3451
3452 FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
3453 struct statement *case_stmt = sym->stmt;
3454 check_case_type(sel, case_stmt->case_expression, enumcase_holder);
3455 check_case_type(sel, case_stmt->case_to, enumcase_holder);
3456 } END_FOR_EACH_PTR(sym);
3457 }
3458
3459 static void evaluate_goto_statement(struct statement *stmt)
3460 {
3461 struct symbol *label = stmt->goto_label;
3462
3463 if (label && !label->stmt && !lookup_keyword(label->ident, NS_KEYWORD))
3464 sparse_error(stmt->pos, "label '%s' was not declared", show_ident(label->ident));
3465
3466 evaluate_expression(stmt->goto_expression);
3467 }
3468
3469 struct symbol *evaluate_statement(struct statement *stmt)
3470 {
3471 if (!stmt)
3472 return NULL;
3473
3474 switch (stmt->type) {
3475 case STMT_DECLARATION: {
3476 struct symbol *s;
3477 FOR_EACH_PTR(stmt->declaration, s) {
3478 evaluate_symbol(s);
3479 } END_FOR_EACH_PTR(s);
3480 return NULL;
3481 }
3482
3483 case STMT_RETURN:
3484 return evaluate_return_expression(stmt);
3485
3486 case STMT_EXPRESSION:
3487 if (!evaluate_expression(stmt->expression))
3488 return NULL;
3489 if (stmt->expression->ctype == &null_ctype)
3490 stmt->expression = cast_to(stmt->expression, &ptr_ctype);
3491 return degenerate(stmt->expression);
3492
3493 case STMT_COMPOUND: {
3494 struct statement *s;
3495 struct symbol *type = NULL;
3496
3497 /* Evaluate the return symbol in the compound statement */
3498 evaluate_symbol(stmt->ret);
3499
3500 /*
3501 * Then, evaluate each statement, making the type of the
3502 * compound statement be the type of the last statement
3503 */
3504 type = evaluate_statement(stmt->args);
3505 FOR_EACH_PTR(stmt->stmts, s) {
3506 type = evaluate_statement(s);
3507 } END_FOR_EACH_PTR(s);
3508 if (!type)
3509 type = &void_ctype;
3510 return type;
3511 }
3512 case STMT_IF:
3513 evaluate_if_statement(stmt);
3514 return NULL;
3515 case STMT_ITERATOR:
3516 evaluate_iterator(stmt);
3517 return NULL;
3518 case STMT_SWITCH:
3519 evaluate_switch_statement(stmt);
3520 return NULL;
3521 case STMT_CASE:
3522 evaluate_case_statement(stmt);
3523 return NULL;
3524 case STMT_LABEL:
3525 return evaluate_statement(stmt->label_statement);
3526 case STMT_GOTO:
3527 evaluate_goto_statement(stmt);
3528 return NULL;
3529 case STMT_NONE:
3530 break;
3531 case STMT_ASM:
3532 evaluate_asm_statement(stmt);
3533 return NULL;
3534 case STMT_CONTEXT:
3535 evaluate_expression(stmt->expression);
3536 return NULL;
3537 case STMT_RANGE:
3538 evaluate_expression(stmt->range_expression);
3539 evaluate_expression(stmt->range_low);
3540 evaluate_expression(stmt->range_high);
3541 return NULL;
3542 }
3543 return NULL;
3544 }
Static analysis for C