semantic: Extend expression classification to detect integer constant expressions.

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index 8a52156..9ddd3b2 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -136,11 +136,8 @@ static void enqueue_inner_function(entity_t *entity)
 static ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos)
 {
        const entity_t *entity = get_irg_loc_description(irg, pos);
-
-       if (entity != NULL) {
-               position_t const *const pos = &entity->base.pos;
-               warningf(WARN_UNINITIALIZED, pos, "'%N' might be used uninitialized", entity);
-       }
+       if (entity)
+               warningf(WARN_UNINITIALIZED, &entity->base.pos, "'%N' might be used uninitialized", entity);
        return new_r_Unknown(irg, mode);
 }
 
@@ -604,15 +601,15 @@ static ir_type *create_compound_type(compound_type_t *const type, bool const inc
 
                symbol_t *symbol     = entry->base.symbol;
                type_t   *entry_type = entry->declaration.type;
-               ident    *ident;
+               ident    *member_id;
                if (symbol == NULL) {
                        /* anonymous bitfield member, skip */
                        if (entry->compound_member.bitfield)
                                continue;
                        assert(is_type_compound(entry_type));
-                       ident = id_unique("anon.%u");
+                       member_id = id_unique("anon.%u");
                } else {
-                       ident = new_id_from_str(symbol->string);
+                       member_id = new_id_from_str(symbol->string);
                }
 
                dbg_info *dbgi = get_dbg_info(&entry->base.pos);
@@ -623,7 +620,7 @@ static ir_type *create_compound_type(compound_type_t *const type, bool const inc
                } else {
                        entry_irtype = get_ir_type(entry_type);
                }
-               ir_entity *entity = new_d_entity(irtype, ident, entry_irtype, dbgi);
+               ir_entity *entity = new_d_entity(irtype, member_id, entry_irtype, dbgi);
 
                set_entity_offset(entity, entry->compound_member.offset);
                set_entity_offset_bits_remainder(entity,
@@ -2161,10 +2158,10 @@ static ir_node *handle_assume_compare(dbg_info *dbi,
        }
 
        expression_t *con = NULL;
-       if (is_local_variable(op1) && is_constant_expression(op2) == EXPR_CLASS_CONSTANT) {
+       if (is_local_variable(op1) && is_constant_expression(op2) != EXPR_CLASS_VARIABLE) {
                var = op1->reference.entity;
                con = op2;
-       } else if (is_constant_expression(op1) == EXPR_CLASS_CONSTANT && is_local_variable(op2)) {
+       } else if (is_constant_expression(op1) != EXPR_CLASS_VARIABLE && is_local_variable(op2)) {
                relation = get_inversed_relation(relation);
                var = op2->reference.entity;
                con = op1;
@@ -2447,7 +2444,7 @@ static void compare_to_control_flow(expression_t const *const expr, ir_node *con
                /* set branch prediction info based on __builtin_expect */
                if (is_builtin_expect(expr) && is_Cond(cond)) {
                        call_argument_t *const argument = expr->call.arguments->next;
-                       if (is_constant_expression(argument->expression) == EXPR_CLASS_CONSTANT) {
+                       if (is_constant_expression(argument->expression) != EXPR_CLASS_VARIABLE) {
                                bool               const cnst = fold_constant_to_bool(argument->expression);
                                cond_jmp_predicate const pred = cnst ? COND_JMP_PRED_TRUE : COND_JMP_PRED_FALSE;
                                set_Cond_jmp_pred(cond, pred);
@@ -2647,9 +2644,10 @@ static ir_node *compound_literal_addr(compound_literal_expression_t const *const
        type_t        *type        = expression->type;
        initializer_t *initializer = expression->initializer;
 
-       if (expression->global_scope ||
-               ((type->base.qualifiers & TYPE_QUALIFIER_CONST)
-           && is_constant_initializer(initializer) == EXPR_CLASS_CONSTANT)) {
+       if (expression->global_scope || (
+             type->base.qualifiers & TYPE_QUALIFIER_CONST &&
+             is_constant_initializer(initializer) != EXPR_CLASS_VARIABLE
+           )) {
                ir_entity *entity = create_initializer_entity(dbgi, initializer, type);
                return create_symconst(dbgi, entity);
        } else {
@@ -2748,7 +2746,7 @@ static void init_ir_types(void);
 
 ir_tarval *fold_constant_to_tarval(const expression_t *expression)
 {
-       assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
+       assert(is_constant_expression(expression) >= EXPR_CLASS_CONSTANT);
 
        bool constant_folding_old = constant_folding;
        constant_folding = true;
@@ -2774,7 +2772,7 @@ ir_tarval *fold_constant_to_tarval(const expression_t *expression)
 
 static complex_constant fold_complex_constant(const expression_t *expression)
 {
-       assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
+       assert(is_constant_expression(expression) >= EXPR_CLASS_CONSTANT);
 
        bool constant_folding_old = constant_folding;
        constant_folding = true;
@@ -3148,7 +3146,7 @@ static ir_node *builtin_constant_to_firm(
                const builtin_constant_expression_t *expression)
 {
        ir_mode *const mode = get_ir_mode_storage(expression->base.type);
-       bool     const v    = is_constant_expression(expression->value) == EXPR_CLASS_CONSTANT;
+       bool     const v    = is_constant_expression(expression->value) != EXPR_CLASS_VARIABLE;
        return create_Const_from_bool(mode, v);
 }
 
@@ -4723,12 +4721,12 @@ static void create_variable_initializer(entity_t *entity)
                                                && get_entity_owner(irentity) != get_tls_type()) {
                                        add_entity_linkage(irentity, IR_LINKAGE_CONSTANT);
                                }
-                               ir_initializer_t *initializer = create_initializer_compound(2);
+                               ir_initializer_t *complex_init = create_initializer_compound(2);
                                ir_initializer_t *reali = create_initializer_const(real);
-                               set_initializer_compound_value(initializer, 0, reali);
+                               set_initializer_compound_value(complex_init, 0, reali);
                                ir_initializer_t *imagi = create_initializer_const(imag);
-                               set_initializer_compound_value(initializer, 1, imagi);
-                               set_entity_initializer(irentity, initializer);
+                               set_initializer_compound_value(complex_init, 1, imagi);
+                               set_entity_initializer(irentity, complex_init);
                        }
                        return;
                } else if (!is_type_scalar(init_type)) {
@@ -5155,7 +5153,7 @@ static ir_node *do_while_statement_to_firm(do_while_statement_t *statement)
 
        expression_t *const cond = statement->condition;
        /* Avoid an explicit body block in case of do ... while (0);. */
-       if (is_constant_expression(cond) == EXPR_CLASS_CONSTANT && !fold_constant_to_bool(cond)) {
+       if (is_constant_expression(cond) != EXPR_CLASS_VARIABLE && !fold_constant_to_bool(cond)) {
                /* do ... while (0);. */
                statement_to_firm(statement->body);
                jump_to_target(&continue_target);
@@ -5211,7 +5209,7 @@ static ir_node *for_statement_to_firm(for_statement_t *statement)
 
        /* Create the condition. */
        expression_t *const cond = statement->condition;
-       if (cond && (is_constant_expression(cond) != EXPR_CLASS_CONSTANT || !fold_constant_to_bool(cond))) {
+       if (cond && (is_constant_expression(cond) == EXPR_CLASS_VARIABLE || !fold_constant_to_bool(cond))) {
                jump_target body_target;
                init_jump_target(&body_target, NULL);
                expression_to_control_flow(cond, &body_target, &break_target);