4 * Copyright (C) 2003 Transmeta Corp.
6 * Licensed under the Open Software License version 1.1
8 * expand constant expressions.
25 #include "expression.h"
27 static void expand_expression(struct expression
*);
28 static void expand_statement(struct statement
*);
30 static void expand_symbol_expression(struct expression
*expr
)
32 struct symbol
*sym
= expr
->symbol
;
35 * The preprocessor can cause unknown symbols to be generated
38 warn(expr
->pos
, "undefined preprocessor identifier '%s'", show_ident(expr
->symbol_name
));
39 expr
->type
= EXPR_VALUE
;
45 void cast_value(struct expression
*expr
, struct symbol
*newtype
,
46 struct expression
*old
, struct symbol
*oldtype
)
48 int old_size
= oldtype
->bit_size
;
49 int new_size
= newtype
->bit_size
;
50 long long value
, mask
, ormask
, andmask
;
53 // FIXME! We don't handle FP casts of constant values yet
54 if (newtype
->ctype
.base_type
== &fp_type
)
56 if (oldtype
->ctype
.base_type
== &fp_type
)
59 // For pointers and integers, we can just move the value around
60 expr
->type
= EXPR_VALUE
;
61 if (old_size
== new_size
) {
62 expr
->value
= old
->value
;
66 // expand it to the full "long long" value
67 is_signed
= !(oldtype
->ctype
.modifiers
& MOD_UNSIGNED
);
68 mask
= 1ULL << (old_size
-1);
72 andmask
= mask
| (mask
-1);
76 value
= (value
& andmask
) | ormask
;
78 // Truncate it to the new size
79 mask
= 1ULL << (new_size
-1);
80 mask
= mask
| (mask
-1);
81 expr
->value
= value
& mask
;
84 static int check_shift_count(struct expression
*expr
, struct symbol
*ctype
, unsigned int count
)
86 if (count
>= ctype
->bit_size
) {
87 warn(expr
->pos
, "shift too big for type");
88 count
&= ctype
->bit_size
-1;
94 * CAREFUL! We need to get the size and sign of the
97 static void simplify_int_binop(struct expression
*expr
, struct symbol
*ctype
)
99 struct expression
*left
= expr
->left
, *right
= expr
->right
;
100 unsigned long long v
, l
, r
, mask
;
101 signed long long s
, sl
, sr
;
102 int is_signed
, shift
;
104 if (left
->type
!= EXPR_VALUE
|| right
->type
!= EXPR_VALUE
)
106 l
= left
->value
; r
= right
->value
;
107 is_signed
= !(ctype
->ctype
.modifiers
& MOD_UNSIGNED
);
108 mask
= 1ULL << (ctype
->bit_size
-1);
110 if (is_signed
&& (sl
& mask
))
112 if (is_signed
&& (sr
& mask
))
116 case '+': v
= l
+ r
; s
= v
; break;
117 case '-': v
= l
- r
; s
= v
; break;
118 case '&': v
= l
& r
; s
= v
; break;
119 case '|': v
= l
| r
; s
= v
; break;
120 case '^': v
= l
^ r
; s
= v
; break;
121 case '*': v
= l
* r
; s
= sl
* sr
; break;
122 case '/': if (!r
) return; v
= l
/ r
; s
= sl
/ sr
; break;
123 case '%': if (!r
) return; v
= l
% r
; s
= sl
% sr
; break;
124 case SPECIAL_LEFTSHIFT
: shift
= check_shift_count(expr
, ctype
, r
); v
= l
<< shift
; s
= v
; break;
125 case SPECIAL_RIGHTSHIFT
:shift
= check_shift_count(expr
, ctype
, r
); v
= l
>> shift
; s
= sl
>> shift
; break;
126 case '<': v
= l
< r
; s
= sl
< sr
; break;
127 case '>': v
= l
> r
; s
= sl
> sr
; break;
128 case SPECIAL_LTE
: v
= l
<= r
; s
= sl
<= sr
; break;
129 case SPECIAL_GTE
: v
= l
>= r
; s
= sl
>= sr
; break;
130 case SPECIAL_EQUAL
: v
= l
== r
; s
= v
; break;
131 case SPECIAL_NOTEQUAL
: v
= l
!= r
; s
= v
; break;
136 mask
= mask
| (mask
-1);
137 expr
->value
= v
& mask
;
138 expr
->type
= EXPR_VALUE
;
141 static void expand_int_binop(struct expression
*expr
)
143 simplify_int_binop(expr
, expr
->ctype
);
146 static void expand_logical(struct expression
*expr
)
148 struct expression
*left
= expr
->left
;
149 struct expression
*right
;
151 /* Do immediate short-circuiting ... */
152 expand_expression(left
);
153 if (left
->type
== EXPR_VALUE
) {
154 if (expr
->op
== SPECIAL_LOGICAL_AND
) {
156 expr
->type
= EXPR_VALUE
;
162 expr
->type
= EXPR_VALUE
;
170 expand_expression(right
);
171 if (left
->type
== EXPR_VALUE
&& right
->type
== EXPR_VALUE
) {
173 * We know the left value doesn't matter, since
174 * otherwise we would have short-circuited it..
176 expr
->type
= EXPR_VALUE
;
177 expr
->value
= right
->value
;
181 static void expand_binop(struct expression
*expr
)
183 expand_int_binop(expr
);
186 static void expand_comma(struct expression
*expr
)
188 if (expr
->left
->type
== EXPR_VALUE
)
189 *expr
= *expr
->right
;
192 static void expand_compare(struct expression
*expr
)
194 simplify_int_binop(expr
, expr
->ctype
);
197 static void expand_conditional(struct expression
*expr
)
199 struct expression
*cond
= expr
->conditional
;
201 if (cond
->type
== EXPR_VALUE
) {
202 struct expression
*true, *false;
204 true = expr
->cond_true
? : cond
;
205 false = expr
->cond_false
;
213 static void expand_assignment(struct expression
*expr
)
217 static void expand_addressof(struct expression
*expr
)
221 static void expand_dereference(struct expression
*expr
)
223 struct expression
*unop
= expr
->unop
;
224 if (unop
->type
== EXPR_SYMBOL
) {
225 struct symbol
*sym
= unop
->symbol
;
227 if (sym
->ctype
.modifiers
& MOD_NODEREF
)
228 warn(expr
->pos
, "dereference of '%s'", show_ident(sym
->ident
));
230 /* Const symbol with a constant initializer? */
231 if (!(sym
->ctype
.modifiers
& (MOD_ASSIGNED
| MOD_ADDRESSABLE
))) {
232 struct expression
*value
= sym
->initializer
;
234 if (value
->type
== EXPR_VALUE
) {
235 expr
->type
= EXPR_VALUE
;
236 expr
->value
= value
->value
;
243 static void simplify_preop(struct expression
*expr
)
245 struct expression
*op
= expr
->unop
;
246 unsigned long long v
, mask
;
248 if (op
->type
!= EXPR_VALUE
)
253 case '-': v
= -v
; break;
254 case '!': v
= !v
; break;
255 case '~': v
= ~v
; break;
258 mask
= 1ULL << (expr
->ctype
->bit_size
-1);
259 mask
= mask
| (mask
-1);
260 expr
->value
= v
& mask
;
261 expr
->type
= EXPR_VALUE
;
265 * Unary post-ops: x++ and x--
267 static void expand_postop(struct expression
*expr
)
271 static void expand_preop(struct expression
*expr
)
275 expand_dereference(expr
);
279 expand_addressof(expr
);
282 case SPECIAL_INCREMENT
:
283 case SPECIAL_DECREMENT
:
285 * From a type evaluation standpoint the pre-ops are
286 * the same as the postops
294 simplify_preop(expr
);
297 static void expand_arguments(struct expression_list
*head
)
299 struct expression
*expr
;
301 FOR_EACH_PTR (head
, expr
) {
302 expand_expression(expr
);
306 static void expand_cast(struct expression
*expr
)
308 struct expression
*target
= expr
->cast_expression
;
310 expand_expression(target
);
312 /* Simplify normal integer casts.. */
313 if (target
->type
== EXPR_VALUE
)
314 cast_value(expr
, expr
->ctype
, target
, target
->ctype
);
318 * expand a call expression with a symbol. This
319 * should expand inline functions, and expand
322 static void expand_symbol_call(struct expression
*expr
)
324 struct expression
*fn
= expr
->fn
;
325 struct symbol
*ctype
= fn
->ctype
;
327 if (fn
->type
!= EXPR_PREOP
)
330 if (ctype
->op
&& ctype
->op
->expand
) {
331 ctype
->op
->expand(expr
);
336 static void expand_call(struct expression
*expr
)
339 struct expression
*fn
= expr
->fn
;
342 expand_arguments(expr
->args
);
343 if (sym
->type
== SYM_NODE
)
344 expand_symbol_call(expr
);
347 static void expand_expression_list(struct expression_list
*list
)
349 struct expression
*expr
;
351 FOR_EACH_PTR(list
, expr
) {
352 expand_expression(expr
);
356 static void expand_expression(struct expression
*expr
)
363 switch (expr
->type
) {
369 expand_symbol_expression(expr
);
372 expand_expression(expr
->left
);
373 expand_expression(expr
->right
);
378 expand_logical(expr
);
382 expand_expression(expr
->left
);
383 expand_expression(expr
->right
);
388 expand_expression(expr
->left
);
389 expand_expression(expr
->right
);
390 expand_compare(expr
);
393 case EXPR_ASSIGNMENT
:
394 expand_expression(expr
->left
);
395 expand_expression(expr
->right
);
396 expand_assignment(expr
);
400 expand_expression(expr
->unop
);
405 expand_expression(expr
->unop
);
421 expand_expression(expr
->address
);
424 case EXPR_CONDITIONAL
:
425 expand_expression(expr
->conditional
);
426 expand_expression(expr
->cond_false
);
427 expand_expression(expr
->cond_true
);
428 expand_conditional(expr
);
432 expand_statement(expr
->statement
);
438 case EXPR_INITIALIZER
:
439 expand_expression_list(expr
->expr_list
);
442 case EXPR_IDENTIFIER
:
449 expand_expression(expr
->init_expr
);
453 warn(expr
->pos
, "internal front-end error: sizeof in expansion?");
460 void expand_symbol(struct symbol
*sym
)
462 struct symbol
*base_type
;
466 base_type
= sym
->ctype
.base_type
;
470 expand_expression(sym
->initializer
);
471 /* expand the body of the symbol */
472 if (base_type
->type
== SYM_FN
) {
474 expand_statement(base_type
->stmt
);
478 static void expand_return_expression(struct statement
*stmt
)
480 expand_expression(stmt
->expression
);
483 static void expand_if_statement(struct statement
*stmt
)
485 struct expression
*expr
= stmt
->if_conditional
;
487 if (!expr
|| !expr
->ctype
)
490 expand_expression(expr
);
492 /* Simplify constant conditionals without even evaluating the false side */
493 if (expr
->type
== EXPR_VALUE
) {
494 struct statement
*simple
;
495 simple
= expr
->value
? stmt
->if_true
: stmt
->if_false
;
499 stmt
->type
= STMT_NONE
;
502 expand_statement(simple
);
506 expand_statement(stmt
->if_true
);
507 expand_statement(stmt
->if_false
);
510 static void expand_statement(struct statement
*stmt
)
515 switch (stmt
->type
) {
517 expand_return_expression(stmt
);
520 case STMT_EXPRESSION
:
521 expand_expression(stmt
->expression
);
524 case STMT_COMPOUND
: {
528 FOR_EACH_PTR(stmt
->syms
, sym
) {
531 expand_symbol(stmt
->ret
);
533 FOR_EACH_PTR(stmt
->stmts
, s
) {
540 expand_if_statement(stmt
);
544 expand_expression(stmt
->iterator_pre_condition
);
545 expand_expression(stmt
->iterator_post_condition
);
546 expand_statement(stmt
->iterator_pre_statement
);
547 expand_statement(stmt
->iterator_statement
);
548 expand_statement(stmt
->iterator_post_statement
);
552 expand_expression(stmt
->switch_expression
);
553 expand_statement(stmt
->switch_statement
);
557 expand_expression(stmt
->case_expression
);
558 expand_expression(stmt
->case_to
);
559 expand_statement(stmt
->case_statement
);
563 expand_statement(stmt
->label_statement
);
567 expand_expression(stmt
->goto_expression
);
573 /* FIXME! Do the asm parameter evaluation! */
578 long long get_expression_value(struct expression
*expr
)
580 long long value
, mask
;
581 struct symbol
*ctype
;
583 ctype
= evaluate_expression(expr
);
585 warn(expr
->pos
, "bad constant expression type");
588 expand_expression(expr
);
589 if (expr
->type
!= EXPR_VALUE
) {
590 warn(expr
->pos
, "bad constant expression");
595 mask
= 1ULL << (ctype
->bit_size
-1);
598 while (ctype
->type
!= SYM_BASETYPE
)
599 ctype
= ctype
->ctype
.base_type
;
600 if (!(ctype
->ctype
.modifiers
& MOD_UNSIGNED
))
601 value
= value
| mask
| ~(mask
-1);