+/**
+ * Get the n-th predecessor of a node.
+ * This function removes Id predecessors.
+ * This function automatically handles intra- and interprocedural views.
+ */
+ir_node *get_irn_n (const ir_node *node, int n);
+
+/**
+ * Get the n-th predecessor of a node in intraprocedural view.
+ * Can be used always if it's know that node is not a split one.
+ */
+ir_node *get_irn_intra_n (const ir_node *node, int n);
+
+/**
+ * Get the n-th predecessor of a node in interprocedural view.
+ */
+ir_node *get_irn_inter_n (const 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);
+/** If arg is an argument of the node, returns it's position, -1 otherwise */
+int get_irn_pred_pos (ir_node *node, ir_node *arg);
+/** 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 (const 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);
+
+/** Returns the pinned state of a node.
+ *
+ * Returns whether the node _always_ must be pinned.
+ * I.e., the node is not floating after global cse.
+ *
+ * @returns Either state op_pin_state_pinned or op_pin_state_floats.
+ */
+op_pin_state get_irn_pinned (const ir_node *node);
+
+/** Set pin state for nodes with op pin state op_pin_state_exc_pinned */
+void set_irn_pinned(ir_node *node, op_pin_state state);
+
+/** Returns whether the node is currently pinned.
+ *
+ * If get_irn_pinned returns op_pin_state_floats and the graph the
+ * node belongs to is in state op_poin_state_floats then this function
+ * returns 'floats', else 'pinned'.
+ */
+op_pin_state is_irn_pinned_in_irg (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 block The block the new node belongs to
+ * @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[]);
+
+/**
+ * Return the block the node belongs to. This is only
+ * possible for pinned nodes or if the graph is in pinned state.
+ * Otherwise the block may be incorrect. This condition is
+ * now checked by an assertion.
+ *
+ * This works for all except Block. It can return Blocks or the Bad node.
+ *
+ * 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(). */
+ir_node *get_nodes_block (const ir_node *node);
+
+/** Sets the Block of a node. */
+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_max /**< number of projections from a Start */
+} 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. */
+ir_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. */
+ir_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);
+/** Get the predecessor block.
+ *
+ * Returns the block corresponding to the predecessor pos of block.
+ *
+ * There are several ambiguities we resolve with this function:
+ * - The direct predecessor can be a Proj, which is not pinned.
+ * We walk from the predecessor to the next pinned node
+ * (skip_Proj) and return the block that node is in.
+ * - If we encounter the Bad node, this function does not return
+ * Start, but the Bad node.
+ */
+ir_node *get_Block_cfgpred_block(ir_node *node, int pos);
+int get_Block_matured (ir_node *node);
+void set_Block_matured (ir_node *node, int matured);
+
+/** A visited flag only for block nodes.
+ * @see also: get_irn_visited() inc_irg_visited() inc_irg_block_visited()*/
+unsigned long get_Block_block_visited (ir_node *node);
+void set_Block_block_visited (ir_node *node, unsigned long visit);
+
+/**
+ * Marks a block as dead but do not replace it with a Bad node.
+ * Dead blocks are removed in the con
+ */
+ir_node *set_Block_dead(ir_node *block);
+int is_Block_dead(const ir_node *block);
+
+/* 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);
+/** Return the interprocedural predecessor at position pos. */
+ir_node *get_Block_cg_cfgpred(ir_node * node, int pos);
+/* frees the memory. */
+void remove_Block_cg_cfgpred_arr(ir_node * node);
+
+/** returns the extended basic block a block belongs to */
+ir_extblk *get_Block_extbb(const ir_node *block);
+/** sets the extended basic block a block belongs to */
+void set_Block_extbb(ir_node *block, ir_extblk *extblk);
+
+/** Return the number of Keep alive node. */
+int get_End_n_keepalives(ir_node *end);
+
+/** Return the Keep alive node a position pos. */
+ir_node *get_End_keepalive(ir_node *end, int pos);
+
+/** Keep alive dedicated nodes. These must be either PhiM or Block nodes. */
+void add_End_keepalive (ir_node *end, ir_node *ka);
+
+/** Set the Keep alive node at position pos. */
+void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
+
+/** Set new keep-alives */
+void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
+
+/** 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);
+
+/** Return the target address of an IJmp */
+ir_node *get_IJmp_target(ir_node *ijmp);
+
+/** Sets the target address of an IJmp */
+void set_IJmp_target(ir_node *ijmp, ir_node *tgt);
+
+/* 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 flavors 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 differences 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.
+ */
+typedef enum {
+ pn_Cond_false, /**< Control flow if operand is "false". */
+ pn_Cond_true, /**< Control flow if operand is "true". */
+ pn_Cond_max /**< number of projections from a Cond */
+} pn_Cond; /* Projection numbers for Cond. */
+
+ir_node *get_Return_mem (ir_node *node);
+void set_Return_mem (ir_node *node, ir_node *mem);
+ir_node **get_Return_res_arr (ir_node *node);
+int get_Return_n_ress (ir_node *node);
+ir_node *get_Return_res (ir_node *node, int pos);
+void set_Return_res (ir_node *node, int pos, ir_node *res);
+
+typedef enum {
+ CNST_NULL = 0, /**< The node is a const(0). */
+ CNST_ONE = +1, /**< The node is a const(1). */
+ CNST_ALL_ONE = -1, /**< The node is a const(11111...). */
+ CNST_OTHER = 2, /**< The tarval of the const has another value. */
+ CNST_SYMCONST = 3, /**< The node is symconst. */
+ CNST_NO_CONST = 4 /**< The node is no const at all. */
+} cnst_classify_t;
+
+tarval *get_Const_tarval (ir_node *node);
+void set_Const_tarval (ir_node *node, tarval *con);
+
+/**
+ * Classify a node concerning constant properties.
+ * @param irn A node to check for.
+ * @return Constant properties of that node.
+ */
+cnst_classify_t classify_Const(ir_node *irn);
+
+/** Returns the source language type of a Const node.
+ * Must be an atomic type. Mode of type must be mode of node.
+ */
+ir_type *get_Const_type (ir_node *node);
+
+/** Sets the source language type of a Const node. */
+void set_Const_type (ir_node *node, ir_type *tp);
+
+/** This enum names the three different kinds of symbolic Constants