X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=559b1c21379b92338c2d575f17eb976f1a68d65f;hb=3def71f59901789159be20bfdc806fb0fb1b6375;hp=53edbdd4bb1a1d52420dadcbb069fc8fcb7ab3e1;hpb=769ceb3899516a85ca9b2eeed654c4e4af92ee4c;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 53edbdd..559b1c2 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; @@ -111,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); @@ -131,11 +126,9 @@ 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 && warning.uninitialized) { - warningf(&entity->base.source_position, - "%s '%#T' might be used uninitialized", - get_entity_kind_name(entity->kind), - entity->declaration.type, entity->base.symbol); + if (entity != NULL) { + source_position_t const *const pos = &entity->base.source_position; + warningf(WARN_UNINITIALIZED, pos, "'%N' might be used uninitialized", entity); } return new_r_Unknown(irg, mode); } @@ -435,9 +428,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) @@ -445,9 +438,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) @@ -455,27 +448,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; } /** @@ -581,10 +574,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"); @@ -785,6 +778,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); @@ -1546,11 +1544,9 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref) /* for gcc compatibility we have to produce (dummy) addresses for some * builtins which don't have entities */ if (irentity == NULL) { - if (warning.other) { - warningf(&ref->base.source_position, - "taking address of builtin '%Y'", - ref->entity->base.symbol); - } + source_position_t const *const pos = &ref->base.source_position; + symbol_t const *const sym = ref->entity->base.symbol; + warningf(WARN_OTHER, pos, "taking address of builtin '%Y'", sym); /* simply create a NULL pointer */ ir_mode *mode = get_ir_mode_arithmetic(type_void_ptr); @@ -1751,10 +1747,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: { @@ -2038,8 +2034,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); @@ -2457,7 +2453,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; @@ -4451,8 +4447,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); @@ -4602,7 +4598,6 @@ static void return_statement_to_firm(return_statement_t *statement) 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) { @@ -4611,10 +4606,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 { @@ -5295,20 +5290,19 @@ static void asm_statement_to_firm(const asm_statement_t *statement) asm_constraint_flags_t asm_flags = be_parse_asm_constraints(constraints); - if (asm_flags & ASM_CONSTRAINT_FLAG_NO_SUPPORT) { - warningf(&statement->base.source_position, - "some constraints in '%s' are not supported", constraints); - } - if (asm_flags & ASM_CONSTRAINT_FLAG_INVALID) { - errorf(&statement->base.source_position, - "some constraints in '%s' are invalid", constraints); - continue; - } - if (! (asm_flags & ASM_CONSTRAINT_FLAG_MODIFIER_WRITE)) { - errorf(&statement->base.source_position, - "no write flag specified for output constraints '%s'", - constraints); - continue; + { + source_position_t const *const pos = &statement->base.source_position; + if (asm_flags & ASM_CONSTRAINT_FLAG_NO_SUPPORT) { + warningf(WARN_OTHER, pos, "some constraints in '%s' are not supported", constraints); + } + if (asm_flags & ASM_CONSTRAINT_FLAG_INVALID) { + errorf(pos, "some constraints in '%s' are invalid", constraints); + continue; + } + if (! (asm_flags & ASM_CONSTRAINT_FLAG_MODIFIER_WRITE)) { + errorf(pos, "no write flag specified for output constraints '%s'", constraints); + continue; + } } unsigned pos = next_pos++; @@ -5481,7 +5475,8 @@ static void asm_statement_to_firm(const asm_statement_t *statement) static void ms_try_statement_to_firm(ms_try_statement_t *statement) { statement_to_firm(statement->try_statement); - warningf(&statement->base.source_position, "structured exception handling ignored"); + source_position_t const *const pos = &statement->base.source_position; + warningf(WARN_OTHER, pos, "structured exception handling ignored"); } static void leave_statement_to_firm(leave_statement_t *statement) @@ -5655,13 +5650,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; } @@ -5803,7 +5798,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)); @@ -5866,9 +5861,8 @@ static void create_function(entity_t *entity) if (has_computed_gotos) { /* if we have computed goto's in the function, we cannot inline it */ if (get_irg_inline_property(irg) >= irg_inline_recomended) { - warningf(&entity->base.source_position, - "function '%Y' can never be inlined because it contains a computed goto", - entity->base.symbol); + source_position_t const *const pos = &entity->base.source_position; + warningf(WARN_OTHER, pos, "'%N' can never be inlined because it contains a computed goto", entity); } set_irg_inline_property(irg, irg_inline_forbidden); } @@ -5887,8 +5881,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) @@ -5901,7 +5895,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);