+ pn_Mod_M, /**< Memory result. */
+ pn_Mod_X_except, /**< Execution result if exception occured. */
+ pn_Mod_res /**< Result of computation. */
+} pn_Mod; /* Projection numbers for Mod. */
+
+ir_node *get_Abs_op (ir_node *node);
+void set_Abs_op (ir_node *node, ir_node *op);
+
+ir_node *get_And_left (ir_node *node);
+void set_And_left (ir_node *node, ir_node *left);
+ir_node *get_And_right (ir_node *node);
+void set_And_right (ir_node *node, ir_node *right);
+
+ir_node *get_Or_left (ir_node *node);
+void set_Or_left (ir_node *node, ir_node *left);
+ir_node *get_Or_right (ir_node *node);
+void set_Or_right (ir_node *node, ir_node *right);
+
+ir_node *get_Eor_left (ir_node *node);
+void set_Eor_left (ir_node *node, ir_node *left);
+ir_node *get_Eor_right (ir_node *node);
+void set_Eor_right (ir_node *node, ir_node *right);
+
+ir_node *get_Not_op (ir_node *node);
+void set_Not_op (ir_node *node, ir_node *op);
+
+/**
+ * Projection numbers for Cmp are defined several times.
+ * The bit patterns are used for various tests, so don't change.
+ * The "unordered" values are possible results of comparing
+ * floating point numbers.
+ */
+typedef enum {
+ pn_Cmp_False = 0, /**< false */
+ pn_Cmp_Eq, /**< equal */
+ pn_Cmp_Lt, /**< less */
+ pn_Cmp_Le, /**< less or equal */
+ pn_Cmp_Gt, /**< greater */
+ pn_Cmp_Ge, /**< greater or equal */
+ pn_Cmp_Lg, /**< less or greater */
+ pn_Cmp_Leg = 7, /**< less, equal or greater = ordered */
+ pn_Cmp_Uo, /**< unordered */
+ pn_Cmp_Ue, /**< unordered or equal */
+ pn_Cmp_Ul, /**< unordered or less */
+ pn_Cmp_Ule, /**< unordered, less or equal */
+ pn_Cmp_Ug, /**< unordered or greater */
+ pn_Cmp_Uge, /**< unordered, greater or equal */
+ pn_Cmp_Ne, /**< unordered, less or greater = not equal */
+ pn_Cmp_True = 15 /**< true */
+ /* not_mask = Leg*/ /* bits to flip to negate comparison * @@ hack for jni interface */
+} pn_Cmp; /* Projection numbers for Cmp */
+/* #define not_mask pn_Cmp_Leg */
+
+const char *get_pnc_string(int pnc);
+int get_negated_pnc(int pnc);
+ir_node *get_Cmp_left (ir_node *node);
+void set_Cmp_left (ir_node *node, ir_node *left);
+ir_node *get_Cmp_right (ir_node *node);
+void set_Cmp_right (ir_node *node, ir_node *right);
+
+ir_node *get_Shl_left (ir_node *node);
+void set_Shl_left (ir_node *node, ir_node *left);
+ir_node *get_Shl_right (ir_node *node);
+void set_Shl_right (ir_node *node, ir_node *right);
+
+ir_node *get_Shr_left (ir_node *node);
+void set_Shr_left (ir_node *node, ir_node *left);
+ir_node *get_Shr_right (ir_node *node);
+void set_Shr_right (ir_node *node, ir_node *right);
+
+ir_node *get_Shrs_left (ir_node *node);
+void set_Shrs_left (ir_node *node, ir_node *left);
+ir_node *get_Shrs_right (ir_node *node);
+void set_Shrs_right (ir_node *node, ir_node *right);
+
+ir_node *get_Rot_left (ir_node *node);
+void set_Rot_left (ir_node *node, ir_node *left);
+ir_node *get_Rot_right (ir_node *node);
+void set_Rot_right (ir_node *node, ir_node *right);
+
+ir_node *get_Conv_op (ir_node *node);
+void set_Conv_op (ir_node *node, ir_node *op);
+
+/* Does Cast need a mem operator?
+ * Cast should only depend on the type, not on the state of an
+ * entity. But: we initialze various fields after Alloc, that
+ * are accessed in the cast. This required some precaution, to
+ * get the right memory into the Loads generated from the cast.
+ */
+ir_node *get_Cast_op (ir_node *node);
+void set_Cast_op (ir_node *node, ir_node *op);
+type *get_Cast_type (ir_node *node);
+void set_Cast_type (ir_node *node, type *to_tp);
+
+/** Returns true if n is Phi or Filter in interprocedural_view.
+ Returns false if irg in phase building and the Phi has zero
+ predecessors: it's a Phi0. */
+int is_Phi (ir_node *n);
+/** Returns true if irg in phase building and the Phi has zero
+ predecessors: it's a Phi0. */
+int is_Phi0 (ir_node *n);
+/* These routines also work for Filter nodes in interprocedural view. */
+ir_node **get_Phi_preds_arr (ir_node *node);
+int get_Phi_n_preds (ir_node *node);
+ir_node *get_Phi_pred (ir_node *node, int pos);
+void set_Phi_pred (ir_node *node, int pos, ir_node *pred);
+
+ir_node *get_Filter_pred(ir_node *node);
+void set_Filter_pred(ir_node *node, ir_node *pred);
+long get_Filter_proj(ir_node *node);
+void set_Filter_proj(ir_node *node, long proj);
+/* set the interprocedural predecessors, ...d_arr uses current_ir_graph.
+ * @@@ Maybe better: arity is zero if no cg preds. */
+void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in);
+void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred);
+int get_Filter_n_cg_preds(ir_node *node);
+ir_node *get_Filter_cg_pred(ir_node *node, int pos);
+
+/** Return true if parameter is a memory operation.
+ *
+ * A memory operation is an operation that directly changes the
+ * memory. I.e., a Load or a Store operation.
+ */
+int is_memop(ir_node *node);
+ir_node *get_memop_mem (ir_node *node);
+void set_memop_mem (ir_node *node, ir_node *mem);
+ir_node *get_memop_ptr (ir_node *node);
+void set_memop_ptr (ir_node *node, ir_node *ptr);
+
+/**
+ * Projection numbers for Load: use for Proj nodes!
+ */
+typedef enum {
+ pn_Load_M, /**< Memory result. */
+ pn_Load_X_except, /**< Execution result if exception occured. */
+ pn_Load_res /**< Result of load operation. */
+} pn_Load; /* Projection numbers for Load. */
+
+ir_node *get_Load_mem (ir_node *node);
+void set_Load_mem (ir_node *node, ir_node *mem);
+ir_node *get_Load_ptr (ir_node *node);
+void set_Load_ptr (ir_node *node, ir_node *ptr);
+
+/**
+ * Projection numbers for Store: use for Proj nodes!
+ */
+typedef enum {
+ pn_Store_M, /**< Memory result. */
+ pn_Store_X_except /**< Execution result if exception occured. */
+} pn_Store; /* Projection numbers for Store. */
+
+ir_node *get_Store_mem (ir_node *node);
+void set_Store_mem (ir_node *node, ir_node *mem);
+ir_node *get_Store_ptr (ir_node *node);
+void set_Store_ptr (ir_node *node, ir_node *ptr);
+ir_node *get_Store_value (ir_node *node);
+void set_Store_value (ir_node *node, ir_node *value);
+
+/**
+ * Projection numbers for Alloc: use for Proj nodes!
+ */
+typedef enum {
+ pn_Alloc_M, /**< Memory result. */
+ pn_Alloc_X_except, /**< Execution result if exception occured. */
+ pn_Alloc_res /**< Result of allocation. */
+} pn_Alloc; /* Projection numbers for Alloc. */
+
+ir_node *get_Alloc_mem (ir_node *node);
+void set_Alloc_mem (ir_node *node, ir_node *mem);
+ir_node *get_Alloc_size (ir_node *node);
+void set_Alloc_size (ir_node *node, ir_node *size);
+type *get_Alloc_type (ir_node *node);
+void set_Alloc_type (ir_node *node, type *tp);
+
+/** The allocation place. */
+typedef enum {
+ stack_alloc, /**< Alloc allocates the object on the stack. */
+ heap_alloc /**< Alloc allocates the object on the heap. */