/* Warning: automatically generated code */
#ifndef FIRM_IR_NODEOPS_H
#define FIRM_IR_NODEOPS_H

#include "firm_types.h"

/**
 * @addtogroup ir_node
 * @{
 */


/**
 * Projection numbers for result of Alloc node (use for Proj nodes)
 */
typedef enum {
	pn_Alloc_M = pn_Generic_M, /**< memory result */
	pn_Alloc_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Alloc_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Alloc_res = pn_Generic_other, /**< pointer to newly allocated memory */
	pn_Alloc_max
} pn_Alloc;

/**
 * Projection numbers for result of Bound node (use for Proj nodes)
 */
typedef enum {
	pn_Bound_M = pn_Generic_M, /**< memory result */
	pn_Bound_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Bound_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Bound_res = pn_Generic_other, /**< the checked index */
	pn_Bound_max
} pn_Bound;

/**
 * Projection numbers for result of Builtin node (use for Proj nodes)
 */
typedef enum {
	pn_Builtin_M = pn_Generic_M, /**< memory result */
	pn_Builtin_1_result = pn_Generic_other, /**< first result */
	pn_Builtin_max
} pn_Builtin;

/**
 * Projection numbers for result of Call node (use for Proj nodes)
 */
typedef enum {
	pn_Call_M = pn_Generic_M, /**< memory result */
	pn_Call_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Call_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Call_T_result = pn_Generic_other, /**< tuple containing all results */
	pn_Call_max
} pn_Call;

/**
 * Projection numbers for result of Cond node (use for Proj nodes)
 */
typedef enum {
	pn_Cond_false, /**< control flow if operand is "false" */
	pn_Cond_true, /**< control flow if operand is "true" */
	pn_Cond_max
} pn_Cond;

/**
 * Projection numbers for result of CopyB node (use for Proj nodes)
 */
typedef enum {
	pn_CopyB_M = pn_Generic_M, /**< memory result */
	pn_CopyB_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_CopyB_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_CopyB_max
} pn_CopyB;

/**
 * Projection numbers for result of Div node (use for Proj nodes)
 */
typedef enum {
	pn_Div_M = pn_Generic_M, /**< memory result */
	pn_Div_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Div_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Div_res = pn_Generic_other, /**< result of computation */
	pn_Div_max
} pn_Div;

/**
 * Projection numbers for result of InstOf node (use for Proj nodes)
 */
typedef enum {
	pn_InstOf_M = pn_Generic_M, /**< memory result */
	pn_InstOf_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_InstOf_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_InstOf_res = pn_Generic_other, /**< checked object pointer */
	pn_InstOf_max
} pn_InstOf;

/**
 * Projection numbers for result of Load node (use for Proj nodes)
 */
typedef enum {
	pn_Load_M = pn_Generic_M, /**< memory result */
	pn_Load_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Load_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Load_res = pn_Generic_other, /**< result of load operation */
	pn_Load_max
} pn_Load;

/**
 * Projection numbers for result of Mod node (use for Proj nodes)
 */
typedef enum {
	pn_Mod_M = pn_Generic_M, /**< memory result */
	pn_Mod_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Mod_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Mod_res = pn_Generic_other, /**< result of computation */
	pn_Mod_max
} pn_Mod;

/**
 * Projection numbers for result of Raise node (use for Proj nodes)
 */
typedef enum {
	pn_Raise_M = pn_Generic_M, /**< memory result */
	pn_Raise_X = pn_Generic_X_regular, /**< control flow to exception handler */
	pn_Raise_max
} pn_Raise;

/**
 * Projection numbers for result of Start node (use for Proj nodes)
 */
typedef enum {
	pn_Start_X_initial_exec, /**< control flow */
	pn_Start_M, /**< initial memory */
	pn_Start_P_frame_base, /**< frame base pointer */
	pn_Start_T_args, /**< function arguments */
	pn_Start_max
} pn_Start;

/**
 * Projection numbers for result of Store node (use for Proj nodes)
 */
typedef enum {
	pn_Store_M = pn_Generic_M, /**< memory result */
	pn_Store_X_regular = pn_Generic_X_regular, /**< control flow when no exception occurs */
	pn_Store_X_except = pn_Generic_X_except, /**< control flow when exception occured */
	pn_Store_max
} pn_Store;




/**
 * Construct an Add node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Add(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Add node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Add(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Add node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Add(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Add node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Add(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Alloc node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_count number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether to allocate the variable on the stack or heap
*/
FIRM_API ir_node *new_rd_Alloc(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where);

/**
 * Construct an Alloc node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_count number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether to allocate the variable on the stack or heap
*/
FIRM_API ir_node *new_r_Alloc(ir_node *block, ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where);

/**
 * Construct an Alloc node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_count number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether to allocate the variable on the stack or heap
*/
FIRM_API ir_node *new_d_Alloc(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where);

/**
 * Construct an Alloc node.
 *
 * @param irn_mem   memory dependency
 * @param irn_count number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether to allocate the variable on the stack or heap
*/
FIRM_API ir_node *new_Alloc(ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where);


/**
 * Construct an And node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_And(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an And node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_And(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an And node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_And(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an And node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_And(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Bad node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
*/
FIRM_API ir_node *new_rd_Bad(dbg_info *dbgi, ir_graph *irg);

/**
 * Construct a Bad node.
 *
 * @param irg       The IR graph the node belongs to.
*/
FIRM_API ir_node *new_r_Bad(ir_graph *irg);

/**
 * Construct a Bad node.
 *
 * @param dbgi      A pointer to debug information.
*/
FIRM_API ir_node *new_d_Bad(dbg_info *dbgi);

/**
 * Construct a Bad node.
 *
*/
FIRM_API ir_node *new_Bad(void);

