X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgraph.c;h=df317c70805554c5fa33cf24b8efa9ba037ae51a;hb=a947c2090825c6a49b3fbfaafc00c8c34d649a40;hp=465b30d078cc939982cbac87e0d0a963be39bd7a;hpb=2f500449b37a392471468c2924020098f95b2662;p=libfirm diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index 465b30d07..df317c708 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -23,13 +23,9 @@ * @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 -#endif +#include #ifdef HAVE_STDDEF_H # include #endif @@ -135,15 +131,40 @@ static ir_graph *alloc_graph(void) { */ static void free_graph(ir_graph *irg) { char *ptr = (char *)irg; + int i; + + for (i = 0; i < EDGE_KIND_LAST; ++i) + edges_deactivate_kind(irg, i); + DEL_ARR_F(irg->idx_irn_map); free(ptr - additional_graph_data_size); } -#if USE_EXPLICIT_PHI_IN_STACK -/* really defined in ircons.c */ -typedef struct Phi_in_stack Phi_in_stack; -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 @@ -167,18 +188,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; @@ -186,13 +201,6 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { 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 = 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; @@ -204,7 +212,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; @@ -217,7 +224,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 --*/ @@ -225,19 +232,21 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { set_entity_irg(ent, res); /*-- a class type so that it can contain "inner" methods as in Pascal. --*/ - res->frame_type = new_type_frame(mangle(get_entity_ident(ent), frame_type_suffix)); + res->frame_type = new_type_frame(id_mangle(get_entity_ident(ent), frame_type_suffix)); /* the Anchor node must be created first */ res->anchor = new_Anchor(res); /*-- Nodes needed in every graph --*/ set_irg_end_block (res, new_immBlock()); + 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); set_irg_start_block(res, start_block); set_irg_bad (res, new_ir_node(NULL, res, start_block, op_Bad, mode_T, 0, NULL)); set_irg_no_mem (res, new_ir_node(NULL, res, start_block, op_NoMem, mode_M, 0, NULL)); @@ -246,11 +255,10 @@ 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)); initial_mem = new_Proj(start, mode_M, pn_Start_M); set_irg_initial_mem(res, initial_mem); @@ -271,6 +279,7 @@ ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) { /*-- Make a block to start with --*/ first_block = new_immBlock(); + set_cur_block(first_block); add_immBlock_pred(first_block, projX); res->method_execution_frequency = -1.0; @@ -287,24 +296,27 @@ ir_graph *new_ir_graph(ir_entity *ent, int n_loc) { /* Make a rudimentary IR graph for the constant code. Must look like a correct irg, spare everything else. */ -ir_graph *new_const_code_irg(void) { - ir_graph *res; - ir_node *end, *start_block, *start, *projX; - - res = alloc_graph(); +ir_graph *new_const_code_irg(void) +{ + ir_graph *res = alloc_graph(); + ir_node *bad; + ir_node *body_block; + ir_node *end; + ir_node *end_block; + ir_node *no_mem; + ir_node *projX; + ir_node *start_block; + ir_node *start; /* inform statistics here, as blocks will be already build on this graph */ hook_new_graph(res, NULL); - current_ir_graph = res; - res->n_loc = 1; /* Only the memory. */ - res->visited = 0; /* visited flag, for the ir walker */ + current_ir_graph = res; + res->n_loc = 1; /* Only the memory. */ + 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(sizeof(*res->obst)); - obstack_init (res->obst); + res->obst = XMALLOC(struct obstack); + obstack_init(res->obst); res->extbb_obst = NULL; res->last_node_idx = 0; @@ -314,47 +326,53 @@ 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 - numbering for optimizing use in - iropt.c */ - res->ent = NULL; + /* value table for global value numbering for optimizing use in iropt.c */ + res->value_table = new_identities(); + res->ent = NULL; res->frame_type = NULL; /* the Anchor node must be created first */ res->anchor = new_Anchor(res); /* -- The end block -- */ - set_irg_end_block (res, new_immBlock()); + end_block = new_immBlock(); + set_irg_end_block(res, end_block); + 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(get_cur_block()); /* mature the end block */ + mature_immBlock(end_block); /* -- The start block -- */ start_block = new_immBlock(); + set_cur_block(start_block); set_irg_start_block(res, start_block); - set_irg_bad (res, new_ir_node (NULL, res, start_block, op_Bad, mode_T, 0, NULL)); - set_irg_no_mem (res, new_ir_node (NULL, res, start_block, op_NoMem, mode_M, 0, NULL)); - start = new_Start(); - set_irg_start (res, start); + bad = new_ir_node(NULL, res, start_block, op_Bad, mode_T, 0, NULL); + set_irg_bad(res, bad); + no_mem = new_ir_node(NULL, res, start_block, op_NoMem, mode_M, 0, NULL); + set_irg_no_mem(res, no_mem); + start = new_Start(); + set_irg_start(res, start); /* Proj results of start node */ set_irg_initial_mem(res, new_Proj(start, mode_M, pn_Start_M)); projX = new_Proj(start, mode_X, pn_Start_X_initial_exec); add_immBlock_pred(start_block, projX); - mature_immBlock (start_block); /* mature the start block */ + mature_immBlock(start_block); - add_immBlock_pred(new_immBlock(), projX); - mature_immBlock (get_cur_block()); /* mature the 'body' block for expressions */ + body_block = new_immBlock(); + add_immBlock_pred(body_block, projX); + mature_immBlock(body_block); /* mature the 'body' block for expressions */ + set_cur_block(body_block); /* Set the visited flag high enough that the blocks will never be visited. */ - set_irn_visited(get_cur_block(), -1); - set_Block_block_visited(get_cur_block(), -1); + set_irn_visited(body_block, -1); + set_Block_block_visited(body_block, -1); set_Block_block_visited(start_block, -1); set_irn_visited(start_block, -1); - set_irn_visited(get_irg_bad(res), -1); - set_irn_visited(get_irg_no_mem(res), -1); + set_irn_visited(bad, -1); + set_irn_visited(no_mem, -1); res->phase_state = phase_high; @@ -369,7 +387,7 @@ ir_graph *new_const_code_irg(void) { * @param env The copied graph. */ static void copy_all_nodes(ir_node *n, void *env) { - ir_graph *irg = current_ir_graph; + ir_graph *irg = env; ir_op *op = get_irn_op(n); ir_node *nn; @@ -417,7 +435,7 @@ static void copy_all_nodes(ir_node *n, void *env) { static void set_all_preds(ir_node *irn, void *env) { int i; ir_node *nn, *pred; - ir_graph *clone_irg = env; + (void) env; nn = get_irn_link(irn); @@ -451,10 +469,7 @@ ir_graph *create_irg_copy(ir_graph *irg) { 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(sizeof(*res->obst)); + res->obst = XMALLOC(struct obstack); obstack_init(res->obst); res->extbb_obst = NULL; @@ -468,11 +483,12 @@ ir_graph *create_irg_copy(ir_graph *irg) { res->value_table = new_identities(); /* clone the frame type here for safety */ + irp_reserve_resources(irp, IR_RESOURCE_ENTITY_LINK); res->frame_type = clone_frame_type(irg->frame_type); res->phase_state = irg->phase_state; - set_using_irn_link(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); @@ -499,7 +515,8 @@ ir_graph *create_irg_copy(ir_graph *irg) { is different from the original one. */ res->estimated_node_count = irg->estimated_node_count; - clear_using_irn_link(irg); + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); + irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK); return res; } @@ -516,6 +533,8 @@ ir_graph *create_irg_copy(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); @@ -533,9 +552,6 @@ void free_ir_graph(ir_graph *irg) { free_End(get_irg_end(irg)); obstack_free(irg->obst,NULL); free(irg->obst); -#if USE_EXPLICIT_PHI_IN_STACK - free_Phi_in_stack(irg->Phi_in_stack); -#endif if (irg->loc_descriptions) free(irg->loc_descriptions); irg->kind = k_BAD; @@ -567,6 +583,10 @@ int get_irg_idx(const ir_graph *irg) { return irg->index; } +ir_node *(get_idx_irn)(ir_graph *irg, unsigned idx) { + return _get_idx_irn(irg, idx); +} + ir_node * (get_irg_start_block)(const ir_graph *irg) { return _get_irg_start_block(irg); @@ -624,28 +644,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 * @@ -678,16 +698,6 @@ void _set_irg_args(irg, node); } -ir_node * -(get_irg_value_param_base)(const ir_graph *irg) { - return _get_irg_value_param_base(irg); -} - -void -(set_irg_value_param_base)(ir_graph *irg, ir_node *node) { - _set_irg_value_param_base(irg, node); -} - ir_node * (get_irg_bad)(const ir_graph *irg) { return _get_irg_bad(irg); @@ -738,6 +748,13 @@ void _set_irg_frame_type(irg, ftp); } +/* Returns the value parameter type of an IR graph. */ +ir_type *get_irg_value_param_type(ir_graph *irg) { + ir_entity *ent = get_irg_entity(irg); + ir_type *mtp = get_entity_type(ent); + return get_method_value_param_type(mtp); +} + int get_irg_n_locs(ir_graph *irg) { if (get_opt_precise_exc_context()) @@ -906,18 +923,18 @@ void * return _get_irg_link(irg); } -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 unsigned long max_irg_visited = 0; +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) { @@ -938,13 +955,13 @@ inc_irg_visited(ir_graph *irg) { } #ifdef INTERPROCEDURAL_VIEW -unsigned long +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; } @@ -952,24 +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); } @@ -1016,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; } @@ -1028,50 +1045,21 @@ 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_irn_visited(ir_graph *irg) { - assert(irg->using_irn_visited == 0); - irg->using_irn_visited = 1; -} - -void clear_using_irn_visited(ir_graph *irg) { - assert(irg->using_irn_visited == 1); - irg->using_irn_visited = 0; -} - -int using_irn_visited(const ir_graph *irg) { - return irg->using_irn_visited; +void ir_reserve_resources(ir_graph *irg, ir_resources_t resources) { + assert((resources & ~IR_RESOURCE_LOCAL_MASK) == 0); + assert((irg->reserved_resources & resources) == 0); + irg->reserved_resources |= resources; } - -void set_using_irn_link(ir_graph *irg) { - assert(irg->using_irn_link == 0); - irg->using_irn_link = 1; +void ir_free_resources(ir_graph *irg, ir_resources_t resources) { + assert((irg->reserved_resources & resources) == resources); + irg->reserved_resources &= ~resources; } -void clear_using_irn_link(ir_graph *irg) { - assert(irg->using_irn_link == 1); - irg->using_irn_link = 0; +ir_resources_t ir_resources_reserved(const ir_graph *irg) { + return irg->reserved_resources; } - -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) {