-int
-(is_unop)(const ir_node *node) {
- return _is_unop(node);
-}
-
-ir_node *
-get_unop_op(const ir_node *node) {
- if (node->op->opar == oparity_unary)
- return get_irn_n(node, node->op->op_index);
-
- assert(node->op->opar == oparity_unary);
- return NULL;
-}
-
-void
-set_unop_op(ir_node *node, ir_node *op) {
- if (node->op->opar == oparity_unary)
- set_irn_n(node, node->op->op_index, op);
-
- assert(node->op->opar == oparity_unary);
-}
-
-int
-(is_binop)(const ir_node *node) {
- return _is_binop(node);
-}
-
-ir_node *
-get_binop_left(const ir_node *node) {
- assert(node->op->opar == oparity_binary);
- return get_irn_n(node, node->op->op_index);
-}
-
-void
-set_binop_left(ir_node *node, ir_node *left) {
- assert(node->op->opar == oparity_binary);
- set_irn_n(node, node->op->op_index, left);
-}
-
-ir_node *
-get_binop_right(const ir_node *node) {
- assert(node->op->opar == oparity_binary);
- return get_irn_n(node, node->op->op_index + 1);
-}
-
-void
-set_binop_right(ir_node *node, ir_node *right) {
- assert(node->op->opar == oparity_binary);
- set_irn_n(node, node->op->op_index + 1, right);
-}
-
-int is_Phi(const ir_node *n) {
- ir_op *op;
-
- assert(n);
- op = get_irn_op(n);
-
- if (op == op_Filter) return get_interprocedural_view();
-
- if (op == op_Phi)
- return ((get_irg_phase_state(get_irn_irg(n)) != phase_building) ||
- (get_irn_arity(n) > 0));
-
- return 0;
-}
-
-int is_Phi0(const ir_node *n) {
- assert(n);
-
- return ((get_irn_op(n) == op_Phi) &&
- (get_irn_arity(n) == 0) &&
- (get_irg_phase_state(get_irn_irg(n)) == phase_building));
-}
-
-ir_node **
-get_Phi_preds_arr(ir_node *node) {
- assert(node->op == op_Phi);
- return (ir_node **)&(get_irn_in(node)[1]);
-}
-
-int
-get_Phi_n_preds(const ir_node *node) {
- assert(is_Phi(node) || is_Phi0(node));
- return (get_irn_arity(node));
-}
-
-/*
-void set_Phi_n_preds(ir_node *node, int n_preds) {
- assert(node->op == op_Phi);
-}
-*/
-
-ir_node *
-get_Phi_pred(const ir_node *node, int pos) {
- assert(is_Phi(node) || is_Phi0(node));
- return get_irn_n(node, pos);
-}
-
-void
-set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
- assert(is_Phi(node) || is_Phi0(node));
- set_irn_n(node, pos, pred);
-}
-
-
-int is_memop(ir_node *node) {
- return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
-}
-
-ir_node *get_memop_mem(ir_node *node) {
- assert(is_memop(node));
- return get_irn_n(node, 0);
-}
-
-void set_memop_mem(ir_node *node, ir_node *mem) {
- assert(is_memop(node));
- set_irn_n(node, 0, mem);
-}
-
-ir_node *get_memop_ptr(ir_node *node) {
- assert(is_memop(node));
- return get_irn_n(node, 1);
-}
-
-void set_memop_ptr(ir_node *node, ir_node *ptr) {
- assert(is_memop(node));
- set_irn_n(node, 1, ptr);
-}
-
-ir_node *
-get_Load_mem(ir_node *node) {
- assert(node->op == op_Load);
- return get_irn_n(node, 0);
-}
-
-void
-set_Load_mem(ir_node *node, ir_node *mem) {
- assert(node->op == op_Load);
- set_irn_n(node, 0, mem);
-}
-
-ir_node *
-get_Load_ptr(ir_node *node) {
- assert(node->op == op_Load);
- return get_irn_n(node, 1);
-}
-
-void
-set_Load_ptr(ir_node *node, ir_node *ptr) {
- assert(node->op == op_Load);
- set_irn_n(node, 1, ptr);
-}
-
-ir_mode *
-get_Load_mode(ir_node *node) {
- assert(node->op == op_Load);
- return node->attr.load.load_mode;
-}
-
-void
-set_Load_mode(ir_node *node, ir_mode *mode) {
- assert(node->op == op_Load);
- node->attr.load.load_mode = mode;
-}
-
-ir_volatility
-get_Load_volatility(ir_node *node) {
- assert(node->op == op_Load);
- return node->attr.load.volatility;
-}
-
-void
-set_Load_volatility(ir_node *node, ir_volatility volatility) {
- assert(node->op == op_Load);
- node->attr.load.volatility = volatility;
-}
-
-
-ir_node *
-get_Store_mem(ir_node *node) {
- assert(node->op == op_Store);
- return get_irn_n(node, 0);
-}
-
-void
-set_Store_mem(ir_node *node, ir_node *mem) {
- assert(node->op == op_Store);
- set_irn_n(node, 0, mem);
-}
-
-ir_node *
-get_Store_ptr(ir_node *node) {
- assert(node->op == op_Store);
- return get_irn_n(node, 1);
-}
-
-void
-set_Store_ptr(ir_node *node, ir_node *ptr) {
- assert(node->op == op_Store);
- set_irn_n(node, 1, ptr);
-}
-
-ir_node *
-get_Store_value(ir_node *node) {
- assert(node->op == op_Store);
- return get_irn_n(node, 2);
-}
-
-void
-set_Store_value(ir_node *node, ir_node *value) {
- assert(node->op == op_Store);
- set_irn_n(node, 2, value);
-}
-
-ir_volatility
-get_Store_volatility(ir_node *node) {
- assert(node->op == op_Store);
- return node->attr.store.volatility;
-}
-
-void
-set_Store_volatility(ir_node *node, ir_volatility volatility) {
- assert(node->op == op_Store);
- node->attr.store.volatility = volatility;
-}
-
-
-ir_node *
-get_Alloc_mem(ir_node *node) {
- assert(node->op == op_Alloc);
- return get_irn_n(node, 0);
-}
-
-void
-set_Alloc_mem(ir_node *node, ir_node *mem) {
- assert(node->op == op_Alloc);
- set_irn_n(node, 0, mem);
-}
-
-ir_node *
-get_Alloc_size(ir_node *node) {
- assert(node->op == op_Alloc);
- return get_irn_n(node, 1);
-}
-
-void
-set_Alloc_size(ir_node *node, ir_node *size) {
- assert(node->op == op_Alloc);
- set_irn_n(node, 1, size);
-}
-
-ir_type *
-get_Alloc_type(ir_node *node) {
- assert(node->op == op_Alloc);
- return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
-}
-
-void
-set_Alloc_type(ir_node *node, ir_type *tp) {
- assert(node->op == op_Alloc);
- node->attr.alloc.type = tp;
-}
-
-where_alloc
-get_Alloc_where(ir_node *node) {
- assert(node->op == op_Alloc);
- return node->attr.alloc.where;
-}
-
-void
-set_Alloc_where(ir_node *node, where_alloc where) {
- assert(node->op == op_Alloc);
- node->attr.alloc.where = where;
-}
-
-
-ir_node *
-get_Free_mem(ir_node *node) {
- assert(node->op == op_Free);
- return get_irn_n(node, 0);
-}
-
-void
-set_Free_mem(ir_node *node, ir_node *mem) {
- assert(node->op == op_Free);
- set_irn_n(node, 0, mem);
-}
-
-ir_node *
-get_Free_ptr(ir_node *node) {
- assert(node->op == op_Free);
- return get_irn_n(node, 1);
-}
-
-void
-set_Free_ptr(ir_node *node, ir_node *ptr) {
- assert(node->op == op_Free);
- set_irn_n(node, 1, ptr);
-}
-
-ir_node *
-get_Free_size(ir_node *node) {
- assert(node->op == op_Free);
- return get_irn_n(node, 2);
-}
-
-void
-set_Free_size(ir_node *node, ir_node *size) {
- assert(node->op == op_Free);
- set_irn_n(node, 2, size);
-}
-
-ir_type *
-get_Free_type(ir_node *node) {
- assert(node->op == op_Free);
- return node->attr.free.type = skip_tid(node->attr.free.type);
-}
-
-void
-set_Free_type(ir_node *node, ir_type *tp) {
- assert(node->op == op_Free);
- node->attr.free.type = tp;
-}
-
-where_alloc
-get_Free_where(ir_node *node) {
- assert(node->op == op_Free);
- return node->attr.free.where;
-}
-
-void
-set_Free_where(ir_node *node, where_alloc where) {
- assert(node->op == op_Free);
- node->attr.free.where = where;
-}
-
-ir_node **get_Sync_preds_arr(ir_node *node) {
- assert(node->op == op_Sync);
- return (ir_node **)&(get_irn_in(node)[1]);
-}
-
-int get_Sync_n_preds(ir_node *node) {
- assert(node->op == op_Sync);
- return (get_irn_arity(node));
-}
-
-/*
-void set_Sync_n_preds(ir_node *node, int n_preds) {
- assert(node->op == op_Sync);
-}
-*/
-
-ir_node *get_Sync_pred(ir_node *node, int pos) {
- assert(node->op == op_Sync);
- return get_irn_n(node, pos);
-}
-
-void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
- assert(node->op == op_Sync);
- set_irn_n(node, pos, pred);
-}
-
-/* Add a new Sync predecessor */
-void add_Sync_pred(ir_node *node, ir_node *pred) {
- assert(node->op == op_Sync);
- add_irn_n(node, pred);
-}
-
-/* Returns the source language type of a Proj node. */
-ir_type *get_Proj_type(ir_node *n) {
- ir_type *tp = firm_unknown_type;
- 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_VProj_proj(const ir_node *node)
-{
- return node->attr.proj;
-}
-
-void set_VProj_proj(ir_node *node, long value)
-{
- node->attr.proj = value;
-}
-
-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(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 (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(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(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(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(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) {
- node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
- node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
- memset(node->attr.filter.backedge, 0, sizeof(int) * 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(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(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(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;
- }