4 * Copyright (C) 2003 Transmeta Corp.
7 * Licensed under the Open Software License version 1.1
9 * expand constant expressions.
26 #include "expression.h"
28 static void expand_expression(struct expression
*);
29 static void expand_statement(struct statement
*);
31 static void expand_symbol_expression(struct expression
*expr
)
33 struct symbol
*sym
= expr
->symbol
;
36 * The preprocessor can cause unknown symbols to be generated
39 warn(expr
->pos
, "undefined preprocessor identifier '%s'", show_ident(expr
->symbol_name
));
40 expr
->type
= EXPR_VALUE
;
46 void cast_value(struct expression
*expr
, struct symbol
*newtype
,
47 struct expression
*old
, struct symbol
*oldtype
)
49 int old_size
= oldtype
->bit_size
;
50 int new_size
= newtype
->bit_size
;
51 long long value
, mask
, ormask
, andmask
;
54 // FIXME! We don't handle FP casts of constant values yet
55 if (newtype
->ctype
.base_type
== &fp_type
)
57 if (oldtype
->ctype
.base_type
== &fp_type
)
60 // For pointers and integers, we can just move the value around
61 expr
->type
= EXPR_VALUE
;
62 if (old_size
== new_size
) {
63 expr
->value
= old
->value
;
67 // expand it to the full "long long" value
68 is_signed
= !(oldtype
->ctype
.modifiers
& MOD_UNSIGNED
);
69 mask
= 1ULL << (old_size
-1);
73 andmask
= mask
| (mask
-1);
77 value
= (value
& andmask
) | ormask
;
79 // Truncate it to the new size
80 mask
= 1ULL << (new_size
-1);
81 mask
= mask
| (mask
-1);
82 expr
->value
= value
& mask
;
85 static int check_shift_count(struct expression
*expr
, struct symbol
*ctype
, unsigned int count
)
87 if (count
>= ctype
->bit_size
) {
88 warn(expr
->pos
, "shift too big for type");
89 count
&= ctype
->bit_size
-1;
95 * CAREFUL! We need to get the size and sign of the
98 static void simplify_int_binop(struct expression
*expr
, struct symbol
*ctype
)
100 struct expression
*left
= expr
->left
, *right
= expr
->right
;
101 unsigned long long v
, l
, r
, mask
;
102 signed long long s
, sl
, sr
;
103 int is_signed
, shift
;
105 if (left
->type
!= EXPR_VALUE
|| right
->type
!= EXPR_VALUE
)
107 l
= left
->value
; r
= right
->value
;
108 is_signed
= !(ctype
->ctype
.modifiers
& MOD_UNSIGNED
);
109 mask
= 1ULL << (ctype
->bit_size
-1);
111 if (is_signed
&& (sl
& mask
))
113 if (is_signed
&& (sr
& mask
))
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
= v
; break;
122 case '*': v
= l
* r
; s
= sl
* sr
; break;
123 case '/': if (!r
) return; v
= l
/ r
; s
= sl
/ sr
; break;
124 case '%': if (!r
) return; v
= l
% r
; s
= sl
% sr
; break;
125 case SPECIAL_LEFTSHIFT
: shift
= check_shift_count(expr
, ctype
, r
); v
= l
<< shift
; s
= v
; break;
126 case SPECIAL_RIGHTSHIFT
:shift
= check_shift_count(expr
, ctype
, r
); v
= l
>> shift
; s
= sl
>> shift
; break;
127 case '<': v
= l
< r
; s
= sl
< sr
; break;
128 case '>': v
= l
> r
; s
= sl
> sr
; break;
129 case SPECIAL_LTE
: v
= l
<= r
; s
= sl
<= sr
; break;
130 case SPECIAL_GTE
: v
= l
>= r
; s
= sl
>= sr
; break;
131 case SPECIAL_EQUAL
: v
= l
== r
; s
= v
; break;
132 case SPECIAL_NOTEQUAL
: v
= l
!= r
; s
= v
; break;
137 mask
= mask
| (mask
-1);
138 expr
->value
= v
& mask
;
139 expr
->type
= EXPR_VALUE
;
142 static void expand_int_binop(struct expression
*expr
)
144 simplify_int_binop(expr
, expr
->ctype
);
147 static void expand_logical(struct expression
*expr
)
149 struct expression
*left
= expr
->left
;
150 struct expression
*right
;
152 /* Do immediate short-circuiting ... */
153 expand_expression(left
);
154 if (left
->type
== EXPR_VALUE
) {
155 if (expr
->op
== SPECIAL_LOGICAL_AND
) {
157 expr
->type
= EXPR_VALUE
;
163 expr
->type
= EXPR_VALUE
;
171 expand_expression(right
);
172 if (left
->type
== EXPR_VALUE
&& right
->type
== EXPR_VALUE
) {
174 * We know the left value doesn't matter, since
175 * otherwise we would have short-circuited it..
177 expr
->type
= EXPR_VALUE
;
178 expr
->value
= right
->value
;
182 static void expand_binop(struct expression
*expr
)
184 expand_int_binop(expr
);
187 static void expand_comma(struct expression
*expr
)
189 if (expr
->left
->type
== EXPR_VALUE
)
190 *expr
= *expr
->right
;
193 static void expand_compare(struct expression
*expr
)
195 simplify_int_binop(expr
, expr
->ctype
);
198 static void expand_conditional(struct expression
*expr
)
200 struct expression
*cond
= expr
->conditional
;
202 if (cond
->type
== EXPR_VALUE
) {
203 struct expression
*true, *false;
205 true = expr
->cond_true
? : cond
;
206 false = expr
->cond_false
;
214 static void expand_assignment(struct expression
*expr
)
218 static void expand_addressof(struct expression
*expr
)
222 static void expand_dereference(struct expression
*expr
)
224 struct expression
*unop
= expr
->unop
;
225 if (unop
->type
== EXPR_SYMBOL
) {
226 struct symbol
*sym
= unop
->symbol
;
228 if (sym
->ctype
.modifiers
& MOD_NODEREF
)
229 warn(expr
->pos
, "dereference of '%s'", show_ident(sym
->ident
));
231 /* Const symbol with a constant initializer? */
232 if (!(sym
->ctype
.modifiers
& (MOD_ASSIGNED
| MOD_ADDRESSABLE
))) {
233 struct expression
*value
= sym
->initializer
;
235 if (value
->type
== EXPR_VALUE
) {
236 expr
->type
= EXPR_VALUE
;
237 expr
->value
= value
->value
;
244 static void simplify_preop(struct expression
*expr
)
246 struct expression
*op
= expr
->unop
;
247 unsigned long long v
, mask
;
249 if (op
->type
!= EXPR_VALUE
)
254 case '-': v
= -v
; break;
255 case '!': v
= !v
; break;
256 case '~': v
= ~v
; break;
259 mask
= 1ULL << (expr
->ctype
->bit_size
-1);
260 mask
= mask
| (mask
-1);
261 expr
->value
= v
& mask
;
262 expr
->type
= EXPR_VALUE
;
266 * Unary post-ops: x++ and x--
268 static void expand_postop(struct expression
*expr
)
272 static void expand_preop(struct expression
*expr
)
276 expand_dereference(expr
);
280 expand_addressof(expr
);
283 case SPECIAL_INCREMENT
:
284 case SPECIAL_DECREMENT
:
286 * From a type evaluation standpoint the pre-ops are
287 * the same as the postops
295 simplify_preop(expr
);
298 static void expand_arguments(struct expression_list
*head
)
300 struct expression
*expr
;
302 FOR_EACH_PTR (head
, expr
) {
303 expand_expression(expr
);
307 static void expand_cast(struct expression
*expr
)
309 struct expression
*target
= expr
->cast_expression
;
311 expand_expression(target
);
313 /* Simplify normal integer casts.. */
314 if (target
->type
== EXPR_VALUE
)
315 cast_value(expr
, expr
->ctype
, target
, target
->ctype
);
319 * expand a call expression with a symbol. This
320 * should expand inline functions, and expand
323 static void expand_symbol_call(struct expression
*expr
)
325 struct expression
*fn
= expr
->fn
;
326 struct symbol
*ctype
= fn
->ctype
;
328 if (fn
->type
!= EXPR_PREOP
)
331 if (ctype
->op
&& ctype
->op
->expand
) {
332 ctype
->op
->expand(expr
);
337 static void expand_call(struct expression
*expr
)
340 struct expression
*fn
= expr
->fn
;
343 expand_arguments(expr
->args
);
344 if (sym
->type
== SYM_NODE
)
345 expand_symbol_call(expr
);
348 static void expand_expression_list(struct expression_list
*list
)
350 struct expression
*expr
;
352 FOR_EACH_PTR(list
, expr
) {
353 expand_expression(expr
);
357 static void expand_expression(struct expression
*expr
)
364 switch (expr
->type
) {
370 expand_symbol_expression(expr
);
373 expand_expression(expr
->left
);
374 expand_expression(expr
->right
);
379 expand_logical(expr
);
383 expand_expression(expr
->left
);
384 expand_expression(expr
->right
);
389 expand_expression(expr
->left
);
390 expand_expression(expr
->right
);
391 expand_compare(expr
);
394 case EXPR_ASSIGNMENT
:
395 expand_expression(expr
->left
);
396 expand_expression(expr
->right
);
397 expand_assignment(expr
);
401 expand_expression(expr
->unop
);
406 expand_expression(expr
->unop
);
422 expand_expression(expr
->address
);
425 case EXPR_CONDITIONAL
:
426 expand_expression(expr
->conditional
);
427 expand_expression(expr
->cond_false
);
428 expand_expression(expr
->cond_true
);
429 expand_conditional(expr
);
433 expand_statement(expr
->statement
);
439 case EXPR_INITIALIZER
:
440 expand_expression_list(expr
->expr_list
);
443 case EXPR_IDENTIFIER
:
450 expand_expression(expr
->init_expr
);
454 warn(expr
->pos
, "internal front-end error: sizeof in expansion?");
460 static void expand_const_expression(struct expression
*expr
, const char *where
)
463 expand_expression(expr
);
464 if (expr
->type
!= EXPR_VALUE
)
465 warn(expr
->pos
, "Expected constant expression in %s", where
);
469 void expand_symbol(struct symbol
*sym
)
471 struct symbol
*base_type
;
475 base_type
= sym
->ctype
.base_type
;
479 expand_expression(sym
->initializer
);
480 /* expand the body of the symbol */
481 if (base_type
->type
== SYM_FN
) {
483 expand_statement(base_type
->stmt
);
487 static void expand_return_expression(struct statement
*stmt
)
489 expand_expression(stmt
->expression
);
492 static void expand_if_statement(struct statement
*stmt
)
494 struct expression
*expr
= stmt
->if_conditional
;
496 if (!expr
|| !expr
->ctype
)
499 expand_expression(expr
);
501 /* This is only valid if nobody jumps into the "dead" side */
503 /* Simplify constant conditionals without even evaluating the false side */
504 if (expr
->type
== EXPR_VALUE
) {
505 struct statement
*simple
;
506 simple
= expr
->value
? stmt
->if_true
: stmt
->if_false
;
510 stmt
->type
= STMT_NONE
;
513 expand_statement(simple
);
518 expand_statement(stmt
->if_true
);
519 expand_statement(stmt
->if_false
);
522 static void expand_statement(struct statement
*stmt
)
527 switch (stmt
->type
) {
529 expand_return_expression(stmt
);
532 case STMT_EXPRESSION
:
533 expand_expression(stmt
->expression
);
536 case STMT_COMPOUND
: {
540 FOR_EACH_PTR(stmt
->syms
, sym
) {
543 expand_symbol(stmt
->ret
);
545 FOR_EACH_PTR(stmt
->stmts
, s
) {
552 expand_if_statement(stmt
);
556 expand_expression(stmt
->iterator_pre_condition
);
557 expand_expression(stmt
->iterator_post_condition
);
558 expand_statement(stmt
->iterator_pre_statement
);
559 expand_statement(stmt
->iterator_statement
);
560 expand_statement(stmt
->iterator_post_statement
);
564 expand_expression(stmt
->switch_expression
);
565 expand_statement(stmt
->switch_statement
);
569 expand_const_expression(stmt
->case_expression
, "case statement");
570 expand_const_expression(stmt
->case_to
, "case statement");
571 expand_statement(stmt
->case_statement
);
575 expand_statement(stmt
->label_statement
);
579 expand_expression(stmt
->goto_expression
);
585 /* FIXME! Do the asm parameter evaluation! */
588 /* Should not show up at this stage */
591 case STMT_MULTIVALUE
:
597 long long get_expression_value(struct expression
*expr
)
599 long long value
, mask
;
600 struct symbol
*ctype
;
604 ctype
= evaluate_expression(expr
);
606 warn(expr
->pos
, "bad constant expression type");
609 expand_expression(expr
);
610 if (expr
->type
!= EXPR_VALUE
) {
611 warn(expr
->pos
, "bad constant expression");
616 mask
= 1ULL << (ctype
->bit_size
-1);
619 while (ctype
->type
!= SYM_BASETYPE
)
620 ctype
= ctype
->ctype
.base_type
;
621 if (!(ctype
->ctype
.modifiers
& MOD_UNSIGNED
))
622 value
= value
| mask
| ~(mask
-1);