X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgraph.c;h=225862d90319e93d21f8110fe738cd9acc16dba7;hb=8399216d8aebc713bbda04b6e3e250a1d52b20bf;hp=3f00b28a188397f8520e546e5e8a6b4d8e815fcf;hpb=56c4f99a95cfeda4dbea6a1d702be5cff87e7fd3;p=libfirm diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index 3f00b28a1..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 @@ -85,8 +120,7 @@ new_r_ir_graph (entity *ent, int n_loc) 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 */ @@ -117,7 +151,7 @@ new_r_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 @@ -161,6 +195,7 @@ new_r_ir_graph (entity *ent, int n_loc) #ifdef DEBUG_libfirm res->graph_nr = get_irp_new_node_nr(); #endif + res->proj_args = NULL; set_store(res->initial_mem); @@ -194,8 +229,7 @@ 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); @@ -208,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; @@ -217,25 +251,29 @@ 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 */ + + /* -- 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 (); - res->initial_mem = new_Proj (res->start, mode_M, pn_Start_M); - /* 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); @@ -412,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); @@ -618,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) { @@ -684,3 +732,38 @@ void (inc_irg_block_visited)(ir_graph *irg) { __inc_irg_block_visited(irg); } + + +/** + * 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); + + set_nodes_block(n, block); + } +} + +/* 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; +}