comprakt/doxygen_libfirm/a00062_source.html

 /* Warning: Automatically generated file */

 #ifndef IR_GEN_IRNODE_H

 #define IR_GEN_IRNODE_H


 #include <assert.h>


 #define is_ASM(node) is_ASM_(node)

 #define get_ASM_constraints(node) get_ASM_constraints_(node)

 #define set_ASM_constraints(node, constraints) set_ASM_constraints_(node, constraints)

 #define get_ASM_clobbers(node) get_ASM_clobbers_(node)

 #define set_ASM_clobbers(node, clobbers) set_ASM_clobbers_(node, clobbers)

 #define get_ASM_text(node) get_ASM_text_(node)

 #define set_ASM_text(node, text) set_ASM_text_(node, text)

 #define get_ASM_mem(node) get_ASM_mem_(node)

 #define set_ASM_mem(node, mem) set_ASM_mem_(node, mem)

 #define get_ASM_n_inputs(node) get_ASM_n_inputs_(node)

 #define get_ASM_input(node, pos) get_ASM_input_(node, pos)

 #define set_ASM_input(node, pos, input) set_ASM_input_(node, pos, input)

 #define get_ASM_input_arr(node) get_ASM_input_arr_(node)


 #define is_Add(node) is_Add_(node)

 #define get_Add_left(node) get_Add_left_(node)

 #define set_Add_left(node, left) set_Add_left_(node, left)

 #define get_Add_right(node) get_Add_right_(node)

 #define set_Add_right(node, right) set_Add_right_(node, right)


 #define is_Address(node) is_Address_(node)

 #define get_Address_entity(node) get_Address_entity_(node)

 #define set_Address_entity(node, entity) set_Address_entity_(node, entity)


 #define is_Align(node) is_Align_(node)

 #define get_Align_type(node) get_Align_type_(node)

 #define set_Align_type(node, type) set_Align_type_(node, type)


 #define is_Alloc(node) is_Alloc_(node)

 #define get_Alloc_alignment(node) get_Alloc_alignment_(node)

 #define set_Alloc_alignment(node, alignment) set_Alloc_alignment_(node, alignment)

 #define get_Alloc_mem(node) get_Alloc_mem_(node)

 #define set_Alloc_mem(node, mem) set_Alloc_mem_(node, mem)

 #define get_Alloc_size(node) get_Alloc_size_(node)

 #define set_Alloc_size(node, size) set_Alloc_size_(node, size)


 #define is_Anchor(node) is_Anchor_(node)

 #define get_Anchor_end_block(node) get_Anchor_end_block_(node)

 #define set_Anchor_end_block(node, end_block) set_Anchor_end_block_(node, end_block)

 #define get_Anchor_start_block(node) get_Anchor_start_block_(node)

 #define set_Anchor_start_block(node, start_block) set_Anchor_start_block_(node, start_block)

 #define get_Anchor_end(node) get_Anchor_end_(node)

 #define set_Anchor_end(node, end) set_Anchor_end_(node, end)

 #define get_Anchor_start(node) get_Anchor_start_(node)

 #define set_Anchor_start(node, start) set_Anchor_start_(node, start)

 #define get_Anchor_frame(node) get_Anchor_frame_(node)

 #define set_Anchor_frame(node, frame) set_Anchor_frame_(node, frame)

 #define get_Anchor_initial_mem(node) get_Anchor_initial_mem_(node)

 #define set_Anchor_initial_mem(node, initial_mem) set_Anchor_initial_mem_(node, initial_mem)

 #define get_Anchor_args(node) get_Anchor_args_(node)

 #define set_Anchor_args(node, args) set_Anchor_args_(node, args)

 #define get_Anchor_no_mem(node) get_Anchor_no_mem_(node)

 #define set_Anchor_no_mem(node, no_mem) set_Anchor_no_mem_(node, no_mem)


 #define is_And(node) is_And_(node)

 #define get_And_left(node) get_And_left_(node)

 #define set_And_left(node, left) set_And_left_(node, left)

 #define get_And_right(node) get_And_right_(node)

 #define set_And_right(node, right) set_And_right_(node, right)


 #define is_Bad(node) is_Bad_(node)


 #define is_Bitcast(node) is_Bitcast_(node)

 #define get_Bitcast_op(node) get_Bitcast_op_(node)

 #define set_Bitcast_op(node, op) set_Bitcast_op_(node, op)


 #define is_Block(node) is_Block_(node)

 #define get_Block_entity(node) get_Block_entity_(node)

 #define set_Block_entity(node, entity) set_Block_entity_(node, entity)

 #define get_Block_n_cfgpreds(node) get_Block_n_cfgpreds_(node)

 #define get_Block_cfgpred(node, pos) get_Block_cfgpred_(node, pos)

 #define set_Block_cfgpred(node, pos, cfgpred) set_Block_cfgpred_(node, pos, cfgpred)

 #define get_Block_cfgpred_arr(node) get_Block_cfgpred_arr_(node)


 #define is_Builtin(node) is_Builtin_(node)

 #define get_Builtin_kind(node) get_Builtin_kind_(node)

 #define set_Builtin_kind(node, kind) set_Builtin_kind_(node, kind)

 #define get_Builtin_type(node) get_Builtin_type_(node)

 #define set_Builtin_type(node, type) set_Builtin_type_(node, type)

 #define get_Builtin_mem(node) get_Builtin_mem_(node)

 #define set_Builtin_mem(node, mem) set_Builtin_mem_(node, mem)

 #define get_Builtin_n_params(node) get_Builtin_n_params_(node)

 #define get_Builtin_param(node, pos) get_Builtin_param_(node, pos)

 #define set_Builtin_param(node, pos, param) set_Builtin_param_(node, pos, param)

 #define get_Builtin_param_arr(node) get_Builtin_param_arr_(node)


 #define is_Call(node) is_Call_(node)

 #define get_Call_type(node) get_Call_type_(node)

 #define set_Call_type(node, type) set_Call_type_(node, type)

 #define get_Call_mem(node) get_Call_mem_(node)

 #define set_Call_mem(node, mem) set_Call_mem_(node, mem)

 #define get_Call_ptr(node) get_Call_ptr_(node)

 #define set_Call_ptr(node, ptr) set_Call_ptr_(node, ptr)

 #define get_Call_n_params(node) get_Call_n_params_(node)

 #define get_Call_param(node, pos) get_Call_param_(node, pos)

 #define set_Call_param(node, pos, param) set_Call_param_(node, pos, param)

 #define get_Call_param_arr(node) get_Call_param_arr_(node)


 #define is_Cmp(node) is_Cmp_(node)

 #define get_Cmp_relation(node) get_Cmp_relation_(node)

 #define set_Cmp_relation(node, relation) set_Cmp_relation_(node, relation)

 #define get_Cmp_left(node) get_Cmp_left_(node)

 #define set_Cmp_left(node, left) set_Cmp_left_(node, left)

 #define get_Cmp_right(node) get_Cmp_right_(node)

 #define set_Cmp_right(node, right) set_Cmp_right_(node, right)


 #define is_Cond(node) is_Cond_(node)

 #define get_Cond_jmp_pred(node) get_Cond_jmp_pred_(node)

 #define set_Cond_jmp_pred(node, jmp_pred) set_Cond_jmp_pred_(node, jmp_pred)

 #define get_Cond_selector(node) get_Cond_selector_(node)

 #define set_Cond_selector(node, selector) set_Cond_selector_(node, selector)


 #define is_Confirm(node) is_Confirm_(node)

 #define get_Confirm_relation(node) get_Confirm_relation_(node)

 #define set_Confirm_relation(node, relation) set_Confirm_relation_(node, relation)

 #define get_Confirm_value(node) get_Confirm_value_(node)

 #define set_Confirm_value(node, value) set_Confirm_value_(node, value)

 #define get_Confirm_bound(node) get_Confirm_bound_(node)

 #define set_Confirm_bound(node, bound) set_Confirm_bound_(node, bound)


 #define is_Const(node) is_Const_(node)

 #define get_Const_tarval(node) get_Const_tarval_(node)

 #define set_Const_tarval(node, tarval) set_Const_tarval_(node, tarval)


 #define is_Conv(node) is_Conv_(node)

 #define get_Conv_op(node) get_Conv_op_(node)

 #define set_Conv_op(node, op) set_Conv_op_(node, op)


 #define is_CopyB(node) is_CopyB_(node)

 #define get_CopyB_type(node) get_CopyB_type_(node)

 #define set_CopyB_type(node, type) set_CopyB_type_(node, type)

 #define get_CopyB_volatility(node) get_CopyB_volatility_(node)

 #define set_CopyB_volatility(node, volatility) set_CopyB_volatility_(node, volatility)

 #define get_CopyB_mem(node) get_CopyB_mem_(node)

 #define set_CopyB_mem(node, mem) set_CopyB_mem_(node, mem)

 #define get_CopyB_dst(node) get_CopyB_dst_(node)

 #define set_CopyB_dst(node, dst) set_CopyB_dst_(node, dst)

 #define get_CopyB_src(node) get_CopyB_src_(node)

 #define set_CopyB_src(node, src) set_CopyB_src_(node, src)


 #define is_Deleted(node) is_Deleted_(node)


 #define is_Div(node) is_Div_(node)

 #define get_Div_resmode(node) get_Div_resmode_(node)

 #define set_Div_resmode(node, resmode) set_Div_resmode_(node, resmode)

 #define get_Div_no_remainder(node) get_Div_no_remainder_(node)

 #define set_Div_no_remainder(node, no_remainder) set_Div_no_remainder_(node, no_remainder)

 #define get_Div_mem(node) get_Div_mem_(node)

 #define set_Div_mem(node, mem) set_Div_mem_(node, mem)

 #define get_Div_left(node) get_Div_left_(node)

 #define set_Div_left(node, left) set_Div_left_(node, left)

 #define get_Div_right(node) get_Div_right_(node)

 #define set_Div_right(node, right) set_Div_right_(node, right)


 #define is_Dummy(node) is_Dummy_(node)


 #define is_End(node) is_End_(node)

 #define get_End_n_keepalives(node) get_End_n_keepalives_(node)

 #define get_End_keepalive(node, pos) get_End_keepalive_(node, pos)

 #define set_End_keepalive(node, pos, keepalive) set_End_keepalive_(node, pos, keepalive)

 #define get_End_keepalive_arr(node) get_End_keepalive_arr_(node)


 #define is_Eor(node) is_Eor_(node)

 #define get_Eor_left(node) get_Eor_left_(node)

 #define set_Eor_left(node, left) set_Eor_left_(node, left)

 #define get_Eor_right(node) get_Eor_right_(node)

 #define set_Eor_right(node, right) set_Eor_right_(node, right)


 #define is_Free(node) is_Free_(node)

 #define get_Free_mem(node) get_Free_mem_(node)

 #define set_Free_mem(node, mem) set_Free_mem_(node, mem)

 #define get_Free_ptr(node) get_Free_ptr_(node)

 #define set_Free_ptr(node, ptr) set_Free_ptr_(node, ptr)


 #define is_IJmp(node) is_IJmp_(node)

 #define get_IJmp_target(node) get_IJmp_target_(node)

 #define set_IJmp_target(node, target) set_IJmp_target_(node, target)


 #define is_Id(node) is_Id_(node)

 #define get_Id_pred(node) get_Id_pred_(node)

 #define set_Id_pred(node, pred) set_Id_pred_(node, pred)


 #define is_Jmp(node) is_Jmp_(node)


 #define is_Load(node) is_Load_(node)

 #define get_Load_mode(node) get_Load_mode_(node)

 #define set_Load_mode(node, mode) set_Load_mode_(node, mode)

 #define get_Load_type(node) get_Load_type_(node)

 #define set_Load_type(node, type) set_Load_type_(node, type)

 #define get_Load_volatility(node) get_Load_volatility_(node)

 #define set_Load_volatility(node, volatility) set_Load_volatility_(node, volatility)

 #define get_Load_unaligned(node) get_Load_unaligned_(node)

 #define set_Load_unaligned(node, unaligned) set_Load_unaligned_(node, unaligned)

 #define get_Load_mem(node) get_Load_mem_(node)

 #define set_Load_mem(node, mem) set_Load_mem_(node, mem)

 #define get_Load_ptr(node) get_Load_ptr_(node)

 #define set_Load_ptr(node, ptr) set_Load_ptr_(node, ptr)


 #define is_Member(node) is_Member_(node)

 #define get_Member_entity(node) get_Member_entity_(node)

 #define set_Member_entity(node, entity) set_Member_entity_(node, entity)

 #define get_Member_ptr(node) get_Member_ptr_(node)

 #define set_Member_ptr(node, ptr) set_Member_ptr_(node, ptr)


 #define is_Minus(node) is_Minus_(node)

 #define get_Minus_op(node) get_Minus_op_(node)

 #define set_Minus_op(node, op) set_Minus_op_(node, op)


 #define is_Mod(node) is_Mod_(node)

 #define get_Mod_resmode(node) get_Mod_resmode_(node)

 #define set_Mod_resmode(node, resmode) set_Mod_resmode_(node, resmode)

 #define get_Mod_mem(node) get_Mod_mem_(node)

 #define set_Mod_mem(node, mem) set_Mod_mem_(node, mem)

 #define get_Mod_left(node) get_Mod_left_(node)

 #define set_Mod_left(node, left) set_Mod_left_(node, left)

 #define get_Mod_right(node) get_Mod_right_(node)

 #define set_Mod_right(node, right) set_Mod_right_(node, right)


 #define is_Mul(node) is_Mul_(node)

 #define get_Mul_left(node) get_Mul_left_(node)

 #define set_Mul_left(node, left) set_Mul_left_(node, left)

 #define get_Mul_right(node) get_Mul_right_(node)

 #define set_Mul_right(node, right) set_Mul_right_(node, right)


 #define is_Mulh(node) is_Mulh_(node)

 #define get_Mulh_left(node) get_Mulh_left_(node)

 #define set_Mulh_left(node, left) set_Mulh_left_(node, left)

 #define get_Mulh_right(node) get_Mulh_right_(node)

 #define set_Mulh_right(node, right) set_Mulh_right_(node, right)


 #define is_Mux(node) is_Mux_(node)

 #define get_Mux_sel(node) get_Mux_sel_(node)

 #define set_Mux_sel(node, sel) set_Mux_sel_(node, sel)

 #define get_Mux_false(node) get_Mux_false_(node)

 #define set_Mux_false(node, false_) set_Mux_false_(node, false_)

 #define get_Mux_true(node) get_Mux_true_(node)

 #define set_Mux_true(node, true_) set_Mux_true_(node, true_)


 #define is_NoMem(node) is_NoMem_(node)


 #define is_Not(node) is_Not_(node)

 #define get_Not_op(node) get_Not_op_(node)

 #define set_Not_op(node, op) set_Not_op_(node, op)


 #define is_Offset(node) is_Offset_(node)

 #define get_Offset_entity(node) get_Offset_entity_(node)

 #define set_Offset_entity(node, entity) set_Offset_entity_(node, entity)


 #define is_Or(node) is_Or_(node)

 #define get_Or_left(node) get_Or_left_(node)

 #define set_Or_left(node, left) set_Or_left_(node, left)

 #define get_Or_right(node) get_Or_right_(node)

 #define set_Or_right(node, right) set_Or_right_(node, right)


 #define is_Phi(node) is_Phi_(node)

 #define get_Phi_loop(node) get_Phi_loop_(node)

 #define set_Phi_loop(node, loop) set_Phi_loop_(node, loop)

 #define get_Phi_n_preds(node) get_Phi_n_preds_(node)

 #define get_Phi_pred(node, pos) get_Phi_pred_(node, pos)

 #define set_Phi_pred(node, pos, pred) set_Phi_pred_(node, pos, pred)

 #define get_Phi_pred_arr(node) get_Phi_pred_arr_(node)


 #define is_Pin(node) is_Pin_(node)

 #define get_Pin_op(node) get_Pin_op_(node)

 #define set_Pin_op(node, op) set_Pin_op_(node, op)


 #define is_Proj(node) is_Proj_(node)

 #define get_Proj_num(node) get_Proj_num_(node)

 #define set_Proj_num(node, num) set_Proj_num_(node, num)

 #define get_Proj_pred(node) get_Proj_pred_(node)

 #define set_Proj_pred(node, pred) set_Proj_pred_(node, pred)


 #define is_Raise(node) is_Raise_(node)

 #define get_Raise_mem(node) get_Raise_mem_(node)

 #define set_Raise_mem(node, mem) set_Raise_mem_(node, mem)

 #define get_Raise_exo_ptr(node) get_Raise_exo_ptr_(node)

 #define set_Raise_exo_ptr(node, exo_ptr) set_Raise_exo_ptr_(node, exo_ptr)


 #define is_Return(node) is_Return_(node)

 #define get_Return_mem(node) get_Return_mem_(node)

 #define set_Return_mem(node, mem) set_Return_mem_(node, mem)

 #define get_Return_n_ress(node) get_Return_n_ress_(node)

 #define get_Return_res(node, pos) get_Return_res_(node, pos)

 #define set_Return_res(node, pos, res) set_Return_res_(node, pos, res)

 #define get_Return_res_arr(node) get_Return_res_arr_(node)


 #define is_Sel(node) is_Sel_(node)

 #define get_Sel_type(node) get_Sel_type_(node)

 #define set_Sel_type(node, type) set_Sel_type_(node, type)

 #define get_Sel_ptr(node) get_Sel_ptr_(node)

 #define set_Sel_ptr(node, ptr) set_Sel_ptr_(node, ptr)

 #define get_Sel_index(node) get_Sel_index_(node)

 #define set_Sel_index(node, index) set_Sel_index_(node, index)


 #define is_Shl(node) is_Shl_(node)

 #define get_Shl_left(node) get_Shl_left_(node)

 #define set_Shl_left(node, left) set_Shl_left_(node, left)

 #define get_Shl_right(node) get_Shl_right_(node)

 #define set_Shl_right(node, right) set_Shl_right_(node, right)


 #define is_Shr(node) is_Shr_(node)

 #define get_Shr_left(node) get_Shr_left_(node)

 #define set_Shr_left(node, left) set_Shr_left_(node, left)

 #define get_Shr_right(node) get_Shr_right_(node)

 #define set_Shr_right(node, right) set_Shr_right_(node, right)


 #define is_Shrs(node) is_Shrs_(node)

 #define get_Shrs_left(node) get_Shrs_left_(node)

 #define set_Shrs_left(node, left) set_Shrs_left_(node, left)

 #define get_Shrs_right(node) get_Shrs_right_(node)

 #define set_Shrs_right(node, right) set_Shrs_right_(node, right)


 #define is_Size(node) is_Size_(node)

 #define get_Size_type(node) get_Size_type_(node)

 #define set_Size_type(node, type) set_Size_type_(node, type)


 #define is_Start(node) is_Start_(node)


 #define is_Store(node) is_Store_(node)

 #define get_Store_type(node) get_Store_type_(node)

 #define set_Store_type(node, type) set_Store_type_(node, type)

 #define get_Store_volatility(node) get_Store_volatility_(node)

 #define set_Store_volatility(node, volatility) set_Store_volatility_(node, volatility)

 #define get_Store_unaligned(node) get_Store_unaligned_(node)

 #define set_Store_unaligned(node, unaligned) set_Store_unaligned_(node, unaligned)

 #define get_Store_mem(node) get_Store_mem_(node)

 #define set_Store_mem(node, mem) set_Store_mem_(node, mem)

 #define get_Store_ptr(node) get_Store_ptr_(node)

 #define set_Store_ptr(node, ptr) set_Store_ptr_(node, ptr)

 #define get_Store_value(node) get_Store_value_(node)

 #define set_Store_value(node, value) set_Store_value_(node, value)


 #define is_Sub(node) is_Sub_(node)

 #define get_Sub_left(node) get_Sub_left_(node)

 #define set_Sub_left(node, left) set_Sub_left_(node, left)

 #define get_Sub_right(node) get_Sub_right_(node)

 #define set_Sub_right(node, right) set_Sub_right_(node, right)


 #define is_Switch(node) is_Switch_(node)

 #define get_Switch_n_outs(node) get_Switch_n_outs_(node)

 #define set_Switch_n_outs(node, n_outs) set_Switch_n_outs_(node, n_outs)

 #define get_Switch_table(node) get_Switch_table_(node)

 #define set_Switch_table(node, table) set_Switch_table_(node, table)

 #define get_Switch_selector(node) get_Switch_selector_(node)

 #define set_Switch_selector(node, selector) set_Switch_selector_(node, selector)


 #define is_Sync(node) is_Sync_(node)

 #define get_Sync_n_preds(node) get_Sync_n_preds_(node)

 #define get_Sync_pred(node, pos) get_Sync_pred_(node, pos)

 #define set_Sync_pred(node, pos, pred) set_Sync_pred_(node, pos, pred)

 #define get_Sync_pred_arr(node) get_Sync_pred_arr_(node)


 #define is_Tuple(node) is_Tuple_(node)

 #define get_Tuple_n_preds(node) get_Tuple_n_preds_(node)

 #define get_Tuple_pred(node, pos) get_Tuple_pred_(node, pos)

 #define set_Tuple_pred(node, pos, pred) set_Tuple_pred_(node, pos, pred)

 #define get_Tuple_pred_arr(node) get_Tuple_pred_arr_(node)


 #define is_Unknown(node) is_Unknown_(node)


 #define is_entconst(node) is_entconst_(node)

 #define get_entconst_entity(node) get_entconst_entity_(node)

 #define set_entconst_entity(node, entity) set_entconst_entity_(node, entity)

 #define is_typeconst(node) is_typeconst_(node)

 #define get_typeconst_type(node) get_typeconst_type_(node)

 #define set_typeconst_type(node, type) set_typeconst_type_(node, type)

 static inline int is_ASM_(const ir_node *node)

 {

     return get_irn_op(node) == op_ASM;

 }

 static inline ir_node *get_ASM_mem_(const ir_node *node)

 {

     assert(is_ASM(node));

     return get_irn_n(node, n_ASM_mem);

 }


 static inline void set_ASM_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_ASM(node));

     set_irn_n(node, n_ASM_mem, mem);

 }


 static inline int get_ASM_n_inputs_(ir_node const *node)

 {

     assert(is_ASM(node));

     return get_irn_arity(node) - (n_ASM_max + 1);

 }


 static inline ir_node *get_ASM_input_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_ASM_n_inputs(node));

     return get_irn_n(node, pos + (n_ASM_max + 1));

 }


 static inline void set_ASM_input_(ir_node *node, int pos, ir_node *input)

 {

     assert(0 <= pos && pos < get_ASM_n_inputs(node));

     set_irn_n(node, pos + (n_ASM_max + 1), input);

 }


 static inline ir_node **get_ASM_input_arr_(ir_node *node)

 {

     assert(is_ASM(node));

     return get_irn_in(node) + (n_ASM_max + 1);

 }


 static inline int is_Add_(const ir_node *node)

 {

     return get_irn_op(node) == op_Add;

 }

 static inline ir_node *get_Add_left_(const ir_node *node)

 {

     assert(is_Add(node));

     return get_irn_n(node, n_Add_left);

 }


 static inline void set_Add_left_(ir_node *node, ir_node *left)

 {

     assert(is_Add(node));

     set_irn_n(node, n_Add_left, left);

 }


 static inline ir_node *get_Add_right_(const ir_node *node)

 {

     assert(is_Add(node));

     return get_irn_n(node, n_Add_right);

 }


 static inline void set_Add_right_(ir_node *node, ir_node *right)

 {

     assert(is_Add(node));

     set_irn_n(node, n_Add_right, right);

 }


 static inline int is_Address_(const ir_node *node)

 {

     return get_irn_op(node) == op_Address;

 }

 static inline int is_Align_(const ir_node *node)

 {

     return get_irn_op(node) == op_Align;

 }

 static inline int is_Alloc_(const ir_node *node)

 {

     return get_irn_op(node) == op_Alloc;

 }

 static inline ir_node *get_Alloc_mem_(const ir_node *node)

 {

     assert(is_Alloc(node));

     return get_irn_n(node, n_Alloc_mem);

 }


 static inline void set_Alloc_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Alloc(node));

     set_irn_n(node, n_Alloc_mem, mem);

 }


 static inline ir_node *get_Alloc_size_(const ir_node *node)

 {

     assert(is_Alloc(node));

     return get_irn_n(node, n_Alloc_size);

 }


 static inline void set_Alloc_size_(ir_node *node, ir_node *size)

 {

     assert(is_Alloc(node));

     set_irn_n(node, n_Alloc_size, size);

 }


 static inline int is_Anchor_(const ir_node *node)

 {

     return get_irn_op(node) == op_Anchor;

 }

 static inline ir_node *get_Anchor_end_block_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_end_block);

 }


 static inline void set_Anchor_end_block_(ir_node *node, ir_node *end_block)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_end_block, end_block);

 }


 static inline ir_node *get_Anchor_start_block_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_start_block);

 }


 static inline void set_Anchor_start_block_(ir_node *node, ir_node *start_block)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_start_block, start_block);

 }


 static inline ir_node *get_Anchor_end_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_end);

 }


 static inline void set_Anchor_end_(ir_node *node, ir_node *end)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_end, end);

 }


 static inline ir_node *get_Anchor_start_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_start);

 }


 static inline void set_Anchor_start_(ir_node *node, ir_node *start)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_start, start);

 }


 static inline ir_node *get_Anchor_frame_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_frame);

 }


 static inline void set_Anchor_frame_(ir_node *node, ir_node *frame)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_frame, frame);

 }


 static inline ir_node *get_Anchor_initial_mem_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_initial_mem);

 }


 static inline void set_Anchor_initial_mem_(ir_node *node, ir_node *initial_mem)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_initial_mem, initial_mem);

 }


 static inline ir_node *get_Anchor_args_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_args);

 }


 static inline void set_Anchor_args_(ir_node *node, ir_node *args)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_args, args);

 }


 static inline ir_node *get_Anchor_no_mem_(const ir_node *node)

 {

     assert(is_Anchor(node));

     return get_irn_n(node, n_Anchor_no_mem);

 }


 static inline void set_Anchor_no_mem_(ir_node *node, ir_node *no_mem)

 {

     assert(is_Anchor(node));

     set_irn_n(node, n_Anchor_no_mem, no_mem);

 }


 static inline int is_And_(const ir_node *node)

 {

     return get_irn_op(node) == op_And;

 }

 static inline ir_node *get_And_left_(const ir_node *node)

 {

     assert(is_And(node));

     return get_irn_n(node, n_And_left);

 }


 static inline void set_And_left_(ir_node *node, ir_node *left)

 {

     assert(is_And(node));

     set_irn_n(node, n_And_left, left);

 }


 static inline ir_node *get_And_right_(const ir_node *node)

 {

     assert(is_And(node));

     return get_irn_n(node, n_And_right);

 }


 static inline void set_And_right_(ir_node *node, ir_node *right)

 {

     assert(is_And(node));

     set_irn_n(node, n_And_right, right);

 }


 static inline int is_Bad_(const ir_node *node)

 {

     return get_irn_op(node) == op_Bad;

 }

 static inline int is_Bitcast_(const ir_node *node)

 {

     return get_irn_op(node) == op_Bitcast;

 }

 static inline ir_node *get_Bitcast_op_(const ir_node *node)

 {

     assert(is_Bitcast(node));

     return get_irn_n(node, n_Bitcast_op);

 }


 static inline void set_Bitcast_op_(ir_node *node, ir_node *op)

 {

     assert(is_Bitcast(node));

     set_irn_n(node, n_Bitcast_op, op);

 }


 static inline int is_Block_(const ir_node *node)

 {

     return get_irn_op(node) == op_Block;

 }

 static inline int get_Block_n_cfgpreds_(ir_node const *node)

 {

     assert(is_Block(node));

     return get_irn_arity(node);

 }


 static inline ir_node *get_Block_cfgpred_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Block_n_cfgpreds(node));

     return get_irn_n(node, pos);

 }


 static inline void set_Block_cfgpred_(ir_node *node, int pos, ir_node *cfgpred)

 {

     assert(0 <= pos && pos < get_Block_n_cfgpreds(node));

     set_irn_n(node, pos, cfgpred);

 }


 static inline ir_node **get_Block_cfgpred_arr_(ir_node *node)

 {

     assert(is_Block(node));

     return get_irn_in(node);

 }


 static inline int is_Builtin_(const ir_node *node)

 {

     return get_irn_op(node) == op_Builtin;

 }

 static inline ir_node *get_Builtin_mem_(const ir_node *node)

 {

     assert(is_Builtin(node));

     return get_irn_n(node, n_Builtin_mem);

 }


 static inline void set_Builtin_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Builtin(node));

     set_irn_n(node, n_Builtin_mem, mem);

 }


 static inline int get_Builtin_n_params_(ir_node const *node)

 {

     assert(is_Builtin(node));

     return get_irn_arity(node) - (n_Builtin_max + 1);

 }


 static inline ir_node *get_Builtin_param_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Builtin_n_params(node));

     return get_irn_n(node, pos + (n_Builtin_max + 1));

 }


 static inline void set_Builtin_param_(ir_node *node, int pos, ir_node *param)

 {

     assert(0 <= pos && pos < get_Builtin_n_params(node));

     set_irn_n(node, pos + (n_Builtin_max + 1), param);

 }


 static inline ir_node **get_Builtin_param_arr_(ir_node *node)

 {

     assert(is_Builtin(node));

     return get_irn_in(node) + (n_Builtin_max + 1);

 }


 static inline int is_Call_(const ir_node *node)

 {

     return get_irn_op(node) == op_Call;

 }

 static inline ir_node *get_Call_mem_(const ir_node *node)

 {

     assert(is_Call(node));

     return get_irn_n(node, n_Call_mem);

 }


 static inline void set_Call_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Call(node));

     set_irn_n(node, n_Call_mem, mem);

 }


 static inline ir_node *get_Call_ptr_(const ir_node *node)

 {

     assert(is_Call(node));

     return get_irn_n(node, n_Call_ptr);

 }


 static inline void set_Call_ptr_(ir_node *node, ir_node *ptr)

 {

     assert(is_Call(node));

     set_irn_n(node, n_Call_ptr, ptr);

 }


 static inline int get_Call_n_params_(ir_node const *node)

 {

     assert(is_Call(node));

     return get_irn_arity(node) - (n_Call_max + 1);

 }


 static inline ir_node *get_Call_param_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Call_n_params(node));

     return get_irn_n(node, pos + (n_Call_max + 1));

 }


 static inline void set_Call_param_(ir_node *node, int pos, ir_node *param)

 {

     assert(0 <= pos && pos < get_Call_n_params(node));

     set_irn_n(node, pos + (n_Call_max + 1), param);

 }


 static inline ir_node **get_Call_param_arr_(ir_node *node)

 {

     assert(is_Call(node));

     return get_irn_in(node) + (n_Call_max + 1);

 }


 static inline int is_Cmp_(const ir_node *node)

 {

     return get_irn_op(node) == op_Cmp;

 }

 static inline ir_node *get_Cmp_left_(const ir_node *node)

 {

     assert(is_Cmp(node));

     return get_irn_n(node, n_Cmp_left);

 }


 static inline void set_Cmp_left_(ir_node *node, ir_node *left)

 {

     assert(is_Cmp(node));

     set_irn_n(node, n_Cmp_left, left);

 }


 static inline ir_node *get_Cmp_right_(const ir_node *node)

 {

     assert(is_Cmp(node));

     return get_irn_n(node, n_Cmp_right);

 }


 static inline void set_Cmp_right_(ir_node *node, ir_node *right)

 {

     assert(is_Cmp(node));

     set_irn_n(node, n_Cmp_right, right);

 }


 static inline int is_Cond_(const ir_node *node)

 {

     return get_irn_op(node) == op_Cond;

 }

 static inline ir_node *get_Cond_selector_(const ir_node *node)

 {

     assert(is_Cond(node));

     return get_irn_n(node, n_Cond_selector);

 }


 static inline void set_Cond_selector_(ir_node *node, ir_node *selector)

 {

     assert(is_Cond(node));

     set_irn_n(node, n_Cond_selector, selector);

 }


 static inline int is_Confirm_(const ir_node *node)

 {

     return get_irn_op(node) == op_Confirm;

 }

 static inline ir_node *get_Confirm_value_(const ir_node *node)

 {

     assert(is_Confirm(node));

     return get_irn_n(node, n_Confirm_value);

 }


 static inline void set_Confirm_value_(ir_node *node, ir_node *value)

 {

     assert(is_Confirm(node));

     set_irn_n(node, n_Confirm_value, value);

 }


 static inline ir_node *get_Confirm_bound_(const ir_node *node)

 {

     assert(is_Confirm(node));

     return get_irn_n(node, n_Confirm_bound);

 }


 static inline void set_Confirm_bound_(ir_node *node, ir_node *bound)

 {

     assert(is_Confirm(node));

     set_irn_n(node, n_Confirm_bound, bound);

 }


 static inline int is_Const_(const ir_node *node)

 {

     return get_irn_op(node) == op_Const;

 }

 static inline int is_Conv_(const ir_node *node)

 {

     return get_irn_op(node) == op_Conv;

 }

 static inline ir_node *get_Conv_op_(const ir_node *node)

 {

     assert(is_Conv(node));

     return get_irn_n(node, n_Conv_op);

 }


 static inline void set_Conv_op_(ir_node *node, ir_node *op)

 {

     assert(is_Conv(node));

     set_irn_n(node, n_Conv_op, op);

 }


 static inline int is_CopyB_(const ir_node *node)

 {

     return get_irn_op(node) == op_CopyB;

 }

 static inline ir_node *get_CopyB_mem_(const ir_node *node)

 {

     assert(is_CopyB(node));

     return get_irn_n(node, n_CopyB_mem);

 }


 static inline void set_CopyB_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_CopyB(node));

     set_irn_n(node, n_CopyB_mem, mem);

 }


 static inline ir_node *get_CopyB_dst_(const ir_node *node)

 {

     assert(is_CopyB(node));

     return get_irn_n(node, n_CopyB_dst);

 }


 static inline void set_CopyB_dst_(ir_node *node, ir_node *dst)

 {

     assert(is_CopyB(node));

     set_irn_n(node, n_CopyB_dst, dst);

 }


 static inline ir_node *get_CopyB_src_(const ir_node *node)

 {

     assert(is_CopyB(node));

     return get_irn_n(node, n_CopyB_src);

 }


 static inline void set_CopyB_src_(ir_node *node, ir_node *src)

 {

     assert(is_CopyB(node));

     set_irn_n(node, n_CopyB_src, src);

 }


 static inline int is_Deleted_(const ir_node *node)

 {

     return get_irn_op(node) == op_Deleted;

 }

 static inline int is_Div_(const ir_node *node)

 {

     return get_irn_op(node) == op_Div;

 }

 static inline ir_node *get_Div_mem_(const ir_node *node)

 {

     assert(is_Div(node));

     return get_irn_n(node, n_Div_mem);

 }


 static inline void set_Div_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Div(node));

     set_irn_n(node, n_Div_mem, mem);

 }


 static inline ir_node *get_Div_left_(const ir_node *node)

 {

     assert(is_Div(node));

     return get_irn_n(node, n_Div_left);

 }


 static inline void set_Div_left_(ir_node *node, ir_node *left)

 {

     assert(is_Div(node));

     set_irn_n(node, n_Div_left, left);

 }


 static inline ir_node *get_Div_right_(const ir_node *node)

 {

     assert(is_Div(node));

     return get_irn_n(node, n_Div_right);

 }


 static inline void set_Div_right_(ir_node *node, ir_node *right)

 {

     assert(is_Div(node));

     set_irn_n(node, n_Div_right, right);

 }


 static inline int is_Dummy_(const ir_node *node)

 {

     return get_irn_op(node) == op_Dummy;

 }

 static inline int is_End_(const ir_node *node)

 {

     return get_irn_op(node) == op_End;

 }

 static inline int get_End_n_keepalives_(ir_node const *node)

 {

     assert(is_End(node));

     return get_irn_arity(node);

 }


 static inline ir_node *get_End_keepalive_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_End_n_keepalives(node));

     return get_irn_n(node, pos);

 }


 static inline void set_End_keepalive_(ir_node *node, int pos, ir_node *keepalive)

 {

     assert(0 <= pos && pos < get_End_n_keepalives(node));

     set_irn_n(node, pos, keepalive);

 }


 static inline ir_node **get_End_keepalive_arr_(ir_node *node)

 {

     assert(is_End(node));

     return get_irn_in(node);

 }


 static inline int is_Eor_(const ir_node *node)

 {

     return get_irn_op(node) == op_Eor;

 }

 static inline ir_node *get_Eor_left_(const ir_node *node)

 {

     assert(is_Eor(node));

     return get_irn_n(node, n_Eor_left);

 }


 static inline void set_Eor_left_(ir_node *node, ir_node *left)

 {

     assert(is_Eor(node));

     set_irn_n(node, n_Eor_left, left);

 }


 static inline ir_node *get_Eor_right_(const ir_node *node)

 {

     assert(is_Eor(node));

     return get_irn_n(node, n_Eor_right);

 }


 static inline void set_Eor_right_(ir_node *node, ir_node *right)

 {

     assert(is_Eor(node));

     set_irn_n(node, n_Eor_right, right);

 }


 static inline int is_Free_(const ir_node *node)

 {

     return get_irn_op(node) == op_Free;

 }

 static inline ir_node *get_Free_mem_(const ir_node *node)

 {

     assert(is_Free(node));

     return get_irn_n(node, n_Free_mem);

 }


 static inline void set_Free_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Free(node));

     set_irn_n(node, n_Free_mem, mem);

 }


 static inline ir_node *get_Free_ptr_(const ir_node *node)

 {

     assert(is_Free(node));

     return get_irn_n(node, n_Free_ptr);

 }


 static inline void set_Free_ptr_(ir_node *node, ir_node *ptr)

 {

     assert(is_Free(node));

     set_irn_n(node, n_Free_ptr, ptr);

 }


 static inline int is_IJmp_(const ir_node *node)

 {

     return get_irn_op(node) == op_IJmp;

 }

 static inline ir_node *get_IJmp_target_(const ir_node *node)

 {

     assert(is_IJmp(node));

     return get_irn_n(node, n_IJmp_target);

 }


 static inline void set_IJmp_target_(ir_node *node, ir_node *target)

 {

     assert(is_IJmp(node));

     set_irn_n(node, n_IJmp_target, target);

 }


 static inline int is_Id_(const ir_node *node)

 {

     return get_irn_op(node) == op_Id;

 }

 static inline ir_node *get_Id_pred_(const ir_node *node)

 {

     assert(is_Id(node));

     return get_irn_n(node, n_Id_pred);

 }


 static inline void set_Id_pred_(ir_node *node, ir_node *pred)

 {

     assert(is_Id(node));

     set_irn_n(node, n_Id_pred, pred);

 }


 static inline int is_Jmp_(const ir_node *node)

 {

     return get_irn_op(node) == op_Jmp;

 }

 static inline int is_Load_(const ir_node *node)

 {

     return get_irn_op(node) == op_Load;

 }

 static inline ir_node *get_Load_mem_(const ir_node *node)

 {

     assert(is_Load(node));

     return get_irn_n(node, n_Load_mem);

 }


 static inline void set_Load_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Load(node));

     set_irn_n(node, n_Load_mem, mem);

 }


 static inline ir_node *get_Load_ptr_(const ir_node *node)

 {

     assert(is_Load(node));

     return get_irn_n(node, n_Load_ptr);

 }


 static inline void set_Load_ptr_(ir_node *node, ir_node *ptr)

 {

     assert(is_Load(node));

     set_irn_n(node, n_Load_ptr, ptr);

 }


 static inline int is_Member_(const ir_node *node)

 {

     return get_irn_op(node) == op_Member;

 }

 static inline ir_node *get_Member_ptr_(const ir_node *node)

 {

     assert(is_Member(node));

     return get_irn_n(node, n_Member_ptr);

 }


 static inline void set_Member_ptr_(ir_node *node, ir_node *ptr)

 {

     assert(is_Member(node));

     set_irn_n(node, n_Member_ptr, ptr);

 }


 static inline int is_Minus_(const ir_node *node)

 {

     return get_irn_op(node) == op_Minus;

 }

 static inline ir_node *get_Minus_op_(const ir_node *node)

 {

     assert(is_Minus(node));

     return get_irn_n(node, n_Minus_op);

 }


 static inline void set_Minus_op_(ir_node *node, ir_node *op)

 {

     assert(is_Minus(node));

     set_irn_n(node, n_Minus_op, op);

 }


 static inline int is_Mod_(const ir_node *node)

 {

     return get_irn_op(node) == op_Mod;

 }

 static inline ir_node *get_Mod_mem_(const ir_node *node)

 {

     assert(is_Mod(node));

     return get_irn_n(node, n_Mod_mem);

 }


 static inline void set_Mod_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Mod(node));

     set_irn_n(node, n_Mod_mem, mem);

 }


 static inline ir_node *get_Mod_left_(const ir_node *node)

 {

     assert(is_Mod(node));

     return get_irn_n(node, n_Mod_left);

 }


 static inline void set_Mod_left_(ir_node *node, ir_node *left)

 {

     assert(is_Mod(node));

     set_irn_n(node, n_Mod_left, left);

 }


 static inline ir_node *get_Mod_right_(const ir_node *node)

 {

     assert(is_Mod(node));

     return get_irn_n(node, n_Mod_right);

 }


 static inline void set_Mod_right_(ir_node *node, ir_node *right)

 {

     assert(is_Mod(node));

     set_irn_n(node, n_Mod_right, right);

 }


 static inline int is_Mul_(const ir_node *node)

 {

     return get_irn_op(node) == op_Mul;

 }

 static inline ir_node *get_Mul_left_(const ir_node *node)

 {

     assert(is_Mul(node));

     return get_irn_n(node, n_Mul_left);

 }


 static inline void set_Mul_left_(ir_node *node, ir_node *left)

 {

     assert(is_Mul(node));

     set_irn_n(node, n_Mul_left, left);

 }


 static inline ir_node *get_Mul_right_(const ir_node *node)

 {

     assert(is_Mul(node));

     return get_irn_n(node, n_Mul_right);

 }


 static inline void set_Mul_right_(ir_node *node, ir_node *right)

 {

     assert(is_Mul(node));

     set_irn_n(node, n_Mul_right, right);

 }


 static inline int is_Mulh_(const ir_node *node)

 {

     return get_irn_op(node) == op_Mulh;

 }

 static inline ir_node *get_Mulh_left_(const ir_node *node)

 {

     assert(is_Mulh(node));

     return get_irn_n(node, n_Mulh_left);

 }


 static inline void set_Mulh_left_(ir_node *node, ir_node *left)

 {

     assert(is_Mulh(node));

     set_irn_n(node, n_Mulh_left, left);

 }


 static inline ir_node *get_Mulh_right_(const ir_node *node)

 {

     assert(is_Mulh(node));

     return get_irn_n(node, n_Mulh_right);

 }


 static inline void set_Mulh_right_(ir_node *node, ir_node *right)

 {

     assert(is_Mulh(node));

     set_irn_n(node, n_Mulh_right, right);

 }


 static inline int is_Mux_(const ir_node *node)

 {

     return get_irn_op(node) == op_Mux;

 }

 static inline ir_node *get_Mux_sel_(const ir_node *node)

 {

     assert(is_Mux(node));

     return get_irn_n(node, n_Mux_sel);

 }


 static inline void set_Mux_sel_(ir_node *node, ir_node *sel)

 {

     assert(is_Mux(node));

     set_irn_n(node, n_Mux_sel, sel);

 }


 static inline ir_node *get_Mux_false_(const ir_node *node)

 {

     assert(is_Mux(node));

     return get_irn_n(node, n_Mux_false);

 }


 static inline void set_Mux_false_(ir_node *node, ir_node *false_)

 {

     assert(is_Mux(node));

     set_irn_n(node, n_Mux_false, false_);

 }


 static inline ir_node *get_Mux_true_(const ir_node *node)

 {

     assert(is_Mux(node));

     return get_irn_n(node, n_Mux_true);

 }


 static inline void set_Mux_true_(ir_node *node, ir_node *true_)

 {

     assert(is_Mux(node));

     set_irn_n(node, n_Mux_true, true_);

 }


 static inline int is_NoMem_(const ir_node *node)

 {

     return get_irn_op(node) == op_NoMem;

 }

 static inline int is_Not_(const ir_node *node)

 {

     return get_irn_op(node) == op_Not;

 }

 static inline ir_node *get_Not_op_(const ir_node *node)

 {

     assert(is_Not(node));

     return get_irn_n(node, n_Not_op);

 }


 static inline void set_Not_op_(ir_node *node, ir_node *op)

 {

     assert(is_Not(node));

     set_irn_n(node, n_Not_op, op);

 }


 static inline int is_Offset_(const ir_node *node)

 {

     return get_irn_op(node) == op_Offset;

 }

 static inline int is_Or_(const ir_node *node)

 {

     return get_irn_op(node) == op_Or;

 }

 static inline ir_node *get_Or_left_(const ir_node *node)

 {

     assert(is_Or(node));

     return get_irn_n(node, n_Or_left);

 }


 static inline void set_Or_left_(ir_node *node, ir_node *left)

 {

     assert(is_Or(node));

     set_irn_n(node, n_Or_left, left);

 }


 static inline ir_node *get_Or_right_(const ir_node *node)

 {

     assert(is_Or(node));

     return get_irn_n(node, n_Or_right);

 }


 static inline void set_Or_right_(ir_node *node, ir_node *right)

 {

     assert(is_Or(node));

     set_irn_n(node, n_Or_right, right);

 }


 static inline int is_Phi_(const ir_node *node)

 {

     return get_irn_op(node) == op_Phi;

 }

 static inline int get_Phi_n_preds_(ir_node const *node)

 {

     assert(is_Phi(node));

     return get_irn_arity(node);

 }


 static inline ir_node *get_Phi_pred_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Phi_n_preds(node));

     return get_irn_n(node, pos);

 }


 static inline void set_Phi_pred_(ir_node *node, int pos, ir_node *pred)

 {

     assert(0 <= pos && pos < get_Phi_n_preds(node));

     set_irn_n(node, pos, pred);

 }


 static inline ir_node **get_Phi_pred_arr_(ir_node *node)

 {

     assert(is_Phi(node));

     return get_irn_in(node);

 }


 static inline int is_Pin_(const ir_node *node)

 {

     return get_irn_op(node) == op_Pin;

 }

 static inline ir_node *get_Pin_op_(const ir_node *node)

 {

     assert(is_Pin(node));

     return get_irn_n(node, n_Pin_op);

 }


 static inline void set_Pin_op_(ir_node *node, ir_node *op)

 {

     assert(is_Pin(node));

     set_irn_n(node, n_Pin_op, op);

 }


 static inline int is_Proj_(const ir_node *node)

 {

     return get_irn_op(node) == op_Proj;

 }

 static inline ir_node *get_Proj_pred_(const ir_node *node)

 {

     assert(is_Proj(node));

     return get_irn_n(node, n_Proj_pred);

 }


 static inline void set_Proj_pred_(ir_node *node, ir_node *pred)

 {

     assert(is_Proj(node));

     set_irn_n(node, n_Proj_pred, pred);

 }


 static inline int is_Raise_(const ir_node *node)

 {

     return get_irn_op(node) == op_Raise;

 }

 static inline ir_node *get_Raise_mem_(const ir_node *node)

 {

     assert(is_Raise(node));

     return get_irn_n(node, n_Raise_mem);

 }


 static inline void set_Raise_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Raise(node));

     set_irn_n(node, n_Raise_mem, mem);

 }


 static inline ir_node *get_Raise_exo_ptr_(const ir_node *node)

 {

     assert(is_Raise(node));

     return get_irn_n(node, n_Raise_exo_ptr);

 }


 static inline void set_Raise_exo_ptr_(ir_node *node, ir_node *exo_ptr)

 {

     assert(is_Raise(node));

     set_irn_n(node, n_Raise_exo_ptr, exo_ptr);

 }


 static inline int is_Return_(const ir_node *node)

 {

     return get_irn_op(node) == op_Return;

 }

 static inline ir_node *get_Return_mem_(const ir_node *node)

 {

     assert(is_Return(node));

     return get_irn_n(node, n_Return_mem);

 }


 static inline void set_Return_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Return(node));

     set_irn_n(node, n_Return_mem, mem);

 }


 static inline int get_Return_n_ress_(ir_node const *node)

 {

     assert(is_Return(node));

     return get_irn_arity(node) - (n_Return_max + 1);

 }


 static inline ir_node *get_Return_res_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Return_n_ress(node));

     return get_irn_n(node, pos + (n_Return_max + 1));

 }


 static inline void set_Return_res_(ir_node *node, int pos, ir_node *res)

 {

     assert(0 <= pos && pos < get_Return_n_ress(node));

     set_irn_n(node, pos + (n_Return_max + 1), res);

 }


 static inline ir_node **get_Return_res_arr_(ir_node *node)

 {

     assert(is_Return(node));

     return get_irn_in(node) + (n_Return_max + 1);

 }


 static inline int is_Sel_(const ir_node *node)

 {

     return get_irn_op(node) == op_Sel;

 }

 static inline ir_node *get_Sel_ptr_(const ir_node *node)

 {

     assert(is_Sel(node));

     return get_irn_n(node, n_Sel_ptr);

 }


 static inline void set_Sel_ptr_(ir_node *node, ir_node *ptr)

 {

     assert(is_Sel(node));

     set_irn_n(node, n_Sel_ptr, ptr);

 }


 static inline ir_node *get_Sel_index_(const ir_node *node)

 {

     assert(is_Sel(node));

     return get_irn_n(node, n_Sel_index);

 }


 static inline void set_Sel_index_(ir_node *node, ir_node *index)

 {

     assert(is_Sel(node));

     set_irn_n(node, n_Sel_index, index);

 }


 static inline int is_Shl_(const ir_node *node)

 {

     return get_irn_op(node) == op_Shl;

 }

 static inline ir_node *get_Shl_left_(const ir_node *node)

 {

     assert(is_Shl(node));

     return get_irn_n(node, n_Shl_left);

 }


 static inline void set_Shl_left_(ir_node *node, ir_node *left)

 {

     assert(is_Shl(node));

     set_irn_n(node, n_Shl_left, left);

 }


 static inline ir_node *get_Shl_right_(const ir_node *node)

 {

     assert(is_Shl(node));

     return get_irn_n(node, n_Shl_right);

 }


 static inline void set_Shl_right_(ir_node *node, ir_node *right)

 {

     assert(is_Shl(node));

     set_irn_n(node, n_Shl_right, right);

 }


 static inline int is_Shr_(const ir_node *node)

 {

     return get_irn_op(node) == op_Shr;

 }

 static inline ir_node *get_Shr_left_(const ir_node *node)

 {

     assert(is_Shr(node));

     return get_irn_n(node, n_Shr_left);

 }


 static inline void set_Shr_left_(ir_node *node, ir_node *left)

 {

     assert(is_Shr(node));

     set_irn_n(node, n_Shr_left, left);

 }


 static inline ir_node *get_Shr_right_(const ir_node *node)

 {

     assert(is_Shr(node));

     return get_irn_n(node, n_Shr_right);

 }


 static inline void set_Shr_right_(ir_node *node, ir_node *right)

 {

     assert(is_Shr(node));

     set_irn_n(node, n_Shr_right, right);

 }


 static inline int is_Shrs_(const ir_node *node)

 {

     return get_irn_op(node) == op_Shrs;

 }

 static inline ir_node *get_Shrs_left_(const ir_node *node)

 {

     assert(is_Shrs(node));

     return get_irn_n(node, n_Shrs_left);

 }


 static inline void set_Shrs_left_(ir_node *node, ir_node *left)

 {

     assert(is_Shrs(node));

     set_irn_n(node, n_Shrs_left, left);

 }


 static inline ir_node *get_Shrs_right_(const ir_node *node)

 {

     assert(is_Shrs(node));

     return get_irn_n(node, n_Shrs_right);

 }


 static inline void set_Shrs_right_(ir_node *node, ir_node *right)

 {

     assert(is_Shrs(node));

     set_irn_n(node, n_Shrs_right, right);

 }


 static inline int is_Size_(const ir_node *node)

 {

     return get_irn_op(node) == op_Size;

 }

 static inline int is_Start_(const ir_node *node)

 {

     return get_irn_op(node) == op_Start;

 }

 static inline int is_Store_(const ir_node *node)

 {

     return get_irn_op(node) == op_Store;

 }

 static inline ir_node *get_Store_mem_(const ir_node *node)

 {

     assert(is_Store(node));

     return get_irn_n(node, n_Store_mem);

 }


 static inline void set_Store_mem_(ir_node *node, ir_node *mem)

 {

     assert(is_Store(node));

     set_irn_n(node, n_Store_mem, mem);

 }


 static inline ir_node *get_Store_ptr_(const ir_node *node)

 {

     assert(is_Store(node));

     return get_irn_n(node, n_Store_ptr);

 }


 static inline void set_Store_ptr_(ir_node *node, ir_node *ptr)

 {

     assert(is_Store(node));

     set_irn_n(node, n_Store_ptr, ptr);

 }


 static inline ir_node *get_Store_value_(const ir_node *node)

 {

     assert(is_Store(node));

     return get_irn_n(node, n_Store_value);

 }


 static inline void set_Store_value_(ir_node *node, ir_node *value)

 {

     assert(is_Store(node));

     set_irn_n(node, n_Store_value, value);

 }


 static inline int is_Sub_(const ir_node *node)

 {

     return get_irn_op(node) == op_Sub;

 }

 static inline ir_node *get_Sub_left_(const ir_node *node)

 {

     assert(is_Sub(node));

     return get_irn_n(node, n_Sub_left);

 }


 static inline void set_Sub_left_(ir_node *node, ir_node *left)

 {

     assert(is_Sub(node));

     set_irn_n(node, n_Sub_left, left);

 }


 static inline ir_node *get_Sub_right_(const ir_node *node)

 {

     assert(is_Sub(node));

     return get_irn_n(node, n_Sub_right);

 }


 static inline void set_Sub_right_(ir_node *node, ir_node *right)

 {

     assert(is_Sub(node));

     set_irn_n(node, n_Sub_right, right);

 }


 static inline int is_Switch_(const ir_node *node)

 {

     return get_irn_op(node) == op_Switch;

 }

 static inline ir_node *get_Switch_selector_(const ir_node *node)

 {

     assert(is_Switch(node));

     return get_irn_n(node, n_Switch_selector);

 }


 static inline void set_Switch_selector_(ir_node *node, ir_node *selector)

 {

     assert(is_Switch(node));

     set_irn_n(node, n_Switch_selector, selector);

 }


 static inline int is_Sync_(const ir_node *node)

 {

     return get_irn_op(node) == op_Sync;

 }

 static inline int get_Sync_n_preds_(ir_node const *node)

 {

     assert(is_Sync(node));

     return get_irn_arity(node);

 }


 static inline ir_node *get_Sync_pred_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Sync_n_preds(node));

     return get_irn_n(node, pos);

 }


 static inline void set_Sync_pred_(ir_node *node, int pos, ir_node *pred)

 {

     assert(0 <= pos && pos < get_Sync_n_preds(node));

     set_irn_n(node, pos, pred);

 }


 static inline ir_node **get_Sync_pred_arr_(ir_node *node)

 {

     assert(is_Sync(node));

     return get_irn_in(node);

 }


 static inline int is_Tuple_(const ir_node *node)

 {

     return get_irn_op(node) == op_Tuple;

 }

 static inline int get_Tuple_n_preds_(ir_node const *node)

 {

     assert(is_Tuple(node));

     return get_irn_arity(node);

 }


 static inline ir_node *get_Tuple_pred_(ir_node const *node, int pos)

 {

     assert(0 <= pos && pos < get_Tuple_n_preds(node));

     return get_irn_n(node, pos);

 }


 static inline void set_Tuple_pred_(ir_node *node, int pos, ir_node *pred)

 {

     assert(0 <= pos && pos < get_Tuple_n_preds(node));

     set_irn_n(node, pos, pred);

 }


 static inline ir_node **get_Tuple_pred_arr_(ir_node *node)

 {

     assert(is_Tuple(node));

     return get_irn_in(node);

 }


 static inline int is_Unknown_(const ir_node *node)

 {

     return get_irn_op(node) == op_Unknown;

 }

 static inline int is_entconst_(const ir_node *node)

 {

     return is_Address(node) || is_Offset(node);

 }


 static inline int is_typeconst_(const ir_node *node)

 {

     return is_Align(node) || is_Size(node);

 }


 static inline ir_asm_constraint* get_ASM_constraints_(const ir_node *node)

 {

     assert(is_ASM(node));

     return node->attr.assem.constraints;

 }


 static inline void set_ASM_constraints_(ir_node *node, ir_asm_constraint* constraints)

 {

     assert(is_ASM(node));

     node->attr.assem.constraints = constraints;

 }


 static inline ident** get_ASM_clobbers_(const ir_node *node)

 {

     assert(is_ASM(node));

     return node->attr.assem.clobbers;

 }


 static inline void set_ASM_clobbers_(ir_node *node, ident** clobbers)

 {

     assert(is_ASM(node));

     node->attr.assem.clobbers = clobbers;

 }


 static inline ident* get_ASM_text_(const ir_node *node)

 {

     assert(is_ASM(node));

     return node->attr.assem.text;

 }


 static inline void set_ASM_text_(ir_node *node, ident* text)

 {

     assert(is_ASM(node));

     node->attr.assem.text = text;

 }


 static inline ir_entity* get_Address_entity_(const ir_node *node)

 {

     assert(is_Address(node));

     return node->attr.entc.entity;

 }


 static inline void set_Address_entity_(ir_node *node, ir_entity* entity)

 {

     assert(is_Address(node));

     node->attr.entc.entity = entity;

 }


 static inline ir_type* get_Align_type_(const ir_node *node)

 {

     assert(is_Align(node));

     return node->attr.typec.type;

 }


 static inline void set_Align_type_(ir_node *node, ir_type* type)

 {

     assert(is_Align(node));

     node->attr.typec.type = type;

 }


 static inline unsigned get_Alloc_alignment_(const ir_node *node)

 {

     assert(is_Alloc(node));

     return node->attr.alloc.alignment;

 }


 static inline void set_Alloc_alignment_(ir_node *node, unsigned alignment)

 {

     assert(is_Alloc(node));

     node->attr.alloc.alignment = alignment;

 }


 static inline ir_entity* get_Block_entity_(const ir_node *node)

 {

     assert(is_Block(node));

     return node->attr.block.entity;

 }


 static inline void set_Block_entity_(ir_node *node, ir_entity* entity)

 {

     assert(is_Block(node));

     node->attr.block.entity = entity;

 }


 static inline ir_builtin_kind get_Builtin_kind_(const ir_node *node)

 {

     assert(is_Builtin(node));

     return node->attr.builtin.kind;

 }


 static inline void set_Builtin_kind_(ir_node *node, ir_builtin_kind kind)

 {

     assert(is_Builtin(node));

     node->attr.builtin.kind = kind;

 }


 static inline ir_type* get_Builtin_type_(const ir_node *node)

 {

     assert(is_Builtin(node));

     return node->attr.builtin.type;

 }


 static inline void set_Builtin_type_(ir_node *node, ir_type* type)

 {

     assert(is_Builtin(node));

     node->attr.builtin.type = type;

 }


 static inline ir_type* get_Call_type_(const ir_node *node)

 {

     assert(is_Call(node));

     return node->attr.call.type;

 }


 static inline void set_Call_type_(ir_node *node, ir_type* type)

 {

     assert(is_Call(node));

     node->attr.call.type = type;

 }


 static inline ir_relation get_Cmp_relation_(const ir_node *node)

 {

     assert(is_Cmp(node));

     return node->attr.cmp.relation;

 }


 static inline void set_Cmp_relation_(ir_node *node, ir_relation relation)

 {

     assert(is_Cmp(node));

     node->attr.cmp.relation = relation;

 }


 static inline cond_jmp_predicate get_Cond_jmp_pred_(const ir_node *node)

 {

     assert(is_Cond(node));

     return node->attr.cond.jmp_pred;

 }


 static inline void set_Cond_jmp_pred_(ir_node *node, cond_jmp_predicate jmp_pred)

 {

     assert(is_Cond(node));

     node->attr.cond.jmp_pred = jmp_pred;

 }


 static inline ir_relation get_Confirm_relation_(const ir_node *node)

 {

     assert(is_Confirm(node));

     return node->attr.confirm.relation;

 }


 static inline void set_Confirm_relation_(ir_node *node, ir_relation relation)

 {

     assert(is_Confirm(node));

     node->attr.confirm.relation = relation;

 }


 static inline ir_tarval* get_Const_tarval_(const ir_node *node)

 {

     assert(is_Const(node));

     return node->attr.con.tarval;

 }


 static inline void set_Const_tarval_(ir_node *node, ir_tarval* tarval)

 {

     assert(is_Const(node));

     node->attr.con.tarval = tarval;

 }


 static inline ir_type* get_CopyB_type_(const ir_node *node)

 {

     assert(is_CopyB(node));

     return node->attr.copyb.type;

 }


 static inline void set_CopyB_type_(ir_node *node, ir_type* type)

 {

     assert(is_CopyB(node));

     node->attr.copyb.type = type;

 }


 static inline ir_volatility get_CopyB_volatility_(const ir_node *node)

 {

     assert(is_CopyB(node));

     return node->attr.copyb.volatility;

 }


 static inline void set_CopyB_volatility_(ir_node *node, ir_volatility volatility)

 {

     assert(is_CopyB(node));

     node->attr.copyb.volatility = volatility;

 }


 static inline ir_mode* get_Div_resmode_(const ir_node *node)

 {

     assert(is_Div(node));

     return node->attr.div.resmode;

 }


 static inline void set_Div_resmode_(ir_node *node, ir_mode* resmode)

 {

     assert(is_Div(node));

     node->attr.div.resmode = resmode;

 }


 static inline int get_Div_no_remainder_(const ir_node *node)

 {

     assert(is_Div(node));

     return node->attr.div.no_remainder;

 }


 static inline void set_Div_no_remainder_(ir_node *node, int no_remainder)

 {

     assert(is_Div(node));

     node->attr.div.no_remainder = no_remainder;

 }


 static inline ir_mode* get_Load_mode_(const ir_node *node)

 {

     assert(is_Load(node));

     return node->attr.load.mode;

 }


 static inline void set_Load_mode_(ir_node *node, ir_mode* mode)

 {

     assert(is_Load(node));

     node->attr.load.mode = mode;

 }


 static inline ir_type* get_Load_type_(const ir_node *node)

 {

     assert(is_Load(node));

     return node->attr.load.type;

 }


 static inline void set_Load_type_(ir_node *node, ir_type* type)

 {

     assert(is_Load(node));

     node->attr.load.type = type;

 }


 static inline ir_volatility get_Load_volatility_(const ir_node *node)

 {

     assert(is_Load(node));

     return node->attr.load.volatility;

 }


 static inline void set_Load_volatility_(ir_node *node, ir_volatility volatility)

 {

     assert(is_Load(node));

     node->attr.load.volatility = volatility;

 }


 static inline ir_align get_Load_unaligned_(const ir_node *node)

 {

     assert(is_Load(node));

     return node->attr.load.unaligned;

 }


 static inline void set_Load_unaligned_(ir_node *node, ir_align unaligned)

 {

     assert(is_Load(node));

     node->attr.load.unaligned = unaligned;

 }


 static inline ir_entity* get_Member_entity_(const ir_node *node)

 {

     assert(is_Member(node));

     return node->attr.member.entity;

 }


 static inline void set_Member_entity_(ir_node *node, ir_entity* entity)

 {

     assert(is_Member(node));

     node->attr.member.entity = entity;

 }


 static inline ir_mode* get_Mod_resmode_(const ir_node *node)

 {

     assert(is_Mod(node));

     return node->attr.mod.resmode;

 }


 static inline void set_Mod_resmode_(ir_node *node, ir_mode* resmode)

 {

     assert(is_Mod(node));

     node->attr.mod.resmode = resmode;

 }


 static inline ir_entity* get_Offset_entity_(const ir_node *node)

 {

     assert(is_Offset(node));

     return node->attr.entc.entity;

 }


 static inline void set_Offset_entity_(ir_node *node, ir_entity* entity)

 {

     assert(is_Offset(node));

     node->attr.entc.entity = entity;

 }


 static inline int get_Phi_loop_(const ir_node *node)

 {

     assert(is_Phi(node));

     return node->attr.phi.loop;

 }


 static inline void set_Phi_loop_(ir_node *node, int loop)

 {

     assert(is_Phi(node));

     node->attr.phi.loop = loop;

 }


 static inline unsigned get_Proj_num_(const ir_node *node)

 {

     assert(is_Proj(node));

     return node->attr.proj.num;

 }


 static inline void set_Proj_num_(ir_node *node, unsigned num)

 {

     assert(is_Proj(node));

     node->attr.proj.num = num;

 }


 static inline ir_type* get_Sel_type_(const ir_node *node)

 {

     assert(is_Sel(node));

     return node->attr.sel.type;

 }


 static inline void set_Sel_type_(ir_node *node, ir_type* type)

 {

     assert(is_Sel(node));

     node->attr.sel.type = type;

 }


 static inline ir_type* get_Size_type_(const ir_node *node)

 {

     assert(is_Size(node));

     return node->attr.typec.type;

 }


 static inline void set_Size_type_(ir_node *node, ir_type* type)

 {

     assert(is_Size(node));

     node->attr.typec.type = type;

 }


 static inline ir_type* get_Store_type_(const ir_node *node)

 {

     assert(is_Store(node));

     return node->attr.store.type;

 }


 static inline void set_Store_type_(ir_node *node, ir_type* type)

 {

     assert(is_Store(node));

     node->attr.store.type = type;

 }


 static inline ir_volatility get_Store_volatility_(const ir_node *node)

 {

     assert(is_Store(node));

     return node->attr.store.volatility;

 }


 static inline void set_Store_volatility_(ir_node *node, ir_volatility volatility)

 {

     assert(is_Store(node));

     node->attr.store.volatility = volatility;

 }


 static inline ir_align get_Store_unaligned_(const ir_node *node)

 {

     assert(is_Store(node));

     return node->attr.store.unaligned;

 }


 static inline void set_Store_unaligned_(ir_node *node, ir_align unaligned)

 {

     assert(is_Store(node));

     node->attr.store.unaligned = unaligned;

 }


 static inline unsigned get_Switch_n_outs_(const ir_node *node)

 {

     assert(is_Switch(node));

     return node->attr.switcha.n_outs;

 }


 static inline void set_Switch_n_outs_(ir_node *node, unsigned n_outs)

 {

     assert(is_Switch(node));

     node->attr.switcha.n_outs = n_outs;

 }


 static inline ir_switch_table* get_Switch_table_(const ir_node *node)

 {

     assert(is_Switch(node));

     return node->attr.switcha.table;

 }


 static inline void set_Switch_table_(ir_node *node, ir_switch_table* table)

 {

     assert(is_Switch(node));

     node->attr.switcha.table = table;

 }


 static inline ir_entity* get_entconst_entity_(const ir_node *node)

 {

     assert(is_entconst(node));

     return node->attr.entc.entity;

 }


 static inline void set_entconst_entity_(ir_node *node, ir_entity* entity)

 {

     assert(is_entconst(node));

     node->attr.entc.entity = entity;

 }


 static inline ir_type* get_typeconst_type_(const ir_node *node)

 {

     assert(is_typeconst(node));

     return node->attr.typec.type;

 }


 static inline void set_typeconst_type_(ir_node *node, ir_type* type)

 {

     assert(is_typeconst(node));

     node->attr.typec.type = type;

 }

 void ir_init_opcodes(void);

 void ir_finish_opcodes(void);


 #endif

