nodes.h

/* Warning: Automatically generated file */
#ifndef FIRM_IR_NODES_H
#define FIRM_IR_NODES_H




typedef enum ir_opcode {
    iro_ASM,
    iro_Add,
    iro_Address,
    iro_Align,
    iro_Alloc,
    iro_Anchor,
    iro_And,
    iro_Bad,
    iro_Bitcast,
    iro_Block,
    iro_Builtin,
    iro_Call,
    iro_Cmp,
    iro_Cond,
    iro_Confirm,
    iro_Const,
    iro_Conv,
    iro_CopyB,
    iro_Deleted,
    iro_Div,
    iro_Dummy,
    iro_End,
    iro_Eor,
    iro_Free,
    iro_IJmp,
    iro_Id,
    iro_Jmp,
    iro_Load,
    iro_Member,
    iro_Minus,
    iro_Mod,
    iro_Mul,
    iro_Mulh,
    iro_Mux,
    iro_NoMem,
    iro_Not,
    iro_Offset,
    iro_Or,
    iro_Phi,
    iro_Pin,
    iro_Proj,
    iro_Raise,
    iro_Return,
    iro_Sel,
    iro_Shl,
    iro_Shr,
    iro_Shrs,
    iro_Size,
    iro_Start,
    iro_Store,
    iro_Sub,
    iro_Switch,
    iro_Sync,
    iro_Tuple,
    iro_Unknown,
    iro_first = iro_ASM,
    iro_last  = iro_Unknown,
} ir_opcode;

typedef enum {
    n_ASM_mem, 
    n_ASM_max = n_ASM_mem
} n_ASM;

typedef enum {
    pn_ASM_M, 
    pn_ASM_first_out, 
    pn_ASM_max = pn_ASM_first_out
} pn_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  int get_ASM_n_inputs(ir_node const *node);
FIRM_API  ir_node *get_ASM_input(ir_node const *node, int pos);
FIRM_API  void set_ASM_input(ir_node *node, int pos, ir_node *input);
ir_node **get_ASM_input_arr(ir_node *node);

