X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgraph.c;h=0680c7cb08e7bdf303703a05faf3d55f5fb7d3af;hb=70a04b0cc2c9efc3323b9ef1a6158c0ae1c88235;hp=bc3adf3c5e574af9c413e46f7f1c2278663745f8;hpb=2807bb5b1ed34c23dc30d228ab0686c6fc9d6ae3;p=libfirm diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index bc3adf3c5..0680c7cb0 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -26,9 +26,7 @@ #include "config.h" #include -#ifdef HAVE_STDDEF_H -# include -#endif +#include #include "xmalloc.h" #include "ircons_t.h" @@ -48,6 +46,7 @@ #include "iredges_t.h" #include "type_t.h" #include "irmemory.h" +#include "irphase.h" #define INITIAL_IDX_IRN_MAP_SIZE 1024 @@ -74,30 +73,6 @@ void set_current_ir_graph(ir_graph *graph) current_ir_graph = graph; } -#ifdef INTERPROCEDURAL_VIEW -int firm_interprocedural_view = 0; - -int (get_interprocedural_view)(void) -{ - return _get_interprocedural_view(); -} - -void (set_interprocedural_view)(int state) -{ - firm_interprocedural_view = state; - - /* set function vectors for faster access */ - if (state) { - _get_irn_arity = _get_irn_inter_arity; - _get_irn_n = _get_irn_inter_n; - } - else { - _get_irn_arity = _get_irn_intra_arity; - _get_irn_n = _get_irn_intra_n; - } -} -#endif - /** contains the suffix for frame type names */ static ident *frame_type_suffix = NULL; @@ -119,8 +94,7 @@ static ir_graph *alloc_graph(void) { ir_graph *res; size_t size = sizeof(ir_graph) + additional_graph_data_size; - char *ptr = xmalloc(size); - memset(ptr, 0, size); + char *ptr = XMALLOCNZ(char, size); res = (ir_graph *)(ptr + additional_graph_data_size); res->kind = k_ir_graph; @@ -251,8 +225,6 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) set_cur_block(get_irg_end_block(res)); end = new_End(); set_irg_end (res, end); - set_irg_end_reg (res, end); - set_irg_end_except(res, end); start_block = new_immBlock(); set_cur_block(start_block); @@ -346,8 +318,6 @@ ir_graph *new_const_code_irg(void) set_cur_block(end_block); end = new_End(); set_irg_end (res, end); - set_irg_end_reg (res, end); - set_irg_end_except(res, end); mature_immBlock(end_block); /* -- The start block -- */ @@ -392,36 +362,17 @@ ir_graph *new_const_code_irg(void) * @param n A node from the original method graph. * @param env The copied graph. */ -static void copy_all_nodes(ir_node *n, void *env) +static void copy_all_nodes(ir_node *node, void *env) { - ir_graph *irg = env; - ir_op *op = get_irn_op(n); - ir_node *nn; - - nn = new_ir_node(get_irn_dbg_info(n), - irg, - NULL, /* no block yet, will be set later */ - op, - get_irn_mode(n), - get_irn_arity(n), - get_irn_in(n) + 1); + ir_graph *irg = env; + ir_node *new_node = irn_copy_into_irg(node, irg); - - /* Copy the attributes. These might point to additional data. If this - was allocated on the old obstack the pointers now are dangling. This - frees e.g. the memory of the graph_arr allocated in new_immBlock. */ - copy_node_attr(irg, n, nn); - set_irn_link(n, nn); - - /* fix the irg for Blocks: as Bad nodes are NOT copied, no - need t fix them */ - if (is_Block(nn)) - nn->attr.block.irg.irg = irg; + set_irn_link(node, new_node); /* fix access to entities on the stack frame */ - if (is_Sel(nn)) { - ir_entity *ent = get_Sel_entity(nn); - ir_type *tp = get_entity_owner(ent); + if (is_Sel(new_node)) { + ir_entity *ent = get_Sel_entity(new_node); + ir_type *tp = get_entity_owner(ent); if (is_frame_type(tp)) { /* replace by the copied entity */ @@ -429,7 +380,7 @@ static void copy_all_nodes(ir_node *n, void *env) assert(is_entity(ent)); assert(get_entity_owner(ent) == get_irg_frame_type(irg)); - set_Sel_entity(nn, ent); + set_Sel_entity(new_node, ent); } } } @@ -439,32 +390,16 @@ static void copy_all_nodes(ir_node *n, void *env) * The copied nodes are set as link of their original nodes. The links of * "irn" predecessors are the predecessors of copied node. */ -static void set_all_preds(ir_node *irn, void *env) +static void rewire(ir_node *irn, void *env) { - int i; - ir_node *nn, *pred; (void) env; - - nn = get_irn_link(irn); - - if (is_Block(irn)) { - ir_node *mbh = get_Block_MacroBlock(irn); - set_Block_MacroBlock(nn, get_irn_link(mbh)); - for (i = get_Block_n_cfgpreds(irn) - 1; i >= 0; i--) { - pred = get_Block_cfgpred(irn, i); - set_Block_cfgpred(nn, i, get_irn_link(pred)); - } - } else { - /* First we set the block our copy if it is not a block.*/ - set_nodes_block(nn, get_irn_link(get_nodes_block(irn))); - for (i = get_irn_arity(irn) - 1; i >= 0; i--) { - pred = get_irn_n(irn, i); - set_irn_n(nn, i, get_irn_link(pred)); - } - } + irn_rewire_inputs(irn); } -#define NN(irn) get_irn_link(irn) +static ir_node *get_new_node(const ir_node *old_node) +{ + return (ir_node*) get_irn_link(old_node); +} /* * Create a new graph that is a copy of a given one. @@ -500,25 +435,23 @@ ir_graph *create_irg_copy(ir_graph *irg) ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); /* copy all nodes from the graph irg to the new graph res */ - irg_walk_anchors(irg, copy_all_nodes, set_all_preds, res); + irg_walk_anchors(irg, copy_all_nodes, rewire, res); /* copy the Anchor node */ - res->anchor = NN(irg->anchor); + res->anchor = get_new_node(irg->anchor); /* -- The end block -- */ - set_irg_end_block (res, NN(get_irg_end_block(irg))); - set_irg_end (res, NN(get_irg_end(irg))); - set_irg_end_reg (res, NN(get_irg_end_reg(irg))); - set_irg_end_except(res, NN(get_irg_end_except(irg))); + set_irg_end_block (res, get_new_node(get_irg_end_block(irg))); + set_irg_end (res, get_new_node(get_irg_end(irg))); /* -- The start block -- */ - set_irg_start_block(res, NN(get_irg_start_block(irg))); - set_irg_bad (res, NN(get_irg_bad(irg))); - set_irg_no_mem (res, NN(get_irg_no_mem(irg))); - set_irg_start (res, NN(get_irg_start(irg))); + set_irg_start_block(res, get_new_node(get_irg_start_block(irg))); + set_irg_bad (res, get_new_node(get_irg_bad(irg))); + set_irg_no_mem (res, get_new_node(get_irg_no_mem(irg))); + set_irg_start (res, get_new_node(get_irg_start(irg))); /* Proj results of start node */ - set_irg_initial_mem(res, NN(get_irg_initial_mem(irg))); + set_irg_initial_mem(res, get_new_node(get_irg_initial_mem(irg))); /* Copy the node count estimation. Would be strange if this is different from the original one. */ @@ -529,8 +462,6 @@ ir_graph *create_irg_copy(ir_graph *irg) return res; } -#undef NN - /* Frees the passed irgraph. Deallocates all nodes in this graph and the ir_graph structure. @@ -638,27 +569,6 @@ void (set_irg_end)(ir_graph *irg, ir_node *node) _set_irg_end(irg, node); } -ir_node *(get_irg_end_reg)(const ir_graph *irg) -{ - return _get_irg_end_reg(irg); -} - -void (set_irg_end_reg)(ir_graph *irg, ir_node *node) -{ - _set_irg_end_reg(irg, node); -} - -ir_node *(get_irg_end_except)(const ir_graph *irg) -{ - return _get_irg_end_except(irg); -} - -void (set_irg_end_except)(ir_graph *irg, ir_node *node) -{ - assert(get_irn_op(node) == op_EndExcept || is_End(node)); - _set_irg_end_except(irg, node); -} - ir_node *(get_irg_initial_exec)(const ir_graph *irg) { return _get_irg_initial_exec(irg); @@ -775,16 +685,6 @@ int get_irg_n_locs(ir_graph *irg) return irg->n_loc - 1; } -void set_irg_n_loc(ir_graph *irg, int n_loc) -{ - if (get_opt_precise_exc_context()) - irg->n_loc = n_loc + 1 + 1; - else - irg->n_loc = n_loc + 1; -} - - - /* Returns the obstack associated with the graph. */ struct obstack * (get_irg_obstack)(const ir_graph *irg) { @@ -1051,6 +951,26 @@ void *get_irg_loc_description(ir_graph *irg, int n) return irg->loc_descriptions ? irg->loc_descriptions[n] : NULL; } +void irg_register_phase(ir_graph *irg, ir_phase_id id, ir_phase *phase) +{ + assert(id <= PHASE_LAST); + assert(irg->phases[id] == NULL); + irg->phases[id] = phase; +} + +void irg_invalidate_phases(ir_graph *irg) +{ + int p; + for (p = 0; p <= PHASE_LAST; ++p) { + ir_phase *phase = irg->phases[p]; + if (phase == NULL) + continue; + + phase_free(phase); + irg->phases[p] = NULL; + } +} + #ifndef NDEBUG void ir_reserve_resources(ir_graph *irg, ir_resources_t resources) {