/**
 * Construct a Block node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_rd_Block(dbg_info *dbgi, ir_graph *irg, int arity, ir_node *const * in);

/**
 * Construct a Block node.
 *
 * @param irg       The IR graph the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_r_Block(ir_graph *irg, int arity, ir_node *const * in);

/**
 * Construct a Block node.
 *
 * @param dbgi      A pointer to debug information.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_d_Block(dbg_info *dbgi, int arity, ir_node *const * in);

/**
 * Construct a Block node.
 *
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_Block(int arity, ir_node *const * in);

/**
 * Construct a Borrow node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Borrow(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Borrow node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Borrow(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Borrow node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Borrow(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Borrow node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Borrow(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Bound node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_index value to test
 * @param irn_lower lower bound (inclusive)
 * @param irn_upper upper bound (exclusive)
*/
FIRM_API ir_node *new_rd_Bound(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper);

/**
 * Construct a Bound node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_index value to test
 * @param irn_lower lower bound (inclusive)
 * @param irn_upper upper bound (exclusive)
*/
FIRM_API ir_node *new_r_Bound(ir_node *block, ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper);

/**
 * Construct a Bound node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_index value to test
 * @param irn_lower lower bound (inclusive)
 * @param irn_upper upper bound (exclusive)
*/
FIRM_API ir_node *new_d_Bound(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper);

/**
 * Construct a Bound node.
 *
 * @param irn_mem   memory dependency
 * @param irn_index value to test
 * @param irn_lower lower bound (inclusive)
 * @param irn_upper upper bound (exclusive)
*/
FIRM_API ir_node *new_Bound(ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper);

/**
 * Construct a Builtin node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param kind      kind of builtin
 * @param type      method type for the builtin call
*/
FIRM_API ir_node *new_rd_Builtin(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type);

/**
 * Construct a Builtin node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param kind      kind of builtin
 * @param type      method type for the builtin call
*/
FIRM_API ir_node *new_r_Builtin(ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type);

/**
 * Construct a Builtin node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param kind      kind of builtin
 * @param type      method type for the builtin call
*/
FIRM_API ir_node *new_d_Builtin(dbg_info *dbgi, ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type);

/**
 * Construct a Builtin node.
 *
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param kind      kind of builtin
 * @param type      method type for the builtin call
*/
FIRM_API ir_node *new_Builtin(ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type);

/**
 * Construct a Call node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to called code
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param type      type of the call (usually type of the called procedure)
*/
FIRM_API ir_node *new_rd_Call(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type);

/**
 * Construct a Call node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to called code
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param type      type of the call (usually type of the called procedure)
*/
FIRM_API ir_node *new_r_Call(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type);

/**
 * Construct a Call node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to called code
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param type      type of the call (usually type of the called procedure)
*/
FIRM_API ir_node *new_d_Call(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type);

/**
 * Construct a Call node.
 *
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to called code
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param type      type of the call (usually type of the called procedure)
*/
FIRM_API ir_node *new_Call(ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type);

/**
 * Construct a Carry node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Carry(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Carry node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Carry(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Carry node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Carry(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Carry node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Carry(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Cast node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param type      target type of the case
*/
FIRM_API ir_node *new_rd_Cast(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_type* type);

/**
 * Construct a Cast node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param type      target type of the case
*/
FIRM_API ir_node *new_r_Cast(ir_node *block, ir_node * irn_op, ir_type* type);

/**
 * Construct a Cast node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_op    operand
 * @param type      target type of the case
*/
FIRM_API ir_node *new_d_Cast(dbg_info *dbgi, ir_node * irn_op, ir_type* type);

/**
 * Construct a Cast node.
 *
 * @param irn_op    operand
 * @param type      target type of the case
*/
FIRM_API ir_node *new_Cast(ir_node * irn_op, ir_type* type);

/**
 * Construct a Cmp node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param relation  Comparison relation
*/
FIRM_API ir_node *new_rd_Cmp(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_relation relation);

/**
 * Construct a Cmp node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param relation  Comparison relation
*/
FIRM_API ir_node *new_r_Cmp(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_relation relation);

/**
 * Construct a Cmp node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param relation  Comparison relation
*/
FIRM_API ir_node *new_d_Cmp(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_relation relation);

/**
 * Construct a Cmp node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param relation  Comparison relation
*/
FIRM_API ir_node *new_Cmp(ir_node * irn_left, ir_node * irn_right, ir_relation relation);

/**
 * Construct a Cond node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_selector condition parameter
*/
FIRM_API ir_node *new_rd_Cond(dbg_info *dbgi, ir_node *block, ir_node * irn_selector);

/**
 * Construct a Cond node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_selector condition parameter
*/
FIRM_API ir_node *new_r_Cond(ir_node *block, ir_node * irn_selector);

/**
 * Construct a Cond node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_selector condition parameter
*/
FIRM_API ir_node *new_d_Cond(dbg_info *dbgi, ir_node * irn_selector);

/**
 * Construct a Cond node.
 *
 * @param irn_selector condition parameter
*/
FIRM_API ir_node *new_Cond(ir_node * irn_selector);