FIRM_API  ir_asm_constraint* get_ASM_constraints(const ir_node *node);
FIRM_API  void set_ASM_constraints(ir_node *node, ir_asm_constraint* 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_op *op_ASM;

FIRM_API  ir_op *get_op_ASM(void);

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

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

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

FIRM_API  ir_node *new_Add(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Add;

FIRM_API  ir_op *get_op_Add(void);

FIRM_API  ir_node *new_rd_Address(dbg_info *dbgi, ir_graph *irg, ir_entity* entity);

FIRM_API  ir_node *new_r_Address(ir_graph *irg, ir_entity* entity);

FIRM_API  ir_node *new_d_Address(dbg_info *dbgi, ir_entity* entity);

FIRM_API  ir_node *new_Address(ir_entity* entity);

FIRM_API  int is_Address(const ir_node *node);


FIRM_API  ir_entity* get_Address_entity(const ir_node *node);
FIRM_API  void set_Address_entity(ir_node *node, ir_entity* entity);
FIRM_API  ir_op *op_Address;

FIRM_API  ir_op *get_op_Address(void);

FIRM_API  ir_node *new_rd_Align(dbg_info *dbgi, ir_graph *irg, ir_mode * mode, ir_type* type);

FIRM_API  ir_node *new_r_Align(ir_graph *irg, ir_mode * mode, ir_type* type);

FIRM_API  ir_node *new_d_Align(dbg_info *dbgi, ir_mode * mode, ir_type* type);

FIRM_API  ir_node *new_Align(ir_mode * mode, ir_type* type);

FIRM_API  int is_Align(const ir_node *node);


FIRM_API  ir_type* get_Align_type(const ir_node *node);
FIRM_API  void set_Align_type(ir_node *node, ir_type* type);
FIRM_API  ir_op *op_Align;

FIRM_API  ir_op *get_op_Align(void);

typedef enum {
    n_Alloc_mem, 
    n_Alloc_size, 
    n_Alloc_max = n_Alloc_size
} n_Alloc;

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

FIRM_API  ir_node *new_rd_Alloc(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_size, unsigned alignment);

FIRM_API  ir_node *new_r_Alloc(ir_node *block, ir_node * irn_mem, ir_node * irn_size, unsigned alignment);

FIRM_API  ir_node *new_d_Alloc(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_size, unsigned alignment);

FIRM_API  ir_node *new_Alloc(ir_node * irn_mem, ir_node * irn_size, unsigned alignment);

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_size(const ir_node *node);
FIRM_API  void set_Alloc_size(ir_node *node, ir_node *size);

FIRM_API  unsigned get_Alloc_alignment(const ir_node *node);
FIRM_API  void set_Alloc_alignment(ir_node *node, unsigned alignment);
FIRM_API  ir_op *op_Alloc;

FIRM_API  ir_op *get_op_Alloc(void);

typedef enum {
    n_Anchor_end_block, 
    n_Anchor_start_block, 
    n_Anchor_end, 
    n_Anchor_start, 
    n_Anchor_frame, 
    n_Anchor_initial_mem, 
    n_Anchor_args, 
    n_Anchor_no_mem, 
    n_Anchor_max = n_Anchor_no_mem
} n_Anchor;


FIRM_API  int is_Anchor(const ir_node *node);

FIRM_API  ir_node *get_Anchor_end_block(const ir_node *node);
FIRM_API  void set_Anchor_end_block(ir_node *node, ir_node *end_block);
FIRM_API  ir_node *get_Anchor_start_block(const ir_node *node);
FIRM_API  void set_Anchor_start_block(ir_node *node, ir_node *start_block);
FIRM_API  ir_node *get_Anchor_end(const ir_node *node);
FIRM_API  void set_Anchor_end(ir_node *node, ir_node *end);
FIRM_API  ir_node *get_Anchor_start(const ir_node *node);
FIRM_API  void set_Anchor_start(ir_node *node, ir_node *start);
FIRM_API  ir_node *get_Anchor_frame(const ir_node *node);
FIRM_API  void set_Anchor_frame(ir_node *node, ir_node *frame);
FIRM_API  ir_node *get_Anchor_initial_mem(const ir_node *node);
FIRM_API  void set_Anchor_initial_mem(ir_node *node, ir_node *initial_mem);
FIRM_API  ir_node *get_Anchor_args(const ir_node *node);
FIRM_API  void set_Anchor_args(ir_node *node, ir_node *args);
FIRM_API  ir_node *get_Anchor_no_mem(const ir_node *node);
FIRM_API  void set_Anchor_no_mem(ir_node *node, ir_node *no_mem);
FIRM_API  ir_op *op_Anchor;

FIRM_API  ir_op *get_op_Anchor(void);

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

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

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

FIRM_API  ir_node *new_And(ir_node * irn_left, ir_node * irn_right);

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_op *op_And;

FIRM_API  ir_op *get_op_And(void);

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_op *op_Bad;

FIRM_API  ir_op *get_op_Bad(void);

typedef enum {
    n_Bitcast_op, 
    n_Bitcast_max = n_Bitcast_op
} n_Bitcast;

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

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

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

FIRM_API  ir_node *new_Bitcast(ir_node * irn_op, ir_mode * mode);

FIRM_API  int is_Bitcast(const ir_node *node);

FIRM_API  ir_node *get_Bitcast_op(const ir_node *node);
FIRM_API  void set_Bitcast_op(ir_node *node, ir_node *op);
FIRM_API  ir_op *op_Bitcast;

FIRM_API  ir_op *get_op_Bitcast(void);

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  int get_Block_n_cfgpreds(ir_node const *node);
FIRM_API  ir_node *get_Block_cfgpred(ir_node const *node, int pos);
FIRM_API  void set_Block_cfgpred(ir_node *node, int pos, ir_node *cfgpred);
ir_node **get_Block_cfgpred_arr(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);
FIRM_API  ir_op *op_Block;

FIRM_API  ir_op *get_op_Block(void);

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  int get_Builtin_n_params(ir_node const *node);
FIRM_API  ir_node *get_Builtin_param(ir_node const *node, int pos);
FIRM_API  void set_Builtin_param(ir_node *node, int pos, ir_node *param);
ir_node **get_Builtin_param_arr(ir_node *node);

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_op *op_Builtin;

FIRM_API  ir_op *get_op_Builtin(void);

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  int get_Call_n_params(ir_node const *node);
FIRM_API  ir_node *get_Call_param(ir_node const *node, int pos);
FIRM_API  void set_Call_param(ir_node *node, int pos, ir_node *param);
ir_node **get_Call_param_arr(ir_node *node);

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  ir_op *op_Call;

FIRM_API  ir_op *get_op_Call(void);

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);
FIRM_API  ir_op *op_Cmp;

FIRM_API  ir_op *get_op_Cmp(void);

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);
FIRM_API  ir_op *op_Cond;

