- ir_node *pred = get_Proj_pred(n);
-
- switch (get_irn_opcode(pred)) {
- case iro_Proj: {
- ir_node *pred_pred;
- /* Deal with Start / Call here: we need to know the Proj Nr. */
- assert(get_irn_mode(pred) == mode_T);
- pred_pred = get_Proj_pred(pred);
- if (get_irn_op(pred_pred) == op_Start) {
- ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
- tp = get_method_param_type(mtp, get_Proj_proj(n));
- } else if (get_irn_op(pred_pred) == op_Call) {
- ir_type *mtp = get_Call_type(pred_pred);
- tp = get_method_res_type(mtp, get_Proj_proj(n));
- }
- } break;
- case iro_Start: break;
- case iro_Call: break;
- case iro_Load: {
- ir_node *a = get_Load_ptr(pred);
- if (is_Sel(a))
- tp = get_entity_type(get_Sel_entity(a));
- } break;
- default:
- break;
- }
- return tp;
-}
-
-ir_node *
-get_Proj_pred(const ir_node *node) {
- assert(is_Proj(node));
- return get_irn_n(node, 0);
-}
-
-void
-set_Proj_pred(ir_node *node, ir_node *pred) {
- assert(is_Proj(node));
- set_irn_n(node, 0, pred);
-}
-
-long
-get_Proj_proj(const ir_node *node) {
- assert(is_Proj(node));
- if (get_irn_opcode(node) == iro_Proj) {
- return node->attr.proj;
- } else {
- assert(get_irn_opcode(node) == iro_Filter);
- return node->attr.filter.proj;
- }
-}
-
-void
-set_Proj_proj(ir_node *node, long proj) {
- assert(node->op == op_Proj);
- node->attr.proj = proj;
-}
-
-ir_node **
-get_Tuple_preds_arr(ir_node *node) {
- assert(node->op == op_Tuple);
- return (ir_node **)&(get_irn_in(node)[1]);
-}
-
-int
-get_Tuple_n_preds(const ir_node *node) {
- assert(node->op == op_Tuple);
- return (get_irn_arity(node));
-}
-
-/*
-void
-set_Tuple_n_preds(ir_node *node, int n_preds) {
- assert(node->op == op_Tuple);
-}
-*/
-
-ir_node *
-get_Tuple_pred(const ir_node *node, int pos) {
- assert(node->op == op_Tuple);
- return get_irn_n(node, pos);
-}
-
-void
-set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
- assert(node->op == op_Tuple);
- set_irn_n(node, pos, pred);
-}
-
-ir_node *
-get_Id_pred(const ir_node *node) {
- assert(node->op == op_Id);
- return get_irn_n(node, 0);
-}
-
-void
-set_Id_pred(ir_node *node, ir_node *pred) {
- assert(node->op == op_Id);
- set_irn_n(node, 0, pred);
-}
-
-ir_node *get_Confirm_value(const ir_node *node) {
- assert(node->op == op_Confirm);
- return get_irn_n(node, 0);
-}
-
-void set_Confirm_value(ir_node *node, ir_node *value) {
- assert(node->op == op_Confirm);
- set_irn_n(node, 0, value);
-}
-
-ir_node *get_Confirm_bound(const ir_node *node) {
- assert(node->op == op_Confirm);
- return get_irn_n(node, 1);
-}
-
-void set_Confirm_bound(ir_node *node, ir_node *bound) {
- assert(node->op == op_Confirm);
- set_irn_n(node, 0, bound);
-}
-
-pn_Cmp get_Confirm_cmp(const ir_node *node) {
- assert(node->op == op_Confirm);
- return node->attr.confirm.cmp;
-}
-
-void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
- assert(node->op == op_Confirm);
- node->attr.confirm.cmp = cmp;
-}
-
-ir_node *
-get_Filter_pred(ir_node *node) {
- assert(node->op == op_Filter);
- return node->in[1];
-}
-
-void
-set_Filter_pred(ir_node *node, ir_node *pred) {
- assert(node->op == op_Filter);
- node->in[1] = pred;
-}
-
-long
-get_Filter_proj(ir_node *node) {
- assert(node->op == op_Filter);
- return node->attr.filter.proj;
-}
-
-void
-set_Filter_proj(ir_node *node, long proj) {
- assert(node->op == op_Filter);
- node->attr.filter.proj = proj;
-}
-
-/* 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);
-}
-
-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(const 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(const 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(const 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(const 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);
-}