+ir_node *
+get_Cond_selector(ir_node *node) {
+ assert(node->op == op_Cond);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Cond_selector(ir_node *node, ir_node *selector) {
+ assert(node->op == op_Cond);
+ set_irn_n(node, 0, selector);
+}
+
+cond_kind
+get_Cond_kind(ir_node *node) {
+ assert(node->op == op_Cond);
+ return node->attr.cond.kind;
+}
+
+void
+set_Cond_kind(ir_node *node, cond_kind kind) {
+ assert(node->op == op_Cond);
+ node->attr.cond.kind = kind;
+}
+
+long
+get_Cond_defaultProj(ir_node *node) {
+ assert(node->op == op_Cond);
+ return node->attr.cond.default_proj;
+}
+
+ir_node *
+get_Return_mem(ir_node *node) {
+ assert(node->op == op_Return);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Return_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Return);
+ set_irn_n(node, 0, mem);
+}
+
+int
+get_Return_n_ress(ir_node *node) {
+ assert(node->op == op_Return);
+ return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
+}
+
+ir_node **
+get_Return_res_arr (ir_node *node) {
+ assert((node->op == op_Return));
+ if (get_Return_n_ress(node) > 0)
+ return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
+ else
+ return NULL;
+}
+
+/*
+void
+set_Return_n_res(ir_node *node, int results) {
+ assert(node->op == op_Return);
+}
+*/
+
+ir_node *
+get_Return_res(ir_node *node, int pos) {
+ assert(node->op == op_Return);
+ assert(get_Return_n_ress(node) > pos);
+ return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
+}
+
+void
+set_Return_res(ir_node *node, int pos, ir_node *res){
+ assert(node->op == op_Return);
+ set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
+}
+
+tarval *(get_Const_tarval)(ir_node *node) {
+ return _get_Const_tarval(node);
+}
+
+void
+set_Const_tarval(ir_node *node, tarval *con) {
+ assert(node->op == op_Const);
+ node->attr.con.tv = con;
+}
+
+cnst_classify_t (classify_Const)(ir_node *node) {
+ return _classify_Const(node);
+}
+
+
+/* The source language type. Must be an atomic type. Mode of type must
+ be mode of node. For tarvals from entities type must be pointer to
+ entity type. */
+ir_type *
+get_Const_type(ir_node *node) {
+ assert(node->op == op_Const);
+ return node->attr.con.tp;
+}
+
+void
+set_Const_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_Const);
+ if (tp != firm_unknown_type) {
+ assert(is_atomic_type(tp));
+ assert(get_type_mode(tp) == get_irn_mode(node));
+ }
+ node->attr.con.tp = tp;
+}
+
+
+symconst_kind
+get_SymConst_kind(const ir_node *node) {
+ assert(node->op == op_SymConst);
+ return node->attr.symc.num;
+}
+
+void
+set_SymConst_kind(ir_node *node, symconst_kind num) {
+ assert(node->op == op_SymConst);
+ node->attr.symc.num = num;
+}
+
+ir_type *
+get_SymConst_type(ir_node *node) {
+ assert((node->op == op_SymConst) &&
+ (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
+ return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
+}
+
+void
+set_SymConst_type(ir_node *node, ir_type *tp) {
+ assert((node->op == op_SymConst) &&
+ (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
+ node->attr.symc.sym.type_p = tp;
+}
+
+ident *
+get_SymConst_name(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
+ return node->attr.symc.sym.ident_p;
+}
+
+void
+set_SymConst_name(ir_node *node, ident *name) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
+ node->attr.symc.sym.ident_p = name;
+}
+
+
+/* Only to access SymConst of kind symconst_addr_ent. Else assertion: */
+ir_entity *get_SymConst_entity(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
+ return node->attr.symc.sym.entity_p;
+}
+
+void set_SymConst_entity(ir_node *node, ir_entity *ent) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
+ node->attr.symc.sym.entity_p = ent;
+}
+
+ir_enum_const *get_SymConst_enum(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
+ return node->attr.symc.sym.enum_p;
+}
+
+void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
+ node->attr.symc.sym.enum_p = ec;
+}
+
+union symconst_symbol
+get_SymConst_symbol(const ir_node *node) {
+ assert(node->op == op_SymConst);
+ return node->attr.symc.sym;
+}
+
+void
+set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
+ assert(node->op == op_SymConst);
+ node->attr.symc.sym = sym;
+}
+
+ir_type *
+get_SymConst_value_type(ir_node *node) {
+ assert(node->op == op_SymConst);
+ if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
+ return node->attr.symc.tp;
+}
+
+void
+set_SymConst_value_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_SymConst);
+ node->attr.symc.tp = tp;
+}
+
+ir_node *
+get_Sel_mem(ir_node *node) {
+ assert(node->op == op_Sel);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Sel_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Sel);
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *
+get_Sel_ptr(ir_node *node) {
+ assert(node->op == op_Sel);
+ return get_irn_n(node, 1);
+}
+
+void
+set_Sel_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Sel);
+ set_irn_n(node, 1, ptr);
+}
+
+int
+get_Sel_n_indexs(ir_node *node) {
+ assert(node->op == op_Sel);
+ return (get_irn_arity(node) - SEL_INDEX_OFFSET);
+}
+
+ir_node **
+get_Sel_index_arr(ir_node *node) {
+ assert((node->op == op_Sel));
+ if (get_Sel_n_indexs(node) > 0)
+ return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
+ else
+ return NULL;
+}
+
+ir_node *
+get_Sel_index(ir_node *node, int pos) {
+ assert(node->op == op_Sel);
+ return get_irn_n(node, pos + SEL_INDEX_OFFSET);
+}
+
+void
+set_Sel_index(ir_node *node, int pos, ir_node *index) {
+ assert(node->op == op_Sel);
+ set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
+}
+
+ir_entity *
+get_Sel_entity(ir_node *node) {
+ assert(node->op == op_Sel);
+ return node->attr.sel.ent;
+}
+
+void
+set_Sel_entity(ir_node *node, ir_entity *ent) {
+ assert(node->op == op_Sel);
+ node->attr.sel.ent = ent;
+}
+
+
+/* For unary and binary arithmetic operations the access to the
+ operands can be factored out. Left is the first, right the
+ second arithmetic value as listed in tech report 0999-33.
+ unops are: Minus, Abs, Not, Conv, Cast
+ binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
+ Shr, Shrs, Rotate, Cmp */
+
+
+ir_node *
+get_Call_mem(ir_node *node) {
+ assert(node->op == op_Call);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Call_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Call);
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *
+get_Call_ptr(ir_node *node) {
+ assert(node->op == op_Call);
+ return get_irn_n(node, 1);
+}
+
+void
+set_Call_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_Call);
+ set_irn_n(node, 1, ptr);
+}
+
+ir_node **
+get_Call_param_arr(ir_node *node) {
+ assert(node->op == op_Call);
+ return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
+}
+
+int
+get_Call_n_params(ir_node *node) {
+ assert(node->op == op_Call);
+ return (get_irn_arity(node) - CALL_PARAM_OFFSET);
+}
+
+int
+get_Call_arity(ir_node *node) {
+ assert(node->op == op_Call);
+ return get_Call_n_params(node);
+}
+
+/* void
+set_Call_arity(ir_node *node, ir_node *arity) {
+ assert(node->op == op_Call);
+}
+*/
+
+ir_node *
+get_Call_param(ir_node *node, int pos) {
+ assert(node->op == op_Call);
+ return get_irn_n(node, pos + CALL_PARAM_OFFSET);
+}
+
+void
+set_Call_param(ir_node *node, int pos, ir_node *param) {
+ assert(node->op == op_Call);
+ set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
+}
+
+ir_type *
+get_Call_type(ir_node *node) {
+ assert(node->op == op_Call);
+ return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);