FIRM_API  ir_op *get_op_Cond(void);

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_op *op_Confirm;

FIRM_API  ir_op *get_op_Confirm(void);

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);
FIRM_API  ir_op *op_Const;

FIRM_API  ir_op *get_op_Const(void);

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);
FIRM_API  ir_op *op_Conv;

FIRM_API  ir_op *get_op_Conv(void);

typedef enum {
    n_CopyB_mem, 
    n_CopyB_dst, 
    n_CopyB_src, 
    n_CopyB_max = n_CopyB_src
} n_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, ir_cons_flags flags);

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, ir_cons_flags flags);

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, ir_cons_flags flags);

FIRM_API  ir_node *new_CopyB(ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type, ir_cons_flags flags);

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  ir_volatility get_CopyB_volatility(const ir_node *node);
FIRM_API  void set_CopyB_volatility(ir_node *node, ir_volatility volatility);
FIRM_API  ir_op *op_CopyB;

FIRM_API  ir_op *get_op_CopyB(void);

FIRM_API  int is_Deleted(const ir_node *node);

FIRM_API  ir_op *op_Deleted;

FIRM_API  ir_op *get_op_Deleted(void);

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, int pinned);

FIRM_API  ir_node *new_r_Div(ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, int pinned);

FIRM_API  ir_node *new_d_Div(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, int pinned);

FIRM_API  ir_node *new_Div(ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, int pinned);

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_op *op_Div;

FIRM_API  ir_op *get_op_Div(void);

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_op *op_Dummy;

FIRM_API  ir_op *get_op_Dummy(void);

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

FIRM_API  int get_End_n_keepalives(ir_node const *node);
FIRM_API  ir_node *get_End_keepalive(ir_node const *node, int pos);
FIRM_API  void set_End_keepalive(ir_node *node, int pos, ir_node *keepalive);
ir_node **get_End_keepalive_arr(ir_node *node);
FIRM_API  ir_op *op_End;

FIRM_API  ir_op *get_op_End(void);

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

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

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

FIRM_API  ir_node *new_Eor(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Eor;

FIRM_API  ir_op *get_op_Eor(void);

typedef enum {
    n_Free_mem, 
    n_Free_ptr, 
    n_Free_max = n_Free_ptr
} n_Free;

FIRM_API  ir_node *new_rd_Free(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr);

FIRM_API  ir_node *new_r_Free(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr);

FIRM_API  ir_node *new_d_Free(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr);

FIRM_API  ir_node *new_Free(ir_node * irn_mem, ir_node * irn_ptr);

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_op *op_Free;

FIRM_API  ir_op *get_op_Free(void);

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);
FIRM_API  ir_op *op_IJmp;

FIRM_API  ir_op *get_op_IJmp(void);

typedef enum {
    n_Id_pred, 
    n_Id_max = n_Id_pred
} n_Id;


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);
FIRM_API  ir_op *op_Id;

FIRM_API  ir_op *get_op_Id(void);

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

FIRM_API  ir_op *op_Jmp;

FIRM_API  ir_op *get_op_Jmp(void);

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_type* type, 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_type* type, 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_type* type, ir_cons_flags flags);

FIRM_API  ir_node *new_Load(ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_type* type, 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_type* get_Load_type(const ir_node *node);
FIRM_API  void set_Load_type(ir_node *node, ir_type* type);

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_op *op_Load;

FIRM_API  ir_op *get_op_Load(void);

typedef enum {
    n_Member_ptr, 
    n_Member_max = n_Member_ptr
} n_Member;

FIRM_API  ir_node *new_rd_Member(dbg_info *dbgi, ir_node *block, ir_node * irn_ptr, ir_entity* entity);

FIRM_API  ir_node *new_r_Member(ir_node *block, ir_node * irn_ptr, ir_entity* entity);

FIRM_API  ir_node *new_d_Member(dbg_info *dbgi, ir_node * irn_ptr, ir_entity* entity);

FIRM_API  ir_node *new_Member(ir_node * irn_ptr, ir_entity* entity);

FIRM_API  int is_Member(const ir_node *node);

FIRM_API  ir_node *get_Member_ptr(const ir_node *node);
FIRM_API  void set_Member_ptr(ir_node *node, ir_node *ptr);

FIRM_API  ir_entity* get_Member_entity(const ir_node *node);
FIRM_API  void set_Member_entity(ir_node *node, ir_entity* entity);
FIRM_API  ir_op *op_Member;

FIRM_API  ir_op *get_op_Member(void);

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

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

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

FIRM_API  ir_node *new_Minus(ir_node * irn_op);

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);
FIRM_API  ir_op *op_Minus;

