+/**
+ * Get the n-th predecessor of a node.
+ * This function removes Id predecessors.
+ */
+ir_node *get_irn_n (ir_node *node, int n);
+ir_node *get_irn_intra_n (ir_node *node, int n);
+ir_node *get_irn_inter_n (ir_node *node, int n);
+
+/** Replace the n-th predecessor of a node with a new one. */
+void set_irn_n (ir_node *node, int n, ir_node *in);
+/* Sets the mode struct of node. */
+void set_irn_mode (ir_node *node, ir_mode *mode);
+/** Gets the mode struct of a node. */
+ir_mode *get_irn_mode (const ir_node *node);
+/** Gets the mode-enum modecode. */
+modecode get_irn_modecode (const ir_node *node);
+/** Gets the ident for a string representation of the mode .*/
+ident *get_irn_modeident (const ir_node *node);
+/** Gets the string representation of the mode .*/
+const char *get_irn_modename (const ir_node *node);
+/** Gets the opcode struct of the node. */
+ir_op *get_irn_op (const ir_node *node);
+/** Sets the opcode struct of the node. */
+void set_irn_op (ir_node *node, ir_op *op);
+/** Gets the opcode-enum of the node. */
+opcode get_irn_opcode (const ir_node *node);
+/** Get the string representation of the opcode. */
+const char *get_irn_opname (const ir_node *node);
+/** Get the ident for a string representation of the opcode. */
+ident *get_irn_opident (const ir_node *node);
+/** Gets the visited counter of a node. */
+unsigned long get_irn_visited (const ir_node *node);
+/** Sets the visited counter of a node. */
+void set_irn_visited (ir_node *node, unsigned long visited);
+/** Sets visited to get_irg_visited(current_ir_graph). */
+void mark_irn_visited (ir_node *node);
+/** Returns 1 if visited < get_irg_visited(current_ir_graph). */
+int irn_not_visited (const ir_node *node);
+/** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
+int irn_visited (const ir_node *node);
+
+/**
+ * Sets the link of a node.
+ * Only allowed if the graph is NOT in phase_building.
+ */
+void set_irn_link (ir_node *node, void *link);
+
+/** Returns the link of a node. */
+void *get_irn_link (const ir_node *node);
+
+/** Returns the ir_graph this node belongs to. Only valid if irg
+ * is in state op_pin_state_pinned (irg is only stored in the block. */
+ir_graph *get_irn_irg (ir_node *node);
+
+/** Outputs a unique number for this node if libFIRM is compiled for
+ debugging, (configure with --enable-debug) else returns address
+ of node cast to long. */
+long get_irn_node_nr (const ir_node *node);
+
+
+/**
+ * irnode constructor.
+ * Create a new irnode in irg, with an op, mode, arity and
+ * some incoming irnodes.
+ * This constructor is used in every specified irnode constructor.
+ *
+ * @param db Debug info.
+ * @param irg IR-graph on with this new node should be constructed.
+ * @param op The opcode of the new node.
+ * @param mode The mode of the new node.
+ * @param arity The arity of the new node, may be <0 if yet.
+ * @param in An array of arity predecessor nodes.
+ */
+ir_node *
+new_ir_node (dbg_info *db,
+ ir_graph *irg,
+ ir_node *block,
+ ir_op *op,
+ ir_mode *mode,
+ int arity,
+ ir_node *in[]);
+
+/*
+ *
+ * NAME access functions for node fields.
+ *
+ * Not properly documented ;-)
+ *
+ */
+
+/** This works for all except Block. To express the difference to
+ * access routines that work for all nodes we use infix "nodes" and do not
+ * name this function get_irn_block. */
+#define get_nodes_block get_nodes_Block
+ir_node *get_nodes_block (ir_node *node);
+#define set_nodes_block set_nodes_Block
+void set_nodes_block (ir_node *node, ir_node *block);
+
+/**
+ * @function get_irn_block
+ * @see get_nodes_block()
+ */
+/**
+ * Projection numbers for result of Start node: use for Proj nodes!
+ */
+typedef enum {
+ pn_Start_X_initial_exec, /**< Projection on the initial control flow. */
+ pn_Start_M, /**< Projection on the initial memory. */
+ pn_Start_P_frame_base, /**< Projection on the frame base pointer. */
+ pn_Start_P_globals, /**< Projection on the pointer to the data segment
+ containing _all_ global entities. */
+ pn_Start_T_args, /**< Projection on all arguments. */
+ pn_Start_P_value_arg_base /**< Pointer to region of compound value arguments as defined by
+ type of this method. */
+} pn_Start; /* Projection numbers for Start. */
+
+
+/** Test whether arbitrary node is frame pointer.
+ *
+ * Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
+ * from Start. If so returns frame type, else Null. */
+type *is_frame_pointer(ir_node *n);
+
+/** Test whether arbitrary node is globals pointer.
+ *
+ * Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
+ * from Start. If so returns global type, else Null. */
+type *is_globals_pointer(ir_node *n);
+
+/** Test whether arbitrary node is value arg base.
+ *
+ * Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
+ * from Start. If so returns 1, else 0. */
+int is_value_arg_pointer(ir_node *n);
+
+
+/* @@@ no more supported */
+ir_node **get_Block_cfgpred_arr (ir_node *node);
+int get_Block_n_cfgpreds (ir_node *node);
+ir_node *get_Block_cfgpred (ir_node *node, int pos);
+void set_Block_cfgpred (ir_node *node, int pos, ir_node *pred);
+bool get_Block_matured (ir_node *node);
+void set_Block_matured (ir_node *node, bool matured);
+unsigned long get_Block_block_visited (ir_node *node);
+void set_Block_block_visited (ir_node *node, unsigned long visit);
+/* For this current_ir_graph must be set. */
+void mark_Block_block_visited(ir_node *node);
+int Block_not_block_visited(ir_node *node);
+
+/* Set and remove interprocedural predecessors. If the interprocedural
+ * predecessors are removed, the node has the same predecessors in
+ * both views.
+ * @@@ Maybe better: arity is zero if no cg preds. */
+void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in);
+void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred);
+/* @@@ not supported */
+ir_node **get_Block_cg_cfgpred_arr(ir_node * node);
+/* Returns the number of interprocedural predecessors. 0 if none. */
+int get_Block_cg_n_cfgpreds(ir_node * node);
+ir_node *get_Block_cg_cfgpred(ir_node * node, int pos);
+/* frees the memory. */
+void remove_Block_cg_cfgpred_arr(ir_node * node);
+
+/** Keep alive dedicated nodes. These must be either
+ * PhiM or Block nodes. */
+int get_End_n_keepalives(ir_node *end);
+ir_node *get_End_keepalive(ir_node *end, int pos);
+void add_End_keepalive (ir_node *end, ir_node *ka);
+void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
+/* Some parts of the End node are allocated separately -- their memory
+ is not recovered by dead_node_elimination if a End node is dead.
+ free_End frees these data structures. */
+void free_End (ir_node *end);
+
+
+/* We distinguish three kinds of Cond nodes. These can be distinguished
+ by the mode of the selector operand and an internal flag of type cond_kind.
+ First we distinguish binary Conds and switch Conds.
+ A binary Cond has as selector a boolean value. Proj(0) projects the control
+ flow for case "False", Proj(1) the control flow for "True". A binary Cond
+ is recognized by the boolean selector.
+ The switch Cond has as selector an unsigned integer. It produces as result
+ an n+1 Tuple (cf0, ... , cfn) of control flows.
+ We differ two flavours of this Cond. The first, the dense Cond, passes
+ control along output i if the selector value is i, 0 <= i <= n. If the
+ selector value is >n it passes control along output n.
+ The second Cond flavor differes in the treatment of cases not specified in
+ the source program. It magically knows about the existence of Proj nodes.
+ It only passes control along output i, 0 <= i <= n, if a node Proj(Cond, i)
+ exists. Else it passes control along output n (even if this Proj does not
+ exist.) This Cond we call "fragmentary". There is a special constructor
+ new_defaultProj that automatically sets the flavor.
+ The two switch flavors are distinguished by a flag of type cond_kind.
+ Default flavor is "dense"
+*/
+typedef enum {
+ dense, /**< Default. Missing Proj nodes are dead control flow. */
+ fragmentary /**< Special. No control flow optimizations allowed. Missing
+ Proj nodes mean default control flow, i.e., Proj(n). */
+} cond_kind;
+
+ir_node *get_Cond_selector (ir_node *node);
+void set_Cond_selector (ir_node *node, ir_node *selector);
+cond_kind get_Cond_kind (ir_node *node);
+void set_Cond_kind (ir_node *node, cond_kind kind);
+long get_Cond_defaultProj (ir_node *node);
+
+/**
+ * Projection numbers for conditions.
+ */