nodeops.h

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

#include "firm_types.h"

#include "begin.h"

typedef enum {
    n_ASM_mem,
    n_ASM_max = n_ASM_mem
} n_ASM;


FIRM_API int is_ASM(const ir_node *node);

FIRM_API ir_node *get_ASM_mem(const ir_node *node);
FIRM_API void set_ASM_mem(ir_node *node, ir_node *mem);
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);
typedef enum {
    n_Add_left,
    n_Add_right,
    n_Add_max = n_Add_right
} n_Add;


FIRM_API ir_node *new_rd_Add(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Add(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Add(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Add(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Add(const ir_node *node);

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);
typedef enum {
    n_Alloc_mem,
    n_Alloc_count,
    n_Alloc_max = n_Alloc_count
} n_Alloc;


typedef enum {
    pn_Alloc_M, 
    pn_Alloc_res, 
    pn_Alloc_X_regular, 
    pn_Alloc_X_except, 
    pn_Alloc_max = pn_Alloc_X_except
} pn_Alloc;

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);

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);

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);

FIRM_API ir_node *new_Alloc(ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where);
FIRM_API int is_Alloc(const ir_node *node);

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 int is_Anchor(const ir_node *node);

typedef enum {
    n_And_left,
    n_And_right,
    n_And_max = n_And_right
} n_And;


FIRM_API ir_node *new_rd_And(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_And(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_And(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_And(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_And(const ir_node *node);

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 *new_rd_Bad(dbg_info *dbgi, ir_graph *irg, ir_mode * mode);

FIRM_API ir_node *new_r_Bad(ir_graph *irg, ir_mode * mode);

FIRM_API ir_node *new_d_Bad(dbg_info *dbgi, ir_mode * mode);

FIRM_API ir_node *new_Bad(ir_mode * mode);
FIRM_API int is_Bad(const ir_node *node);

FIRM_API ir_node *new_rd_Block(dbg_info *dbgi, ir_graph *irg, int arity, ir_node *const * in);

FIRM_API ir_node *new_r_Block(ir_graph *irg, int arity, ir_node *const * in);

FIRM_API ir_node *new_d_Block(dbg_info *dbgi, int arity, ir_node *const * in);

FIRM_API ir_node *new_Block(int arity, ir_node *const * in);
FIRM_API int is_Block(const ir_node *node);

FIRM_API ir_entity* get_Block_entity(const ir_node *node);
FIRM_API void set_Block_entity(ir_node *node, ir_entity* entity);
typedef enum {
    n_Borrow_left,
    n_Borrow_right,
    n_Borrow_max = n_Borrow_right
} n_Borrow;


FIRM_API ir_node *new_rd_Borrow(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Borrow(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Borrow(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Borrow(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Borrow(const ir_node *node);

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);
typedef enum {
    n_Bound_mem,
    n_Bound_index,
    n_Bound_lower,
    n_Bound_upper,
    n_Bound_max = n_Bound_upper
} n_Bound;


typedef enum {
    pn_Bound_M, 
    pn_Bound_res, 
    pn_Bound_X_regular, 
    pn_Bound_X_except, 
    pn_Bound_max = pn_Bound_X_except
} pn_Bound;

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);

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);

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);

FIRM_API ir_node *new_Bound(ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper);
FIRM_API int is_Bound(const ir_node *node);

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);
typedef enum {
    n_Builtin_mem,
    n_Builtin_max = n_Builtin_mem
} n_Builtin;


typedef enum {
    pn_Builtin_M, 
    pn_Builtin_max = pn_Builtin_M
} pn_Builtin;

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);

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);

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);

FIRM_API ir_node *new_Builtin(ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type);
FIRM_API int is_Builtin(const ir_node *node);

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);
typedef enum {
    n_Call_mem,
    n_Call_ptr,
    n_Call_max = n_Call_ptr
} n_Call;


typedef enum {
    pn_Call_M, 
    pn_Call_T_result, 
    pn_Call_X_regular, 
    pn_Call_X_except, 
    pn_Call_max = pn_Call_X_except
} pn_Call;

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);

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);

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);

FIRM_API ir_node *new_Call(ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type);
FIRM_API int is_Call(const ir_node *node);

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);
typedef enum {
    n_Carry_left,
    n_Carry_right,
    n_Carry_max = n_Carry_right
} n_Carry;


