@@ -147,7 +147,8 @@ vr_values::get_lattice_entry (const_tree var)
return NULL. Otherwise create an empty range if none existed for VAR. */
const value_range_equiv *
-vr_values::get_value_range (const_tree var)
+vr_values::get_value_range (const_tree var,
+ gimple *stmt ATTRIBUTE_UNUSED)
{
/* If we have no recorded ranges, then return NULL. */
if (!vr_value)
@@ -450,7 +451,7 @@ simplify_using_ranges::op_with_boolean_value_range_p (tree op)
/* ?? Errr, this should probably check for [0,0] and [1,1] as well
as [0,1]. */
- const value_range *vr = get_value_range (op);
+ const value_range *vr = get_value_range (op, NULL);
return *vr == value_range (build_zero_cst (TREE_TYPE (op)),
build_one_cst (TREE_TYPE (op)));
}
@@ -972,12 +973,13 @@ vr_values::extract_range_from_cond_expr (value_range_equiv *vr, gassign *stmt)
void
vr_values::extract_range_from_comparison (value_range_equiv *vr,
+ gimple *stmt,
enum tree_code code,
tree type, tree op0, tree op1)
{
bool sop;
tree val
- = simplifier.vrp_evaluate_conditional_warnv_with_ops (code, op0, op1,
+ = simplifier.vrp_evaluate_conditional_warnv_with_ops (stmt, code, op0, op1,
false, &sop, NULL);
if (val)
{
@@ -1008,14 +1010,14 @@ check_for_binary_op_overflow (vr_values *store,
{
value_range vr0, vr1;
if (TREE_CODE (op0) == SSA_NAME)
- vr0 = *store->get_value_range (op0);
+ vr0 = *store->get_value_range (op0, NULL);
else if (TREE_CODE (op0) == INTEGER_CST)
vr0.set (op0);
else
vr0.set_varying (TREE_TYPE (op0));
if (TREE_CODE (op1) == SSA_NAME)
- vr1 = *store->get_value_range (op1);
+ vr1 = *store->get_value_range (op1, NULL);
else if (TREE_CODE (op1) == INTEGER_CST)
vr1.set (op1);
else
@@ -1472,7 +1474,7 @@ vr_values::extract_range_from_assignment (value_range_equiv *vr, gassign *stmt)
else if (code == COND_EXPR)
extract_range_from_cond_expr (vr, stmt);
else if (TREE_CODE_CLASS (code) == tcc_comparison)
- extract_range_from_comparison (vr, gimple_assign_rhs_code (stmt),
+ extract_range_from_comparison (vr, stmt, gimple_assign_rhs_code (stmt),
gimple_expr_type (stmt),
gimple_assign_rhs1 (stmt),
gimple_assign_rhs2 (stmt));
@@ -1805,7 +1807,7 @@ vr_values::adjust_range_with_scev (value_range_equiv *vr, class loop *loop,
if (TREE_CODE (step) == INTEGER_CST
&& is_gimple_val (init)
&& (TREE_CODE (init) != SSA_NAME
- || get_value_range (init)->kind () == VR_RANGE))
+ || get_value_range (init, stmt)->kind () == VR_RANGE))
{
widest_int nit;
@@ -1838,7 +1840,7 @@ vr_values::adjust_range_with_scev (value_range_equiv *vr, class loop *loop,
value_range initvr;
if (TREE_CODE (init) == SSA_NAME)
- initvr = *(get_value_range (init));
+ initvr = *(get_value_range (init, stmt));
else if (is_gimple_min_invariant (init))
initvr.set (init);
else
@@ -2090,7 +2092,7 @@ const value_range_equiv *
simplify_using_ranges::get_vr_for_comparison (int i, value_range_equiv *tem)
{
/* Shallow-copy equiv bitmap. */
- const value_range_equiv *vr = get_value_range (ssa_name (i));
+ const value_range_equiv *vr = get_value_range (ssa_name (i), NULL);
/* If name N_i does not have a valid range, use N_i as its own
range. This allows us to compare against names that may
@@ -2115,7 +2117,7 @@ simplify_using_ranges::compare_name_with_value
bool *strict_overflow_p, bool use_equiv_p)
{
/* Get the set of equivalences for VAR. */
- bitmap e = get_value_range (var)->equiv ();
+ bitmap e = get_value_range (var, NULL)->equiv ();
/* Start at -1. Set it to 0 if we do a comparison without relying
on overflow, or 1 if all comparisons rely on overflow. */
@@ -2195,8 +2197,8 @@ simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2,
{
/* Compare the ranges of every name equivalent to N1 against the
ranges of every name equivalent to N2. */
- bitmap e1 = get_value_range (n1)->equiv ();
- bitmap e2 = get_value_range (n2)->equiv ();
+ bitmap e1 = get_value_range (n1, NULL)->equiv ();
+ bitmap e2 = get_value_range (n2, NULL)->equiv ();
/* Use the fake bitmaps if e1 or e2 are not available. */
static bitmap s_e1 = NULL, s_e2 = NULL;
@@ -2308,8 +2310,8 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops_using_ranges
(enum tree_code code, tree op0, tree op1, bool * strict_overflow_p)
{
const value_range_equiv *vr0, *vr1;
- vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0) : NULL;
- vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1) : NULL;
+ vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0, NULL) : NULL;
+ vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1, NULL) : NULL;
tree res = NULL_TREE;
if (vr0 && vr1)
@@ -2326,7 +2328,8 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops_using_ranges
tree
simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
- (enum tree_code code,
+ (gimple *stmt,
+ enum tree_code code,
tree op0, tree op1,
bool use_equiv_p,
bool *strict_overflow_p,
@@ -2387,7 +2390,7 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
}
else
gcc_unreachable ();
- const value_range_equiv *vr0 = get_value_range (op0);
+ const value_range_equiv *vr0 = get_value_range (op0, stmt);
/* If vro, the range for OP0 to pass the overflow test, has
no intersection with *vr0, OP0's known range, then the
overflow test can't pass, so return the node for false.
@@ -2449,8 +2452,8 @@ simplify_using_ranges::vrp_evaluate_conditional (tree_code code, tree op0,
return NULL_TREE;
sop = false;
- ret = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, true, &sop,
- &only_ranges);
+ ret = vrp_evaluate_conditional_warnv_with_ops (stmt, code, op0, op1, true,
+ &sop, &only_ranges);
if (ret && sop)
{
@@ -2493,7 +2496,7 @@ simplify_using_ranges::vrp_evaluate_conditional (tree_code code, tree op0,
always fold regardless of the value of OP0. If -Wtype-limits
was specified, emit a warning. */
tree type = TREE_TYPE (op0);
- const value_range_equiv *vr0 = get_value_range (op0);
+ const value_range_equiv *vr0 = get_value_range (op0, stmt);
if (vr0->varying_p ()
&& INTEGRAL_TYPE_P (type)
@@ -2544,7 +2547,7 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
fprintf (dump_file, "\t");
print_generic_expr (dump_file, use);
fprintf (dump_file, ": ");
- dump_value_range (dump_file, get_value_range (use));
+ dump_value_range (dump_file, get_value_range (use, stmt));
}
fprintf (dump_file, "\n");
@@ -2594,7 +2597,8 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
4 more predicates folded in SPEC. */
bool sop;
- val = vrp_evaluate_conditional_warnv_with_ops (gimple_cond_code (stmt),
+ val = vrp_evaluate_conditional_warnv_with_ops (stmt,
+ gimple_cond_code (stmt),
gimple_cond_lhs (stmt),
gimple_cond_rhs (stmt),
false, &sop, NULL);
@@ -3119,7 +3123,7 @@ simplify_using_ranges::simplify_div_or_mod_using_ranges
}
else
{
- vr = get_value_range (op0);
+ vr = get_value_range (op0, stmt);
if (range_int_cst_p (vr))
{
op0min = vr->min ();
@@ -3130,7 +3134,7 @@ simplify_using_ranges::simplify_div_or_mod_using_ranges
if (rhs_code == TRUNC_MOD_EXPR
&& TREE_CODE (op1) == SSA_NAME)
{
- const value_range_equiv *vr1 = get_value_range (op1);
+ const value_range_equiv *vr1 = get_value_range (op1, stmt);
if (range_int_cst_p (vr1))
op1min = vr1->min ();
}
@@ -3279,7 +3283,7 @@ simplify_using_ranges::simplify_abs_using_ranges (gimple_stmt_iterator *gsi,
gimple *stmt)
{
tree op = gimple_assign_rhs1 (stmt);
- const value_range *vr = get_value_range (op);
+ const value_range *vr = get_value_range (op, stmt);
if (vr)
{
@@ -3369,14 +3373,14 @@ simplify_using_ranges::simplify_bit_ops_using_ranges
wide_int mask;
if (TREE_CODE (op0) == SSA_NAME)
- vr0 = *(get_value_range (op0));
+ vr0 = *(get_value_range (op0, stmt));
else if (is_gimple_min_invariant (op0))
vr0.set (op0);
else
return false;
if (TREE_CODE (op1) == SSA_NAME)
- vr1 = *(get_value_range (op1));
+ vr1 = *(get_value_range (op1, stmt));
else if (is_gimple_min_invariant (op1))
vr1.set (op1);
else
@@ -3595,7 +3599,7 @@ simplify_using_ranges::simplify_cond_using_ranges_1 (gcond *stmt)
&& INTEGRAL_TYPE_P (TREE_TYPE (op0))
&& is_gimple_min_invariant (op1))
{
- const value_range *vr = get_value_range (op0);
+ const value_range *vr = get_value_range (op0, stmt);
/* If we have range information for OP0, then we might be
able to simplify this conditional. */
@@ -3739,7 +3743,7 @@ simplify_using_ranges::simplify_switch_using_ranges (gswitch *stmt)
if (TREE_CODE (op) == SSA_NAME)
{
- vr = get_value_range (op);
+ vr = get_value_range (op, stmt);
/* We can only handle integer ranges. */
if (vr->varying_p ()
@@ -4032,7 +4036,7 @@ simplify_using_ranges::simplify_float_conversion_using_ranges
gimple *stmt)
{
tree rhs1 = gimple_assign_rhs1 (stmt);
- const value_range *vr = get_value_range (rhs1);
+ const value_range *vr = get_value_range (rhs1, stmt);
scalar_float_mode fltmode
= SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt)));
scalar_int_mode mode;
@@ -4196,7 +4200,7 @@ simplify_using_ranges::simplify_internal_call_using_ranges
bool
simplify_using_ranges::two_valued_val_range_p (tree var, tree *a, tree *b)
{
- value_range vr = *get_value_range (var);
+ value_range vr = *get_value_range (var, NULL);
vr.normalize_symbolics ();
if (vr.varying_p () || vr.undefined_p ())
return false;
@@ -38,12 +38,12 @@ public:
// ?? These should be cleaned, merged, and made private.
tree vrp_evaluate_conditional (tree_code, tree, tree, gimple *);
void vrp_visit_cond_stmt (gcond *, edge *);
- tree vrp_evaluate_conditional_warnv_with_ops (enum tree_code,
+ tree vrp_evaluate_conditional_warnv_with_ops (gimple *stmt, enum tree_code,
tree, tree, bool,
bool *, bool *);
private:
- const value_range_equiv *get_value_range (const_tree op);
+ const value_range_equiv *get_value_range (const_tree op, gimple *stmt);
bool simplify_truth_ops_using_ranges (gimple_stmt_iterator *, gimple *);
bool simplify_div_or_mod_using_ranges (gimple_stmt_iterator *, gimple *);
bool simplify_abs_using_ranges (gimple_stmt_iterator *, gimple *);
@@ -101,7 +101,7 @@ class vr_values
vr_values (void);
~vr_values (void);
- const value_range_equiv *get_value_range (const_tree);
+ const value_range_equiv *get_value_range (const_tree, gimple * = NULL);
void set_vr_value (tree, value_range_equiv *);
value_range_equiv *swap_vr_value (tree, value_range_equiv *);
@@ -140,8 +140,8 @@ class vr_values
void extract_range_from_unary_expr (value_range_equiv *, enum tree_code,
tree, tree);
void extract_range_from_cond_expr (value_range_equiv *, gassign *);
- void extract_range_from_comparison (value_range_equiv *, enum tree_code,
- tree, tree, tree);
+ void extract_range_from_comparison (value_range_equiv *, gimple *,
+ enum tree_code, tree, tree, tree);
void vrp_visit_assignment_or_call (gimple*, tree *, value_range_equiv *);
void vrp_visit_switch_stmt (gswitch *, edge *);
@@ -167,9 +167,9 @@ class vr_values
};
inline const value_range_equiv *
-simplify_using_ranges::get_value_range (const_tree op)
+simplify_using_ranges::get_value_range (const_tree op, gimple *stmt)
{
- return store->get_value_range (op);
+ return store->get_value_range (op, stmt);
}
extern tree get_output_for_vrp (gimple *);