X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=d1cf59a688a6bbc1f11d65139001dd120554fb4c;hb=f62e85e79349d1b37a5c1f38f30d3c7bcbeebfc6;hp=382ca18129dda64ddfd2909fe7a25d3304c9a4b3;hpb=0dbcab321aa3bbbfdab6ae8dbab51e6b4ea47790;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 382ca18..d1cf59a 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -44,12 +44,11 @@ #include "types.h" #include "type_hash.h" #include "mangle.h" -#include "walk_statements.h" +#include "walk.h" #include "warning.h" #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; @@ -80,7 +81,6 @@ static label_t **all_labels; static entity_t **inner_functions; static ir_node *ijmp_list; static bool constant_folding; -static bool initializer_use_bitfield_basetype; static const entity_t *current_function_entity; static ir_node *current_function_name; @@ -90,7 +90,6 @@ static ir_graph *current_function; static translation_unit_t *current_translation_unit; static trampoline_region *current_trampolines; static ir_type *current_outer_frame; -static ir_type *current_outer_value_type; static ir_node *current_static_link; static entitymap_t entitymap; @@ -111,12 +110,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 +124,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); } @@ -146,7 +137,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; } @@ -170,6 +161,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; @@ -178,6 +181,15 @@ static ir_node *_expression_to_firm(const expression_t *expression); static ir_node *expression_to_firm(const expression_t *expression); static void create_local_declaration(entity_t *entity); +static unsigned decide_modulo_shift(unsigned type_size) +{ + if (architecture_modulo_shift == 0) + return 0; + if (type_size < architecture_modulo_shift) + return architecture_modulo_shift; + return type_size; +} + static ir_mode *init_atomic_ir_mode(atomic_type_kind_t kind) { unsigned flags = get_atomic_type_flags(kind); @@ -188,7 +200,7 @@ static ir_mode *init_atomic_ir_mode(atomic_type_kind_t kind) ir_mode_sort sort; unsigned bit_size = size * 8; bool is_signed = (flags & ATOMIC_TYPE_FLAG_SIGNED) != 0; - unsigned modulo_shift; + unsigned modulo_shift = 0; ir_mode_arithmetic arithmetic; if (flags & ATOMIC_TYPE_FLAG_INTEGER) { @@ -197,13 +209,12 @@ static ir_mode *init_atomic_ir_mode(atomic_type_kind_t kind) bit_size); sort = irms_int_number; arithmetic = irma_twos_complement; - modulo_shift = bit_size < machine_size ? machine_size : bit_size; + modulo_shift = decide_modulo_shift(bit_size); } else { assert(flags & ATOMIC_TYPE_FLAG_FLOAT); snprintf(name, sizeof(name), "F%u", bit_size); sort = irms_float_number; arithmetic = irma_ieee754; - modulo_shift = 0; } return new_ir_mode(name, sort, bit_size, is_signed, arithmetic, modulo_shift); @@ -225,26 +236,6 @@ static void init_atomic_modes(void) /* there's no real void type in firm */ atomic_modes[ATOMIC_TYPE_VOID] = atomic_modes[ATOMIC_TYPE_CHAR]; - - /* initialize pointer modes */ - char name[64]; - ir_mode_sort sort = irms_reference; - unsigned bit_size = machine_size; - bool is_signed = 0; - ir_mode_arithmetic arithmetic = irma_twos_complement; - unsigned modulo_shift - = bit_size < machine_size ? machine_size : bit_size; - - snprintf(name, sizeof(name), "p%u", machine_size); - ir_mode *ptr_mode = new_ir_mode(name, sort, bit_size, is_signed, arithmetic, - modulo_shift); - - set_reference_mode_signed_eq(ptr_mode, atomic_modes[get_intptr_kind()]); - set_reference_mode_unsigned_eq(ptr_mode, atomic_modes[get_uintptr_kind()]); - - /* Hmm, pointers should be machine size */ - set_modeP_data(ptr_mode); - set_modeP_code(ptr_mode); } ir_mode *get_atomic_mode(atomic_type_kind_t kind) @@ -423,9 +414,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) @@ -433,9 +424,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) @@ -443,27 +434,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; } /** @@ -532,21 +523,20 @@ static ir_type *get_unsigned_int_type_for_bit_size(ir_type *base_tp, return res; } -static ir_type *create_bitfield_type(bitfield_type_t *const type) +static ir_type *create_bitfield_type(const entity_t *entity) { - type_t *base = skip_typeref(type->base_type); + assert(entity->kind == ENTITY_COMPOUND_MEMBER); + type_t *base = skip_typeref(entity->declaration.type); assert(base->kind == TYPE_ATOMIC || base->kind == TYPE_ENUM); ir_type *irbase = get_ir_type(base); - unsigned size = type->bit_size; + unsigned bit_size = entity->compound_member.bit_size; assert(!is_type_float(base)); if (is_type_signed(base)) { - return get_signed_int_type_for_bit_size(irbase, size, - (const type_t*) type); + return get_signed_int_type_for_bit_size(irbase, bit_size, base); } else { - return get_unsigned_int_type_for_bit_size(irbase, size, - (const type_t*) type); + return get_unsigned_int_type_for_bit_size(irbase, bit_size, base); } } @@ -569,10 +559,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"); @@ -612,7 +602,7 @@ static ir_type *create_compound_type(compound_type_t *type, ident *ident; if (symbol == NULL) { /* anonymous bitfield member, skip */ - if (entry_type->kind == TYPE_BITFIELD) + if (entry->compound_member.bitfield) continue; assert(entry_type->kind == TYPE_COMPOUND_STRUCT || entry_type->kind == TYPE_COMPOUND_UNION); @@ -623,7 +613,12 @@ static ir_type *create_compound_type(compound_type_t *type, dbg_info *dbgi = get_dbg_info(&entry->base.source_position); - ir_type *entry_irtype = get_ir_type(entry_type); + ir_type *entry_irtype; + if (entry->compound_member.bitfield) { + entry_irtype = create_bitfield_type(entry); + } else { + entry_irtype = get_ir_type(entry_type); + } ir_entity *entity = new_d_entity(irtype, ident, entry_irtype, dbgi); set_entity_offset(entity, entry->compound_member.offset); @@ -743,12 +738,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; case TYPE_TYPEOF: case TYPE_TYPEDEF: @@ -776,6 +765,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); @@ -1079,7 +1073,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) { @@ -1201,12 +1195,12 @@ static bool try_create_integer(literal_expression_t *literal, static void create_integer_tarval(literal_expression_t *literal) { - unsigned us = 0; - unsigned ls = 0; - symbol_t *suffix = literal->suffix; + unsigned us = 0; + unsigned ls = 0; + const string_t *suffix = &literal->suffix; /* parse suffix */ - if (suffix != NULL) { - for (const char *c = suffix->string; *c != '\0'; ++c) { + if (suffix->size > 0) { + for (const char *c = suffix->begin; *c != '\0'; ++c) { if (*c == 'u' || *c == 'U') { ++us; } if (*c == 'l' || *c == 'L') { ++ls; } } @@ -1290,6 +1284,8 @@ static ir_node *literal_to_firm(const literal_expression_t *literal) } case EXPR_LITERAL_CHARACTER: { long long int v; + bool char_is_signed + = get_atomic_type_flags(ATOMIC_TYPE_CHAR) & ATOMIC_TYPE_FLAG_SIGNED; if (size == 1 && char_is_signed) { v = (signed char)string[0]; } else { @@ -1490,7 +1486,7 @@ static ir_node *get_local_frame(ir_entity *const ent) { ir_graph *const irg = current_ir_graph; const ir_type *const owner = get_entity_owner(ent); - if (owner == current_outer_frame || owner == current_outer_value_type) { + if (owner == current_outer_frame) { assert(current_static_link != NULL); return current_static_link; } else { @@ -1537,11 +1533,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); @@ -1742,10 +1736,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: { @@ -1826,10 +1820,16 @@ static ir_node *process_builtin_call(const call_expression_t *call) case bk_gnu_builtin_ffs: return gen_unary_builtin(ir_bk_ffs, call->arguments->expression, function_type, dbgi); case bk_gnu_builtin_clz: + case bk_gnu_builtin_clzl: + case bk_gnu_builtin_clzll: return gen_unary_builtin(ir_bk_clz, call->arguments->expression, function_type, dbgi); case bk_gnu_builtin_ctz: + case bk_gnu_builtin_ctzl: + case bk_gnu_builtin_ctzll: return gen_unary_builtin(ir_bk_ctz, call->arguments->expression, function_type, dbgi); case bk_gnu_builtin_popcount: + case bk_gnu_builtin_popcountl: + case bk_gnu_builtin_popcountll: case bk_ms__popcount: return gen_unary_builtin(ir_bk_popcount, call->arguments->expression, function_type, dbgi); case bk_gnu_builtin_parity: @@ -1940,7 +1940,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) { @@ -2029,8 +2029,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); @@ -2143,9 +2143,8 @@ static ir_node *bitfield_store_to_firm(dbg_info *dbgi, value = create_conv(dbgi, value, mode); /* kill upper bits of value and shift to right position */ - int bitoffset = get_entity_offset_bits_remainder(entity); - int bitsize = get_mode_size_bits(get_type_mode(entity_type)); - + int bitoffset = get_entity_offset_bits_remainder(entity); + int bitsize = get_mode_size_bits(get_type_mode(entity_type)); ir_tarval *mask = create_bitfield_mask(mode, 0, bitsize); ir_node *mask_node = new_d_Const(dbgi, mask); ir_node *value_masked = new_d_And(dbgi, value, mask_node, mode); @@ -2175,44 +2174,51 @@ static ir_node *bitfield_store_to_firm(dbg_info *dbgi, } static ir_node *bitfield_extract_to_firm(const select_expression_t *expression, - ir_node *addr) -{ - dbg_info *dbgi = get_dbg_info(&expression->base.source_position); - type_t *type = expression->base.type; - ir_mode *mode = get_ir_mode_storage(type); - ir_node *mem = get_store(); - ir_node *load = new_d_Load(dbgi, mem, addr, mode, cons_none); - ir_node *load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M); - ir_node *load_res = new_d_Proj(dbgi, load, mode, pn_Load_res); - - load_res = create_conv(dbgi, load_res, mode_int); + ir_node *addr) +{ + dbg_info *dbgi = get_dbg_info(&expression->base.source_position); + entity_t *entity = expression->compound_entry; + type_t *base_type = entity->declaration.type; + ir_mode *mode = get_ir_mode_storage(base_type); + ir_node *mem = get_store(); + ir_node *load = new_d_Load(dbgi, mem, addr, mode, cons_none); + ir_node *load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M); + ir_node *load_res = new_d_Proj(dbgi, load, mode, pn_Load_res); + + ir_mode *amode = mode; + /* optimisation, since shifting in modes < machine_size is usually + * less efficient */ + if (get_mode_size_bits(amode) < get_mode_size_bits(mode_uint)) { + amode = mode_uint; + } + unsigned amode_size = get_mode_size_bits(amode); + load_res = create_conv(dbgi, load_res, amode); set_store(load_mem); /* kill upper bits */ assert(expression->compound_entry->kind == ENTITY_COMPOUND_MEMBER); - ir_entity *entity = expression->compound_entry->compound_member.entity; - int bitoffset = get_entity_offset_bits_remainder(entity); - ir_type *entity_type = get_entity_type(entity); - int bitsize = get_mode_size_bits(get_type_mode(entity_type)); - long shift_bitsl = machine_size - bitoffset - bitsize; - assert(shift_bitsl >= 0); - ir_tarval *tvl = new_tarval_from_long(shift_bitsl, mode_uint); - ir_node *countl = new_d_Const(dbgi, tvl); - ir_node *shiftl = new_d_Shl(dbgi, load_res, countl, mode_int); - - long shift_bitsr = bitoffset + shift_bitsl; - assert(shift_bitsr <= (long) machine_size); - ir_tarval *tvr = new_tarval_from_long(shift_bitsr, mode_uint); - ir_node *countr = new_d_Const(dbgi, tvr); + int bitoffset = entity->compound_member.bit_offset; + int bitsize = entity->compound_member.bit_size; + unsigned shift_bitsl = amode_size - bitoffset - bitsize; + ir_tarval *tvl = new_tarval_from_long((long)shift_bitsl, mode_uint); + ir_node *countl = new_d_Const(dbgi, tvl); + ir_node *shiftl = new_d_Shl(dbgi, load_res, countl, amode); + + unsigned shift_bitsr = bitoffset + shift_bitsl; + assert(shift_bitsr <= amode_size); + ir_tarval *tvr = new_tarval_from_long((long)shift_bitsr, mode_uint); + ir_node *countr = new_d_Const(dbgi, tvr); ir_node *shiftr; if (mode_is_signed(mode)) { - shiftr = new_d_Shrs(dbgi, shiftl, countr, mode_int); + shiftr = new_d_Shrs(dbgi, shiftl, countr, amode); } else { - shiftr = new_d_Shr(dbgi, shiftl, countr, mode_int); + shiftr = new_d_Shr(dbgi, shiftl, countr, amode); } - return create_conv(dbgi, shiftr, mode); + type_t *type = expression->base.type; + ir_mode *resmode = get_ir_mode_arithmetic(type); + return create_conv(dbgi, shiftr, resmode); } /* make sure the selected compound type is constructed */ @@ -2263,7 +2269,7 @@ static ir_node *set_value_for_expression_addr(const expression_t *expression, entity_t *entity = select->compound_entry; assert(entity->kind == ENTITY_COMPOUND_MEMBER); - if (entity->declaration.type->kind == TYPE_BITFIELD) { + if (entity->compound_member.bitfield) { ir_entity *irentity = entity->compound_member.entity; bool set_volatile = select->base.type->base.qualifiers & TYPE_QUALIFIER_VOLATILE; @@ -2316,7 +2322,7 @@ static ir_node *get_value_from_lvalue(const expression_t *expression, ir_node *value; if (expression->kind == EXPR_SELECT && - expression->select.compound_entry->declaration.type->kind == TYPE_BITFIELD){ + expression->select.compound_entry->compound_member.bitfield) { construct_select_compound(&expression->select); value = bitfield_extract_to_firm(&expression->select, addr); } else { @@ -2448,7 +2454,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; @@ -2588,7 +2594,6 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression) case EXPR_UNARY_PREFIX_INCREMENT: case EXPR_UNARY_PREFIX_DECREMENT: return create_incdec(expression); - case EXPR_UNARY_CAST_IMPLICIT: case EXPR_UNARY_CAST: { ir_node *value_node = expression_to_firm(value); type_t *from_type = value->base.type; @@ -3100,6 +3105,14 @@ static ir_tarval *fold_constant_to_tarval(const expression_t *expression) return get_Const_tarval(cnst); } +/* this function is only used in parser.c, but it relies on libfirm functionality */ +bool constant_is_negative(const expression_t *expression) +{ + assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT); + ir_tarval *tv = fold_constant_to_tarval(expression); + return tarval_is_negative(tv); +} + long fold_constant_to_int(const expression_t *expression) { if (expression->kind == EXPR_INVALID) @@ -3218,11 +3231,10 @@ static ir_node *select_to_firm(const select_expression_t *expression) (const expression_t*) expression); type = skip_typeref(type); - entity_t *entry = expression->compound_entry; + entity_t *entry = expression->compound_entry; assert(entry->kind == ENTITY_COMPOUND_MEMBER); - type_t *entry_type = skip_typeref(entry->declaration.type); - if (entry_type->kind == TYPE_BITFIELD) { + if (entry->compound_member.bitfield) { return bitfield_extract_to_firm(expression, addr); } @@ -3304,7 +3316,6 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex case TYPE_COMPLEX: tc = complex_type_class; goto make_const; case TYPE_IMAGINARY: tc = complex_type_class; goto make_const; - case TYPE_BITFIELD: tc = integer_type_class; goto make_const; case TYPE_ARRAY: /* gcc handles this as pointer */ case TYPE_FUNCTION: /* gcc handles this as pointer */ case TYPE_POINTER: tc = pointer_type_class; goto make_const; @@ -3317,7 +3328,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: @@ -3372,15 +3382,19 @@ static ir_node *statement_expression_to_firm(const statement_expression_t *expr) static ir_node *va_start_expression_to_firm( const va_start_expression_t *const expr) { + ir_graph *const irg = current_ir_graph; type_t *const type = current_function_entity->declaration.type; ir_type *const method_type = get_ir_type(type); - int const n = get_method_n_params(method_type) - 1; - ir_entity *const parm_ent = get_method_value_param_ent(method_type, n); - ir_node *const frame = get_irg_frame(current_ir_graph); + size_t const n = get_method_n_params(method_type) - 1; + ir_type *frame_type = get_irg_frame_type(irg); + ir_type *param_irtype = get_method_param_type(method_type, n); + ir_entity *const param_ent = + new_parameter_entity(frame_type, n, param_irtype); + ir_node *const frame = get_irg_frame(irg); dbg_info *const dbgi = get_dbg_info(&expr->base.source_position); ir_node *const no_mem = new_NoMem(); ir_node *const arg_sel = - new_d_simpleSel(dbgi, no_mem, frame, parm_ent); + new_d_simpleSel(dbgi, no_mem, frame, param_ent); type_t *const param_type = expr->parameter->base.type; ir_node *const cnst = get_type_size_node(param_type); @@ -3575,7 +3589,6 @@ static ir_node *_expression_to_firm(const expression_t *expression) case EXPR_LABEL_ADDRESS: return label_address_to_firm(&expression->label_address); - case EXPR_UNKNOWN: case EXPR_INVALID: break; } @@ -3711,14 +3724,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); } } @@ -3726,7 +3733,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; } @@ -4032,15 +4039,6 @@ static ir_initializer_t *create_ir_initializer_value( } type_t *type = initializer->value->base.type; expression_t *expr = initializer->value; - if (initializer_use_bitfield_basetype) { - type_t *skipped = skip_typeref(type); - if (skipped->kind == TYPE_BITFIELD) { - /* remove the bitfield cast... */ - assert(expr->kind == EXPR_UNARY_CAST_IMPLICIT); - expr = expr->unary.value; - type = skipped->bitfield.base_type; - } - } ir_node *value = expression_to_firm(expr); ir_mode *mode = get_ir_mode_storage(type); value = create_conv(NULL, value, mode); @@ -4375,13 +4373,8 @@ static void create_local_initializer(initializer_t *initializer, dbg_info *dbgi, } if (is_constant_initializer(initializer) == EXPR_CLASS_VARIABLE) { - bool old_initializer_use_bitfield_basetype - = initializer_use_bitfield_basetype; - initializer_use_bitfield_basetype = true; ir_initializer_t *irinitializer = create_ir_initializer(initializer, type); - initializer_use_bitfield_basetype - = old_initializer_use_bitfield_basetype; create_dynamic_initializer(irinitializer, dbgi, entity); return; @@ -4449,8 +4442,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); @@ -4498,7 +4491,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; @@ -4593,14 +4586,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) { @@ -4609,10 +4601,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 { @@ -4639,12 +4631,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); @@ -4765,7 +4757,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) { @@ -4822,7 +4814,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); @@ -4839,7 +4831,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()); } @@ -4850,7 +4842,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(); } @@ -4868,9 +4860,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) @@ -4977,7 +4968,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)) @@ -5055,14 +5046,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) @@ -5071,13 +5062,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; @@ -5102,7 +5093,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. @@ -5216,7 +5207,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) { @@ -5231,7 +5222,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) @@ -5294,20 +5285,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++; @@ -5480,7 +5470,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) @@ -5629,16 +5620,23 @@ static void initialize_function_parameters(entity_t *entity) assert(entity->kind == ENTITY_FUNCTION); ir_graph *irg = current_ir_graph; ir_node *args = get_irg_args(irg); - ir_type *function_irtype = get_ir_type(entity->declaration.type); - int first_param_nr = 0; + int n = 0; + ir_type *function_irtype; if (entity->function.need_closure) { /* add an extra parameter for the static link */ entity->function.static_link = new_r_Proj(args, mode_P_data, 0); - ++first_param_nr; + ++n; + + /* Matze: IMO this is wrong, nested functions should have an own + * type and not rely on strange parameters... */ + function_irtype = create_method_type(&entity->declaration.type->function, true); + } else { + function_irtype = get_ir_type(entity->declaration.type); } - int n = 0; + + entity_t *parameter = entity->function.parameters.entities; for ( ; parameter != NULL; parameter = parameter->base.next, ++n) { if (parameter->kind != ENTITY_PARAMETER) @@ -5653,22 +5651,20 @@ static void initialize_function_parameters(entity_t *entity) needs_entity = true; } + ir_type *param_irtype = get_method_param_type(function_irtype, n); 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_type *frame_type = get_irg_frame_type(irg); + ir_entity *param + = new_parameter_entity(frame_type, n, param_irtype); parameter->declaration.kind = DECLARATION_KIND_PARAMETER_ENTITY; - parameter->parameter.v.entity = entity; + parameter->parameter.v.entity = param; continue; } - ir_type *param_irtype = get_method_param_type(function_irtype, n); - ir_mode *param_mode = get_type_mode(param_irtype); - - long pn = n + first_param_nr; - ir_node *value = new_r_Proj(args, param_mode, pn); + ir_mode *param_mode = get_type_mode(param_irtype); + long pn = n; + ir_node *value = new_r_Proj(args, param_mode, pn); ir_mode *mode = get_ir_mode_storage(type); value = create_conv(NULL, value, mode); @@ -5802,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)); @@ -5823,7 +5819,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; @@ -5865,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); } @@ -5886,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) @@ -5900,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); @@ -5919,14 +5914,11 @@ static void create_function(entity_t *entity) if (inner != NULL) { ir_type *rem_outer_frame = current_outer_frame; current_outer_frame = get_irg_frame_type(current_ir_graph); - ir_type *rem_outer_value_type = current_outer_value_type; - current_outer_value_type = get_irg_value_param_type(current_ir_graph); for (int i = ARR_LEN(inner) - 1; i >= 0; --i) { create_function(inner[i]); } DEL_ARR_F(inner); - current_outer_value_type = rem_outer_value_type; current_outer_frame = rem_outer_frame; } }