+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);
+}
+
+void
+set_Call_type(ir_node *node, ir_type *tp) {
+ assert(node->op == op_Call);
+ assert((get_unknown_type() == tp) || is_Method_type(tp));
+ node->attr.call.cld_tp = tp;
+}
+
+int Call_has_callees(ir_node *node) {
+ assert(node && node->op == op_Call);
+ return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
+ (node->attr.call.callee_arr != NULL));
+}
+
+int get_Call_n_callees(ir_node * node) {
+ assert(node && node->op == op_Call && node->attr.call.callee_arr);
+ return ARR_LEN(node->attr.call.callee_arr);
+}
+
+ir_entity * get_Call_callee(ir_node * node, int pos) {
+ assert(pos >= 0 && pos < get_Call_n_callees(node));
+ return node->attr.call.callee_arr[pos];
+}
+
+void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
+ assert(node->op == op_Call);
+ if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
+ node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
+ }
+ memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
+}
+
+void remove_Call_callee_arr(ir_node * node) {
+ assert(node->op == op_Call);
+ node->attr.call.callee_arr = NULL;
+}
+
+ir_node * get_CallBegin_ptr(ir_node *node) {
+ assert(node->op == op_CallBegin);
+ return get_irn_n(node, 0);
+}
+
+void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
+ assert(node->op == op_CallBegin);
+ set_irn_n(node, 0, ptr);
+}
+
+ir_node * get_CallBegin_call(ir_node *node) {
+ assert(node->op == op_CallBegin);
+ return node->attr.callbegin.call;
+}
+
+void set_CallBegin_call(ir_node *node, ir_node *call) {
+ assert(node->op == op_CallBegin);
+ node->attr.callbegin.call = call;
+}
+
+
+#define BINOP(OP) \
+ir_node * get_##OP##_left(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, node->op->op_index); \
+} \
+void set_##OP##_left(ir_node *node, ir_node *left) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, node->op->op_index, left); \
+} \
+ir_node *get_##OP##_right(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, node->op->op_index + 1); \
+} \
+void set_##OP##_right(ir_node *node, ir_node *right) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, node->op->op_index + 1, right); \
+}
+
+#define UNOP(OP) \
+ir_node *get_##OP##_op(const ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, node->op->op_index); \
+} \
+void set_##OP##_op (ir_node *node, ir_node *op) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, node->op->op_index, op); \
+}
+
+#define BINOP_MEM(OP) \
+BINOP(OP) \
+ \
+ir_node * \
+get_##OP##_mem(ir_node *node) { \
+ assert(node->op == op_##OP); \
+ return get_irn_n(node, 0); \
+} \
+ \
+void \
+set_##OP##_mem(ir_node *node, ir_node *mem) { \
+ assert(node->op == op_##OP); \
+ set_irn_n(node, 0, mem); \
+}
+
+BINOP(Add)
+BINOP(Sub)
+UNOP(Minus)
+BINOP(Mul)
+BINOP_MEM(Quot)
+BINOP_MEM(DivMod)
+BINOP_MEM(Div)
+BINOP_MEM(Mod)
+UNOP(Abs)
+BINOP(And)
+BINOP(Or)
+BINOP(Eor)
+UNOP(Not)
+BINOP(Shl)
+BINOP(Shr)
+BINOP(Shrs)
+BINOP(Rot)
+BINOP(Cmp)
+UNOP(Conv)
+UNOP(Cast)
+
+int get_Conv_strict(ir_node *node) {
+ assert(node->op == op_Conv);
+ return node->attr.conv.strict;
+}
+
+void set_Conv_strict(ir_node *node, int strict_flag) {
+ assert(node->op == op_Conv);
+ node->attr.conv.strict = (char)strict_flag;
+}
+
+ir_type *
+get_Cast_type(ir_node *node) {
+ assert(node->op == op_Cast);
+ return node->attr.cast.totype;
+}
+
+void
+set_Cast_type(ir_node *node, ir_type *to_tp) {
+ assert(node->op == op_Cast);
+ node->attr.cast.totype = to_tp;
+}
+
+
+/* Checks for upcast.
+ *
+ * Returns true if the Cast node casts a class type to a super type.
+ */
+int is_Cast_upcast(ir_node *node) {
+ ir_type *totype = get_Cast_type(node);
+ ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
+ ir_graph *myirg = get_irn_irg(node);
+
+ assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
+ assert(fromtype);
+
+ while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
+ totype = get_pointer_points_to_type(totype);
+ fromtype = get_pointer_points_to_type(fromtype);
+ }