FIRM_API ir_node *new_rd_Carry(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Carry(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Carry(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Carry(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Carry(const ir_node *node);

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);
typedef enum {
    n_Cast_op,
    n_Cast_max = n_Cast_op
} n_Cast;


FIRM_API ir_node *new_rd_Cast(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_type* type);

FIRM_API ir_node *new_r_Cast(ir_node *block, ir_node * irn_op, ir_type* type);

FIRM_API ir_node *new_d_Cast(dbg_info *dbgi, ir_node * irn_op, ir_type* type);

FIRM_API ir_node *new_Cast(ir_node * irn_op, ir_type* type);
FIRM_API int is_Cast(const ir_node *node);

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);
typedef enum {
    n_Cmp_left,
    n_Cmp_right,
    n_Cmp_max = n_Cmp_right
} n_Cmp;


FIRM_API ir_node *new_rd_Cmp(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_relation relation);

FIRM_API ir_node *new_r_Cmp(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_relation relation);

FIRM_API ir_node *new_d_Cmp(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_relation relation);

FIRM_API ir_node *new_Cmp(ir_node * irn_left, ir_node * irn_right, ir_relation relation);
FIRM_API int is_Cmp(const ir_node *node);

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);
typedef enum {
    n_Cond_selector,
    n_Cond_max = n_Cond_selector
} n_Cond;


typedef enum {
    pn_Cond_false, 
    pn_Cond_true, 
    pn_Cond_max = pn_Cond_true
} pn_Cond;

FIRM_API ir_node *new_rd_Cond(dbg_info *dbgi, ir_node *block, ir_node * irn_selector);

FIRM_API ir_node *new_r_Cond(ir_node *block, ir_node * irn_selector);

FIRM_API ir_node *new_d_Cond(dbg_info *dbgi, ir_node * irn_selector);

FIRM_API ir_node *new_Cond(ir_node * irn_selector);
FIRM_API int is_Cond(const ir_node *node);

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 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);
typedef enum {
    n_Confirm_value,
    n_Confirm_bound,
    n_Confirm_max = n_Confirm_bound
} n_Confirm;


FIRM_API ir_node *new_rd_Confirm(dbg_info *dbgi, ir_node *block, ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

FIRM_API ir_node *new_r_Confirm(ir_node *block, ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

FIRM_API ir_node *new_d_Confirm(dbg_info *dbgi, ir_node * irn_value, ir_node * irn_bound, ir_relation relation);

FIRM_API ir_node *new_Confirm(ir_node * irn_value, ir_node * irn_bound, ir_relation relation);
FIRM_API int is_Confirm(const ir_node *node);

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_node *new_rd_Const(dbg_info *dbgi, ir_graph *irg, ir_tarval* tarval);

FIRM_API ir_node *new_r_Const(ir_graph *irg, ir_tarval* tarval);

FIRM_API ir_node *new_d_Const(dbg_info *dbgi, ir_tarval* tarval);

FIRM_API ir_node *new_Const(ir_tarval* tarval);
FIRM_API int is_Const(const ir_node *node);

FIRM_API ir_tarval* get_Const_tarval(const ir_node *node);
FIRM_API void set_Const_tarval(ir_node *node, ir_tarval* tarval);
typedef enum {
    n_Conv_op,
    n_Conv_max = n_Conv_op
} n_Conv;


FIRM_API ir_node *new_rd_Conv(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_r_Conv(ir_node *block, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_d_Conv(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_Conv(ir_node * irn_op, ir_mode * mode);
FIRM_API int is_Conv(const ir_node *node);

FIRM_API ir_node *get_Conv_op(const ir_node *node);
FIRM_API void set_Conv_op(ir_node *node, ir_node *op);
typedef enum {
    n_CopyB_mem,
    n_CopyB_dst,
    n_CopyB_src,
    n_CopyB_max = n_CopyB_src
} n_CopyB;


typedef enum {
    pn_CopyB_M, 
    pn_CopyB_X_regular, 
    pn_CopyB_X_except, 
    pn_CopyB_max = pn_CopyB_X_except
} pn_CopyB;

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);

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);

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);

FIRM_API ir_node *new_CopyB(ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type);
FIRM_API int is_CopyB(const ir_node *node);

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 int is_Deleted(const ir_node *node);

typedef enum {
    n_Div_mem,
    n_Div_left,
    n_Div_right,
    n_Div_max = n_Div_right
} n_Div;


typedef enum {
    pn_Div_M, 
    pn_Div_res, 
    pn_Div_X_regular, 
    pn_Div_X_except, 
    pn_Div_max = pn_Div_X_except
} pn_Div;

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);

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);

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);

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);
FIRM_API int is_Div(const ir_node *node);

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 *new_rd_Dummy(dbg_info *dbgi, ir_graph *irg, ir_mode * mode);