op_And
ir_op * op_And
And opcode.
Definition: nodes.h:597

n_Shrs_right
second operand
Definition: nodes.h:3570

is_Alloc
int is_Alloc(const ir_node *node)
Test if node is a Alloc.
Definition: gen_irnode.c:2970

is_Cmp
int is_Cmp(const ir_node *node)
Test if node is a Cmp.
Definition: gen_irnode.c:3060

op_End
ir_op * op_End
End opcode.
Definition: nodes.h:1763

is_Free
int is_Free(const ir_node *node)
Test if node is a Free.
Definition: gen_irnode.c:3195

op_Call
ir_op * op_Call
Call opcode.
Definition: nodes.h:1029

op_Not
ir_op * op_Not
Not opcode.
Definition: nodes.h:2782

n_Sub_left
first operand
Definition: nodes.h:3880

op_Free
ir_op * op_Free
Free opcode.
Definition: nodes.h:1913

n_Mux_false
selected if sel input is false
Definition: nodes.h:2604

n_Conv_op
operand
Definition: nodes.h:1359

is_Div
int is_Div(const ir_node *node)
Test if node is a Div.
Definition: gen_irnode.c:3155

n_Bitcast_op
operand
Definition: nodes.h:688

op_Deleted
ir_op * op_Deleted
Deleted opcode.
Definition: nodes.h:1534

