+/* Don't use get_irn_arity, get_irn_n in implementation as access
+ shall work independent of view!!! */
+void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node ** in) {
+ assert(node->op == op_Filter);
+ if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
+ ir_graph *irg = get_irn_irg(node);
+ node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
+ node->attr.filter.backedge = new_backedge_arr(irg->obst, arity);
+ node->attr.filter.in_cg[0] = node->in[0];
+ }
+ memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
+}
+
+void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
+ assert(node->op == op_Filter && node->attr.filter.in_cg &&
+ 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
+ node->attr.filter.in_cg[pos + 1] = pred;
+}
+
+int get_Filter_n_cg_preds(ir_node *node) {
+ assert(node->op == op_Filter && node->attr.filter.in_cg);
+ return (ARR_LEN(node->attr.filter.in_cg) - 1);
+}
+
+ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
+ int arity;
+ assert(node->op == op_Filter && node->attr.filter.in_cg &&
+ 0 <= pos);
+ arity = ARR_LEN(node->attr.filter.in_cg);
+ assert(pos < arity - 1);
+ return node->attr.filter.in_cg[pos + 1];
+}
+
+/* Mux support */
+ir_node *get_Mux_sel(const ir_node *node) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ return get_Psi_cond(node, 0);
+ }
+ assert(node->op == op_Mux);
+ return node->in[1];
+}
+
+void set_Mux_sel(ir_node *node, ir_node *sel) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ set_Psi_cond(node, 0, sel);
+ } else {
+ assert(node->op == op_Mux);
+ node->in[1] = sel;
+ }
+}
+
+ir_node *get_Mux_false(const ir_node *node) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ return get_Psi_default(node);
+ }
+ assert(node->op == op_Mux);
+ return node->in[2];
+}
+
+void set_Mux_false(ir_node *node, ir_node *ir_false) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ set_Psi_default(node, ir_false);
+ } else {
+ assert(node->op == op_Mux);
+ node->in[2] = ir_false;
+ }
+}
+
+ir_node *get_Mux_true(const ir_node *node) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ return get_Psi_val(node, 0);
+ }
+ assert(node->op == op_Mux);
+ return node->in[3];
+}
+
+void set_Mux_true(ir_node *node, ir_node *ir_true) {
+ if (node->op == op_Psi) {
+ assert(get_irn_arity(node) == 3);
+ set_Psi_val(node, 0, ir_true);
+ } else {
+ assert(node->op == op_Mux);
+ node->in[3] = ir_true;
+ }
+}
+
+/* Psi support */
+ir_node *get_Psi_cond(const ir_node *node, int pos) {
+ assert(node->op == op_Psi);
+ assert(pos < get_Psi_n_conds(node));
+ return get_irn_n(node, 2 * pos);
+}
+
+void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
+ assert(node->op == op_Psi);
+ assert(pos < get_Psi_n_conds(node));
+ set_irn_n(node, 2 * pos, cond);
+}
+
+ir_node *get_Psi_val(const ir_node *node, int pos) {
+ assert(node->op == op_Psi);
+ assert(pos < get_Psi_n_conds(node));
+ return get_irn_n(node, 2 * pos + 1);
+}
+
+void set_Psi_val(ir_node *node, int pos, ir_node *val) {
+ assert(node->op == op_Psi);
+ assert(pos < get_Psi_n_conds(node));
+ set_irn_n(node, 2 * pos + 1, val);
+}
+
+ir_node *get_Psi_default(const 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)(const ir_node *node) {
+ return _get_Psi_n_conds(node);
+}
+
+/* CopyB support */
+ir_node *get_CopyB_mem(const 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(const 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(const 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 = skip_tid(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 = skip_tid(node->attr.instof.type);