4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
7 * Licensed under the Open Software License version 1.1
9 * Evaluate constant expressions.
27 #include "expression.h"
29 struct symbol
*current_fn
;
31 static struct symbol
*degenerate(struct expression
*expr
);
32 static struct symbol
*evaluate_symbol(struct symbol
*sym
);
34 static struct symbol
*evaluate_symbol_expression(struct expression
*expr
)
36 struct expression
*addr
;
37 struct symbol
*sym
= expr
->symbol
;
38 struct symbol
*base_type
;
41 expression_error(expr
, "undefined identifier '%s'", show_ident(expr
->symbol_name
));
45 examine_symbol_type(sym
);
47 base_type
= get_base_type(sym
);
49 expression_error(expr
, "identifier '%s' has no type", show_ident(expr
->symbol_name
));
53 addr
= alloc_expression(expr
->pos
, EXPR_SYMBOL
);
55 addr
->symbol_name
= expr
->symbol_name
;
56 addr
->ctype
= &lazy_ptr_ctype
; /* Lazy evaluation: we need to do a proper job if somebody does &sym */
57 expr
->type
= EXPR_PREOP
;
61 /* The type of a symbol is the symbol itself! */
66 static struct symbol
*evaluate_string(struct expression
*expr
)
68 struct symbol
*sym
= alloc_symbol(expr
->pos
, SYM_NODE
);
69 struct symbol
*array
= alloc_symbol(expr
->pos
, SYM_ARRAY
);
70 struct expression
*addr
= alloc_expression(expr
->pos
, EXPR_SYMBOL
);
71 struct expression
*initstr
= alloc_expression(expr
->pos
, EXPR_STRING
);
72 unsigned int length
= expr
->string
->length
;
74 sym
->array_size
= alloc_const_expression(expr
->pos
, length
);
75 sym
->bit_size
= bytes_to_bits(length
);
76 sym
->ctype
.alignment
= 1;
78 sym
->ctype
.modifiers
= MOD_STATIC
;
79 sym
->ctype
.base_type
= array
;
80 sym
->initializer
= initstr
;
83 initstr
->string
= expr
->string
;
85 array
->array_size
= sym
->array_size
;
86 array
->bit_size
= bytes_to_bits(length
);
87 array
->ctype
.alignment
= 1;
88 array
->ctype
.modifiers
= MOD_STATIC
;
89 array
->ctype
.base_type
= &char_ctype
;
92 addr
->ctype
= &lazy_ptr_ctype
;
94 expr
->type
= EXPR_PREOP
;
101 /* type has come from classify_type and is an integer type */
102 static inline struct symbol
*integer_promotion(struct symbol
*type
)
104 struct symbol
*orig_type
= type
;
105 unsigned long mod
= type
->ctype
.modifiers
;
106 int width
= type
->bit_size
;
109 * Bitfields always promote to the base type,
110 * even if the bitfield might be bigger than
113 if (type
->type
== SYM_BITFIELD
) {
114 type
= type
->ctype
.base_type
;
117 mod
= type
->ctype
.modifiers
;
118 if (width
< bits_in_int
)
121 /* If char/short has as many bits as int, it still gets "promoted" */
122 if (mod
& (MOD_CHAR
| MOD_SHORT
)) {
123 if (mod
& MOD_UNSIGNED
)
131 * integer part of usual arithmetic conversions:
132 * integer promotions are applied
133 * if left and right are identical, we are done
134 * if signedness is the same, convert one with lower rank
135 * unless unsigned argument has rank lower than signed one, convert the
137 * if signed argument is bigger than unsigned one, convert the unsigned.
138 * otherwise, convert signed.
140 * Leaving aside the integer promotions, that is equivalent to
141 * if identical, don't convert
142 * if left is bigger than right, convert right
143 * if right is bigger than left, convert right
144 * otherwise, if signedness is the same, convert one with lower rank
145 * otherwise convert the signed one.
147 static struct symbol
*bigger_int_type(struct symbol
*left
, struct symbol
*right
)
149 unsigned long lmod
, rmod
;
151 left
= integer_promotion(left
);
152 right
= integer_promotion(right
);
157 if (left
->bit_size
> right
->bit_size
)
160 if (right
->bit_size
> left
->bit_size
)
163 lmod
= left
->ctype
.modifiers
;
164 rmod
= right
->ctype
.modifiers
;
165 if ((lmod
^ rmod
) & MOD_UNSIGNED
) {
166 if (lmod
& MOD_UNSIGNED
)
168 } else if ((lmod
& ~rmod
) & (MOD_LONG
| MOD_LONGLONG
))
176 static int same_cast_type(struct symbol
*orig
, struct symbol
*new)
178 return orig
->bit_size
== new->bit_size
&& orig
->bit_offset
== new->bit_offset
;
181 static struct symbol
*base_type(struct symbol
*node
, unsigned long *modp
, unsigned long *asp
)
183 unsigned long mod
, as
;
187 mod
|= node
->ctype
.modifiers
;
188 as
|= node
->ctype
.as
;
189 if (node
->type
== SYM_NODE
) {
190 node
= node
->ctype
.base_type
;
195 *modp
= mod
& ~MOD_IGNORE
;
200 static int is_same_type(struct expression
*expr
, struct symbol
*new)
202 struct symbol
*old
= expr
->ctype
;
203 unsigned long oldmod
, newmod
, oldas
, newas
;
205 old
= base_type(old
, &oldmod
, &oldas
);
206 new = base_type(new, &newmod
, &newas
);
208 /* Same base type, same address space? */
209 if (old
== new && oldas
== newas
) {
210 unsigned long difmod
;
212 /* Check the modifier bits. */
213 difmod
= (oldmod
^ newmod
) & ~MOD_NOCAST
;
215 /* Exact same type? */
220 * Not the same type, but differs only in "const".
221 * Don't warn about MOD_NOCAST.
223 if (difmod
== MOD_CONST
)
226 if ((oldmod
| newmod
) & MOD_NOCAST
) {
227 const char *tofrom
= "to/from";
228 if (!(newmod
& MOD_NOCAST
))
230 if (!(oldmod
& MOD_NOCAST
))
232 warning(expr
->pos
, "implicit cast %s nocast type", tofrom
);
238 warn_for_different_enum_types (struct position pos
,
239 struct symbol
*typea
,
240 struct symbol
*typeb
)
244 if (typea
->type
== SYM_NODE
)
245 typea
= typea
->ctype
.base_type
;
246 if (typeb
->type
== SYM_NODE
)
247 typeb
= typeb
->ctype
.base_type
;
252 if (typea
->type
== SYM_ENUM
&& typeb
->type
== SYM_ENUM
) {
253 warning(pos
, "mixing different enum types");
254 info(pos
, " %s versus", show_typename(typea
));
255 info(pos
, " %s", show_typename(typeb
));
260 * This gets called for implicit casts in assignments and
261 * integer promotion. We often want to try to move the
262 * cast down, because the ops involved may have been
263 * implicitly cast up, and we can get rid of the casts
266 static struct expression
* cast_to(struct expression
*old
, struct symbol
*type
)
268 struct expression
*expr
;
270 warn_for_different_enum_types (old
->pos
, old
->ctype
, type
);
272 if (old
->ctype
!= &null_ctype
&& is_same_type(old
, type
))
276 * See if we can simplify the op. Move the cast down.
280 if (old
->ctype
->bit_size
< type
->bit_size
)
282 if (old
->op
== '~') {
284 old
->unop
= cast_to(old
->unop
, type
);
289 case EXPR_IMPLIED_CAST
:
290 warn_for_different_enum_types(old
->pos
, old
->ctype
, type
);
292 if (old
->ctype
->bit_size
>= type
->bit_size
) {
293 struct expression
*orig
= old
->cast_expression
;
294 if (same_cast_type(orig
->ctype
, type
))
296 if (old
->ctype
->bit_offset
== type
->bit_offset
) {
298 old
->cast_type
= type
;
308 expr
= alloc_expression(old
->pos
, EXPR_IMPLIED_CAST
);
309 expr
->flags
= old
->flags
;
311 expr
->cast_type
= type
;
312 expr
->cast_expression
= old
;
327 static inline int classify_type(struct symbol
*type
, struct symbol
**base
)
329 static int type_class
[SYM_BAD
+ 1] = {
330 [SYM_PTR
] = TYPE_PTR
,
331 [SYM_FN
] = TYPE_PTR
| TYPE_FN
,
332 [SYM_ARRAY
] = TYPE_PTR
| TYPE_COMPOUND
,
333 [SYM_STRUCT
] = TYPE_COMPOUND
,
334 [SYM_UNION
] = TYPE_COMPOUND
,
335 [SYM_BITFIELD
] = TYPE_NUM
| TYPE_BITFIELD
,
336 [SYM_RESTRICT
] = TYPE_NUM
| TYPE_RESTRICT
,
337 [SYM_FOULED
] = TYPE_NUM
| TYPE_RESTRICT
| TYPE_FOULED
,
339 if (type
->type
== SYM_NODE
)
340 type
= type
->ctype
.base_type
;
341 if (type
->type
== SYM_TYPEOF
) {
342 type
= evaluate_expression(type
->initializer
);
343 if (type
->type
== SYM_NODE
)
344 type
= type
->ctype
.base_type
;
346 if (type
->type
== SYM_ENUM
)
347 type
= type
->ctype
.base_type
;
349 if (type
->type
== SYM_BASETYPE
) {
350 if (type
->ctype
.base_type
== &int_type
)
352 if (type
->ctype
.base_type
== &fp_type
)
353 return TYPE_NUM
| TYPE_FLOAT
;
355 return type_class
[type
->type
];
358 #define is_int(class) ((class & (TYPE_NUM | TYPE_FLOAT)) == TYPE_NUM)
360 static inline int is_string_type(struct symbol
*type
)
362 if (type
->type
== SYM_NODE
)
363 type
= type
->ctype
.base_type
;
364 return type
->type
== SYM_ARRAY
&& is_byte_type(type
->ctype
.base_type
);
367 static struct symbol
*bad_expr_type(struct expression
*expr
)
369 sparse_error(expr
->pos
, "incompatible types for operation (%s)", show_special(expr
->op
));
370 switch (expr
->type
) {
373 info(expr
->pos
, " left side has type %s", show_typename(expr
->left
->ctype
));
374 info(expr
->pos
, " right side has type %s", show_typename(expr
->right
->ctype
));
378 info(expr
->pos
, " argument has type %s", show_typename(expr
->unop
->ctype
));
385 return expr
->ctype
= &bad_ctype
;
388 static int restricted_value(struct expression
*v
, struct symbol
*type
)
390 if (v
->type
!= EXPR_VALUE
)
397 static int restricted_binop(int op
, struct symbol
*type
)
402 case SPECIAL_AND_ASSIGN
:
403 case SPECIAL_OR_ASSIGN
:
404 case SPECIAL_XOR_ASSIGN
:
405 return 1; /* unfoul */
409 return 2; /* keep fouled */
411 case SPECIAL_NOTEQUAL
:
412 return 3; /* warn if fouled */
418 static int restricted_unop(int op
, struct symbol
**type
)
421 if ((*type
)->bit_size
< bits_in_int
)
422 *type
= befoul(*type
);
429 /* type should be SYM_FOULED */
430 static inline struct symbol
*unfoul(struct symbol
*type
)
432 return type
->ctype
.base_type
;
435 static struct symbol
*restricted_binop_type(int op
,
436 struct expression
*left
,
437 struct expression
*right
,
438 int lclass
, int rclass
,
439 struct symbol
*ltype
,
440 struct symbol
*rtype
)
442 struct symbol
*ctype
= NULL
;
443 if (lclass
& TYPE_RESTRICT
) {
444 if (rclass
& TYPE_RESTRICT
) {
445 if (ltype
== rtype
) {
447 } else if (lclass
& TYPE_FOULED
) {
448 if (unfoul(ltype
) == rtype
)
450 } else if (rclass
& TYPE_FOULED
) {
451 if (unfoul(rtype
) == ltype
)
455 if (!restricted_value(right
, ltype
))
458 } else if (!restricted_value(left
, rtype
))
462 switch (restricted_binop(op
, ctype
)) {
464 if ((lclass
^ rclass
) & TYPE_FOULED
)
465 ctype
= unfoul(ctype
);
468 if (!(lclass
& rclass
& TYPE_FOULED
))
480 static inline void unrestrict(struct expression
*expr
,
481 int class, struct symbol
**ctype
)
483 if (class & TYPE_RESTRICT
) {
484 if (class & TYPE_FOULED
)
485 *ctype
= unfoul(*ctype
);
486 warning(expr
->pos
, "%s degrades to integer",
487 show_typename(*ctype
));
488 *ctype
= (*ctype
)->ctype
.base_type
; /* get to arithmetic type */
492 static struct symbol
*usual_conversions(int op
,
493 struct expression
*left
,
494 struct expression
*right
,
495 int lclass
, int rclass
,
496 struct symbol
*ltype
,
497 struct symbol
*rtype
)
499 struct symbol
*ctype
;
501 warn_for_different_enum_types(right
->pos
, left
->ctype
, right
->ctype
);
503 if ((lclass
| rclass
) & TYPE_RESTRICT
)
507 if (!(lclass
& TYPE_FLOAT
)) {
508 if (!(rclass
& TYPE_FLOAT
))
509 return bigger_int_type(ltype
, rtype
);
512 } else if (rclass
& TYPE_FLOAT
) {
513 unsigned long lmod
= ltype
->ctype
.modifiers
;
514 unsigned long rmod
= rtype
->ctype
.modifiers
;
515 if (rmod
& ~lmod
& (MOD_LONG
| MOD_LONGLONG
))
523 ctype
= restricted_binop_type(op
, left
, right
,
524 lclass
, rclass
, ltype
, rtype
);
528 unrestrict(left
, lclass
, <ype
);
529 unrestrict(right
, rclass
, &rtype
);
534 static inline int lvalue_expression(struct expression
*expr
)
536 return expr
->type
== EXPR_PREOP
&& expr
->op
== '*';
539 static inline int is_function(struct symbol
*type
)
541 return type
&& type
->type
== SYM_FN
;
544 static struct symbol
*evaluate_ptr_add(struct expression
*expr
, struct symbol
*itype
)
546 struct expression
*index
= expr
->right
;
547 struct symbol
*ctype
, *base
;
550 classify_type(degenerate(expr
->left
), &ctype
);
551 base
= examine_pointer_target(ctype
);
554 expression_error(expr
, "missing type information");
557 if (is_function(base
)) {
558 expression_error(expr
, "arithmetics on pointers to functions");
562 /* Get the size of whatever the pointer points to */
563 multiply
= is_void_type(base
) ? 1 : bits_to_bytes(base
->bit_size
);
565 if (ctype
== &null_ctype
)
569 if (multiply
== 1 && itype
->bit_size
>= bits_in_pointer
)
572 if (index
->type
== EXPR_VALUE
) {
573 struct expression
*val
= alloc_expression(expr
->pos
, EXPR_VALUE
);
574 unsigned long long v
= index
->value
, mask
;
575 mask
= 1ULL << (itype
->bit_size
- 1);
581 mask
= 1ULL << (bits_in_pointer
- 1);
582 v
&= mask
| (mask
- 1);
584 val
->ctype
= ssize_t_ctype
;
589 if (itype
->bit_size
< bits_in_pointer
)
590 index
= cast_to(index
, ssize_t_ctype
);
593 struct expression
*val
= alloc_expression(expr
->pos
, EXPR_VALUE
);
594 struct expression
*mul
= alloc_expression(expr
->pos
, EXPR_BINOP
);
596 val
->ctype
= ssize_t_ctype
;
597 val
->value
= multiply
;
600 mul
->ctype
= ssize_t_ctype
;
610 static void examine_fn_arguments(struct symbol
*fn
);
612 #define MOD_IGN (MOD_VOLATILE | MOD_CONST)
614 const char *type_difference(struct ctype
*c1
, struct ctype
*c2
,
615 unsigned long mod1
, unsigned long mod2
)
617 unsigned long as1
= c1
->as
, as2
= c2
->as
;
618 struct symbol
*t1
= c1
->base_type
;
619 struct symbol
*t2
= c2
->base_type
;
620 int move1
= 1, move2
= 1;
621 mod1
|= c1
->modifiers
;
622 mod2
|= c2
->modifiers
;
626 struct symbol
*base1
= t1
->ctype
.base_type
;
627 struct symbol
*base2
= t2
->ctype
.base_type
;
630 * FIXME! Collect alignment and context too here!
633 if (t1
&& t1
->type
!= SYM_PTR
) {
634 mod1
|= t1
->ctype
.modifiers
;
641 if (t2
&& t2
->type
!= SYM_PTR
) {
642 mod2
|= t2
->ctype
.modifiers
;
651 return "different types";
653 if (t1
->type
== SYM_NODE
|| t1
->type
== SYM_ENUM
) {
661 if (t2
->type
== SYM_NODE
|| t2
->type
== SYM_ENUM
) {
671 if (type
!= t2
->type
)
672 return "different base types";
676 sparse_error(t1
->pos
,
677 "internal error: bad type in derived(%d)",
681 return "different base types";
684 /* allow definition of incomplete structs and unions */
685 if (t1
->ident
== t2
->ident
)
687 return "different base types";
689 /* XXX: we ought to compare sizes */
692 if (Waddress_space
&& as1
!= as2
)
693 return "different address spaces";
694 /* MOD_SPECIFIER is due to idiocy in parse.c */
695 if ((mod1
^ mod2
) & ~MOD_IGNORE
& ~MOD_SPECIFIER
)
696 return "different modifiers";
697 /* we could be lazier here */
698 base1
= examine_pointer_target(t1
);
699 base2
= examine_pointer_target(t2
);
700 mod1
= t1
->ctype
.modifiers
;
702 mod2
= t2
->ctype
.modifiers
;
706 struct symbol
*arg1
, *arg2
;
709 if (Waddress_space
&& as1
!= as2
)
710 return "different address spaces";
711 if ((mod1
^ mod2
) & ~MOD_IGNORE
& ~MOD_SIGNEDNESS
)
712 return "different modifiers";
713 mod1
= t1
->ctype
.modifiers
;
715 mod2
= t2
->ctype
.modifiers
;
718 if (base1
->variadic
!= base2
->variadic
)
719 return "incompatible variadic arguments";
720 examine_fn_arguments(t1
);
721 examine_fn_arguments(t2
);
722 PREPARE_PTR_LIST(t1
->arguments
, arg1
);
723 PREPARE_PTR_LIST(t2
->arguments
, arg2
);
730 return "different argument counts";
731 diffstr
= type_difference(&arg1
->ctype
,
735 static char argdiff
[80];
736 sprintf(argdiff
, "incompatible argument %d (%s)", i
, diffstr
);
743 FINISH_PTR_LIST(arg2
);
744 FINISH_PTR_LIST(arg1
);
748 if (Waddress_space
&& as1
!= as2
)
749 return "different address spaces";
751 return "different base types";
752 diff
= (mod1
^ mod2
) & ~MOD_IGNORE
;
756 return "different type sizes";
757 else if (diff
& ~MOD_SIGNEDNESS
)
758 return "different modifiers";
760 return "different signedness";
765 if (Waddress_space
&& as1
!= as2
)
766 return "different address spaces";
767 if ((mod1
^ mod2
) & ~MOD_IGNORE
& ~MOD_SIGNEDNESS
)
768 return "different modifiers";
772 static void bad_null(struct expression
*expr
)
774 if (Wnon_pointer_null
)
775 warning(expr
->pos
, "Using plain integer as NULL pointer");
778 static unsigned long target_qualifiers(struct symbol
*type
)
780 unsigned long mod
= type
->ctype
.modifiers
& MOD_IGN
;
781 if (type
->ctype
.base_type
&& type
->ctype
.base_type
->type
== SYM_ARRAY
)
786 static struct symbol
*evaluate_ptr_sub(struct expression
*expr
)
788 const char *typediff
;
789 struct symbol
*ltype
, *rtype
;
790 struct expression
*l
= expr
->left
;
791 struct expression
*r
= expr
->right
;
792 struct symbol
*lbase
, *rbase
;
794 classify_type(degenerate(l
), <ype
);
795 classify_type(degenerate(r
), &rtype
);
797 lbase
= examine_pointer_target(ltype
);
798 rbase
= examine_pointer_target(rtype
);
799 typediff
= type_difference(<ype
->ctype
, &rtype
->ctype
,
800 target_qualifiers(rtype
),
801 target_qualifiers(ltype
));
803 expression_error(expr
, "subtraction of different types can't work (%s)", typediff
);
805 if (is_function(lbase
)) {
806 expression_error(expr
, "subtraction of functions? Share your drugs");
810 expr
->ctype
= ssize_t_ctype
;
811 if (lbase
->bit_size
> bits_in_char
) {
812 struct expression
*sub
= alloc_expression(expr
->pos
, EXPR_BINOP
);
813 struct expression
*div
= expr
;
814 struct expression
*val
= alloc_expression(expr
->pos
, EXPR_VALUE
);
815 unsigned long value
= bits_to_bytes(lbase
->bit_size
);
817 val
->ctype
= size_t_ctype
;
820 if (value
& (value
-1)) {
821 if (Wptr_subtraction_blows
)
822 warning(expr
->pos
, "potentially expensive pointer subtraction");
826 sub
->ctype
= ssize_t_ctype
;
835 return ssize_t_ctype
;
838 #define is_safe_type(type) ((type)->ctype.modifiers & MOD_SAFE)
840 static struct symbol
*evaluate_conditional(struct expression
*expr
, int iterator
)
842 struct symbol
*ctype
;
847 if (!iterator
&& expr
->type
== EXPR_ASSIGNMENT
&& expr
->op
== '=')
848 warning(expr
->pos
, "assignment expression in conditional");
850 ctype
= evaluate_expression(expr
);
852 if (is_safe_type(ctype
))
853 warning(expr
->pos
, "testing a 'safe expression'");
859 static struct symbol
*evaluate_logical(struct expression
*expr
)
861 if (!evaluate_conditional(expr
->left
, 0))
863 if (!evaluate_conditional(expr
->right
, 0))
866 expr
->ctype
= &bool_ctype
;
868 if (!(expr
->left
->flags
& expr
->right
->flags
& Int_const_expr
))
874 static struct symbol
*evaluate_binop(struct expression
*expr
)
876 struct symbol
*ltype
, *rtype
, *ctype
;
877 int lclass
= classify_type(expr
->left
->ctype
, <ype
);
878 int rclass
= classify_type(expr
->right
->ctype
, &rtype
);
882 if (!(expr
->left
->flags
& expr
->right
->flags
& Int_const_expr
))
886 /* number op number */
887 if (lclass
& rclass
& TYPE_NUM
) {
888 if ((lclass
| rclass
) & TYPE_FLOAT
) {
890 case '+': case '-': case '*': case '/':
893 return bad_expr_type(expr
);
897 if (op
== SPECIAL_LEFTSHIFT
|| op
== SPECIAL_RIGHTSHIFT
) {
898 // shifts do integer promotions, but that's it.
899 unrestrict(expr
->left
, lclass
, <ype
);
900 unrestrict(expr
->right
, rclass
, &rtype
);
901 ctype
= ltype
= integer_promotion(ltype
);
902 rtype
= integer_promotion(rtype
);
904 // The rest do usual conversions
905 const unsigned left_not
= expr
->left
->type
== EXPR_PREOP
906 && expr
->left
->op
== '!';
907 const unsigned right_not
= expr
->right
->type
== EXPR_PREOP
908 && expr
->right
->op
== '!';
909 if ((op
== '&' || op
== '|') && (left_not
|| right_not
))
910 warning(expr
->pos
, "dubious: %sx %c %sy",
913 right_not
? "!" : "");
915 ltype
= usual_conversions(op
, expr
->left
, expr
->right
,
916 lclass
, rclass
, ltype
, rtype
);
917 ctype
= rtype
= ltype
;
920 expr
->left
= cast_to(expr
->left
, ltype
);
921 expr
->right
= cast_to(expr
->right
, rtype
);
926 /* pointer (+|-) integer */
927 if (lclass
& TYPE_PTR
&& is_int(rclass
) && (op
== '+' || op
== '-')) {
928 unrestrict(expr
->right
, rclass
, &rtype
);
929 return evaluate_ptr_add(expr
, rtype
);
932 /* integer + pointer */
933 if (rclass
& TYPE_PTR
&& is_int(lclass
) && op
== '+') {
934 struct expression
*index
= expr
->left
;
935 unrestrict(index
, lclass
, <ype
);
936 expr
->left
= expr
->right
;
938 return evaluate_ptr_add(expr
, ltype
);
941 /* pointer - pointer */
942 if (lclass
& rclass
& TYPE_PTR
&& expr
->op
== '-')
943 return evaluate_ptr_sub(expr
);
945 return bad_expr_type(expr
);
948 static struct symbol
*evaluate_comma(struct expression
*expr
)
950 expr
->ctype
= degenerate(expr
->right
);
951 if (expr
->ctype
== &null_ctype
)
952 expr
->ctype
= &ptr_ctype
;
953 expr
->flags
&= expr
->left
->flags
& expr
->right
->flags
;
957 static int modify_for_unsigned(int op
)
960 op
= SPECIAL_UNSIGNED_LT
;
962 op
= SPECIAL_UNSIGNED_GT
;
963 else if (op
== SPECIAL_LTE
)
964 op
= SPECIAL_UNSIGNED_LTE
;
965 else if (op
== SPECIAL_GTE
)
966 op
= SPECIAL_UNSIGNED_GTE
;
970 static inline int is_null_pointer_constant(struct expression
*e
)
972 if (e
->ctype
== &null_ctype
)
974 if (!(e
->flags
& Int_const_expr
))
976 return is_zero_constant(e
) ? 2 : 0;
979 static struct symbol
*evaluate_compare(struct expression
*expr
)
981 struct expression
*left
= expr
->left
, *right
= expr
->right
;
982 struct symbol
*ltype
, *rtype
, *lbase
, *rbase
;
983 int lclass
= classify_type(degenerate(left
), <ype
);
984 int rclass
= classify_type(degenerate(right
), &rtype
);
985 struct symbol
*ctype
;
986 const char *typediff
;
989 if (!(expr
->left
->flags
& expr
->right
->flags
& Int_const_expr
))
994 if (is_type_type(ltype
) && is_type_type(rtype
))
997 if (is_safe_type(left
->ctype
) || is_safe_type(right
->ctype
))
998 warning(expr
->pos
, "testing a 'safe expression'");
1000 /* number on number */
1001 if (lclass
& rclass
& TYPE_NUM
) {
1002 ctype
= usual_conversions(expr
->op
, expr
->left
, expr
->right
,
1003 lclass
, rclass
, ltype
, rtype
);
1004 expr
->left
= cast_to(expr
->left
, ctype
);
1005 expr
->right
= cast_to(expr
->right
, ctype
);
1006 if (ctype
->ctype
.modifiers
& MOD_UNSIGNED
)
1007 expr
->op
= modify_for_unsigned(expr
->op
);
1011 /* at least one must be a pointer */
1012 if (!((lclass
| rclass
) & TYPE_PTR
))
1013 return bad_expr_type(expr
);
1015 /* equality comparisons can be with null pointer constants */
1016 if (expr
->op
== SPECIAL_EQUAL
|| expr
->op
== SPECIAL_NOTEQUAL
) {
1017 int is_null1
= is_null_pointer_constant(left
);
1018 int is_null2
= is_null_pointer_constant(right
);
1023 if (is_null1
&& is_null2
) {
1024 int positive
= expr
->op
== SPECIAL_EQUAL
;
1025 expr
->type
= EXPR_VALUE
;
1026 expr
->value
= positive
;
1029 if (is_null1
&& (rclass
& TYPE_PTR
)) {
1030 left
= cast_to(left
, rtype
);
1033 if (is_null2
&& (lclass
& TYPE_PTR
)) {
1034 right
= cast_to(right
, ltype
);
1038 /* both should be pointers */
1039 if (!(lclass
& rclass
& TYPE_PTR
))
1040 return bad_expr_type(expr
);
1041 expr
->op
= modify_for_unsigned(expr
->op
);
1043 lbase
= examine_pointer_target(ltype
);
1044 rbase
= examine_pointer_target(rtype
);
1046 /* they also have special treatment for pointers to void */
1047 if (expr
->op
== SPECIAL_EQUAL
|| expr
->op
== SPECIAL_NOTEQUAL
) {
1048 if (ltype
->ctype
.as
== rtype
->ctype
.as
) {
1049 if (lbase
== &void_ctype
) {
1050 right
= cast_to(right
, ltype
);
1053 if (rbase
== &void_ctype
) {
1054 left
= cast_to(left
, rtype
);
1060 typediff
= type_difference(<ype
->ctype
, &rtype
->ctype
,
1061 target_qualifiers(rtype
),
1062 target_qualifiers(ltype
));
1066 expression_error(expr
, "incompatible types in comparison expression (%s)", typediff
);
1070 expr
->ctype
= &bool_ctype
;
1075 * NOTE! The degenerate case of "x ? : y", where we don't
1076 * have a true case, this will possibly promote "x" to the
1077 * same type as "y", and thus _change_ the conditional
1078 * test in the expression. But since promotion is "safe"
1079 * for testing, that's OK.
1081 static struct symbol
*evaluate_conditional_expression(struct expression
*expr
)
1083 struct expression
**true;
1084 struct symbol
*ctype
, *ltype
, *rtype
, *lbase
, *rbase
;
1086 const char * typediff
;
1089 if (!evaluate_conditional(expr
->conditional
, 0))
1091 if (!evaluate_expression(expr
->cond_false
))
1094 ctype
= degenerate(expr
->conditional
);
1095 rtype
= degenerate(expr
->cond_false
);
1097 true = &expr
->conditional
;
1099 if (expr
->cond_true
) {
1100 if (!evaluate_expression(expr
->cond_true
))
1102 ltype
= degenerate(expr
->cond_true
);
1103 true = &expr
->cond_true
;
1107 int flags
= expr
->conditional
->flags
& Int_const_expr
;
1108 flags
&= (*true)->flags
& expr
->cond_false
->flags
;
1113 lclass
= classify_type(ltype
, <ype
);
1114 rclass
= classify_type(rtype
, &rtype
);
1115 if (lclass
& rclass
& TYPE_NUM
) {
1116 ctype
= usual_conversions('?', *true, expr
->cond_false
,
1117 lclass
, rclass
, ltype
, rtype
);
1118 *true = cast_to(*true, ctype
);
1119 expr
->cond_false
= cast_to(expr
->cond_false
, ctype
);
1123 if ((lclass
| rclass
) & TYPE_PTR
) {
1124 int is_null1
= is_null_pointer_constant(*true);
1125 int is_null2
= is_null_pointer_constant(expr
->cond_false
);
1127 if (is_null1
&& is_null2
) {
1128 *true = cast_to(*true, &ptr_ctype
);
1129 expr
->cond_false
= cast_to(expr
->cond_false
, &ptr_ctype
);
1133 if (is_null1
&& (rclass
& TYPE_PTR
)) {
1136 *true = cast_to(*true, rtype
);
1140 if (is_null2
&& (lclass
& TYPE_PTR
)) {
1142 bad_null(expr
->cond_false
);
1143 expr
->cond_false
= cast_to(expr
->cond_false
, ltype
);
1147 if (!(lclass
& rclass
& TYPE_PTR
)) {
1148 typediff
= "different types";
1151 /* OK, it's pointer on pointer */
1152 if (ltype
->ctype
.as
!= rtype
->ctype
.as
) {
1153 typediff
= "different address spaces";
1157 /* need to be lazier here */
1158 lbase
= examine_pointer_target(ltype
);
1159 rbase
= examine_pointer_target(rtype
);
1160 qual
= target_qualifiers(ltype
) | target_qualifiers(rtype
);
1162 if (lbase
== &void_ctype
) {
1163 /* XXX: pointers to function should warn here */
1168 if (rbase
== &void_ctype
) {
1169 /* XXX: pointers to function should warn here */
1173 /* XXX: that should be pointer to composite */
1175 typediff
= type_difference(<ype
->ctype
, &rtype
->ctype
,
1182 /* void on void, struct on same struct, union on same union */
1183 if (ltype
== rtype
) {
1187 typediff
= "different base types";
1190 expression_error(expr
, "incompatible types in conditional expression (%s)", typediff
);
1194 expr
->ctype
= ctype
;
1198 if (qual
& ~ctype
->ctype
.modifiers
) {
1199 struct symbol
*sym
= alloc_symbol(ctype
->pos
, SYM_PTR
);
1201 sym
->ctype
.modifiers
|= qual
;
1204 *true = cast_to(*true, ctype
);
1205 expr
->cond_false
= cast_to(expr
->cond_false
, ctype
);
1209 /* FP assignments can not do modulo or bit operations */
1210 static int compatible_float_op(int op
)
1212 return op
== SPECIAL_ADD_ASSIGN
||
1213 op
== SPECIAL_SUB_ASSIGN
||
1214 op
== SPECIAL_MUL_ASSIGN
||
1215 op
== SPECIAL_DIV_ASSIGN
;
1218 static int evaluate_assign_op(struct expression
*expr
)
1220 struct symbol
*target
= expr
->left
->ctype
;
1221 struct symbol
*source
= expr
->right
->ctype
;
1222 struct symbol
*t
, *s
;
1223 int tclass
= classify_type(target
, &t
);
1224 int sclass
= classify_type(source
, &s
);
1227 if (tclass
& sclass
& TYPE_NUM
) {
1228 if (tclass
& TYPE_FLOAT
&& !compatible_float_op(op
)) {
1229 expression_error(expr
, "invalid assignment");
1232 if (tclass
& TYPE_RESTRICT
) {
1233 if (!restricted_binop(op
, t
)) {
1234 warning(expr
->pos
, "bad assignment (%s) to %s",
1235 show_special(op
), show_typename(t
));
1236 expr
->right
= cast_to(expr
->right
, target
);
1239 /* allowed assignments unfoul */
1240 if (sclass
& TYPE_FOULED
&& unfoul(s
) == t
)
1242 if (!restricted_value(expr
->right
, t
))
1244 } else if (!(sclass
& TYPE_RESTRICT
))
1246 /* source and target would better be identical restricted */
1249 warning(expr
->pos
, "invalid assignment: %s", show_special(op
));
1250 info(expr
->pos
, " left side has type %s", show_typename(t
));
1251 info(expr
->pos
, " right side has type %s", show_typename(s
));
1252 expr
->right
= cast_to(expr
->right
, target
);
1255 if (tclass
== TYPE_PTR
&& is_int(sclass
)) {
1256 if (op
== SPECIAL_ADD_ASSIGN
|| op
== SPECIAL_SUB_ASSIGN
) {
1257 unrestrict(expr
->right
, sclass
, &s
);
1258 evaluate_ptr_add(expr
, s
);
1261 expression_error(expr
, "invalid pointer assignment");
1265 expression_error(expr
, "invalid assignment");
1269 expr
->right
= cast_to(expr
->right
, target
);
1273 static int whitelist_pointers(struct symbol
*t1
, struct symbol
*t2
)
1276 return 0; /* yes, 0 - we don't want a cast_to here */
1277 if (t1
== &void_ctype
)
1279 if (t2
== &void_ctype
)
1281 if (classify_type(t1
, &t1
) != TYPE_NUM
)
1283 if (classify_type(t2
, &t2
) != TYPE_NUM
)
1287 if (t1
->ctype
.modifiers
& t2
->ctype
.modifiers
& MOD_CHAR
)
1289 if ((t1
->ctype
.modifiers
^ t2
->ctype
.modifiers
) & MOD_SIZE
)
1294 static int compatible_assignment_types(struct expression
*expr
, struct symbol
*target
,
1295 struct expression
**rp
, const char *where
)
1297 const char *typediff
;
1298 struct symbol
*source
= degenerate(*rp
);
1299 struct symbol
*t
, *s
;
1300 int tclass
= classify_type(target
, &t
);
1301 int sclass
= classify_type(source
, &s
);
1303 if (tclass
& sclass
& TYPE_NUM
) {
1304 if (tclass
& TYPE_RESTRICT
) {
1305 /* allowed assignments unfoul */
1306 if (sclass
& TYPE_FOULED
&& unfoul(s
) == t
)
1308 if (!restricted_value(*rp
, target
))
1312 } else if (!(sclass
& TYPE_RESTRICT
))
1314 typediff
= "different base types";
1318 if (tclass
== TYPE_PTR
) {
1319 unsigned long mod1
, mod2
;
1320 struct symbol
*b1
, *b2
;
1321 // NULL pointer is always OK
1322 int is_null
= is_null_pointer_constant(*rp
);
1328 if (!(sclass
& TYPE_PTR
)) {
1329 typediff
= "different base types";
1332 b1
= examine_pointer_target(t
);
1333 b2
= examine_pointer_target(s
);
1334 mod1
= target_qualifiers(t
);
1335 mod2
= target_qualifiers(s
);
1336 if (whitelist_pointers(b1
, b2
)) {
1338 * assignments to/from void * are OK, provided that
1339 * we do not remove qualifiers from pointed to [C]
1340 * or mix address spaces [sparse].
1342 if (t
->ctype
.as
!= s
->ctype
.as
) {
1343 typediff
= "different address spaces";
1347 typediff
= "different modifiers";
1352 /* It's OK if the target is more volatile or const than the source */
1353 typediff
= type_difference(&t
->ctype
, &s
->ctype
, 0, mod1
);
1359 if ((tclass
& TYPE_COMPOUND
) && s
== t
)
1362 if (tclass
& TYPE_NUM
) {
1363 /* XXX: need to turn into comparison with NULL */
1364 if (t
== &bool_ctype
&& (sclass
& TYPE_PTR
))
1366 typediff
= "different base types";
1369 typediff
= "invalid types";
1372 warning(expr
->pos
, "incorrect type in %s (%s)", where
, typediff
);
1373 info(expr
->pos
, " expected %s", show_typename(target
));
1374 info(expr
->pos
, " got %s", show_typename(source
));
1375 *rp
= cast_to(*rp
, target
);
1378 *rp
= cast_to(*rp
, target
);
1382 static void mark_assigned(struct expression
*expr
)
1388 switch (expr
->type
) {
1393 if (sym
->type
!= SYM_NODE
)
1395 sym
->ctype
.modifiers
|= MOD_ASSIGNED
;
1399 mark_assigned(expr
->left
);
1400 mark_assigned(expr
->right
);
1403 case EXPR_FORCE_CAST
:
1404 mark_assigned(expr
->cast_expression
);
1407 mark_assigned(expr
->base
);
1415 static void evaluate_assign_to(struct expression
*left
, struct symbol
*type
)
1417 if (type
->ctype
.modifiers
& MOD_CONST
)
1418 expression_error(left
, "assignment to const expression");
1420 /* We know left is an lvalue, so it's a "preop-*" */
1421 mark_assigned(left
->unop
);
1424 static struct symbol
*evaluate_assignment(struct expression
*expr
)
1426 struct expression
*left
= expr
->left
;
1427 struct expression
*where
= expr
;
1428 struct symbol
*ltype
;
1430 if (!lvalue_expression(left
)) {
1431 expression_error(expr
, "not an lvalue");
1435 ltype
= left
->ctype
;
1437 if (expr
->op
!= '=') {
1438 if (!evaluate_assign_op(expr
))
1441 if (!compatible_assignment_types(where
, ltype
, &expr
->right
, "assignment"))
1445 evaluate_assign_to(left
, ltype
);
1447 expr
->ctype
= ltype
;
1451 static void examine_fn_arguments(struct symbol
*fn
)
1455 FOR_EACH_PTR(fn
->arguments
, s
) {
1456 struct symbol
*arg
= evaluate_symbol(s
);
1457 /* Array/function arguments silently degenerate into pointers */
1463 ptr
= alloc_symbol(s
->pos
, SYM_PTR
);
1464 if (arg
->type
== SYM_ARRAY
)
1465 ptr
->ctype
= arg
->ctype
;
1467 ptr
->ctype
.base_type
= arg
;
1468 ptr
->ctype
.as
|= s
->ctype
.as
;
1469 ptr
->ctype
.modifiers
|= s
->ctype
.modifiers
& MOD_PTRINHERIT
;
1471 s
->ctype
.base_type
= ptr
;
1473 s
->ctype
.modifiers
&= ~MOD_PTRINHERIT
;
1476 examine_symbol_type(s
);
1483 } END_FOR_EACH_PTR(s
);
1486 static struct symbol
*convert_to_as_mod(struct symbol
*sym
, int as
, int mod
)
1488 /* Take the modifiers of the pointer, and apply them to the member */
1489 mod
|= sym
->ctype
.modifiers
;
1490 if (sym
->ctype
.as
!= as
|| sym
->ctype
.modifiers
!= mod
) {
1491 struct symbol
*newsym
= alloc_symbol(sym
->pos
, SYM_NODE
);
1493 newsym
->ctype
.as
= as
;
1494 newsym
->ctype
.modifiers
= mod
;
1500 static struct symbol
*create_pointer(struct expression
*expr
, struct symbol
*sym
, int degenerate
)
1502 struct symbol
*node
= alloc_symbol(expr
->pos
, SYM_NODE
);
1503 struct symbol
*ptr
= alloc_symbol(expr
->pos
, SYM_PTR
);
1505 node
->ctype
.base_type
= ptr
;
1506 ptr
->bit_size
= bits_in_pointer
;
1507 ptr
->ctype
.alignment
= pointer_alignment
;
1509 node
->bit_size
= bits_in_pointer
;
1510 node
->ctype
.alignment
= pointer_alignment
;
1513 if (sym
->ctype
.modifiers
& MOD_REGISTER
) {
1514 warning(expr
->pos
, "taking address of 'register' variable '%s'", show_ident(sym
->ident
));
1515 sym
->ctype
.modifiers
&= ~MOD_REGISTER
;
1517 if (sym
->type
== SYM_NODE
) {
1518 ptr
->ctype
.as
|= sym
->ctype
.as
;
1519 ptr
->ctype
.modifiers
|= sym
->ctype
.modifiers
& MOD_PTRINHERIT
;
1520 sym
= sym
->ctype
.base_type
;
1522 if (degenerate
&& sym
->type
== SYM_ARRAY
) {
1523 ptr
->ctype
.as
|= sym
->ctype
.as
;
1524 ptr
->ctype
.modifiers
|= sym
->ctype
.modifiers
& MOD_PTRINHERIT
;
1525 sym
= sym
->ctype
.base_type
;
1527 ptr
->ctype
.base_type
= sym
;
1532 /* Arrays degenerate into pointers on pointer arithmetic */
1533 static struct symbol
*degenerate(struct expression
*expr
)
1535 struct symbol
*ctype
, *base
;
1539 ctype
= expr
->ctype
;
1542 base
= examine_symbol_type(ctype
);
1543 if (ctype
->type
== SYM_NODE
)
1544 base
= ctype
->ctype
.base_type
;
1546 * Arrays degenerate into pointers to the entries, while
1547 * functions degenerate into pointers to themselves.
1548 * If array was part of non-lvalue compound, we create a copy
1549 * of that compound first and then act as if we were dealing with
1550 * the corresponding field in there.
1552 switch (base
->type
) {
1554 if (expr
->type
== EXPR_SLICE
) {
1555 struct symbol
*a
= alloc_symbol(expr
->pos
, SYM_NODE
);
1556 struct expression
*e0
, *e1
, *e2
, *e3
, *e4
;
1558 a
->ctype
.base_type
= expr
->base
->ctype
;
1559 a
->bit_size
= expr
->base
->ctype
->bit_size
;
1560 a
->array_size
= expr
->base
->ctype
->array_size
;
1562 e0
= alloc_expression(expr
->pos
, EXPR_SYMBOL
);
1564 e0
->ctype
= &lazy_ptr_ctype
;
1566 e1
= alloc_expression(expr
->pos
, EXPR_PREOP
);
1569 e1
->ctype
= expr
->base
->ctype
; /* XXX */
1571 e2
= alloc_expression(expr
->pos
, EXPR_ASSIGNMENT
);
1573 e2
->right
= expr
->base
;
1575 e2
->ctype
= expr
->base
->ctype
;
1577 if (expr
->r_bitpos
) {
1578 e3
= alloc_expression(expr
->pos
, EXPR_BINOP
);
1581 e3
->right
= alloc_const_expression(expr
->pos
,
1582 bits_to_bytes(expr
->r_bitpos
));
1583 e3
->ctype
= &lazy_ptr_ctype
;
1588 e4
= alloc_expression(expr
->pos
, EXPR_COMMA
);
1591 e4
->ctype
= &lazy_ptr_ctype
;
1594 expr
->type
= EXPR_PREOP
;
1598 if (expr
->op
!= '*' || expr
->type
!= EXPR_PREOP
) {
1599 expression_error(expr
, "strange non-value function or array");
1602 *expr
= *expr
->unop
;
1603 ctype
= create_pointer(expr
, ctype
, 1);
1604 expr
->ctype
= ctype
;
1611 static struct symbol
*evaluate_addressof(struct expression
*expr
)
1613 struct expression
*op
= expr
->unop
;
1614 struct symbol
*ctype
;
1616 if (op
->op
!= '*' || op
->type
!= EXPR_PREOP
) {
1617 expression_error(expr
, "not addressable");
1624 if (expr
->type
== EXPR_SYMBOL
) {
1625 struct symbol
*sym
= expr
->symbol
;
1626 sym
->ctype
.modifiers
|= MOD_ADDRESSABLE
;
1630 * symbol expression evaluation is lazy about the type
1631 * of the sub-expression, so we may have to generate
1632 * the type here if so..
1634 if (expr
->ctype
== &lazy_ptr_ctype
) {
1635 ctype
= create_pointer(expr
, ctype
, 0);
1636 expr
->ctype
= ctype
;
1642 static struct symbol
*evaluate_dereference(struct expression
*expr
)
1644 struct expression
*op
= expr
->unop
;
1645 struct symbol
*ctype
= op
->ctype
, *node
, *target
;
1647 /* Simplify: *&(expr) => (expr) */
1648 if (op
->type
== EXPR_PREOP
&& op
->op
== '&') {
1654 /* Dereferencing a node drops all the node information. */
1655 if (ctype
->type
== SYM_NODE
)
1656 ctype
= ctype
->ctype
.base_type
;
1658 node
= alloc_symbol(expr
->pos
, SYM_NODE
);
1659 target
= ctype
->ctype
.base_type
;
1661 switch (ctype
->type
) {
1663 expression_error(expr
, "cannot dereference this type");
1666 node
->ctype
.modifiers
= target
->ctype
.modifiers
& MOD_SPECIFIER
;
1667 merge_type(node
, ctype
);
1671 if (!lvalue_expression(op
)) {
1672 expression_error(op
, "non-lvalue array??");
1676 /* Do the implied "addressof" on the array */
1680 * When an array is dereferenced, we need to pick
1681 * up the attributes of the original node too..
1683 merge_type(node
, op
->ctype
);
1684 merge_type(node
, ctype
);
1688 node
->bit_size
= target
->bit_size
;
1689 node
->array_size
= target
->array_size
;
1696 * Unary post-ops: x++ and x--
1698 static struct symbol
*evaluate_postop(struct expression
*expr
)
1700 struct expression
*op
= expr
->unop
;
1701 struct symbol
*ctype
= op
->ctype
;
1702 int class = classify_type(op
->ctype
, &ctype
);
1705 if (!lvalue_expression(expr
->unop
)) {
1706 expression_error(expr
, "need lvalue expression for ++/--");
1710 if ((class & TYPE_RESTRICT
) && restricted_unop(expr
->op
, &ctype
))
1711 return bad_expr_type(expr
);
1713 if (class & TYPE_NUM
) {
1715 } else if (class == TYPE_PTR
) {
1716 struct symbol
*target
= examine_pointer_target(ctype
);
1717 if (!is_function(target
))
1718 multiply
= bits_to_bytes(target
->bit_size
);
1722 evaluate_assign_to(op
, op
->ctype
);
1723 expr
->op_value
= multiply
;
1724 expr
->ctype
= ctype
;
1728 expression_error(expr
, "bad argument type for ++/--");
1732 static struct symbol
*evaluate_sign(struct expression
*expr
)
1734 struct symbol
*ctype
= expr
->unop
->ctype
;
1735 int class = classify_type(ctype
, &ctype
);
1736 if (expr
->flags
&& !(expr
->unop
->flags
& Int_const_expr
))
1738 /* should be an arithmetic type */
1739 if (!(class & TYPE_NUM
))
1740 return bad_expr_type(expr
);
1741 if (!(class & (TYPE_FLOAT
|TYPE_RESTRICT
))) {
1742 struct symbol
*rtype
= integer_promotion(ctype
);
1743 expr
->unop
= cast_to(expr
->unop
, rtype
);
1745 } else if ((class & TYPE_FLOAT
) && expr
->op
!= '~') {
1746 /* no conversions needed */
1747 } else if ((class & TYPE_RESTRICT
) && !restricted_unop(expr
->op
, &ctype
)) {
1748 /* no conversions needed */
1750 return bad_expr_type(expr
);
1752 if (expr
->op
== '+')
1753 *expr
= *expr
->unop
;
1754 expr
->ctype
= ctype
;
1758 static struct symbol
*evaluate_preop(struct expression
*expr
)
1760 struct symbol
*ctype
= expr
->unop
->ctype
;
1764 *expr
= *expr
->unop
;
1770 return evaluate_sign(expr
);
1773 return evaluate_dereference(expr
);
1776 return evaluate_addressof(expr
);
1778 case SPECIAL_INCREMENT
:
1779 case SPECIAL_DECREMENT
:
1781 * From a type evaluation standpoint the preops are
1782 * the same as the postops
1784 return evaluate_postop(expr
);
1787 if (expr
->flags
&& !(expr
->unop
->flags
& Int_const_expr
))
1789 if (is_safe_type(ctype
))
1790 warning(expr
->pos
, "testing a 'safe expression'");
1791 if (is_float_type(ctype
)) {
1792 struct expression
*arg
= expr
->unop
;
1793 expr
->type
= EXPR_BINOP
;
1794 expr
->op
= SPECIAL_EQUAL
;
1796 expr
->right
= alloc_expression(expr
->pos
, EXPR_FVALUE
);
1797 expr
->right
->ctype
= ctype
;
1798 expr
->right
->fvalue
= 0;
1799 } else if (is_fouled_type(ctype
)) {
1800 warning(expr
->pos
, "%s degrades to integer",
1801 show_typename(ctype
->ctype
.base_type
));
1803 ctype
= &bool_ctype
;
1809 expr
->ctype
= ctype
;
1813 static struct symbol
*find_identifier(struct ident
*ident
, struct symbol_list
*_list
, int *offset
)
1815 struct ptr_list
*head
= (struct ptr_list
*)_list
;
1816 struct ptr_list
*list
= head
;
1822 for (i
= 0; i
< list
->nr
; i
++) {
1823 struct symbol
*sym
= (struct symbol
*) list
->list
[i
];
1825 if (sym
->ident
!= ident
)
1827 *offset
= sym
->offset
;
1830 struct symbol
*ctype
= sym
->ctype
.base_type
;
1834 if (ctype
->type
!= SYM_UNION
&& ctype
->type
!= SYM_STRUCT
)
1836 sub
= find_identifier(ident
, ctype
->symbol_list
, offset
);
1839 *offset
+= sym
->offset
;
1843 } while ((list
= list
->next
) != head
);
1847 static struct expression
*evaluate_offset(struct expression
*expr
, unsigned long offset
)
1849 struct expression
*add
;
1852 * Create a new add-expression
1854 * NOTE! Even if we just add zero, we need a new node
1855 * for the member pointer, since it has a different
1856 * type than the original pointer. We could make that
1857 * be just a cast, but the fact is, a node is a node,
1858 * so we might as well just do the "add zero" here.
1860 add
= alloc_expression(expr
->pos
, EXPR_BINOP
);
1863 add
->right
= alloc_expression(expr
->pos
, EXPR_VALUE
);
1864 add
->right
->ctype
= &int_ctype
;
1865 add
->right
->value
= offset
;
1868 * The ctype of the pointer will be lazily evaluated if
1869 * we ever take the address of this member dereference..
1871 add
->ctype
= &lazy_ptr_ctype
;
1875 /* structure/union dereference */
1876 static struct symbol
*evaluate_member_dereference(struct expression
*expr
)
1879 struct symbol
*ctype
, *member
;
1880 struct expression
*deref
= expr
->deref
, *add
;
1881 struct ident
*ident
= expr
->member
;
1885 if (!evaluate_expression(deref
))
1888 expression_error(expr
, "bad member name");
1892 ctype
= deref
->ctype
;
1893 examine_symbol_type(ctype
);
1894 address_space
= ctype
->ctype
.as
;
1895 mod
= ctype
->ctype
.modifiers
;
1896 if (ctype
->type
== SYM_NODE
) {
1897 ctype
= ctype
->ctype
.base_type
;
1898 address_space
|= ctype
->ctype
.as
;
1899 mod
|= ctype
->ctype
.modifiers
;
1901 if (!ctype
|| (ctype
->type
!= SYM_STRUCT
&& ctype
->type
!= SYM_UNION
)) {
1902 expression_error(expr
, "expected structure or union");
1906 member
= find_identifier(ident
, ctype
->symbol_list
, &offset
);
1908 const char *type
= ctype
->type
== SYM_STRUCT
? "struct" : "union";
1909 const char *name
= "<unnamed>";
1912 name
= ctype
->ident
->name
;
1913 namelen
= ctype
->ident
->len
;
1915 if (ctype
->symbol_list
)
1916 expression_error(expr
, "no member '%s' in %s %.*s",
1917 show_ident(ident
), type
, namelen
, name
);
1919 expression_error(expr
, "using member '%s' in "
1920 "incomplete %s %.*s", show_ident(ident
),
1921 type
, namelen
, name
);
1926 * The member needs to take on the address space and modifiers of
1927 * the "parent" type.
1929 member
= convert_to_as_mod(member
, address_space
, mod
);
1930 ctype
= get_base_type(member
);
1932 if (!lvalue_expression(deref
)) {
1933 if (deref
->type
!= EXPR_SLICE
) {
1937 expr
->base
= deref
->base
;
1938 expr
->r_bitpos
= deref
->r_bitpos
;
1940 expr
->r_bitpos
+= bytes_to_bits(offset
);
1941 expr
->type
= EXPR_SLICE
;
1942 expr
->r_nrbits
= member
->bit_size
;
1943 expr
->r_bitpos
+= member
->bit_offset
;
1944 expr
->ctype
= member
;
1948 deref
= deref
->unop
;
1949 expr
->deref
= deref
;
1951 add
= evaluate_offset(deref
, offset
);
1952 expr
->type
= EXPR_PREOP
;
1956 expr
->ctype
= member
;
1960 static int is_promoted(struct expression
*expr
)
1963 switch (expr
->type
) {
1966 case EXPR_CONDITIONAL
:
1990 static struct symbol
*evaluate_cast(struct expression
*);
1992 static struct symbol
*evaluate_type_information(struct expression
*expr
)
1994 struct symbol
*sym
= expr
->cast_type
;
1996 sym
= evaluate_expression(expr
->cast_expression
);
2000 * Expressions of restricted types will possibly get
2001 * promoted - check that here
2003 if (is_restricted_type(sym
)) {
2004 if (sym
->bit_size
< bits_in_int
&& is_promoted(expr
))
2006 } else if (is_fouled_type(sym
)) {
2010 examine_symbol_type(sym
);
2011 if (is_bitfield_type(sym
)) {
2012 expression_error(expr
, "trying to examine bitfield type");
2018 static struct symbol
*evaluate_sizeof(struct expression
*expr
)
2020 struct symbol
*type
;
2023 type
= evaluate_type_information(expr
);
2027 size
= type
->bit_size
;
2029 if (size
< 0 && is_void_type(type
)) {
2030 warning(expr
->pos
, "expression using sizeof(void)");
2031 size
= bits_in_char
;
2034 if (is_function(type
->ctype
.base_type
)) {
2035 warning(expr
->pos
, "expression using sizeof on a function");
2036 size
= bits_in_char
;
2039 if ((size
< 0) || (size
& (bits_in_char
- 1)))
2040 expression_error(expr
, "cannot size expression");
2042 expr
->type
= EXPR_VALUE
;
2043 expr
->value
= bits_to_bytes(size
);
2045 expr
->ctype
= size_t_ctype
;
2046 return size_t_ctype
;
2049 static struct symbol
*evaluate_ptrsizeof(struct expression
*expr
)
2051 struct symbol
*type
;
2054 type
= evaluate_type_information(expr
);
2058 if (type
->type
== SYM_NODE
)
2059 type
= type
->ctype
.base_type
;
2062 switch (type
->type
) {
2066 type
= get_base_type(type
);
2070 expression_error(expr
, "expected pointer expression");
2073 size
= type
->bit_size
;
2074 if (size
& (bits_in_char
-1))
2076 expr
->type
= EXPR_VALUE
;
2077 expr
->value
= bits_to_bytes(size
);
2079 expr
->ctype
= size_t_ctype
;
2080 return size_t_ctype
;
2083 static struct symbol
*evaluate_alignof(struct expression
*expr
)
2085 struct symbol
*type
;
2087 type
= evaluate_type_information(expr
);
2091 expr
->type
= EXPR_VALUE
;
2092 expr
->value
= type
->ctype
.alignment
;
2094 expr
->ctype
= size_t_ctype
;
2095 return size_t_ctype
;
2098 static int evaluate_arguments(struct symbol
*f
, struct symbol
*fn
, struct expression_list
*head
)
2100 struct expression
*expr
;
2101 struct symbol_list
*argument_types
= fn
->arguments
;
2102 struct symbol
*argtype
;
2105 PREPARE_PTR_LIST(argument_types
, argtype
);
2106 FOR_EACH_PTR (head
, expr
) {
2107 struct expression
**p
= THIS_ADDRESS(expr
);
2108 struct symbol
*ctype
, *target
;
2109 ctype
= evaluate_expression(expr
);
2116 struct symbol
*type
;
2117 int class = classify_type(ctype
, &type
);
2118 if (is_int(class)) {
2119 *p
= cast_to(expr
, integer_promotion(type
));
2120 } else if (class & TYPE_FLOAT
) {
2121 unsigned long mod
= type
->ctype
.modifiers
;
2122 if (!(mod
& (MOD_LONG
|MOD_LONGLONG
)))
2123 *p
= cast_to(expr
, &double_ctype
);
2124 } else if (class & TYPE_PTR
) {
2125 if (expr
->ctype
== &null_ctype
)
2126 *p
= cast_to(expr
, &ptr_ctype
);
2131 static char where
[30];
2132 examine_symbol_type(target
);
2133 sprintf(where
, "argument %d", i
);
2134 compatible_assignment_types(expr
, target
, p
, where
);
2138 NEXT_PTR_LIST(argtype
);
2139 } END_FOR_EACH_PTR(expr
);
2140 FINISH_PTR_LIST(argtype
);
2144 static struct symbol
*find_struct_ident(struct symbol
*ctype
, struct ident
*ident
)
2148 FOR_EACH_PTR(ctype
->symbol_list
, sym
) {
2149 if (sym
->ident
== ident
)
2151 } END_FOR_EACH_PTR(sym
);
2155 static void convert_index(struct expression
*e
)
2157 struct expression
*child
= e
->idx_expression
;
2158 unsigned from
= e
->idx_from
;
2159 unsigned to
= e
->idx_to
+ 1;
2161 e
->init_offset
= from
* bits_to_bytes(e
->ctype
->bit_size
);
2162 e
->init_nr
= to
- from
;
2163 e
->init_expr
= child
;
2166 static void convert_ident(struct expression
*e
)
2168 struct expression
*child
= e
->ident_expression
;
2169 struct symbol
*sym
= e
->field
;
2171 e
->init_offset
= sym
->offset
;
2173 e
->init_expr
= child
;
2176 static void convert_designators(struct expression
*e
)
2179 if (e
->type
== EXPR_INDEX
)
2181 else if (e
->type
== EXPR_IDENTIFIER
)
2189 static void excess(struct expression
*e
, const char *s
)
2191 warning(e
->pos
, "excessive elements in %s initializer", s
);
2195 * implicit designator for the first element
2197 static struct expression
*first_subobject(struct symbol
*ctype
, int class,
2198 struct expression
**v
)
2200 struct expression
*e
= *v
, *new;
2202 if (ctype
->type
== SYM_NODE
)
2203 ctype
= ctype
->ctype
.base_type
;
2205 if (class & TYPE_PTR
) { /* array */
2206 if (!ctype
->bit_size
)
2208 new = alloc_expression(e
->pos
, EXPR_INDEX
);
2209 new->idx_expression
= e
;
2210 new->ctype
= ctype
->ctype
.base_type
;
2212 struct symbol
*field
, *p
;
2213 PREPARE_PTR_LIST(ctype
->symbol_list
, p
);
2214 while (p
&& !p
->ident
&& is_bitfield_type(p
))
2220 new = alloc_expression(e
->pos
, EXPR_IDENTIFIER
);
2221 new->ident_expression
= e
;
2222 new->field
= new->ctype
= field
;
2229 * sanity-check explicit designators; return the innermost one or NULL
2230 * in case of error. Assign types.
2232 static struct expression
*check_designators(struct expression
*e
,
2233 struct symbol
*ctype
)
2235 struct expression
*last
= NULL
;
2238 if (ctype
->type
== SYM_NODE
)
2239 ctype
= ctype
->ctype
.base_type
;
2240 if (e
->type
== EXPR_INDEX
) {
2241 struct symbol
*type
;
2242 if (ctype
->type
!= SYM_ARRAY
) {
2243 err
= "array index in non-array";
2246 type
= ctype
->ctype
.base_type
;
2247 if (ctype
->bit_size
>= 0 && type
->bit_size
>= 0) {
2248 unsigned offset
= e
->idx_to
* type
->bit_size
;
2249 if (offset
>= ctype
->bit_size
) {
2250 err
= "index out of bounds in";
2254 e
->ctype
= ctype
= type
;
2257 if (!e
->idx_expression
) {
2261 e
= e
->idx_expression
;
2262 } else if (e
->type
== EXPR_IDENTIFIER
) {
2263 if (ctype
->type
!= SYM_STRUCT
&& ctype
->type
!= SYM_UNION
) {
2264 err
= "field name not in struct or union";
2267 ctype
= find_struct_ident(ctype
, e
->expr_ident
);
2269 err
= "unknown field name in";
2272 e
->field
= e
->ctype
= ctype
;
2274 if (!e
->ident_expression
) {
2278 e
= e
->ident_expression
;
2279 } else if (e
->type
== EXPR_POS
) {
2280 err
= "internal front-end error: EXPR_POS in";
2285 expression_error(e
, "%s initializer", err
);
2290 * choose the next subobject to initialize.
2292 * Get designators for next element, switch old ones to EXPR_POS.
2293 * Return the resulting expression or NULL if we'd run out of subobjects.
2294 * The innermost designator is returned in *v. Designators in old
2295 * are assumed to be already sanity-checked.
2297 static struct expression
*next_designators(struct expression
*old
,
2298 struct symbol
*ctype
,
2299 struct expression
*e
, struct expression
**v
)
2301 struct expression
*new = NULL
;
2305 if (old
->type
== EXPR_INDEX
) {
2306 struct expression
*copy
;
2309 copy
= next_designators(old
->idx_expression
,
2312 n
= old
->idx_to
+ 1;
2313 if (n
* old
->ctype
->bit_size
== ctype
->bit_size
) {
2318 *v
= new = alloc_expression(e
->pos
, EXPR_INDEX
);
2321 new = alloc_expression(e
->pos
, EXPR_INDEX
);
2324 new->idx_from
= new->idx_to
= n
;
2325 new->idx_expression
= copy
;
2326 new->ctype
= old
->ctype
;
2328 } else if (old
->type
== EXPR_IDENTIFIER
) {
2329 struct expression
*copy
;
2330 struct symbol
*field
;
2332 copy
= next_designators(old
->ident_expression
,
2335 field
= old
->field
->next_subobject
;
2341 *v
= new = alloc_expression(e
->pos
, EXPR_IDENTIFIER
);
2344 new = alloc_expression(e
->pos
, EXPR_IDENTIFIER
);
2348 new->expr_ident
= field
->ident
;
2349 new->ident_expression
= copy
;
2356 static int handle_simple_initializer(struct expression
**ep
, int nested
,
2357 int class, struct symbol
*ctype
);
2360 * deal with traversing subobjects [6.7.8(17,18,20)]
2362 static void handle_list_initializer(struct expression
*expr
,
2363 int class, struct symbol
*ctype
)
2365 struct expression
*e
, *last
= NULL
, *top
= NULL
, *next
;
2368 FOR_EACH_PTR(expr
->expr_list
, e
) {
2369 struct expression
**v
;
2370 struct symbol
*type
;
2373 if (e
->type
!= EXPR_INDEX
&& e
->type
!= EXPR_IDENTIFIER
) {
2376 last
= first_subobject(ctype
, class, &top
);
2378 last
= next_designators(last
, ctype
, e
, &top
);
2381 excess(e
, class & TYPE_PTR
? "array" :
2383 DELETE_CURRENT_PTR(e
);
2387 warning(e
->pos
, "advancing past deep designator");
2390 REPLACE_CURRENT_PTR(e
, last
);
2392 next
= check_designators(e
, ctype
);
2394 DELETE_CURRENT_PTR(e
);
2398 /* deeper than one designator? */
2400 convert_designators(last
);
2405 lclass
= classify_type(top
->ctype
, &type
);
2406 if (top
->type
== EXPR_INDEX
)
2407 v
= &top
->idx_expression
;
2409 v
= &top
->ident_expression
;
2411 if (handle_simple_initializer(v
, 1, lclass
, top
->ctype
))
2414 if (!(lclass
& TYPE_COMPOUND
)) {
2415 warning(e
->pos
, "bogus scalar initializer");
2416 DELETE_CURRENT_PTR(e
);
2420 next
= first_subobject(type
, lclass
, v
);
2422 warning(e
->pos
, "missing braces around initializer");
2427 DELETE_CURRENT_PTR(e
);
2428 excess(e
, lclass
& TYPE_PTR
? "array" : "struct or union");
2430 } END_FOR_EACH_PTR(e
);
2432 convert_designators(last
);
2433 expr
->ctype
= ctype
;
2436 static int is_string_literal(struct expression
**v
)
2438 struct expression
*e
= *v
;
2439 while (e
&& e
->type
== EXPR_PREOP
&& e
->op
== '(')
2441 if (!e
|| e
->type
!= EXPR_STRING
)
2443 if (e
!= *v
&& Wparen_string
)
2445 "array initialized from parenthesized string constant");
2451 * We want a normal expression, possibly in one layer of braces. Warn
2452 * if the latter happens inside a list (it's legal, but likely to be
2453 * an effect of screwup). In case of anything not legal, we are definitely
2454 * having an effect of screwup, so just fail and let the caller warn.
2456 static struct expression
*handle_scalar(struct expression
*e
, int nested
)
2458 struct expression
*v
= NULL
, *p
;
2462 if (e
->type
!= EXPR_INITIALIZER
)
2465 FOR_EACH_PTR(e
->expr_list
, p
) {
2469 } END_FOR_EACH_PTR(p
);
2473 case EXPR_INITIALIZER
:
2475 case EXPR_IDENTIFIER
:
2481 warning(e
->pos
, "braces around scalar initializer");
2486 * deal with the cases that don't care about subobjects:
2487 * scalar <- assignment expression, possibly in braces [6.7.8(11)]
2488 * character array <- string literal, possibly in braces [6.7.8(14)]
2489 * struct or union <- assignment expression of compatible type [6.7.8(13)]
2490 * compound type <- initializer list in braces [6.7.8(16)]
2491 * The last one punts to handle_list_initializer() which, in turn will call
2492 * us for individual elements of the list.
2494 * We do not handle 6.7.8(15) (wide char array <- wide string literal) for
2495 * the lack of support of wide char stuff in general.
2497 * One note: we need to take care not to evaluate a string literal until
2498 * we know that we *will* handle it right here. Otherwise we would screw
2499 * the cases like struct { struct {char s[10]; ...} ...} initialized with
2500 * { "string", ...} - we need to preserve that string literal recognizable
2501 * until we dig into the inner struct.
2503 static int handle_simple_initializer(struct expression
**ep
, int nested
,
2504 int class, struct symbol
*ctype
)
2506 int is_string
= is_string_type(ctype
);
2507 struct expression
*e
= *ep
, *p
;
2508 struct symbol
*type
;
2514 if (!(class & TYPE_COMPOUND
)) {
2515 e
= handle_scalar(e
, nested
);
2519 if (!evaluate_expression(e
))
2521 compatible_assignment_types(e
, ctype
, ep
, "initializer");
2526 * sublist; either a string, or we dig in; the latter will deal with
2527 * pathologies, so we don't need anything fancy here.
2529 if (e
->type
== EXPR_INITIALIZER
) {
2531 struct expression
*v
= NULL
;
2534 FOR_EACH_PTR(e
->expr_list
, p
) {
2538 } END_FOR_EACH_PTR(p
);
2539 if (count
== 1 && is_string_literal(&v
)) {
2544 handle_list_initializer(e
, class, ctype
);
2549 if (is_string_literal(&e
)) {
2550 /* either we are doing array of char, or we'll have to dig in */
2557 /* struct or union can be initialized by compatible */
2558 if (class != TYPE_COMPOUND
)
2560 type
= evaluate_expression(e
);
2563 if (ctype
->type
== SYM_NODE
)
2564 ctype
= ctype
->ctype
.base_type
;
2565 if (type
->type
== SYM_NODE
)
2566 type
= type
->ctype
.base_type
;
2572 p
= alloc_expression(e
->pos
, EXPR_STRING
);
2574 type
= evaluate_expression(p
);
2575 if (ctype
->bit_size
!= -1 &&
2576 ctype
->bit_size
+ bits_in_char
< type
->bit_size
) {
2578 "too long initializer-string for array of char");
2584 static void evaluate_initializer(struct symbol
*ctype
, struct expression
**ep
)
2586 struct symbol
*type
;
2587 int class = classify_type(ctype
, &type
);
2588 if (!handle_simple_initializer(ep
, 0, class, ctype
))
2589 expression_error(*ep
, "invalid initializer");
2592 static struct symbol
*evaluate_cast(struct expression
*expr
)
2594 struct expression
*target
= expr
->cast_expression
;
2595 struct symbol
*ctype
;
2596 struct symbol
*t1
, *t2
;
2598 int as1
= 0, as2
= 0;
2604 * Special case: a cast can be followed by an
2605 * initializer, in which case we need to pass
2606 * the type value down to that initializer rather
2607 * than trying to evaluate it as an expression
2609 * A more complex case is when the initializer is
2610 * dereferenced as part of a post-fix expression.
2611 * We need to produce an expression that can be dereferenced.
2613 if (target
->type
== EXPR_INITIALIZER
) {
2614 struct symbol
*sym
= expr
->cast_type
;
2615 struct expression
*addr
= alloc_expression(expr
->pos
, EXPR_SYMBOL
);
2617 sym
->initializer
= target
;
2618 evaluate_symbol(sym
);
2620 addr
->ctype
= &lazy_ptr_ctype
; /* Lazy eval */
2623 expr
->type
= EXPR_PREOP
;
2631 ctype
= examine_symbol_type(expr
->cast_type
);
2632 expr
->ctype
= ctype
;
2633 expr
->cast_type
= ctype
;
2635 evaluate_expression(target
);
2638 class1
= classify_type(ctype
, &t1
);
2640 /* cast to non-integer type -> not an integer constant expression */
2641 if (!is_int(class1
))
2643 /* if argument turns out to be not an integer constant expression *and*
2644 it was not a floating literal to start with -> too bad */
2645 else if (expr
->flags
== Int_const_expr
&&
2646 !(target
->flags
& Int_const_expr
))
2649 * You can always throw a value away by casting to
2650 * "void" - that's an implicit "force". Note that
2651 * the same is _not_ true of "void *".
2653 if (t1
== &void_ctype
)
2656 if (class1
& (TYPE_COMPOUND
| TYPE_FN
))
2657 warning(expr
->pos
, "cast to non-scalar");
2661 expression_error(expr
, "cast from unknown type");
2664 class2
= classify_type(t2
, &t2
);
2666 if (class2
& TYPE_COMPOUND
)
2667 warning(expr
->pos
, "cast from non-scalar");
2669 if (expr
->type
== EXPR_FORCE_CAST
)
2672 /* allowed cast unfouls */
2673 if (class2
& TYPE_FOULED
)
2677 if (class1
& TYPE_RESTRICT
)
2678 warning(expr
->pos
, "cast to %s",
2680 if (class2
& TYPE_RESTRICT
)
2681 warning(expr
->pos
, "cast from %s",
2685 if (t1
== &ulong_ctype
)
2687 else if (class1
== TYPE_PTR
) {
2688 examine_pointer_target(t1
);
2692 if (t2
== &ulong_ctype
)
2694 else if (class2
== TYPE_PTR
) {
2695 examine_pointer_target(t2
);
2699 if (!as1
&& as2
> 0)
2700 warning(expr
->pos
, "cast removes address space of expression");
2701 if (as1
> 0 && as2
> 0 && as1
!= as2
)
2702 warning(expr
->pos
, "cast between address spaces (<asn:%d>-><asn:%d>)", as2
, as1
);
2703 if (as1
> 0 && !as2
&&
2704 !is_null_pointer_constant(target
) && Wcast_to_as
)
2706 "cast adds address space to expression (<asn:%d>)", as1
);
2708 if (!(t1
->ctype
.modifiers
& MOD_PTRINHERIT
) && class1
== TYPE_PTR
&&
2709 !as1
&& (target
->flags
& Int_const_expr
)) {
2710 if (t1
->ctype
.base_type
== &void_ctype
) {
2711 if (is_zero_constant(target
)) {
2713 expr
->type
= EXPR_VALUE
;
2714 expr
->ctype
= &null_ctype
;
2725 * Evaluate a call expression with a symbol. This
2726 * should expand inline functions, and evaluate
2729 static int evaluate_symbol_call(struct expression
*expr
)
2731 struct expression
*fn
= expr
->fn
;
2732 struct symbol
*ctype
= fn
->ctype
;
2734 if (fn
->type
!= EXPR_PREOP
)
2737 if (ctype
->op
&& ctype
->op
->evaluate
)
2738 return ctype
->op
->evaluate(expr
);
2740 if (ctype
->ctype
.modifiers
& MOD_INLINE
) {
2742 struct symbol
*curr
= current_fn
;
2744 if (ctype
->definition
)
2745 ctype
= ctype
->definition
;
2747 current_fn
= ctype
->ctype
.base_type
;
2749 ret
= inline_function(expr
, ctype
);
2751 /* restore the old function */
2759 static struct symbol
*evaluate_call(struct expression
*expr
)
2762 struct symbol
*ctype
, *sym
;
2763 struct expression
*fn
= expr
->fn
;
2764 struct expression_list
*arglist
= expr
->args
;
2766 if (!evaluate_expression(fn
))
2768 sym
= ctype
= fn
->ctype
;
2769 if (ctype
->type
== SYM_NODE
)
2770 ctype
= ctype
->ctype
.base_type
;
2771 if (ctype
->type
== SYM_PTR
)
2772 ctype
= get_base_type(ctype
);
2774 if (ctype
->type
!= SYM_FN
) {
2775 struct expression
*arg
;
2776 expression_error(expr
, "not a function %s",
2777 show_ident(sym
->ident
));
2778 /* do typechecking in arguments */
2779 FOR_EACH_PTR (arglist
, arg
) {
2780 evaluate_expression(arg
);
2781 } END_FOR_EACH_PTR(arg
);
2785 examine_fn_arguments(ctype
);
2786 if (sym
->type
== SYM_NODE
&& fn
->type
== EXPR_PREOP
&&
2787 sym
->op
&& sym
->op
->args
) {
2788 if (!sym
->op
->args(expr
))
2791 if (!evaluate_arguments(sym
, ctype
, arglist
))
2793 args
= expression_list_size(expr
->args
);
2794 fnargs
= symbol_list_size(ctype
->arguments
);
2796 expression_error(expr
,
2797 "not enough arguments for function %s",
2798 show_ident(sym
->ident
));
2799 if (args
> fnargs
&& !ctype
->variadic
)
2800 expression_error(expr
,
2801 "too many arguments for function %s",
2802 show_ident(sym
->ident
));
2804 if (sym
->type
== SYM_NODE
) {
2805 if (evaluate_symbol_call(expr
))
2808 expr
->ctype
= ctype
->ctype
.base_type
;
2812 static struct symbol
*evaluate_offsetof(struct expression
*expr
)
2814 struct expression
*e
= expr
->down
;
2815 struct symbol
*ctype
= expr
->in
;
2818 if (expr
->op
== '.') {
2819 struct symbol
*field
;
2822 expression_error(expr
, "expected structure or union");
2825 examine_symbol_type(ctype
);
2826 class = classify_type(ctype
, &ctype
);
2827 if (class != TYPE_COMPOUND
) {
2828 expression_error(expr
, "expected structure or union");
2832 field
= find_identifier(expr
->ident
, ctype
->symbol_list
, &offset
);
2834 expression_error(expr
, "unknown member");
2838 expr
->type
= EXPR_VALUE
;
2839 expr
->flags
= Int_const_expr
;
2840 expr
->value
= offset
;
2842 expr
->ctype
= size_t_ctype
;
2845 expression_error(expr
, "expected structure or union");
2848 examine_symbol_type(ctype
);
2849 class = classify_type(ctype
, &ctype
);
2850 if (class != (TYPE_COMPOUND
| TYPE_PTR
)) {
2851 expression_error(expr
, "expected array");
2854 ctype
= ctype
->ctype
.base_type
;
2856 expr
->type
= EXPR_VALUE
;
2857 expr
->flags
= Int_const_expr
;
2860 expr
->ctype
= size_t_ctype
;
2862 struct expression
*idx
= expr
->index
, *m
;
2863 struct symbol
*i_type
= evaluate_expression(idx
);
2864 int i_class
= classify_type(i_type
, &i_type
);
2865 if (!is_int(i_class
)) {
2866 expression_error(expr
, "non-integer index");
2869 unrestrict(idx
, i_class
, &i_type
);
2870 idx
= cast_to(idx
, size_t_ctype
);
2871 m
= alloc_const_expression(expr
->pos
,
2872 bits_to_bytes(ctype
->bit_size
));
2873 m
->ctype
= size_t_ctype
;
2874 m
->flags
= Int_const_expr
;
2875 expr
->type
= EXPR_BINOP
;
2879 expr
->ctype
= size_t_ctype
;
2880 expr
->flags
= m
->flags
& idx
->flags
& Int_const_expr
;
2884 struct expression
*copy
= __alloc_expression(0);
2886 if (e
->type
== EXPR_OFFSETOF
)
2888 if (!evaluate_expression(e
))
2890 expr
->type
= EXPR_BINOP
;
2891 expr
->flags
= e
->flags
& copy
->flags
& Int_const_expr
;
2893 expr
->ctype
= size_t_ctype
;
2897 return size_t_ctype
;
2900 struct symbol
*evaluate_expression(struct expression
*expr
)
2907 switch (expr
->type
) {
2910 expression_error(expr
, "value expression without a type");
2913 return evaluate_string(expr
);
2915 return evaluate_symbol_expression(expr
);
2917 if (!evaluate_expression(expr
->left
))
2919 if (!evaluate_expression(expr
->right
))
2921 return evaluate_binop(expr
);
2923 return evaluate_logical(expr
);
2925 evaluate_expression(expr
->left
);
2926 if (!evaluate_expression(expr
->right
))
2928 return evaluate_comma(expr
);
2930 if (!evaluate_expression(expr
->left
))
2932 if (!evaluate_expression(expr
->right
))
2934 return evaluate_compare(expr
);
2935 case EXPR_ASSIGNMENT
:
2936 if (!evaluate_expression(expr
->left
))
2938 if (!evaluate_expression(expr
->right
))
2940 return evaluate_assignment(expr
);
2942 if (!evaluate_expression(expr
->unop
))
2944 return evaluate_preop(expr
);
2946 if (!evaluate_expression(expr
->unop
))
2948 return evaluate_postop(expr
);
2950 case EXPR_FORCE_CAST
:
2951 case EXPR_IMPLIED_CAST
:
2952 return evaluate_cast(expr
);
2954 return evaluate_sizeof(expr
);
2955 case EXPR_PTRSIZEOF
:
2956 return evaluate_ptrsizeof(expr
);
2958 return evaluate_alignof(expr
);
2960 return evaluate_member_dereference(expr
);
2962 return evaluate_call(expr
);
2964 case EXPR_CONDITIONAL
:
2965 return evaluate_conditional_expression(expr
);
2966 case EXPR_STATEMENT
:
2967 expr
->ctype
= evaluate_statement(expr
->statement
);
2971 expr
->ctype
= &ptr_ctype
;
2975 /* Evaluate the type of the symbol .. */
2976 evaluate_symbol(expr
->symbol
);
2977 /* .. but the type of the _expression_ is a "type" */
2978 expr
->ctype
= &type_ctype
;
2982 return evaluate_offsetof(expr
);
2984 /* These can not exist as stand-alone expressions */
2985 case EXPR_INITIALIZER
:
2986 case EXPR_IDENTIFIER
:
2989 expression_error(expr
, "internal front-end error: initializer in expression");
2992 expression_error(expr
, "internal front-end error: SLICE re-evaluated");
2998 static void check_duplicates(struct symbol
*sym
)
3001 struct symbol
*next
= sym
;
3003 while ((next
= next
->same_symbol
) != NULL
) {
3004 const char *typediff
;
3005 evaluate_symbol(next
);
3007 typediff
= type_difference(&sym
->ctype
, &next
->ctype
, 0, 0);
3009 sparse_error(sym
->pos
, "symbol '%s' redeclared with different type (originally declared at %s:%d) - %s",
3010 show_ident(sym
->ident
),
3011 stream_name(next
->pos
.stream
), next
->pos
.line
, typediff
);
3016 unsigned long mod
= sym
->ctype
.modifiers
;
3017 if (mod
& (MOD_STATIC
| MOD_REGISTER
))
3019 if (!(mod
& MOD_TOPLEVEL
))
3023 if (sym
->ident
== &main_ident
)
3025 warning(sym
->pos
, "symbol '%s' was not declared. Should it be static?", show_ident(sym
->ident
));
3029 static struct symbol
*evaluate_symbol(struct symbol
*sym
)
3031 struct symbol
*base_type
;
3039 sym
= examine_symbol_type(sym
);
3040 base_type
= get_base_type(sym
);
3044 /* Evaluate the initializers */
3045 if (sym
->initializer
)
3046 evaluate_initializer(sym
, &sym
->initializer
);
3048 /* And finally, evaluate the body of the symbol too */
3049 if (base_type
->type
== SYM_FN
) {
3050 struct symbol
*curr
= current_fn
;
3052 if (sym
->definition
&& sym
->definition
!= sym
)
3053 return evaluate_symbol(sym
->definition
);
3055 current_fn
= base_type
;
3057 examine_fn_arguments(base_type
);
3058 if (!base_type
->stmt
&& base_type
->inline_stmt
)
3060 if (base_type
->stmt
)
3061 evaluate_statement(base_type
->stmt
);
3069 void evaluate_symbol_list(struct symbol_list
*list
)
3073 FOR_EACH_PTR(list
, sym
) {
3074 evaluate_symbol(sym
);
3075 check_duplicates(sym
);
3076 } END_FOR_EACH_PTR(sym
);
3079 static struct symbol
*evaluate_return_expression(struct statement
*stmt
)
3081 struct expression
*expr
= stmt
->expression
;
3082 struct symbol
*fntype
;
3084 evaluate_expression(expr
);
3085 fntype
= current_fn
->ctype
.base_type
;
3086 if (!fntype
|| fntype
== &void_ctype
) {
3087 if (expr
&& expr
->ctype
!= &void_ctype
)
3088 expression_error(expr
, "return expression in %s function", fntype
?"void":"typeless");
3089 if (expr
&& Wreturn_void
)
3090 warning(stmt
->pos
, "returning void-valued expression");
3095 sparse_error(stmt
->pos
, "return with no return value");
3100 compatible_assignment_types(expr
, fntype
, &stmt
->expression
, "return expression");
3104 static void evaluate_if_statement(struct statement
*stmt
)
3106 if (!stmt
->if_conditional
)
3109 evaluate_conditional(stmt
->if_conditional
, 0);
3110 evaluate_statement(stmt
->if_true
);
3111 evaluate_statement(stmt
->if_false
);
3114 static void evaluate_iterator(struct statement
*stmt
)
3116 evaluate_symbol_list(stmt
->iterator_syms
);
3117 evaluate_conditional(stmt
->iterator_pre_condition
, 1);
3118 evaluate_conditional(stmt
->iterator_post_condition
,1);
3119 evaluate_statement(stmt
->iterator_pre_statement
);
3120 evaluate_statement(stmt
->iterator_statement
);
3121 evaluate_statement(stmt
->iterator_post_statement
);
3124 static void verify_output_constraint(struct expression
*expr
, const char *constraint
)
3126 switch (*constraint
) {
3127 case '=': /* Assignment */
3128 case '+': /* Update */
3131 expression_error(expr
, "output constraint is not an assignment constraint (\"%s\")", constraint
);
3135 static void verify_input_constraint(struct expression
*expr
, const char *constraint
)
3137 switch (*constraint
) {
3138 case '=': /* Assignment */
3139 case '+': /* Update */
3140 expression_error(expr
, "input constraint with assignment (\"%s\")", constraint
);
3144 static void evaluate_asm_statement(struct statement
*stmt
)
3146 struct expression
*expr
;
3149 expr
= stmt
->asm_string
;
3150 if (!expr
|| expr
->type
!= EXPR_STRING
) {
3151 sparse_error(stmt
->pos
, "need constant string for inline asm");
3156 FOR_EACH_PTR(stmt
->asm_outputs
, expr
) {
3157 struct ident
*ident
;
3160 case 0: /* Identifier */
3162 ident
= (struct ident
*)expr
;
3165 case 1: /* Constraint */
3167 if (!expr
|| expr
->type
!= EXPR_STRING
) {
3168 sparse_error(expr
? expr
->pos
: stmt
->pos
, "asm output constraint is not a string");
3169 *THIS_ADDRESS(expr
) = NULL
;
3172 verify_output_constraint(expr
, expr
->string
->data
);
3175 case 2: /* Expression */
3177 if (!evaluate_expression(expr
))
3179 if (!lvalue_expression(expr
))
3180 warning(expr
->pos
, "asm output is not an lvalue");
3181 evaluate_assign_to(expr
, expr
->ctype
);
3184 } END_FOR_EACH_PTR(expr
);
3187 FOR_EACH_PTR(stmt
->asm_inputs
, expr
) {
3188 struct ident
*ident
;
3191 case 0: /* Identifier */
3193 ident
= (struct ident
*)expr
;
3196 case 1: /* Constraint */
3198 if (!expr
|| expr
->type
!= EXPR_STRING
) {
3199 sparse_error(expr
? expr
->pos
: stmt
->pos
, "asm input constraint is not a string");
3200 *THIS_ADDRESS(expr
) = NULL
;
3203 verify_input_constraint(expr
, expr
->string
->data
);
3206 case 2: /* Expression */
3208 if (!evaluate_expression(expr
))
3212 } END_FOR_EACH_PTR(expr
);
3214 FOR_EACH_PTR(stmt
->asm_clobbers
, expr
) {
3216 sparse_error(stmt
->pos
, "bad asm output");
3219 if (expr
->type
== EXPR_STRING
)
3221 expression_error(expr
, "asm clobber is not a string");
3222 } END_FOR_EACH_PTR(expr
);
3225 static void evaluate_case_statement(struct statement
*stmt
)
3227 evaluate_expression(stmt
->case_expression
);
3228 evaluate_expression(stmt
->case_to
);
3229 evaluate_statement(stmt
->case_statement
);
3232 static void check_case_type(struct expression
*switch_expr
,
3233 struct expression
*case_expr
,
3234 struct expression
**enumcase
)
3236 struct symbol
*switch_type
, *case_type
;
3242 switch_type
= switch_expr
->ctype
;
3243 case_type
= evaluate_expression(case_expr
);
3245 if (!switch_type
|| !case_type
)
3249 warn_for_different_enum_types(case_expr
->pos
, case_type
, (*enumcase
)->ctype
);
3250 else if (is_enum_type(case_type
))
3251 *enumcase
= case_expr
;
3254 sclass
= classify_type(switch_type
, &switch_type
);
3255 cclass
= classify_type(case_type
, &case_type
);
3257 /* both should be arithmetic */
3258 if (!(sclass
& cclass
& TYPE_NUM
))
3261 /* neither should be floating */
3262 if ((sclass
| cclass
) & TYPE_FLOAT
)
3265 /* if neither is restricted, we are OK */
3266 if (!((sclass
| cclass
) & TYPE_RESTRICT
))
3269 if (!restricted_binop_type(SPECIAL_EQUAL
, case_expr
, switch_expr
,
3270 cclass
, sclass
, case_type
, switch_type
)) {
3271 unrestrict(case_expr
, cclass
, &case_type
);
3272 unrestrict(switch_expr
, sclass
, &switch_type
);
3277 expression_error(case_expr
, "incompatible types for 'case' statement");
3280 static void evaluate_switch_statement(struct statement
*stmt
)
3283 struct expression
*enumcase
= NULL
;
3284 struct expression
**enumcase_holder
= &enumcase
;
3285 struct expression
*sel
= stmt
->switch_expression
;
3287 evaluate_expression(sel
);
3288 evaluate_statement(stmt
->switch_statement
);
3291 if (sel
->ctype
&& is_enum_type(sel
->ctype
))
3292 enumcase_holder
= NULL
; /* Only check cases against switch */
3294 FOR_EACH_PTR(stmt
->switch_case
->symbol_list
, sym
) {
3295 struct statement
*case_stmt
= sym
->stmt
;
3296 check_case_type(sel
, case_stmt
->case_expression
, enumcase_holder
);
3297 check_case_type(sel
, case_stmt
->case_to
, enumcase_holder
);
3298 } END_FOR_EACH_PTR(sym
);
3301 struct symbol
*evaluate_statement(struct statement
*stmt
)
3306 switch (stmt
->type
) {
3307 case STMT_DECLARATION
: {
3309 FOR_EACH_PTR(stmt
->declaration
, s
) {
3311 } END_FOR_EACH_PTR(s
);
3316 return evaluate_return_expression(stmt
);
3318 case STMT_EXPRESSION
:
3319 if (!evaluate_expression(stmt
->expression
))
3321 if (stmt
->expression
->ctype
== &null_ctype
)
3322 stmt
->expression
= cast_to(stmt
->expression
, &ptr_ctype
);
3323 return degenerate(stmt
->expression
);
3325 case STMT_COMPOUND
: {
3326 struct statement
*s
;
3327 struct symbol
*type
= NULL
;
3329 /* Evaluate the return symbol in the compound statement */
3330 evaluate_symbol(stmt
->ret
);
3333 * Then, evaluate each statement, making the type of the
3334 * compound statement be the type of the last statement
3336 type
= evaluate_statement(stmt
->args
);
3337 FOR_EACH_PTR(stmt
->stmts
, s
) {
3338 type
= evaluate_statement(s
);
3339 } END_FOR_EACH_PTR(s
);
3345 evaluate_if_statement(stmt
);
3348 evaluate_iterator(stmt
);
3351 evaluate_switch_statement(stmt
);
3354 evaluate_case_statement(stmt
);
3357 return evaluate_statement(stmt
->label_statement
);
3359 evaluate_expression(stmt
->goto_expression
);
3364 evaluate_asm_statement(stmt
);
3367 evaluate_expression(stmt
->expression
);
3370 evaluate_expression(stmt
->range_expression
);
3371 evaluate_expression(stmt
->range_low
);
3372 evaluate_expression(stmt
->range_high
);