is_Proj
int is_Proj(const ir_node *node)
Test if node is a Proj.
Definition: gen_irnode.c:3360

op_Anchor
ir_op * op_Anchor
Anchor opcode.
Definition: nodes.h:523

is_Add
int is_Add(const ir_node *node)
Test if node is a Add.
Definition: gen_irnode.c:2935

op_Mod
ir_op * op_Mod
Mod opcode.
Definition: nodes.h:2435

n_Mul_right
second operand
Definition: nodes.h:2454

n_Pin_op
value which is pinned
Definition: nodes.h:3014

n_Return_max
Definition: nodes.h:3242

n_Mux_sel
value making the output selection
Definition: nodes.h:2603

n_Proj_pred
the tuple value from which a part is extracted
Definition: nodes.h:3079

is_Load
int is_Load(const ir_node *node)
Test if node is a Load.
Definition: gen_irnode.c:3215

n_CopyB_src
source address
Definition: nodes.h:1430

get_Call_n_params
int get_Call_n_params(ir_node const *node)
Get the number of Call params.
Definition: gen_irnode.c:667

n_IJmp_target
target address of the jump
Definition: nodes.h:1933

op_NoMem
ir_op * op_NoMem
NoMem opcode.
Definition: nodes.h:2717

is_Size
int is_Size(const ir_node *node)
Test if node is a Size.
Definition: gen_irnode.c:3415