/**
 * Construct a Confirm node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_value value to express a constraint for
 * @param irn_bound value to compare against
 * @param relation  relation of value to bound
*/
FIRM_API ir_node *new_rd_Confirm(dbg_info *dbgi, ir_node *block, ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

/**
 * Construct a Confirm node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_value value to express a constraint for
 * @param irn_bound value to compare against
 * @param relation  relation of value to bound
*/
FIRM_API ir_node *new_r_Confirm(ir_node *block, ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

/**
 * Construct a Confirm node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_value value to express a constraint for
 * @param irn_bound value to compare against
 * @param relation  relation of value to bound
*/
FIRM_API ir_node *new_d_Confirm(dbg_info *dbgi, ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

/**
 * Construct a Confirm node.
 *
 * @param irn_value value to express a constraint for
 * @param irn_bound value to compare against
 * @param relation  relation of value to bound
*/
FIRM_API ir_node *new_Confirm(ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

/**
 * Construct a Const node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
 * @param tarval    constant value (a tarval object)
*/
FIRM_API ir_node *new_rd_Const(dbg_info *dbgi, ir_graph *irg, ir_tarval* tarval);

/**
 * Construct a Const node.
 *
 * @param irg       The IR graph the node belongs to.
 * @param tarval    constant value (a tarval object)
*/
FIRM_API ir_node *new_r_Const(ir_graph *irg, ir_tarval* tarval);

/**
 * Construct a Const node.
 *
 * @param dbgi      A pointer to debug information.
 * @param tarval    constant value (a tarval object)
*/
FIRM_API ir_node *new_d_Const(dbg_info *dbgi, ir_tarval* tarval);

/**
 * Construct a Const node.
 *
 * @param tarval    constant value (a tarval object)
*/
FIRM_API ir_node *new_Const(ir_tarval* tarval);

/**
 * Construct a Conv node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Conv(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Conv node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Conv(ir_node *block, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Conv node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Conv(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Conv node.
 *
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Conv(ir_node * irn_op, ir_mode * mode);

/**
 * Construct a CopyB node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_dst   destination address
 * @param irn_src   source address
 * @param type      type of copied data
*/
FIRM_API ir_node *new_rd_CopyB(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type);

/**
 * Construct a CopyB node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_dst   destination address
 * @param irn_src   source address
 * @param type      type of copied data
*/
FIRM_API ir_node *new_r_CopyB(ir_node *block, ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type);

/**
 * Construct a CopyB node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_dst   destination address
 * @param irn_src   source address
 * @param type      type of copied data
*/
FIRM_API ir_node *new_d_CopyB(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type);

/**
 * Construct a CopyB node.
 *
 * @param irn_mem   memory dependency
 * @param irn_dst   destination address
 * @param irn_src   source address
 * @param type      type of copied data
*/
FIRM_API ir_node *new_CopyB(ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type);


/**
 * Construct a Div node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result value
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_rd_Div(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Div node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result value
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_r_Div(ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Div node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result value
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_d_Div(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Div node.
 *
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result value
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_Div(ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Dummy node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Dummy(dbg_info *dbgi, ir_graph *irg, ir_mode * mode);

/**
 * Construct a Dummy node.
 *
 * @param irg       The IR graph the node belongs to.
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Dummy(ir_graph *irg, ir_mode * mode);

/**
 * Construct a Dummy node.
 *
 * @param dbgi      A pointer to debug information.
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Dummy(dbg_info *dbgi, ir_mode * mode);

/**
 * Construct a Dummy node.
 *
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Dummy(ir_mode * mode);

/**
 * Construct an End node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_rd_End(dbg_info *dbgi, ir_graph *irg, int arity, ir_node *const * in);

/**
 * Construct an End node.
 *
 * @param irg       The IR graph the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_r_End(ir_graph *irg, int arity, ir_node *const * in);

/**
 * Construct an End node.
 *
 * @param dbgi      A pointer to debug information.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_d_End(dbg_info *dbgi, int arity, ir_node *const * in);

/**
 * Construct an End node.
 *
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_End(int arity, ir_node *const * in);

/**
 * Construct an Eor node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Eor(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Eor node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Eor(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Eor node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Eor(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Eor node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Eor(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Free node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to the object to free
 * @param irn_size  number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether allocation was on the stack or heap
*/
FIRM_API ir_node *new_rd_Free(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_size, ir_type* type, ir_where_alloc where);

/**
 * Construct a Free node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to the object to free
 * @param irn_size  number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether allocation was on the stack or heap
*/
FIRM_API ir_node *new_r_Free(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_size, ir_type* type, ir_where_alloc where);

/**
 * Construct a Free node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to the object to free
 * @param irn_size  number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether allocation was on the stack or heap
*/
FIRM_API ir_node *new_d_Free(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_size, ir_type* type, ir_where_alloc where);

/**
 * Construct a Free node.
 *
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to the object to free
 * @param irn_size  number of objects to allocate
 * @param type      type of the allocated variable
 * @param where     whether allocation was on the stack or heap
*/
FIRM_API ir_node *new_Free(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_size, ir_type* type, ir_where_alloc where);

/**
 * Construct an IJmp node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_target target address of the jump
*/
FIRM_API ir_node *new_rd_IJmp(dbg_info *dbgi, ir_node *block, ir_node * irn_target);

/**
 * Construct an IJmp node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_target target address of the jump
*/
FIRM_API ir_node *new_r_IJmp(ir_node *block, ir_node * irn_target);

/**
 * Construct an IJmp node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_target target address of the jump
*/
FIRM_API ir_node *new_d_IJmp(dbg_info *dbgi, ir_node * irn_target);

/**
 * Construct an IJmp node.
 *
 * @param irn_target target address of the jump
*/
FIRM_API ir_node *new_IJmp(ir_node * irn_target);

/**
 * Construct an Id node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_pred  the value which is returned unchanged
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Id(dbg_info *dbgi, ir_node *block, ir_node * irn_pred, ir_mode * mode);

/**
 * Construct an Id node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_pred  the value which is returned unchanged
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Id(ir_node *block, ir_node * irn_pred, ir_mode * mode);

/**
 * Construct an Id node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_pred  the value which is returned unchanged
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Id(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode);

/**
 * Construct an Id node.
 *
 * @param irn_pred  the value which is returned unchanged
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Id(ir_node * irn_pred, ir_mode * mode);

/**
 * Construct an InstOf node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_store memory dependency
 * @param irn_obj   pointer to object being queried
 * @param type      type to check ptr for
*/
FIRM_API ir_node *new_rd_InstOf(dbg_info *dbgi, ir_node *block, ir_node * irn_store, ir_node * irn_obj, ir_type* type);

/**
 * Construct an InstOf node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_store memory dependency
 * @param irn_obj   pointer to object being queried
 * @param type      type to check ptr for
*/
FIRM_API ir_node *new_r_InstOf(ir_node *block, ir_node * irn_store, ir_node * irn_obj, ir_type* type);

/**
 * Construct an InstOf node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_store memory dependency
 * @param irn_obj   pointer to object being queried
 * @param type      type to check ptr for
*/
FIRM_API ir_node *new_d_InstOf(dbg_info *dbgi, ir_node * irn_store, ir_node * irn_obj, ir_type* type);

/**
 * Construct an InstOf node.
 *
 * @param irn_store memory dependency
 * @param irn_obj   pointer to object being queried
 * @param type      type to check ptr for
*/
FIRM_API ir_node *new_InstOf(ir_node * irn_store, ir_node * irn_obj, ir_type* type);

/**
 * Construct a Jmp node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
*/
FIRM_API ir_node *new_rd_Jmp(dbg_info *dbgi, ir_node *block);

/**
 * Construct a Jmp node.
 *
 * @param block     The IR block the node belongs to.
*/
FIRM_API ir_node *new_r_Jmp(ir_node *block);

/**
 * Construct a Jmp node.
 *
 * @param dbgi      A pointer to debug information.
*/
FIRM_API ir_node *new_d_Jmp(dbg_info *dbgi);

/**
 * Construct a Jmp node.
 *
*/
FIRM_API ir_node *new_Jmp(void);

/**
 * Construct a Load node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to load from
 * @param mode      mode of the value to be loaded
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_rd_Load(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags);

/**
 * Construct a Load node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to load from
 * @param mode      mode of the value to be loaded
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_r_Load(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags);

/**
 * Construct a Load node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to load from
 * @param mode      mode of the value to be loaded
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_d_Load(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags);

/**
 * Construct a Load node.
 *
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to load from
 * @param mode      mode of the value to be loaded
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_Load(ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags);

/**
 * Construct a Minus node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Minus(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Minus node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Minus(ir_node *block, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Minus node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Minus(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Minus node.
 *
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Minus(ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Mod node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_rd_Mod(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Mod node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_r_Mod(ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Mod node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_d_Mod(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Mod node.
 *
 * @param irn_mem   memory dependency
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param resmode   mode of the result
 * @param pin_state pinned state
*/
FIRM_API ir_node *new_Mod(ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state);

/**
 * Construct a Mul node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Mul(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mul node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Mul(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mul node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Mul(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mul node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Mul(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mulh node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Mulh(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mulh node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Mulh(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mulh node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Mulh(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mulh node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Mulh(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Mux node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_sel   value making the output selection
 * @param irn_false selected if sel input is false
 * @param irn_true  selected if sel input is true
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Mux(dbg_info *dbgi, ir_node *block, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode);

/**
 * Construct a Mux node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_sel   value making the output selection
 * @param irn_false selected if sel input is false
 * @param irn_true  selected if sel input is true
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Mux(ir_node *block, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode);

/**
 * Construct a Mux node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_sel   value making the output selection
 * @param irn_false selected if sel input is false
 * @param irn_true  selected if sel input is true
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Mux(dbg_info *dbgi, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode);

/**
 * Construct a Mux node.
 *
 * @param irn_sel   value making the output selection
 * @param irn_false selected if sel input is false
 * @param irn_true  selected if sel input is true
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Mux(ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode);

/**
 * Construct a NoMem node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
*/
FIRM_API ir_node *new_rd_NoMem(dbg_info *dbgi, ir_graph *irg);

/**
 * Construct a NoMem node.
 *
 * @param irg       The IR graph the node belongs to.
*/
FIRM_API ir_node *new_r_NoMem(ir_graph *irg);

/**
 * Construct a NoMem node.
 *
 * @param dbgi      A pointer to debug information.
*/
FIRM_API ir_node *new_d_NoMem(dbg_info *dbgi);

/**
 * Construct a NoMem node.
 *
*/
FIRM_API ir_node *new_NoMem(void);

/**
 * Construct a Not node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Not(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Not node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Not(ir_node *block, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Not node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Not(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode);

/**
 * Construct a Not node.
 *
 * @param irn_op    operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Not(ir_node * irn_op, ir_mode * mode);

/**
 * Construct an Or node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Or(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Or node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Or(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Or node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Or(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct an Or node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Or(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Phi node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Phi(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in, ir_mode * mode);

/**
 * Construct a Phi node.
 *
 * @param block     The IR block the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Phi(ir_node *block, int arity, ir_node *const * in, ir_mode * mode);

/**
 * Construct a Phi node.
 *
 * @param dbgi      A pointer to debug information.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Phi(dbg_info *dbgi, int arity, ir_node *const * in, ir_mode * mode);

/**
 * Construct a Phi node.
 *
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Phi(int arity, ir_node *const * in, ir_mode * mode);

/**
 * Construct a Pin node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_op    value which is pinned
*/
FIRM_API ir_node *new_rd_Pin(dbg_info *dbgi, ir_node *block, ir_node * irn_op);

/**
 * Construct a Pin node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_op    value which is pinned
*/
FIRM_API ir_node *new_r_Pin(ir_node *block, ir_node * irn_op);

/**
 * Construct a Pin node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_op    value which is pinned
*/
FIRM_API ir_node *new_d_Pin(dbg_info *dbgi, ir_node * irn_op);

/**
 * Construct a Pin node.
 *
 * @param irn_op    value which is pinned
*/
FIRM_API ir_node *new_Pin(ir_node * irn_op);

/**
 * Construct a Proj node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_pred  the tuple value from which a part is extracted
 * @param mode      mode of the operations result
 * @param proj      number of tuple component to be extracted
*/
FIRM_API ir_node *new_rd_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, long proj);

/**
 * Construct a Proj node.
 *
 * @param irn_pred  the tuple value from which a part is extracted
 * @param mode      mode of the operations result
 * @param proj      number of tuple component to be extracted
*/
FIRM_API ir_node *new_r_Proj(ir_node * irn_pred, ir_mode * mode, long proj);

/**
 * Construct a Proj node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_pred  the tuple value from which a part is extracted
 * @param mode      mode of the operations result
 * @param proj      number of tuple component to be extracted
*/
FIRM_API ir_node *new_d_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, long proj);

/**
 * Construct a Proj node.
 *
 * @param irn_pred  the tuple value from which a part is extracted
 * @param mode      mode of the operations result
 * @param proj      number of tuple component to be extracted
*/
FIRM_API ir_node *new_Proj(ir_node * irn_pred, ir_mode * mode, long proj);

/**
 * Construct a Raise node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_exo_ptr pointer to exception object to be thrown
*/
FIRM_API ir_node *new_rd_Raise(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_exo_ptr);

/**
 * Construct a Raise node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_exo_ptr pointer to exception object to be thrown
*/
FIRM_API ir_node *new_r_Raise(ir_node *block, ir_node * irn_mem, ir_node * irn_exo_ptr);

/**
 * Construct a Raise node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_exo_ptr pointer to exception object to be thrown
*/
FIRM_API ir_node *new_d_Raise(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_exo_ptr);

/**
 * Construct a Raise node.
 *
 * @param irn_mem   memory dependency
 * @param irn_exo_ptr pointer to exception object to be thrown
*/
FIRM_API ir_node *new_Raise(ir_node * irn_mem, ir_node * irn_exo_ptr);

/**
 * Construct a Return node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_rd_Return(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in);

/**
 * Construct a Return node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_r_Return(ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in);

/**
 * Construct a Return node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_d_Return(dbg_info *dbgi, ir_node * irn_mem, int arity, ir_node *const * in);

/**
 * Construct a Return node.
 *
 * @param irn_mem   memory dependency
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_Return(ir_node * irn_mem, int arity, ir_node *const * in);

/**
 * Construct a Rotl node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Rotl(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Rotl node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Rotl(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Rotl node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Rotl(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Rotl node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Rotl(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Sel node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to object to select from
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param entity    entity which is selected
*/
FIRM_API ir_node *new_rd_Sel(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity);

/**
 * Construct a Sel node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to object to select from
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param entity    entity which is selected
*/
FIRM_API ir_node *new_r_Sel(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity);

/**
 * Construct a Sel node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to object to select from
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param entity    entity which is selected
*/
FIRM_API ir_node *new_d_Sel(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity);

/**
 * Construct a Sel node.
 *
 * @param irn_mem   memory dependency
 * @param irn_ptr   pointer to object to select from
 * @param arity     size of additional inputs array
 * @param in        additional inputs
 * @param entity    entity which is selected
*/
FIRM_API ir_node *new_Sel(ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity);

/**
 * Construct a Shl node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Shl(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shl node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Shl(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shl node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Shl(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shl node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Shl(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shr node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Shr(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shr node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Shr(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shr node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Shr(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shr node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Shr(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shrs node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Shrs(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shrs node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Shrs(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shrs node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Shrs(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Shrs node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Shrs(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Start node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
*/
FIRM_API ir_node *new_rd_Start(dbg_info *dbgi, ir_graph *irg);

/**
 * Construct a Start node.
 *
 * @param irg       The IR graph the node belongs to.
*/
FIRM_API ir_node *new_r_Start(ir_graph *irg);

/**
 * Construct a Start node.
 *
 * @param dbgi      A pointer to debug information.
*/
FIRM_API ir_node *new_d_Start(dbg_info *dbgi);

/**
 * Construct a Start node.
 *
*/
FIRM_API ir_node *new_Start(void);

/**
 * Construct a Store node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to store to
 * @param irn_value value to store
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_rd_Store(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags);

/**
 * Construct a Store node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to store to
 * @param irn_value value to store
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_r_Store(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags);

/**
 * Construct a Store node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to store to
 * @param irn_value value to store
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_d_Store(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags);

/**
 * Construct a Store node.
 *
 * @param irn_mem   memory dependency
 * @param irn_ptr   address to store to
 * @param irn_value value to store
 * @param flags     specifies alignment, volatility and pin state
*/
FIRM_API ir_node *new_Store(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags);

/**
 * Construct a Sub node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Sub(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Sub node.
 *
 * @param block     The IR block the node belongs to.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Sub(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Sub node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Sub(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

/**
 * Construct a Sub node.
 *
 * @param irn_left  first operand
 * @param irn_right second operand
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Sub(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);


/**
 * Construct a Sync node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_rd_Sync(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in);

/**
 * Construct a Sync node.
 *
 * @param block     The IR block the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_r_Sync(ir_node *block, int arity, ir_node *const * in);

/**
 * Construct a Sync node.
 *
 * @param dbgi      A pointer to debug information.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_d_Sync(dbg_info *dbgi, int arity, ir_node *const * in);

/**
 * Construct a Sync node.
 *
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_Sync(int arity, ir_node *const * in);

/**
 * Construct a Tuple node.
 *
 * @param dbgi      A pointer to debug information.
 * @param block     The IR block the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_rd_Tuple(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in);

/**
 * Construct a Tuple node.
 *
 * @param block     The IR block the node belongs to.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_r_Tuple(ir_node *block, int arity, ir_node *const * in);

/**
 * Construct a Tuple node.
 *
 * @param dbgi      A pointer to debug information.
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_d_Tuple(dbg_info *dbgi, int arity, ir_node *const * in);

/**
 * Construct a Tuple node.
 *
 * @param arity     size of additional inputs array
 * @param in        additional inputs
*/
FIRM_API ir_node *new_Tuple(int arity, ir_node *const * in);

/**
 * Construct an Unknown node.
 *
 * @param dbgi      A pointer to debug information.
 * @param irg       The IR graph the node belongs to.
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_rd_Unknown(dbg_info *dbgi, ir_graph *irg, ir_mode * mode);

/**
 * Construct an Unknown node.
 *
 * @param irg       The IR graph the node belongs to.
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_r_Unknown(ir_graph *irg, ir_mode * mode);

/**
 * Construct an Unknown node.
 *
 * @param dbgi      A pointer to debug information.
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_d_Unknown(dbg_info *dbgi, ir_mode * mode);

/**
 * Construct an Unknown node.
 *
 * @param mode      mode of the operations result
*/
FIRM_API ir_node *new_Unknown(ir_mode * mode);



/** Return true of the node is a ASM node. */
FIRM_API int is_ASM(const ir_node *node);
/** Return true of the node is a Add node. */
FIRM_API int is_Add(const ir_node *node);
/** Return true of the node is a Alloc node. */
FIRM_API int is_Alloc(const ir_node *node);
/** Return true of the node is a Anchor node. */
FIRM_API int is_Anchor(const ir_node *node);
/** Return true of the node is a And node. */
FIRM_API int is_And(const ir_node *node);
/** Return true of the node is a Bad node. */
FIRM_API int is_Bad(const ir_node *node);
/** Return true of the node is a Block node. */
FIRM_API int is_Block(const ir_node *node);
/** Return true of the node is a Borrow node. */
FIRM_API int is_Borrow(const ir_node *node);
/** Return true of the node is a Bound node. */
FIRM_API int is_Bound(const ir_node *node);
/** Return true of the node is a Builtin node. */
FIRM_API int is_Builtin(const ir_node *node);
/** Return true of the node is a Call node. */
FIRM_API int is_Call(const ir_node *node);
/** Return true of the node is a Carry node. */
FIRM_API int is_Carry(const ir_node *node);
/** Return true of the node is a Cast node. */
FIRM_API int is_Cast(const ir_node *node);
/** Return true of the node is a Cmp node. */
FIRM_API int is_Cmp(const ir_node *node);
/** Return true of the node is a Cond node. */
FIRM_API int is_Cond(const ir_node *node);
/** Return true of the node is a Confirm node. */
FIRM_API int is_Confirm(const ir_node *node);
/** Return true of the node is a Const node. */
FIRM_API int is_Const(const ir_node *node);
/** Return true of the node is a Conv node. */
FIRM_API int is_Conv(const ir_node *node);
/** Return true of the node is a CopyB node. */
FIRM_API int is_CopyB(const ir_node *node);
/** Return true of the node is a Deleted node. */
FIRM_API int is_Deleted(const ir_node *node);
/** Return true of the node is a Div node. */
FIRM_API int is_Div(const ir_node *node);
/** Return true of the node is a Dummy node. */
FIRM_API int is_Dummy(const ir_node *node);
/** Return true of the node is a End node. */
FIRM_API int is_End(const ir_node *node);
/** Return true of the node is a Eor node. */
FIRM_API int is_Eor(const ir_node *node);
/** Return true of the node is a Free node. */
FIRM_API int is_Free(const ir_node *node);
/** Return true of the node is a IJmp node. */
FIRM_API int is_IJmp(const ir_node *node);
/** Return true of the node is a Id node. */
FIRM_API int is_Id(const ir_node *node);
/** Return true of the node is a InstOf node. */
FIRM_API int is_InstOf(const ir_node *node);
/** Return true of the node is a Jmp node. */
FIRM_API int is_Jmp(const ir_node *node);
/** Return true of the node is a Load node. */
FIRM_API int is_Load(const ir_node *node);
/** Return true of the node is a Minus node. */
FIRM_API int is_Minus(const ir_node *node);
/** Return true of the node is a Mod node. */
FIRM_API int is_Mod(const ir_node *node);
/** Return true of the node is a Mul node. */
FIRM_API int is_Mul(const ir_node *node);
/** Return true of the node is a Mulh node. */
FIRM_API int is_Mulh(const ir_node *node);
/** Return true of the node is a Mux node. */
FIRM_API int is_Mux(const ir_node *node);
/** Return true of the node is a NoMem node. */
FIRM_API int is_NoMem(const ir_node *node);
/** Return true of the node is a Not node. */
FIRM_API int is_Not(const ir_node *node);
/** Return true of the node is a Or node. */
FIRM_API int is_Or(const ir_node *node);
/** Return true of the node is a Phi node. */
FIRM_API int is_Phi(const ir_node *node);
/** Return true of the node is a Pin node. */
FIRM_API int is_Pin(const ir_node *node);
/** Return true of the node is a Proj node. */
FIRM_API int is_Proj(const ir_node *node);
/** Return true of the node is a Raise node. */
FIRM_API int is_Raise(const ir_node *node);
/** Return true of the node is a Return node. */
FIRM_API int is_Return(const ir_node *node);
/** Return true of the node is a Rotl node. */
FIRM_API int is_Rotl(const ir_node *node);
/** Return true of the node is a Sel node. */
FIRM_API int is_Sel(const ir_node *node);
/** Return true of the node is a Shl node. */
FIRM_API int is_Shl(const ir_node *node);
/** Return true of the node is a Shr node. */
FIRM_API int is_Shr(const ir_node *node);
/** Return true of the node is a Shrs node. */
FIRM_API int is_Shrs(const ir_node *node);
/** Return true of the node is a Start node. */
FIRM_API int is_Start(const ir_node *node);
/** Return true of the node is a Store node. */
FIRM_API int is_Store(const ir_node *node);
/** Return true of the node is a Sub node. */
FIRM_API int is_Sub(const ir_node *node);
/** Return true of the node is a SymConst node. */
FIRM_API int is_SymConst(const ir_node *node);
/** Return true of the node is a Sync node. */
FIRM_API int is_Sync(const ir_node *node);
/** Return true of the node is a Tuple node. */
FIRM_API int is_Tuple(const ir_node *node);
/** Return true of the node is a Unknown node. */
FIRM_API int is_Unknown(const ir_node *node);


FIRM_API ir_asm_constraint* get_ASM_input_constraints(const ir_node *node);
FIRM_API void set_ASM_input_constraints(ir_node *node, ir_asm_constraint* input_constraints);
FIRM_API ir_asm_constraint* get_ASM_output_constraints(const ir_node *node);
FIRM_API void set_ASM_output_constraints(ir_node *node, ir_asm_constraint* output_constraints);
FIRM_API ident** get_ASM_clobbers(const ir_node *node);
FIRM_API void set_ASM_clobbers(ir_node *node, ident** clobbers);
FIRM_API ident* get_ASM_text(const ir_node *node);
FIRM_API void set_ASM_text(ir_node *node, ident* text);

FIRM_API ir_node *get_Add_left(const ir_node *node);
FIRM_API void set_Add_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Add_right(const ir_node *node);
FIRM_API void set_Add_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Alloc_mem(const ir_node *node);
FIRM_API void set_Alloc_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Alloc_count(const ir_node *node);
FIRM_API void set_Alloc_count(ir_node *node, ir_node *count);
FIRM_API ir_type* get_Alloc_type(const ir_node *node);
FIRM_API void set_Alloc_type(ir_node *node, ir_type* type);
FIRM_API ir_where_alloc get_Alloc_where(const ir_node *node);
FIRM_API void set_Alloc_where(ir_node *node, ir_where_alloc where);


FIRM_API ir_node *get_And_left(const ir_node *node);
FIRM_API void set_And_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_And_right(const ir_node *node);
FIRM_API void set_And_right(ir_node *node, ir_node *right);



FIRM_API ir_node *get_Borrow_left(const ir_node *node);
FIRM_API void set_Borrow_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Borrow_right(const ir_node *node);
FIRM_API void set_Borrow_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Bound_mem(const ir_node *node);
FIRM_API void set_Bound_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Bound_index(const ir_node *node);
FIRM_API void set_Bound_index(ir_node *node, ir_node *index);
FIRM_API ir_node *get_Bound_lower(const ir_node *node);
FIRM_API void set_Bound_lower(ir_node *node, ir_node *lower);
FIRM_API ir_node *get_Bound_upper(const ir_node *node);
FIRM_API void set_Bound_upper(ir_node *node, ir_node *upper);

FIRM_API ir_node *get_Builtin_mem(const ir_node *node);
FIRM_API void set_Builtin_mem(ir_node *node, ir_node *mem);
FIRM_API ir_builtin_kind get_Builtin_kind(const ir_node *node);
FIRM_API void set_Builtin_kind(ir_node *node, ir_builtin_kind kind);
FIRM_API ir_type* get_Builtin_type(const ir_node *node);
FIRM_API void set_Builtin_type(ir_node *node, ir_type* type);

FIRM_API ir_node *get_Call_mem(const ir_node *node);
FIRM_API void set_Call_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Call_ptr(const ir_node *node);
FIRM_API void set_Call_ptr(ir_node *node, ir_node *ptr);
FIRM_API ir_type* get_Call_type(const ir_node *node);
FIRM_API void set_Call_type(ir_node *node, ir_type* type);
FIRM_API unsigned get_Call_tail_call(const ir_node *node);
FIRM_API void set_Call_tail_call(ir_node *node, unsigned tail_call);

FIRM_API ir_node *get_Carry_left(const ir_node *node);
FIRM_API void set_Carry_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Carry_right(const ir_node *node);
FIRM_API void set_Carry_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Cast_op(const ir_node *node);
FIRM_API void set_Cast_op(ir_node *node, ir_node *op);
FIRM_API ir_type* get_Cast_type(const ir_node *node);
FIRM_API void set_Cast_type(ir_node *node, ir_type* type);

FIRM_API ir_node *get_Cmp_left(const ir_node *node);
FIRM_API void set_Cmp_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Cmp_right(const ir_node *node);
FIRM_API void set_Cmp_right(ir_node *node, ir_node *right);
FIRM_API ir_relation get_Cmp_relation(const ir_node *node);
FIRM_API void set_Cmp_relation(ir_node *node, ir_relation relation);

FIRM_API ir_node *get_Cond_selector(const ir_node *node);
FIRM_API void set_Cond_selector(ir_node *node, ir_node *selector);
FIRM_API long get_Cond_default_proj(const ir_node *node);
FIRM_API void set_Cond_default_proj(ir_node *node, long default_proj);
FIRM_API cond_jmp_predicate get_Cond_jmp_pred(const ir_node *node);
FIRM_API void set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate jmp_pred);

FIRM_API ir_node *get_Confirm_value(const ir_node *node);
FIRM_API void set_Confirm_value(ir_node *node, ir_node *value);
FIRM_API ir_node *get_Confirm_bound(const ir_node *node);
FIRM_API void set_Confirm_bound(ir_node *node, ir_node *bound);
FIRM_API ir_relation get_Confirm_relation(const ir_node *node);
FIRM_API void set_Confirm_relation(ir_node *node, ir_relation relation);

FIRM_API ir_tarval* get_Const_tarval(const ir_node *node);
FIRM_API void set_Const_tarval(ir_node *node, ir_tarval* tarval);

FIRM_API ir_node *get_Conv_op(const ir_node *node);
FIRM_API void set_Conv_op(ir_node *node, ir_node *op);
FIRM_API int get_Conv_strict(const ir_node *node);
FIRM_API void set_Conv_strict(ir_node *node, int strict);

FIRM_API ir_node *get_CopyB_mem(const ir_node *node);
FIRM_API void set_CopyB_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_CopyB_dst(const ir_node *node);
FIRM_API void set_CopyB_dst(ir_node *node, ir_node *dst);
FIRM_API ir_node *get_CopyB_src(const ir_node *node);
FIRM_API void set_CopyB_src(ir_node *node, ir_node *src);
FIRM_API ir_type* get_CopyB_type(const ir_node *node);
FIRM_API void set_CopyB_type(ir_node *node, ir_type* type);


FIRM_API ir_node *get_Div_mem(const ir_node *node);
FIRM_API void set_Div_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Div_left(const ir_node *node);
FIRM_API void set_Div_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Div_right(const ir_node *node);
FIRM_API void set_Div_right(ir_node *node, ir_node *right);
FIRM_API ir_mode* get_Div_resmode(const ir_node *node);
FIRM_API void set_Div_resmode(ir_node *node, ir_mode* resmode);
FIRM_API int get_Div_no_remainder(const ir_node *node);
FIRM_API void set_Div_no_remainder(ir_node *node, int no_remainder);



FIRM_API ir_node *get_Eor_left(const ir_node *node);
FIRM_API void set_Eor_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Eor_right(const ir_node *node);
FIRM_API void set_Eor_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Free_mem(const ir_node *node);
FIRM_API void set_Free_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Free_ptr(const ir_node *node);
FIRM_API void set_Free_ptr(ir_node *node, ir_node *ptr);
FIRM_API ir_node *get_Free_size(const ir_node *node);
FIRM_API void set_Free_size(ir_node *node, ir_node *size);
FIRM_API ir_type* get_Free_type(const ir_node *node);
FIRM_API void set_Free_type(ir_node *node, ir_type* type);
FIRM_API ir_where_alloc get_Free_where(const ir_node *node);
FIRM_API void set_Free_where(ir_node *node, ir_where_alloc where);

FIRM_API ir_node *get_IJmp_target(const ir_node *node);
FIRM_API void set_IJmp_target(ir_node *node, ir_node *target);

FIRM_API ir_node *get_Id_pred(const ir_node *node);
FIRM_API void set_Id_pred(ir_node *node, ir_node *pred);

FIRM_API ir_node *get_InstOf_store(const ir_node *node);
FIRM_API void set_InstOf_store(ir_node *node, ir_node *store);
FIRM_API ir_node *get_InstOf_obj(const ir_node *node);
FIRM_API void set_InstOf_obj(ir_node *node, ir_node *obj);
FIRM_API ir_type* get_InstOf_type(const ir_node *node);
FIRM_API void set_InstOf_type(ir_node *node, ir_type* type);


FIRM_API ir_node *get_Load_mem(const ir_node *node);
FIRM_API void set_Load_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Load_ptr(const ir_node *node);
FIRM_API void set_Load_ptr(ir_node *node, ir_node *ptr);
FIRM_API ir_mode* get_Load_mode(const ir_node *node);
FIRM_API void set_Load_mode(ir_node *node, ir_mode* mode);
FIRM_API ir_volatility get_Load_volatility(const ir_node *node);
FIRM_API void set_Load_volatility(ir_node *node, ir_volatility volatility);
FIRM_API ir_align get_Load_unaligned(const ir_node *node);
FIRM_API void set_Load_unaligned(ir_node *node, ir_align unaligned);

FIRM_API ir_node *get_Minus_op(const ir_node *node);
FIRM_API void set_Minus_op(ir_node *node, ir_node *op);

FIRM_API ir_node *get_Mod_mem(const ir_node *node);
FIRM_API void set_Mod_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Mod_left(const ir_node *node);
FIRM_API void set_Mod_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Mod_right(const ir_node *node);
FIRM_API void set_Mod_right(ir_node *node, ir_node *right);
FIRM_API ir_mode* get_Mod_resmode(const ir_node *node);
FIRM_API void set_Mod_resmode(ir_node *node, ir_mode* resmode);

FIRM_API ir_node *get_Mul_left(const ir_node *node);
FIRM_API void set_Mul_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Mul_right(const ir_node *node);
FIRM_API void set_Mul_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Mulh_left(const ir_node *node);
FIRM_API void set_Mulh_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Mulh_right(const ir_node *node);
FIRM_API void set_Mulh_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Mux_sel(const ir_node *node);
FIRM_API void set_Mux_sel(ir_node *node, ir_node *sel);
FIRM_API ir_node *get_Mux_false(const ir_node *node);
FIRM_API void set_Mux_false(ir_node *node, ir_node *false_);
FIRM_API ir_node *get_Mux_true(const ir_node *node);
FIRM_API void set_Mux_true(ir_node *node, ir_node *true_);


FIRM_API ir_node *get_Not_op(const ir_node *node);
FIRM_API void set_Not_op(ir_node *node, ir_node *op);

FIRM_API ir_node *get_Or_left(const ir_node *node);
FIRM_API void set_Or_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Or_right(const ir_node *node);
FIRM_API void set_Or_right(ir_node *node, ir_node *right);


FIRM_API ir_node *get_Pin_op(const ir_node *node);
FIRM_API void set_Pin_op(ir_node *node, ir_node *op);

FIRM_API ir_node *get_Proj_pred(const ir_node *node);
FIRM_API void set_Proj_pred(ir_node *node, ir_node *pred);
FIRM_API long get_Proj_proj(const ir_node *node);
FIRM_API void set_Proj_proj(ir_node *node, long proj);

FIRM_API ir_node *get_Raise_mem(const ir_node *node);
FIRM_API void set_Raise_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Raise_exo_ptr(const ir_node *node);
FIRM_API void set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr);

