X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=390c53b4c90eed83548e595457c5361110e5fa69;hb=ab9abdc9b3e520d4e94b10de3fa2380c7a5a15f3;hp=af8aa2d01c62eb7593bfd02f89fad90e8b2c8d92;hpb=a58f1479ddc4dfaf756403ad9acce3f72125397a;p=cparser diff --git a/ast2firm.c b/ast2firm.c index af8aa2d..390c53b 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -58,7 +58,7 @@ 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 ir_node **immature_blocks; static bool constant_folding; static const declaration_t *current_function_decl; @@ -1566,17 +1566,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; } @@ -1662,6 +1662,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; } @@ -1669,9 +1678,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) @@ -2131,10 +2140,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); @@ -2311,9 +2318,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); @@ -2611,7 +2618,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); } @@ -2622,7 +2632,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 */ @@ -2633,15 +2644,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) @@ -3044,28 +3063,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; @@ -3079,7 +3090,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; @@ -3093,14 +3104,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); @@ -3124,6 +3136,7 @@ static void create_condition_evaluation(const expression_t *expression, } set_cur_block(NULL); + return cond_expr; } @@ -4168,7 +4181,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) { @@ -4218,6 +4231,8 @@ static void while_statement_to_firm(while_statement_t *statement) add_immBlock_pred(body_block, header_jmp); keep_alive(body_block); + set_cur_block(body_block); + keep_alive(get_store()); } else { if (false_block == NULL) { false_block = new_immBlock(); @@ -4361,6 +4376,7 @@ static void for_statement_to_firm(for_statement_t *statement) false_block); } else { keep_alive(header_block); + keep_alive(get_store()); jmp = new_Jmp(); add_immBlock_pred(body_block, jmp); } @@ -4423,8 +4439,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; } @@ -4507,14 +4523,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, @@ -4550,7 +4566,7 @@ static ir_node *get_label_block(declaration_t *label) label->declaration_kind = DECLARATION_KIND_LABEL_BLOCK; label->v.block = block; - ARR_APP1(ir_node *, imature_blocks, block); + ARR_APP1(ir_node *, immature_blocks, block); return block; } @@ -4565,6 +4581,7 @@ static void label_to_firm(const label_statement_t *statement) } set_cur_block(block); + keep_alive(get_store()); keep_alive(block); if (statement->statement != NULL) { @@ -5273,8 +5290,8 @@ 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(immature_blocks == NULL); + immature_blocks = NEW_ARR_F(ir_node*, 0); int n_local_vars = get_function_n_local_vars(declaration); ir_graph *irg = new_ir_graph(function_entity, n_local_vars); @@ -5328,11 +5345,11 @@ 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]); + for(int i = 0; i < ARR_LEN(immature_blocks); ++i) { + mature_immBlock(immature_blocks[i]); } - DEL_ARR_F(imature_blocks); - imature_blocks = NULL; + DEL_ARR_F(immature_blocks); + immature_blocks = NULL; mature_immBlock(first_block); mature_immBlock(end_block); @@ -5412,6 +5429,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); @@ -5421,24 +5444,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) { @@ -5495,4 +5516,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; }