/*
- * 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.
*
/* 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_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;
}
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];
}
return mbh;
}
+/* returns the macro block header of a node. */
+ir_node *get_irn_MacroBlock(const ir_node *n) {
+ if (! is_Block(n))
+ n = get_nodes_block(n);
+ return get_Block_MacroBlock(n);
+}
+
/* returns the graph of a Block. */
ir_graph *get_Block_irg(const ir_node *block) {
assert(is_Block(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);
}
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); \
} \
}
-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);
}
}
ir_where_alloc
-get_Alloc_where(ir_node *node) {
+get_Alloc_where(const ir_node *node) {
assert(node->op == op_Alloc);
return node->attr.alloc.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);
}
}
ir_where_alloc
-get_Free_where(ir_node *node) {
+get_Free_where(const ir_node *node) {
assert(node->op == op_Free);
return node->attr.free.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);
}
}
/* 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) {
+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);
set_irn_n(node, 2 * pos, cond);
}
-ir_node *get_Psi_val(ir_node *node, int pos) {
+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);
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_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);
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) n; }
+void dump_irn(const ir_node *n) { (void) n; }
#endif /* DEBUG_libfirm */