op_Conv
ir_op * op_Conv
Conv opcode.
Definition: nodes.h:1410

op_Offset
ir_op * op_Offset
Offset opcode.
Definition: nodes.h:2844

n_Member_ptr
pointer to object to select from
Definition: nodes.h:2204

is_CopyB
int is_CopyB(const ir_node *node)
Test if node is a CopyB.
Definition: gen_irnode.c:3125

op_Builtin
ir_op * op_Builtin
Builtin opcode.
Definition: nodes.h:916

op_Raise
ir_op * op_Raise
Raise opcode.
Definition: nodes.h:3222

op_Start
ir_op * op_Start
Start opcode.
Definition: nodes.h:3746

op_Id
ir_op * op_Id
Id opcode.
Definition: nodes.h:2017

n_Or_right
second operand
Definition: nodes.h:2863

op_Cmp
ir_op * op_Cmp
Cmp opcode.
Definition: nodes.h:1113

get_Block_n_cfgpreds
int get_Block_n_cfgpreds(ir_node const *node)
Get the number of Block cfgpreds.
Definition: gen_irnode.c:506

is_End
int is_End(const ir_node *node)
Test if node is a End.
Definition: gen_irnode.c:3185

op_Align
ir_op * op_Align
Align opcode.
Definition: nodes.h:357

