X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=e5a38a0d2c63f4346ba2267737caec469681bd43;hb=9e9141455d9e7a9028d7ffa1d5656b1e9bb25c74;hp=09f48fd5cb3f8b637125750d98ed3eca2e16e5c1;hpb=da1c2bddeba34326ef288302e4f7129584041df1;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 09f48fd..e5a38a0 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -25,6 +25,7 @@ #include #include +#include #include #include "ast2firm.h" @@ -53,20 +54,24 @@ static ir_type *ir_type_wchar_t; static ir_type *ir_type_void; static ir_type *ir_type_int; -static type_t *type_const_char; +static int next_value_number_function; +static ir_node *continue_label; +static ir_node *break_label; +static ir_node *current_switch_cond; +static bool saw_default_label; +static declaration_t **all_labels; +static declaration_t **inner_functions; +static int inner_function_idx; +static ir_node *ijmp_list; +static bool constant_folding; -static int next_value_number_function; -static ir_node *continue_label; -static ir_node *break_label; -static ir_node *current_switch_cond; -static bool saw_default_label; -static ir_node **imature_blocks; -static bool constant_folding; +extern bool have_const_functions; static const declaration_t *current_function_decl; static ir_node *current_function_name; static ir_node *current_funcsig; static switch_statement_t *current_switch; +static ir_graph *current_function; static entitymap_t entitymap; @@ -84,13 +89,34 @@ typedef enum declaration_kind_t { DECLARATION_KIND_ENUM_ENTRY, DECLARATION_KIND_COMPOUND_TYPE_INCOMPLETE, DECLARATION_KIND_COMPOUND_TYPE_COMPLETE, - DECLARATION_KIND_TYPE + DECLARATION_KIND_TYPE, + DECLARATION_KIND_INNER_FUNCTION } declaration_kind_t; static ir_type *get_ir_type(type_t *type); static ir_type *get_ir_type_incomplete(type_t *type); static int count_decls_in_stmts(const statement_t *stmt); +static void enqueue_inner_function(declaration_t *declaration) { + if (inner_functions == NULL) { + inner_functions = NEW_ARR_F(declaration_t *, 16); + inner_functions[0] = declaration; + inner_function_idx = 1; + } else { + int size = ARR_LEN(inner_functions); + if (inner_function_idx >= size) { + ARR_RESIZE(declaration_t *, inner_functions, size + 16); + } + inner_functions[inner_function_idx++] = declaration; + } +} + +static declaration_t *next_inner_function(void) { + if (inner_function_idx == 0) + return 0; + return inner_functions[--inner_function_idx]; +} + ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos) { const declaration_t *declaration = get_irg_loc_description(irg, pos); @@ -530,7 +556,7 @@ static ir_type *create_bitfield_type(bitfield_type_t *const type) assert(base->kind == TYPE_ATOMIC || base->kind == TYPE_ENUM); ir_type *irbase = get_ir_type(base); - unsigned size = fold_constant(type->size); + unsigned size = type->bit_size; assert(!is_type_float(base)); if (is_type_signed(base)) { @@ -650,7 +676,7 @@ static ir_type *create_compound_type(compound_type_t *type, ir_type *irtype, size_t base; size_t bits_remainder; if (entry_type->kind == TYPE_BITFIELD) { - size_t size_bits = fold_constant(entry_type->bitfield.size); + size_t size_bits = entry_type->bitfield.bit_size; size_t rest_size_bits = (entry_alignment - misalign)*8 - bit_offset; if (size_bits > rest_size_bits) { @@ -807,7 +833,9 @@ static ir_type *get_ir_type(type_t *type) ir_type *firm_type = NULL; switch (type->kind) { case TYPE_ERROR: - panic("error type occurred"); + /* Happens while constant folding, when there was an error */ + return create_atomic_type(&type_void->atomic); + case TYPE_ATOMIC: firm_type = create_atomic_type(&type->atomic); break; @@ -1022,6 +1050,10 @@ static void handle_gnu_attributes_ent(ir_entity *ent, declaration_t *decl) __attribute__((pure)) specifier. */ set_entity_additional_property(ent, mtp_property_pure); } + if (decl->modifiers & DM_CONST) { + set_entity_additional_property(ent, mtp_property_const); + have_const_functions = true; + } if (decl->modifiers & DM_USED) { /* TRUE if the declaration includes the GNU __attribute__((used)) specifier. */ @@ -1036,7 +1068,8 @@ static void handle_gnu_attributes_ent(ir_entity *ent, declaration_t *decl) */ static ir_entity *get_function_entity(declaration_t *declaration) { - if (declaration->declaration_kind == DECLARATION_KIND_FUNCTION) + if (declaration->declaration_kind == DECLARATION_KIND_FUNCTION || + declaration->declaration_kind == DECLARATION_KIND_INNER_FUNCTION) return declaration->v.entity; assert(declaration->declaration_kind == DECLARATION_KIND_UNKNOWN); @@ -1390,6 +1423,18 @@ static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode) return new_d_Conv(dbgi, value, dest_mode); } +/** + * Keep all memory edges of the given block. + */ +static void keep_all_memory(ir_node *block) { + ir_node *old = get_cur_block(); + + set_cur_block(block); + keep_alive(get_store()); + /* TODO: keep all memory edges from restricted pointers */ + set_cur_block(old); +} + static ir_node *reference_expression_to_firm(const reference_expression_t *ref) { dbg_info *dbgi = get_dbg_info(&ref->base.source_position); @@ -1399,14 +1444,19 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref) /* make sure the type is constructed */ (void) get_ir_type(type); - switch((declaration_kind_t) declaration->declaration_kind) { + switch ((declaration_kind_t)declaration->declaration_kind) { case DECLARATION_KIND_TYPE: case DECLARATION_KIND_UNKNOWN: break; case DECLARATION_KIND_ENUM_ENTRY: { ir_mode *const mode = get_ir_mode(type); - return new_Const(mode, declaration->v.enum_val); + if (ref->is_outer_ref) { + /* reference to an outer variable */ + panic("Outer variable reference not implemented"); + } else { + return new_Const(mode, declaration->v.enum_val); + } } case DECLARATION_KIND_LOCAL_VARIABLE: { @@ -1417,6 +1467,17 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref) ir_mode *const mode = get_ir_mode(type); return create_symconst(dbgi, mode, declaration->v.entity); } + case DECLARATION_KIND_INNER_FUNCTION: { + ir_mode *const mode = get_ir_mode(type); + if (! declaration->goto_to_outer && !declaration->need_closure) { + /* inner function not using the closure */ + return create_symconst(dbgi, mode, declaration->v.entity); + } else { + /* TODO: need trampoline here */ + panic("Trampoline code not implemented"); + return create_symconst(dbgi, mode, declaration->v.entity); + } + } case DECLARATION_KIND_GLOBAL_VARIABLE: { ir_node *const addr = get_global_var_address(dbgi, declaration); return deref_address(dbgi, declaration->type, addr); @@ -1455,11 +1516,6 @@ static ir_node *reference_addr(const reference_expression_t *ref) /* you can store to a local variable (so we don't panic but return NULL * as an indicator for no real address) */ return NULL; - case DECLARATION_KIND_FUNCTION: { - type_t *const type = skip_typeref(ref->base.type); - ir_mode *const mode = get_ir_mode(type); - return create_symconst(dbgi, mode, declaration->v.entity); - } case DECLARATION_KIND_GLOBAL_VARIABLE: { ir_node *const addr = get_global_var_address(dbgi, declaration); return addr; @@ -1478,6 +1534,13 @@ static ir_node *reference_addr(const reference_expression_t *ref) case DECLARATION_KIND_ENUM_ENTRY: panic("trying to reference enum entry"); + case DECLARATION_KIND_FUNCTION: { + type_t *const type = skip_typeref(declaration->type); + ir_mode *const mode = get_ir_mode(type); + return create_symconst(dbgi, mode, declaration->v.entity); + } + + case DECLARATION_KIND_INNER_FUNCTION: case DECLARATION_KIND_COMPOUND_TYPE_INCOMPLETE: case DECLARATION_KIND_COMPOUND_TYPE_COMPLETE: case DECLARATION_KIND_COMPOUND_MEMBER: @@ -1521,7 +1584,11 @@ static ir_node *process_builtin_call(const call_expression_t *call) return res; } - case T___builtin_huge_val: { + + case T___builtin_huge_val: + case T___builtin_inf: + case T___builtin_inff: + case T___builtin_infl: { ir_mode *mode = get_ir_mode(function_type->function.return_type); tarval *tv = get_mode_infinite(mode); ir_node *res = new_d_Const(dbgi, mode, tv); @@ -1529,7 +1596,7 @@ static ir_node *process_builtin_call(const call_expression_t *call) } case T___builtin_nan: case T___builtin_nanf: - case T___builtin_nand: { + case T___builtin_nanl: { /* Ignore string for now... */ assert(is_type_function(function_type)); ir_mode *mode = get_ir_mode(function_type->function.return_type); @@ -1568,17 +1635,17 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) if (declaration->v.entity == rts_entities[rts_alloca]) { /* handle alloca() call */ expression_t *argument = call->arguments->expression; - ir_node *size = expression_to_firm(argument); + ir_node *size = expression_to_firm(argument); - size = create_conv(dbgi, size, get_ir_mode(type_size_t)); + size = create_conv(dbgi, size, get_ir_mode(type_size_t)); - ir_node *store = get_store(); - dbg_info *dbgi = get_dbg_info(&call->base.source_position); - ir_node *alloca = new_d_Alloc(dbgi, store, size, firm_unknown_type, - stack_alloc); - ir_node *proj_m = new_Proj(alloca, mode_M, pn_Alloc_M); + ir_node *store = get_store(); + dbg_info *dbgi = get_dbg_info(&call->base.source_position); + ir_node *alloca = new_d_Alloc(dbgi, store, size, firm_unknown_type, + stack_alloc); + ir_node *proj_m = new_Proj(alloca, mode_M, pn_Alloc_M); set_store(proj_m); - ir_node *res = new_Proj(alloca, mode_P_data, pn_Alloc_res); + ir_node *res = new_Proj(alloca, mode_P_data, pn_Alloc_res); return res; } @@ -1664,6 +1731,15 @@ static ir_node *call_expression_to_firm(const call_expression_t *call) result = new_d_Proj(dbgi, resproj, mode, 0); } + if (function->kind == EXPR_REFERENCE && + function->reference.declaration->modifiers & DM_NORETURN) { + /* A dead end: Keep the Call and the Block. Also place all further + * nodes into a new and unreachable block. */ + keep_alive(node); + keep_alive(get_cur_block()); + new_Block(0, NULL); + } + return result; } @@ -1671,9 +1747,9 @@ static void statement_to_firm(statement_t *statement); static ir_node *compound_statement_to_firm(compound_statement_t *compound); static ir_node *expression_to_addr(const expression_t *expression); -static void create_condition_evaluation(const expression_t *expression, - ir_node *true_block, - ir_node *false_block); +static ir_node *create_condition_evaluation(const expression_t *expression, + ir_node *true_block, + ir_node *false_block); static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type, ir_node *value) @@ -1718,21 +1794,19 @@ static tarval *create_bitfield_mask(ir_mode *mode, int offset, int size) return mask1; } -static void bitfield_store_to_firm(const select_expression_t *expression, - ir_node *addr, ir_node *value) +static void bitfield_store_to_firm(dbg_info *dbgi, + ir_entity *entity, ir_node *addr, ir_node *value, bool set_volatile) { - type_t *type = expression->base.type; - ir_mode *mode = get_ir_mode(type); - - assert(get_irn_mode(value) == mode || is_Bad(value)); + ir_type *entity_type = get_entity_type(entity); + ir_type *base_type = get_primitive_base_type(entity_type); + assert(base_type != NULL); + ir_mode *mode = get_type_mode(base_type); - dbg_info *dbgi = get_dbg_info(&expression->base.source_position); + value = create_conv(dbgi, value, mode); /* kill upper bits of value and shift to right position */ - ir_entity *entity = expression->compound_entry->v.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)); + int bitoffset = get_entity_offset_bits_remainder(entity); + int bitsize = get_mode_size_bits(get_type_mode(entity_type)); tarval *mask = create_bitfield_mask(mode, 0, bitsize); ir_node *mask_node = new_d_Const(dbgi, mode, mask); @@ -1757,7 +1831,7 @@ static void bitfield_store_to_firm(const select_expression_t *expression, ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M); set_store(store_mem); - if (type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) { + if (set_volatile) { set_Load_volatility(load, volatility_is_volatile); set_Store_volatility(store, volatility_is_volatile); } @@ -1830,7 +1904,10 @@ static void set_value_for_expression_addr(const expression_t *expression, declaration_t *declaration = select->compound_entry; if (declaration->type->kind == TYPE_BITFIELD) { - bitfield_store_to_firm(select, addr, value); + ir_entity *entity = select->compound_entry->v.entity; + bool set_volatile + = select->base.type->base.qualifiers & TYPE_QUALIFIER_VOLATILE; + bitfield_store_to_firm(dbgi, entity, addr, value, set_volatile); return; } } @@ -2133,10 +2210,8 @@ static ir_node *produce_condition_result(const expression_t *expression, mature_immBlock(one_block); mature_immBlock(zero_block); - ir_node *common_block = new_immBlock(); - add_immBlock_pred(common_block, jmp_one); - add_immBlock_pred(common_block, jmp_zero); - mature_immBlock(common_block); + ir_node *in_cf[2] = { jmp_one, jmp_zero }; + new_Block(2, in_cf); ir_node *in[2] = { one, zero }; ir_node *val = new_d_Phi(dbgi, 2, in, mode); @@ -2152,9 +2227,8 @@ static ir_node *adjust_for_pointer_arithmetic(dbg_info *dbgi, unsigned elem_size = get_type_size_const(points_to); /* gcc extension: allow arithmetic with void * and function * */ - if (elem_size == 0 && - (is_type_atomic(points_to, ATOMIC_TYPE_VOID) || - is_type_function(points_to))) { + if ((elem_size == 0 && is_type_atomic(points_to, ATOMIC_TYPE_VOID)) || + is_type_function(points_to)) { elem_size = 1; } @@ -2314,9 +2388,9 @@ static ir_node *create_assign_binop(const binary_expression_t *expression) dbg_info *const dbgi = get_dbg_info(&expression->base.source_position); const expression_t *left_expr = expression->left; ir_mode *left_mode = get_ir_mode(left_expr->base.type); + ir_node *right = expression_to_firm(expression->right); ir_node *left_addr = expression_to_addr(left_expr); ir_node *left = get_value_from_lvalue(left_expr, left_addr); - ir_node *right = expression_to_firm(expression->right); ir_node *result = create_op(dbgi, expression, left, right); result = create_conv(dbgi, result, left_mode); @@ -2473,7 +2547,6 @@ static long get_offsetof_offset(const offsetof_expression_t *expression) expression_t *array_index = designator->array_index; assert(designator->array_index != NULL); assert(is_type_array(type)); - assert(is_type_valid(array_index->base.type)); long index = fold_constant(array_index); ir_type *arr_type = get_ir_type(type); @@ -2574,8 +2647,11 @@ static ir_node *alignof_to_firm(const typeprop_expression_t *expression) } static void init_ir_types(void); + long fold_constant(const expression_t *expression) { + assert(is_type_valid(skip_typeref(expression->base.type))); + bool constant_folding_old = constant_folding; constant_folding = true; @@ -2613,7 +2689,10 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression) if (is_constant_expression(expression->condition)) { long val = fold_constant(expression->condition); if (val) { - return expression_to_firm(expression->true_expression); + expression_t *true_expression = expression->true_expression; + if (true_expression == NULL) + true_expression = expression->condition; + return expression_to_firm(true_expression); } else { return expression_to_firm(expression->false_expression); } @@ -2624,7 +2703,8 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression) /* create the true block */ ir_node *true_block = new_immBlock(); - ir_node *true_val = expression_to_firm(expression->true_expression); + ir_node *true_val = expression->true_expression != NULL ? + expression_to_firm(expression->true_expression) : NULL; ir_node *true_jmp = new_Jmp(); /* create the false block */ @@ -2635,15 +2715,23 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression) /* create the condition evaluation */ set_cur_block(cur_block); - create_condition_evaluation(expression->condition, true_block, false_block); + ir_node *const cond_expr = create_condition_evaluation(expression->condition, true_block, false_block); + if (expression->true_expression == NULL) { + if (cond_expr != NULL) { + true_val = cond_expr; + } else { + /* Condition ended with a short circuit (&&, ||, !) operation. + * Generate a "1" as value for the true branch. */ + ir_mode *const mode = mode_Is; + true_val = new_Const(mode, get_mode_one(mode)); + } + } mature_immBlock(true_block); mature_immBlock(false_block); /* create the common block */ - ir_node *common_block = new_immBlock(); - add_immBlock_pred(common_block, true_jmp); - add_immBlock_pred(common_block, false_jmp); - mature_immBlock(common_block); + ir_node *in_cf[2] = { true_jmp, false_jmp }; + new_Block(2, in_cf); /* TODO improve static semantics, so either both or no values are NULL */ if (true_val == NULL || false_val == NULL) @@ -2923,6 +3011,52 @@ static ir_node *builtin_prefetch_to_firm( return NULL; } +static ir_node *get_label_block(declaration_t *label) +{ + assert(label->namespc == NAMESPACE_LABEL || label->namespc == NAMESPACE_LOCAL_LABEL); + + if (label->declaration_kind == DECLARATION_KIND_LABEL_BLOCK) { + return label->v.block; + } + assert(label->declaration_kind == DECLARATION_KIND_UNKNOWN); + + /* beware: might be called from create initializer with current_ir_graph + * set to const_code_irg. */ + ir_graph *rem = current_ir_graph; + current_ir_graph = current_function; + + ir_node *old_cur_block = get_cur_block(); + ir_node *block = new_immBlock(); + set_cur_block(old_cur_block); + + label->declaration_kind = DECLARATION_KIND_LABEL_BLOCK; + label->v.block = block; + + ARR_APP1(declaration_t *, all_labels, label); + + current_ir_graph = rem; + return block; +} + +/** + * Pointer to a label. This is used for the + * GNU address-of-label extension. + */ +static ir_node *label_address_to_firm( + const label_address_expression_t *label) +{ + ir_node *block = get_label_block(label->declaration); + ir_label_t nr = get_Block_label(block); + + if (nr == 0) { + nr = get_irp_next_label_nr(); + set_Block_label(block, nr); + } + symconst_symbol value; + value.label = nr; + return new_SymConst(mode_P_code, value, symconst_label); +} + /** * creates firm nodes for an expression. The difference between this function * and expression_to_firm is, that this version might produce mode_b nodes @@ -2937,7 +3071,7 @@ static ir_node *_expression_to_firm(const expression_t *expression) } #endif - switch(expression->kind) { + switch (expression->kind) { case EXPR_CHARACTER_CONSTANT: return character_constant_to_firm(&expression->conste); case EXPR_WIDE_CHARACTER_CONSTANT: @@ -2986,6 +3120,8 @@ static ir_node *_expression_to_firm(const expression_t *expression) return offsetof_to_firm(&expression->offsetofe); case EXPR_COMPOUND_LITERAL: return compound_literal_to_firm(&expression->compound_literal); + case EXPR_LABEL_ADDRESS: + return label_address_to_firm(&expression->label_address); case EXPR_UNKNOWN: case EXPR_INVALID: @@ -3046,28 +3182,20 @@ static ir_node *expression_to_firm(const expression_t *expression) return produce_condition_result(expression, dbgi); } -static ir_node *expression_to_modeb(const expression_t *expression) -{ - ir_node *res = _expression_to_firm(expression); - res = create_conv(NULL, res, mode_b); - - return res; -} - /** * create a short-circuit expression evaluation that tries to construct * efficient control flow structures for &&, || and ! expressions */ -static void create_condition_evaluation(const expression_t *expression, - ir_node *true_block, - ir_node *false_block) +static ir_node *create_condition_evaluation(const expression_t *expression, + ir_node *true_block, + ir_node *false_block) { switch(expression->kind) { case EXPR_UNARY_NOT: { const unary_expression_t *unary_expression = &expression->unary; create_condition_evaluation(unary_expression->value, false_block, true_block); - return; + return NULL; } case EXPR_BINARY_LOGICAL_AND: { const binary_expression_t *binary_expression = &expression->binary; @@ -3081,7 +3209,7 @@ static void create_condition_evaluation(const expression_t *expression, set_cur_block(extra_block); create_condition_evaluation(binary_expression->right, true_block, false_block); - return; + return NULL; } case EXPR_BINARY_LOGICAL_OR: { const binary_expression_t *binary_expression = &expression->binary; @@ -3095,14 +3223,15 @@ static void create_condition_evaluation(const expression_t *expression, set_cur_block(extra_block); create_condition_evaluation(binary_expression->right, true_block, false_block); - return; + return NULL; } default: break; } dbg_info *dbgi = get_dbg_info(&expression->base.source_position); - ir_node *condition = expression_to_modeb(expression); + ir_node *cond_expr = _expression_to_firm(expression); + ir_node *condition = create_conv(NULL, cond_expr, mode_b); ir_node *cond = new_d_Cond(dbgi, condition); ir_node *true_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_true); ir_node *false_proj = new_d_Proj(dbgi, cond, mode_X, pn_Cond_false); @@ -3126,6 +3255,7 @@ static void create_condition_evaluation(const expression_t *expression, } set_cur_block(NULL); + return cond_expr; } @@ -3145,6 +3275,8 @@ static void create_declaration_entity(declaration_t *declaration, dbg_info *const dbgi = get_dbg_info(&declaration->source_position); ir_entity *const entity = new_d_entity(parent_type, id, irtype, dbgi); + handle_gnu_attributes_ent(entity, declaration); + declaration->declaration_kind = (unsigned char) declaration_kind; declaration->v.entity = entity; set_entity_variability(entity, variability_uninitialized); @@ -3331,12 +3463,11 @@ static void walk_designator(type_path_t *path, const designator_t *designator) expression_t *array_index = designator->array_index; assert(designator->array_index != NULL); assert(is_type_array(type)); - assert(is_type_valid(array_index->base.type)); long index = fold_constant(array_index); assert(index >= 0); #ifndef NDEBUG - if (type->array.size_constant == 1) { + if (type->array.size_constant) { long array_size = type->array.size; assert(index < array_size); } @@ -3589,7 +3720,7 @@ static void create_dynamic_null_initializer(ir_type *type, dbg_info *dbgi, } static void create_dynamic_initializer_sub(ir_initializer_t *initializer, - ir_type *type, dbg_info *dbgi, ir_node *base_addr) + ir_entity *entity, ir_type *type, dbg_info *dbgi, ir_node *base_addr) { switch(get_initializer_kind(initializer)) { case IR_INITIALIZER_NULL: { @@ -3597,11 +3728,18 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, return; } case IR_INITIALIZER_CONST: { - ir_node *node = get_initializer_const_value(initializer); - ir_mode *mode = get_irn_mode(node); - assert(get_type_mode(type) == mode); + ir_node *node = get_initializer_const_value(initializer); + ir_mode *mode = get_irn_mode(node); + ir_type *ent_type = get_entity_type(entity); + + /* is it a bitfield type? */ + if (is_Primitive_type(ent_type) && + get_primitive_base_type(ent_type) != NULL) { + bitfield_store_to_firm(dbgi, entity, base_addr, node, false); + return; + } - /* TODO: bitfields... */ + assert(get_type_mode(type) == mode); ir_node *mem = get_store(); ir_node *store = new_d_Store(dbgi, mem, base_addr, node); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); @@ -3609,12 +3747,19 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, return; } case IR_INITIALIZER_TARVAL: { - tarval *tv = get_initializer_tarval_value(initializer); - ir_mode *mode = get_tarval_mode(tv); - ir_node *cnst = new_d_Const(dbgi, mode, tv); - assert(get_type_mode(type) == mode); + tarval *tv = get_initializer_tarval_value(initializer); + ir_mode *mode = get_tarval_mode(tv); + ir_node *cnst = new_d_Const(dbgi, mode, tv); + ir_type *ent_type = get_entity_type(entity); + + /* is it a bitfield type? */ + if (is_Primitive_type(ent_type) && + get_primitive_base_type(ent_type) != NULL) { + bitfield_store_to_firm(dbgi, entity, base_addr, cnst, false); + return; + } - /* TODO: bitfields... */ + assert(get_type_mode(type) == mode); ir_node *mem = get_store(); ir_node *store = new_d_Store(dbgi, mem, base_addr, cnst); ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M); @@ -3636,26 +3781,29 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer, panic("initializer doesn't match compound type"); for(int i = 0; i < n_members; ++i) { - ir_node *addr; - ir_type *irtype; + ir_node *addr; + ir_type *irtype; + ir_entity *sub_entity; if (is_Array_type(type)) { - ir_entity *entity = get_array_element_entity(type); tarval *index_tv = new_tarval_from_long(i, mode_uint); ir_node *cnst = new_d_Const(dbgi, mode_uint, index_tv); ir_node *in[1] = { cnst }; - irtype = get_array_element_type(type); - addr = new_d_Sel(dbgi, new_NoMem(), base_addr, 1, in, entity); + irtype = get_array_element_type(type); + sub_entity = get_array_element_entity(type); + addr = new_d_Sel(dbgi, new_NoMem(), base_addr, 1, in, + sub_entity); } else { - ir_entity *member = get_compound_member(type, i); - - irtype = get_entity_type(member); - addr = new_d_simpleSel(dbgi, new_NoMem(), base_addr, member); + sub_entity = get_compound_member(type, i); + irtype = get_entity_type(sub_entity); + addr = new_d_simpleSel(dbgi, new_NoMem(), base_addr, + sub_entity); } ir_initializer_t *sub_init = get_initializer_compound_value(initializer, i); - create_dynamic_initializer_sub(sub_init, irtype, dbgi, addr); + create_dynamic_initializer_sub(sub_init, sub_entity, irtype, dbgi, + addr); } return; } @@ -3671,7 +3819,7 @@ static void create_dynamic_initializer(ir_initializer_t *initializer, ir_node *base_addr = new_d_simpleSel(dbgi, new_NoMem(), frame, entity); ir_type *type = get_entity_type(entity); - create_dynamic_initializer_sub(initializer, type, dbgi, base_addr); + create_dynamic_initializer_sub(initializer, entity, type, dbgi, base_addr); } static void create_local_initializer(initializer_t *initializer, dbg_info *dbgi, @@ -3750,7 +3898,8 @@ static void create_declaration_initializer(declaration_t *declaration) return; } - type_t *type = skip_typeref(declaration->type); + type_t *type = declaration->type; + type_qualifiers_t tq = get_type_qualifier(type, true); if (initializer->kind == INITIALIZER_VALUE) { initializer_value_t *initializer_value = &initializer->value; @@ -3767,7 +3916,7 @@ static void create_declaration_initializer(declaration_t *declaration) ir_entity *entity = declaration->v.entity; - if (type->base.qualifiers & TYPE_QUALIFIER_CONST) { + if (tq & TYPE_QUALIFIER_CONST) { set_entity_variability(entity, variability_constant); } else { set_entity_variability(entity, variability_initialized); @@ -3775,14 +3924,14 @@ static void create_declaration_initializer(declaration_t *declaration) set_atomic_ent_value(entity, value); } } else { - assert(declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE_ENTITY - || declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE); + assert(declaration_kind == DECLARATION_KIND_LOCAL_VARIABLE_ENTITY || + declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE); ir_entity *entity = declaration->v.entity; ir_initializer_t *irinitializer = create_ir_initializer(initializer, type); - if (type->base.qualifiers & TYPE_QUALIFIER_CONST) { + if (tq & TYPE_QUALIFIER_CONST) { set_entity_variability(entity, variability_constant); } else { set_entity_variability(entity, variability_initialized); @@ -4055,7 +4204,9 @@ static void create_local_declaration(declaration_t *declaration) case STORAGE_CLASS_REGISTER: if (is_type_function(type)) { if (declaration->init.statement != NULL) { - panic("nested functions not supported yet"); + get_function_entity(declaration); + declaration->declaration_kind = DECLARATION_KIND_INNER_FUNCTION; + enqueue_inner_function(declaration); } else { get_function_entity(declaration); } @@ -4101,10 +4252,11 @@ static void initialize_local_declaration(declaration_t *declaration) case DECLARATION_KIND_FUNCTION: case DECLARATION_KIND_TYPE: case DECLARATION_KIND_ENUM_ENTRY: + case DECLARATION_KIND_INNER_FUNCTION: return; case DECLARATION_KIND_UNKNOWN: - panic("can't initialize unknwon declaration"); + panic("can't initialize unknown declaration"); } panic("invalid declaration kind"); } @@ -4170,7 +4322,7 @@ static void if_statement_to_firm(if_statement_t *statement) } mature_immBlock(true_block); - if (false_block != fallthrough_block) { + if (false_block != fallthrough_block && false_block != NULL) { mature_immBlock(false_block); } if (fallthrough_block != NULL) { @@ -4220,6 +4372,8 @@ static void while_statement_to_firm(while_statement_t *statement) add_immBlock_pred(body_block, header_jmp); keep_alive(body_block); + keep_all_memory(body_block); + set_cur_block(body_block); } else { if (false_block == NULL) { false_block = new_immBlock(); @@ -4301,12 +4455,13 @@ static void for_statement_to_firm(for_statement_t *statement) for( ; declaration != NULL; declaration = declaration->next) { create_local_declaration(declaration); } - declaration = statement->scope.declarations; - for( ; declaration != NULL; declaration = declaration->next) { - initialize_local_declaration(declaration); - } if (get_cur_block() != NULL) { + declaration = statement->scope.declarations; + for( ; declaration != NULL; declaration = declaration->next) { + initialize_local_declaration(declaration); + } + if (statement->initialisation != NULL) { expression_to_firm(statement->initialisation); } @@ -4363,6 +4518,7 @@ static void for_statement_to_firm(for_statement_t *statement) false_block); } else { keep_alive(header_block); + keep_all_memory(header_block); jmp = new_Jmp(); add_immBlock_pred(body_block, jmp); } @@ -4425,8 +4581,8 @@ static void switch_statement_to_firm(switch_statement_t *statement) /* default case */ continue; } - for (long cns = l->first_case; cns <= l->last_case; ++cns) - ++num_cases; + if (l->last_case >= l->first_case) + num_cases += l->last_case - l->first_case; if (l->last_case > def_nr) def_nr = l->last_case; } @@ -4496,7 +4652,7 @@ static void switch_statement_to_firm(switch_statement_t *statement) static void case_label_to_firm(const case_label_statement_t *statement) { - if (statement->is_empty) + if (statement->is_empty_range) return; dbg_info *dbgi = get_dbg_info(&statement->base.source_position); @@ -4509,14 +4665,14 @@ static void case_label_to_firm(const case_label_statement_t *statement) set_cur_block(old_block); if (statement->expression != NULL) { - long start_pn = statement->first_case; - long end_pn = statement->last_case; - assert(start_pn <= end_pn); + long pn = statement->first_case; + long end_pn = statement->last_case; + assert(pn <= end_pn); /* create jumps for all cases in the given range */ - for (long pn = start_pn; pn <= end_pn; ++pn) { + do { proj = new_d_Proj(dbgi, current_switch_cond, mode_X, pn); add_immBlock_pred(block, proj); - } + } while(pn++ < end_pn); } else { saw_default_label = true; proj = new_d_defaultProj(dbgi, current_switch_cond, @@ -4536,27 +4692,6 @@ static void case_label_to_firm(const case_label_statement_t *statement) } } -static ir_node *get_label_block(declaration_t *label) -{ - assert(label->namespc == NAMESPACE_LABEL); - - if (label->declaration_kind == DECLARATION_KIND_LABEL_BLOCK) { - return label->v.block; - } - assert(label->declaration_kind == DECLARATION_KIND_UNKNOWN); - - ir_node *old_cur_block = get_cur_block(); - ir_node *block = new_immBlock(); - set_cur_block(old_cur_block); - - label->declaration_kind = DECLARATION_KIND_LABEL_BLOCK; - label->v.block = block; - - ARR_APP1(ir_node *, imature_blocks, block); - - return block; -} - static void label_to_firm(const label_statement_t *statement) { ir_node *block = get_label_block(statement->label); @@ -4568,6 +4703,7 @@ static void label_to_firm(const label_statement_t *statement) set_cur_block(block); keep_alive(block); + keep_all_memory(block); if (statement->statement != NULL) { statement_to_firm(statement->statement); @@ -4579,10 +4715,23 @@ static void goto_to_firm(const goto_statement_t *statement) if (get_cur_block() == NULL) return; - ir_node *block = get_label_block(statement->label); - ir_node *jmp = new_Jmp(); - add_immBlock_pred(block, jmp); + if (statement->expression) { + ir_node *irn = expression_to_firm(statement->expression); + dbg_info *dbgi = get_dbg_info(&statement->base.source_position); + ir_node *ijmp = new_d_IJmp(dbgi, irn); + set_irn_link(ijmp, ijmp_list); + ijmp_list = ijmp; + } else { + if (statement->outer_fkt_jmp) { + /* TODO: this is a outer function jmp */ + panic("outer function jump not implemented"); + } else { + ir_node *block = get_label_block(statement->label); + ir_node *jmp = new_Jmp(); + add_immBlock_pred(block, jmp); + } + } set_cur_block(NULL); } @@ -5014,6 +5163,7 @@ static int count_decls_in_expression(const expression_t *expression) { case EXPR_BUILTIN_SYMBOL: case EXPR_VA_START: case EXPR_VA_ARG: + case EXPR_LABEL_ADDRESS: break; } @@ -5252,6 +5402,16 @@ static void add_function_pointer(ir_type *segment, ir_entity *method, set_atomic_ent_value(ptr, val); } +/** + * Generate possible IJmp branches to a given label block. + */ +static void gen_ijmp_branches(ir_node *block) { + ir_node *ijmp; + for (ijmp = ijmp_list; ijmp != NULL; ijmp = get_irn_link(ijmp)) { + add_immBlock_pred(block, ijmp); + } +} + /** * Create code for a function. */ @@ -5275,12 +5435,16 @@ static void create_function(declaration_t *declaration) current_function_name = NULL; current_funcsig = NULL; - assert(imature_blocks == NULL); - imature_blocks = NEW_ARR_F(ir_node*, 0); + assert(all_labels == NULL); + all_labels = NEW_ARR_F(declaration_t *, 0); + ijmp_list = NULL; int n_local_vars = get_function_n_local_vars(declaration); ir_graph *irg = new_ir_graph(function_entity, n_local_vars); + ir_graph *old_current_function = current_function; + current_function = irg; + set_irg_fp_model(irg, firm_opt.fp_model); tarval_enable_fp_ops((firm_opt.fp_model & fp_strict_algebraic) == 0); set_irn_dbg_info(get_irg_start_block(irg), get_entity_dbg_info(function_entity)); @@ -5330,11 +5494,27 @@ static void create_function(declaration_t *declaration) add_immBlock_pred(end_block, ret); } - for(int i = 0; i < ARR_LEN(imature_blocks); ++i) { - mature_immBlock(imature_blocks[i]); + bool has_computed_gotos = false; + for (int i = ARR_LEN(all_labels) - 1; i >= 0; --i) { + declaration_t *label = all_labels[i]; + if (label->address_taken) { + gen_ijmp_branches(label->v.block); + has_computed_gotos = true; + } + mature_immBlock(label->v.block); + } + 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(&declaration->source_position, + "function '%Y' can never be inlined because it contains a computed goto", + declaration->symbol); + } + set_irg_inline_property(irg, irg_inline_forbidden); } - DEL_ARR_F(imature_blocks); - imature_blocks = NULL; + + DEL_ARR_F(all_labels); + all_labels = NULL; mature_immBlock(first_block); mature_immBlock(end_block); @@ -5368,6 +5548,7 @@ static void create_function(declaration_t *declaration) set_type_alignment_bytes(frame_type, align_all); irg_vrfy(irg); + current_function = old_current_function; } static void scope_to_firm(scope_t *scope) @@ -5405,6 +5586,10 @@ static void scope_to_firm(scope_t *scope) type_t *type = declaration->type; if (type->kind == TYPE_FUNCTION) { create_function(declaration); + declaration_t *inner; + for (inner = next_inner_function(); inner != NULL; + inner = next_inner_function()) + create_function(inner); } else { assert(declaration->declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE); @@ -5414,6 +5599,12 @@ static void scope_to_firm(scope_t *scope) } } +static void set_be_option(const char *option) +{ + int res = firm_be_option(option); + assert(res); +} + void init_ast2firm(void) { obstack_init(&asm_obst); @@ -5423,24 +5614,22 @@ void init_ast2firm(void) id_imp = new_id_from_chars("__imp_", 6); /* OS option must be set to the backend */ - const char *s = "ia32-gasmode=linux"; switch (firm_opt.os_support) { case OS_SUPPORT_MINGW: create_ld_ident = create_ld_ident_win32; - s = "ia32-gasmode=mingw"; + set_be_option("ia32-gasmode=mingw"); break; case OS_SUPPORT_LINUX: create_ld_ident = create_ld_ident_linux_elf; - s = "ia32-gasmode=elf"; + set_be_option("ia32-gasmode=elf"); break; case OS_SUPPORT_MACHO: create_ld_ident = create_ld_ident_macho; - s = "ia32-gasmode=macho"; + set_be_option("ia32-gasmode=macho"); + set_be_option("ia32-stackalign=4"); + set_be_option("pic"); break; } - int res = firm_be_option(s); - (void) res; - assert(res); /* create idents for all known runtime functions */ for (size_t i = 0; i < sizeof(rts_data) / sizeof(rts_data[0]); ++i) { @@ -5457,10 +5646,6 @@ static void init_ir_types(void) return; ir_types_initialized = 1; - type_const_char = make_atomic_type(ATOMIC_TYPE_CHAR, TYPE_QUALIFIER_CONST); - type_void = make_atomic_type(ATOMIC_TYPE_VOID, TYPE_QUALIFIER_NONE); - type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE); - ir_type_int = get_ir_type(type_int); ir_type_const_char = get_ir_type(type_const_char); ir_type_wchar_t = get_ir_type(type_wchar_t); @@ -5501,4 +5686,6 @@ void translation_unit_to_firm(translation_unit_t *unit) scope_to_firm(&unit->scope); global_asm_to_firm(unit->global_asm); + + current_ir_graph = NULL; }