/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
/*
* Calculates the negated (Complement(R)) pnc condition.
*/
-int get_negated_pnc(int pnc, ir_mode *mode) {
+pn_Cmp get_negated_pnc(long pnc, ir_mode *mode) {
pnc ^= pn_Cmp_True;
/* do NOT add the Uo bit for non-floating point values */
if (! mode_is_float(mode))
pnc &= ~pn_Cmp_Uo;
- return pnc;
+ return (pn_Cmp) pnc;
}
/* Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
-int
-get_inversed_pnc(int pnc) {
- int code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
- int lesser = pnc & pn_Cmp_Lt;
- int greater = pnc & pn_Cmp_Gt;
+pn_Cmp get_inversed_pnc(long pnc) {
+ long code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
+ long lesser = pnc & pn_Cmp_Lt;
+ long greater = pnc & pn_Cmp_Gt;
code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0);
- return code;
+ return (pn_Cmp) code;
}
/**
set_irn_n(node, -1, block);
}
+/* this works for all except Block */
+ir_node *
+get_nodes_MacroBlock(const ir_node *node) {
+ assert(node->op != op_Block);
+ return get_Block_MacroBlock(get_irn_n(node, -1));
+}
+
/* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
* from Start. If so returns frame type, else Null. */
-ir_type *is_frame_pointer(ir_node *n) {
+ir_type *is_frame_pointer(const ir_node *n) {
if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
+ if (is_Start(start)) {
return get_irg_frame_type(get_irn_irg(start));
}
}
/* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
* from Start. If so returns global type, else Null. */
-ir_type *is_globals_pointer(ir_node *n) {
+ir_type *is_globals_pointer(const ir_node *n) {
if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
+ if (is_Start(start)) {
return get_glob_type();
}
}
/* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
* from Start. If so returns tls type, else Null. */
-ir_type *is_tls_pointer(ir_node *n) {
+ir_type *is_tls_pointer(const ir_node *n) {
if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
+ if (is_Start(start)) {
return get_tls_type();
}
}
/* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
* from Start. If so returns 1, else 0. */
-int is_value_arg_pointer(ir_node *n) {
- if ((get_irn_op(n) == op_Proj) &&
+int is_value_arg_pointer(const ir_node *n) {
+ if (is_Proj(n) &&
(get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
- (get_irn_op(get_Proj_pred(n)) == op_Start))
+ is_Start(get_Proj_pred(n)))
return 1;
return 0;
}
}
ir_node *
-(get_Block_cfgpred)(ir_node *node, int pos) {
+(get_Block_cfgpred)(const ir_node *node, int pos) {
return _get_Block_cfgpred(node, pos);
}
}
ir_node *
-(get_Block_cfgpred_block)(ir_node *node, int pos) {
+(get_Block_cfgpred_block)(const ir_node *node, int pos) {
return _get_Block_cfgpred_block(node, pos);
}
int
-get_Block_matured(ir_node *node) {
+get_Block_matured(const ir_node *node) {
assert(node->op == op_Block);
return (int)node->attr.block.is_matured;
}
}
ir_node *
-get_Block_graph_arr (ir_node *node, int pos) {
+get_Block_graph_arr(ir_node *node, int pos) {
assert(node->op == op_Block);
return node->attr.block.graph_arr[pos+1];
}
void
-set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
+set_Block_graph_arr(ir_node *node, int pos, ir_node *value) {
assert(node->op == op_Block);
node->attr.block.graph_arr[pos+1] = value;
}
+#ifdef INTERPROCEDURAL_VIEW
void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
assert(node->op == op_Block);
if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
}
-int get_Block_cg_n_cfgpreds(ir_node *node) {
+int get_Block_cg_n_cfgpreds(const ir_node *node) {
assert(node->op == op_Block);
return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
}
-ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) {
+ir_node *get_Block_cg_cfgpred(const ir_node *node, int pos) {
assert(node->op == op_Block && node->attr.block.in_cg);
return node->attr.block.in_cg[pos + 1];
}
assert(node->op == op_Block);
node->attr.block.in_cg = NULL;
}
+#endif
ir_node *(set_Block_dead)(ir_node *block) {
return _set_Block_dead(block);
/* returns the macro block header of a block. */
ir_node *get_Block_MacroBlock(const ir_node *block) {
+ ir_node *mbh;
assert(is_Block(block));
- return get_irn_n(block, -1);
+ mbh = get_irn_n(block, -1);
+ /* once macro block header is respected by all optimizations,
+ this assert can be removed */
+ assert(mbh != NULL);
+ return mbh;
}
/* returns the graph of a Block. */
}
int
-get_End_n_keepalives(ir_node *end) {
+get_End_n_keepalives(const ir_node *end) {
assert(end->op == op_End);
return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}
ir_node *
-get_End_keepalive(ir_node *end, int pos) {
+get_End_keepalive(const ir_node *end, int pos) {
assert(end->op == op_End);
return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
}
void
-free_End (ir_node *end) {
+free_End(ir_node *end) {
assert(end->op == op_End);
end->kind = k_BAD;
DEL_ARR_F(end->in);
}
/* Return the target address of an IJmp */
-ir_node *get_IJmp_target(ir_node *ijmp) {
+ir_node *get_IJmp_target(const ir_node *ijmp) {
assert(ijmp->op == op_IJmp);
return get_irn_n(ijmp, 0);
}
> Firm to the target machine. That could be done if there was some way of
> projecting "default" out of the Cond node.
I know it's complicated.
-Basically there are two proglems:
- - determining the gaps between the projs
+Basically there are two problems:
+ - determining the gaps between the Projs
- determining the biggest case constant to know the proj number for
the default node.
I see several solutions:
1. Introduce a ProjDefault node. Solves both problems.
This means to extend all optimizations executed during construction.
2. Give the Cond node for switch two flavors:
- a) there are no gaps in the projs (existing flavor)
+ a) there are no gaps in the Projs (existing flavor)
b) gaps may exist, default proj is still the Proj with the largest
projection number. This covers also the gaps.
3. Fix the semantic of the Cond to that of 2b)
2a).
*/
ir_node *
-get_Cond_selector(ir_node *node) {
+get_Cond_selector(const ir_node *node) {
assert(node->op == op_Cond);
return get_irn_n(node, 0);
}
}
cond_kind
-get_Cond_kind(ir_node *node) {
+get_Cond_kind(const ir_node *node) {
assert(node->op == op_Cond);
return node->attr.cond.kind;
}
}
long
-get_Cond_defaultProj(ir_node *node) {
+get_Cond_defaultProj(const ir_node *node) {
assert(node->op == op_Cond);
return node->attr.cond.default_proj;
}
ir_node *
-get_Return_mem(ir_node *node) {
+get_Return_mem(const ir_node *node) {
assert(node->op == op_Return);
return get_irn_n(node, 0);
}
}
int
-get_Return_n_ress(ir_node *node) {
+get_Return_n_ress(const ir_node *node) {
assert(node->op == op_Return);
return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}
ir_node **
-get_Return_res_arr (ir_node *node) {
+get_Return_res_arr(ir_node *node) {
assert((node->op == op_Return));
if (get_Return_n_ress(node) > 0)
return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
*/
ir_node *
-get_Return_res(ir_node *node, int pos) {
+get_Return_res(const ir_node *node, int pos) {
assert(node->op == op_Return);
assert(get_Return_n_ress(node) > pos);
return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
node->attr.con.tv = con;
}
-cnst_classify_t (classify_Const)(ir_node *node) {
- return _classify_Const(node);
+int (is_Const_null)(const ir_node *node) {
+ return _is_Const_null(node);
+}
+
+int (is_Const_one)(const ir_node *node) {
+ return _is_Const_one(node);
+}
+
+int (is_Const_all_one)(const ir_node *node) {
+ return _is_Const_all_one(node);
}
ir_type *
get_Const_type(ir_node *node) {
assert(node->op == op_Const);
+ node->attr.con.tp = skip_tid(node->attr.con.tp);
return node->attr.con.tp;
}
}
ir_node *
-get_Sel_mem(ir_node *node) {
+get_Sel_mem(const ir_node *node) {
assert(node->op == op_Sel);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Sel_ptr(ir_node *node) {
+get_Sel_ptr(const ir_node *node) {
assert(node->op == op_Sel);
return get_irn_n(node, 1);
}
}
int
-get_Sel_n_indexs(ir_node *node) {
+get_Sel_n_indexs(const ir_node *node) {
assert(node->op == op_Sel);
return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}
}
ir_node *
-get_Sel_index(ir_node *node, int pos) {
+get_Sel_index(const ir_node *node, int pos) {
assert(node->op == op_Sel);
return get_irn_n(node, pos + SEL_INDEX_OFFSET);
}
}
ir_entity *
-get_Sel_entity(ir_node *node) {
+get_Sel_entity(const ir_node *node) {
assert(node->op == op_Sel);
return node->attr.sel.ent;
}
+ir_entity *_get_Sel_entity(ir_node *node) {
+ return get_Sel_entity(node);
+}
+
void
set_Sel_entity(ir_node *node, ir_entity *ent) {
assert(node->op == op_Sel);
ir_node *
-get_Call_mem(ir_node *node) {
+get_Call_mem(const ir_node *node) {
assert(node->op == op_Call);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Call_ptr(ir_node *node) {
+get_Call_ptr(const ir_node *node) {
assert(node->op == op_Call);
return get_irn_n(node, 1);
}
}
int
-get_Call_n_params(ir_node *node) {
+get_Call_n_params(const ir_node *node) {
assert(node->op == op_Call);
return (get_irn_arity(node) - CALL_PARAM_OFFSET);
}
int
-get_Call_arity(ir_node *node) {
+get_Call_arity(const ir_node *node) {
assert(node->op == op_Call);
return get_Call_n_params(node);
}
*/
ir_node *
-get_Call_param(ir_node *node, int pos) {
+get_Call_param(const ir_node *node, int pos) {
assert(node->op == op_Call);
return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
node->attr.call.cld_tp = tp;
}
-int Call_has_callees(ir_node *node) {
+int Call_has_callees(const 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) {
+int get_Call_n_callees(const 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) {
+ir_entity *get_Call_callee(const 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) {
+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) {
+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) {
+ir_node *get_CallBegin_ptr(const ir_node *node) {
assert(node->op == op_CallBegin);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, ptr);
}
-ir_node * get_CallBegin_call(ir_node *node) {
+ir_node *get_CallBegin_call(const ir_node *node) {
assert(node->op == op_CallBegin);
return node->attr.callbegin.call;
}
-void set_CallBegin_call(ir_node *node, ir_node *call) {
+void set_CallBegin_call(ir_node *node, ir_node *call) {
assert(node->op == op_CallBegin);
node->attr.callbegin.call = call;
}
assert(node->op == op_##OP); \
return get_irn_n(node, node->op->op_index); \
} \
-void set_##OP##_op (ir_node *node, ir_node *op) { \
+void set_##OP##_op(ir_node *node, ir_node *op) { \
assert(node->op == op_##OP); \
set_irn_n(node, node->op->op_index, op); \
}
BINOP(OP) \
\
ir_node * \
-get_##OP##_mem(ir_node *node) { \
+get_##OP##_mem(const ir_node *node) { \
assert(node->op == op_##OP); \
return get_irn_n(node, 0); \
} \
UNOP(Conv)
UNOP(Cast)
-int get_Conv_strict(ir_node *node) {
+int get_Conv_strict(const ir_node *node) {
assert(node->op == op_Conv);
return node->attr.conv.strict;
}
ir_type *
get_Cast_type(ir_node *node) {
assert(node->op == op_Cast);
+ node->attr.cast.totype = skip_tid(node->attr.cast.totype);
return node->attr.cast.totype;
}
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(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
assert(fromtype);
while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
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_Phi)(const ir_node *n) {
+ return _is_Phi(n);
}
int is_Phi0(const ir_node *n) {
}
-int is_memop(ir_node *node) {
- return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
+int is_memop(const ir_node *node) {
+ ir_opcode code = get_irn_opcode(node);
+ return (code == iro_Load || code == iro_Store);
}
-ir_node *get_memop_mem(ir_node *node) {
+ir_node *get_memop_mem(const ir_node *node) {
assert(is_memop(node));
return get_irn_n(node, 0);
}
set_irn_n(node, 0, mem);
}
-ir_node *get_memop_ptr(ir_node *node) {
+ir_node *get_memop_ptr(const ir_node *node) {
assert(is_memop(node));
return get_irn_n(node, 1);
}
}
ir_node *
-get_Load_mem(ir_node *node) {
+get_Load_mem(const ir_node *node) {
assert(node->op == op_Load);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Load_ptr(ir_node *node) {
+get_Load_ptr(const ir_node *node) {
assert(node->op == op_Load);
return get_irn_n(node, 1);
}
}
ir_mode *
-get_Load_mode(ir_node *node) {
+get_Load_mode(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.load_mode;
}
}
ir_volatility
-get_Load_volatility(ir_node *node) {
+get_Load_volatility(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.volatility;
}
}
ir_align
-get_Load_align(ir_node *node) {
+get_Load_align(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.aligned;
}
ir_node *
-get_Store_mem(ir_node *node) {
+get_Store_mem(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Store_ptr(ir_node *node) {
+get_Store_ptr(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 1);
}
}
ir_node *
-get_Store_value(ir_node *node) {
+get_Store_value(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 2);
}
}
ir_volatility
-get_Store_volatility(ir_node *node) {
+get_Store_volatility(const ir_node *node) {
assert(node->op == op_Store);
return node->attr.store.volatility;
}
}
ir_align
-get_Store_align(ir_node *node) {
+get_Store_align(const ir_node *node) {
assert(node->op == op_Store);
return node->attr.store.aligned;
}
ir_node *
-get_Alloc_mem(ir_node *node) {
+get_Alloc_mem(const ir_node *node) {
assert(node->op == op_Alloc);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Alloc_size(ir_node *node) {
+get_Alloc_size(const ir_node *node) {
assert(node->op == op_Alloc);
return get_irn_n(node, 1);
}
node->attr.alloc.type = tp;
}
-where_alloc
-get_Alloc_where(ir_node *node) {
+ir_where_alloc
+get_Alloc_where(const ir_node *node) {
assert(node->op == op_Alloc);
return node->attr.alloc.where;
}
void
-set_Alloc_where(ir_node *node, where_alloc where) {
+set_Alloc_where(ir_node *node, ir_where_alloc where) {
assert(node->op == op_Alloc);
node->attr.alloc.where = where;
}
ir_node *
-get_Free_mem(ir_node *node) {
+get_Free_mem(const ir_node *node) {
assert(node->op == op_Free);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Free_ptr(ir_node *node) {
+get_Free_ptr(const ir_node *node) {
assert(node->op == op_Free);
return get_irn_n(node, 1);
}
}
ir_node *
-get_Free_size(ir_node *node) {
+get_Free_size(const ir_node *node) {
assert(node->op == op_Free);
return get_irn_n(node, 2);
}
node->attr.free.type = tp;
}
-where_alloc
-get_Free_where(ir_node *node) {
+ir_where_alloc
+get_Free_where(const ir_node *node) {
assert(node->op == op_Free);
return node->attr.free.where;
}
void
-set_Free_where(ir_node *node, where_alloc where) {
+set_Free_where(ir_node *node, ir_where_alloc where) {
assert(node->op == op_Free);
node->attr.free.where = where;
}
return (ir_node **)&(get_irn_in(node)[1]);
}
-int get_Sync_n_preds(ir_node *node) {
+int get_Sync_n_preds(const ir_node *node) {
assert(node->op == op_Sync);
return (get_irn_arity(node));
}
}
*/
-ir_node *get_Sync_pred(ir_node *node, int pos) {
+ir_node *get_Sync_pred(const ir_node *node, int pos) {
assert(node->op == op_Sync);
return get_irn_n(node, pos);
}
}
int
-get_Tuple_n_preds(ir_node *node) {
+get_Tuple_n_preds(const ir_node *node) {
assert(node->op == op_Tuple);
return (get_irn_arity(node));
}
*/
ir_node *
-get_Tuple_pred (ir_node *node, int pos) {
+get_Tuple_pred(const ir_node *node, int pos) {
assert(node->op == op_Tuple);
return get_irn_n(node, pos);
}
}
ir_node *
-get_Id_pred(ir_node *node) {
+get_Id_pred(const ir_node *node) {
assert(node->op == op_Id);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, pred);
}
-ir_node *get_Confirm_value(ir_node *node) {
+ir_node *get_Confirm_value(const ir_node *node) {
assert(node->op == op_Confirm);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, value);
}
-ir_node *get_Confirm_bound(ir_node *node) {
+ir_node *get_Confirm_bound(const ir_node *node) {
assert(node->op == op_Confirm);
return get_irn_n(node, 1);
}
/* 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) {
+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_ARR_D (int, current_ir_graph->obst, arity);
- memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
+ 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);
}
/* Mux support */
-ir_node *get_Mux_sel(ir_node *node) {
+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);
}
}
-ir_node *get_Mux_false(ir_node *node) {
+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);
}
}
-ir_node *get_Mux_true(ir_node *node) {
+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);
}
/* Psi support */
-ir_node *get_Psi_cond(ir_node *node, int pos) {
- int num_conds = get_Psi_n_conds(node);
+ir_node *get_Psi_cond(const ir_node *node, int pos) {
assert(node->op == op_Psi);
- assert(pos < num_conds);
+ 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) {
- int num_conds = get_Psi_n_conds(node);
assert(node->op == op_Psi);
- assert(pos < num_conds);
+ assert(pos < get_Psi_n_conds(node));
set_irn_n(node, 2 * pos, cond);
}
-ir_node *get_Psi_val(ir_node *node, int pos) {
- int num_vals = get_Psi_n_conds(node);
+ir_node *get_Psi_val(const ir_node *node, int pos) {
assert(node->op == op_Psi);
- assert(pos < num_vals);
+ 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) {
- int num_vals = get_Psi_n_conds(node);
assert(node->op == op_Psi);
- assert(pos < num_vals);
+ assert(pos < get_Psi_n_conds(node));
set_irn_n(node, 2 * pos + 1, val);
}
-ir_node *get_Psi_default(ir_node *node) {
+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);
set_irn_n(node, def_pos, val);
}
-int (get_Psi_n_conds)(ir_node *node) {
+int (get_Psi_n_conds)(const ir_node *node) {
return _get_Psi_n_conds(node);
}
/* CopyB support */
-ir_node *get_CopyB_mem(ir_node *node) {
+ir_node *get_CopyB_mem(const ir_node *node) {
assert(node->op == op_CopyB);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, mem);
}
-ir_node *get_CopyB_dst(ir_node *node) {
+ir_node *get_CopyB_dst(const ir_node *node) {
assert(node->op == op_CopyB);
return get_irn_n(node, 1);
}
set_irn_n(node, 1, dst);
}
-ir_node *get_CopyB_src (ir_node *node) {
+ir_node *get_CopyB_src(const ir_node *node) {
assert(node->op == op_CopyB);
return get_irn_n(node, 2);
}
ir_type *get_CopyB_type(ir_node *node) {
assert(node->op == op_CopyB);
- return node->attr.copyb.data_type;
+ return node->attr.copyb.data_type = skip_tid(node->attr.copyb.data_type);
}
void set_CopyB_type(ir_node *node, ir_type *data_type) {
ir_type *
get_InstOf_type(ir_node *node) {
- assert(node->op = op_InstOf);
- return node->attr.instof.type;
+ 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);
+ assert(node->op == op_InstOf);
node->attr.instof.type = type;
}
ir_node *
-get_InstOf_store(ir_node *node) {
- assert(node->op = op_InstOf);
+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);
+ assert(node->op == op_InstOf);
set_irn_n(node, 0, obj);
}
ir_node *
-get_InstOf_obj(ir_node *node) {
- assert(node->op = op_InstOf);
+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);
+ 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) {
+get_Raise_mem(const ir_node *node) {
assert(node->op == op_Raise);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Raise_exo_ptr(ir_node *node) {
+get_Raise_exo_ptr(const ir_node *node) {
assert(node->op == op_Raise);
return get_irn_n(node, 1);
}
/* Bound support */
/* Returns the memory input of a Bound operation. */
-ir_node *get_Bound_mem(ir_node *bound) {
+ir_node *get_Bound_mem(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 0);
}
}
/* Returns the index input of a Bound operation. */
-ir_node *get_Bound_index(ir_node *bound) {
+ir_node *get_Bound_index(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 1);
}
}
/* Returns the lower bound input of a Bound operation. */
-ir_node *get_Bound_lower(ir_node *bound) {
+ir_node *get_Bound_lower(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 2);
}
}
/* Returns the upper bound input of a Bound operation. */
-ir_node *get_Bound_upper(ir_node *bound) {
+ir_node *get_Bound_upper(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 3);
}
return _is_Conv(node);
}
+int
+(is_strictConv)(const ir_node *node) {
+ return _is_strictConv(node);
+}
+
int
(is_Cast)(const ir_node *node) {
return _is_Cast(node);
return _is_Sync(node);
}
-/* returns true if node is a Confirm node. */
+/* Returns true if node is a Confirm node. */
int
(is_Confirm)(const ir_node *node) {
return _is_Confirm(node);
}
-/* returns true if node is a Pin node. */
+/* Returns true if node is a Pin node. */
int
(is_Pin)(const ir_node *node) {
return _is_Pin(node);
}
-/* returns true if node is a SymConst node. */
+/* Returns true if node is a SymConst node. */
int
(is_SymConst)(const ir_node *node) {
return _is_SymConst(node);
}
-/* returns true if node is a Cond node. */
+/* Returns true if node is a SymConst node with kind symconst_addr_ent. */
+int
+(is_SymConst_addr_ent)(const ir_node *node) {
+ return _is_SymConst_addr_ent(node);
+}
+
+/* Returns true if node is a Cond node. */
int
(is_Cond)(const ir_node *node) {
return _is_Cond(node);
}
int
-is_Proj(const ir_node *node) {
+(is_Proj)(const ir_node *node) {
assert(node);
return node->op == op_Proj ||
(!get_interprocedural_view() && node->op == op_Filter);
}
/* Returns true if the operation manipulates control flow. */
-int
-is_cfop(const ir_node *node) {
- return is_cfopcode(get_irn_op(node));
+int is_cfop(const ir_node *node) {
+ return is_op_cfopcode(get_irn_op(node));
}
/* Returns true if the operation manipulates interprocedural control flow:
case iro_Store :
case iro_Alloc :
case iro_Bound :
- return get_irn_n(node, 0);
+ case iro_CopyB :
+ return get_irn_n(node, pn_Generic_M_regular);
case iro_Bad :
case iro_Unknown:
return node;
ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
switch (code) {
case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
- case iro_Sel: ops->get_entity_attr = get_Sel_entity; break;
+ case iro_Sel: ops->get_entity_attr = _get_Sel_entity; break;
default:
/* not allowed to be NULL */
if (! ops->get_entity_attr)
#ifdef DEBUG_libfirm
-void dump_irn(ir_node *n) {
+void dump_irn(const ir_node *n) {
int i, arity = get_irn_arity(n);
printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
if (!is_Block(n)) {
}
#else /* DEBUG_libfirm */
-void dump_irn(ir_node *n) {}
+void dump_irn(const ir_node *n) { (void) n; }
#endif /* DEBUG_libfirm */
projects / libfirm / blobdiff