op_Shrs
ir_op * op_Shrs
Shrs opcode.
Definition: nodes.h:3625

get_Sync_n_preds
int get_Sync_n_preds(ir_node const *node)
Get the number of Sync preds.
Definition: gen_irnode.c:2783

n_Anchor_end
end node of this ir_graph
Definition: nodes.h:474

op_Unknown
ir_op * op_Unknown
Unknown opcode.
Definition: nodes.h:4229

is_Phi
int is_Phi(const ir_node *node)
Test if node is a Phi.
Definition: gen_irnode.c:3340

n_Store_ptr
address to store to
Definition: nodes.h:3765

is_entconst
int is_entconst(const ir_node *node)
Test if node is a entconst.
Definition: gen_irnode.c:3520

n_And_left
first operand
Definition: nodes.h:541

op_Shr
ir_op * op_Shr
Shr opcode.
Definition: nodes.h:3546

n_And_right
second operand
Definition: nodes.h:542

get_Phi_n_preds
int get_Phi_n_preds(ir_node const *node)
Get the number of Phi preds.
Definition: gen_irnode.c:2019

is_Cond
int is_Cond(const ir_node *node)
Test if node is a Cond.
Definition: gen_irnode.c:3075

op_Address
ir_op * op_Address
Address opcode.
Definition: nodes.h:295

