X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgmod.c;h=f9a4f481610f86510817e3306162bd48a4064a16;hb=7e8388fa7996ff182d3aa4e0cdd41b27bed4982f;hp=0a06562804b2c9222c7fec8f308a8600a47e2a2b;hpb=98c21a869cebe3db3aec1d823ddbd7000416ff83;p=libfirm diff --git a/ir/ir/irgmod.c b/ir/ir/irgmod.c index 0a0656280..f9a4f4816 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,16 +123,18 @@ 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); + set_Phi_next(n, get_Block_phis(block)); + set_Block_phis(block, n); } else if (is_Proj(n)) { pred = n; do { @@ -138,13 +143,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 */ @@ -156,14 +180,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); @@ -172,11 +195,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); } @@ -186,6 +210,7 @@ void part_block(ir_node *node) { ir_node *new_block; ir_node *old_block; ir_node *phi; + ir_node *mbh; /* Turn off optimizations so that blocks are not merged again. */ int rem_opt = get_opt_optimize(); @@ -193,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(); @@ -206,12 +240,49 @@ 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) { set_nodes_block(phi, new_block); - phi = get_irn_link(phi); + phi = get_Phi_next(phi); + } + + /* rewire partBlocks */ + if (mbh != old_block) { + ir_node *next, *block = get_irn_link(mbh); + + set_irn_link(mbh, NULL); + set_irn_link(old_block, NULL); + + /* 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); + 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, get_irn_link(old_block)); + set_irn_link(old_block, 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); + } + } } set_optimize(rem_opt);