FIRM_API ir_node *new_r_Dummy(ir_graph *irg, ir_mode * mode);

FIRM_API ir_node *new_d_Dummy(dbg_info *dbgi, ir_mode * mode);

FIRM_API ir_node *new_Dummy(ir_mode * mode);
FIRM_API int is_Dummy(const ir_node *node);

FIRM_API ir_node *new_rd_End(dbg_info *dbgi, ir_graph *irg, int arity, ir_node *const * in);

FIRM_API ir_node *new_r_End(ir_graph *irg, int arity, ir_node *const * in);

FIRM_API ir_node *new_d_End(dbg_info *dbgi, int arity, ir_node *const * in);

FIRM_API ir_node *new_End(int arity, ir_node *const * in);
FIRM_API int is_End(const ir_node *node);

typedef enum {
    n_Eor_left,
    n_Eor_right,
    n_Eor_max = n_Eor_right
} n_Eor;


FIRM_API ir_node *new_rd_Eor(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Eor(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Eor(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Eor(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Eor(const ir_node *node);

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);
typedef enum {
    n_Free_mem,
    n_Free_ptr,
    n_Free_count,
    n_Free_max = n_Free_count
} n_Free;


FIRM_API ir_node *new_rd_Free(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where);

FIRM_API ir_node *new_r_Free(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where);

FIRM_API ir_node *new_d_Free(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where);

FIRM_API ir_node *new_Free(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where);
FIRM_API int is_Free(const ir_node *node);

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_count(const ir_node *node);
FIRM_API void set_Free_count(ir_node *node, ir_node *count);
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);
typedef enum {
    n_IJmp_target,
    n_IJmp_max = n_IJmp_target
} n_IJmp;


FIRM_API ir_node *new_rd_IJmp(dbg_info *dbgi, ir_node *block, ir_node * irn_target);

FIRM_API ir_node *new_r_IJmp(ir_node *block, ir_node * irn_target);

FIRM_API ir_node *new_d_IJmp(dbg_info *dbgi, ir_node * irn_target);

FIRM_API ir_node *new_IJmp(ir_node * irn_target);
FIRM_API int is_IJmp(const ir_node *node);

FIRM_API ir_node *get_IJmp_target(const ir_node *node);
FIRM_API void set_IJmp_target(ir_node *node, ir_node *target);
typedef enum {
    n_Id_pred,
    n_Id_max = n_Id_pred
} n_Id;


FIRM_API ir_node *new_rd_Id(dbg_info *dbgi, ir_node *block, ir_node * irn_pred, ir_mode * mode);

FIRM_API ir_node *new_r_Id(ir_node *block, ir_node * irn_pred, ir_mode * mode);

FIRM_API ir_node *new_d_Id(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode);

FIRM_API ir_node *new_Id(ir_node * irn_pred, ir_mode * mode);
FIRM_API int is_Id(const ir_node *node);

FIRM_API ir_node *get_Id_pred(const ir_node *node);
FIRM_API void set_Id_pred(ir_node *node, ir_node *pred);
typedef enum {
    n_InstOf_store,
    n_InstOf_obj,
    n_InstOf_max = n_InstOf_obj
} n_InstOf;


typedef enum {
    pn_InstOf_M, 
    pn_InstOf_res, 
    pn_InstOf_X_regular, 
    pn_InstOf_X_except, 
    pn_InstOf_max = pn_InstOf_X_except
} pn_InstOf;

FIRM_API ir_node *new_rd_InstOf(dbg_info *dbgi, ir_node *block, ir_node * irn_store, ir_node * irn_obj, ir_type* type);

FIRM_API ir_node *new_r_InstOf(ir_node *block, ir_node * irn_store, ir_node * irn_obj, ir_type* type);

FIRM_API ir_node *new_d_InstOf(dbg_info *dbgi, ir_node * irn_store, ir_node * irn_obj, ir_type* type);

FIRM_API ir_node *new_InstOf(ir_node * irn_store, ir_node * irn_obj, ir_type* type);
FIRM_API int is_InstOf(const ir_node *node);

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 *new_rd_Jmp(dbg_info *dbgi, ir_node *block);

FIRM_API ir_node *new_r_Jmp(ir_node *block);

FIRM_API ir_node *new_d_Jmp(dbg_info *dbgi);

FIRM_API ir_node *new_Jmp(void);
FIRM_API int is_Jmp(const ir_node *node);

typedef enum {
    n_Load_mem,
    n_Load_ptr,
    n_Load_max = n_Load_ptr
} n_Load;


typedef enum {
    pn_Load_M, 
    pn_Load_res, 
    pn_Load_X_regular, 
    pn_Load_X_except, 
    pn_Load_max = pn_Load_X_except
} pn_Load;

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);

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);

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);