n_ASM_mem
memory dependency
Definition: nodes.h:114

is_Align
int is_Align(const ir_node *node)
Test if node is a Align.
Definition: gen_irnode.c:2955

n_Anchor_no_mem
the only NoMem node of this ir_graph
Definition: nodes.h:479

n_Free_ptr
pointer to the object to free
Definition: nodes.h:1858

is_Raise
int is_Raise(const ir_node *node)
Test if node is a Raise.
Definition: gen_irnode.c:3375

is_Store
int is_Store(const ir_node *node)
Test if node is a Store.
Definition: gen_irnode.c:3435

n_Mod_right
second operand
Definition: nodes.h:2352

op_Proj
ir_op * op_Proj
Proj opcode.
Definition: nodes.h:3137

n_Call_max
Definition: nodes.h:939

n_Div_left
first operand
Definition: nodes.h:1553

op_Block
ir_op * op_Block
Block opcode.
Definition: nodes.h:809

is_Pin
int is_Pin(const ir_node *node)
Test if node is a Pin.
Definition: gen_irnode.c:3355

op_Eor
ir_op * op_Eor
Eor opcode.
Definition: nodes.h:1839

op_Shl
ir_op * op_Shl
Shl opcode.
Definition: nodes.h:3468

op_Mul
ir_op * op_Mul
Mul opcode.
Definition: nodes.h:2509