FIRM_API  ir_op *get_op_Minus(void);

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, int pinned);

FIRM_API  ir_node *new_r_Mod(ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, int pinned);

FIRM_API  ir_node *new_d_Mod(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, int pinned);

FIRM_API  ir_node *new_Mod(ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, int pinned);

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);
FIRM_API  ir_op *op_Mod;

FIRM_API  ir_op *get_op_Mod(void);

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

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

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

FIRM_API  ir_node *new_Mul(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Mul;

FIRM_API  ir_op *get_op_Mul(void);

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

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

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

FIRM_API  ir_node *new_Mulh(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Mulh;

FIRM_API  ir_op *get_op_Mulh(void);

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

FIRM_API  ir_node *new_r_Mux(ir_node *block, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true);

FIRM_API  ir_node *new_d_Mux(dbg_info *dbgi, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true);

FIRM_API  ir_node *new_Mux(ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true);

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_op *op_Mux;

FIRM_API  ir_op *get_op_Mux(void);

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

FIRM_API  ir_op *op_NoMem;

FIRM_API  ir_op *get_op_NoMem(void);

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

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

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

FIRM_API  ir_node *new_Not(ir_node * irn_op);

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);
FIRM_API  ir_op *op_Not;

FIRM_API  ir_op *get_op_Not(void);

FIRM_API  ir_node *new_rd_Offset(dbg_info *dbgi, ir_graph *irg, ir_mode * mode, ir_entity* entity);

FIRM_API  ir_node *new_r_Offset(ir_graph *irg, ir_mode * mode, ir_entity* entity);

FIRM_API  ir_node *new_d_Offset(dbg_info *dbgi, ir_mode * mode, ir_entity* entity);

FIRM_API  ir_node *new_Offset(ir_mode * mode, ir_entity* entity);

FIRM_API  int is_Offset(const ir_node *node);


FIRM_API  ir_entity* get_Offset_entity(const ir_node *node);
FIRM_API  void set_Offset_entity(ir_node *node, ir_entity* entity);
FIRM_API  ir_op *op_Offset;

FIRM_API  ir_op *get_op_Offset(void);

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

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

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

FIRM_API  ir_node *new_Or(ir_node * irn_left, ir_node * irn_right);

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_op *op_Or;

FIRM_API  ir_op *get_op_Or(void);

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

FIRM_API  int get_Phi_n_preds(ir_node const *node);
FIRM_API  ir_node *get_Phi_pred(ir_node const *node, int pos);
FIRM_API  void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
ir_node **get_Phi_pred_arr(ir_node *node);

FIRM_API  int get_Phi_loop(const ir_node *node);
FIRM_API  void set_Phi_loop(ir_node *node, int loop);
FIRM_API  ir_op *op_Phi;

FIRM_API  ir_op *get_op_Phi(void);

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);
FIRM_API  ir_op *op_Pin;

FIRM_API  ir_op *get_op_Pin(void);

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, unsigned num);

FIRM_API  ir_node *new_r_Proj(ir_node * irn_pred, ir_mode * mode, unsigned num);

FIRM_API  ir_node *new_d_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, unsigned num);

FIRM_API  ir_node *new_Proj(ir_node * irn_pred, ir_mode * mode, unsigned num);

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  unsigned get_Proj_num(const ir_node *node);
FIRM_API  void set_Proj_num(ir_node *node, unsigned num);
FIRM_API  ir_op *op_Proj;

FIRM_API  ir_op *get_op_Proj(void);

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);
FIRM_API  ir_op *op_Raise;

FIRM_API  ir_op *get_op_Raise(void);

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);
FIRM_API  int get_Return_n_ress(ir_node const *node);
FIRM_API  ir_node *get_Return_res(ir_node const *node, int pos);
FIRM_API  void set_Return_res(ir_node *node, int pos, ir_node *res);
ir_node **get_Return_res_arr(ir_node *node);
FIRM_API  ir_op *op_Return;

FIRM_API  ir_op *get_op_Return(void);

