+is_ir_node (void *thing);
+
+/** returns the number of predecessors without the block predecessor: */
+int get_irn_arity (const ir_node *node);
+INLINE int get_irn_intra_arity (const ir_node *node);
+INLINE int get_irn_inter_arity (const ir_node *node);
+
+/** Replaces the old in array by a new one that will contain the ins given in
+ the parameters. Conserves the block predecessor. It copies the array passed.
+ This function is necessary to ajust in arrays of blocks, calls and phis.
+ Assumes that current_ir_graph is set to the graph containing "node".
+ "in" must contain all predecessors except the block that are required for
+ the nodes opcode. */
+INLINE void set_irn_in (ir_node *node, int arity,
+ ir_node *in[]);
+/* to iterate through the predecessors without touching the array. No
+ order of predecessors guaranteed.
+ To iterate over the operands iterate from 0 to i < get_irn_arity(),
+ to iterate including the Block predecessor iterate from i = -1 to
+ i < get_irn_arity. */
+/* Access predecessor n */
+/* get_irn_n removes Id predecessors. */
+INLINE ir_node *get_irn_n (ir_node *node, int n);
+INLINE ir_node *get_irn_intra_n (ir_node *node, int n);
+INLINE ir_node *get_irn_inter_n (ir_node *node, int n);
+INLINE void set_irn_n (ir_node *node, int n, ir_node *in);
+/** Sets the mode struct of node */
+INLINE void set_irn_mode (ir_node *node, ir_mode *mode);
+/** Gets the mode struct. */
+INLINE ir_mode *get_irn_mode (const ir_node *node);
+/** Gets the mode-enum modecode. */
+INLINE modecode get_irn_modecode (const ir_node *node);
+/** Gets the ident for a string representation of the mode .*/
+INLINE ident *get_irn_modeident (const ir_node *node);
+/** Gets the string representation of the mode .*/
+INLINE const char *get_irn_modename (const ir_node *node);
+/** Gets the opcode struct of the node */
+INLINE ir_op *get_irn_op (const ir_node *node);
+/** Sets the opcode struct of the node. */
+INLINE void set_irn_op (ir_node *node, ir_op *op);
+/** Gets the opcode-enum of the node. */
+INLINE opcode get_irn_opcode (const ir_node *node);
+/** Get the string representation of the opcode. */
+INLINE const char *get_irn_opname (const ir_node *node);
+/** Get the ident for a string representation of the opcode. */
+INLINE ident *get_irn_opident (const ir_node *node);
+INLINE unsigned long get_irn_visited (const ir_node *node);
+INLINE void set_irn_visited (ir_node *node, unsigned long visited);
+/** Sets visited to get_irg_visited(current_ir_graph). */
+INLINE void mark_irn_visited (ir_node *node);
+/** Returns 1 if visited < get_irg_visited(current_ir_graph). */
+INLINE int irn_not_visited (const ir_node *node);
+/** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
+INLINE int irn_visited (const ir_node *node);
+INLINE void set_irn_link (ir_node *node, void *link);
+INLINE void *get_irn_link (const ir_node *node);
+
+/** Returns the ir_graph this node belongs to. Only valid if irg
+ * is in state pinned (irg is only stored in the block. */
+INLINE 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. */
+INLINE 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.
+ * If arity is negative, a node with a dynamic array is created.
+ */
+INLINE 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". */
+#define get_nodes_block get_nodes_Block
+INLINE ir_node *get_nodes_Block (ir_node *node);
+#define set_nodes_block set_nodes_Block
+INLINE void set_nodes_Block (ir_node *node, ir_node *block);
+
+/** Projection numbers for result of Start node: use for Proj nodes! */
+/* @@@ old name convention! */
+typedef enum {
+ pns_initial_exec, /**< Projection on an executable, the initial control
+ flow. */
+ pns_global_store, /**< Projection on the global store */
+ pns_frame_base, /**< Projection on the frame base */
+ pns_globals, /**< Projection on the pointer to the data segment
+ containing _all_ global entities. */
+ pns_args, /**< Projection on all arguments */
+ pns_value_arg_base /**< Pointer to region of compound value arguments as defined by
+ type of this method. */
+} pns_number; /* pns: Projection Number Start */
+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 */
+INLINE ir_node **get_Block_cfgpred_arr (ir_node *node);
+int get_Block_n_cfgpreds (ir_node *node);
+INLINE ir_node *get_Block_cfgpred (ir_node *node, int pos);
+INLINE void set_Block_cfgpred (ir_node *node, int pos, ir_node *pred);
+INLINE bool get_Block_matured (ir_node *node);
+INLINE void set_Block_matured (ir_node *node, bool matured);
+INLINE unsigned long get_Block_block_visited (ir_node *node);
+INLINE void set_Block_block_visited (ir_node *node, unsigned long visit);
+/* For this current_ir_graph must be set. */
+INLINE void mark_Block_block_visited(ir_node *node);
+INLINE 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 interproc 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);
+
+/* Start references the irg it is in.
+ @@@ old -- use get_irn_irg instead! */
+ir_graph *get_Start_irg(ir_node *node);
+
+INLINE int get_End_n_keepalives(ir_node *end);
+INLINE ir_node *get_End_keepalive(ir_node *end, int pos);
+INLINE void add_End_keepalive (ir_node *end, ir_node *ka);
+INLINE void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
+/* Some parts of the End node are allocated seperately -- their memory
+ is not recovered by dead_node_elimination if a End node is dead.
+ free_End frees these data structures. */
+INLINE void free_End (ir_node *end);
+
+/* @@@ old -- use get_irn_irg instead! */
+ir_graph *get_EndReg_irg (ir_node *end);
+ir_graph *get_EndExcept_irg (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;