X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgraph.c;h=225862d90319e93d21f8110fe738cd9acc16dba7;hb=8399216d8aebc713bbda04b6e3e250a1d52b20bf;hp=d68a86c8974c6e6aa8ecca14d48f7202369127d5;hpb=65faa2bb5df86c0b6e02d9d779e06956ccd1ff9f;p=libfirm diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index d68a86c89..225862d90 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -11,11 +11,16 @@ */ #ifdef HAVE_CONFIG_H -# include +# include "config.h" #endif +#ifdef HAVE_STRING_H # include +#endif + +#include +# include "xmalloc.h" # include "ircons.h" # include "irgraph_t.h" # include "irprog_t.h" @@ -27,6 +32,19 @@ # include "mangle.h" # include "irouts.h" # include "firmstat.h" +# include "irgwalk.h" + +/** + * Indicates, whether additional data can be registered to graphs. + * If set to 1, this is not possible anymore. + */ +static int forbid_new_data = 0; + +/** + * The amount of additional space for custom data to be allocated upon + * creating a new graph. + */ +static size_t additional_graph_data_size = 0; ir_graph *current_ir_graph; INLINE ir_graph *get_current_ir_graph(void) { @@ -59,7 +77,24 @@ void (set_interprocedural_view)(int state) { static ident* frame_type_suffix = NULL; void init_irgraph(void) { - frame_type_suffix = new_id_from_chars(FRAME_TP_SUFFIX, strlen(FRAME_TP_SUFFIX)); + frame_type_suffix = new_id_from_str(FRAME_TP_SUFFIX); + forbid_new_data = 1; +} + +/** + * Allocate a new ir graph. + * This function respects the registered graph data. The only reason for + * this function is, that there are two locations, where graphs are + * allocated (new_r_ir_graph, new_const_code_irg). + * @return Memory for a new graph. + */ +ir_graph *alloc_graph(void) +{ + 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); } #if USE_EXPLICIT_PHI_IN_STACK @@ -79,21 +114,19 @@ void free_Phi_in_stack(Phi_in_stack *s); and optimization. */ ir_graph * -new_ir_graph (entity *ent, int n_loc) +new_r_ir_graph (entity *ent, int n_loc) { ir_graph *res; ir_node *first_block; ir_node *projX; - res = (ir_graph *) malloc (sizeof (ir_graph)); - memset(res, 0, sizeof (ir_graph)); + res = alloc_graph(); res->kind = k_ir_graph; /* inform statistics here, as blocks will be already build on this graph */ stat_new_graph(res, ent); current_ir_graph = res; - add_irp_irg(res); /* remember this graph global. */ /*-- initialized for each graph. --*/ if (get_opt_precise_exc_context()) { @@ -118,7 +151,7 @@ new_ir_graph (entity *ent, int n_loc) generation */ #endif res->kind = k_ir_graph; - res->obst = (struct obstack *) xmalloc (sizeof (struct obstack)); + res->obst = xmalloc (sizeof(*res->obst)); obstack_init (res->obst); res->value_table = new_identities (); /* value table for global value numbering for optimizing use in @@ -151,15 +184,18 @@ new_ir_graph (entity *ent, int n_loc) res->start_block = new_immBlock(); res->start = new_Start(); res->bad = new_ir_node(NULL, res, res->start_block, op_Bad, mode_T, 0, NULL); + res->no_mem = new_ir_node(NULL, res, res->start_block, op_NoMem, mode_M, 0, NULL); /* Proj results of start node */ projX = new_Proj (res->start, mode_X, pn_Start_X_initial_exec); - res->frame = new_Proj (res->start, mode_P_mach, pn_Start_P_frame_base); res->globals = new_Proj (res->start, mode_P_mach, pn_Start_P_globals); + res->frame = new_Proj (res->start, mode_P_mach, pn_Start_P_frame_base); + res->globals = new_Proj (res->start, mode_P_mach, pn_Start_P_globals); res->initial_mem = new_Proj (res->start, mode_M, pn_Start_M); res->args = new_Proj (res->start, mode_T, pn_Start_T_args); #ifdef DEBUG_libfirm res->graph_nr = get_irp_new_node_nr(); #endif + res->proj_args = NULL; set_store(res->initial_mem); @@ -179,14 +215,21 @@ new_ir_graph (entity *ent, int n_loc) } +ir_graph * +new_ir_graph (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; +} + /* 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 *projX; - res = (ir_graph *) malloc (sizeof(*res)); - memset(res, 0, sizeof(*res)); + res = alloc_graph(); /* inform statistics here, as blocks will be already build on this graph */ stat_new_graph(res, NULL); @@ -199,7 +242,7 @@ ir_graph *new_const_code_irg(void) { res->Phi_in_stack = NULL; #endif res->kind = k_ir_graph; - res->obst = (struct obstack *) xmalloc (sizeof (struct obstack)); + res->obst = xmalloc (sizeof(*res->obst)); obstack_init (res->obst); res->phase_state = phase_building; res->op_pin_state_pinned = op_pin_state_pinned; @@ -208,29 +251,35 @@ ir_graph *new_const_code_irg(void) { iropt.c */ res->ent = NULL; res->frame_type = NULL; - res->start_block = new_immBlock (); + + /* -- The end block -- */ res->end_block = new_immBlock (); res->end = new_End (); res->end_reg = res->end; res->end_except = res->end; mature_immBlock(get_cur_block()); /* mature the end block */ - res->bad = new_ir_node (NULL, res, res->start_block, op_Bad, mode_T, 0, NULL); - res->start = new_Start (); - res->initial_mem = new_Proj (res->start, mode_M, pn_Start_M); + /* -- The start block -- */ + res->start_block = new_immBlock (); + res->bad = new_ir_node (NULL, res, res->start_block, op_Bad, mode_T, 0, NULL); + res->no_mem = new_ir_node (NULL, res, res->start_block, op_NoMem, mode_M, 0, NULL); + res->start = new_Start (); /* Proj results of start node */ - projX = new_Proj (res->start, mode_X, pn_Start_X_initial_exec); + res->initial_mem = new_Proj (res->start, mode_M, pn_Start_M); + projX = new_Proj (res->start, mode_X, pn_Start_X_initial_exec); add_immBlock_pred (res->start_block, projX); mature_immBlock (res->start_block); /* mature the start block */ add_immBlock_pred (new_immBlock (), projX); mature_immBlock (get_cur_block()); /* mature the 'body' block for expressions */ - /* Set the visited flag high enough that the block will never be visited. */ + + /* 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_Block_block_visited(res->start_block, -1); set_irn_visited(res->start_block, -1); set_irn_visited(res->bad, -1); + set_irn_visited(res->no_mem, -1); res->phase_state = phase_high; return res; @@ -401,6 +450,16 @@ void __set_irg_args(irg, node); } +ir_node ** +(get_irg_proj_args) (const ir_graph *irg) { + return __get_irg_proj_args (irg); +} + +void +(set_irg_proj_args) (ir_graph *irg, ir_node **nodes) { + __set_irg_proj_args (irg, nodes); +} + ir_node * (get_irg_bad)(const ir_graph *irg) { return __get_irg_bad(irg); @@ -411,19 +470,15 @@ void __set_irg_bad(irg, node); } -/* GL removed: we need unknown with mode for analyses. ir_node * -get_irg_unknown (ir_graph *irg) -{ - return irg->unknown; +(get_irg_no_mem)(const ir_graph *irg) { + return __get_irg_no_mem(irg); } void -set_irg_unknown (ir_graph *irg, ir_node *node) -{ - irg->unknown = node; +(set_irg_no_mem)(ir_graph *irg, ir_node *node) { + __set_irg_no_mem(irg, node); } -*/ ir_node * (get_irg_current_block)(const ir_graph *irg) { @@ -611,8 +666,8 @@ void * return __get_irg_link(irg); } -/* maximum visited flag content of all ir_graph visited fields. */ -static int max_irg_visited = 0; +/** maximum visited flag content of all ir_graph visited fields. */ +static unsigned long max_irg_visited = 0; unsigned long (get_irg_visited)(const ir_graph *irg) { @@ -678,19 +733,37 @@ void __inc_irg_block_visited(irg); } -/* is irg a pseudo graph for analysis? */ -int is_pseudo_ir_graph(ir_graph *irg) -{ - int res = false; - entity *ent; - assert(irg && "nothing here"); - assert(is_ir_graph(irg) && "no ir_graph given"); +/** + * walker Start->End: places Proj nodes into the same block + * as it's predecessors + * + * @param n the node + * @param env ignored + */ +static void normalize_proj_walker(ir_node *n, void *env) +{ + if (is_Proj(n)) { + ir_node *pred = get_Proj_pred(n); + ir_node *block = get_nodes_block(pred); - ent = get_irg_entity(irg); - if(visibility_external_allocated == get_entity_visibility(ent) - && peculiarity_existent == get_entity_peculiarity(ent)) { - res = true; + set_nodes_block(n, block); } - return(res); +} + +/* put the proj's into the same block as its predecessors */ +void normalize_proj_nodes(ir_graph *irg) +{ + irg_walk_graph(irg, NULL, normalize_proj_walker, NULL); + set_irg_outs_inconsistent(irg); +} + +size_t register_additional_graph_data(size_t size) +{ + assert(!forbid_new_data && "Too late to register additional node data"); + + if(forbid_new_data) + return 0; + + return additional_graph_data_size += size; }