X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=86638a7f9873b58f70e28b26cab0204492e69f34;hb=a59c61b5fa0c601030faec6aea663be9c76f2414;hp=1e92b9f4df34983efe0b26d72f30058bac07c2f9;hpb=6df9a73b1c5883560d0559de7c52862c1ab83abc;p=cparser diff --git a/ast2firm.c b/ast2firm.c index 1e92b9f..86638a7 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -53,18 +53,22 @@ static ir_type *ir_type_wchar_t; static ir_type *ir_type_void; static ir_type *ir_type_int; -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; +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 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; @@ -82,13 +86,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); @@ -528,7 +553,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)) { @@ -648,7 +673,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) { @@ -805,7 +830,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; @@ -1034,7 +1061,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); @@ -1388,6 +1416,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); @@ -1397,14 +1437,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: { @@ -1415,6 +1460,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); @@ -1453,11 +1509,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; @@ -1476,6 +1527,8 @@ 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: + case DECLARATION_KIND_INNER_FUNCTION: case DECLARATION_KIND_COMPOUND_TYPE_INCOMPLETE: case DECLARATION_KIND_COMPOUND_TYPE_COMPLETE: case DECLARATION_KIND_COMPOUND_MEMBER: @@ -2940,6 +2993,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 @@ -2954,7 +3053,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: @@ -3003,6 +3102,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: @@ -4066,7 +4167,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); } @@ -4112,10 +4215,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"); } @@ -4231,8 +4335,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); - keep_alive(get_store()); } else { if (false_block == NULL) { false_block = new_immBlock(); @@ -4314,12 +4418,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); } @@ -4376,7 +4481,7 @@ static void for_statement_to_firm(for_statement_t *statement) false_block); } else { keep_alive(header_block); - keep_alive(get_store()); + keep_all_memory(header_block); jmp = new_Jmp(); add_immBlock_pred(body_block, jmp); } @@ -4510,7 +4615,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); @@ -4550,27 +4655,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); @@ -4581,8 +4665,8 @@ static void label_to_firm(const label_statement_t *statement) } set_cur_block(block); - keep_alive(get_store()); keep_alive(block); + keep_all_memory(block); if (statement->statement != NULL) { statement_to_firm(statement->statement); @@ -4594,10 +4678,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); } @@ -5029,6 +5126,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; } @@ -5267,6 +5365,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. */ @@ -5290,12 +5398,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)); @@ -5345,11 +5457,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); @@ -5383,6 +5511,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) @@ -5420,6 +5549,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);