X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgmod.c;h=4a6926ebbd6f928a51a42067c808be92df27b975;hb=6596239a5116d8b13257f7976b57c9de619a606e;hp=1abdf7ead02cd891fa868c360e98414ad51d381a;hpb=11d8edd41767b8d85a2431138527a1ebab0ed40e;p=libfirm diff --git a/ir/ir/irgmod.c b/ir/ir/irgmod.c index 1abdf7ead..4a6926ebb 100644 --- a/ir/ir/irgmod.c +++ b/ir/ir/irgmod.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -52,14 +52,15 @@ void turn_into_tuple(ir_node *node, int arity) { if (get_irn_arity(node) == arity) { /* keep old array */ } else { - /* don't use get_nodes_block here, we allow turn_into_tuple for unpinned nodes */ - ir_node *block = get_irn_n(node, -1); + ir_graph *irg = get_irn_irg(node); + ir_node *block = get_nodes_block(node); + edges_node_deleted(node, irg); /* Allocate new array, don't free old in_array, it's on the obstack. */ - edges_node_deleted(node, current_ir_graph); - node->in = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity+1); + node->in = NEW_ARR_D(ir_node *, irg->obst, arity+1); /* clear the new in array, else edge_notify tries to delete garbage */ memset(node->in, 0, (arity+1) * sizeof(node->in[0])); - set_irn_n(node, -1, block); + /* set the block back */ + set_nodes_block(node, block); } } @@ -95,8 +96,6 @@ void exchange(ir_node *old, ir_node *nw) { /* Else, do it the old-fashioned way. */ ir_node *block; - assert(get_irn_op(old)->opar != oparity_dynamic); - hook_turn_into_id(old); block = old->in[0]; @@ -108,6 +107,10 @@ void exchange(ir_node *old, ir_node *nw) { } } + if (get_irn_op(old)->opar == oparity_dynamic) { + DEL_ARR_F(get_irn_in(old)); + } + old->op = op_Id; old->in = NEW_ARR_D (ir_node *, irg->obst, 2); old->in[0] = block; @@ -120,15 +123,17 @@ void exchange(ir_node *old, ir_node *nw) { /*--------------------------------------------------------------------*/ /** - * Walker: links all Phi nodes to their Blocks and - * all Proj nodes to there predecessors + * Walker: links all Phi nodes to their Blocks lists, + * all Proj nodes to there predecessors and all + * partBlocks to there MacroBlock header. */ -static void collect(ir_node *n, void *env) { +static void collect_phiprojs_walker(ir_node *n, void *env) { ir_node *pred; + (void) env; if (is_Phi(n)) { - set_irn_link(n, get_irn_link(get_nodes_block(n))); - set_irn_link(get_nodes_block(n), n); + ir_node *block = get_nodes_block(n); + add_Block_phi(block, n); } else if (is_Proj(n)) { pred = n; do { @@ -137,13 +142,32 @@ static void collect(ir_node *n, void *env) { set_irn_link(n, get_irn_link(pred)); set_irn_link(pred, n); + } else if (is_Block(n)) { + ir_node *mbh = get_Block_MacroBlock(n); + + if (mbh != n) { + set_irn_link(n, get_irn_link(mbh)); + set_irn_link(mbh, n); + } } } -void collect_phiprojs(ir_graph *irg) { - irg_walk_graph(irg, firm_clear_link, collect, NULL); +/** + * clear all links, including the Phi list of blocks and Phi nodes. + */ +static void clear_node_and_phis_links(ir_node *n, void *env) { + (void) env; + + set_irn_link(n, NULL); + if (is_Block(n)) + set_Block_phis(n, NULL); + else if (is_Phi(n)) + set_Phi_next(n, NULL); } +void collect_phiprojs(ir_graph *irg) { + irg_walk_graph(irg, clear_node_and_phis_links, collect_phiprojs_walker, NULL); +} /*--------------------------------------------------------------------*/ /* Functionality for part_block */ @@ -155,14 +179,13 @@ void collect_phiprojs(ir_graph *irg) { */ static void move(ir_node *node, ir_node *from_bl, ir_node *to_bl) { int i, arity; - ir_node *proj, *pred; /* move this node */ set_nodes_block(node, to_bl); - /* move its projs */ + /* move its Projs */ if (get_irn_mode(node) == mode_T) { - proj = get_irn_link(node); + ir_node *proj = get_irn_link(node); while (proj) { if (get_nodes_block(proj) == from_bl) set_nodes_block(proj, to_bl); @@ -171,11 +194,12 @@ static void move(ir_node *node, ir_node *from_bl, ir_node *to_bl) { } /* recursion ... */ - if (get_irn_op(node) == op_Phi) return; + if (is_Phi(node)) + return; arity = get_irn_arity(node); for (i = 0; i < arity; i++) { - pred = get_irn_n(node, i); + ir_node *pred = get_irn_n(node, i); if (get_nodes_block(pred) == from_bl) move(pred, from_bl, to_bl); } @@ -185,6 +209,8 @@ void part_block(ir_node *node) { ir_node *new_block; ir_node *old_block; ir_node *phi; + ir_node *mbh; + ir_node *next, *block; /* Turn off optimizations so that blocks are not merged again. */ int rem_opt = get_opt_optimize(); @@ -192,8 +218,17 @@ void part_block(ir_node *node) { /* Transform the control flow */ old_block = get_nodes_block(node); + mbh = get_Block_MacroBlock(old_block); new_block = new_Block(get_Block_n_cfgpreds(old_block), - get_Block_cfgpred_arr(old_block)); + get_Block_cfgpred_arr(old_block)); + + if (mbh != old_block) { + /* we splitting a partBlock */ + set_Block_MacroBlock(new_block, mbh); + } else { + /* we are splitting a header: this creates a new header */ + set_Block_MacroBlock(new_block, new_block); + } set_irg_current_block(current_ir_graph, new_block); { ir_node *jmp = new_Jmp(); @@ -205,15 +240,77 @@ void part_block(ir_node *node) { move(node, old_block, new_block); /* move Phi nodes to new_block */ - phi = get_irn_link(old_block); - set_irn_link(new_block, phi); - set_irn_link(old_block, NULL); + phi = get_Block_phis(old_block); + set_Block_phis(new_block, phi); + set_Block_phis(old_block, NULL); while (phi) { - if(get_nodes_block(phi) == old_block); /* @@@ inlinening chokes on phis that don't - obey this condition. How do they get into - the list??? Example: InterfaceIII */ set_nodes_block(phi, new_block); - phi = get_irn_link(phi); + phi = get_Phi_next(phi); + } + + /* rewire partBlocks */ + if (mbh != old_block) { + ir_node *list = NULL; + + /* move blocks from mbh to old_block if old_block dominates them */ + block = get_irn_link(mbh); + + set_irn_link(mbh, NULL); + set_Block_MacroBlock(old_block, old_block); + + /* note that we must splice the list of partBlock here */ + for (; block != NULL; block = next) { + ir_node *curr = block; + assert(is_Block(curr)); + + next = get_irn_link(block); + + if (block == old_block) + continue; + + assert(get_Block_MacroBlock(curr) == mbh); + + for (;;) { + if (curr == old_block) { + /* old_block dominates the block, so old_block will be + the new macro block header */ + set_Block_MacroBlock(block, old_block); + set_irn_link(block, list); + list = block; + break; + } + if (curr == mbh) { + /* leave it in the mbh */ + set_irn_link(block, get_irn_link(mbh)); + set_irn_link(mbh, block); + break; + } + + assert(get_Block_n_cfgpreds(curr) == 1); + curr = get_Block_cfgpred_block(curr, 0); + } + } + /* beware: do NOT directly manipulate old_block's list, as old_block is + in mbh's list and this would destroy the list! */ + set_irn_link(old_block, list); + + /* finally add new_block to mbh's list */ + set_irn_link(new_block, get_irn_link(mbh)); + set_irn_link(mbh, new_block); + } else { + /* move blocks from mbh to new_block */ + block = get_irn_link(mbh); + + set_irn_link(mbh, NULL); + set_irn_link(new_block, NULL); + + for (; block != NULL; block = next) { + next = get_irn_link(block); + + set_Block_MacroBlock(block, new_block); + set_irn_link(block, get_irn_link(new_block)); + set_irn_link(new_block, block); + } } set_optimize(rem_opt);