projects
/
libfirm
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
fix warnings
[libfirm]
/
ir
/
ir
/
irnode.c
diff --git
a/ir/ir/irnode.c
b/ir/ir/irnode.c
index
dda3d4f
..
ddcfec1
100644
(file)
--- a/
ir/ir/irnode.c
+++ b/
ir/ir/irnode.c
@@
-1,5
+1,5
@@
/*
/*
- * Copyright (C) 1995-200
7
University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-200
8
University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
*
* This file is part of libFirm.
*
@@
-72,26
+72,25
@@
const char *get_pnc_string(int pnc) {
/*
* Calculates the negated (Complement(R)) pnc condition.
*/
/*
* 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;
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., "<" --> ">" */
}
/* 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);
code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0);
- return code;
+ return
(pn_Cmp)
code;
}
/**
}
/**
@@
-664,12
+663,19
@@
set_nodes_block(ir_node *node, ir_node *block) {
set_irn_n(node, -1, block);
}
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. */
/* 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 (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));
}
}
return get_irg_frame_type(get_irn_irg(start));
}
}
@@
-678,10
+684,10
@@
ir_type *is_frame_pointer(ir_node *n) {
/* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
* from Start. If so returns global type, else Null. */
/* 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 (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();
}
}
return get_glob_type();
}
}
@@
-690,10
+696,10
@@
ir_type *is_globals_pointer(ir_node *n) {
/* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
* from Start. If so returns tls type, else Null. */
/* 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 (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();
}
}
return get_tls_type();
}
}
@@
-702,10
+708,10
@@
ir_type *is_tls_pointer(ir_node *n) {
/* 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. */
/* 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_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;
}
return 1;
return 0;
}
@@
-726,7
+732,7
@@
int
}
ir_node *
}
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);
}
return _get_Block_cfgpred(node, pos);
}
@@
-737,12
+743,12
@@
set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
}
ir_node *
}
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
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;
}
assert(node->op == op_Block);
return (int)node->attr.block.is_matured;
}
@@
-780,17
+786,18
@@
int
}
ir_node *
}
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
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;
}
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) {
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) {
@@
-821,12
+828,12
@@
ir_node **get_Block_cg_cfgpred_arr(ir_node *node) {
return node->attr.block.in_cg == NULL ? NULL : 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;
}
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);
return node->attr.block.in_cg[pos + 1];
}
@@
-835,6
+842,7
@@
void remove_Block_cg_cfgpred_arr(ir_node *node) {
assert(node->op == op_Block);
node->attr.block.in_cg = NULL;
}
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);
ir_node *(set_Block_dead)(ir_node *block) {
return _set_Block_dead(block);
@@
-860,8
+868,13
@@
void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
/* returns the macro block header of a block. */
ir_node *get_Block_MacroBlock(const ir_node *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));
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. */
}
/* returns the graph of a Block. */
@@
-887,13
+900,13
@@
void set_Block_label(ir_node *block, ir_label_t label) {
}
int
}
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 *
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);
}
assert(end->op == op_End);
return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
@@
-949,7
+962,7
@@
void remove_End_keepalive(ir_node *end, ir_node *irn) {
}
void
}
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);
assert(end->op == op_End);
end->kind = k_BAD;
DEL_ARR_F(end->in);
@@
-958,7
+971,7
@@
free_End (ir_node *end) {
}
/* Return the target address of an IJmp */
}
/* 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);
}
assert(ijmp->op == op_IJmp);
return get_irn_n(ijmp, 0);
}
@@
-976,15
+989,15
@@
void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
> 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.
> 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 pro
g
lems:
- - determining the gaps between the
p
rojs
+Basically there are two pro
b
lems:
+ - determining the gaps between the
P
rojs
- 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:
- 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
p
rojs (existing flavor)
+ a) there are no gaps in the
P
rojs (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)
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)
@@
-1001,7
+1014,7
@@
dataflow analysis and 3) does not allow to convert the representation to
2a).
*/
ir_node *
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);
}
assert(node->op == op_Cond);
return get_irn_n(node, 0);
}
@@
-1013,7
+1026,7
@@
set_Cond_selector(ir_node *node, ir_node *selector) {
}
cond_kind
}
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;
}
assert(node->op == op_Cond);
return node->attr.cond.kind;
}
@@
-1025,13
+1038,13
@@
set_Cond_kind(ir_node *node, cond_kind kind) {
}
long
}
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 *
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);
}
assert(node->op == op_Return);
return get_irn_n(node, 0);
}
@@
-1043,13
+1056,13
@@
set_Return_mem(ir_node *node, ir_node *mem) {
}
int
}
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 **
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]);
assert((node->op == op_Return));
if (get_Return_n_ress(node) > 0)
return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
@@
-1065,7
+1078,7
@@
set_Return_n_res(ir_node *node, int results) {
*/
ir_node *
*/
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);
assert(node->op == op_Return);
assert(get_Return_n_ress(node) > pos);
return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
@@
-1087,8
+1100,16
@@
set_Const_tarval(ir_node *node, tarval *con) {
node->attr.con.tv = con;
}
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);
}
}
@@
-1098,6
+1119,7
@@
cnst_classify_t (classify_Const)(ir_node *node) {
ir_type *
get_Const_type(ir_node *node) {
assert(node->op == op_Const);
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;
}
return node->attr.con.tp;
}
@@
-1208,7
+1230,7
@@
set_SymConst_value_type(ir_node *node, ir_type *tp) {
}
ir_node *
}
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);
}
assert(node->op == op_Sel);
return get_irn_n(node, 0);
}
@@
-1220,7
+1242,7
@@
set_Sel_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Sel);
return get_irn_n(node, 1);
}
@@
-1232,7
+1254,7
@@
set_Sel_ptr(ir_node *node, ir_node *ptr) {
}
int
}
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);
}
assert(node->op == op_Sel);
return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}
@@
-1247,7
+1269,7
@@
get_Sel_index_arr(ir_node *node) {
}
ir_node *
}
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);
}
assert(node->op == op_Sel);
return get_irn_n(node, pos + SEL_INDEX_OFFSET);
}
@@
-1259,7
+1281,7
@@
set_Sel_index(ir_node *node, int pos, ir_node *index) {
}
ir_entity *
}
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;
}
assert(node->op == op_Sel);
return node->attr.sel.ent;
}
@@
-1280,7
+1302,7
@@
set_Sel_entity(ir_node *node, ir_entity *ent) {
ir_node *
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);
}
assert(node->op == op_Call);
return get_irn_n(node, 0);
}
@@
-1292,7
+1314,7
@@
set_Call_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Call);
return get_irn_n(node, 1);
}
@@
-1310,13
+1332,13
@@
get_Call_param_arr(ir_node *node) {
}
int
}
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
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);
}
assert(node->op == op_Call);
return get_Call_n_params(node);
}
@@
-1328,7
+1350,7
@@
set_Call_arity(ir_node *node, ir_node *arity) {
*/
ir_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);
}
assert(node->op == op_Call);
return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
@@
-1352,23
+1374,23
@@
set_Call_type(ir_node *node, ir_type *tp) {
node->attr.call.cld_tp = tp;
}
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));
}
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);
}
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];
}
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);
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);
@@
-1376,12
+1398,12
@@
void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
}
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;
}
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);
}
assert(node->op == op_CallBegin);
return get_irn_n(node, 0);
}
@@
-1391,12
+1413,12
@@
void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
set_irn_n(node, 0, ptr);
}
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;
}
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_CallBegin);
node->attr.callbegin.call = call;
}
@@
-1425,7
+1447,7
@@
ir_node *get_##OP##_op(const ir_node *node) { \
assert(node->op == op_##OP); \
return get_irn_n(node, node->op->op_index); \
} \
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); \
}
assert(node->op == op_##OP); \
set_irn_n(node, node->op->op_index, op); \
}
@@
-1434,7
+1456,7
@@
void set_##OP##_op (ir_node *node, ir_node *op) { \
BINOP(OP) \
\
ir_node * \
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); \
} \
assert(node->op == op_##OP); \
return get_irn_n(node, 0); \
} \
@@
-1481,7
+1503,7
@@
BINOP(Cmp)
UNOP(Conv)
UNOP(Cast)
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;
}
assert(node->op == op_Conv);
return node->attr.conv.strict;
}
@@
-1494,6
+1516,7
@@
void set_Conv_strict(ir_node *node, int strict_flag) {
ir_type *
get_Cast_type(ir_node *node) {
assert(node->op == op_Cast);
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;
}
return node->attr.cast.totype;
}
@@
-1511,9
+1534,8
@@
set_Cast_type(ir_node *node, ir_type *to_tp) {
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));
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)) {
assert(fromtype);
while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
@@
-1600,19
+1622,9
@@
set_binop_right(ir_node *node, ir_node *right) {
set_irn_n(node, node->op->op_index + 1, right);
}
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_Phi0(const ir_node *n) {
@@
-1654,11
+1666,12
@@
set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
}
}
-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);
}
assert(is_memop(node));
return get_irn_n(node, 0);
}
@@
-1668,7
+1681,7
@@
void set_memop_mem(ir_node *node, ir_node *mem) {
set_irn_n(node, 0, mem);
}
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);
}
assert(is_memop(node));
return get_irn_n(node, 1);
}
@@
-1679,7
+1692,7
@@
void set_memop_ptr(ir_node *node, ir_node *ptr) {
}
ir_node *
}
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);
}
assert(node->op == op_Load);
return get_irn_n(node, 0);
}
@@
-1691,7
+1704,7
@@
set_Load_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Load);
return get_irn_n(node, 1);
}
@@
-1703,7
+1716,7
@@
set_Load_ptr(ir_node *node, ir_node *ptr) {
}
ir_mode *
}
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;
}
assert(node->op == op_Load);
return node->attr.load.load_mode;
}
@@
-1715,7
+1728,7
@@
set_Load_mode(ir_node *node, ir_mode *mode) {
}
ir_volatility
}
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;
}
assert(node->op == op_Load);
return node->attr.load.volatility;
}
@@
-1727,7
+1740,7
@@
set_Load_volatility(ir_node *node, ir_volatility volatility) {
}
ir_align
}
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;
}
assert(node->op == op_Load);
return node->attr.load.aligned;
}
@@
-1740,7
+1753,7
@@
set_Load_align(ir_node *node, ir_align align) {
ir_node *
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);
}
assert(node->op == op_Store);
return get_irn_n(node, 0);
}
@@
-1752,7
+1765,7
@@
set_Store_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Store);
return get_irn_n(node, 1);
}
@@
-1764,7
+1777,7
@@
set_Store_ptr(ir_node *node, ir_node *ptr) {
}
ir_node *
}
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);
}
assert(node->op == op_Store);
return get_irn_n(node, 2);
}
@@
-1776,7
+1789,7
@@
set_Store_value(ir_node *node, ir_node *value) {
}
ir_volatility
}
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;
}
assert(node->op == op_Store);
return node->attr.store.volatility;
}
@@
-1788,7
+1801,7
@@
set_Store_volatility(ir_node *node, ir_volatility volatility) {
}
ir_align
}
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;
}
assert(node->op == op_Store);
return node->attr.store.aligned;
}
@@
-1801,7
+1814,7
@@
set_Store_align(ir_node *node, ir_align align) {
ir_node *
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);
}
assert(node->op == op_Alloc);
return get_irn_n(node, 0);
}
@@
-1813,7
+1826,7
@@
set_Alloc_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Alloc);
return get_irn_n(node, 1);
}
@@
-1836,21
+1849,21
@@
set_Alloc_type(ir_node *node, ir_type *tp) {
node->attr.alloc.type = tp;
}
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
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 *
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);
}
assert(node->op == op_Free);
return get_irn_n(node, 0);
}
@@
-1862,7
+1875,7
@@
set_Free_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Free);
return get_irn_n(node, 1);
}
@@
-1874,7
+1887,7
@@
set_Free_ptr(ir_node *node, ir_node *ptr) {
}
ir_node *
}
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);
}
assert(node->op == op_Free);
return get_irn_n(node, 2);
}
@@
-1897,14
+1910,14
@@
set_Free_type(ir_node *node, ir_type *tp) {
node->attr.free.type = tp;
}
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
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;
}
assert(node->op == op_Free);
node->attr.free.where = where;
}
@@
-1914,7
+1927,7
@@
ir_node **get_Sync_preds_arr(ir_node *node) {
return (ir_node **)&(get_irn_in(node)[1]);
}
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));
}
assert(node->op == op_Sync);
return (get_irn_arity(node));
}
@@
-1925,7
+1938,7
@@
void set_Sync_n_preds(ir_node *node, int n_preds) {
}
*/
}
*/
-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);
}
assert(node->op == op_Sync);
return get_irn_n(node, pos);
}
@@
-2009,7
+2022,7
@@
get_Tuple_preds_arr(ir_node *node) {
}
int
}
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));
}
assert(node->op == op_Tuple);
return (get_irn_arity(node));
}
@@
-2022,7
+2035,7
@@
set_Tuple_n_preds(ir_node *node, int n_preds) {
*/
ir_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);
}
assert(node->op == op_Tuple);
return get_irn_n(node, pos);
}
@@
-2034,7
+2047,7
@@
set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
}
ir_node *
}
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);
}
assert(node->op == op_Id);
return get_irn_n(node, 0);
}
@@
-2045,7
+2058,7
@@
set_Id_pred(ir_node *node, ir_node *pred) {
set_irn_n(node, 0, pred);
}
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);
}
assert(node->op == op_Confirm);
return get_irn_n(node, 0);
}
@@
-2055,7
+2068,7
@@
void set_Confirm_value(ir_node *node, ir_node *value) {
set_irn_n(node, 0, value);
}
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);
}
assert(node->op == op_Confirm);
return get_irn_n(node, 1);
}
@@
-2101,12
+2114,12
@@
set_Filter_proj(ir_node *node, long proj) {
/* Don't use get_irn_arity, get_irn_n in implementation as access
shall work independent of view!!! */
/* 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) {
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.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);
node->attr.filter.in_cg[0] = node->in[0];
}
memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
@@
-2133,7
+2146,7
@@
ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
}
/* Mux support */
}
/* 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);
if (node->op == op_Psi) {
assert(get_irn_arity(node) == 3);
return get_Psi_cond(node, 0);
@@
-2152,7
+2165,7
@@
void set_Mux_sel(ir_node *node, ir_node *sel) {
}
}
}
}
-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);
if (node->op == op_Psi) {
assert(get_irn_arity(node) == 3);
return get_Psi_default(node);
@@
-2171,7
+2184,7
@@
void set_Mux_false(ir_node *node, ir_node *ir_false) {
}
}
}
}
-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);
if (node->op == op_Psi) {
assert(get_irn_arity(node) == 3);
return get_Psi_val(node, 0);
@@
-2191,35
+2204,31
@@
void set_Mux_true(ir_node *node, ir_node *ir_true) {
}
/* Psi support */
}
/* 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(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) {
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(node->op == op_Psi);
- assert(pos <
num_conds
);
+ assert(pos <
get_Psi_n_conds(node)
);
set_irn_n(node, 2 * pos, cond);
}
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(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) {
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(node->op == op_Psi);
- assert(pos <
num_vals
);
+ assert(pos <
get_Psi_n_conds(node)
);
set_irn_n(node, 2 * pos + 1, val);
}
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);
int def_pos = get_irn_arity(node) - 1;
assert(node->op == op_Psi);
return get_irn_n(node, def_pos);
@@
-2231,12
+2240,12
@@
void set_Psi_default(ir_node *node, ir_node *val) {
set_irn_n(node, def_pos, val);
}
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 */
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);
}
assert(node->op == op_CopyB);
return get_irn_n(node, 0);
}
@@
-2246,7
+2255,7
@@
void set_CopyB_mem(ir_node *node, ir_node *mem) {
set_irn_n(node, 0, mem);
}
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);
}
assert(node->op == op_CopyB);
return get_irn_n(node, 1);
}
@@
-2256,7
+2265,7
@@
void set_CopyB_dst(ir_node *node, ir_node *dst) {
set_irn_n(node, 1, dst);
}
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);
}
assert(node->op == op_CopyB);
return get_irn_n(node, 2);
}
@@
-2268,7
+2277,7
@@
void set_CopyB_src(ir_node *node, ir_node *src) {
ir_type *get_CopyB_type(ir_node *node) {
assert(node->op == op_CopyB);
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) {
}
void set_CopyB_type(ir_node *node, ir_type *data_type) {
@@
-2279,43
+2288,43
@@
void set_CopyB_type(ir_node *node, ir_type *data_type) {
ir_type *
get_InstOf_type(ir_node *node) {
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) {
}
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 *
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) {
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 *
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) {
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 *
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);
}
assert(node->op == op_Raise);
return get_irn_n(node, 0);
}
@@
-2327,7
+2336,7
@@
set_Raise_mem(ir_node *node, ir_node *mem) {
}
ir_node *
}
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);
}
assert(node->op == op_Raise);
return get_irn_n(node, 1);
}
@@
-2341,7
+2350,7
@@
set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
/* Bound support */
/* Returns the memory input of a Bound operation. */
/* 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);
}
assert(bound->op == op_Bound);
return get_irn_n(bound, 0);
}
@@
-2352,7
+2361,7
@@
void set_Bound_mem(ir_node *bound, ir_node *mem) {
}
/* Returns the index input of a Bound operation. */
}
/* 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);
}
assert(bound->op == op_Bound);
return get_irn_n(bound, 1);
}
@@
-2363,7
+2372,7
@@
void set_Bound_index(ir_node *bound, ir_node *idx) {
}
/* Returns the lower bound input of a Bound operation. */
}
/* 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);
}
assert(bound->op == op_Bound);
return get_irn_n(bound, 2);
}
@@
-2374,7
+2383,7
@@
void set_Bound_lower(ir_node *bound, ir_node *lower) {
}
/* Returns the upper bound input of a Bound operation. */
}
/* 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);
}
assert(bound->op == op_Bound);
return get_irn_n(bound, 3);
}
@@
-2703,6
+2712,11
@@
int
return _is_Conv(node);
}
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);
int
(is_Cast)(const ir_node *node) {
return _is_Cast(node);
@@
-2766,25
+2780,31
@@
int
return _is_Sync(node);
}
return _is_Sync(node);
}
-/*
r
eturns true if node is a Confirm node. */
+/*
R
eturns true if node is a Confirm node. */
int
(is_Confirm)(const ir_node *node) {
return _is_Confirm(node);
}
int
(is_Confirm)(const ir_node *node) {
return _is_Confirm(node);
}
-/*
r
eturns true if node is a Pin node. */
+/*
R
eturns true if node is a Pin node. */
int
(is_Pin)(const ir_node *node) {
return _is_Pin(node);
}
int
(is_Pin)(const ir_node *node) {
return _is_Pin(node);
}
-/*
r
eturns true if node is a SymConst node. */
+/*
R
eturns true if node is a SymConst node. */
int
(is_SymConst)(const ir_node *node) {
return _is_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_Cond)(const ir_node *node) {
return _is_Cond(node);
@@
-2826,16
+2846,15
@@
int
}
int
}
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. */
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:
}
/* Returns true if the operation manipulates interprocedural control flow:
@@
-2865,7
+2884,8
@@
ir_node *get_fragile_op_mem(ir_node *node) {
case iro_Store :
case iro_Alloc :
case iro_Bound :
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;
case iro_Bad :
case iro_Unknown:
return node;
@@
-3065,7
+3085,7
@@
dbg_info *(get_irn_dbg_info)(const ir_node *n) {
#ifdef DEBUG_libfirm
#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)) {
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)) {
@@
-3082,5
+3102,5
@@
void dump_irn(ir_node *n) {
}
#else /* DEBUG_libfirm */
}
#else /* DEBUG_libfirm */
-void dump_irn(
ir_node *n) {
}
+void dump_irn(
const ir_node *n) { (void) n;
}
#endif /* DEBUG_libfirm */
#endif /* DEBUG_libfirm */