# 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"
ir_graph *current_ir_graph;
INLINE ir_graph *get_current_ir_graph(void) {
ir_node *projX;
res = (ir_graph *) malloc (sizeof (ir_graph));
- res->kind=k_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 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! */
-#endif
+ /*-- 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 */
+ 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
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 */
+ numbering for optimizing use in
+ iropt.c */
res->outs = NULL;
- res->phase_state = phase_building;
- res->pinned = pinned;
- res->outs_state = no_outs;
- res->dom_state = no_dom;
+ res->phase_state = phase_building;
+ res->pinned = pinned;
+ res->outs_state = no_outs;
+ res->dom_state = no_dom;
res->typeinfo_state = irg_typeinfo_none;
+ res->loopinfo_state = loopinfo_none;
- /** Type information for the procedure of the graph **/
+ /*-- Type information for the procedure of the graph --*/
res->ent = ent;
set_entity_irg(ent, res);
-/**
- contain "inner" methods as in Pascal. **/
+ /*-- 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 ();
+ /*-- 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);
- res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL);
+ 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->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL); */
/* Proj results of start node */
- projX = new_Proj (res->start, mode_X, pns_initial_exec);
- set_store (new_Proj (res->start, mode_M, pns_global_store));
- res->frame = new_Proj (res->start, mode_P_mach, pns_frame_base);
- res->globals = new_Proj (res->start, mode_P_mach, pns_globals);
- res->args = new_Proj (res->start, mode_T, pns_args);
+ projX = new_Proj (res->start, mode_X, pns_initial_exec);
+ res->frame = new_Proj (res->start, mode_P_mach, pns_frame_base);
+ res->globals = new_Proj (res->start, mode_P_mach, pns_globals);
+ res->initial_mem = new_Proj (res->start, mode_M, pns_global_store);
+ res->args = new_Proj (res->start, mode_T, pns_args);
#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);
add_in_edge(res->start_block, projX);
/*
*/
mature_block (res->current_block);
- /** Make a block to start with **/
- first_block = new_immBlock ();
+ /*-- Make a block to start with --*/
+ first_block = new_immBlock();
add_in_edge (first_block, projX);
return res;
res = (ir_graph *) malloc (sizeof(*res));
memset(res, 0, sizeof(*res));
+ /* inform statistics here, as blocks will be already build on this graph */
+ stat_new_graph(res, NULL);
+
current_ir_graph = res;
res->n_loc = 1; /* Only the memory. */
res->visited = 0; /* visited flag, for the ir walker */
res->phase_state = phase_building;
res->pinned = pinned;
res->value_table = new_identities (); /* value table for global value
- numbering for optimizing use in
- iropt.c */
+ 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_block = new_immBlock ();
+ res->end = new_End ();
+ res->end_reg = res->end;
+ res->end_except = res->end;
mature_block(get_cur_block());
res->bad = new_ir_node (NULL, res, res->start_block, op_Bad, mode_T, 0, NULL);
- res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL);
+ /* res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL); */
res->start = new_Start ();
/* Proj results of start node */
projX = new_Proj (res->start, mode_X, pns_initial_exec);
- set_store (new_Proj (res->start, mode_M, pns_global_store));
add_in_edge(res->start_block, projX);
mature_block (res->current_block);
add_in_edge (new_immBlock (), projX);
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 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) {
- set_entity_irg(irg->ent, NULL);
- irg->kind = k_BAD;
+ stat_free_graph(irg);
+ if (irg->outs_state != no_outs) 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);
}
void set_irg_{attr name} (ir_graph *irg, {attr type} {attr}); */
int
-is_ir_graph(void *thing) {
- assert(thing);
- if (get_kind(thing) == k_ir_graph)
- return 1;
- else
- return 0;
+(is_ir_graph)(void *thing) {
+ return __is_ir_graph(thing);
}
/* Outputs a unique number for this node */
#ifdef DEBUG_libfirm
return irg->graph_nr;
#else
- return 0;
+ return (long)irg;
#endif
}
ir_node *
-get_irg_start_block (ir_graph *irg)
-{
- return irg->start_block;
+(get_irg_start_block)(ir_graph *irg) {
+ return __get_irg_start_block(irg);
}
void
-set_irg_start_block (ir_graph *irg, ir_node *node)
-{
- irg->start_block = node;
+(set_irg_start_block)(ir_graph *irg, ir_node *node) {
+ __set_irg_start_block(irg, node);
}
ir_node *
-get_irg_start (ir_graph *irg)
-{
- return irg->start;
+(get_irg_start)(ir_graph *irg) {
+ return __get_irg_start(irg);
}
void
-set_irg_start(ir_graph *irg, ir_node *node)
-{
- irg->start = node;
+(set_irg_start)(ir_graph *irg, ir_node *node) {
+ __set_irg_start(irg, node);
}
ir_node *
-get_irg_end_block (ir_graph *irg)
-{
- return irg->end_block;
+(get_irg_end_block)(ir_graph *irg) {
+ return __get_irg_end_block(irg);
}
void
-set_irg_end_block (ir_graph *irg, ir_node *node)
-{
- irg->end_block = node;
+(set_irg_end_block)(ir_graph *irg, ir_node *node) {
+ __set_irg_end_block(irg, node);
}
ir_node *
-get_irg_end (ir_graph *irg)
-{
- return irg->end;
+(get_irg_end)(ir_graph *irg) {
+ return __get_irg_end(irg);
}
void
-set_irg_end (ir_graph *irg, ir_node *node)
-{
- irg->end = node;
+(set_irg_end)(ir_graph *irg, ir_node *node) {
+ __set_irg_end(irg, node);
}
ir_node *
-get_irg_cstore (ir_graph *irg)
-{
- return irg->cstore;
+(get_irg_end_reg)(ir_graph *irg) {
+ return __get_irg_end_reg(irg);
+}
+
+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;
+}
+
+ir_node *
+(get_irg_end_except)(ir_graph *irg) {
+ return __get_irg_end_except(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);
+ irg->end_except = node;
+}
+
+ir_node *
+(get_irg_cstore)(ir_graph *irg) {
+ return __get_irg_cstore(irg);
}
void
-set_irg_cstore (ir_graph *irg, ir_node *node)
-{
- irg->cstore = node;
+(set_irg_cstore)(ir_graph *irg, ir_node *node) {
+ __set_irg_cstore(irg, node);
}
ir_node *
-get_irg_frame (ir_graph *irg)
-{
- return irg->frame;
+(get_irg_frame)(ir_graph *irg) {
+ return __get_irg_frame(irg);
}
void
-set_irg_frame (ir_graph *irg, ir_node *node)
-{
- irg->frame = node;
+(set_irg_frame)(ir_graph *irg, ir_node *node) {
+ __set_irg_frame(irg, node);
}
ir_node *
-get_irg_globals (ir_graph *irg)
-{
- return irg->globals;
+(get_irg_globals)(ir_graph *irg) {
+ return __get_irg_globals(irg);
}
void
-set_irg_globals (ir_graph *irg, ir_node *node)
-{
- irg->globals = node;
+(set_irg_globals)(ir_graph *irg, ir_node *node) {
+ __set_irg_globals(irg, node);
}
ir_node *
-get_irg_args (ir_graph *irg)
+(get_irg_initial_mem)(ir_graph *irg)
{
- return irg->args;
+ return __get_irg_initial_mem(irg);
}
void
-set_irg_args (ir_graph *irg, ir_node *node)
-{
- irg->args = node;
+(set_irg_initial_mem)(ir_graph *irg, ir_node *node) {
+ __set_irg_initial_mem(irg, node);
}
ir_node *
-get_irg_bad (ir_graph *irg)
-{
- return irg->bad;
+(get_irg_args)(ir_graph *irg) {
+ return __get_irg_args(irg);
}
void
-set_irg_bad (ir_graph *irg, ir_node *node)
-{
- irg->bad = node;
+(set_irg_args)(ir_graph *irg, ir_node *node) {
+ __set_irg_args(irg, node);
}
+ir_node *
+(get_irg_bad)(ir_graph *irg) {
+ return __get_irg_bad(irg);
+}
+
+void
+(set_irg_bad)(ir_graph *irg, ir_node *node) {
+ __set_irg_bad(irg, node);
+}
+
+/* GL removed: we need unknown with mode for analyses.
ir_node *
get_irg_unknown (ir_graph *irg)
{
{
irg->unknown = node;
}
+*/
ir_node *
-get_irg_current_block (ir_graph *irg)
-{
- return irg->current_block;
+(get_irg_current_block)(ir_graph *irg) {
+ return __get_irg_current_block(irg);
}
void
-set_irg_current_block (ir_graph *irg, ir_node *node)
-{
- irg->current_block = node;
+(set_irg_current_block)(ir_graph *irg, ir_node *node) {
+ __set_irg_current_block(irg, node);
}
entity *
-get_irg_ent (ir_graph *irg)
-{
- assert(irg && irg->ent);
- return irg->ent;
+(get_irg_ent)(ir_graph *irg) {
+ return __get_irg_ent(irg);
}
void
-set_irg_ent (ir_graph *irg, entity *ent)
-{
- irg->ent = ent;
+(set_irg_ent)(ir_graph *irg, entity *ent) {
+ __set_irg_ent(irg, ent);
}
type *
-get_irg_frame_type (ir_graph *irg)
-{
- assert(irg && irg->frame_type);
- return irg->frame_type;
+(get_irg_frame_type)(ir_graph *irg) {
+ return __get_irg_frame_type(irg);
}
void
-set_irg_frame_type (ir_graph *irg, type *ftp)
-{
- assert(is_class_type(ftp));
- irg->frame_type = ftp;
+(set_irg_frame_type)(ir_graph *irg, type *ftp) {
+ __set_irg_frame_type(irg, ftp);
}
int
get_irg_n_locs (ir_graph *irg)
{
-#if PRECISE_EXC_CONTEXT
- return irg->n_loc - 1 - 1;
-#else
- return irg->n_loc - 1;
-#endif
+ if (get_opt_precise_exc_context())
+ return irg->n_loc - 1 - 1;
+ else
+ return irg->n_loc - 1;
}
void
set_irg_n_loc (ir_graph *irg, int n_loc)
{
-#if PRECISE_EXC_CONTEXT
- irg->n_loc = n_loc + 1 + 1;
-#else
- irg->n_loc = n_loc + 1;
-#endif
+ if (get_opt_precise_exc_context())
+ irg->n_loc = n_loc + 1 + 1;
+ else
+ irg->n_loc = n_loc + 1;
}
/* Returns the obstack associated with the graph. */
-struct obstack *get_irg_obstack(ir_graph *irg) {
- return irg->obst;
+struct obstack *
+(get_irg_obstack)(ir_graph *irg) {
+ return __get_irg_obstack(irg);
}
/*
*/
int node_is_in_irgs_storage(ir_graph *irg, ir_node *n)
{
- struct _obstack_chunk *p;
+ struct _obstack_chunk *p;
/*
* checks wheater the ir_node pointer i on the obstack.
- * A more sophisticated chaeck would test the "whole" ir_node
+ * 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))
}
irg_phase_state
-get_irg_phase_state (ir_graph *irg) {
- return irg->phase_state;
+(get_irg_phase_state)(ir_graph *irg) {
+ return __get_irg_phase_state(irg);
}
void
-set_irg_phase_low(ir_graph *irg) {
- irg->phase_state = phase_low;
+(set_irg_phase_low)(ir_graph *irg) {
+ __set_irg_phase_low(irg);
}
op_pinned
-get_irg_pinned (ir_graph *irg) {
- return irg->pinned;
+(get_irg_pinned)(ir_graph *irg) {
+ return __get_irg_pinned(irg);
}
irg_outs_state
-get_irg_outs_state(ir_graph *irg) {
- return irg->outs_state;
+(get_irg_outs_state)(ir_graph *irg) {
+ return __get_irg_outs_state(irg);
}
void
-set_irg_outs_inconsistent(ir_graph *irg) {
- irg->outs_state = outs_inconsistent;
+(set_irg_outs_inconsistent)(ir_graph *irg) {
+ __set_irg_outs_inconsistent(irg);
}
irg_dom_state
-get_irg_dom_state(ir_graph *irg) {
- return irg->dom_state;
+(get_irg_dom_state)(ir_graph *irg) {
+ return __get_irg_dom_state(irg);
}
void
-set_irg_dom_inconsistent(ir_graph *irg) {
- irg->dom_state = dom_inconsistent;
+(set_irg_dom_inconsistent)(ir_graph *irg) {
+ __set_irg_dom_inconsistent(irg);
}
irg_loopinfo_state
-get_irg_loopinfo_state(ir_graph *irg) {
- assert(0 && "not implemented");
- return 999;
+(get_irg_loopinfo_state)(ir_graph *irg) {
+ return __get_irg_loopinfo_state(irg);
+}
+
+void
+(set_irg_loopinfo_state)(ir_graph *irg, irg_loopinfo_state s) {
+ __set_irg_loopinfo_state(irg, s);
}
void
set_irg_loopinfo_inconsistent(ir_graph *irg) {
- assert(0 && "not implemented");
+ if (irg->loopinfo_state == loopinfo_ip_consistent)
+ irg->loopinfo_state = loopinfo_ip_inconsistent;
+
+ else if (irg->loopinfo_state == loopinfo_consistent)
+ irg->loopinfo_state = loopinfo_inconsistent;
+
+ else if (irg->loopinfo_state == loopinfo_cf_ip_consistent)
+ irg->loopinfo_state = loopinfo_cf_ip_inconsistent;
+
+ else if (irg->loopinfo_state == loopinfo_cf_consistent)
+ irg->loopinfo_state = loopinfo_cf_inconsistent;
+}
+
+void
+(set_irg_pinned)(ir_graph *irg, op_pinned p) {
+ __set_irg_pinned(irg, p);
+}
+
+irg_callee_info_state
+(get_irg_callee_info_state)(ir_graph *irg) {
+ return __get_irg_callee_info_state(irg);
}
-INLINE void
-set_irg_pinned (ir_graph *irg, op_pinned p) {
- irg->pinned = p;
+void
+(set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s) {
+ __set_irg_callee_info_state(irg, s);
+}
+
+irg_inline_property
+(get_irg_inline_property)(ir_graph *irg) {
+ return __get_irg_inline_property(irg);
}
-INLINE void
-set_irg_link (ir_graph *irg, void *thing) {
- irg->link = thing;
+void
+(set_irg_inline_property)(ir_graph *irg, irg_inline_property s) {
+ __set_irg_inline_property(irg, s);
}
-INLINE void *
-get_irg_link (ir_graph *irg) {
- return irg->link;
+void
+(set_irg_link)(ir_graph *irg, void *thing) {
+ __set_irg_link(irg, thing);
+}
+
+void *
+(get_irg_link)(ir_graph *irg) {
+ return __get_irg_link(irg);
}
/* maximum visited flag content of all ir_graph visited fields. */
static int max_irg_visited = 0;
unsigned long
-get_irg_visited (ir_graph *irg)
-{
- return irg->visited;
+(get_irg_visited)(ir_graph *irg) {
+ return __get_irg_visited(irg);
}
void
}
unsigned long
-get_irg_block_visited (ir_graph *irg)
-{
- return irg->block_visited;
+(get_irg_block_visited)(ir_graph *irg) {
+ return __get_irg_block_visited(irg);
}
void
-set_irg_block_visited (ir_graph *irg, unsigned long visited)
-{
- irg->block_visited = visited;
+(set_irg_block_visited)(ir_graph *irg, unsigned long visited) {
+ __set_irg_block_visited(irg, visited);
}
void
-inc_irg_block_visited (ir_graph *irg)
-{
- ++irg->block_visited;
+(inc_irg_block_visited)(ir_graph *irg) {
+ __inc_irg_block_visited(irg);
}
projects / libfirm / blobdiff