Do not use get_nodes_block(). It is now available when global CSE is enabled
[libfirm] / ir / ir / irnode_t.h
index 5cc3bc4..016e93f 100644 (file)
@@ -3,7 +3,7 @@
  * File name:   ir/ir/irnode_t.h
  * Purpose:     Representation of an intermediate operation -- private header.
  * Author:      Martin Trapp, Christian Schaefer
- * Modified by: Goetz Lindenmaier
+ * Modified by: Goetz Lindenmaier, Michael Beck
  * Created:
  * CVS-ID:      $Id$
  * Copyright:   (c) 1998-2003 Universität Karlsruhe
@@ -17,9 +17,8 @@
  *
  * @author Martin Trapp, Christian Schaefer
  */
-
-# ifndef _IRNODE_T_H_
-# define _IRNODE_T_H_
+#ifndef _IRNODE_T_H_
+#define _IRNODE_T_H_
 
 #include "firm_config.h"
 #include "irnode.h"
@@ -40,7 +39,7 @@
 #include "irextbb_t.h"
 
 
-/** ir node attributes **/
+/** IR node attributes **/
 
 /** Block attributes */
 typedef struct {
@@ -50,95 +49,86 @@ typedef struct {
   /* Attributes private to construction: */
   unsigned matured:1;         /**< if set, all in-nodes of the block are fixed */
   unsigned dead:1;            /**< if set, the block is dead (and could be replace by a Bad */
-  struct ir_node **graph_arr; /**< array to store all parameters */
+  ir_node **graph_arr;        /**< array to store all parameters */
   /* Attributes holding analyses information */
-  struct dom_info dom;        /**< Datastructure that holds information about dominators.
-                 @@@ @todo
-                 Eventually overlay with graph_arr as only valid
-                 in different phases.  Eventually inline the whole
-                 datastructure. */
-  /*   exc_t exc;  */            /**< role of this block for exception handling */
-  /*   ir_node *handler_entry; */    /**< handler entry block iff this block is part of a region */
+  dom_info dom;               /**< Datastructure that holds information about dominators.
+                                   @@@ @todo
+                                   Eventually overlay with graph_arr as only valid
+                                   in different phases.  Eventually inline the whole
+                                   datastructure. */
+  dom_info pdom;              /**< Datastructure that holds information about post-dominators. */
   ir_node ** in_cg;           /**< array with predecessors in
-                   * interprocedural_view, if they differ
-                   * from intraprocedural predecessors */
+                               * interprocedural_view, if they differ
+                               * from intraprocedural predecessors */
   int *backedge;              /**< Field n set to true if pred n is backedge.
-                     @@@ @todo Ev. replace by bitfield! */
+                                   @@@ @todo Ev. replace by bit field! */
   int *cg_backedge;           /**< Field n set to true if pred n is interprocedural backedge.
-                     @@@ @todo Ev. replace by bitfield! */
+                                   @@@ @todo Ev. replace by bit field! */
   ir_extblk *extblk;          /**< the extended basic block this block belongs to */
 
   struct list_head succ_head; /**< A list head for all successor edges of a block. */
 
 } block_attr;
 
-/** Start attributes */
-typedef struct {
-  char dummy;
-  /*   ir_graph *irg;   @@@ now in block */
-} start_attr;
-
-/** Cond attributes */
+/** Cond attributes. */
 typedef struct {
   cond_kind kind;           /**< flavor of Cond */
   long default_proj;        /**< only for non-binary Conds: biggest Proj number, i.e. the one used for default. */
   cond_jmp_predicate pred;  /**< only for binary Conds: The jump predication. */
 } cond_attr;
 
-/** Const attributes */
+/** Const attributes. */
 typedef struct {
   tarval  *tv;       /**< the target value */
   ir_type *tp;       /**< the source type, for analyses. default: type_unknown. */
 } const_attr;
 
+/** SymConst attributes. */
 typedef struct {
   symconst_symbol sym;  // old tori
   symconst_kind num;
   ir_type *tp;       /**< the source type, for analyses. default: type_unknown. */
 } symconst_attr;
 
-/** Sel attributes */
+/** Sel attributes. */
 typedef struct {
   entity *ent;          /**< entity to select */
 } sel_attr;
 
-/** Exception attributes */
+/** Exception attributes. */
 typedef struct {
-  op_pin_state   pin_state;     /**< the pin state for operations that might generate a exception:
-                                     If it's know that no exception will be generated, could be set to
-                                     op_pin_state_floats. */
 #if PRECISE_EXC_CONTEXT
   struct ir_node **frag_arr;    /**< For Phi node construction in case of exception */
 #endif
 } except_attr;
 
-/** Call attributes */
+/** Call attributes. */
 typedef struct {
   except_attr    exc;           /**< the exception attribute. MUST be the first one. */
   ir_type *cld_tp;              /**< type of called procedure */
   entity ** callee_arr;         /**< result of callee analysis */
 } call_attr;
 
-/** Alloc attributes */
+/** Alloc attributes. */
 typedef struct {
   except_attr    exc;           /**< the exception attribute. MUST be the first one. */
   ir_type *type;                /**< Type of the allocated object.  */
   where_alloc where;            /**< stack, heap or other managed part of memory */
 } alloc_attr;
 
-/** Free attributes */
+/** Free attributes. */
 typedef struct {
   ir_type *type;                /**< Type of the allocated object.  */
   where_alloc where;            /**< stack, heap or other managed part of memory */
 } free_attr;
 
-/** InstOf attributes */
+/** InstOf attributes. */
 typedef struct {
-  ir_type *ent;
-  int dfn;
+  except_attr    exc;           /**< the exception attribute. MUST be the first one. */
+  ir_type *type;                /**< the type of which the object pointer must be */
 } io_attr;
 
-/** Filter attributes */
+/** Filter attributes. */
 typedef struct {
   long proj;                 /**< contains the result position to project (Proj) */
   ir_node ** in_cg;          /**< array with interprocedural predecessors (Phi) */
@@ -146,29 +136,29 @@ typedef struct {
                      @todo Ev. replace by bitfield! */
 } filter_attr;
 
-/** EndReg/EndExcept attributes */
+/** EndReg/EndExcept attributes. */
 typedef struct {
   char dummy;
 } end_attr;
 
-/** CallBegin attributes */
+/** CallBegin attributes. */
 typedef struct {
-  ir_node * call;               /**< associated Call-operation */
+  ir_node * call;               /**< Associated Call-operation. */
 } callbegin_attr;
 
-/** Cast attributes */
+/** Cast attributes. */
 typedef struct {
-  ir_type *totype;              /**< type of the casted node */
+  ir_type *totype;              /**< Type of the casted node. */
 } cast_attr;
 
-/** Load attributes */
+/** Load attributes. */
 typedef struct {
-  except_attr    exc;           /**< the exception attribute. MUST be the first one. */
-  ir_mode        *load_mode;    /**< the mode of this Load operation */
-  ent_volatility volatility;     /**< the volatility of a Load/Store operation */
+  except_attr    exc;           /**< The exception attribute. MUST be the first one. */
+  ir_mode        *load_mode;    /**< The mode of this Load operation. */
+  ent_volatility volatility;     /**< The volatility of a Load/Store operation. */
 } load_attr;
 
-/** Store attributes */
+/** Store attributes. */
 typedef struct {
   except_attr    exc;           /**< the exception attribute. MUST be the first one. */
   ent_volatility volatility;     /**< the volatility of a Store operation */
@@ -176,37 +166,46 @@ typedef struct {
 
 typedef pn_Cmp confirm_attr;    /**< Attribute to hold compare operation */
 
-/** CopyB attribute */
+/** CopyB attribute. */
 typedef struct {
-  except_attr    exc;           /**< the exception attribute. MUST be the first one. */
-  ir_type        *data_type;    /**< type of the copied entity */
+  except_attr    exc;           /**< The exception attribute. MUST be the first one. */
+  ir_type        *data_type;    /**< Type of the copied entity. */
 } copyb_attr;
 
+/** Bound attribute. */
+typedef struct {
+  except_attr    exc;           /**< The exception attribute. MUST be the first one. */
+} bound_attr;
+
+/** Conv attribute. */
+typedef struct {
+  char           strict;        /**< If set, this is a strict Conv that cannot be removed. */
+} conv_attr;
+
 /**
  * Edge info to put into an irn.
  */
 typedef struct _irn_edge_info_t {
-  struct list_head outs_head;  /**< The list of all outs */
-  int out_count;               /**< number of outs in the list */
+  struct list_head outs_head;  /**< The list of all outs. */
+  int out_count;               /**< Number of outs in the list. */
 } irn_edge_info_t;
 
 
 /** Some IR-nodes just have one attribute, these are stored here,
    some have more. Their name is 'irnodename_attr' */
 typedef union {
-  start_attr     start; /**< For Start */
-  block_attr     block; /**< For Block: Fields needed to construct it */
-  cond_attr      c;     /**< For Cond. */
-  const_attr     con;   /**< For Const: contains the value of the constant and a type */
-  symconst_attr  i;     /**< For SymConst. */
-  sel_attr       s;     /**< For Sel. */
-  call_attr      call;  /**< For Call: pointer to the type of the method to call */
+  block_attr     block;   /**< For Block: Fields needed to construct it */
+  cond_attr      cond;    /**< For Cond. */
+  const_attr     con;     /**< For Const: contains the value of the constant and a type */
+  symconst_attr  symc;    /**< For SymConst. */
+  sel_attr       sel;     /**< For Sel. */
+  call_attr      call;    /**< For Call: pointer to the type of the method to call */
   callbegin_attr callbegin; /**< For CallBegin */
-  alloc_attr     a;    /**< For Alloc. */
-  free_attr      f   /**< For Free. */
-  io_attr        io;    /**< For InstOf */
-  cast_attr      cast;  /**< For Cast. */
-  load_attr      load;  /**< For Load. */
+  alloc_attr     alloc;  /**< For Alloc. */
+  free_attr      free;   /**< For Free. */
+  io_attr        instof; /**< For InstOf */
+  cast_attr      cast;   /**< For Cast. */
+  load_attr      load;   /**< For Load. */
   store_attr     store;  /**< For Store. */
   int            phi0_pos;  /**< For Phi. Used to remember the value defined by
                    this Phi node.  Needed when the Phi is completed
@@ -223,6 +222,8 @@ typedef union {
   end_attr       end;           /**< For EndReg, EndExcept */
   except_attr    except;        /**< For Phi node construction in case of exceptions */
   copyb_attr     copyb;         /**< For CopyB operation */
+  bound_attr     bound;         /**< For Bound operation */
+  conv_attr      conv;          /**< For Conv operation */
 } attr;
 
 
@@ -233,38 +234,42 @@ struct ir_node {
   firm_kind kind;          /**< distinguishes this node from others */
   ir_op *op;               /**< Opcode of this node. */
   ir_mode *mode;           /**< Mode of this node. */
-  struct ir_node **in;     /**< array with predecessors / operands */
-  unsigned long visited;   /**< visited counter for walks of the graph */
-  void *link;              /**< to attach additional information to the node, e.g.
+  struct ir_node **in;     /**< The array of predecessors / operands. */
+  unsigned long visited;   /**< Visited counter for walks of the graph. */
+  unsigned node_idx;       /**< The node index of this node in its graph. */
+  unsigned pinned : 1;     /**< A node is either pinned or not. */
+  void *link;              /**< To attach additional information to the node, e.g.
                               used while construction to link Phi0 nodes and
-                             during optimization to link to nodes that
-                             shall replace a node. */
+                              during optimization to link to nodes that
+                              shall replace a node. */
   /* ------- Fields for optimizations / analysis information ------- */
   struct ir_node **out;    /**< @deprecated array of out edges. */
   struct dbg_info* dbi;    /**< A pointer to information for debug support. */
   /* ------- For debugging ------- */
 #ifdef DEBUG_libfirm
-       int out_valid;
-  int node_nr;             /**< a unique node number for each node to make output
-                             readable. */
+  int out_valid;
+  long node_nr;            /**< A unique node number for each node to make output
+                                readable. */
 #endif
   /* ------- For analyses -------- */
   ir_loop *loop;           /**< the loop the node is in. Access routines in irloop.h */
-#ifdef  DO_HEAPANALYSIS
+#ifdef DO_HEAPANALYSIS
   struct abstval *av;      /**< the abstract value of this node */
   struct section *sec;
 #endif
-#if FIRM_EDGES_INPLACE
   irn_edge_info_t edge_info;  /**< everlasting out edges */
-#endif
   /* ------- Opcode depending fields -------- */
   attr attr;               /**< attribute of this node. Depends on opcode.
                               Must be last field of struct ir_node. */
 };
 
 
-/** Returns the array with the ins.  The content of the array may not be
-   changed.  */
+/**
+ * Returns the array with the ins.  The content of the array may not be
+ * changed.
+ * Note that this function returns the whole in array including the
+ * block predecessor. So, it is NOT symmetric with set_irn_in().
+ */
 ir_node     **get_irn_in            (const ir_node *node);
 
 /** @{ */
@@ -332,7 +337,7 @@ ir_op_ops *firm_set_default_get_entity_attr(opcode code, ir_op_ops *ops);
  * Intern version for libFirm.
  */
 static INLINE int
-_is_ir_node (const void *thing) {
+_is_ir_node(const void *thing) {
   return (get_kind(thing) == k_ir_node);
 }
 
@@ -341,11 +346,17 @@ _is_ir_node (const void *thing) {
  * Intern version for libFirm.
  */
 static INLINE ir_op *
-_get_irn_op (const ir_node *node) {
-  assert (node);
+_get_irn_op(const ir_node *node) {
+  assert(node);
   return node->op;
 }
 
+static INLINE void
+_set_irn_op(ir_node *node, ir_op *op) {
+  assert(node);
+  node->op = op;
+}
+
 /** Copies all attributes stored in the old node  to the new node.
     Assumes both have the same opcode and sufficient size. */
 static INLINE void
@@ -361,9 +372,9 @@ copy_node_attr(const ir_node *old_node, ir_node *new_node) {
  * Intern version for libFirm.
  */
 static INLINE opcode
-_get_irn_opcode (const ir_node *node) {
-  assert (k_ir_node == get_kind(node));
-  assert (node->op);
+_get_irn_opcode(const ir_node *node) {
+  assert(k_ir_node == get_kind(node));
+  assert(node->op);
   return node->op->code;
 }
 
@@ -372,7 +383,7 @@ _get_irn_opcode (const ir_node *node) {
  * Intern version for libFirm.
  */
 static INLINE int
-_get_irn_intra_arity (const ir_node *node) {
+_get_irn_intra_arity(const ir_node *node) {
   assert(node);
   return ARR_LEN(node->in) - 1;
 }
@@ -382,7 +393,7 @@ _get_irn_intra_arity (const ir_node *node) {
  * Intern version for libFirm.
  */
 static INLINE int
-_get_irn_inter_arity (const ir_node *node) {
+_get_irn_inter_arity(const ir_node *node) {
   assert(node);
   if (_get_irn_op(node) == op_Filter) {
     assert(node->attr.filter.in_cg);
@@ -403,7 +414,7 @@ extern int (*_get_irn_arity)(const ir_node *node);
  * Intern version for libFirm.
  */
 static INLINE ir_node *
-_get_irn_intra_n (const ir_node *node, int n) {
+_get_irn_intra_n(const ir_node *node, int n) {
   ir_node *nn;
 
   assert(node); assert(-1 <= n && n < _get_irn_intra_arity(node));
@@ -418,7 +429,7 @@ _get_irn_intra_n (const ir_node *node, int n) {
  * Intern version for libFirm.
  */
 static INLINE ir_node*
-_get_irn_inter_n (const ir_node *node, int n) {
+_get_irn_inter_n(const ir_node *node, int n) {
   assert(node); assert(-1 <= n && n < _get_irn_inter_arity(node));
 
   /* handle Filter and Block specially */
@@ -429,7 +440,7 @@ _get_irn_inter_n (const ir_node *node, int n) {
     return (node->attr.block.in_cg[n + 1] = skip_Id(node->attr.block.in_cg[n + 1]));
   }
 
-  return _get_irn_intra_n (node, n);
+  return _get_irn_intra_n(node, n);
 }
 
 /**
@@ -447,9 +458,8 @@ extern ir_node *(*_get_irn_n)(const ir_node *node, int n);
  * Intern version for libFirm.
  */
 static INLINE ir_mode *
-_get_irn_mode (const ir_node *node)
-{
-  assert (node);
+_get_irn_mode(const ir_node *node) {
+  assert(node);
   return node->mode;
 }
 
@@ -458,9 +468,8 @@ _get_irn_mode (const ir_node *node)
  * Intern version of libFirm.
  */
 static INLINE void
-_set_irn_mode (ir_node *node, ir_mode *mode)
-{
-  assert (node);
+_set_irn_mode(ir_node *node, ir_mode *mode) {
+  assert(node);
   node->mode = mode;
 }
 
@@ -469,9 +478,8 @@ _set_irn_mode (ir_node *node, ir_mode *mode)
  * Intern version for libFirm.
  */
 static INLINE unsigned long
-_get_irn_visited (const ir_node *node)
-{
-  assert (node);
+_get_irn_visited(const ir_node *node) {
+  assert(node);
   return node->visited;
 }
 
@@ -480,9 +488,8 @@ _get_irn_visited (const ir_node *node)
  * Intern version for libFirm.
  */
 static INLINE void
-_set_irn_visited (ir_node *node, unsigned long visited)
-{
-  assert (node);
+_set_irn_visited(ir_node *node, unsigned long visited) {
+  assert(node);
   node->visited = visited;
 }
 
@@ -491,8 +498,8 @@ _set_irn_visited (ir_node *node, unsigned long visited)
  * Intern version for libFirm.
  */
 static INLINE void
-_mark_irn_visited (ir_node *node) {
-  assert (node);
+_mark_irn_visited(ir_node *node) {
+  assert(node);
   node->visited = current_ir_graph->visited;
 }
 
@@ -502,7 +509,7 @@ _mark_irn_visited (ir_node *node) {
  */
 static INLINE int
 _irn_visited(const ir_node *node) {
-  assert (node);
+  assert(node);
   return (node->visited >= current_ir_graph->visited);
 }
 
@@ -512,7 +519,7 @@ _irn_visited(const ir_node *node) {
  */
 static INLINE int
 _irn_not_visited(const ir_node *node) {
-  assert (node);
+  assert(node);
   return (node->visited < current_ir_graph->visited);
 }
 
@@ -522,7 +529,7 @@ _irn_not_visited(const ir_node *node) {
  */
 static INLINE void
 _set_irn_link(ir_node *node, void *link) {
-  assert (node);
+  assert(node);
   /* Link field is used for Phi construction and various optimizations
      in iropt. */
   assert(get_irg_phase_state(get_irn_irg(node)) != phase_building);
@@ -536,7 +543,7 @@ _set_irn_link(ir_node *node, void *link) {
  */
 static INLINE void *
 _get_irn_link(const ir_node *node) {
-  assert (node && _is_ir_node(node));
+  assert(node && _is_ir_node(node));
   return node->link;
 }
 
@@ -554,14 +561,14 @@ _get_irn_pinned(const ir_node *node) {
   state = _get_op_pinned(_get_irn_op(node));
 
   if (state >= op_pin_state_exc_pinned)
-    return get_opt_fragile_ops() ? node->attr.except.pin_state : op_pin_state_pinned;
-  return state;
+    return get_opt_fragile_ops() ? (op_pin_state)node->pinned : op_pin_state_pinned;
+  return (op_pin_state)node->pinned;
 }
 
 static INLINE op_pin_state
 _is_irn_pinned_in_irg(const ir_node *node) {
-  if (get_irg_pinned(get_irn_irg(node)) == op_pin_state_floats)
-    return get_irn_pinned(node);
+  if (_get_irg_pinned(get_irn_irg(node)) == op_pin_state_floats)
+    return _get_irn_pinned(node);
   return op_pin_state_pinned;
 }
 
@@ -580,19 +587,65 @@ _is_binop(const ir_node *node) {
 static INLINE int
 _is_Bad(const ir_node *node) {
   assert(node);
-  return (node && _get_irn_op(node) == op_Bad);
+  return (_get_irn_op(node) == op_Bad);
 }
 
 static INLINE int
 _is_Const(const ir_node *node) {
   assert(node);
-  return (node && _get_irn_op(node) == op_Const);
+  return (_get_irn_op(node) == op_Const);
+}
+
+static INLINE int
+_is_Unknown(const ir_node *node) {
+  assert(node);
+  return (_get_irn_op(node) == op_Unknown);
+}
+
+static INLINE int
+_is_Return(const ir_node *node) {
+  assert(node);
+  return (_get_irn_op(node) == op_Return);
 }
 
 static INLINE int
-_is_Unknown (const ir_node *node) {
+_is_Call(const ir_node *node) {
   assert(node);
-  return (node && _get_irn_op(node) == op_Unknown);
+  return (_get_irn_op(node) == op_Call);
+}
+
+static INLINE int
+_is_Sel(const ir_node *node) {
+  assert(node);
+  return (_get_irn_op(node) == op_Sel);
+}
+
+static INLINE int
+_is_Mux(const ir_node *node) {
+  assert(node);
+  if (node) {
+    ir_op *op = _get_irn_op(node);
+    return (op == op_Mux || ((op == op_Psi) && _get_irn_arity(node) == 3));
+  }
+  return 0;
+}
+
+static INLINE int
+_is_Load(const ir_node *node) {
+  assert(node);
+  return (_get_irn_op(node) == op_Load);
+}
+
+static INLINE int
+_is_Sync(const ir_node *node) {
+  assert(node);
+  return (_get_irn_op(node) == op_Sync);
+}
+
+static INLINE int
+_is_Confirm(const ir_node *node) {
+  assert(node);
+  return (_get_irn_op(node) == op_Confirm);
 }
 
 static INLINE int
@@ -608,13 +661,13 @@ _is_Block(const ir_node *node) {
 }
 
 static INLINE int
-_get_Block_n_cfgpreds (ir_node *node) {
+_get_Block_n_cfgpreds(ir_node *node) {
   assert(_is_Block(node));
   return _get_irn_arity(node);
 }
 
 static INLINE ir_node *
-_get_Block_cfgpred (ir_node *node, int pos) {
+_get_Block_cfgpred(ir_node *node, int pos) {
   assert(0 <= pos && pos < get_irn_arity(node));
   assert(_is_Block(node));
   return _get_irn_n(node, pos);
@@ -640,27 +693,27 @@ _get_Block_cfgpred_block(ir_node *node, int pos) {
 }
 
 static INLINE unsigned long
-_get_Block_block_visited (ir_node *node) {
-  assert (node->op == op_Block);
+_get_Block_block_visited(ir_node *node) {
+  assert(node->op == op_Block);
   return node->attr.block.block_visited;
 }
 
 static INLINE void
-_set_Block_block_visited (ir_node *node, unsigned long visit) {
-  assert (node->op == op_Block);
+_set_Block_block_visited(ir_node *node, unsigned long visit) {
+  assert(node->op == op_Block);
   node->attr.block.block_visited = visit;
 }
 
 /* For this current_ir_graph must be set. */
 static INLINE void
-_mark_Block_block_visited (ir_node *node) {
-  assert (node->op == op_Block);
+_mark_Block_block_visited(ir_node *node) {
+  assert(node->op == op_Block);
   node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
 }
 
 static INLINE int
 _Block_not_block_visited(ir_node *node) {
-  assert (node->op == op_Block);
+  assert(node->op == op_Block);
   return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
 }
 
@@ -673,7 +726,7 @@ _set_Block_dead(ir_node *block) {
 
 static INLINE int
 _is_Block_dead(const ir_node *block) {
-  ir_op * op = _get_irn_op(block);
+  ir_op *op = _get_irn_op(block);
 
   if (op == op_Bad)
     return 1;
@@ -694,7 +747,7 @@ static INLINE cnst_classify_t _classify_Const(ir_node *node) {
 
   op = _get_irn_op(node);
 
-  if(op == op_Const)
+  if (op == op_Const)
     return classify_tarval(_get_Const_tarval(node));
   else if(op == op_SymConst)
     return CNST_SYMCONST;
@@ -722,14 +775,43 @@ static INLINE int _is_irn_constlike(const ir_node *node) {
   return is_op_constlike(_get_irn_op(node));
 }
 
+static INLINE int _is_irn_always_opt(const ir_node *node) {
+  return is_op_always_opt(_get_irn_op(node));
+}
+
+static INLINE int _is_irn_keep(const ir_node *node) {
+  return is_op_keep(_get_irn_op(node));
+}
+
+static INLINE int _is_irn_machine_op(const ir_node *node) {
+  return is_op_machine(_get_irn_op(node));
+}
+
+static INLINE int _is_irn_machine_operand(const ir_node *node) {
+  return is_op_machine_operand(_get_irn_op(node));
+}
+
+static INLINE int _is_irn_machine_user(const ir_node *node, unsigned n) {
+  return is_op_machine_user(_get_irn_op(node), n);
+}
+
 static INLINE cond_jmp_predicate _get_Cond_jmp_pred(ir_node *node) {
   assert (_get_irn_op(node) == op_Cond);
-  return node->attr.c.pred;
+  return node->attr.cond.pred;
 }
 
 static INLINE void _set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate pred) {
   assert (_get_irn_op(node) == op_Cond);
-  node->attr.c.pred = pred;
+  node->attr.cond.pred = pred;
+}
+
+static INLINE int _get_Psi_n_conds(ir_node *node) {
+  assert(_get_irn_op(node) == op_Psi);
+  return _get_irn_arity(node) >> 1;
+}
+
+static INLINE unsigned _get_irn_idx(const ir_node *node) {
+  return node->node_idx;
 }
 
 /* this section MUST contain all inline functions */
@@ -743,6 +825,7 @@ static INLINE void _set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate pred) {
 #define get_irn_mode(node)                    _get_irn_mode(node)
 #define set_irn_mode(node, mode)              _set_irn_mode(node, mode)
 #define get_irn_op(node)                      _get_irn_op(node)
+#define set_irn_op(node, op)                  _set_irn_op(node, op)
 #define get_irn_opcode(node)                  _get_irn_opcode(node)
 #define get_irn_visited(node)                 _get_irn_visited(node)
 #define set_irn_visited(node, v)              _set_irn_visited(node, v)
@@ -757,6 +840,13 @@ static INLINE void _set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate pred) {
 #define is_binop(node)                        _is_binop(node)
 #define is_Const(node)                        _is_Const(node)
 #define is_Unknown(node)                      _is_Unknown(node)
+#define is_Return(node)                       _is_Return(node)
+#define is_Call(node)                         _is_Call(node)
+#define is_Sel(node)                          _is_Sel(node)
+#define is_Mux(node)                          _is_Mux(node)
+#define is_Load(node)                         _is_Load(node)
+#define is_Sync(node)                         _is_Sync(node)
+#define is_Confirm(node)                      _is_Confirm(node)
 #define is_Bad(node)                          _is_Bad(node)
 #define is_no_Block(node)                     _is_no_Block(node)
 #define is_Block(node)                        _is_Block(node)
@@ -776,7 +866,14 @@ static INLINE void _set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate pred) {
 #define get_irn_type_attr(node)               _get_irn_type_attr(node)
 #define get_irn_entity_attr(node)             _get_irn_entity_attr(node)
 #define is_irn_constlike(node)                _is_irn_constlike(node)
+#define is_irn_always_opt(node)               _is_irn_always_opt(node)
+#define is_irn_keep(node)                     _is_irn_keep(node)
+#define is_irn_machine_op(node)               _is_irn_machine_op(node)
+#define is_irn_machine_operand(node)          _is_irn_machine_operand(node)
+#define is_irn_machine_user(node, n)          _is_irn_machine_user(node, n)
 #define get_Cond_jmp_pred(node)               _get_Cond_jmp_pred(node)
 #define set_Cond_jmp_pred(node, pred)         _set_Cond_jmp_pred(node, pred)
+#define get_Psi_n_conds(node)                 _get_Psi_n_conds(node)
+#define get_irn_idx(node)                     _get_irn_idx(node)
 
 # endif /* _IRNODE_T_H_ */