FIRM_API ir_node *get_Return_mem(const ir_node *node);
FIRM_API void set_Return_mem(ir_node *node, ir_node *mem);

FIRM_API ir_node *get_Rotl_left(const ir_node *node);
FIRM_API void set_Rotl_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Rotl_right(const ir_node *node);
FIRM_API void set_Rotl_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Sel_mem(const ir_node *node);
FIRM_API void set_Sel_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Sel_ptr(const ir_node *node);
FIRM_API void set_Sel_ptr(ir_node *node, ir_node *ptr);
FIRM_API ir_entity* get_Sel_entity(const ir_node *node);
FIRM_API void set_Sel_entity(ir_node *node, ir_entity* entity);

FIRM_API ir_node *get_Shl_left(const ir_node *node);
FIRM_API void set_Shl_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Shl_right(const ir_node *node);
FIRM_API void set_Shl_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Shr_left(const ir_node *node);
FIRM_API void set_Shr_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Shr_right(const ir_node *node);
FIRM_API void set_Shr_right(ir_node *node, ir_node *right);

FIRM_API ir_node *get_Shrs_left(const ir_node *node);
FIRM_API void set_Shrs_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Shrs_right(const ir_node *node);
FIRM_API void set_Shrs_right(ir_node *node, ir_node *right);


FIRM_API ir_node *get_Store_mem(const ir_node *node);
FIRM_API void set_Store_mem(ir_node *node, ir_node *mem);
FIRM_API ir_node *get_Store_ptr(const ir_node *node);
FIRM_API void set_Store_ptr(ir_node *node, ir_node *ptr);
FIRM_API ir_node *get_Store_value(const ir_node *node);
FIRM_API void set_Store_value(ir_node *node, ir_node *value);
FIRM_API ir_volatility get_Store_volatility(const ir_node *node);
FIRM_API void set_Store_volatility(ir_node *node, ir_volatility volatility);
FIRM_API ir_align get_Store_unaligned(const ir_node *node);
FIRM_API void set_Store_unaligned(ir_node *node, ir_align unaligned);

FIRM_API ir_node *get_Sub_left(const ir_node *node);
FIRM_API void set_Sub_left(ir_node *node, ir_node *left);
FIRM_API ir_node *get_Sub_right(const ir_node *node);
FIRM_API void set_Sub_right(ir_node *node, ir_node *right);




/** @} */

#endif
