+ir_node *get_Psi_val(ir_node *node, int pos) {
+ int num_vals = get_Psi_n_conds(node);
+ assert(node->op == op_Psi);
+ assert(pos < num_vals);
+ return get_irn_n(node, 2 * pos + 1);
+}
+
+void set_Psi_val(ir_node *node, int pos, ir_node *val) {
+ int num_vals = get_Psi_n_conds(node);
+ assert(node->op == op_Psi);
+ assert(pos < num_vals);
+ set_irn_n(node, 2 * pos + 1, val);
+}
+
+ir_node *get_Psi_default(ir_node *node) {
+ int def_pos = get_irn_arity(node) - 1;
+ assert(node->op == op_Psi);
+ return get_irn_n(node, def_pos);
+}
+
+void set_Psi_default(ir_node *node, ir_node *val) {
+ int def_pos = get_irn_arity(node);
+ assert(node->op == op_Psi);
+ set_irn_n(node, def_pos, val);
+}
+
+int (get_Psi_n_conds)(ir_node *node) {
+ return _get_Psi_n_conds(node);
+}
+
+/* CopyB support */
+ir_node *get_CopyB_mem(ir_node *node) {
+ assert(node->op == op_CopyB);
+ return get_irn_n(node, 0);
+}
+
+void set_CopyB_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_CopyB);
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *get_CopyB_dst(ir_node *node) {
+ assert(node->op == op_CopyB);
+ return get_irn_n(node, 1);
+}
+
+void set_CopyB_dst(ir_node *node, ir_node *dst) {
+ assert(node->op == op_CopyB);
+ set_irn_n(node, 1, dst);
+}
+
+ir_node *get_CopyB_src (ir_node *node) {
+ assert(node->op == op_CopyB);
+ return get_irn_n(node, 2);
+}
+
+void set_CopyB_src(ir_node *node, ir_node *src) {
+ assert(node->op == op_CopyB);
+ set_irn_n(node, 2, src);
+}
+
+ir_type *get_CopyB_type(ir_node *node) {
+ assert(node->op == op_CopyB);
+ return node->attr.copyb.data_type;
+}
+
+void set_CopyB_type(ir_node *node, ir_type *data_type) {
+ assert(node->op == op_CopyB && data_type);
+ node->attr.copyb.data_type = data_type;
+}
+
+
+ir_type *
+get_InstOf_type(ir_node *node) {
+ assert(node->op = op_InstOf);
+ return node->attr.instof.type;
+}
+
+void
+set_InstOf_type(ir_node *node, ir_type *type) {
+ assert(node->op = op_InstOf);
+ node->attr.instof.type = type;
+}
+
+ir_node *
+get_InstOf_store(ir_node *node) {
+ assert(node->op = op_InstOf);
+ return get_irn_n(node, 0);
+}
+
+void
+set_InstOf_store(ir_node *node, ir_node *obj) {
+ assert(node->op = op_InstOf);
+ set_irn_n(node, 0, obj);
+}
+
+ir_node *
+get_InstOf_obj(ir_node *node) {
+ assert(node->op = op_InstOf);
+ return get_irn_n(node, 1);
+}
+
+void
+set_InstOf_obj(ir_node *node, ir_node *obj) {
+ assert(node->op = op_InstOf);
+ set_irn_n(node, 1, obj);
+}
+
+/* Returns the memory input of a Raise operation. */
+ir_node *
+get_Raise_mem(ir_node *node) {
+ assert(node->op == op_Raise);
+ return get_irn_n(node, 0);
+}
+
+void
+set_Raise_mem(ir_node *node, ir_node *mem) {
+ assert(node->op == op_Raise);
+ set_irn_n(node, 0, mem);
+}
+
+ir_node *
+get_Raise_exo_ptr(ir_node *node) {
+ assert(node->op == op_Raise);
+ return get_irn_n(node, 1);
+}
+
+void
+set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
+ assert(node->op == op_Raise);
+ set_irn_n(node, 1, exo_ptr);
+}
+
+/* Bound support */
+
+/* Returns the memory input of a Bound operation. */
+ir_node *get_Bound_mem(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 0);
+}
+
+void set_Bound_mem(ir_node *bound, ir_node *mem) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 0, mem);
+}
+
+/* Returns the index input of a Bound operation. */
+ir_node *get_Bound_index(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 1);
+}
+
+void set_Bound_index(ir_node *bound, ir_node *idx) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 1, idx);
+}
+
+/* Returns the lower bound input of a Bound operation. */
+ir_node *get_Bound_lower(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 2);
+}
+
+void set_Bound_lower(ir_node *bound, ir_node *lower) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 2, lower);
+}
+
+/* Returns the upper bound input of a Bound operation. */
+ir_node *get_Bound_upper(ir_node *bound) {
+ assert(bound->op == op_Bound);
+ return get_irn_n(bound, 3);
+}
+
+void set_Bound_upper(ir_node *bound, ir_node *upper) {
+ assert(bound->op == op_Bound);
+ set_irn_n(bound, 3, upper);
+}
+
+/* Return the operand of a Pin node. */
+ir_node *get_Pin_op(ir_node *pin) {
+ assert(pin->op == op_Pin);
+ return get_irn_n(pin, 0);
+}
+
+void set_Pin_op(ir_node *pin, ir_node *node) {
+ assert(pin->op == op_Pin);
+ set_irn_n(pin, 0, node);
+}
+
+
+/* returns the graph of a node */