X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgraph.c;h=226ae7b98de075afa9dc2b5b6169289ff2b5d3c6;hb=0fbcef83aa6060534172bb13e71cdadb04428806;hp=24fedff1ecb8a4a9f46fceda0629afb20cbc0d5b;hpb=99b96354f30cc378356372557e409a5eb63edaf1;p=libfirm diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index 24fedff1e..226ae7b98 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.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. * @@ -23,9 +23,7 @@ * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck * @version $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #ifdef HAVE_STRING_H # include @@ -38,6 +36,7 @@ #include "ircons_t.h" #include "irgraph_t.h" #include "irprog_t.h" +#include "irgraph_t.h" #include "irnode_t.h" #include "iropt_t.h" #include "irflag_t.h" @@ -47,6 +46,7 @@ #include "irhooks.h" #include "irtools.h" #include "irgwalk.h" +#include "irbackedge_t.h" #include "iredges_t.h" #include "type_t.h" #include "irmemory.h" @@ -113,11 +113,19 @@ void firm_init_irgraph(void) { * @return Memory for a new graph. */ static ir_graph *alloc_graph(void) { - size_t size = sizeof(ir_graph) + additional_graph_data_size; - char *ptr = xmalloc(size); + ir_graph *res; + size_t size = sizeof(ir_graph) + additional_graph_data_size; + char *ptr = xmalloc(size); memset(ptr, 0, size); - return (ir_graph *) (ptr + additional_graph_data_size); + res = (ir_graph *)(ptr + additional_graph_data_size); + res->kind = k_ir_graph; + + /* initialize the idx->node map. */ + res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE); + memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0])); + + return res; } /** @@ -135,6 +143,33 @@ Phi_in_stack *new_Phi_in_stack(); void free_Phi_in_stack(Phi_in_stack *s); #endif +/** + * Set the number of locals for a given graph. + * + * @param irg the graph + * @param n_loc number of locals + */ +void irg_set_nloc(ir_graph *res, int n_loc) { + assert(res->phase_state == phase_building); + + if (get_opt_precise_exc_context()) { + res->n_loc = n_loc + 1 + 1; /* number of local variables that are never + dereferenced in this graph plus one for + the store plus one for links to fragile + operations. n_loc is not the number of + parameters to the procedure! */ + } else { + res->n_loc = n_loc + 1; /* number of local variables that are never + dereferenced in this graph plus one for + the store. This is not the number of parameters + to the procedure! */ + } + if (res->loc_descriptions) { + xfree(res->loc_descriptions); + res->loc_descriptions = NULL; + } +} + /* Allocates a list of nodes: - The start block containing a start node and Proj nodes for it's four results (X, M, P, Tuple). @@ -150,14 +185,6 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { ir_node *end, *start, *start_block, *initial_mem, *projX; res = alloc_graph(); - res->kind = k_ir_graph; - - //edges_init_graph_kind(res, EDGE_KIND_NORMAL); - //edges_init_graph_kind(res, EDGE_KIND_BLOCK); - - /* initialize the idx->node map. */ - res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE); - memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0])); /* inform statistics here, as blocks will be already build on this graph */ hook_new_graph(res, ent); @@ -165,18 +192,12 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { current_ir_graph = res; /*-- initialized for each graph. --*/ - if (get_opt_precise_exc_context()) { - res->n_loc = n_loc + 1 + 1; /* number of local variables that are never - dereferenced in this graph plus one for - the store plus one for links to fragile - operations. n_loc is not the number of - parameters to the procedure! */ - } else { - res->n_loc = n_loc + 1; /* number of local variables that are never - dereferenced in this graph plus one for - the store. This is not the number of parameters - to the procedure! */ - } + res->kind = k_ir_graph; + res->obst = XMALLOC(struct obstack); + obstack_init(res->obst); + + res->phase_state = phase_building; + irg_set_nloc(res, n_loc); /* descriptions will be allocated on demand */ res->loc_descriptions = NULL; @@ -188,9 +209,6 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { res->Phi_in_stack = new_Phi_in_stack(); /* A stack needed for automatic Phi generation */ #endif - res->kind = k_ir_graph; - res->obst = xmalloc (sizeof(*res->obst)); - obstack_init(res->obst); res->extbb_obst = NULL; res->last_node_idx = 0; @@ -202,7 +220,6 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { res->inline_property = irg_inline_any; res->additional_properties = mtp_property_inherited; /* inherited from type */ - res->phase_state = phase_building; res->irg_pinned_state = op_pin_state_pinned; res->outs_state = outs_none; res->dom_state = dom_none; @@ -215,7 +232,7 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { res->extblk_state = ir_extblk_info_none; res->execfreq_state = exec_freq_none; res->fp_model = fp_model_precise; - res->adr_taken_state = ir_address_taken_not_computed; + res->entity_usage_state = ir_entity_usage_not_computed; res->mem_disambig_opt = aa_opt_inherited; /*-- Type information for the procedure of the graph --*/ @@ -244,8 +261,8 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { /* Proj results of start node */ projX = new_Proj(start, mode_X, pn_Start_X_initial_exec); + set_irg_initial_exec (res, projX); set_irg_frame (res, new_Proj(start, mode_P_data, pn_Start_P_frame_base)); - set_irg_globals (res, new_Proj(start, mode_P_data, pn_Start_P_globals)); set_irg_tls (res, new_Proj(start, mode_P_data, pn_Start_P_tls)); set_irg_args (res, new_Proj(start, mode_T, pn_Start_T_args)); set_irg_value_param_base(res, new_Proj(start, mode_P_data, pn_Start_P_value_arg_base)); @@ -277,9 +294,7 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { return res; } - -ir_graph * -new_ir_graph(ir_entity *ent, int n_loc) { +ir_graph *new_ir_graph(ir_entity *ent, int n_loc) { ir_graph *res = new_r_ir_graph(ent, n_loc); add_irp_irg(res); /* remember this graph global. */ return res; @@ -293,10 +308,6 @@ ir_graph *new_const_code_irg(void) { res = alloc_graph(); - /* initialize the idx->node map. */ - res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE); - memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0])); - /* inform statistics here, as blocks will be already build on this graph */ hook_new_graph(res, NULL); @@ -307,8 +318,7 @@ ir_graph *new_const_code_irg(void) { #if USE_EXPLICIT_PHI_IN_STACK res->Phi_in_stack = NULL; #endif - res->kind = k_ir_graph; - res->obst = xmalloc (sizeof(*res->obst)); + res->obst = XMALLOC(struct obstack); obstack_init (res->obst); res->extbb_obst = NULL; @@ -319,7 +329,7 @@ ir_graph *new_const_code_irg(void) { res->extblk_state = ir_extblk_info_none; res->fp_model = fp_model_precise; - res->value_table = new_identities (); /* value table for global value + res->value_table = new_identities(); /* value table for global value numbering for optimizing use in iropt.c */ res->ent = NULL; @@ -366,8 +376,150 @@ ir_graph *new_const_code_irg(void) { return res; } -/* Defined in iropt.c */ -void del_identities (pset *value_table); +/** + * Pre-Walker: Copies blocks and nodes from the original method graph + * to the copied graph. + * + * @param n A node from the original method graph. + * @param env The copied graph. + */ +static void copy_all_nodes(ir_node *n, 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); + + + /* 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(n, nn); + new_backedge_info(nn); + set_irn_link(n, nn); + + /* fix the irg for blocks */ + if (is_Block(nn)) + nn->attr.block.irg = irg; + + /* 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_frame_type(tp)) { + /* replace by the copied entity */ + ent = get_entity_link(ent); + + assert(is_entity(ent)); + assert(get_entity_owner(ent) == get_irg_frame_type(irg)); + set_Sel_entity(nn, ent); + } + } +} + +/** + * Post-walker: Set the predecessors of the copied nodes. + * 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) { + 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)); + } + } +} + +#define NN(irn) get_irn_link(irn) + +/* + * Create a new graph that is a copy of a given one. + */ +ir_graph *create_irg_copy(ir_graph *irg) { + ir_graph *res; + + res = alloc_graph(); + + res->n_loc = 0; + res->visited = 0; /* visited flag, for the ir walker */ + res->block_visited = 0; /* visited flag, for the 'block'-walker */ +#if USE_EXPLICIT_PHI_IN_STACK + res->Phi_in_stack = NULL; +#endif + res->obst = XMALLOC(struct obstack); + obstack_init(res->obst); + res->extbb_obst = NULL; + + res->last_node_idx = 0; + + res->phase_state = irg->phase_state; + res->irg_pinned_state = irg->irg_pinned_state; + res->extblk_state = ir_extblk_info_none; + res->fp_model = irg->fp_model; + + res->value_table = new_identities(); + + /* clone the frame type here for safety */ + res->frame_type = clone_frame_type(irg->frame_type); + + res->phase_state = irg->phase_state; + + 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); + + /* copy the Anchor node */ + res->anchor = NN(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))); + + /* -- 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))); + + /* Proj results of start node */ + set_irg_initial_mem(res, NN(get_irg_initial_mem(irg))); + + /* Copy the node count estimation. Would be strange if this + is different from the original one. */ + res->estimated_node_count = irg->estimated_node_count; + + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); + + return res; +} +#undef NN + /* Frees the passed irgraph. Deallocates all nodes in this graph and the ir_graph structure. @@ -376,13 +528,18 @@ void del_identities (pset *value_table); inefficient search, call remove_irp_irg by hand). Does not free types, entities or modes that are used only by this graph, nor the entity standing for this graph. */ -void free_ir_graph (ir_graph *irg) { +void free_ir_graph(ir_graph *irg) { assert(is_ir_graph(irg)); + edges_deactivate(irg); + hook_free_graph(irg); - if (irg->outs_state != outs_none) free_irg_outs(irg); - if (irg->frame_type) free_type(irg->frame_type); - if (irg->value_table) del_identities(irg->value_table); + if (irg->outs_state != outs_none) + free_irg_outs(irg); + if (irg->frame_type) + free_type(irg->frame_type); + if (irg->value_table) + del_identities(irg->value_table); if (irg->ent) { ir_peculiarity pec = get_entity_peculiarity (irg->ent); set_entity_peculiarity (irg->ent, peculiarity_description); @@ -417,6 +574,10 @@ int long get_irg_graph_nr(const ir_graph *irg) { return irg->graph_nr; } +#else +long get_irg_graph_nr(const ir_graph *irg) { + return PTR_TO_INT(irg); +} #endif int get_irg_idx(const ir_graph *irg) { @@ -480,28 +641,28 @@ ir_node * void (set_irg_end_except)(ir_graph *irg, ir_node *node) { - assert(get_irn_op(node) == op_EndExcept || get_irn_op(node) == op_End); + assert(get_irn_op(node) == op_EndExcept || is_End(node)); _set_irg_end_except(irg, node); } ir_node * -(get_irg_frame)(const ir_graph *irg) { - return _get_irg_frame(irg); +(get_irg_initial_exec)(const ir_graph *irg) { + return _get_irg_initial_exec(irg); } void -(set_irg_frame)(ir_graph *irg, ir_node *node) { - _set_irg_frame(irg, node); +(set_irg_initial_exec)(ir_graph *irg, ir_node *node) { + _set_irg_initial_exec(irg, node); } ir_node * -(get_irg_globals)(const ir_graph *irg) { - return _get_irg_globals(irg); +(get_irg_frame)(const ir_graph *irg) { + return _get_irg_frame(irg); } void -(set_irg_globals)(ir_graph *irg, ir_node *node) { - _set_irg_globals(irg, node); +(set_irg_frame)(ir_graph *irg, ir_node *node) { + _set_irg_frame(irg, node); } ir_node * @@ -762,36 +923,45 @@ void * return _get_irg_link(irg); } -/** maximum visited flag content of all ir_graph visited fields. */ -static unsigned long max_irg_visited = 0; - -unsigned long +ir_visited_t (get_irg_visited)(const ir_graph *irg) { return _get_irg_visited(irg); } +#ifdef INTERPROCEDURAL_VIEW +/** maximum visited flag content of all ir_graph visited fields. */ +static ir_visited_t max_irg_visited = 0; +#endif /* INTERPROCEDURAL_VIEW */ + void -set_irg_visited(ir_graph *irg, unsigned long visited) { +set_irg_visited(ir_graph *irg, ir_visited_t visited) { irg->visited = visited; +#ifdef INTERPROCEDURAL_VIEW if (irg->visited > max_irg_visited) { max_irg_visited = irg->visited; } +#endif /* INTERPROCEDURAL_VIEW */ } void inc_irg_visited(ir_graph *irg) { +#ifdef INTERPROCEDURAL_VIEW if (++irg->visited > max_irg_visited) { max_irg_visited = irg->visited; } +#else + ++irg->visited; +#endif /* INTERPROCEDURAL_VIEW */ } -unsigned long +#ifdef INTERPROCEDURAL_VIEW +ir_visited_t get_max_irg_visited(void) { - /* +#ifndef NDEBUG int i; for(i = 0; i < get_irp_n_irgs(); i++) - assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); - */ + assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); +#endif return max_irg_visited; } @@ -799,23 +969,24 @@ void set_max_irg_visited(int val) { max_irg_visited = val; } -unsigned long +ir_visited_t inc_max_irg_visited(void) { - /* +#ifndef NDEBUG int i; for(i = 0; i < get_irp_n_irgs(); i++) - assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); - */ + assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); +#endif return ++max_irg_visited; } +#endif /* INTERPROCEDURAL_VIEW */ -unsigned long +ir_visited_t (get_irg_block_visited)(const ir_graph *irg) { return _get_irg_block_visited(irg); } void -(set_irg_block_visited)(ir_graph *irg, unsigned long visited) { +(set_irg_block_visited)(ir_graph *irg, ir_visited_t visited) { _set_irg_block_visited(irg, visited); } @@ -862,7 +1033,7 @@ void set_irg_loc_description(ir_graph *irg, int n, void *description) { assert(0 <= n && n < irg->n_loc); if (! irg->loc_descriptions) - irg->loc_descriptions = xcalloc(sizeof(*irg->loc_descriptions), irg->n_loc); + irg->loc_descriptions = XMALLOCNZ(void*, irg->n_loc); irg->loc_descriptions[n] = description; } @@ -874,50 +1045,23 @@ void *get_irg_loc_description(ir_graph *irg, int n) { } #ifndef NDEBUG -void set_using_block_visited(ir_graph *irg) { - assert(irg->using_block_visited == 0); - irg->using_block_visited = 1; -} - -void clear_using_block_visited(ir_graph *irg) { - assert(irg->using_block_visited == 1); - irg->using_block_visited = 0; -} - -int using_block_visited(const ir_graph *irg) { - return irg->using_block_visited; -} - - -void set_using_visited(ir_graph *irg) { - assert(irg->using_visited == 0); - irg->using_visited = 1; +void ir_reserve_resources(ir_graph *irg, ir_resources_t resources) +{ + assert((irg->reserved_resources & resources) == 0); + irg->reserved_resources |= resources; } -void clear_using_visited(ir_graph *irg) { - assert(irg->using_visited == 1); - irg->using_visited = 0; +void ir_free_resources(ir_graph *irg, ir_resources_t resources) +{ + assert((irg->reserved_resources & resources) == resources); + irg->reserved_resources &= ~resources; } -int using_visited(const ir_graph *irg) { - return irg->using_visited; +ir_resources_t ir_resources_reserved(const ir_graph *irg) +{ + return irg->reserved_resources; } - - -void set_using_irn_link(ir_graph *irg) { - assert(irg->using_irn_link == 0); - irg->using_irn_link = 1; -} - -void clear_using_irn_link(ir_graph *irg) { - assert(irg->using_irn_link == 1); - irg->using_irn_link = 0; -} - -int using_irn_link(const ir_graph *irg) { - return irg->using_irn_link; -} -#endif +#endif /* NDEBUG */ /* Returns a estimated node count of the irg. */ unsigned (get_irg_estimated_node_cnt)(const ir_graph *irg) {