X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=384450c8ab577f8f835861c018fae8c1f2bb5103;hb=84b4c24ec6848505549af4b240df492317138f27;hp=2e85c8aa512fbdfeb19339fd5471bb321fdc02fe;hpb=8845feb009950d2c76a394660a5bd81a0be0f2a6;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 2e85c8a..384450c 100644 --- 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); } @@ -238,12 +235,6 @@ static void init_atomic_modes(void) } } -ir_mode *get_atomic_mode(atomic_type_kind_t kind) -{ - assert(kind <= ATOMIC_TYPE_LAST); - return atomic_modes[kind]; -} - static ir_node *get_vla_size(array_type_t *const type) { ir_node *size_node = type->size_node; @@ -337,6 +328,8 @@ static type_t *get_parameter_type(type_t *orig_type) return type; } +static ir_type *get_ir_type(type_t *type); + static ir_type *create_method_type(const function_type_t *function_type, bool for_closure) { type_t *return_type = skip_typeref(function_type->return_type); @@ -485,10 +478,12 @@ static ir_type *get_signed_int_type_for_bit_size(ir_type *base_tp, mode = s_modes[size]; if (mode == NULL) { - char name[32]; + ir_mode *base_mode = get_type_mode(base_tp); + unsigned modulo_shift = get_mode_modulo_shift(base_mode); + char name[32]; snprintf(name, sizeof(name), "bf_I%u", size); - mode = new_int_mode(name, irma_twos_complement, size, 1, 0); + mode = new_int_mode(name, irma_twos_complement, size, 1, modulo_shift); s_modes[size] = mode; } @@ -517,10 +512,12 @@ static ir_type *get_unsigned_int_type_for_bit_size(ir_type *base_tp, mode = u_modes[size]; if (mode == NULL) { - char name[32]; + ir_mode *base_mode = get_type_mode(base_tp); + unsigned modulo_shift = get_mode_modulo_shift(base_mode); + char name[32]; snprintf(name, sizeof(name), "bf_U%u", size); - mode = new_int_mode(name, irma_twos_complement, size, 0, 0); + mode = new_int_mode(name, irma_twos_complement, size, 0, modulo_shift); u_modes[size] = mode; } @@ -600,15 +597,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); @@ -619,7 +616,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, @@ -679,7 +676,7 @@ static ir_type *get_ir_type_incomplete(type_t *type) } } -ir_type *get_ir_type(type_t *type) +static ir_type *get_ir_type(type_t *type) { type = skip_typeref(type); @@ -2157,10 +2154,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; @@ -2203,15 +2200,15 @@ static ir_node *handle_assume(expression_t const *const expr) static ir_node *create_cast(unary_expression_t const *const expr) { - type_t *const type = skip_typeref(expr->base.type); - if (is_type_void(type)) - return NULL; - type_t *const from_type = skip_typeref(expr->value->base.type); ir_node *value = is_type_complex(from_type) ? expression_to_complex(expr->value).real : expression_to_value(expr->value); + type_t *const type = skip_typeref(expr->base.type); + if (is_type_void(type)) + return NULL; + dbg_info *const dbgi = get_dbg_info(&expr->base.pos); ir_mode *const mode = get_ir_mode_storage(type); /* check for conversion from / to __based types */ @@ -2443,7 +2440,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); @@ -2643,9 +2640,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 { @@ -2744,7 +2742,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; @@ -2770,7 +2768,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; @@ -3144,7 +3142,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); } @@ -3198,7 +3196,9 @@ static ir_node *expression_to_value(expression_t const *const expr) switch (expr->kind) { case EXPR_UNARY_CAST: - if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) { + if (!is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) + return create_cast(&expr->unary); + /* FALLTHROUGH */ case EXPR_BINARY_EQUAL: case EXPR_BINARY_GREATER: case EXPR_BINARY_GREATEREQUAL: @@ -3213,16 +3213,14 @@ static ir_node *expression_to_value(expression_t const *const expr) case EXPR_BINARY_LOGICAL_AND: case EXPR_BINARY_LOGICAL_OR: case EXPR_BINARY_NOTEQUAL: - case EXPR_UNARY_NOT:; - jump_target true_target; - jump_target false_target; - init_jump_target(&true_target, NULL); - init_jump_target(&false_target, NULL); - expression_to_control_flow(expr, &true_target, &false_target); - return control_flow_to_1_0(expr, &true_target, &false_target); - } else { - return create_cast(&expr->unary); - } + case EXPR_UNARY_NOT: { + jump_target true_target; + jump_target false_target; + init_jump_target(&true_target, NULL); + init_jump_target(&false_target, NULL); + expression_to_control_flow(expr, &true_target, &false_target); + return control_flow_to_1_0(expr, &true_target, &false_target); + } case EXPR_BINARY_ADD: case EXPR_BINARY_BITWISE_AND: @@ -3383,23 +3381,24 @@ static ir_node *expression_to_control_flow(expression_t const *const expr, jump_ if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) { expression_to_control_flow(expr->unary.value, true_target, false_target); return NULL; - } else { - default:; - type_t *const type = skip_typeref(expr->base.type); - if (is_type_complex(type)) { - complex_to_control_flow(expr, true_target, false_target); - return NULL; - } - - dbg_info *const dbgi = get_dbg_info(&expr->base.pos); - ir_mode *const mode = get_ir_mode_arithmetic(type); - ir_node *const val = create_conv(dbgi, expression_to_value(expr), mode); - ir_node *const left = val; - ir_node *const right = new_Const(get_mode_null(get_irn_mode(val))); - ir_relation const relation = ir_relation_unordered_less_greater; - compare_to_control_flow(expr, left, right, relation, true_target, false_target); - return val; } + /* FALLTHROUGH */ + default: { + type_t *const type = skip_typeref(expr->base.type); + if (is_type_complex(type)) { + complex_to_control_flow(expr, true_target, false_target); + return NULL; + } + + dbg_info *const dbgi = get_dbg_info(&expr->base.pos); + ir_mode *const mode = get_ir_mode_arithmetic(type); + ir_node *const val = create_conv(dbgi, expression_to_value(expr), mode); + ir_node *const left = val; + ir_node *const right = new_Const(get_mode_null(get_irn_mode(val))); + ir_relation const relation = ir_relation_unordered_less_greater; + compare_to_control_flow(expr, left, right, relation, true_target, false_target); + return val; + } } } @@ -4719,12 +4718,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)) { @@ -5151,7 +5150,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); @@ -5207,7 +5206,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);