/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
- *
* This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
*/
/**
* @file
* @brief Optimizations regarding Confirm nodes.
* @author Michael Beck
- * @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
#undef DEBUG_CONFIRM
#include "irnode_t.h"
#include "iropt_t.h"
#include "iropt_dbg.h"
-#include "opt_confirms.h"
+#include "iroptimize.h"
#include "irflag_t.h"
#include "irprintf.h"
* such kind of operation, we use border flags allowing
* all intervals.
*/
-typedef struct _interval_t {
- tarval *min; /**< lowest border */
- tarval *max; /**< highest border */
+typedef struct interval_t {
+ ir_tarval *min; /**< lowest border */
+ ir_tarval *max; /**< highest border */
unsigned char flags; /**< border flags */
} interval_t;
#ifdef DEBUG_CONFIRM
-#define compare_iv(l_iv, r_iv, pnc) compare_iv_dbg(l_iv, r_iv, pnc)
+#define compare_iv(l_iv, r_iv, relation) compare_iv_dbg(l_iv, r_iv, relation)
/* forward */
-static tarval *compare_iv_dbg(const interval_t *l_iv, const interval_t *r_iv, pn_Cmp pnc);
+static tarval *compare_iv_dbg(const interval_t *l_iv, const interval_t *r_iv, ir_relation relation);
/* triangle */
-#define DBG_OUT_TR(l_pnc, l_bound, r_pnc, r_bound, pnc, v) \
+#define DBG_OUT_TR(l_relation, l_bound, r_relation, r_bound, relation, v) \
ir_printf("In %e:\na %= %n && b %= %n ==> a %= b == %s\n", \
get_irg_entity(current_ir_graph), \
- l_pnc, l_bound, r_pnc, r_bound, pnc, v);
+ l_relation, l_bound, r_relation, r_bound, relation, v)
/* right side */
-#define DBG_OUT_R(r_pnc, r_bound, left, pnc, right, v) \
+#define DBG_OUT_R(r_relation, r_bound, left, relation, right, v) \
ir_printf("In %e:\na %= %n ==> %n %= %n == %s\n", \
get_irg_entity(current_ir_graph), \
- r_pnc, r_bound, left, pnc, right, v);
+ r_relation, r_bound, left, relation, right, v)
/* left side */
-#define DBG_OUT_L(l_pnc, l_bound, left, pnc, right, v) \
+#define DBG_OUT_L(l_relation, l_bound, left, relation, right, v) \
ir_printf("In %e:\na %= %n ==> %n %= %n == %s\n", \
get_irg_entity(current_ir_graph), \
- l_pnc, l_bound, left, pnc, right, v);
+ l_relation, l_bound, left, relation, right, v)
#else
-#define DBG_OUT_TR(l_pnc, l_bound, r_pnc, r_bound, pnc, v)
-#define DBG_OUT_R(r_pnc, r_bound, left, pnc, right, v)
-#define DBG_OUT_L(l_pnc, l_bound, left, pnc, right, v)
+#define DBG_OUT_TR(l_relation, l_bound, r_relation, r_bound, relation, v) (void)0
+#define DBG_OUT_R(r_relation, r_bound, left, relation, right, v) (void)0
+#define DBG_OUT_L(l_relation, l_bound, left, relation, right, v) (void)0
#endif /* DEBUG_CONFIRM */
* This is a often needed case, so we handle here Confirm
* nodes too.
*/
-int value_not_zero(ir_node *n, ir_node **confirm) {
-#define RET_ON(x) if (x) { *confirm = n; return 1; }; break
+int value_not_zero(const ir_node *n, const ir_node **confirm)
+{
+#define RET_ON(x) if (x) { *confirm = n; return 1; } break
- tarval *tv;
+ ir_tarval *tv;
ir_mode *mode = get_irn_mode(n);
- pn_Cmp pnc;
+ ir_relation relation;
*confirm = NULL;
/* there might be several Confirms one after other that form an interval */
- for (; is_Confirm(n); n = get_Confirm_value(n)) {
+ for (;;) {
+ if (is_Minus(n)) {
+ /* we can safely skip Minus when checking for != 0 */
+ n = get_unop_op(n);
+ continue;
+ }
+ if (! is_Confirm(n))
+ break;
+
/*
* Note: A Confirm is never after a Const. So,
* we simply can check the bound for being a Const
* without the fear that is might be hidden by a further Confirm.
*/
tv = value_of(get_Confirm_bound(n));
- if (tv == tarval_bad)
- return 0;
+ if (tv == tarval_bad) {
+ n = get_Confirm_value(n);
+ continue;
+ }
- pnc = tarval_cmp(tv, get_mode_null(mode));
+ relation = tarval_cmp(tv, get_mode_null(mode));
/*
* Beware: C might by a NaN. It is not clear, what we should do
*
* Note that only the C != 0 case need additional checking.
*/
- switch (get_Confirm_cmp(n)) {
- case pn_Cmp_Eq: /* n == C /\ C != 0 ==> n != 0 */
- RET_ON(pnc != pn_Cmp_Eq && pnc != pn_Cmp_Uo);
- case pn_Cmp_Lg: /* n != C /\ C == 0 ==> n != 0 */
- RET_ON(pnc == pn_Cmp_Eq);
- case pn_Cmp_Lt: /* n < C /\ C <= 0 ==> n != 0 */
- RET_ON(pnc == pn_Cmp_Lt || pnc == pn_Cmp_Eq);
- case pn_Cmp_Le: /* n <= C /\ C < 0 ==> n != 0 */
- RET_ON(pnc == pn_Cmp_Lt);
- case pn_Cmp_Ge: /* n >= C /\ C > 0 ==> n != 0 */
- RET_ON(pnc == pn_Cmp_Gt);
- case pn_Cmp_Gt: /* n > C /\ C >= 0 ==> n != 0 */
- RET_ON(pnc == pn_Cmp_Gt || pnc == pn_Cmp_Eq);
+ switch (get_Confirm_relation(n)) {
+ case ir_relation_equal: /* n == C /\ C != 0 ==> n != 0 */
+ RET_ON(relation != ir_relation_equal && relation != ir_relation_unordered);
+ case ir_relation_less_greater: /* n != C /\ C == 0 ==> n != 0 */
+ RET_ON(relation == ir_relation_equal);
+ case ir_relation_less: /* n < C /\ C <= 0 ==> n != 0 */
+ RET_ON(relation == ir_relation_less || relation == ir_relation_equal);
+ case ir_relation_less_equal: /* n <= C /\ C < 0 ==> n != 0 */
+ RET_ON(relation == ir_relation_less);
+ case ir_relation_greater_equal: /* n >= C /\ C > 0 ==> n != 0 */
+ RET_ON(relation == ir_relation_greater);
+ case ir_relation_greater: /* n > C /\ C >= 0 ==> n != 0 */
+ RET_ON(relation == ir_relation_greater || relation == ir_relation_equal);
default:
break;
}
+ n = get_Confirm_value(n);
}
- tv = value_of(n);
+ /* global entities are never NULL */
+ if (is_SymConst_addr_ent(n))
+ return true;
+ tv = value_of(n);
if (tv == tarval_bad)
- return 0;
+ return false;
- pnc = tarval_cmp(tv, get_mode_null(mode));
+ relation = tarval_cmp(tv, get_mode_null(mode));
/* again, need check for NaN */
- return (pnc != pn_Cmp_Eq) && (pnc != pn_Cmp_Uo);
+ return (relation != ir_relation_equal) && (relation != ir_relation_unordered);
#undef RET_ON
-} /* value_not_zero */
+}
/*
* Check, if the value of a node cannot represent a NULL pointer.
*
- * - Casts are skipped
- * - If sel_based_null_check_elim is enabled, all
- * Sel nodes can be skipped.
+ * - Sels are skipped
* - A SymConst(entity) is NEVER a NULL pointer
* - Confirms are evaluated
*/
-int value_not_null(ir_node *n, ir_node **confirm) {
- ir_op *op;
+int value_not_null(const ir_node *n, const ir_node **confirm)
+{
+ ir_tarval *tv;
*confirm = NULL;
- n = skip_Cast(n);
- op = get_irn_op(n);
+ tv = value_of(n);
+ if (tarval_is_constant(tv) && ! tarval_is_null(tv))
+ return 1;
+
assert(mode_is_reference(get_irn_mode(n)));
- if (get_opt_sel_based_null_check_elim()) {
- /* skip all Sel nodes and Cast's */
- while (op == op_Sel) {
- n = skip_Cast(get_Sel_ptr(n));
- op = get_irn_op(n);
- }
+ /* skip all Sel nodes */
+ while (is_Sel(n)) {
+ n = get_Sel_ptr(n);
}
- if (op == op_SymConst && get_SymConst_kind(n) == symconst_addr_ent)
+ while (1) {
+ if (is_Proj(n)) { n = get_Proj_pred(n); continue; }
+ break;
+ }
+
+ if (is_SymConst_addr_ent(n)) {
+ /* global references are never NULL */
+ return 1;
+ } else if (n == get_irg_frame(get_irn_irg(n))) {
+ /* local references are never NULL */
+ return 1;
+ } else if (is_Alloc(n)) {
+ /* alloc never returns NULL (it throws an exception instead) */
return 1;
- if (op == op_Const) {
- if (!is_Const_null(n))
- return 1;
} else {
- for (; is_Confirm(n); n = skip_Cast(get_Confirm_value(n))) {
- if (get_Confirm_cmp(n) != pn_Cmp_Lg) {
- ir_node *bound = get_Confirm_bound(n);
- if (is_Const(bound) && is_Const_null(bound)) {
+ /* check for more Confirms */
+ for (; is_Confirm(n); n = get_Confirm_value(n)) {
+ if (get_Confirm_relation(n) == ir_relation_less_greater) {
+ ir_node *bound = get_Confirm_bound(n);
+ ir_tarval *tv = value_of(bound);
+
+ if (tarval_is_null(tv)) {
*confirm = n;
return 1;
}
}
}
return 0;
-} /* value_not_null */
+}
+
+#ifdef __cplusplus
+extern "C++" {
+ static inline ir_value_classify_sign operator *(ir_value_classify_sign sign, int mul) {
+ return (ir_value_classify_sign) (sign*mul);
+ }
+}
+#endif
/*
* Check, if the value of a node can be confirmed >= 0 or <= 0,
* If the mode of the value did not honor signed zeros, else
* check for >= 0 or < 0.
*/
-value_classify_sign classify_value_sign(ir_node *n) {
- tarval *tv, *c;
+ir_value_classify_sign classify_value_sign(ir_node *n)
+{
+ ir_tarval *tv, *c;
ir_mode *mode;
- pn_Cmp cmp, ncmp;
-
- if (get_irn_op(n) != op_Confirm)
+ ir_relation cmp, ncmp;
+ int negate = 1;
+
+ for (;;) {
+ unsigned code = get_irn_opcode(n);
+
+ switch (code) {
+ case iro_Minus:
+ negate *= -1;
+ n = get_Minus_op(n);
+ continue;
+ case iro_Confirm:
+ break;
+ default:
+ return value_classified_unknown;
+ }
+ break;
+ }
+ if (!is_Confirm(n))
return value_classified_unknown;
tv = value_of(get_Confirm_bound(n));
* optimization possibilities, so we handle this
* different.
*/
- cmp = get_Confirm_cmp(n);
+ cmp = get_Confirm_relation(n);
switch (cmp) {
- case pn_Cmp_Lt:
+ case ir_relation_less:
/*
* must be x < c <= 1 to be useful if integer mode and -0 = 0
* x < c <= 0 to be useful else
*/
- case pn_Cmp_Le:
+ case ir_relation_less_equal:
/*
* must be x <= c < 1 to be useful if integer mode and -0 = 0
* x <= c < 0 to be useful else
get_mode_one(mode) : get_mode_null(mode);
ncmp = tarval_cmp(tv, c);
- if (ncmp == pn_Cmp_Eq)
- ncmp = pn_Cmp_Le;
+ if (ncmp == ir_relation_equal)
+ ncmp = ir_relation_less_equal;
- if (cmp != (ncmp ^ pn_Cmp_Eq))
+ if (cmp != (ncmp ^ ir_relation_equal))
return value_classified_unknown;
/* yep, negative */
- return value_classified_negative;
+ return value_classified_negative * negate;
- case pn_Cmp_Ge:
+ case ir_relation_greater_equal:
/*
* must be x >= c > -1 to be useful if integer mode
* x >= c >= 0 to be useful else
*/
- case pn_Cmp_Gt:
+ case ir_relation_greater:
/*
* must be x > c >= -1 to be useful if integer mode
* x > c >= 0 to be useful else
c = get_mode_minus_one(mode);
ncmp = tarval_cmp(tv, c);
- if (ncmp == pn_Cmp_Eq)
- ncmp = pn_Cmp_Ge;
+ if (ncmp == ir_relation_equal)
+ ncmp = ir_relation_greater_equal;
- if (cmp != (ncmp ^ pn_Cmp_Eq))
+ if (cmp != (ncmp ^ ir_relation_equal))
return value_classified_unknown;
} else {
c = get_mode_minus_one(mode);
ncmp = tarval_cmp(tv, c);
- if (ncmp != pn_Cmp_Eq && ncmp != pn_Cmp_Gt)
+ if (ncmp != ir_relation_equal && ncmp != ir_relation_greater)
return value_classified_unknown;
}
/* yep, positive */
- return value_classified_positive;
+ return value_classified_positive * negate;
default:
return value_classified_unknown;
}
-} /* classify_value_sign */
+}
/**
* construct an interval from a value
* @return the filled interval or NULL if no interval
* can be created (happens only on floating point
*/
-static interval_t *get_interval_from_tv(interval_t *iv, tarval *tv) {
+static interval_t *get_interval_from_tv(interval_t *iv, ir_tarval *tv)
+{
ir_mode *mode = get_tarval_mode(tv);
if (tv == tarval_bad) {
iv->flags = MIN_INCLUDED | MAX_INCLUDED;
return iv;
-} /* get_interval_from_tv */
+}
/**
* construct an interval from a Confirm
*
- * @param iv an empty interval, will be filled
- * @param bound the bound value
- * @param pnc the Confirm compare relation
+ * @param iv an empty interval, will be filled
+ * @param bound the bound value
+ * @param relation the Confirm compare relation
*
* @return the filled interval or NULL if no interval
* can be created (happens only on floating point
*/
-static interval_t *get_interval(interval_t *iv, ir_node *bound, pn_Cmp pnc) {
- ir_mode *mode = get_irn_mode(bound);
- tarval *tv = value_of(bound);
+static interval_t *get_interval(interval_t *iv, ir_node *bound, ir_relation relation)
+{
+ ir_mode *mode = get_irn_mode(bound);
+ ir_tarval *tv = value_of(bound);
if (tv == tarval_bad) {
/* There is nothing we could do here. For integer
}
/* check which side is known */
- switch (pnc) {
- case pn_Cmp_Eq:
+ switch (relation) {
+ case ir_relation_equal:
/* [tv, tv] */
iv->min =
iv->max = tv;
iv->flags = MIN_INCLUDED | MAX_INCLUDED;
break;
- case pn_Cmp_Le:
+ case ir_relation_less_equal:
/* [-oo, tv] */
iv->min = get_mode_min(mode);
iv->max = tv;
iv->flags = MIN_INCLUDED | MAX_INCLUDED;
break;
- case pn_Cmp_Lt:
+ case ir_relation_less:
/* [-oo, tv) */
iv->min = get_mode_min(mode);
iv->max = tv;
iv->flags = MIN_INCLUDED | MAX_EXCLUDED;
break;
- case pn_Cmp_Gt:
+ case ir_relation_greater:
/* (tv, +oo] */
iv->min = tv;
iv->max = get_mode_max(mode);
iv->flags = MIN_EXCLUDED | MAX_INCLUDED;
break;
- case pn_Cmp_Ge:
+ case ir_relation_greater_equal:
/* [tv, +oo] */
iv->min = tv;
iv->max = get_mode_max(mode);
iv->flags = MIN_INCLUDED | MAX_INCLUDED;
break;
- case pn_Cmp_Leg:
+ case ir_relation_less_equal_greater:
/*
* Ordered means, that at least neither
* our bound nor our value ara NaN's
if (iv->min != tarval_bad && iv->max != tarval_bad)
return iv;
return NULL;
-} /* get_interval */
+}
/**
- * Try to evaluate l_iv pnc r_iv.
+ * Try to evaluate l_iv relation r_iv.
*
- * @param l_iv the left interval
- * @param r_iv the right interval
- * @param pnc the compare relation
+ * @param l_iv the left interval
+ * @param r_iv the right interval
+ * @param relation the compare relation
*
* @return
* tarval_b_true or tarval_b_false it it can be evaluated,
* tarval_bad else
*/
-static tarval *(compare_iv)(const interval_t *l_iv, const interval_t *r_iv, pn_Cmp pnc) {
- pn_Cmp res;
- unsigned flags;
- tarval *tv_true = tarval_b_true, *tv_false = tarval_b_false;
+static ir_tarval *(compare_iv)(const interval_t *l_iv, const interval_t *r_iv, ir_relation relation)
+{
+ ir_relation res;
+ unsigned flags;
+ ir_tarval *tv_true = tarval_b_true, *tv_false = tarval_b_false;
/* if one interval contains NaNs, we cannot evaluate anything */
if (! l_iv || ! r_iv)
return tarval_bad;
/* we can only check ordered relations */
- if (pnc & pn_Cmp_Uo) {
- tarval *t;
+ if (relation & ir_relation_unordered) {
+ ir_tarval *t;
- pnc = get_negated_pnc(pnc, get_tarval_mode(l_iv->min));
+ relation = get_negated_relation(relation);
t = tv_true;
tv_true = tv_false;
tv_false = t;
}
/* if we have > or >=, we do the inverse to save some cases */
- if (pnc == pn_Cmp_Ge || pnc == pn_Cmp_Gt) {
+ if (relation == ir_relation_greater_equal || relation == ir_relation_greater) {
const interval_t *t;
- pnc = get_inversed_pnc(pnc);
- t = l_iv;
- l_iv = r_iv;
- r_iv = t;
+ relation = get_inversed_relation(relation);
+ t = l_iv;
+ l_iv = r_iv;
+ r_iv = t;
}
/* now, only the following cases remains */
- switch (pnc) {
- case pn_Cmp_Eq:
+ switch (relation) {
+ case ir_relation_equal:
/* two intervals can be compared for equality only if they are a single value */
if (l_iv->min == l_iv->max && r_iv->min == r_iv->max)
- return tarval_cmp(l_iv->min, r_iv->min) == pn_Cmp_Eq ? tv_true : tv_false;
+ return tarval_cmp(l_iv->min, r_iv->min) == ir_relation_equal ? tv_true : tv_false;
/* if both intervals do not intersect, it is never equal */
res = tarval_cmp(l_iv->max, r_iv->min);
/* b < c ==> [a,b] != [c,d] */
- if (res == pn_Cmp_Lt)
+ if (res == ir_relation_less)
return tv_false;
/* b <= c ==> [a,b) != [c,d] AND [a,b] != (c,d] */
if ((l_iv->flags & MAX_EXCLUDED || r_iv->flags & MIN_EXCLUDED)
- && (res == pn_Cmp_Eq))
+ && (res == ir_relation_equal))
return tv_false;
res = tarval_cmp(r_iv->max, l_iv->min);
/* d < a ==> [c,d] != [a,b] */
- if (res == pn_Cmp_Lt)
+ if (res == ir_relation_less)
return tv_false;
/* d <= a ==> [c,d) != [a,b] AND [c,d] != (a,b] */
if ((r_iv->flags & MAX_EXCLUDED || l_iv->flags & MIN_EXCLUDED)
- && (res == pn_Cmp_Eq))
+ && (res == ir_relation_equal))
return tv_false;
break;
- case pn_Cmp_Lg:
+ case ir_relation_less_greater:
/* two intervals can be compared for not equality only if they are a single value */
if (l_iv->min == l_iv->max && r_iv->min == r_iv->max)
- return tarval_cmp(l_iv->min, r_iv->min) != pn_Cmp_Eq ? tv_true : tv_false;
+ return tarval_cmp(l_iv->min, r_iv->min) != ir_relation_equal ? tv_true : tv_false;
break;
- case pn_Cmp_Lt:
+ case ir_relation_less:
res = tarval_cmp(l_iv->max, r_iv->min);
/* [a, b] < [c, d] <==> b < c */
- if (res == pn_Cmp_Lt)
+ if (res == ir_relation_less)
return tv_true;
/* if one border is excluded, b <= c is enough */
if ((l_iv->flags & MAX_EXCLUDED || r_iv->flags & MIN_EXCLUDED) &&
- res == pn_Cmp_Eq)
+ res == ir_relation_equal)
return tv_true;
/* [a, b] >= [c, d] <==> a > d */
res = tarval_cmp(l_iv->min, r_iv->max);
- if (res == pn_Cmp_Gt)
+ if (res == ir_relation_greater)
return tv_false;
/* if one border is excluded, a >= d is enough */
if ((l_iv->flags & MIN_EXCLUDED || r_iv->flags & MAX_EXCLUDED) &&
- res == pn_Cmp_Eq)
+ res == ir_relation_equal)
return tv_false;
break;
- case pn_Cmp_Le:
+ case ir_relation_less_equal:
/* [a, b) <= [c, d] or [a, b] <= (c, d] <==> b <= c */
flags = (l_iv->flags & MAX_EXCLUDED) | (r_iv->flags & MIN_EXCLUDED);
if (flags) {
res = tarval_cmp(l_iv->max, r_iv->min);
- if (res == pn_Cmp_Lt || res == pn_Cmp_Eq)
+ if (res == ir_relation_less || res == ir_relation_equal)
return tv_true;
}
res = tarval_cmp(l_iv->min, r_iv->max);
/* [a, b] > [c, d] <==> a > d */
- if (res == pn_Cmp_Gt)
+ if (res == ir_relation_greater)
return tv_false;
/* if one border is excluded, a >= d is enough */
if ((l_iv->flags & MIN_EXCLUDED || r_iv->flags & MAX_EXCLUDED) &&
- res == pn_Cmp_Eq)
+ res == ir_relation_equal)
return tv_false;
break;
- case pn_Cmp_Leg:
+ case ir_relation_less_equal_greater:
/* Hmm. if both are intervals, we can find an order */
return tv_true;
return tarval_bad;
}
return tarval_bad;
-} /* compare_iv */
+}
/**
* Returns non-zero, if a given relation is transitive.
*/
-static int is_transitive(pn_Cmp pnc) {
- return (pn_Cmp_False < pnc && pnc < pn_Cmp_Lg);
-} /* is_transitive */
+static int is_transitive(ir_relation relation)
+{
+ return (ir_relation_false < relation && relation < ir_relation_less_greater);
+}
/**
* Return the value of a Cmp if one or both predecessors
* are Confirm nodes.
*
- * @param cmp the Cmp node
- * @param left the left operand of the Cmp
- * @param right the right operand of the Cmp
- * @param pnc the compare relation
+ * @param cmp the Cmp node
+ * @param left the left operand of the Cmp
+ * @param right the right operand of the Cmp
+ * @param relation the compare relation
*/
-tarval *computed_value_Cmp_Confirm(ir_node *cmp, ir_node *left, ir_node *right, pn_Cmp pnc) {
- ir_node *l_bound;
- pn_Cmp l_pnc, res_pnc, neg_pnc;
- interval_t l_iv, r_iv;
- tarval *tv;
- ir_mode *mode;
+ir_tarval *computed_value_Cmp_Confirm(const ir_node *cmp, ir_node *left, ir_node *right, ir_relation relation)
+{
+ ir_node *l_bound;
+ ir_relation l_relation, res_relation, neg_relation;
+ interval_t l_iv, r_iv;
+ ir_tarval *tv;
if (is_Confirm(right)) {
/* we want the Confirm on the left side */
right = left;
left = t;
- pnc = get_inversed_pnc(pnc);
+ relation = get_inversed_relation(relation);
} else if (! is_Confirm(left)) {
- /* no Confirm on either one side, finish */
- return tarval_bad;
+ /* nothing more found */
+ tv = tarval_bad;
+ goto check_null_case;
}
/* ok, here at least left is a Confirm, right might be */
- l_bound = get_Confirm_bound(left);
- l_pnc = get_Confirm_cmp(left);
+ l_bound = get_Confirm_bound(left);
+ l_relation = get_Confirm_relation(left);
if (is_Confirm(right)) {
/*
* both sides are Confirm's. Check some rare cases first.
*/
- ir_node *r_bound = get_Confirm_bound(right);
- pn_Cmp r_pnc = get_Confirm_cmp(right);
+ ir_node *r_bound = get_Confirm_bound(right);
+ ir_relation r_relation = get_Confirm_relation(right);
/*
* some check can be made WITHOUT constant bounds
*/
if (r_bound == l_bound) {
- if (is_transitive(l_pnc)) {
- pn_Cmp r_inc_pnc = get_inversed_pnc(r_pnc);
+ if (is_transitive(l_relation)) {
+ ir_relation r_inc_relation = get_inversed_relation(r_relation);
/*
* triangle inequality:
*
* We handle correctly cases with some <=/>= here
*/
- if ((l_pnc & ~pn_Cmp_Eq) == (r_inc_pnc & ~pn_Cmp_Eq)) {
- res_pnc = (l_pnc & ~pn_Cmp_Eq) | (l_pnc & r_inc_pnc & pn_Cmp_Eq);
+ if ((l_relation & ~ir_relation_equal) == (r_inc_relation & ~ir_relation_equal)) {
+ res_relation = (l_relation & ~ir_relation_equal) | (l_relation & r_inc_relation & ir_relation_equal);
- if ((pnc == res_pnc) || ((pnc & ~pn_Cmp_Eq) == res_pnc)) {
- DBG_OUT_TR(l_pnc, l_bound, r_pnc, r_bound, pnc, "true");
+ if ((relation == res_relation) || ((relation & ~ir_relation_equal) == res_relation)) {
+ DBG_OUT_TR(l_relation, l_bound, r_relation, r_bound, relation, "true");
DBG_EVAL_CONFIRM(cmp);
return tarval_b_true;
} else {
- pn_Cmp neg_pnc = get_negated_pnc(pnc, get_irn_mode(left));
+ ir_relation neg_relation = get_negated_relation(relation);
- if ((neg_pnc == res_pnc) || ((neg_pnc & ~pn_Cmp_Eq) == res_pnc)) {
- DBG_OUT_TR(l_pnc, l_bound, r_pnc, r_bound, pnc, "false");
+ if ((neg_relation == res_relation) || ((neg_relation & ~ir_relation_equal) == res_relation)) {
+ DBG_OUT_TR(l_relation, l_bound, r_relation, r_bound, relation, "false");
DBG_EVAL_CONFIRM(cmp);
return tarval_b_false;
}
*/
if (left == r_bound) {
/*
- * l == bound(r) AND pnc(r) == pnc:
+ * l == bound(r) AND relation(r) == relation:
*
* We know that a CMP b and check for that
*/
- if ((r_pnc == pnc) || (r_pnc == (pnc & ~pn_Cmp_Eq))) {
- DBG_OUT_R(r_pnc, r_bound, left, pnc, right, "true");
+ if ((r_relation == relation) || (r_relation == (relation & ~ir_relation_equal))) {
+ DBG_OUT_R(r_relation, r_bound, left, relation, right, "true");
DBG_EVAL_CONFIRM(cmp);
return tarval_b_true;
}
/*
- * l == bound(r) AND pnc(r) != pnc:
+ * l == bound(r) AND relation(r) != relation:
*
* We know that a CMP b and check for a ~CMP b
*/
else {
- mode = get_irn_mode(left);
- neg_pnc = get_negated_pnc(pnc, mode);
+ neg_relation = get_negated_relation(relation);
- if ((r_pnc == neg_pnc) || (r_pnc == (neg_pnc & ~pn_Cmp_Eq))) {
- DBG_OUT_R(r_pnc, r_bound, left, pnc, right, "false");
+ if ((r_relation == neg_relation) || (r_relation == (neg_relation & ~ir_relation_equal))) {
+ DBG_OUT_R(r_relation, r_bound, left, relation, right, "false");
DBG_EVAL_CONFIRM(cmp);
return tarval_b_false;
}
/* now, try interval magic */
tv = compare_iv(
- get_interval(&l_iv, l_bound, l_pnc),
- get_interval(&r_iv, r_bound, r_pnc),
- pnc);
+ get_interval(&l_iv, l_bound, l_relation),
+ get_interval(&r_iv, r_bound, r_relation),
+ relation);
if (tv != tarval_bad) {
DBG_EVAL_CONFIRM(cmp);
*/
if (right == l_bound) {
/*
- * r == bound(l) AND pnc(l) == pnc:
+ * r == bound(l) AND relation(l) == relation:
*
* We know that a CMP b and check for that
*/
- if ((l_pnc == pnc) || (l_pnc == (pnc & ~pn_Cmp_Eq))) {
- DBG_OUT_L(l_pnc, l_bound, left, pnc, right, "true");
+ if ((l_relation == relation) || (l_relation == (relation & ~ir_relation_equal))) {
+ DBG_OUT_L(l_relation, l_bound, left, relation, right, "true");
DBG_EVAL_CONFIRM(cmp);
return tarval_b_true;
}
/*
- * r == bound(l) AND pnc(l) is Not(pnc):
+ * r == bound(l) AND relation(l) is Not(relation):
*
* We know that a CMP b and check for a ~CMP b
*/
else {
- mode = get_irn_mode(left);
- neg_pnc = get_negated_pnc(pnc, mode);
+ neg_relation = get_negated_relation(relation);
- if ((l_pnc == neg_pnc) || (l_pnc == (neg_pnc & ~pn_Cmp_Eq))) {
- DBG_OUT_L(l_pnc, l_bound, left, pnc, right, "false");
+ if ((l_relation == neg_relation) || (l_relation == (neg_relation & ~ir_relation_equal))) {
+ DBG_OUT_L(l_relation, l_bound, left, relation, right, "false");
DBG_EVAL_CONFIRM(cmp);
return tarval_b_false;
}
if (tv != tarval_bad) {
tv = compare_iv(
- get_interval(&l_iv, l_bound, l_pnc),
+ get_interval(&l_iv, l_bound, l_relation),
get_interval_from_tv(&r_iv, tv),
- pnc);
+ relation);
+ } else {
+check_null_case:
+ /* check some other cases */
+ if ((relation == ir_relation_equal || relation == ir_relation_less_greater) &&
+ is_Const(right) && is_Const_null(right)) {
+ /* for == 0 or != 0 we have some special tools */
+ ir_mode *mode = get_irn_mode(left);
+ const ir_node *dummy;
+ if (mode_is_reference(mode)) {
+ if (value_not_null(left, &dummy)) {
+ tv = relation == ir_relation_equal ? tarval_b_false : tarval_b_true;
+ }
+ } else {
+ if (value_not_zero(left, &dummy)) {
+ tv = relation == ir_relation_equal ? tarval_b_false : tarval_b_true;
+ }
+ }
+ }
}
if (tv != tarval_bad)
DBG_EVAL_CONFIRM(cmp);
return tv;
-} /* computed_value_Cmp_Confirm */
+}
#ifdef DEBUG_CONFIRM
/**
* @param len length of the string buffer
* @param iv the interval
*/
-static int iv_snprintf(char *buf, size_t len, const interval_t *iv) {
+static int iv_snprintf(char *buf, size_t len, const interval_t *iv)
+{
char smin[64], smax[64];
if (iv) {
return snprintf(buf, len, "%s", smin);
}
return snprintf(buf, len, "<UNKNOWN>");
-} /* iv_snprintf */
+}
/**
* For debugging. Prints an interval compare.
*
- * @param l_iv the left interval
- * @param r_iv the right interval
- * @param pnc the compare relation
+ * @param l_iv the left interval
+ * @param r_iv the right interval
+ * @param relation the compare relation
*/
-static void print_iv_cmp(const interval_t *l_iv, const interval_t *r_iv, pn_Cmp pnc) {
+static void print_iv_cmp(const interval_t *l_iv, const interval_t *r_iv, ir_relation relation)
+{
char sl[128], sr[128];
iv_snprintf(sl, sizeof(sl), l_iv);
iv_snprintf(sr, sizeof(sr), r_iv);
- ir_printf("%s %= %s", sl, pnc, sr);
-} /* print_iv_cmp */
+ ir_printf("%s %= %s", sl, relation, sr);
+}
/**
* For debugging. call *compare_iv() and prints inputs and result.
*
- * @param l_iv the left interval
- * @param r_iv the right interval
- * @param pnc the compare relation
+ * @param l_iv the left interval
+ * @param r_iv the right interval
+ * @param relation the compare relation
*/
-static tarval *compare_iv_dbg(const interval_t *l_iv, const interval_t *r_iv, pn_Cmp pnc) {
- tarval *tv = (compare_iv)(l_iv, r_iv, pnc);
+static tarval *compare_iv_dbg(const interval_t *l_iv, const interval_t *r_iv, ir_relation relation)
+{
+ tarval *tv = (compare_iv)(l_iv, r_iv, relation);
if (tv == tarval_bad)
return tv;
ir_printf("In %e:\n", get_irg_entity(current_ir_graph));
- print_iv_cmp(l_iv, r_iv, pnc);
+ print_iv_cmp(l_iv, r_iv, relation);
ir_printf(" = %T\n", tv);
return tv;
-} /* compare_iv_dbg */
+}
#endif /* DEBUG_CONFIRM */
projects / libfirm / blobdiff