n_CopyB_mem
memory dependency
Definition: nodes.h:1428

n_Confirm_bound
value to compare against
Definition: nodes.h:1219

ir_node
struct ir_node ir_node
Procedure Graph Node.
Definition: firm_types.h:53

op_Const
ir_op * op_Const
Const opcode.
Definition: nodes.h:1341

is_Or
int is_Or(const ir_node *node)
Test if node is a Or.
Definition: gen_irnode.c:3335

n_ASM_max
Definition: nodes.h:115

n_Minus_op
operand
Definition: nodes.h:2278

n_Free_mem
memory dependency
Definition: nodes.h:1857

op_Div
ir_op * op_Div
Div opcode.
Definition: nodes.h:1642

is_Not
int is_Not(const ir_node *node)
Test if node is a Not.
Definition: gen_irnode.c:3315

op_Sync
ir_op * op_Sync
Sync opcode.
Definition: nodes.h:4099

op_Add
ir_op * op_Add
Add opcode.
Definition: nodes.h:236

is_Sub
int is_Sub(const ir_node *node)
Test if node is a Sub.
Definition: gen_irnode.c:3470

ir_type
struct ir_type ir_type
Type.
Definition: firm_types.h:71

is_Shl
int is_Shl(const ir_node *node)
Test if node is a Shl.
Definition: gen_irnode.c:3400

n_CopyB_dst
destination address
Definition: nodes.h:1429

op_Bad
ir_op * op_Bad
Bad opcode.
Definition: nodes.h:669

n_Cmp_left
first operand
Definition: nodes.h:1048

