X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgraph.c;h=5247dd12b40ac28c968e72206b7f8d95af93d5f9;hb=e5c8ad12dba958fd212704917d7a433e6716462b;hp=b2ff2072232974437be9cb78fb16fda1f670c3a5;hpb=2bbfd13b3ba44093daf5338931f4e7ac30fe0bd3;p=libfirm diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index b2ff20722..5247dd12b 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -1,667 +1,704 @@ /* - * Project: libFIRM - * File name: ir/ir/irgraph.c - * Purpose: Entry point to the representation of procedure code. - * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * This file is part of libFirm. + * Copyright (C) 2012 University of Karlsruhe. */ -#ifdef HAVE_CONFIG_H -# include -#endif - -# include - -# include "ircons.h" -# include "irgraph_t.h" -# include "irprog_t.h" -# include "iropt_t.h" -# include "irflag_t.h" -# include "array.h" -# include "irgmod.h" -# include "mangle.h" -# include "irouts.h" -# include "firmstat.h" +/** + * @file + * @brief Entry point to the representation of procedure code. + * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck + */ +#include "config.h" + +#include +#include + +#include "xmalloc.h" +#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" +#include "array.h" +#include "irgmod.h" +#include "irouts.h" +#include "irhooks.h" +#include "irtools.h" +#include "util.h" +#include "irgwalk.h" +#include "irbackedge_t.h" +#include "iredges_t.h" +#include "type_t.h" +#include "irmemory.h" +#include "iroptimize.h" +#include "irgopt.h" + +#define INITIAL_IDX_IRN_MAP_SIZE 1024 +/** Suffix that is added to every frame type. */ +#define FRAME_TP_SUFFIX "frame_tp" ir_graph *current_ir_graph; -INLINE ir_graph *get_current_ir_graph(void) { - return current_ir_graph; +ir_graph *get_current_ir_graph(void) +{ + return current_ir_graph; } -INLINE void set_current_ir_graph(ir_graph *graph) { - current_ir_graph = graph; + +void set_current_ir_graph(ir_graph *graph) +{ + current_ir_graph = graph; } +/** contains the suffix for frame type names */ +static ident *frame_type_suffix = NULL; -bool interprocedural_view = false; -INLINE bool get_interprocedural_view(void) { - return interprocedural_view; +void firm_init_irgraph(void) +{ + frame_type_suffix = new_id_from_str(FRAME_TP_SUFFIX); } -INLINE void set_interprocedural_view(bool state) { - interprocedural_view = state; + +/** + * 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. + */ +static ir_graph *alloc_graph(void) +{ + ir_graph *const res = XMALLOCZ(ir_graph); + res->kind = k_ir_graph; + + /* initialize the idx->node map. */ + res->idx_irn_map = NEW_ARR_FZ(ir_node*, INITIAL_IDX_IRN_MAP_SIZE); + + obstack_init(&res->obst); + + /* value table for global value numbering for optimizing use in iropt.c */ + new_identities(res); + + return res; } -static ident* frame_type_suffix = NULL; -void init_irgraph(void) { - frame_type_suffix = new_id_from_chars(FRAME_TP_SUFFIX, strlen(FRAME_TP_SUFFIX)); +/** + * Frees an allocated IR graph + */ +static void free_graph(ir_graph *irg) +{ + for (ir_edge_kind_t i = EDGE_KIND_FIRST; i < EDGE_KIND_LAST; ++i) + edges_deactivate_kind(irg, i); + DEL_ARR_F(irg->idx_irn_map); + free(irg); } -#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 +void irg_set_nloc(ir_graph *res, int n_loc) +{ + assert(irg_is_constrained(res, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); -/* Allocates a list of nodes: - - The start block containing a start node and Proj nodes for it's four - results (X, M, P, Tuple). - - The end block containing an end node. This block is not matured after - new_ir_graph as predecessors need to be added to it. - - The current block, which is empty and also not matured. - Further it allocates several datastructures needed for graph construction - and optimization. -*/ -ir_graph * -new_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->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()) { - 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->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 = (struct obstack *) xmalloc (sizeof (struct obstack)); - obstack_init (res->obst); - res->value_table = new_identities (); /* value table for global value - numbering for optimizing use in - iropt.c */ - res->outs = NULL; - - res->phase_state = phase_building; - res->op_pin_state_pinned = op_pin_state_pinned; - res->outs_state = outs_none; - res->dom_state = dom_none; - res->typeinfo_state = irg_typeinfo_none; - res->loopinfo_state = loopinfo_none; - - /*-- Type information for the procedure of the graph --*/ - res->ent = ent; - set_entity_irg(ent, res); - - /*-- a class type so that it can contain "inner" methods as in Pascal. --*/ - res->frame_type = new_type_class(mangle(get_entity_ident(ent), frame_type_suffix)); - - /* Remove type from type list. Must be treated differently than other types. */ - remove_irp_type_from_list(res->frame_type); - - /*-- Nodes needed in every graph --*/ - res->end_block = new_immBlock(); - res->end = new_End(); - res->end_reg = res->end; - res->end_except = res->end; - - 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); - - /* 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->initial_mem = new_Proj (res->start, mode_M, pn_Start_M); - res->args = new_Proj (res->start, mode_T, pn_Start_T_args); + 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; + } +} + +ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) +{ + ir_graph *res; + ir_node *first_block; + ir_node *start, *start_block, *initial_mem, *projX; + + res = alloc_graph(); + + /* inform statistics here, as blocks will be already build on this graph */ + hook_new_graph(res, ent); + + /* graphs are in construction mode by default */ + add_irg_constraints(res, IR_GRAPH_CONSTRAINT_CONSTRUCTION); + irg_set_nloc(res, n_loc); + + res->irg_pinned_state = op_pin_state_pinned; + res->typeinfo_state = ir_typeinfo_none; + set_irp_typeinfo_inconsistent(); /* there is a new graph with typeinfo_none. */ + res->callee_info_state = irg_callee_info_none; + res->fp_model = fp_model_precise; + res->mem_disambig_opt = aa_opt_inherited; + + /*-- Type information for the procedure of the graph --*/ + res->ent = ent; + set_entity_irg(ent, res); + + /*-- a class type so that it can contain "inner" methods as in Pascal. --*/ + res->frame_type = new_type_frame(); + + /* the Anchor node must be created first */ + res->anchor = new_r_Anchor(res); + + /*-- Nodes needed in every graph --*/ + set_irg_end_block(res, new_r_immBlock(res)); + set_irg_end(res, new_r_End(res, 0, NULL)); + + start_block = new_r_Block_noopt(res, 0, NULL); + set_irg_start_block(res, start_block); + set_irg_no_mem (res, new_r_NoMem(res)); + start = new_r_Start(res); + set_irg_start (res, start); + + /* Proj results of start node */ + projX = new_r_Proj(start, mode_X, pn_Start_X_initial_exec); + set_irg_initial_exec (res, projX); + set_irg_frame (res, new_r_Proj(start, mode_P_data, pn_Start_P_frame_base)); + set_irg_args (res, new_r_Proj(start, mode_T, pn_Start_T_args)); + initial_mem = new_r_Proj(start, mode_M, pn_Start_M); + set_irg_initial_mem(res, initial_mem); + + res->index = get_irp_new_irg_idx(); #ifdef DEBUG_libfirm - res->graph_nr = get_irp_new_node_nr(); + res->graph_nr = get_irp_new_node_nr(); #endif - set_store(res->initial_mem); + set_r_cur_block(res, start_block); + set_r_store(res, initial_mem); - add_immBlock_pred(res->start_block, projX); - /* - * The code generation needs it. leave it in now. - * Use of this edge is matter of discussion, unresolved. Also possible: - * add_immBlock_pred(res->start_block, res->start_block), but invalid typed. - */ - mature_immBlock (res->current_block); + /*-- Make a block to start with --*/ + first_block = new_r_Block(res, 1, &projX); + set_r_cur_block(res, first_block); - /*-- Make a block to start with --*/ - first_block = new_immBlock(); - add_immBlock_pred (first_block, projX); + res->method_execution_frequency = -1.0; - return res; + return res; } +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; +} -/* 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; +ir_graph *new_const_code_irg(void) +{ + ir_graph *res = alloc_graph(); + 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; - res = (ir_graph *) malloc (sizeof(*res)); - memset(res, 0, sizeof(*res)); + /* inform statistics here, as blocks will be already build on this graph */ + hook_new_graph(res, NULL); - /* inform statistics here, as blocks will be already build on this graph */ - stat_new_graph(res, NULL); + res->n_loc = 1; /* Only the memory. */ + res->irg_pinned_state = op_pin_state_pinned; + res->fp_model = fp_model_precise; - 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->kind = k_ir_graph; - res->obst = (struct obstack *) xmalloc (sizeof (struct obstack)); - obstack_init (res->obst); - res->phase_state = phase_building; - res->op_pin_state_pinned = op_pin_state_pinned; - res->value_table = new_identities (); /* value table for global value - numbering for optimizing use in - iropt.c */ - res->ent = NULL; - res->frame_type = NULL; - res->start_block = new_immBlock (); - 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); - - /* Proj results of start node */ - 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_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); - - res->phase_state = phase_high; - return res; -} - -/* Defined in iropt.c */ -void del_identities (pset *value_table); - -/* Frees the passed irgraph. - Deallocates all nodes in this graph and the ir_graph structure. - Sets the field irgraph in the corresponding entity to NULL. - Does not remove the irgraph from the list in irprog (requires - 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) { - - stat_free_graph(irg); - if (irg->outs_state != outs_none) free_outs(irg); - if (irg->frame_type) free_type(irg->frame_type); - if (irg->value_table) del_identities(irg->value_table); - if (irg->ent) { - peculiarity pec = get_entity_peculiarity (irg->ent); - set_entity_peculiarity (irg->ent, peculiarity_description); - set_entity_irg(irg->ent, NULL); /* not set in const code irg */ - set_entity_peculiarity (irg->ent, pec); - } - - free_End(irg->end); - obstack_free(irg->obst,NULL); - free(irg->obst); -#if USE_EXPLICIT_PHI_IN_STACK - free_Phi_in_stack(irg->Phi_in_stack); -#endif - irg->kind = k_BAD; - free(irg); -} + add_irg_constraints(res, IR_GRAPH_CONSTRAINT_CONSTRUCTION); -/* access routines for all ir_graph attributes: - templates: - {attr type} get_irg_{attribute name} (ir_graph *irg); - void set_irg_{attr name} (ir_graph *irg, {attr type} {attr}); */ + /* the Anchor node must be created first */ + res->anchor = new_r_Anchor(res); -int -(is_ir_graph)(void *thing) { - return __is_ir_graph(thing); -} + /* -- The end block -- */ + end_block = new_r_Block_noopt(res, 0, NULL); + set_irg_end_block(res, end_block); + end = new_r_End(res, 0, NULL); + set_irg_end(res, end); -/* Outputs a unique number for this node */ + /* -- The start block -- */ + start_block = new_r_Block_noopt(res, 0, NULL); + set_irg_start_block(res, start_block); + no_mem = new_r_NoMem(res); + set_irg_no_mem(res, no_mem); + start = new_r_Start(res); + set_irg_start(res, start); -INLINE long -get_irg_graph_nr(ir_graph *irg) { - assert(irg); -#ifdef DEBUG_libfirm - return irg->graph_nr; -#else - return (long)irg; -#endif -} + /* Proj results of start node */ + set_irg_initial_mem(res, new_r_Proj(start, mode_M, pn_Start_M)); + projX = new_r_Proj(start, mode_X, pn_Start_X_initial_exec); -ir_node * -(get_irg_start_block)(ir_graph *irg) { - return __get_irg_start_block(irg); -} + body_block = new_r_Block(res, 1, &projX); -void -(set_irg_start_block)(ir_graph *irg, ir_node *node) { - __set_irg_start_block(irg, node); -} + set_r_cur_block(res, body_block); -ir_node * -(get_irg_start)(ir_graph *irg) { - return __get_irg_start(irg); -} + /* Set the visited flag high enough that the blocks will never be visited. */ + 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); -void -(set_irg_start)(ir_graph *irg, ir_node *node) { - __set_irg_start(irg, node); + return res; } -ir_node * -(get_irg_end_block)(ir_graph *irg) { - return __get_irg_end_block(irg); -} +/** + * 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 *node, void *env) +{ + ir_graph *irg = (ir_graph*)env; + ir_node *new_node = irn_copy_into_irg(node, irg); -void -(set_irg_end_block)(ir_graph *irg, ir_node *node) { - __set_irg_end_block(irg, node); -} + set_irn_link(node, new_node); -ir_node * -(get_irg_end)(ir_graph *irg) { - return __get_irg_end(irg); -} + /* fix access to entities on the stack frame */ + if (is_Sel(new_node)) { + ir_entity *ent = get_Sel_entity(new_node); + ir_type *tp = get_entity_owner(ent); -void -(set_irg_end)(ir_graph *irg, ir_node *node) { - __set_irg_end(irg, node); -} + if (is_frame_type(tp)) { + /* replace by the copied entity */ + ent = (ir_entity*)get_entity_link(ent); -ir_node * -(get_irg_end_reg)(ir_graph *irg) { - return __get_irg_end_reg(irg); + assert(is_entity(ent)); + assert(get_entity_owner(ent) == get_irg_frame_type(irg)); + set_Sel_entity(new_node, ent); + } + } } -void set_irg_end_reg (ir_graph *irg, ir_node *node) { - assert(get_irn_op(node) == op_EndReg || get_irn_op(node) == op_End); - irg->end_reg = node; +/** + * 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 rewire(ir_node *irn, void *env) +{ + (void) env; + irn_rewire_inputs(irn); } -ir_node * -(get_irg_end_except)(ir_graph *irg) { - return __get_irg_end_except(irg); +static ir_node *get_new_node(const ir_node *old_node) +{ + return (ir_node*) get_irn_link(old_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); - irg->end_except = node; +ir_graph *create_irg_copy(ir_graph *irg) +{ + ir_graph *res; + + res = alloc_graph(); + + res->irg_pinned_state = irg->irg_pinned_state; + res->fp_model = irg->fp_model; + + /* clone the frame type here for safety */ + irp_reserve_resources(irp, IRP_RESOURCE_ENTITY_LINK); + res->frame_type = clone_frame_type(irg->frame_type); + + 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, rewire, res); + + /* copy the Anchor node */ + res->anchor = get_new_node(irg->anchor); + + /* -- The end block -- */ + 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, get_new_node(get_irg_start_block(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, get_new_node(get_irg_initial_mem(irg))); + + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); + irp_free_resources(irp, IRP_RESOURCE_ENTITY_LINK); + + return res; } -ir_node * -(get_irg_cstore)(ir_graph *irg) { - return __get_irg_cstore(irg); +void free_ir_graph(ir_graph *irg) +{ + assert(is_ir_graph(irg)); + + remove_irp_irg(irg); + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_NONE); + + hook_free_graph(irg); + free_irg_outs(irg); + del_identities(irg); + if (irg->ent) { + set_entity_irg(irg->ent, NULL); /* not set in const code irg */ + } + + free_End(get_irg_end(irg)); + obstack_free(&irg->obst, NULL); + if (irg->loc_descriptions) + free(irg->loc_descriptions); + irg->kind = k_BAD; + free_graph(irg); } -void -(set_irg_cstore)(ir_graph *irg, ir_node *node) { - __set_irg_cstore(irg, node); +int (is_ir_graph)(const void *thing) +{ + return is_ir_graph_(thing); } -ir_node * -(get_irg_frame)(ir_graph *irg) { - return __get_irg_frame(irg); +#ifdef DEBUG_libfirm +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 -void -(set_irg_frame)(ir_graph *irg, ir_node *node) { - __set_irg_frame(irg, node); +size_t get_irg_idx(const ir_graph *irg) +{ + return irg->index; } -ir_node * -(get_irg_globals)(ir_graph *irg) { - return __get_irg_globals(irg); +ir_node *(get_idx_irn)(const ir_graph *irg, unsigned idx) +{ + return get_idx_irn_(irg, idx); } -void -(set_irg_globals)(ir_graph *irg, ir_node *node) { - __set_irg_globals(irg, node); +ir_node *(get_irg_start_block)(const ir_graph *irg) +{ + return get_irg_start_block_(irg); } -ir_node * -(get_irg_initial_mem)(ir_graph *irg) +void (set_irg_start_block)(ir_graph *irg, ir_node *node) { - return __get_irg_initial_mem(irg); + set_irg_start_block_(irg, node); } -void -(set_irg_initial_mem)(ir_graph *irg, ir_node *node) { - __set_irg_initial_mem(irg, node); +ir_node *(get_irg_start)(const ir_graph *irg) +{ + return get_irg_start_(irg); } -ir_node * -(get_irg_args)(ir_graph *irg) { - return __get_irg_args(irg); +void (set_irg_start)(ir_graph *irg, ir_node *node) +{ + set_irg_start_(irg, node); } -void -(set_irg_args)(ir_graph *irg, ir_node *node) { - __set_irg_args(irg, node); +ir_node *(get_irg_end_block)(const ir_graph *irg) +{ + return get_irg_end_block_(irg); } -ir_node * -(get_irg_bad)(ir_graph *irg) { - return __get_irg_bad(irg); +void (set_irg_end_block)(ir_graph *irg, ir_node *node) +{ + set_irg_end_block_(irg, node); } -void -(set_irg_bad)(ir_graph *irg, ir_node *node) { - __set_irg_bad(irg, node); +ir_node *(get_irg_end)(const ir_graph *irg) +{ + return get_irg_end_(irg); } -/* GL removed: we need unknown with mode for analyses. -ir_node * -get_irg_unknown (ir_graph *irg) +void (set_irg_end)(ir_graph *irg, ir_node *node) { - return irg->unknown; + set_irg_end_(irg, node); } -void -set_irg_unknown (ir_graph *irg, ir_node *node) +ir_node *(get_irg_initial_exec)(const ir_graph *irg) { - irg->unknown = node; + return get_irg_initial_exec_(irg); } -*/ -ir_node * -(get_irg_current_block)(ir_graph *irg) { - return __get_irg_current_block(irg); +void (set_irg_initial_exec)(ir_graph *irg, ir_node *node) +{ + set_irg_initial_exec_(irg, node); } -void -(set_irg_current_block)(ir_graph *irg, ir_node *node) { - __set_irg_current_block(irg, node); +ir_node *(get_irg_frame)(const ir_graph *irg) +{ + return get_irg_frame_(irg); } -entity * -(get_irg_entity)(ir_graph *irg) { - return __get_irg_ent(irg); +void (set_irg_frame)(ir_graph *irg, ir_node *node) +{ + set_irg_frame_(irg, node); } -void -(set_irg_entity)(ir_graph *irg, entity *ent) { - __set_irg_ent(irg, ent); +ir_node *(get_irg_initial_mem)(const ir_graph *irg) +{ + return get_irg_initial_mem_(irg); } -type * -(get_irg_frame_type)(ir_graph *irg) { - return __get_irg_frame_type(irg); +void (set_irg_initial_mem)(ir_graph *irg, ir_node *node) +{ + set_irg_initial_mem_(irg, node); } -void -(set_irg_frame_type)(ir_graph *irg, type *ftp) { - __set_irg_frame_type(irg, ftp); +ir_node *(get_irg_args)(const ir_graph *irg) +{ + return get_irg_args_(irg); } +void (set_irg_args)(ir_graph *irg, ir_node *node) +{ + set_irg_args_(irg, node); +} -/* To test for a frame type */ -int -is_frame_type(type *ftp) { - int i; - if (is_class_type(ftp)) { - for (i = 0; i < get_irp_n_irgs(); i++) { - type *frame_tp = get_irg_frame_type(get_irp_irg(i)); - if (ftp == frame_tp) return true; - } - } - return false; +ir_node *(get_irg_no_mem)(const ir_graph *irg) +{ + return get_irg_no_mem_(irg); } -int -get_irg_n_locs (ir_graph *irg) +void (set_irg_no_mem)(ir_graph *irg, ir_node *node) { - if (get_opt_precise_exc_context()) - return irg->n_loc - 1 - 1; - else - return irg->n_loc - 1; + set_irg_no_mem_(irg, node); } -void -set_irg_n_loc (ir_graph *irg, int n_loc) +ir_entity *(get_irg_entity)(const ir_graph *irg) { - if (get_opt_precise_exc_context()) - irg->n_loc = n_loc + 1 + 1; - else - irg->n_loc = n_loc + 1; + return get_irg_entity_(irg); } +void (set_irg_entity)(ir_graph *irg, ir_entity *ent) +{ + set_irg_entity_(irg, ent); +} +ir_type *(get_irg_frame_type)(ir_graph *irg) +{ + return get_irg_frame_type_(irg); +} -/* Returns the obstack associated with the graph. */ -struct obstack * -(get_irg_obstack)(ir_graph *irg) { - return __get_irg_obstack(irg); +void (set_irg_frame_type)(ir_graph *irg, ir_type *ftp) +{ + set_irg_frame_type_(irg, ftp); } -/* - * Returns true if the node n is allocated on the storage of graph irg. - * - * Implementation is GLIBC specific as is uses the internal _obstack_chunk implementation. - */ -int node_is_in_irgs_storage(ir_graph *irg, ir_node *n) +int get_irg_n_locs(ir_graph *irg) { - struct _obstack_chunk *p; + return irg->n_loc - 1; +} - /* - * checks wheater the ir_node pointer i on the obstack. - * A more sophisticated check would test the "whole" ir_node - */ - for (p = irg->obst->chunk; p; p = p->prev) { - if (((char *)p->contents <= (char *)n) && ((char *)n < (char *)p->limit)) - return 1; - } +int node_is_in_irgs_storage(const ir_graph *irg, const ir_node *n) +{ + /* Check whether the ir_node pointer is on the obstack. + * A more sophisticated check would test the "whole" ir_node. */ + for (struct _obstack_chunk const *p = irg->obst.chunk; p; p = p->prev) { + if (((char *)p->contents <= (char *)n) && ((char *)n < (char *)p->limit)) + return 1; + } - return 0; + return 0; } -irg_phase_state -(get_irg_phase_state)(ir_graph *irg) { - return __get_irg_phase_state(irg); +op_pin_state (get_irg_pinned)(const ir_graph *irg) +{ + return get_irg_pinned_(irg); } -void -(set_irg_phase_low)(ir_graph *irg) { - __set_irg_phase_low(irg); +irg_callee_info_state (get_irg_callee_info_state)(const ir_graph *irg) +{ + return get_irg_callee_info_state_(irg); } -op_pin_state -(get_irg_pinned)(ir_graph *irg) { - return __get_irg_pinned(irg); +void (set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s) +{ + set_irg_callee_info_state_(irg, s); } -irg_outs_state -(get_irg_outs_state)(ir_graph *irg) { - return __get_irg_outs_state(irg); +void (set_irg_link)(ir_graph *irg, void *thing) +{ + set_irg_link_(irg, thing); } -void -(set_irg_outs_inconsistent)(ir_graph *irg) { - __set_irg_outs_inconsistent(irg); +void *(get_irg_link)(const ir_graph *irg) +{ + return get_irg_link_(irg); } -irg_dom_state -(get_irg_dom_state)(ir_graph *irg) { - return __get_irg_dom_state(irg); +ir_visited_t (get_irg_visited)(const ir_graph *irg) +{ + return get_irg_visited_(irg); } -void -(set_irg_dom_inconsistent)(ir_graph *irg) { - __set_irg_dom_inconsistent(irg); -} +/** maximum visited flag content of all ir_graph visited fields. */ +static ir_visited_t max_irg_visited = 0; -irg_loopinfo_state -(get_irg_loopinfo_state)(ir_graph *irg) { - return __get_irg_loopinfo_state(irg); +void set_irg_visited(ir_graph *irg, ir_visited_t visited) +{ + irg->visited = visited; + if (irg->visited > max_irg_visited) { + max_irg_visited = irg->visited; + } } -void -(set_irg_loopinfo_state)(ir_graph *irg, irg_loopinfo_state s) { - __set_irg_loopinfo_state(irg, s); +void inc_irg_visited(ir_graph *irg) +{ + ++irg->visited; + if (irg->visited > max_irg_visited) { + max_irg_visited = irg->visited; + } } -void -set_irg_loopinfo_inconsistent(ir_graph *irg) { - if (irg->loopinfo_state == loopinfo_ip_consistent) - irg->loopinfo_state = loopinfo_ip_inconsistent; +ir_visited_t get_max_irg_visited(void) +{ + return max_irg_visited; +} - else if (irg->loopinfo_state == loopinfo_consistent) - irg->loopinfo_state = loopinfo_inconsistent; +void set_max_irg_visited(int val) +{ + max_irg_visited = val; +} - else if (irg->loopinfo_state == loopinfo_cf_ip_consistent) - irg->loopinfo_state = loopinfo_cf_ip_inconsistent; +ir_visited_t inc_max_irg_visited(void) +{ +#ifndef NDEBUG + size_t i; + for (i = 0; i < get_irp_n_irgs(); i++) + assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); +#endif + return ++max_irg_visited; +} - else if (irg->loopinfo_state == loopinfo_cf_consistent) - irg->loopinfo_state = loopinfo_cf_inconsistent; +ir_visited_t (get_irg_block_visited)(const ir_graph *irg) +{ + return get_irg_block_visited_(irg); } -void -(set_irg_pinned)(ir_graph *irg, op_pin_state p) { - __set_irg_pinned(irg, p); +void (set_irg_block_visited)(ir_graph *irg, ir_visited_t visited) +{ + set_irg_block_visited_(irg, visited); } -irg_callee_info_state -(get_irg_callee_info_state)(ir_graph *irg) { - return __get_irg_callee_info_state(irg); +void (inc_irg_block_visited)(ir_graph *irg) +{ + inc_irg_block_visited_(irg); } -void -(set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s) { - __set_irg_callee_info_state(irg, s); +unsigned (get_irg_fp_model)(const ir_graph *irg) +{ + return get_irg_fp_model_(irg); } -irg_inline_property -(get_irg_inline_property)(ir_graph *irg) { - return __get_irg_inline_property(irg); +void set_irg_fp_model(ir_graph *irg, unsigned model) +{ + irg->fp_model = model; } -void -(set_irg_inline_property)(ir_graph *irg, irg_inline_property s) { - __set_irg_inline_property(irg, s); +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 = XMALLOCNZ(void*, irg->n_loc); + + irg->loc_descriptions[n] = description; } -void -(set_irg_link)(ir_graph *irg, void *thing) { - __set_irg_link(irg, thing); +void *get_irg_loc_description(ir_graph *irg, int n) +{ + assert(0 <= n && n < irg->n_loc); + return irg->loc_descriptions ? irg->loc_descriptions[n] : NULL; } -void * -(get_irg_link)(ir_graph *irg) { - return __get_irg_link(irg); +#ifndef NDEBUG +void ir_reserve_resources(ir_graph *irg, ir_resources_t resources) +{ + assert((irg->reserved_resources & resources) == 0); + irg->reserved_resources |= resources; } -/* maximum visited flag content of all ir_graph visited fields. */ -static int max_irg_visited = 0; +void ir_free_resources(ir_graph *irg, ir_resources_t resources) +{ + assert((irg->reserved_resources & resources) == resources); + irg->reserved_resources &= ~resources; +} -unsigned long -(get_irg_visited)(ir_graph *irg) { - return __get_irg_visited(irg); +ir_resources_t ir_resources_reserved(const ir_graph *irg) +{ + return irg->reserved_resources; } +#endif -void -set_irg_visited (ir_graph *irg, unsigned long visited) +unsigned get_irg_last_idx(const ir_graph *irg) { - irg->visited = visited; - if (irg->visited > max_irg_visited) { - max_irg_visited = irg->visited; - } + return irg->last_node_idx; } -void -inc_irg_visited (ir_graph *irg) +void add_irg_constraints(ir_graph *irg, ir_graph_constraints_t constraints) { - if (++irg->visited > max_irg_visited) { - max_irg_visited = irg->visited; - } + irg->constraints |= constraints; } -unsigned long -get_max_irg_visited(void) +void clear_irg_constraints(ir_graph *irg, ir_graph_constraints_t constraints) { - /* - int i; - for(i = 0; i < get_irp_n_irgs(); i++) - assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); - */ - return max_irg_visited; + irg->constraints &= ~constraints; } -void set_max_irg_visited(int val) { - max_irg_visited = val; +int (irg_is_constrained)(const ir_graph *irg, ir_graph_constraints_t constraints) +{ + return irg_is_constrained_(irg, constraints); } -unsigned long -inc_max_irg_visited(void) +void (add_irg_properties)(ir_graph *irg, ir_graph_properties_t props) { - /* - int i; - for(i = 0; i < get_irp_n_irgs(); i++) - assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); - */ - max_irg_visited++; - return max_irg_visited; + add_irg_properties_(irg, props); } -unsigned long -(get_irg_block_visited)(ir_graph *irg) { - return __get_irg_block_visited(irg); +void (clear_irg_properties)(ir_graph *irg, ir_graph_properties_t props) +{ + clear_irg_properties_(irg, props); } -void -(set_irg_block_visited)(ir_graph *irg, unsigned long visited) { - __set_irg_block_visited(irg, visited); +int (irg_has_properties)(const ir_graph *irg, ir_graph_properties_t props) +{ + return irg_has_properties_(irg, props); } -void -(inc_irg_block_visited)(ir_graph *irg) { - __inc_irg_block_visited(irg); +typedef void (*assure_property_func)(ir_graph *irg); + +void assure_irg_properties(ir_graph *irg, ir_graph_properties_t props) +{ + static struct { + ir_graph_properties_t property; + assure_property_func func; + } property_functions[] = { + { IR_GRAPH_PROPERTY_ONE_RETURN, normalize_one_return }, + { IR_GRAPH_PROPERTY_MANY_RETURNS, normalize_n_returns }, + { IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES, remove_critical_cf_edges }, + { IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE, remove_unreachable_code }, + { IR_GRAPH_PROPERTY_NO_BADS, remove_bads }, + { IR_GRAPH_PROPERTY_NO_TUPLES, remove_tuples }, + { IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE, assure_doms }, + { IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE, assure_postdoms }, + { IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES, assure_edges }, + { IR_GRAPH_PROPERTY_CONSISTENT_OUTS, assure_irg_outs }, + { IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO, assure_loopinfo }, + { IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE, assure_irg_entity_usage_computed }, + { IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS, ir_compute_dominance_frontiers }, + }; + size_t i; + for (i = 0; i < ARRAY_SIZE(property_functions); ++i) { + ir_graph_properties_t missing = props & ~irg->properties; + if (missing & property_functions[i].property) + property_functions[i].func(irg); + } + assert((props & ~irg->properties) == IR_GRAPH_PROPERTIES_NONE); +} + +void confirm_irg_properties(ir_graph *irg, ir_graph_properties_t props) +{ + clear_irg_properties(irg, ~props); + if (! (props & IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES)) + edges_deactivate(irg); + if (! (props & IR_GRAPH_PROPERTY_CONSISTENT_OUTS) + && (irg->properties & IR_GRAPH_PROPERTY_CONSISTENT_OUTS)) + free_irg_outs(irg); + if (! (props & IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS)) + ir_free_dominance_frontiers(irg); }