typedef enum {
    n_Sel_ptr, 
    n_Sel_index, 
    n_Sel_max = n_Sel_index
} n_Sel;

FIRM_API  ir_node *new_rd_Sel(dbg_info *dbgi, ir_node *block, ir_node * irn_ptr, ir_node * irn_index, ir_type* type);

FIRM_API  ir_node *new_r_Sel(ir_node *block, ir_node * irn_ptr, ir_node * irn_index, ir_type* type);

FIRM_API  ir_node *new_d_Sel(dbg_info *dbgi, ir_node * irn_ptr, ir_node * irn_index, ir_type* type);

FIRM_API  ir_node *new_Sel(ir_node * irn_ptr, ir_node * irn_index, ir_type* type);

FIRM_API  int is_Sel(const ir_node *node);

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_node *get_Sel_index(const ir_node *node);
FIRM_API  void set_Sel_index(ir_node *node, ir_node *index);

FIRM_API  ir_type* get_Sel_type(const ir_node *node);
FIRM_API  void set_Sel_type(ir_node *node, ir_type* type);
FIRM_API  ir_op *op_Sel;

FIRM_API  ir_op *get_op_Sel(void);

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

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

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

FIRM_API  ir_node *new_Shl(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Shl;

FIRM_API  ir_op *get_op_Shl(void);

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

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

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

FIRM_API  ir_node *new_Shr(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Shr;

FIRM_API  ir_op *get_op_Shr(void);

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

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

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

FIRM_API  ir_node *new_Shrs(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Shrs;

FIRM_API  ir_op *get_op_Shrs(void);

FIRM_API  ir_node *new_rd_Size(dbg_info *dbgi, ir_graph *irg, ir_mode * mode, ir_type* type);

FIRM_API  ir_node *new_r_Size(ir_graph *irg, ir_mode * mode, ir_type* type);

FIRM_API  ir_node *new_d_Size(dbg_info *dbgi, ir_mode * mode, ir_type* type);

FIRM_API  ir_node *new_Size(ir_mode * mode, ir_type* type);

FIRM_API  int is_Size(const ir_node *node);


FIRM_API  ir_type* get_Size_type(const ir_node *node);
FIRM_API  void set_Size_type(ir_node *node, ir_type* type);
FIRM_API  ir_op *op_Size;

FIRM_API  ir_op *get_op_Size(void);

typedef enum {
    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);

FIRM_API  ir_op *op_Start;

FIRM_API  ir_op *get_op_Start(void);

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_type* type, 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_type* type, 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_type* type, ir_cons_flags flags);

FIRM_API  ir_node *new_Store(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_type* type, 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_type* get_Store_type(const ir_node *node);
FIRM_API  void set_Store_type(ir_node *node, ir_type* type);

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_op *op_Store;

FIRM_API  ir_op *get_op_Store(void);

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

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

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

FIRM_API  ir_node *new_Sub(ir_node * irn_left, ir_node * irn_right);

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);
FIRM_API  ir_op *op_Sub;

FIRM_API  ir_op *get_op_Sub(void);

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  ir_op *op_Switch;

FIRM_API  ir_op *get_op_Switch(void);

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  int get_Sync_n_preds(ir_node const *node);
FIRM_API  ir_node *get_Sync_pred(ir_node const *node, int pos);
FIRM_API  void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
ir_node **get_Sync_pred_arr(ir_node *node);
FIRM_API  ir_op *op_Sync;

FIRM_API  ir_op *get_op_Sync(void);

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  int get_Tuple_n_preds(ir_node const *node);
FIRM_API  ir_node *get_Tuple_pred(ir_node const *node, int pos);
FIRM_API  void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);
ir_node **get_Tuple_pred_arr(ir_node *node);
FIRM_API  ir_op *op_Tuple;

FIRM_API  ir_op *get_op_Tuple(void);

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

FIRM_API  ir_op *op_Unknown;

FIRM_API  ir_op *get_op_Unknown(void);

FIRM_API  int is_binop(const ir_node *node);
FIRM_API  int is_entconst(const ir_node *node);
FIRM_API  ir_entity* get_entconst_entity(const ir_node *node);
FIRM_API  void set_entconst_entity(ir_node *node, ir_entity* entity);
FIRM_API  int is_typeconst(const ir_node *node);
FIRM_API  ir_type* get_typeconst_type(const ir_node *node);
FIRM_API  void set_typeconst_type(ir_node *node, ir_type* type);


#endif