-/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-* All rights reserved.
-*
-* Authors: Martin Trapp, Christian Schaefer
-*
-*
-*/
-
-/* $Id$ */
+/*
+ * 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.
+ */
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
#endif
+#ifdef HAVE_STRING_H
# include <string.h>
+#endif
+#ifdef HAVE_STDDEF_H
+# include <stddef.h>
+#endif
-# include "ircons.h"
-# include "irgraph_t.h"
-# include "irprog_t.h"
-# include "iropt_t.h"
-# include "array.h"
-# include "irgmod.h"
-# include "mangle.h"
+#include "xmalloc.h"
+#include "ircons.h"
+#include "irgraph_t.h"
+#include "irprog_t.h"
+#include "irnode_t.h"
+#include "iropt_t.h"
+#include "irflag_t.h"
+#include "array.h"
+#include "irgmod.h"
+#include "mangle.h"
+#include "irouts.h"
+#include "irhooks.h"
+#include "irtools.h"
+#include "irgwalk.h"
+#include "iredges_t.h"
+#include "type_t.h"
+
+#define INITIAL_IDX_IRN_MAP_SIZE 1024
+
+/**
+ * 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) {
+ir_graph *get_current_ir_graph(void) {
return current_ir_graph;
}
-INLINE void set_current_ir_graph(ir_graph *graph) {
+void set_current_ir_graph(ir_graph *graph) {
current_ir_graph = graph;
}
-bool interprocedural_view = false;
-INLINE bool get_interprocedural_view(void) {
- return interprocedural_view;
+int firm_interprocedural_view = 0;
+
+int (get_interprocedural_view)(void) {
+ return _get_interprocedural_view();
+}
+
+void (set_interprocedural_view)(int state) {
+ firm_interprocedural_view = state;
+
+ /* set function vectors for faster access */
+ if (state) {
+ _get_irn_arity = _get_irn_inter_arity;
+ _get_irn_n = _get_irn_inter_n;
+ }
+ else {
+ _get_irn_arity = _get_irn_intra_arity;
+ _get_irn_n = _get_irn_intra_n;
+ }
+}
+
+/** contains the suffix for frame type names */
+static ident *frame_type_suffix = NULL;
+
+/* initialize the IR graph module */
+void firm_init_irgraph(void) {
+ frame_type_suffix = new_id_from_str(FRAME_TP_SUFFIX);
+ forbid_new_data = 1;
}
-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) {
+ 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);
}
-static ident* frame_type_suffix = NULL;
-void init_irgraph(void) {
- frame_type_suffix = id_from_str(FRAME_TP_SUFFIX, strlen(FRAME_TP_SUFFIX));
+/**
+ * Frees an allocated IR graph
+ */
+static void free_graph(ir_graph *irg) {
+ char *ptr = (char *)irg;
+ free(ptr - additional_graph_data_size);
}
#if USE_EXPLICIT_PHI_IN_STACK
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;
+ ir_node *first_block;
+ ir_node *end, *start, *start_block, *initial_mem, *projX;
+
+ res = alloc_graph();
+ res->kind = k_ir_graph;
+
+ edges_init_graph(res);
+
+ /* initialize the idx->node map. */
+ res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE);
+ memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0]));
+
+ /* inform statistics here, as blocks will be already build on this graph */
+ hook_new_graph(res, ent);
- res = (ir_graph *) malloc (sizeof (ir_graph));
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! */
+ }
+
+ /* 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 */
+ 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->obst = (struct obstack *) xmalloc (sizeof (struct obstack));
- obstack_init (res->obst);
+ 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 */
+ 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;
-
- /** Type information for the procedure of the graph **/
+ 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->pdom_state = dom_none;
+ 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->loopinfo_state = loopinfo_none;
+ res->execfreq_state = exec_freq_none;
+ res->class_cast_state = ir_class_casts_transitive;
+ res->extblk_state = ir_extblk_info_none;
+ res->fp_model = fp_model_precise;
+
+ /*-- Type information for the procedure of the graph --*/
res->ent = ent;
set_entity_irg(ent, res);
-/**
- 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);
+ /*-- 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));
- /** Nodes needed in every graph **/
- res->end_block = new_immBlock ();
- res->end = new_End ();
+ /*-- Nodes needed in every graph --*/
+ set_irg_end_block (res, new_immBlock());
+ end = new_End();
+ set_irg_end (res, end);
+ set_irg_end_reg (res, end);
+ set_irg_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);
+ start_block = new_immBlock();
+ 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);
/* 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, pns_frame_base);
- res->globals = new_Proj (res->start, mode_P, pns_globals);
- res->args = new_Proj (res->start, mode_T, pns_args);
+ projX = new_Proj(start, mode_X, pn_Start_X_initial_exec);
+ 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);
+
#ifdef DEBUG_libfirm
- res->graph_nr = get_irp_new_node_nr();
+ res->graph_nr = get_irp_new_node_nr();
#endif
+ res->proj_args = NULL;
-
- add_in_edge(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_in_edge(res->start_block, res->start_block), but invalid typed.
+ * add_immBlock_pred(res->start_block, res->start_block), but invalid typed.
*/
- mature_block (res->current_block);
+ mature_immBlock(res->current_block);
- /** Make a block to start with **/
- first_block = new_immBlock ();
- add_in_edge (first_block, projX);
+ /*-- Make a block to start with --*/
+ first_block = new_immBlock();
+ add_immBlock_pred(first_block, projX);
+
+ res->method_execution_frequency = -1;
+ res->estimated_node_count = 0;
return res;
}
-/* Make a rudimentary ir graph for the constant code.
+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() {
+ir_graph *new_const_code_irg(void) {
ir_graph *res;
- ir_node *projX;
+ ir_node *end, *start_block, *start, *projX;
+
+ res = alloc_graph();
+
+ /* initialize the idx->node map. */
+ res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE);
+ memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0]));
+
+ /* inform statistics here, as blocks will be already build on this graph */
+ hook_new_graph(res, NULL);
- res = (ir_graph *) malloc (sizeof (ir_graph));
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 */
+ 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 = (struct obstack *) xmalloc (sizeof (struct obstack));
+ res->kind = k_ir_graph;
+ res->obst = xmalloc (sizeof(*res->obst));
obstack_init (res->obst);
- res->phase_state = phase_building;
- res->pinned = pinned;
+ res->extbb_obst = NULL;
+
+ res->last_node_idx = 0;
+
+ res->phase_state = phase_building;
+ res->irg_pinned_state = op_pin_state_pinned;
+ 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 */
+ 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 ();
- 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->start = new_Start ();
+ res->frame_type = NULL;
+
+ /* -- The end block -- */
+ set_irg_end_block (res, new_immBlock());
+ 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 */
+
+ /* -- The start block -- */
+ start_block = new_immBlock();
+ 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);
+
/* 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);
- mature_block(get_cur_block());
- /* Set the visited flag high enough that the block will never be visited. */
+ 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 */
+
+ 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 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_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);
+
+ 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 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);
+ assert(is_ir_graph(irg));
+
+ hook_free_graph(irg);
+ if (irg->outs_state != outs_none) free_irg_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(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
- free(irg);
+ if (irg->loc_descriptions)
+ free(irg->loc_descriptions);
+ irg->kind = k_BAD;
+ free_graph(irg);
}
/* access routines for all ir_graph attributes:
{attr type} get_irg_{attribute name} (ir_graph *irg);
void set_irg_{attr name} (ir_graph *irg, {attr type} {attr}); */
-/* Outputs a unique number for this node */
+int
+(is_ir_graph)(const void *thing) {
+ return _is_ir_graph(thing);
+}
-INLINE long
-get_irg_graph_nr(ir_graph *irg) {
+/* Outputs a unique number for this node */
+long get_irg_graph_nr(ir_graph *irg) {
assert(irg);
#ifdef DEBUG_libfirm
return irg->graph_nr;
#else
- return 0;
+ return (long)PTR_TO_INT(irg);
#endif
}
ir_node *
-get_irg_start_block (ir_graph *irg)
-{
- return irg->start_block;
+(get_irg_start_block)(const 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)(const 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)(const 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)(const 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)(const 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->anchors[anchor_end_reg] = node;
+}
+
+ir_node *
+(get_irg_end_except)(const 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->anchors[anchor_end_except] = node;
+}
+
+ir_node *
+(get_irg_frame)(const ir_graph *irg) {
+ return _get_irg_frame(irg);
}
void
-set_irg_cstore (ir_graph *irg, ir_node *node)
-{
- irg->cstore = node;
+(set_irg_frame)(ir_graph *irg, ir_node *node) {
+ _set_irg_frame(irg, node);
}
ir_node *
-get_irg_frame (ir_graph *irg)
-{
- return irg->frame;
+(get_irg_globals)(const ir_graph *irg) {
+ return _get_irg_globals(irg);
}
void
-set_irg_frame (ir_graph *irg, ir_node *node)
-{
- irg->frame = node;
+(set_irg_globals)(ir_graph *irg, ir_node *node) {
+ _set_irg_globals(irg, node);
}
ir_node *
-get_irg_globals (ir_graph *irg)
-{
- return irg->globals;
+(get_irg_tls)(const ir_graph *irg) {
+ return _get_irg_tls(irg);
}
void
-set_irg_globals (ir_graph *irg, ir_node *node)
-{
- irg->globals = node;
+(set_irg_tls)(ir_graph *irg, ir_node *node) {
+ _set_irg_tls(irg, node);
}
ir_node *
-get_irg_args (ir_graph *irg)
-{
- return irg->args;
+(get_irg_initial_mem)(const ir_graph *irg) {
+ 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)(const 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_unknown (ir_graph *irg)
-{
- return irg->unknown;
+(get_irg_value_param_base)(const ir_graph *irg) {
+ return _get_irg_value_param_base(irg);
}
void
-set_irg_unknown (ir_graph *irg, ir_node *node)
-{
- irg->unknown = node;
+(set_irg_value_param_base)(ir_graph *irg, ir_node *node) {
+ _set_irg_value_param_base(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_current_block (ir_graph *irg)
-{
- return irg->current_block;
+(get_irg_bad)(const ir_graph *irg) {
+ return _get_irg_bad(irg);
}
void
-set_irg_current_block (ir_graph *irg, ir_node *node)
-{
- irg->current_block = node;
+(set_irg_bad)(ir_graph *irg, ir_node *node) {
+ _set_irg_bad(irg, node);
}
-entity *
-get_irg_ent (ir_graph *irg)
-{
- assert(irg && irg->ent);
- return irg->ent;
+ir_node *
+(get_irg_no_mem)(const ir_graph *irg) {
+ return _get_irg_no_mem(irg);
}
void
-set_irg_ent (ir_graph *irg, entity *ent)
-{
- irg->ent = ent;
+(set_irg_no_mem)(ir_graph *irg, ir_node *node) {
+ _set_irg_no_mem(irg, node);
}
-type *
-get_irg_frame_type (ir_graph *irg)
-{
- assert(irg && irg->frame_type);
- return irg->frame_type;
+ir_node *
+(get_irg_current_block)(const ir_graph *irg) {
+ return _get_irg_current_block(irg);
}
void
-set_irg_frame_type (ir_graph *irg, type *ftp)
-{
- irg->frame_type = ftp;
+(set_irg_current_block)(ir_graph *irg, ir_node *node) {
+ _set_irg_current_block(irg, node);
}
+entity *
+(get_irg_entity)(const ir_graph *irg) {
+ return _get_irg_entity(irg);
+}
-/* To test for a frame type */
-int
-is_frame_type(type *ftp) {
- return ((is_class_type(ftp) || is_struct_type(ftp)) &&
- id_is_suffix(id_from_str(FRAME_TP_SUFFIX, strlen(FRAME_TP_SUFFIX)),
- get_type_ident(ftp)));
+void
+(set_irg_entity)(ir_graph *irg, entity *ent) {
+ _set_irg_entity(irg, ent);
+}
+
+ir_type *
+(get_irg_frame_type)(ir_graph *irg) {
+ return _get_irg_frame_type(irg);
+}
+
+void
+(set_irg_frame_type)(ir_graph *irg, ir_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)(const ir_graph *irg) {
+ return _get_irg_obstack(irg);
+}
+
+/*
+ * 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)
+{
+ struct _obstack_chunk *p;
+
+ /*
+ * checks weather the ir_node pointer is 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;
+ }
+
+ return 0;
}
irg_phase_state
-get_irg_phase_state (ir_graph *irg) {
- return irg->phase_state;
+(get_irg_phase_state)(const 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_state)(ir_graph *irg, irg_phase_state state) {
+ _set_irg_phase_state(irg, state);
}
-op_pinned
-get_irg_pinned (ir_graph *irg) {
- return irg->pinned;
+op_pin_state
+(get_irg_pinned)(const 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)(const 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_extblk_state
+(get_irg_extblk_state)(const ir_graph *irg) {
+ return _get_irg_extblk_state(irg);
+}
+
+void
+(set_irg_extblk_inconsistent)(ir_graph *irg) {
+ _set_irg_extblk_inconsistent(irg);
+}
+
+irg_dom_state
+(get_irg_dom_state)(const ir_graph *irg) {
+ return _get_irg_dom_state(irg);
}
irg_dom_state
-get_irg_dom_state(ir_graph *irg) {
- return irg->dom_state;
+(get_irg_postdom_state)(const ir_graph *irg) {
+ return _get_irg_postdom_state(irg);
}
void
-set_irg_dom_inconsistent(ir_graph *irg) {
- irg->dom_state = dom_inconsistent;
+(set_irg_doms_inconsistent)(ir_graph *irg) {
+ _set_irg_doms_inconsistent(irg);
}
-INLINE void
-set_irg_pinned (ir_graph *irg, op_pinned p) {
- irg->pinned = p;
+irg_loopinfo_state
+(get_irg_loopinfo_state)(const ir_graph *irg) {
+ return _get_irg_loopinfo_state(irg);
}
-INLINE void
-set_irg_link (ir_graph *irg, void *thing) {
- irg->link = thing;
+void
+(set_irg_loopinfo_state)(ir_graph *irg, irg_loopinfo_state s) {
+ _set_irg_loopinfo_state(irg, s);
}
-INLINE void *
-get_irg_link (ir_graph *irg) {
- return irg->link;
+void
+(set_irg_loopinfo_inconsistent)(ir_graph *irg) {
+ _set_irg_loopinfo_inconsistent(irg);
}
-/* maximum visited flag content of all ir_graph visited fields. */
-static int max_irg_visited = 0;
+void set_irp_loopinfo_inconsistent(void) {
+ int i, n_irgs = get_irp_n_irgs();
+ for (i = 0; i < n_irgs; ++i) {
+ set_irg_loopinfo_inconsistent(get_irp_irg(i));
+ }
+}
+
+
+
+void
+(set_irg_pinned)(ir_graph *irg, op_pin_state p) {
+ _set_irg_pinned(irg, p);
+}
+
+irg_callee_info_state
+(get_irg_callee_info_state)(const ir_graph *irg) {
+ return _get_irg_callee_info_state(irg);
+}
+
+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)(const ir_graph *irg) {
+ return _get_irg_inline_property(irg);
+}
+
+void
+(set_irg_inline_property)(ir_graph *irg, irg_inline_property s) {
+ _set_irg_inline_property(irg, s);
+}
+
+unsigned
+(get_irg_additional_properties)(const ir_graph *irg) {
+ return _get_irg_additional_properties(irg);
+}
+
+void
+(set_irg_additional_properties)(ir_graph *irg, unsigned property_mask) {
+ _set_irg_additional_properties(irg, property_mask);
+}
+
+void
+(set_irg_additional_property)(ir_graph *irg, mtp_additional_property flag) {
+ _set_irg_additional_property(irg, flag);
+}
+
+void
+(set_irg_link)(ir_graph *irg, void *thing) {
+ _set_irg_link(irg, thing);
+}
+
+void *
+(get_irg_link)(const ir_graph *irg) {
+ return _get_irg_link(irg);
+}
+
+/** maximum visited flag content of all ir_graph visited fields. */
+static unsigned long max_irg_visited = 0;
unsigned long
-get_irg_visited (ir_graph *irg)
-{
- return irg->visited;
+(get_irg_visited)(const ir_graph *irg) {
+ return _get_irg_visited(irg);
}
void
unsigned long
get_max_irg_visited(void)
{
- //int i;
- //for(i = 0; i < get_irp_n_irgs(); i++)
- // assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
+ /*
+ 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;
}
unsigned long
inc_max_irg_visited(void)
{
- //int i;
- // for(i = 0; i < get_irp_n_irgs(); i++)
- //assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
+ /*
+ 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;
}
unsigned long
-get_irg_block_visited (ir_graph *irg)
-{
- return irg->block_visited;
+(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)
-{
- 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)
+(inc_irg_block_visited)(ir_graph *irg) {
+ _inc_irg_block_visited(irg);
+}
+
+/* Return the floating point model of this graph. */
+unsigned (get_irg_fp_model)(const ir_graph *irg) {
+ return _get_irg_fp_model(irg);
+}
+
+/* Sets the floating point model for this graph. */
+void set_irg_fp_model(ir_graph *irg, unsigned model) {
+ irg->fp_model = model;
+}
+
+/**
+ * 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);
+ }
+}
+
+/* move Proj nodes 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);
+}
+
+/* set a description for local value n */
+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 = xcalloc(sizeof(*irg->loc_descriptions), irg->n_loc);
+
+ irg->loc_descriptions[n] = description;
+}
+
+/* get the description for local value n */
+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;
+}
+
+/* Returns a estimated node count of the irg. */
+unsigned (get_irg_estimated_node_cnt)(const ir_graph *irg) {
+ return _get_irg_estimated_node_cnt(irg);
+}
+
+/* Returns the last irn index for this graph. */
+unsigned get_irg_last_idx(const ir_graph *irg) {
+ return irg->last_node_idx;
+}
+
+/* register additional space in an IR graph */
+size_t register_additional_graph_data(size_t size)
{
- ++irg->block_visited;
+ assert(!forbid_new_data && "Too late to register additional node data");
+
+ if (forbid_new_data)
+ return 0;
+
+ return additional_graph_data_size += size;
}
projects / libfirm / blobdiff