X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=7a33f35f416592aee1935388fb426c4c258361dc;hb=b84a9dd7e9ae5e072051e565b3f48fa84b4e1cab;hp=ccc82c0f072ee38f2cbfe561d68ed4bb48e4a754;hpb=3ebacacfef57e10045769920f82d4549b97c4eda;p=cparser diff --git a/ast2firm.c b/ast2firm.c index ccc82c0..7a33f35 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -49,7 +49,6 @@ #include "printer.h" #include "entitymap_t.h" #include "driver/firm_opt.h" -#include "driver/firm_cmdline.h" typedef struct trampoline_region trampoline_region; struct trampoline_region { @@ -57,6 +56,8 @@ struct trampoline_region { ir_entity *region; /**< created region for the trampoline */ }; +fp_model_t firm_fp_model = fp_model_precise; + static const backend_params *be_params; static ir_type *ir_type_char; @@ -82,8 +83,6 @@ static ir_node *ijmp_list; static bool constant_folding; static bool initializer_use_bitfield_basetype; -extern bool have_const_functions; - static const entity_t *current_function_entity; static ir_node *current_function_name; static ir_node *current_funcsig; @@ -113,12 +112,6 @@ typedef enum declaration_kind_t { } declaration_kind_t; static ir_mode *get_ir_mode_storage(type_t *type); -/* - * get arithmetic mode for a type. This is different from get_ir_mode_storage, - * int that it returns bigger modes for floating point on some platforms - * (x87 internally does arithemtic with 80bits) - */ -static ir_mode *get_ir_mode_arithmetic(type_t *type); static ir_type *get_ir_type_incomplete(type_t *type); @@ -148,7 +141,7 @@ static const char *dbg_retrieve(const dbg_info *dbg, unsigned *line) if (pos == NULL) return NULL; if (line != NULL) - *line = pos->linenr; + *line = pos->lineno; return pos->input_name; } @@ -172,6 +165,18 @@ static type_dbg_info *get_type_dbg_info_(const type_t *type) return (type_dbg_info*) type; } +/* is the current block a reachable one? */ +static bool currently_reachable(void) +{ + ir_node *const block = get_cur_block(); + return block != NULL && !is_Bad(block); +} + +static void set_unreachable_now(void) +{ + set_cur_block(NULL); +} + static ir_mode *atomic_modes[ATOMIC_TYPE_LAST+1]; static ir_mode *mode_int, *mode_uint; @@ -425,9 +430,9 @@ static ir_type *create_pointer_type(pointer_type_t *type) type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) type); type_t *points_to = type->points_to; ir_type *ir_points_to = get_ir_type_incomplete(points_to); - ir_type *ir_type = new_d_type_pointer(ir_points_to, dbgi); + ir_type *irtype = new_d_type_pointer(ir_points_to, dbgi); - return ir_type; + return irtype; } static ir_type *create_reference_type(reference_type_t *type) @@ -435,9 +440,9 @@ static ir_type *create_reference_type(reference_type_t *type) type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) type); type_t *refers_to = type->refers_to; ir_type *ir_refers_to = get_ir_type_incomplete(refers_to); - ir_type *ir_type = new_d_type_pointer(ir_refers_to, dbgi); + ir_type *irtype = new_d_type_pointer(ir_refers_to, dbgi); - return ir_type; + return irtype; } static ir_type *create_array_type(array_type_t *type) @@ -445,27 +450,27 @@ static ir_type *create_array_type(array_type_t *type) type_dbg_info *dbgi = get_type_dbg_info_((const type_t*) type); type_t *element_type = type->element_type; ir_type *ir_element_type = get_ir_type(element_type); - ir_type *ir_type = new_d_type_array(1, ir_element_type, dbgi); + ir_type *irtype = new_d_type_array(1, ir_element_type, dbgi); const int align = get_type_alignment_bytes(ir_element_type); - set_type_alignment_bytes(ir_type, align); + set_type_alignment_bytes(irtype, align); if (type->size_constant) { int n_elements = type->size; - set_array_bounds_int(ir_type, 0, 0, n_elements); + set_array_bounds_int(irtype, 0, 0, n_elements); size_t elemsize = get_type_size_bytes(ir_element_type); if (elemsize % align > 0) { elemsize += align - (elemsize % align); } - set_type_size_bytes(ir_type, n_elements * elemsize); + set_type_size_bytes(irtype, n_elements * elemsize); } else { - set_array_lower_bound_int(ir_type, 0, 0); + set_array_lower_bound_int(irtype, 0, 0); } - set_type_state(ir_type, layout_fixed); + set_type_state(irtype, layout_fixed); - return ir_type; + return irtype; } /** @@ -571,10 +576,10 @@ static ir_type *create_compound_type(compound_type_t *type, return compound->irtype; } - symbol_t *symbol = compound->base.symbol; + symbol_t *type_symbol = compound->base.symbol; ident *id; - if (symbol != NULL) { - id = new_id_from_str(symbol->string); + if (type_symbol != NULL) { + id = new_id_from_str(type_symbol->string); } else { if (is_union) { id = id_unique("__anonymous_union.%u"); @@ -745,9 +750,6 @@ ir_type *get_ir_type(type_t *type) case TYPE_ENUM: firm_type = create_enum_type(&type->enumt); break; - case TYPE_BUILTIN: - firm_type = get_ir_type(type->builtin.real_type); - break; case TYPE_BITFIELD: firm_type = create_bitfield_type(&type->bitfield); break; @@ -778,6 +780,11 @@ static ir_mode *get_ir_mode_storage(type_t *type) return mode; } +/* + * get arithmetic mode for a type. This is different from get_ir_mode_storage, + * int that it returns bigger modes for floating point on some platforms + * (x87 internally does arithemtic with 80bits) + */ static ir_mode *get_ir_mode_arithmetic(type_t *type) { ir_mode *mode = get_ir_mode_storage(type); @@ -901,7 +908,6 @@ static void handle_decl_modifiers(ir_entity *irentity, entity_t *entity) } if (modifiers & DM_CONST) { add_entity_additional_properties(irentity, mtp_property_const); - have_const_functions = true; } } if (modifiers & DM_USED) { @@ -1082,7 +1088,7 @@ static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) { ir_mode *value_mode = get_irn_mode(value); - if (value_mode == dest_mode || is_Bad(value)) + if (value_mode == dest_mode) return value; if (dest_mode == mode_b) { @@ -1745,10 +1751,10 @@ static ir_node *process_builtin_call(const call_expression_t *call) assert(call->function->kind == EXPR_REFERENCE); reference_expression_t *builtin = &call->function->reference; - type_t *type = skip_typeref(builtin->base.type); - assert(is_type_pointer(type)); + type_t *expr_type = skip_typeref(builtin->base.type); + assert(is_type_pointer(expr_type)); - type_t *function_type = skip_typeref(type->pointer.points_to); + type_t *function_type = skip_typeref(expr_type->pointer.points_to); switch (builtin->entity->function.btk) { case bk_gnu_builtin_alloca: { @@ -1943,7 +1949,7 @@ static ir_node *process_builtin_call(const call_expression_t *call) static ir_node *call_expression_to_firm(const call_expression_t *const call) { dbg_info *const dbgi = get_dbg_info(&call->base.source_position); - assert(get_cur_block() != NULL); + assert(currently_reachable()); expression_t *function = call->function; if (function->kind == EXPR_REFERENCE) { @@ -2032,8 +2038,8 @@ static ir_node *call_expression_to_firm(const call_expression_t *const call) expression_t *expression = argument->expression; ir_node *arg_node = expression_to_firm(expression); - type_t *type = skip_typeref(expression->base.type); - if (!is_type_compound(type)) { + type_t *arg_type = skip_typeref(expression->base.type); + if (!is_type_compound(arg_type)) { ir_mode *mode = get_ir_mode_storage(expression->base.type); arg_node = create_conv(dbgi, arg_node, mode); arg_node = do_strict_conv(dbgi, arg_node); @@ -2451,7 +2457,7 @@ static ir_node *handle_assume_compare(dbg_info *dbi, return res; } - expression_t *con; + expression_t *con = NULL; if (is_local_variable(op1) && is_constant_expression(op2) == EXPR_CLASS_CONSTANT) { var = op1->reference.entity; con = op2; @@ -2660,7 +2666,7 @@ static ir_node *create_op(dbg_info *dbgi, const binary_expression_t *expression, case EXPR_BINARY_SHIFTRIGHT: case EXPR_BINARY_SHIFTLEFT_ASSIGN: case EXPR_BINARY_SHIFTRIGHT_ASSIGN: - mode = get_irn_mode(left); + mode = get_ir_mode_arithmetic(expression->base.type); right = create_conv(dbgi, right, mode_uint); break; @@ -3320,7 +3326,6 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex /* gcc classifies the referenced type */ case TYPE_REFERENCE: type = type->reference.refers_to; continue; - case TYPE_BUILTIN: /* typedef/typeof should be skipped already */ case TYPE_TYPEDEF: case TYPE_TYPEOF: @@ -3714,14 +3719,8 @@ static ir_node *create_condition_evaluation(const expression_t *expression, if (is_builtin_expect(expression) && is_Cond(cond)) { call_argument_t *argument = expression->call.arguments->next; if (is_constant_expression(argument->expression) == EXPR_CLASS_CONSTANT) { - bool cnst = fold_constant_to_bool(argument->expression); - cond_jmp_predicate pred; - - if (cnst == false) { - pred = COND_JMP_PRED_FALSE; - } else { - pred = COND_JMP_PRED_TRUE; - } + 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); } } @@ -3729,7 +3728,7 @@ static ir_node *create_condition_evaluation(const expression_t *expression, add_immBlock_pred(true_block, true_proj); add_immBlock_pred(false_block, false_proj); - set_cur_block(NULL); + set_unreachable_now(); return cond_expr; } @@ -4452,8 +4451,8 @@ static void create_variable_initializer(entity_t *entity) ir_node *value = expression_to_firm(initializer_value->value); - type_t *type = initializer_value->value->base.type; - ir_mode *mode = get_ir_mode_storage(type); + type_t *init_type = initializer_value->value->base.type; + ir_mode *mode = get_ir_mode_storage(init_type); value = create_conv(dbgi, value, mode); value = do_strict_conv(dbgi, value); @@ -4501,7 +4500,7 @@ static void allocate_variable_length_array(entity_t *entity) { assert(entity->kind == ENTITY_VARIABLE); assert(entity->variable.initializer == NULL); - assert(get_cur_block() != NULL); + assert(currently_reachable()); dbg_info *dbgi = get_dbg_info(&entity->base.source_position); type_t *type = entity->declaration.type; @@ -4596,14 +4595,13 @@ static void create_local_static_variable(entity_t *entity) static void return_statement_to_firm(return_statement_t *statement) { - if (get_cur_block() == NULL) + if (!currently_reachable()) return; dbg_info *dbgi = get_dbg_info(&statement->base.source_position); type_t *type = current_function_entity->declaration.type; ir_type *func_irtype = get_ir_type(type); - ir_node *in[1]; int in_len; if (get_method_n_ress(func_irtype) > 0) { @@ -4612,10 +4610,10 @@ static void return_statement_to_firm(return_statement_t *statement) if (statement->value != NULL) { ir_node *node = expression_to_firm(statement->value); if (!is_compound_type(res_type)) { - type_t *type = statement->value->base.type; - ir_mode *mode = get_ir_mode_storage(type); - node = create_conv(dbgi, node, mode); - node = do_strict_conv(dbgi, node); + type_t *ret_value_type = statement->value->base.type; + ir_mode *mode = get_ir_mode_storage(ret_value_type); + node = create_conv(dbgi, node, mode); + node = do_strict_conv(dbgi, node); } in[0] = node; } else { @@ -4642,12 +4640,12 @@ static void return_statement_to_firm(return_statement_t *statement) ir_node *end_block = get_irg_end_block(current_ir_graph); add_immBlock_pred(end_block, ret); - set_cur_block(NULL); + set_unreachable_now(); } static ir_node *expression_statement_to_firm(expression_statement_t *statement) { - if (get_cur_block() == NULL) + if (!currently_reachable()) return NULL; return expression_to_firm(statement->expression); @@ -4768,7 +4766,7 @@ static void initialize_local_declaration(entity_t *entity) // no need to emit code in dead blocks if (entity->declaration.storage_class != STORAGE_CLASS_STATIC - && get_cur_block() == NULL) + && !currently_reachable()) return; switch ((declaration_kind_t) entity->declaration.kind) { @@ -4825,7 +4823,7 @@ static void if_statement_to_firm(if_statement_t *statement) /* Create the condition. */ ir_node *true_block = NULL; ir_node *false_block = NULL; - if (get_cur_block() != NULL) { + if (currently_reachable()) { true_block = new_immBlock(); false_block = new_immBlock(); create_condition_evaluation(statement->condition, true_block, false_block); @@ -4842,7 +4840,7 @@ static void if_statement_to_firm(if_statement_t *statement) } set_cur_block(false_block); statement_to_firm(statement->false_statement); - if (get_cur_block() != NULL) { + if (currently_reachable()) { fallthrough_block = new_immBlock(); add_immBlock_pred(fallthrough_block, new_Jmp()); } @@ -4853,7 +4851,7 @@ static void if_statement_to_firm(if_statement_t *statement) /* Create the true statement. */ set_cur_block(true_block); statement_to_firm(statement->true_statement); - if (get_cur_block() != NULL) { + if (currently_reachable()) { if (fallthrough_block == NULL) { fallthrough_block = new_immBlock(); } @@ -4871,9 +4869,8 @@ static void if_statement_to_firm(if_statement_t *statement) * reachable. */ static void jump_if_reachable(ir_node *const target_block) { - if (get_cur_block() != NULL) { - add_immBlock_pred(target_block, new_Jmp()); - } + ir_node *const pred = currently_reachable() ? new_Jmp() : new_Bad(mode_X); + add_immBlock_pred(target_block, pred); } static void while_statement_to_firm(while_statement_t *statement) @@ -4980,7 +4977,7 @@ static void for_statement_to_firm(for_statement_t *statement) create_local_declaration(entity); } - if (get_cur_block() != NULL) { + if (currently_reachable()) { entity = statement->scope.entities; for ( ; entity != NULL; entity = entity->base.next) { if (!is_declaration(entity)) @@ -5058,14 +5055,14 @@ static void for_statement_to_firm(for_statement_t *statement) static void create_jump_statement(const statement_t *statement, ir_node *target_block) { - if (get_cur_block() == NULL) + if (!currently_reachable()) return; dbg_info *dbgi = get_dbg_info(&statement->base.source_position); ir_node *jump = new_d_Jmp(dbgi); add_immBlock_pred(target_block, jump); - set_cur_block(NULL); + set_unreachable_now(); } static void switch_statement_to_firm(switch_statement_t *statement) @@ -5074,13 +5071,13 @@ static void switch_statement_to_firm(switch_statement_t *statement) dbg_info *dbgi = get_dbg_info(&statement->base.source_position); ir_node *cond = NULL; - if (get_cur_block() != NULL) { + if (currently_reachable()) { ir_node *expression = expression_to_firm(statement->expression); cond = new_d_Cond(dbgi, expression); first_block = get_cur_block(); } - set_cur_block(NULL); + set_unreachable_now(); ir_node *const old_switch_cond = current_switch_cond; ir_node *const old_break_label = break_label; @@ -5105,7 +5102,7 @@ static void switch_statement_to_firm(switch_statement_t *statement) default_proj_nr = l->last_case; } - if (default_proj_nr == INT_MAX) { + if (default_proj_nr == LONG_MAX) { /* Bad: an overflow will occur, we cannot be sure that the * maximum + 1 is a free number. Scan the values a second * time to find a free number. @@ -5219,7 +5216,7 @@ static void label_to_firm(const label_statement_t *statement) static void goto_to_firm(const goto_statement_t *statement) { - if (get_cur_block() == NULL) + if (!currently_reachable()) return; if (statement->expression) { @@ -5234,7 +5231,7 @@ static void goto_to_firm(const goto_statement_t *statement) ir_node *jmp = new_Jmp(); add_immBlock_pred(block, jmp); } - set_cur_block(NULL); + set_unreachable_now(); } static void asm_statement_to_firm(const asm_statement_t *statement) @@ -5657,13 +5654,13 @@ static void initialize_function_parameters(entity_t *entity) } if (needs_entity) { - ir_entity *entity = get_method_value_param_ent(function_irtype, n); - ident *id = new_id_from_str(parameter->base.symbol->string); - set_entity_ident(entity, id); + ir_entity *param = get_method_value_param_ent(function_irtype, n); + ident *id = new_id_from_str(parameter->base.symbol->string); + set_entity_ident(param, id); parameter->declaration.kind = DECLARATION_KIND_PARAMETER_ENTITY; - parameter->parameter.v.entity = entity; + parameter->parameter.v.entity = param; continue; } @@ -5805,7 +5802,7 @@ static void create_function(entity_t *entity) ir_graph *old_current_function = current_function; current_function = irg; - set_irg_fp_model(irg, firm_opt.fp_model); + set_irg_fp_model(irg, firm_fp_model); tarval_enable_fp_ops(1); set_irn_dbg_info(get_irg_start_block(irg), get_entity_dbg_info(function_entity)); @@ -5826,7 +5823,7 @@ static void create_function(entity_t *entity) ir_node *end_block = get_irg_end_block(irg); /* do we have a return statement yet? */ - if (get_cur_block() != NULL) { + if (currently_reachable()) { type_t *type = skip_typeref(entity->declaration.type); assert(is_type_function(type)); const function_type_t *func_type = &type->function; @@ -5889,8 +5886,8 @@ static void create_function(entity_t *entity) int align_all = 4; int offset = 0; for (int i = 0; i < n; ++i) { - ir_entity *entity = get_compound_member(frame_type, i); - ir_type *entity_type = get_entity_type(entity); + ir_entity *member = get_compound_member(frame_type, i); + ir_type *entity_type = get_entity_type(member); int align = get_type_alignment_bytes(entity_type); if (align > align_all) @@ -5903,7 +5900,7 @@ static void create_function(entity_t *entity) } } - set_entity_offset(entity, offset); + set_entity_offset(member, offset); offset += get_type_size_bytes(entity_type); } set_type_size_bytes(frame_type, offset);