/*
- * Project: libFIRM
- * File name: ir/ir/irgraph.c
- * Purpose: Entry point to the representation of procedure code -- internal header.
- * 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.
- */
-
-/**
- * @file irgraph_t.h
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
- * ir graph construction.
+ * This file is part of libFirm.
*
- * @author Martin Trapp, Christian Schaefer
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
*/
+/**
+ * @file
+ * @brief Entry point to the representation of procedure code -- internal header.
+ * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
+ */
+#ifndef FIRM_IR_IRGRAPH_T_H
+#define FIRM_IR_IRGRAPH_T_H
-#ifndef _IRGRAPH_T_H_
-#define _IRGRAPH_T_H_
-
+#include "firm_types.h"
#include "irgraph.h"
-#include "firm_common_t.h"
-#include "irtypeinfo.h"
+#include "irtypes.h"
#include "irprog.h"
-#include "pseudo_irg.h"
+#include "type_t.h"
+#include "entity_t.h"
+#include "iredgekinds.h"
#include "irloop.h"
#include "obst.h"
#include "pset.h"
-#include "type_t.h"
+#include "set.h"
+/** Suffix that is added to every frame type. */
#define FRAME_TP_SUFFIX "frame_tp"
-/** ir_graph holds all information for a procedure */
-struct ir_graph {
- firm_kind kind; /**< always set to k_ir_graph*/
- /* -- Basics of the representation -- */
- struct entity *ent; /**< The entity of this procedure, i.e.,
- the type of the procedure and the
- class it belongs to. */
- struct type *frame_type; /**< A class type representing the stack frame.
- Can include "inner" methods. */
- struct ir_node *start_block; /**< block the start node will belong to */
- struct ir_node *start; /**< start node of this ir_graph */
- struct ir_node *end_block; /**< block the end node will belong to */
- struct ir_node *end; /**< end node of this ir_graph */
- struct ir_node *end_reg; /**< end node of this ir_graph */
- struct ir_node *end_except; /**< end node of this ir_graph */
- struct ir_node *cstore; /**< constant store -- no more needed!! */
- struct ir_node *frame; /**< method's frame */
- struct ir_node *globals; /**< pointer to the data segment containing all
- globals as well as global procedures. */
- struct ir_node *initial_mem; /**< initial memory of this graph */
- struct ir_node *args; /**< methods arguments */
- struct ir_node *bad; /**< bad node of this ir_graph, the one and
- only in this graph */
- struct ir_node *no_mem; /**< NoMem node of this ir_graph, the one and
- only in this graph */
- /* GL removed: we need unknown with mode for analyses. */
- /* struct ir_node *unknown;*/ /**< unknown node of this ir_graph */
- struct obstack *obst; /**< obstack where all of the ir_nodes live */
- struct ir_node *current_block; /**< block for newly gen_*()-erated
- ir_nodes */
-
- /* -- Fields indicating different states of irgraph -- */
- irg_phase_state phase_state; /**< compiler phase */
- op_pin_state op_pin_state_pinned; /**< Flag for status of nodes */
- irg_outs_state outs_state; /**< Out edges. */
- irg_dom_state dom_state; /**< Dominator information */
- irg_typeinfo_state typeinfo_state; /**< Validity of type information */
- irg_callee_info_state callee_info_state; /**< Validity of callee information */
- irg_inline_property inline_property; /**< How to handle inlineing. */
- irg_loopinfo_state loopinfo_state; /**< state of loop information */
-
- /* -- Fields for construction -- */
-#if USE_EXPLICIT_PHI_IN_STACK
- struct Phi_in_stack *Phi_in_stack; /**< needed for automatic Phi construction */
-#endif
- int n_loc; /**< number of local variable in this
- procedure including procedure parameters. */
-
- /* -- Fields for optimizations / analysis information -- */
- pset *value_table; /**< hash table for global value numbering (cse)
- for optimizing use in iropt.c */
- struct ir_node **outs; /**< Space for the out arrays. */
-
-#ifdef DEBUG_libfirm
- int n_outs; /* < Size wasted for outs */
-#endif /* defined DEBUG_libfirm */
- struct ir_loop *loop; /**< The outermost loop */
- void *link; /**< A void* field to link any information to
- the node. */
-
- ir_graph **callers; /**< For callgraph analyses. */
- int *caller_isbe; /**< For callgraph analyses: set if backedge. */
- ir_graph **callees; /**< For callgraph analyses. */
- int *callee_isbe; /**< For callgraph analyses: set if backedge. */
- int callgraph_loop_depth;
- int callgraph_recursion_depth;
- ir_loop *l;
-
- /* -- Fields for Walking the graph -- */
- unsigned long visited; /**< this flag is an identifier for
- ir walk. it will be incremented
- every time someone walks through
- the graph */
- unsigned long block_visited; /**< same as visited, for a complete block */
-#ifdef DEBUG_libfirm
- int graph_nr; /**< a unique graph number for each graph to make output
- readable. */
-#endif
-};
+/**
+ * Initializes the graph construction module.
+ */
+void firm_init_irgraph(void);
/**
- * Initializes the graph construction module
+ * Set the number of locals for a given graph.
+ *
+ * @param irg the graph
+ * @param n_loc number of locals
*/
-void init_irgraph(void);
+void irg_set_nloc(ir_graph *res, int n_loc);
-/* Internal constructor that does not add to irp_irgs or the like. */
-ir_graph *new_r_ir_graph (entity *ent, int n_loc);
+/**
+ * Internal constructor that does not add to irp_irgs or the like.
+ */
+ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc);
-/** Make a rudimentary ir graph for the constant code.
- Must look like a correct irg, spare everything else. */
+/**
+ * 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);
+/**
+ * Create a new graph that is a copy of a given one.
+ * Uses the link fields of the original graphs.
+ *
+ * @param irg The graph that must be copied.
+ */
+ir_graph *create_irg_copy(ir_graph *irg);
+
/**
* Set the op_pin_state_pinned state of a graph.
*
* @param irg the IR graph
* @param p new pin state
*/
-INLINE void
-set_irg_pinned (ir_graph *irg, op_pin_state p);
+void set_irg_pinned(ir_graph *irg, op_pin_state p);
/** Returns the obstack associated with the graph. */
struct obstack *get_irg_obstack(const ir_graph *irg);
* @param irg the IR graph
* @param n the IR node
*/
-int node_is_in_irgs_storage(ir_graph *irg, ir_node *n);
+int node_is_in_irgs_storage(const ir_graph *irg, const ir_node *n);
/*-------------------------------------------------------------------*/
/* inline functions for graphs */
/*-------------------------------------------------------------------*/
-extern int __interprocedural_view;
+static inline int is_ir_graph_(const void *thing)
+{
+ return (get_kind(thing) == k_ir_graph);
+}
-static INLINE int
-__get_interprocedural_view(void) {
- return __interprocedural_view;
+/** Returns the start block of a graph. */
+static inline ir_node *get_irg_start_block_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_start_block);
}
-static INLINE int
-__is_ir_graph(const void *thing) {
- return (get_kind(thing) == k_ir_graph);
+static inline void set_irg_start_block_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_start_block, node);
}
-/** Returns the start block of a graph. */
-static INLINE ir_node *
-__get_irg_start_block(const ir_graph *irg) {
- return irg->start_block;
+static inline ir_node *get_irg_start_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_start);
}
-static INLINE void
-__set_irg_start_block(ir_graph *irg, ir_node *node) {
- irg->start_block = node;
+static inline void set_irg_start_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_start, node);
}
-static INLINE ir_node *
-__get_irg_start(const ir_graph *irg) {
- return irg->start;
+static inline ir_node *get_irg_end_block_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_end_block);
}
-static INLINE void
-__set_irg_start(ir_graph *irg, ir_node *node) {
- irg->start = node;
+static inline void set_irg_end_block_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_end_block, node);
}
-static INLINE ir_node *
-__get_irg_end_block(const ir_graph *irg) {
- return irg->end_block;
+static inline ir_node *get_irg_end_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_end);
}
-static INLINE void
-__set_irg_end_block(ir_graph *irg, ir_node *node) {
- irg->end_block = node;
+static inline void set_irg_end_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_end, node);
}
-static INLINE ir_node *
-__get_irg_end(const ir_graph *irg) {
- return irg->end;
+static inline ir_node *get_irg_initial_exec_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_initial_exec);
}
-static INLINE void
-__set_irg_end(ir_graph *irg, ir_node *node) {
- irg->end = node;
+static inline void set_irg_initial_exec_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_initial_exec, node);
}
-static INLINE ir_node *
-__get_irg_end_reg(const ir_graph *irg) {
- return irg->end_reg;
+static inline ir_node *get_irg_frame_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_frame);
}
-static INLINE ir_node *
-__get_irg_end_except (const ir_graph *irg) {
- return irg->end_except;
+static inline void set_irg_frame_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_frame, node);
}
-static INLINE ir_node *
-__get_irg_cstore(const ir_graph *irg) {
- return irg->cstore;
+static inline ir_node *get_irg_initial_mem_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_initial_mem);
}
-static INLINE void
-__set_irg_cstore(ir_graph *irg, ir_node *node) {
- irg->cstore = node;
+static inline void set_irg_initial_mem_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_initial_mem, node);
}
-static INLINE ir_node *
-__get_irg_frame(const ir_graph *irg) {
- return irg->frame;
+static inline ir_node *get_irg_args_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_args);
}
-static INLINE void
-__set_irg_frame(ir_graph *irg, ir_node *node) {
- irg->frame = node;
+static inline void set_irg_args_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_args, node);
}
-static INLINE ir_node *
-__get_irg_globals(const ir_graph *irg) {
- return irg->globals;
+static inline ir_node *get_irg_no_mem_(const ir_graph *irg)
+{
+ return get_irn_n(irg->anchor, anchor_no_mem);
}
-static INLINE void
-__set_irg_globals(ir_graph *irg, ir_node *node) {
- irg->globals = node;
+static inline void set_irg_no_mem_(ir_graph *irg, ir_node *node)
+{
+ set_irn_n(irg->anchor, anchor_no_mem, node);
}
-static INLINE ir_node *
-__get_irg_initial_mem(const ir_graph *irg) {
- return irg->initial_mem;
+static inline ir_entity *get_irg_entity_(const ir_graph *irg)
+{
+ return irg->ent;
}
-static INLINE void
-__set_irg_initial_mem(ir_graph *irg, ir_node *node) {
- irg->initial_mem = node;
+static inline void set_irg_entity_(ir_graph *irg, ir_entity *ent)
+{
+ irg->ent = ent;
}
-static INLINE ir_node *
-__get_irg_args(const ir_graph *irg) {
- return irg->args;
+static inline ir_type *get_irg_frame_type_(ir_graph *irg)
+{
+ assert(irg->frame_type);
+ return irg->frame_type;
}
-static INLINE void
-__set_irg_args(ir_graph *irg, ir_node *node) {
- irg->args = node;
+static inline void set_irg_frame_type_(ir_graph *irg, ir_type *ftp)
+{
+ assert(is_frame_type(ftp));
+ irg->frame_type = ftp;
}
-static INLINE ir_node *
-__get_irg_bad(const ir_graph *irg) {
- return irg->bad;
+static inline struct obstack *get_irg_obstack_(const ir_graph *irg)
+{
+ return irg->obst;
}
-static INLINE void
-__set_irg_bad(ir_graph *irg, ir_node *node) {
- irg->bad = node;
+
+static inline irg_phase_state get_irg_phase_state_(const ir_graph *irg)
+{
+ return irg->phase_state;
}
-static INLINE ir_node *
-__get_irg_no_mem(const ir_graph *irg) {
- return irg->no_mem;
+static inline void set_irg_phase_state_(ir_graph *irg, irg_phase_state state)
+{
+ irg->phase_state = state;
}
-static INLINE void
-__set_irg_no_mem(ir_graph *irg, ir_node *node) {
- irg->no_mem = node;
+static inline op_pin_state get_irg_pinned_(const ir_graph *irg)
+{
+ return irg->irg_pinned_state;
}
-static INLINE ir_node *
-__get_irg_current_block(const ir_graph *irg) {
- return irg->current_block;
+
+static inline void set_irg_pinned_(ir_graph *irg, op_pin_state p)
+{
+ irg->irg_pinned_state = p;
}
-static INLINE void
-__set_irg_current_block(ir_graph *irg, ir_node *node) {
- irg->current_block = node;
+static inline irg_callee_info_state get_irg_callee_info_state_(const ir_graph *irg)
+{
+ return irg->callee_info_state;
}
-static INLINE entity *
-__get_irg_entity(const ir_graph *irg) {
- assert(irg && irg->ent);
- return irg->ent;
+static inline void set_irg_callee_info_state_(ir_graph *irg, irg_callee_info_state s)
+{
+ irg_callee_info_state irp_state = get_irp_callee_info_state();
+
+ irg->callee_info_state = s;
+
+ /* I could compare ... but who knows? */
+ if ((irp_state == irg_callee_info_consistent) ||
+ ((irp_state == irg_callee_info_inconsistent) && (s == irg_callee_info_none)))
+ set_irp_callee_info_state(s);
}
-static INLINE void
-__set_irg_entity(ir_graph *irg, entity *ent) {
- irg->ent = ent;
+static inline irg_inline_property get_irg_inline_property_(const ir_graph *irg)
+{
+ return irg->inline_property;
}
-static INLINE type *
-__get_irg_frame_type(const ir_graph *irg) {
- assert(irg && irg->frame_type);
- return irg->frame_type;
+static inline void set_irg_inline_property_(ir_graph *irg, irg_inline_property s)
+{
+ irg->inline_property = s;
}
-static INLINE void
-__set_irg_frame_type(ir_graph *irg, type *ftp) {
- assert(is_class_type(ftp));
- irg->frame_type = ftp;
+static inline mtp_additional_properties get_irg_additional_properties_(const ir_graph *irg)
+{
+ if (irg->additional_properties & mtp_property_inherited)
+ return get_method_additional_properties(get_entity_type(irg->ent));
+ return irg->additional_properties;
}
-static INLINE struct obstack *
-__get_irg_obstack(const ir_graph *irg) {
- return irg->obst;
+static inline void set_irg_additional_properties_(ir_graph *irg, mtp_additional_properties mask)
+{
+ irg->additional_properties = mask & ~mtp_property_inherited;
}
+static inline void add_irg_additional_properties_(ir_graph *irg, mtp_additional_properties flag)
+{
+ mtp_additional_properties prop = irg->additional_properties;
-static INLINE irg_phase_state
-__get_irg_phase_state(const ir_graph *irg) {
- return irg->phase_state;
+ if (prop & mtp_property_inherited)
+ prop = get_method_additional_properties(get_entity_type(irg->ent));
+ irg->additional_properties = prop | flag;
}
-static INLINE void
-__set_irg_phase_low(ir_graph *irg) {
- irg->phase_state = phase_low;
+static inline void set_irg_link_(ir_graph *irg, void *thing)
+{
+ irg->link = thing;
}
-static INLINE op_pin_state
-__get_irg_pinned(const ir_graph *irg) {
- return irg->op_pin_state_pinned;
+static inline void *get_irg_link_(const ir_graph *irg)
+{
+ return irg->link;
}
-static INLINE irg_outs_state
-__get_irg_outs_state(const ir_graph *irg) {
- return irg->outs_state;
+static inline ir_visited_t get_irg_visited_(const ir_graph *irg)
+{
+ return irg->visited;
}
-static INLINE void
-__set_irg_outs_inconsistent(ir_graph *irg) {
- irg->outs_state = outs_inconsistent;
+static inline ir_visited_t get_irg_block_visited_(const ir_graph *irg)
+{
+ return irg->block_visited;
}
-static INLINE irg_dom_state
-__get_irg_dom_state(const ir_graph *irg) {
- return irg->dom_state;
+static inline void set_irg_block_visited_(ir_graph *irg, ir_visited_t visited)
+{
+ irg->block_visited = visited;
}
-static INLINE void
-__set_irg_dom_inconsistent(ir_graph *irg) {
- irg->dom_state = dom_inconsistent;
+static inline void inc_irg_block_visited_(ir_graph *irg)
+{
+ ++irg->block_visited;
}
-static INLINE irg_loopinfo_state
-__get_irg_loopinfo_state(const ir_graph *irg) {
- return irg->loopinfo_state;
+static inline void dec_irg_block_visited_(ir_graph *irg)
+{
+ --irg->block_visited;
}
-static INLINE void
-__set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s) {
- irg->loopinfo_state = s;
+static inline unsigned get_irg_estimated_node_cnt_(const ir_graph *irg)
+{
+ return irg->estimated_node_count;
}
-static INLINE void
-__set_irg_pinned(ir_graph *irg, op_pin_state p) {
- irg->op_pin_state_pinned = p;
+/* Return the floating point model of this graph. */
+static inline unsigned get_irg_fp_model_(const ir_graph *irg)
+{
+ return irg->fp_model;
}
-static INLINE irg_callee_info_state
-__get_irg_callee_info_state(const ir_graph *irg) {
- return irg->callee_info_state;
+static inline int irg_is_constrained_(const ir_graph *irg,
+ ir_graph_constraints_t constraints)
+{
+ return (irg->constraints & constraints) == constraints;
}
-static INLINE void
-__set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s) {
- irg_callee_info_state irp_state = get_irp_callee_info_state();
-
- irg->callee_info_state = s;
-
- /* I could compare ... but who knows? */
- if ((irp_state == irg_callee_info_consistent) ||
- ((irp_state == irg_callee_info_inconsistent) && (s == irg_callee_info_none)))
- set_irp_callee_info_state(s);
+static inline void add_irg_properties_(ir_graph *irg,
+ ir_graph_properties_t props)
+{
+ irg->properties |= props;
}
-static INLINE irg_inline_property
-__get_irg_inline_property(const ir_graph *irg) {
- return irg->inline_property;
+static inline void clear_irg_properties_(ir_graph *irg,
+ ir_graph_properties_t props)
+{
+ irg->properties &= ~props;
}
-static INLINE void
-__set_irg_inline_property(ir_graph *irg, irg_inline_property s) {
- irg->inline_property = s;
+static inline int irg_has_properties_(const ir_graph *irg,
+ ir_graph_properties_t props)
+{
+ return (irg->properties & props) == props;
}
-static INLINE void
-__set_irg_link(ir_graph *irg, void *thing) {
- irg->link = thing;
-}
+/**
+ * Allocates a new idx in the irg for the node and adds the irn to the idx -> irn map.
+ * @param irg The graph.
+ * @param irn The node.
+ * @return The index allocated for the node.
+ */
+static inline unsigned irg_register_node_idx(ir_graph *irg, ir_node *irn)
+{
+ unsigned idx = irg->last_node_idx++;
+ if (idx >= (unsigned)ARR_LEN(irg->idx_irn_map))
+ ARR_RESIZE(ir_node *, irg->idx_irn_map, idx + 1);
-static INLINE void *
-__get_irg_link(const ir_graph *irg) {
- return irg->link;
+ irg->idx_irn_map[idx] = irn;
+ return idx;
}
-static INLINE unsigned long
-__get_irg_visited(const ir_graph *irg) {
- return irg->visited;
+/**
+ * Kill a node from the irg. BEWARE: this kills
+ * all later created nodes.
+ */
+static inline void irg_kill_node(ir_graph *irg, ir_node *n)
+{
+ unsigned idx = get_irn_idx(n);
+ assert(idx + 1 == irg->last_node_idx);
+
+ if (idx + 1 == irg->last_node_idx)
+ --irg->last_node_idx;
+ irg->idx_irn_map[idx] = NULL;
+ obstack_free(irg->obst, n);
}
-static INLINE unsigned long
-__get_irg_block_visited(const ir_graph *irg) {
- return irg->block_visited;
+/**
+ * Get the node for an index.
+ * @param irg The graph.
+ * @param idx The index you want the node for.
+ * @return The node with that index or NULL, if there is no node with that index.
+ * @note The node you got might be dead.
+ */
+static inline ir_node *get_idx_irn_(const ir_graph *irg, unsigned idx)
+{
+ assert(idx < (unsigned) ARR_LEN(irg->idx_irn_map));
+ return irg->idx_irn_map[idx];
}
-static INLINE void
-__set_irg_block_visited(ir_graph *irg, unsigned long visited) {
- irg->block_visited = visited;
+/**
+ * Return the number of anchors in this graph.
+ */
+static inline int get_irg_n_anchors(const ir_graph *irg)
+{
+ return get_irn_arity(irg->anchor);
}
-static INLINE void
-__inc_irg_block_visited(ir_graph *irg) {
- ++irg->block_visited;
+/**
+ * Return anchor for given index
+ */
+static inline ir_node *get_irg_anchor(const ir_graph *irg, int idx)
+{
+ return get_irn_n(irg->anchor, idx);
}
-#define get_interprocedural_view() __get_interprocedural_view()
-#define is_ir_graph(thing) __is_ir_graph(thing)
-#define get_irg_start_block(irg) __get_irg_start_block(irg)
-#define set_irg_start_block(irg, node) __set_irg_start_block(irg, node)
-#define get_irg_start(irg) __get_irg_start(irg)
-#define set_irg_start(irg, node) __set_irg_start(irg, node)
-#define get_irg_end_block(irg) __get_irg_end_block(irg)
-#define set_irg_end_block(irg, node) __set_irg_end_block(irg, node)
-#define get_irg_end(irg) __get_irg_end(irg)
-#define set_irg_end(irg, node) __set_irg_end(irg, node)
-#define get_irg_end_reg(irg) __get_irg_end_reg(irg)
-#define get_irg_end_except(irg) __get_irg_end_except(irg)
-#define get_irg_cstore(irg) __get_irg_cstore(irg)
-#define set_irg_cstore(irg, node) __set_irg_cstore(irg, node)
-#define get_irg_frame(irg) __get_irg_frame(irg)
-#define set_irg_frame(irg, node) __set_irg_frame(irg, node)
-#define get_irg_globals(irg) __get_irg_globals(irg)
-#define set_irg_globals(irg, node) __set_irg_globals(irg, node)
-#define get_irg_initial_mem(irg) __get_irg_initial_mem(irg)
-#define set_irg_initial_mem(irg, node) __set_irg_initial_mem(irg, node)
-#define get_irg_args(irg) __get_irg_args(irg)
-#define set_irg_args(irg, node) __set_irg_args(irg, node)
-#define get_irg_bad(irg) __get_irg_bad(irg)
-#define set_irg_bad(irg, node) __set_irg_bad(irg, node)
-#define get_irg_no_mem(irg) __get_irg_no_mem(irg)
-#define set_irg_no_mem(irg, node) __set_irg_no_mem(irg, node)
-#define get_irg_current_block(irg) __get_irg_current_block(irg)
-#define set_irg_current_block(irg, node) __set_irg_current_block(irg, node)
-#define get_irg_entity(irg) __get_irg_entity(irg)
-#define set_irg_entity(irg, ent) __set_irg_entity(irg, ent)
-#define get_irg_frame_type(irg) __get_irg_frame_type(irg)
-#define set_irg_frame_type(irg, ftp) __set_irg_frame_type(irg, ftp)
-#define get_irg_obstack(irg) __get_irg_obstack(irg)
-#define get_irg_phase_state(irg) __get_irg_phase_state(irg)
-#define set_irg_phase_low(irg) __set_irg_phase_low(irg)
-#define get_irg_pinned(irg) __get_irg_pinned(irg)
-#define get_irg_outs_state(irg) __get_irg_outs_state(irg)
-#define set_irg_outs_inconsistent(irg) __set_irg_outs_inconsistent(irg)
-#define get_irg_dom_state(irg) __get_irg_dom_state(irg)
-#define set_irg_dom_inconsistent(irg) __set_irg_dom_inconsistent(irg)
-#define get_irg_loopinfo_state(irg) __get_irg_loopinfo_state(irg)
-#define set_irg_loopinfo_state(irg, s) __set_irg_loopinfo_state(irg, s)
-#define set_irg_pinned(irg, p) __set_irg_pinned(irg, p)
-#define get_irg_callee_info_state(irg) __get_irg_callee_info_state(irg)
-#define set_irg_callee_info_state(irg, s) __set_irg_callee_info_state(irg, s)
-#define get_irg_inline_property(irg) __get_irg_inline_property(irg)
-#define set_irg_inline_property(irg, s) __set_irg_inline_property(irg, s)
-#define set_irg_link(irg, thing) __set_irg_link(irg, thing)
-#define get_irg_link(irg) __get_irg_link(irg)
-#define get_irg_visited(irg) __get_irg_visited(irg)
-#define get_irg_block_visited(irg) __get_irg_block_visited(irg)
-#define set_irg_block_visited(irg, v) __set_irg_block_visited(irg, v)
-#define inc_irg_block_visited(irg) __inc_irg_block_visited(irg)
-
-# endif /* _IRGRAPH_T_H_ */
+/**
+ * Set anchor for given index
+ */
+static inline void set_irg_anchor(ir_graph *irg, int idx, ir_node *irn)
+{
+ set_irn_n(irg->anchor, idx, irn);
+}
+
+
+#define is_ir_graph(thing) is_ir_graph_(thing)
+#define get_irg_start_block(irg) get_irg_start_block_(irg)
+#define set_irg_start_block(irg, node) set_irg_start_block_(irg, node)
+#define get_irg_start(irg) get_irg_start_(irg)
+#define set_irg_start(irg, node) set_irg_start_(irg, node)
+#define get_irg_end_block(irg) get_irg_end_block_(irg)
+#define set_irg_end_block(irg, node) set_irg_end_block_(irg, node)
+#define get_irg_end(irg) get_irg_end_(irg)
+#define set_irg_end(irg, node) set_irg_end_(irg, node)
+#define get_irg_initial_exec(irg) get_irg_initial_exec_(irg)
+#define set_irg_initial_exec(irg, node) set_irg_initial_exec_(irg, node)
+#define get_irg_frame(irg) get_irg_frame_(irg)
+#define set_irg_frame(irg, node) set_irg_frame_(irg, node)
+#define get_irg_initial_mem(irg) get_irg_initial_mem_(irg)
+#define set_irg_initial_mem(irg, node) set_irg_initial_mem_(irg, node)
+#define get_irg_args(irg) get_irg_args_(irg)
+#define set_irg_args(irg, node) set_irg_args_(irg, node)
+#define get_irg_no_mem(irg) get_irg_no_mem_(irg)
+#define set_irn_no_mem(irg, node) set_irn_no_mem_(irg, node)
+#define get_irg_entity(irg) get_irg_entity_(irg)
+#define set_irg_entity(irg, ent) set_irg_entity_(irg, ent)
+#define get_irg_frame_type(irg) get_irg_frame_type_(irg)
+#define set_irg_frame_type(irg, ftp) set_irg_frame_type_(irg, ftp)
+#define get_irg_obstack(irg) get_irg_obstack_(irg)
+#define get_irg_phase_state(irg) get_irg_phase_state_(irg)
+#define set_irg_phase_state(irg, state) set_irg_phase_state_(irg, state)
+#define get_irg_pinned(irg) get_irg_pinned_(irg)
+#define set_irg_pinned(irg, p) set_irg_pinned_(irg, p)
+#define get_irg_callee_info_state(irg) get_irg_callee_info_state_(irg)
+#define set_irg_callee_info_state(irg, s) set_irg_callee_info_state_(irg, s)
+#define get_irg_inline_property(irg) get_irg_inline_property_(irg)
+#define set_irg_inline_property(irg, s) set_irg_inline_property_(irg, s)
+#define get_irg_additional_properties(irg) get_irg_additional_properties_(irg)
+#define set_irg_additional_properties(irg, m) set_irg_additional_properties_(irg, m)
+#define set_irg_additional_property(irg, f) set_irg_additional_property_(irg, f)
+#define set_irg_link(irg, thing) set_irg_link_(irg, thing)
+#define get_irg_link(irg) get_irg_link_(irg)
+#define get_irg_visited(irg) get_irg_visited_(irg)
+#define get_irg_block_visited(irg) get_irg_block_visited_(irg)
+#define set_irg_block_visited(irg, v) set_irg_block_visited_(irg, v)
+#define inc_irg_block_visited(irg) inc_irg_block_visited_(irg)
+#define dec_irg_block_visited(irg) dec_irg_block_visited_(irg)
+#define get_irg_estimated_node_cnt(irg) get_irg_estimated_node_cnt_(irg)
+#define get_irg_fp_model(irg) get_irg_fp_model_(irg)
+#define get_idx_irn(irg, idx) get_idx_irn_(irg, idx)
+#define irg_is_constrained(irg, constraints) irg_is_constrained_(irg, constraints)
+#define add_irg_properties(irg, props) add_irg_properties_(irg, props)
+#define clear_irg_properties(irg, props) clear_irg_properties_(irg, props)
+#define irg_has_properties(irg, props) irg_has_properties_(irg, props)
+
+#endif
projects / libfirm / blobdiff