* @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 <string.h>
-#endif
+#include <string.h>
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#endif
*/
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
ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc) {
ir_graph *res;
ir_node *first_block;
- ir_node *end, *start, *start_block, *initial_mem, *projX;
+ ir_node *end, *start, *start_block, *initial_mem, *projX, *bad;
res = alloc_graph();
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;
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;
- res->value_table = new_identities (); /* value table for global value
- numbering for optimizing use in iropt.c */
+ res->value_table = new_identities(); /* value table for global value
+ numbering for optimizing use in iropt.c */
res->outs = NULL;
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;
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 --*/
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));
+ bad = new_ir_node(NULL, res, start_block, op_Bad, mode_T, 0, NULL);
+ bad->attr.irg.irg = res;
+ set_irg_bad (res, bad);
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);
/* 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);
- add_immBlock_pred(start_block, projX);
set_store(initial_mem);
res->index = get_irp_new_irg_idx();
res->graph_nr = get_irp_new_node_nr();
#endif
- /*
- * 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_immBlock();
+ set_cur_block(first_block);
add_immBlock_pred(first_block, projX);
res->method_execution_frequency = -1.0;
/* 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;
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);
+ bad->attr.irg.irg = res;
+ 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;
* @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;
new_backedge_info(nn);
set_irn_link(n, nn);
- /* fix the irg for blocks */
+ /* fix the irg for Blocks: as Bad nodes are NOT copied, no
+ need t fix them */
if (is_Block(nn))
- nn->attr.block.irg = irg;
+ nn->attr.block.irg.irg = irg;
/* fix access to entities on the stack frame */
if (is_Sel(nn)) {
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);
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;
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);
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;
}
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);
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;
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);
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 *
_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);
_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())
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) {
}
#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;
}
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);
}
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;
}
}
#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 set_using_irn_link(ir_graph *irg) {
- assert(irg->using_irn_link == 0);
- irg->using_irn_link = 1;
+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 clear_using_irn_link(ir_graph *irg) {
- assert(irg->using_irn_link == 1);
- irg->using_irn_link = 0;
+void ir_free_resources(ir_graph *irg, ir_resources_t resources) {
+ assert((irg->reserved_resources & resources) == resources);
+ irg->reserved_resources &= ~resources;
}
-int using_irn_link(const ir_graph *irg) {
- return irg->using_irn_link;
+ir_resources_t ir_resources_reserved(const ir_graph *irg) {
+ return irg->reserved_resources;
}
-#endif
+#endif /* NDEBUG */
/* Returns a estimated node count of the irg. */
unsigned (get_irg_estimated_node_cnt)(const ir_graph *irg) {
return additional_graph_data_size += size;
}
+
+void (set_irg_state)(ir_graph *irg, ir_graph_state_t state)
+{
+ _set_irg_state(irg, state);
+}
+
+void (clear_irg_state)(ir_graph *irg, ir_graph_state_t state)
+{
+ _clear_irg_state(irg, state);
+}
+
+int (is_irg_state)(const ir_graph *irg, ir_graph_state_t state)
+{
+ return _is_irg_state(irg, state);
+}
projects / libfirm / blobdiff