tarval_bad cannot asked for get_tarval_null :-(
[r4268]
tarval *ta = value_of(a);
tarval *tb = value_of(b);
tarval *ta = value_of(a);
tarval *tb = value_of(b);
- if ((ta != tarval_bad) && (tb != tarval_bad)
- && (get_irn_mode(a) == get_irn_mode(b))
- && !(get_mode_sort(get_irn_mode(a)) == irms_reference)) {
+ if ((ta != tarval_bad) && (tb != tarval_bad) && (get_irn_mode(a) == get_irn_mode(b)))
return tarval_add(ta, tb);
return tarval_add(ta, tb);
ta = value_of(a);
tb = value_of(b);
ta = value_of(a);
tb = value_of(b);
- if ((ta != tarval_bad) && (tb != tarval_bad)
- && (get_irn_mode(a) == get_irn_mode(b))
- && !(get_mode_sort(get_irn_mode(a)) == irms_reference)) {
+ if ((ta != tarval_bad) && (tb != tarval_bad) && (get_irn_mode(a) == get_irn_mode(b)))
return tarval_sub(ta, tb);
return tarval_sub(ta, tb);
/* a*0 = 0 or 0*b = 0:
calls computed_value recursive and returns the 0 with proper
mode. */
/* a*0 = 0 or 0*b = 0:
calls computed_value recursive and returns the 0 with proper
mode. */
- tarval *v;
-
- if ( ( ((v = ta) != tarval_bad)
- && (v == get_mode_null(get_tarval_mode(v))) )
- || ( ((v = tb) != tarval_bad)
- && (v == get_mode_null(get_tarval_mode(v))) )) {
- return v;
- }
+ if ((ta != tarval_bad) && (ta == get_mode_null(get_tarval_mode(ta))))
+ return ta;
+ if ((tb != tarval_bad) && (tb == get_mode_null(get_tarval_mode(tb))))
+ return tb;
tarval *tb = value_of(b);
/* Compute c1 / c2 or 0 / a, a != 0 */
tarval *tb = value_of(b);
/* Compute c1 / c2 or 0 / a, a != 0 */
- if ((ta != tarval_bad) && (tb != get_mode_null(get_irn_mode(b)))) {
- if (tb != tarval_bad) /* div by zero: return tarval_bad */
+ if (ta != tarval_bad) {
+ if ((tb != tarval_bad) && (tb != get_mode_null(get_irn_mode(b)))) /* div by zero: return tarval_bad */
return tarval_div(ta, tb);
else if (ta == get_mode_null(get_tarval_mode(ta))) /* 0 / b == 0 */
return ta;
return tarval_div(ta, tb);
else if (ta == get_mode_null(get_tarval_mode(ta))) /* 0 / b == 0 */
return ta;
- if ( (classify_tarval ((v = computed_value (a))) == TV_CLASSIFY_NULL)
- || (classify_tarval ((v = computed_value (b))) == TV_CLASSIFY_NULL)) {
+ if ( (classify_tarval ((v = ta)) == TV_CLASSIFY_NULL)
+ || (classify_tarval ((v = tb)) == TV_CLASSIFY_NULL)) {
return tarval_or (ta, tb);
} else {
tarval *v;
return tarval_or (ta, tb);
} else {
tarval *v;
- if ( (classify_tarval ((v = computed_value (a))) == TV_CLASSIFY_ALL_ONE)
- || (classify_tarval ((v = computed_value (b))) == TV_CLASSIFY_ALL_ONE)) {
+ if ( (classify_tarval ((v = ta)) == TV_CLASSIFY_ALL_ONE)
+ || (classify_tarval ((v = tb)) == TV_CLASSIFY_ALL_ONE)) {
return new_tarval_from_long (proj_nr == Eq, mode_b) */
return new_tarval_from_long (proj_nr & Eq, mode_b);
} else {
return new_tarval_from_long (proj_nr == Eq, mode_b) */
return new_tarval_from_long (proj_nr & Eq, mode_b);
} else {
- tarval *taa = computed_value (aa);
- tarval *tab = computed_value (ab);
+ tarval *taa = value_of(aa);
+ tarval *tab = value_of(ab);
if ((taa != tarval_bad) && (tab != tarval_bad)) { /* 2.: */
/* strange checks... */
if ((taa != tarval_bad) && (tab != tarval_bad)) { /* 2.: */
/* strange checks... */
/* After running compute_node there is only one constant predecessor.
Find this predecessors value and remember the other node: */
/* After running compute_node there is only one constant predecessor.
Find this predecessors value and remember the other node: */
- if ((tv = computed_value(a)) != tarval_bad) {
+ if ((tv = value_of(a)) != tarval_bad) {
- } else if ((tv = computed_value(b)) != tarval_bad) {
+ } else if ((tv = value_of(b)) != tarval_bad) {
ir_node *a = get_binop_left(n);
ir_node *b = get_binop_right(n);
ir_node *a = get_binop_left(n);
ir_node *b = get_binop_right(n);
- if (classify_tarval(computed_value(b)) == TV_CLASSIFY_NULL) {
+ if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n);
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n);
ir_node *b = get_Mul_right(n);
/* Mul is commutative and has again an other neutral element. */
ir_node *b = get_Mul_right(n);
/* Mul is commutative and has again an other neutral element. */
- if (classify_tarval (computed_value (a)) == TV_CLASSIFY_ONE) {
+ if (classify_tarval(value_of(a)) == TV_CLASSIFY_ONE) {
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n);
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n);
- } else if (classify_tarval (computed_value (b)) == TV_CLASSIFY_ONE) {
+ } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n);
}
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n);
}
ir_node *b = get_Div_right(n);
/* Div is not commutative. */
ir_node *b = get_Div_right(n);
/* Div is not commutative. */
- if (classify_tarval(computed_value(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
+ if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
/* Turn Div into a tuple (mem, bad, a) */
ir_node *mem = get_Div_mem(n);
turn_into_tuple(n, 3);
/* Turn Div into a tuple (mem, bad, a) */
ir_node *mem = get_Div_mem(n);
turn_into_tuple(n, 3);
ir_node *b = get_DivMod_right(n);
/* Div is not commutative. */
ir_node *b = get_DivMod_right(n);
/* Div is not commutative. */
- if (classify_tarval(computed_value(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
+ if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
/* Turn DivMod into a tuple (mem, bad, a, 0) */
ir_node *mem = get_Div_mem(n);
ir_mode *mode = get_irn_mode(b);
/* Turn DivMod into a tuple (mem, bad, a, 0) */
ir_node *mem = get_Div_mem(n);
ir_mode *mode = get_irn_mode(b);
if (a == b) {
n = a; /* And has it's own neutral element */
if (a == b) {
n = a; /* And has it's own neutral element */
- } else if (classify_tarval(computed_value(a)) == TV_CLASSIFY_ALL_ONE) {
+ } else if (classify_tarval(value_of(a)) == TV_CLASSIFY_ALL_ONE) {
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n);
n = b;
DBG_OPT_ALGSIM1(oldn, a, b, n);
- } else if (classify_tarval(computed_value(b)) == TV_CLASSIFY_ALL_ONE) {
+ } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_ALL_ONE) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n);
}
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n);
}
static ir_node *transform_node_Div(ir_node *n)
{
static ir_node *transform_node_Div(ir_node *n)
{
- tarval *tv = computed_value(n);
+ tarval *tv = value_of(n);
ir_node *value = n;
/* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */
ir_node *value = n;
/* BEWARE: it is NOT possible to optimize a/a to 1, as this may cause a exception */
static ir_node *transform_node_Mod(ir_node *n)
{
static ir_node *transform_node_Mod(ir_node *n)
{
- tarval *tv = computed_value(n);
+ tarval *tv = value_of(n);
ir_node *value = n;
/* BEWARE: it is NOT possible to optimize a%a to 0, as this may cause a exception */
ir_node *value = n;
/* BEWARE: it is NOT possible to optimize a%a to 0, as this may cause a exception */
add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_block(n));
} else if ((get_irn_op(a) == op_Eor)
&& (get_irn_mode(a) == mode_b)
add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_block(n));
} else if ((get_irn_op(a) == op_Eor)
&& (get_irn_mode(a) == mode_b)
- && (classify_tarval(computed_value(get_Eor_right(a))) == TV_CLASSIFY_ONE)) {
+ && (classify_tarval(value_of(get_Eor_right(a))) == TV_CLASSIFY_ONE)) {
/* The Eor is a negate. Generate a new Cond without the negate,
simulate the negate by exchanging the results. */
set_irn_link(n, new_r_Cond(current_ir_graph, get_nodes_block(n),
/* The Eor is a negate. Generate a new Cond without the negate,
simulate the negate by exchanging the results. */
set_irn_link(n, new_r_Cond(current_ir_graph, get_nodes_block(n),
if ((get_irn_mode(n) == mode_b)
&& (get_irn_op(a) == op_Proj)
&& (get_irn_mode(a) == mode_b)
if ((get_irn_mode(n) == mode_b)
&& (get_irn_op(a) == op_Proj)
&& (get_irn_mode(a) == mode_b)
- && (classify_tarval (computed_value (b)) == TV_CLASSIFY_ONE)
+ && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)
&& (get_irn_op(get_Proj_pred(a)) == op_Cmp))
/* The Eor negates a Cmp. The Cmp has the negated result anyways! */
n = new_r_Proj(current_ir_graph, get_nodes_block(n), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a)));
else if ((get_irn_mode(n) == mode_b)
&& (get_irn_op(get_Proj_pred(a)) == op_Cmp))
/* The Eor negates a Cmp. The Cmp has the negated result anyways! */
n = new_r_Proj(current_ir_graph, get_nodes_block(n), get_Proj_pred(a),
mode_b, get_negated_pnc(get_Proj_proj(a)));
else if ((get_irn_mode(n) == mode_b)
- && (classify_tarval (computed_value (b)) == TV_CLASSIFY_ONE))
+ && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE))
/* The Eor is a Not. Replace it by a Not. */
/* ????!!!Extend to bitfield 1111111. */
n = new_r_Not(current_ir_graph, get_nodes_block(n), a, mode_b);
/* The Eor is a Not. Replace it by a Not. */
/* ????!!!Extend to bitfield 1111111. */
n = new_r_Not(current_ir_graph, get_nodes_block(n), a, mode_b);
switch (get_irn_opcode(n)) {
case iro_Div:
b = get_Div_right(n);
switch (get_irn_opcode(n)) {
case iro_Div:
b = get_Div_right(n);
- tb = computed_value(b);
if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* div(x, c) && c != 0 */
proj_nr = get_Proj_proj(proj);
if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* div(x, c) && c != 0 */
proj_nr = get_Proj_proj(proj);
break;
case iro_Mod:
b = get_Mod_right(n);
break;
case iro_Mod:
b = get_Mod_right(n);
- tb = computed_value(b);
if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* mod(x, c) && c != 0 */
proj_nr = get_Proj_proj(proj);
if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* mod(x, c) && c != 0 */
proj_nr = get_Proj_proj(proj);
break;
case iro_DivMod:
b = get_DivMod_right(n);
break;
case iro_DivMod:
b = get_DivMod_right(n);
- tb = computed_value(b);
if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* DivMod(x, c) && c != 0 */
proj_nr = get_Proj_proj(proj);
if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* DivMod(x, c) && c != 0 */
proj_nr = get_Proj_proj(proj);
case iro_Cond:
if (get_opt_unreachable_code()) {
b = get_Cond_selector(n);
case iro_Cond:
if (get_opt_unreachable_code()) {
b = get_Cond_selector(n);
- tb = computed_value(b);
if (tb != tarval_bad && mode_is_int(get_tarval_mode(tb))) {
/* we have a constant switch */
if (tb != tarval_bad && mode_is_int(get_tarval_mode(tb))) {
/* we have a constant switch */
if (get_irn_op(left) != get_irn_op(n))
return n;
if (get_irn_op(left) != get_irn_op(n))
return n;
- tv1 = computed_value(get_binop_right(n));
+ tv1 = value_of(get_binop_right(n));
if (tv1 == tarval_bad)
return n;
if (tv1 == tarval_bad)
return n;
- tv2 = computed_value(get_binop_right(left));
+ tv2 = value_of(get_binop_right(left));
if (tv2 == tarval_bad)
return n;
if (tv2 == tarval_bad)
return n;
/* constants can not be evaluated */
if (iro != iro_Const) {
/* try to evaluate */
/* constants can not be evaluated */
if (iro != iro_Const) {
/* try to evaluate */
- tv = computed_value (n);
+ tv = computed_value(n);
if ((get_irn_mode(n) != mode_T) && (tv != tarval_bad)) {
/*
* we MUST copy the node here temporary, because it's still needed
if ((get_irn_mode(n) != mode_T) && (tv != tarval_bad)) {
/*
* we MUST copy the node here temporary, because it's still needed
/* constants can not be evaluated */
if (iro != iro_Const) {
/* try to evaluate */
/* constants can not be evaluated */
if (iro != iro_Const) {
/* try to evaluate */
- tv = computed_value (n);
+ tv = computed_value(n);
if ((get_irn_mode(n) != mode_T) && (tv != tarval_bad)) {
/* evaluation was successful -- replace the node. */
n = new_Const (get_tarval_mode (tv), tv);
if ((get_irn_mode(n) != mode_T) && (tv != tarval_bad)) {
/* evaluation was successful -- replace the node. */
n = new_Const (get_tarval_mode (tv), tv);
if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
set_Const_type(n, old_tp);
if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
set_Const_type(n, old_tp);
- DBG_OPT_ALGSIM0(oldn, n);
+
+ DBG_OPT_ALGSIM0(oldn, n);