is_Sync
int is_Sync(const ir_node *node)
Test if node is a Sync.
Definition: gen_irnode.c:3500

n_Anchor_start
start node of this ir_graph
Definition: nodes.h:475

n_Cmp_right
second operand
Definition: nodes.h:1049

n_Mulh_left
first operand
Definition: nodes.h:2528

n_Sub_right
second operand
Definition: nodes.h:3881

is_Shr
int is_Shr(const ir_node *node)
Test if node is a Shr.
Definition: gen_irnode.c:3405

is_Mul
int is_Mul(const ir_node *node)
Test if node is a Mul.
Definition: gen_irnode.c:3295

n_Id_pred
the value which is returned unchanged
Definition: nodes.h:2001

is_Confirm
int is_Confirm(const ir_node *node)
Test if node is a Confirm.
Definition: gen_irnode.c:3090

op_CopyB
ir_op * op_CopyB
CopyB opcode.
Definition: nodes.h:1511

ir_mode
struct ir_mode ir_mode
SSA Value mode.
Definition: firm_types.h:59

is_And
int is_And(const ir_node *node)
Test if node is a And.
Definition: gen_irnode.c:2990

get_Tuple_n_preds
int get_Tuple_n_preds(ir_node const *node)
Get the number of Tuple preds.
Definition: gen_irnode.c:2839

op_Mux
ir_op * op_Mux
Mux opcode.
Definition: nodes.h:2668

is_typeconst
int is_typeconst(const ir_node *node)
Test if node is a typeconst.
Definition: gen_irnode.c:3535

op_Confirm
ir_op * op_Confirm
Confirm opcode.
Definition: nodes.h:1283

n_Alloc_mem
memory dependency
Definition: nodes.h:375

get_irn_n
ir_node * get_irn_n(const ir_node *node, int n)
Returns the n-th predecessor of a node.

is_Call
int is_Call(const ir_node *node)
Test if node is a Call.
Definition: gen_irnode.c:3045

ir_asm_constraint
A input/output constraint attribute.
Definition: firm_types.h:270

op_Pin
ir_op * op_Pin
Pin opcode.
Definition: nodes.h:3061

is_Shrs
int is_Shrs(const ir_node *node)
Test if node is a Shrs.
Definition: gen_irnode.c:3410

op_Member
ir_op * op_Member
Member opcode.
Definition: nodes.h:2260

n_Switch_selector
input selector
Definition: nodes.h:3957

ir_switch_table
struct ir_switch_table ir_switch_table
A switch table mapping integer numbers to proj-numbers of a Switch-node.
Definition: firm_types.h:105

n_Store_value
value to store
Definition: nodes.h:3766

is_Offset
int is_Offset(const ir_node *node)
Test if node is a Offset.
Definition: gen_irnode.c:3320

op_Mulh
ir_op * op_Mulh
Mulh opcode.
Definition: nodes.h:2584

n_Or_left
first operand
Definition: nodes.h:2862

is_Block
int is_Block(const ir_node *node)
Test if node is a Block.
Definition: gen_irnode.c:3005

op_IJmp
ir_op * op_IJmp
IJmp opcode.
Definition: nodes.h:1980

op_Switch
ir_op * op_Switch
Switch opcode.
Definition: nodes.h:4030

n_Builtin_mem
memory dependency
Definition: nodes.h:827

op_Size
ir_op * op_Size
Size opcode.
Definition: nodes.h:3687

ir_entity
struct ir_entity ir_entity
Entity.
Definition: firm_types.h:83

op_Tuple
ir_op * op_Tuple
Tuple opcode.
Definition: nodes.h:4171

is_Const
int is_Const(const ir_node *node)
Test if node is a Const.
Definition: gen_irnode.c:3105

op_Sub
ir_op * op_Sub
Sub opcode.
Definition: nodes.h:3936

is_Mux
int is_Mux(const ir_node *node)
Test if node is a Mux.
Definition: gen_irnode.c:3305

n_Mod_left
first operand
Definition: nodes.h:2351

get_Return_n_ress
int get_Return_n_ress(ir_node const *node)
Get the number of Return ress.
Definition: gen_irnode.c:2242

n_Anchor_args
argument proj of the start node
Definition: nodes.h:478

n_Shr_left
first operand
Definition: nodes.h:3490

ident
const char ident
Identifier.
Definition: firm_types.h:50

op_Sel
ir_op * op_Sel
Sel opcode.
Definition: nodes.h:3390

is_Eor
int is_Eor(const ir_node *node)
Test if node is a Eor.
Definition: gen_irnode.c:3190

n_Raise_exo_ptr
pointer to exception object to be thrown
Definition: nodes.h:3158

n_Sel_ptr
pointer to array to select from
Definition: nodes.h:3325

n_Load_mem
memory dependency
Definition: nodes.h:2084

n_Div_mem
memory dependency
Definition: nodes.h:1552

n_Shl_right
second operand
Definition: nodes.h:3413

op_Alloc
ir_op * op_Alloc
Alloc opcode.
Definition: nodes.h:449

get_irn_op
ir_op * get_irn_op(const ir_node *node)
Returns the opcode struct of the node.

n_Call_mem
memory dependency
Definition: nodes.h:937

is_Return
int is_Return(const ir_node *node)
Test if node is a Return.
Definition: gen_irnode.c:3380

op_Minus
ir_op * op_Minus
Minus opcode.
Definition: nodes.h:2325

n_Anchor_end_block
block the end node belongs to
Definition: nodes.h:472

n_Sel_index
index to select
Definition: nodes.h:3326

n_Return_mem
memory dependency
Definition: nodes.h:3241

n_Add_right
second operand
Definition: nodes.h:181

n_Mul_left
first operand
Definition: nodes.h:2453

is_Conv
int is_Conv(const ir_node *node)
Test if node is a Conv.
Definition: gen_irnode.c:3120

is_Switch
int is_Switch(const ir_node *node)
Test if node is a Switch.
Definition: gen_irnode.c:3475

n_Mux_true
selected if sel input is true
Definition: nodes.h:2605

op_Dummy
ir_op * op_Dummy
Dummy opcode.
Definition: nodes.h:1697

n_Confirm_value
value to express a constraint for
Definition: nodes.h:1218

n_Mod_mem
memory dependency
Definition: nodes.h:2350

get_ASM_n_inputs
int get_ASM_n_inputs(ir_node const *node)
Get the number of ASM inputs.
Definition: gen_irnode.c:28

n_Mulh_right
second operand
Definition: nodes.h:2529

set_irn_n
void set_irn_n(ir_node *node, int n, ir_node *in)
Replaces the n-th predecessor of a node with a new one.

is_Member
int is_Member(const ir_node *node)
Test if node is a Member.
Definition: gen_irnode.c:3260

op_Store
ir_op * op_Store
Store opcode.
Definition: nodes.h:3862

is_Mulh
int is_Mulh(const ir_node *node)
Test if node is a Mulh.
Definition: gen_irnode.c:3300

ir_builtin_kind
ir_builtin_kind
Supported libFirm builtins.
Definition: firm_types.h:280

n_Raise_mem
memory dependency
Definition: nodes.h:3157

n_Store_mem
memory dependency
Definition: nodes.h:3764

ir_tarval
struct ir_tarval ir_tarval
Target Machine Value.
Definition: firm_types.h:68

n_Shr_right
second operand
Definition: nodes.h:3491

is_Tuple
int is_Tuple(const ir_node *node)
Test if node is a Tuple.
Definition: gen_irnode.c:3505

op_Bitcast
ir_op * op_Bitcast
Bitcast opcode.
Definition: nodes.h:739

op_Cond
ir_op * op_Cond
Cond opcode.
Definition: nodes.h:1192

op_Return
ir_op * op_Return
Return opcode.
Definition: nodes.h:3304

n_Anchor_initial_mem
initial memory of this ir_graph
Definition: nodes.h:477

n_Anchor_frame
frame of this ir_graph
Definition: nodes.h:476

is_Id
int is_Id(const ir_node *node)
Test if node is a Id.
Definition: gen_irnode.c:3205

is_Address
int is_Address(const ir_node *node)
Test if node is a Address.
Definition: gen_irnode.c:2940

ir_relation
ir_relation
Relations for comparing numbers.
Definition: firm_types.h:162

n_Cond_selector
condition parameter
Definition: nodes.h:1131

cond_jmp_predicate
cond_jmp_predicate
A type to express conditional jump predictions.
Definition: firm_types.h:212

n_Alloc_size
size of the block in bytes
Definition: nodes.h:376

is_ASM
int is_ASM(const ir_node *node)
Test if node is a ASM.
Definition: gen_irnode.c:2900

op_Jmp
ir_op * op_Jmp
Jmp opcode.
Definition: nodes.h:2066

is_Bitcast
int is_Bitcast(const ir_node *node)
Test if node is a Bitcast.
Definition: gen_irnode.c:3000

n_Eor_left
first operand
Definition: nodes.h:1783

n_Eor_right
second operand
Definition: nodes.h:1784

n_Div_right
second operand
Definition: nodes.h:1554

get_End_n_keepalives
int get_End_n_keepalives(ir_node const *node)
Get the number of End keepalives.
Definition: gen_irnode.c:1155

is_Sel
int is_Sel(const ir_node *node)
Test if node is a Sel.
Definition: gen_irnode.c:3385

n_Call_ptr
pointer to called code
Definition: nodes.h:938

n_Add_left
first operand
Definition: nodes.h:180

is_IJmp
int is_IJmp(const ir_node *node)
Test if node is a IJmp.
Definition: gen_irnode.c:3200

is_Mod
int is_Mod(const ir_node *node)
Test if node is a Mod.
Definition: gen_irnode.c:3280

op_ASM
ir_op * op_ASM
ASM opcode.
Definition: nodes.h:162

op_Load
ir_op * op_Load
Load opcode.
Definition: nodes.h:2183

get_Builtin_n_params
int get_Builtin_n_params(ir_node const *node)
Get the number of Builtin params.
Definition: gen_irnode.c:581

n_Shrs_left
first operand
Definition: nodes.h:3569

n_Load_ptr
address to load from
Definition: nodes.h:2085

n_Shl_left
first operand
Definition: nodes.h:3412

get_irn_arity
int get_irn_arity(const ir_node *node)
Returns the number of predecessors without the block predecessor.

n_Not_op
operand
Definition: nodes.h:2735

op_Or
ir_op * op_Or
Or opcode.
Definition: nodes.h:2918

is_Minus
int is_Minus(const ir_node *node)
Test if node is a Minus.
Definition: gen_irnode.c:3275

is_Builtin
int is_Builtin(const ir_node *node)
Test if node is a Builtin.
Definition: gen_irnode.c:3020

n_Builtin_max
Definition: nodes.h:828

n_Anchor_start_block
block the start node belongs to
Definition: nodes.h:473

is_Anchor
int is_Anchor(const ir_node *node)
Test if node is a Anchor.
Definition: gen_irnode.c:2985

op_Phi
ir_op * op_Phi
Phi opcode.
Definition: nodes.h:2994