FIRM_API ir_node *new_Load(ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags);
FIRM_API int is_Load(const ir_node *node);

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);
typedef enum {
    n_Minus_op,
    n_Minus_max = n_Minus_op
} n_Minus;


FIRM_API ir_node *new_rd_Minus(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_r_Minus(ir_node *block, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_d_Minus(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_Minus(ir_node * irn_op, ir_mode * mode);
FIRM_API int is_Minus(const ir_node *node);

FIRM_API ir_node *get_Minus_op(const ir_node *node);
FIRM_API void set_Minus_op(ir_node *node, ir_node *op);
typedef enum {
    n_Mod_mem,
    n_Mod_left,
    n_Mod_right,
    n_Mod_max = n_Mod_right
} n_Mod;


typedef enum {
    pn_Mod_M, 
    pn_Mod_res, 
    pn_Mod_X_regular, 
    pn_Mod_X_except, 
    pn_Mod_max = pn_Mod_X_except
} pn_Mod;

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);

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);

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);

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);
FIRM_API int is_Mod(const ir_node *node);

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);
typedef enum {
    n_Mul_left,
    n_Mul_right,
    n_Mul_max = n_Mul_right
} n_Mul;


FIRM_API ir_node *new_rd_Mul(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Mul(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Mul(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Mul(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Mul(const ir_node *node);

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);
typedef enum {
    n_Mulh_left,
    n_Mulh_right,
    n_Mulh_max = n_Mulh_right
} n_Mulh;


FIRM_API ir_node *new_rd_Mulh(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Mulh(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Mulh(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Mulh(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Mulh(const ir_node *node);

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);
typedef enum {
    n_Mux_sel,
    n_Mux_false,
    n_Mux_true,
    n_Mux_max = n_Mux_true
} n_Mux;


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);

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);

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);

FIRM_API ir_node *new_Mux(ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode);
FIRM_API int is_Mux(const ir_node *node);

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 *new_rd_NoMem(dbg_info *dbgi, ir_graph *irg);

FIRM_API ir_node *new_r_NoMem(ir_graph *irg);

FIRM_API ir_node *new_d_NoMem(dbg_info *dbgi);

FIRM_API ir_node *new_NoMem(void);
FIRM_API int is_NoMem(const ir_node *node);

typedef enum {
    n_Not_op,
    n_Not_max = n_Not_op
} n_Not;


FIRM_API ir_node *new_rd_Not(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_r_Not(ir_node *block, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_d_Not(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode);

FIRM_API ir_node *new_Not(ir_node * irn_op, ir_mode * mode);
FIRM_API int is_Not(const ir_node *node);

FIRM_API ir_node *get_Not_op(const ir_node *node);
FIRM_API void set_Not_op(ir_node *node, ir_node *op);
typedef enum {
    n_Or_left,
    n_Or_right,
    n_Or_max = n_Or_right
} n_Or;


FIRM_API ir_node *new_rd_Or(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Or(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Or(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Or(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Or(const ir_node *node);

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 *new_rd_Phi(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in, ir_mode * mode);

FIRM_API ir_node *new_r_Phi(ir_node *block, int arity, ir_node *const * in, ir_mode * mode);

FIRM_API ir_node *new_d_Phi(dbg_info *dbgi, int arity, ir_node *const * in, ir_mode * mode);

FIRM_API ir_node *new_Phi(int arity, ir_node *const * in, ir_mode * mode);
FIRM_API int is_Phi(const ir_node *node);

typedef enum {
    n_Pin_op,
    n_Pin_max = n_Pin_op
} n_Pin;


FIRM_API ir_node *new_rd_Pin(dbg_info *dbgi, ir_node *block, ir_node * irn_op);

FIRM_API ir_node *new_r_Pin(ir_node *block, ir_node * irn_op);

FIRM_API ir_node *new_d_Pin(dbg_info *dbgi, ir_node * irn_op);

FIRM_API ir_node *new_Pin(ir_node * irn_op);
FIRM_API int is_Pin(const ir_node *node);

FIRM_API ir_node *get_Pin_op(const ir_node *node);
FIRM_API void set_Pin_op(ir_node *node, ir_node *op);
typedef enum {
    n_Proj_pred,
    n_Proj_max = n_Proj_pred
} n_Proj;


FIRM_API ir_node *new_rd_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, long proj);

FIRM_API ir_node *new_r_Proj(ir_node * irn_pred, ir_mode * mode, long proj);

FIRM_API ir_node *new_d_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, long proj);

FIRM_API ir_node *new_Proj(ir_node * irn_pred, ir_mode * mode, long proj);
FIRM_API int is_Proj(const ir_node *node);

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);
typedef enum {
    n_Raise_mem,
    n_Raise_exo_ptr,
    n_Raise_max = n_Raise_exo_ptr
} n_Raise;


typedef enum {
    pn_Raise_M, 
    pn_Raise_X, 
    pn_Raise_max = pn_Raise_X
} pn_Raise;

FIRM_API ir_node *new_rd_Raise(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_exo_ptr);

FIRM_API ir_node *new_r_Raise(ir_node *block, ir_node * irn_mem, ir_node * irn_exo_ptr);

FIRM_API ir_node *new_d_Raise(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_exo_ptr);

FIRM_API ir_node *new_Raise(ir_node * irn_mem, ir_node * irn_exo_ptr);
FIRM_API int is_Raise(const ir_node *node);

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);
typedef enum {
    n_Return_mem,
    n_Return_max = n_Return_mem
} n_Return;


FIRM_API ir_node *new_rd_Return(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in);

FIRM_API ir_node *new_r_Return(ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in);

FIRM_API ir_node *new_d_Return(dbg_info *dbgi, ir_node * irn_mem, int arity, ir_node *const * in);

FIRM_API ir_node *new_Return(ir_node * irn_mem, int arity, ir_node *const * in);
FIRM_API int is_Return(const ir_node *node);

FIRM_API ir_node *get_Return_mem(const ir_node *node);
FIRM_API void set_Return_mem(ir_node *node, ir_node *mem);
typedef enum {
    n_Rotl_left,
    n_Rotl_right,
    n_Rotl_max = n_Rotl_right
} n_Rotl;


FIRM_API ir_node *new_rd_Rotl(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Rotl(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Rotl(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Rotl(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Rotl(const ir_node *node);

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);
typedef enum {
    n_Sel_mem,
    n_Sel_ptr,
    n_Sel_max = n_Sel_ptr
} n_Sel;


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);

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);

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);

FIRM_API ir_node *new_Sel(ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity);
FIRM_API int is_Sel(const ir_node *node);

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);
typedef enum {
    n_Shl_left,
    n_Shl_right,
    n_Shl_max = n_Shl_right
} n_Shl;


FIRM_API ir_node *new_rd_Shl(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Shl(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Shl(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Shl(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Shl(const ir_node *node);

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);
typedef enum {
    n_Shr_left,
    n_Shr_right,
    n_Shr_max = n_Shr_right
} n_Shr;


FIRM_API ir_node *new_rd_Shr(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Shr(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Shr(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Shr(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Shr(const ir_node *node);

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);
typedef enum {
    n_Shrs_left,
    n_Shrs_right,
    n_Shrs_max = n_Shrs_right
} n_Shrs;


FIRM_API ir_node *new_rd_Shrs(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Shrs(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Shrs(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Shrs(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Shrs(const ir_node *node);

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);
typedef enum {
    pn_Start_X_initial_exec, 
    pn_Start_M, 
    pn_Start_P_frame_base, 
    pn_Start_T_args, 
    pn_Start_max = pn_Start_T_args
} pn_Start;

FIRM_API ir_node *new_rd_Start(dbg_info *dbgi, ir_graph *irg);

FIRM_API ir_node *new_r_Start(ir_graph *irg);

FIRM_API ir_node *new_d_Start(dbg_info *dbgi);

FIRM_API ir_node *new_Start(void);
FIRM_API int is_Start(const ir_node *node);

typedef enum {
    n_Store_mem,
    n_Store_ptr,
    n_Store_value,
    n_Store_max = n_Store_value
} n_Store;


typedef enum {
    pn_Store_M, 
    pn_Store_X_regular, 
    pn_Store_X_except, 
    pn_Store_max = pn_Store_X_except
} pn_Store;

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);

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);

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);

FIRM_API ir_node *new_Store(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags);
FIRM_API int is_Store(const ir_node *node);

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);
typedef enum {
    n_Sub_left,
    n_Sub_right,
    n_Sub_max = n_Sub_right
} n_Sub;


FIRM_API ir_node *new_rd_Sub(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_r_Sub(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_d_Sub(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode);

FIRM_API ir_node *new_Sub(ir_node * irn_left, ir_node * irn_right, ir_mode * mode);
FIRM_API int is_Sub(const ir_node *node);

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);
typedef enum {
    n_Switch_selector,
    n_Switch_max = n_Switch_selector
} n_Switch;


typedef enum {
    pn_Switch_default, 
    pn_Switch_max = pn_Switch_default
} pn_Switch;

FIRM_API ir_node *new_rd_Switch(dbg_info *dbgi, ir_node *block, ir_node * irn_selector, unsigned n_outs, ir_switch_table* table);

FIRM_API ir_node *new_r_Switch(ir_node *block, ir_node * irn_selector, unsigned n_outs, ir_switch_table* table);

FIRM_API ir_node *new_d_Switch(dbg_info *dbgi, ir_node * irn_selector, unsigned n_outs, ir_switch_table* table);

FIRM_API ir_node *new_Switch(ir_node * irn_selector, unsigned n_outs, ir_switch_table* table);
FIRM_API int is_Switch(const ir_node *node);

FIRM_API ir_node *get_Switch_selector(const ir_node *node);
FIRM_API void set_Switch_selector(ir_node *node, ir_node *selector);
FIRM_API unsigned get_Switch_n_outs(const ir_node *node);
FIRM_API void set_Switch_n_outs(ir_node *node, unsigned n_outs);
FIRM_API ir_switch_table* get_Switch_table(const ir_node *node);
FIRM_API void set_Switch_table(ir_node *node, ir_switch_table* table);
FIRM_API int is_SymConst(const ir_node *node);

FIRM_API ir_node *new_rd_Sync(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in);

FIRM_API ir_node *new_r_Sync(ir_node *block, int arity, ir_node *const * in);

FIRM_API ir_node *new_d_Sync(dbg_info *dbgi, int arity, ir_node *const * in);

FIRM_API ir_node *new_Sync(int arity, ir_node *const * in);
FIRM_API int is_Sync(const ir_node *node);

FIRM_API ir_node *new_rd_Tuple(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in);

FIRM_API ir_node *new_r_Tuple(ir_node *block, int arity, ir_node *const * in);

FIRM_API ir_node *new_d_Tuple(dbg_info *dbgi, int arity, ir_node *const * in);

FIRM_API ir_node *new_Tuple(int arity, ir_node *const * in);
FIRM_API int is_Tuple(const ir_node *node);

FIRM_API ir_node *new_rd_Unknown(dbg_info *dbgi, ir_graph *irg, ir_mode * mode);

FIRM_API ir_node *new_r_Unknown(ir_graph *irg, ir_mode * mode);

FIRM_API ir_node *new_d_Unknown(dbg_info *dbgi, ir_mode * mode);

FIRM_API ir_node *new_Unknown(ir_mode * mode);
FIRM_API int is_Unknown(const ir_node *node);

#include "end.h"

#endif