+2018-11-12 Richard Biener <rguenther@suse.de>
+
+ * tree-vrp.h (value_range[_base]::set): Make public. Provide
+ overload for single value.
+ (value_range[_base]::set_nonnull): New.
+ (value_range[_base]::set_null): Likewise.
+ (value_range): Document bitmap copying behavior, mark
+ copy constructor and assignment operator deleted.
+ (value_range::move): New.
+ (value_range::set_and_canonicalize): Default bitmap to zero.
+ (set_value_range_to_nonnull): Remove.
+ (set_value_range_to_null): Likewise.
+ (set_value_range): Likewise.
+ (set_value_range_to_value): Likewise.
+ (extract_range_from_unary_expr): Work on value_range_base.
+ (extract_range_from_binary_expr_1): Likewise. Rename to...
+ (extract_range_from_binary_expr): ... this.
+ * tree-vrp.c (value_range::update): Clear equiv bitmap
+ if required.
+ (value_range::move): New, move equiv bitmap.
+ (value_range_base::set_undefined): Avoid assignment.
+ (value_range::set_undefined): Likewise.
+ (value_range_base::set_varying): Likewise.
+ (value_range::set_varying): Likewise.
+ (set_value_range): Remove.
+ (value_range_base::set): New overload for value.
+ (value_range::set): Likewise.
+ (set_value_range_to_nonnull): Remove.
+ (value_range_base::set_nonnull): New.
+ (value_range::set_nonnull): Likewise.
+ (set_value_range_to_null): Remove.
+ (value_range_base::set_null): New.
+ (value_range::set_null): Likewise.
+ (range_is_null): Work on value_range_base.
+ (range_is_nonnull): Likewise.
+ (ranges_from_anti_range): Likewise.
+ (extract_range_into_wide_ints): Likewise.
+ (extract_range_from_multiplicative_op): Likewise.
+ (extract_range_from_binary_expr): Likewise. Update for API changes.
+ (extract_range_from_unary_expr): Likewise. Remove OBJ_TYPE_REF
+ handling.
+ (value_range::intersect_helper): Avoid copy and assignment.
+ (value_range::union_helper): Likewise.
+ (determine_value_range_1): Adjust.
+ * gimple-ssa-evrp-analyze.c (evrp_range_analyzer::try_find_new_range):
+ Avoid assignment by using move.
+ (evrp_range_analyzer::record_ranges_from_stmt): Avoid assignment.
+ * tree-ssa-threadedge.c (record_temporary_equivalences_from_phis):
+ Likewise.
+ * tree-ssanames.c (get_range_info): Likewise.
+ * vr-values.h (vr_values::get_vr_for_comparison): Adjust API.
+ * vr-values.c (vr_values::get_value_range): Adjust.
+ (vr_values::update_value_range): Likewise.
+ (symbolic_range_based_on_p): Work on value_range_base.
+ (vr_values::extract_range_from_binary_expr): Use value_range_base.
+ (vr_values::extract_range_from_unary_expr): Likewise.
+ (vr_values::extract_range_from_cond_expr): Avoid assignment.
+ (vr_values::extract_range_from_comparison): Adjust.
+ (vr_values::check_for_binary_op_overflow): Use value_range_base.
+ (vr_values::extract_range_basic): Adjust.
+ (vr_values::adjust_range_with_scev): Likewise.
+ (vr_values::vrp_visit_assignment_or_call): Likewise.
+ (vr_values::get_vr_for_comparison): Change API to avoid
+ assignment and copy construction.
+ (vr_values::compare_name_with_value): Adjust accordingly.
+ (vr_values::compare_names): Likewise.
+ (vr_values::extract_range_from_phi_node): Avoid assignment and
+ bogus in-place modify of equiv bitmap.
+ (vr_values::simplify_bit_ops_using_ranges): Use value_range_base.
+ * ipa-prop.c (ipa_compute_jump_functions_for_edge): Adjust
+ for extract_range_from_unary_expr API change.
+ * ipa-cp.c (ipa_vr_operation_and_type_effects): Likewise.
+
2018-11-12 Eric Botcazou <ebotcazou@adacore.com>
* config/mcore/mcore.h (WORD_REGISTER_OPERATIONS): Remove duplicate.
&& vrp_operand_equal_p (old_vr->max (), vr.max ()))
return NULL;
value_range *new_vr = vr_values->allocate_value_range ();
- *new_vr = vr;
+ new_vr->move (&vr);
return new_vr;
}
return NULL;
also have to be very careful about sharing the underlying
bitmaps. Ugh. */
value_range *new_vr = vr_values->allocate_value_range ();
- *new_vr = vr;
- new_vr->equiv_clear ();
+ new_vr->set (vr.kind (), vr.min (), vr.max ());
+ vr.equiv_clear ();
push_value_range (output, new_vr);
}
}
enum tree_code operation,
tree dst_type, tree src_type)
{
- /* ??? We'd want to use value_range_base on the VRP workers. */
- value_range dst_tem;
- value_range src_tem (*src_vr);
- extract_range_from_unary_expr (&dst_tem, operation, dst_type,
- &src_tem, src_type);
- *dst_vr = value_range_base (dst_tem.kind (), dst_tem.min (), dst_tem.max ());
+ extract_range_from_unary_expr (dst_vr, operation, dst_type,
+ src_vr, src_type);
if (dst_vr->varying_p () || dst_vr->undefined_p ())
return false;
return true;
&& (type = get_range_info (arg, &min, &max))
&& (type == VR_RANGE || type == VR_ANTI_RANGE))
{
- /* ??? We'd want to use value_range_base here but the
- VRP workers need to be adjusted first. */
- value_range resvr;
- value_range tmpvr (type,
- wide_int_to_tree (TREE_TYPE (arg), min),
- wide_int_to_tree (TREE_TYPE (arg), max));
+ value_range_base resvr;
+ value_range_base tmpvr (type,
+ wide_int_to_tree (TREE_TYPE (arg), min),
+ wide_int_to_tree (TREE_TYPE (arg), max));
extract_range_from_unary_expr (&resvr, NOP_EXPR, param_type,
&tmpvr, TREE_TYPE (arg));
if (!resvr.undefined_p () && !resvr.varying_p ())
away in the VR stack. */
vr_values *vr_values = evrp_range_analyzer->get_vr_values ();
value_range *new_vr = vr_values->allocate_value_range ();
- *new_vr = value_range ();
+ new (new_vr) value_range ();
/* There are three cases to consider:
if (TREE_CODE (src) == SSA_NAME)
new_vr->deep_copy (vr_values->get_value_range (src));
else if (TREE_CODE (src) == INTEGER_CST)
- set_value_range_to_value (new_vr, src, NULL);
+ new_vr->set (src);
else
new_vr->set_varying ();
min = wide_int_to_tree (TREE_TYPE (name), wmin);
max = wide_int_to_tree (TREE_TYPE (name), wmax);
}
- vr = value_range (kind, min, max);
+ vr.set (kind, min, max);
return kind;
}
set (other.kind (), other.min(), other.max (), NULL);
}
-/* Like above, but keep the equivalences intact. */
+/* Like set, but keep the equivalences in place. */
void
value_range::update (value_range_kind kind, tree min, tree max)
{
- set (kind, min, max, m_equiv);
+ set (kind, min, max,
+ (kind != VR_UNDEFINED && kind != VR_VARYING) ? m_equiv : NULL);
}
/* Copy value_range in FROM into THIS while avoiding bitmap sharing.
set (from->m_kind, from->min (), from->max (), from->m_equiv);
}
+void
+value_range::move (value_range *from)
+{
+ set (from->m_kind, from->min (), from->max ());
+ m_equiv = from->m_equiv;
+ from->m_equiv = NULL;
+}
+
/* Check the validity of the range. */
void
void
value_range_base::set_undefined ()
{
- *this = value_range_base (VR_UNDEFINED, NULL, NULL);
+ set (VR_UNDEFINED, NULL, NULL);
}
void
value_range::set_undefined ()
{
- equiv_clear ();
- *this = value_range (VR_UNDEFINED, NULL, NULL, NULL);
+ set (VR_UNDEFINED, NULL, NULL, NULL);
}
void
value_range_base::set_varying ()
{
- *this = value_range_base (VR_VARYING, NULL, NULL);
+ set (VR_VARYING, NULL, NULL);
}
void
value_range::set_varying ()
{
- equiv_clear ();
- *this = value_range (VR_VARYING, NULL, NULL, NULL);
+ set (VR_VARYING, NULL, NULL, NULL);
}
/* Return TRUE if it is possible that range contains VAL. */
return vr_type;
}
-/* Set value range VR to {T, MIN, MAX, EQUIV}. */
-
-void
-set_value_range (value_range *vr, enum value_range_kind kind,
- tree min, tree max, bitmap equiv)
-{
- *vr = value_range (kind, min, max, equiv);
-}
-
/* Set value range to the canonical form of {VRTYPE, MIN, MAX, EQUIV}.
This means adjusting VRTYPE, MIN and MAX representing the case of a
equiv_clear ();
}
-/* Set value range VR to a single value. This function is only called
- with values we get from statements, and exists to clear the
- TREE_OVERFLOW flag. */
+void
+value_range_base::set (tree val)
+{
+ gcc_assert (TREE_CODE (val) == SSA_NAME || is_gimple_min_invariant (val));
+ if (TREE_OVERFLOW_P (val))
+ val = drop_tree_overflow (val);
+ set (VR_RANGE, val, val);
+}
void
-set_value_range_to_value (value_range *vr, tree val, bitmap equiv)
+value_range::set (tree val)
{
- gcc_assert (is_gimple_min_invariant (val));
+ gcc_assert (TREE_CODE (val) == SSA_NAME || is_gimple_min_invariant (val));
if (TREE_OVERFLOW_P (val))
val = drop_tree_overflow (val);
- set_value_range (vr, VR_RANGE, val, val, equiv);
+ set (VR_RANGE, val, val, NULL);
}
/* Set value range VR to a non-NULL range of type TYPE. */
void
-set_value_range_to_nonnull (value_range *vr, tree type)
+value_range_base::set_nonnull (tree type)
{
tree zero = build_int_cst (type, 0);
- set_value_range (vr, VR_ANTI_RANGE, zero, zero, NULL);
+ set (VR_ANTI_RANGE, zero, zero);
}
+void
+value_range::set_nonnull (tree type)
+{
+ tree zero = build_int_cst (type, 0);
+ set (VR_ANTI_RANGE, zero, zero, NULL);
+}
/* Set value range VR to a NULL range of type TYPE. */
void
-set_value_range_to_null (value_range *vr, tree type)
+value_range_base::set_null (tree type)
+{
+ set (build_int_cst (type, 0));
+}
+
+void
+value_range::set_null (tree type)
{
- set_value_range_to_value (vr, build_int_cst (type, 0), NULL);
+ set (build_int_cst (type, 0));
}
/* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */
/* Return true if VR is [0, 0]. */
static inline bool
-range_is_null (const value_range *vr)
+range_is_null (const value_range_base *vr)
{
return vr->zero_p ();
}
static inline bool
-range_is_nonnull (const value_range *vr)
+range_is_nonnull (const value_range_base *vr)
{
return (vr->kind () == VR_ANTI_RANGE
&& vr->min () == vr->max ()
*VR1 will be VR_UNDEFINED. */
static bool
-ranges_from_anti_range (const value_range *ar,
- value_range *vr0, value_range *vr1)
+ranges_from_anti_range (const value_range_base *ar,
+ value_range_base *vr0, value_range_base *vr1)
{
tree type = ar->type ();
resulting wide ints are set to [-MIN, +MAX] for the type. */
static void inline
-extract_range_into_wide_ints (const value_range *vr,
+extract_range_into_wide_ints (const value_range_base *vr,
signop sign, unsigned prec,
wide_int &wmin, wide_int &wmax)
{
*VR = *VR0 .CODE. *VR1. */
static void
-extract_range_from_multiplicative_op (value_range *vr,
+extract_range_from_multiplicative_op (value_range_base *vr,
enum tree_code code,
- const value_range *vr0,
- const value_range *vr1)
+ const value_range_base *vr0,
+ const value_range_base *vr1)
{
gcc_assert (code == MULT_EXPR
|| code == TRUNC_DIV_EXPR
overflow_undefined))
vr->set_and_canonicalize (VR_RANGE,
wide_int_to_tree (type, res_lb),
- wide_int_to_tree (type, res_ub), NULL);
+ wide_int_to_tree (type, res_ub));
else
vr->set_varying ();
}
{
/* If the limits are swapped, we wrapped around and cover
the entire range. We have a similar check at the end of
- extract_range_from_binary_expr_1. */
+ extract_range_from_binary_expr. */
if (wi::gt_p (tmin, tmax, sgn))
kind = VR_VARYING;
else
type EXPR_TYPE. The resulting range is stored in *VR. */
void
-extract_range_from_binary_expr_1 (value_range *vr,
- enum tree_code code, tree expr_type,
- const value_range *vr0_,
- const value_range *vr1_)
+extract_range_from_binary_expr (value_range_base *vr,
+ enum tree_code code, tree expr_type,
+ const value_range_base *vr0_,
+ const value_range_base *vr1_)
{
signop sign = TYPE_SIGN (expr_type);
unsigned int prec = TYPE_PRECISION (expr_type);
- value_range vr0 = *vr0_, vr1 = *vr1_;
- value_range vrtem0, vrtem1;
+ value_range_base vr0 = *vr0_, vr1 = *vr1_;
+ value_range_base vrtem0, vrtem1;
enum value_range_kind type;
tree min = NULL_TREE, max = NULL_TREE;
int cmp;
easier to special case when vr0 is ~[0,0] for EXACT_DIV_EXPR. */
if (code == EXACT_DIV_EXPR && range_is_nonnull (&vr0))
{
- set_value_range_to_nonnull (vr, expr_type);
+ vr->set_nonnull (expr_type);
return;
}
if (vr0.kind () == VR_ANTI_RANGE
&& ranges_from_anti_range (&vr0, &vrtem0, &vrtem1))
{
- extract_range_from_binary_expr_1 (vr, code, expr_type, &vrtem0, vr1_);
+ extract_range_from_binary_expr (vr, code, expr_type, &vrtem0, vr1_);
if (!vrtem1.undefined_p ())
{
- value_range vrres;
- extract_range_from_binary_expr_1 (&vrres, code, expr_type, &vrtem1, vr1_);
+ value_range_base vrres;
+ extract_range_from_binary_expr (&vrres, code, expr_type,
+ &vrtem1, vr1_);
vr->union_ (&vrres);
}
return;
if (vr1.kind () == VR_ANTI_RANGE
&& ranges_from_anti_range (&vr1, &vrtem0, &vrtem1))
{
- extract_range_from_binary_expr_1 (vr, code, expr_type, vr0_, &vrtem0);
+ extract_range_from_binary_expr (vr, code, expr_type, vr0_, &vrtem0);
if (!vrtem1.undefined_p ())
{
- value_range vrres;
- extract_range_from_binary_expr_1 (&vrres, code, expr_type,
- vr0_, &vrtem1);
+ value_range_base vrres;
+ extract_range_from_binary_expr (&vrres, code, expr_type,
+ vr0_, &vrtem1);
vr->union_ (&vrres);
}
return;
If both are null, then the result is null. Otherwise they
are varying. */
if (!range_includes_zero_p (&vr0) && !range_includes_zero_p (&vr1))
- set_value_range_to_nonnull (vr, expr_type);
+ vr->set_nonnull (expr_type);
else if (range_is_null (&vr0) && range_is_null (&vr1))
- set_value_range_to_null (vr, expr_type);
+ vr->set_null (expr_type);
else
vr->set_varying ();
}
whether the expression evaluates to non-NULL. */
if (!range_includes_zero_p (&vr0)
|| !range_includes_zero_p (&vr1))
- set_value_range_to_nonnull (vr, expr_type);
+ vr->set_nonnull (expr_type);
else if (range_is_null (&vr0) && range_is_null (&vr1))
- set_value_range_to_null (vr, expr_type);
+ vr->set_null (expr_type);
else
vr->set_varying ();
}
/* For pointer types, we are really only interested in asserting
whether the expression evaluates to non-NULL. */
if (!range_includes_zero_p (&vr0) && !range_includes_zero_p (&vr1))
- set_value_range_to_nonnull (vr, expr_type);
+ vr->set_nonnull (expr_type);
else if (range_is_null (&vr0) || range_is_null (&vr1))
- set_value_range_to_null (vr, expr_type);
+ vr->set_null (expr_type);
else
vr->set_varying ();
}
[0,0] - VR_VARYING is not dropped to varying, but is
calculated as [MIN+1, MAX]. */
if (vr0.varying_p ())
- vr0.update (VR_RANGE,
- vrp_val_min (expr_type),
- vrp_val_max (expr_type));
+ vr0.set (VR_RANGE, vrp_val_min (expr_type), vrp_val_max (expr_type));
if (vr1.varying_p ())
- vr1.update (VR_RANGE,
- vrp_val_min (expr_type),
- vrp_val_max (expr_type));
+ vr1.set (VR_RANGE, vrp_val_min (expr_type), vrp_val_max (expr_type));
const bool minus_p = (code == MINUS_EXPR);
tree min_op0 = vr0.min ();
extract_range_into_wide_ints (&vr1, sign, prec, vr1_min, vr1_max);
if (wide_int_range_min_max (wmin, wmax, code, sign, prec,
vr0_min, vr0_max, vr1_min, vr1_max))
- vr->update (VR_RANGE, wide_int_to_tree (expr_type, wmin),
- wide_int_to_tree (expr_type, wmax));
+ vr->set (VR_RANGE, wide_int_to_tree (expr_type, wmin),
+ wide_int_to_tree (expr_type, wmax));
else
vr->set_varying ();
return;
useful ranges just from the shift count. E.g.
x >> 63 for signed 64-bit x is always [-1, 0]. */
if (vr0.kind () != VR_RANGE || vr0.symbolic_p ())
- vr0.update (VR_RANGE,
- vrp_val_min (expr_type),
- vrp_val_max (expr_type));
+ vr0.set (VR_RANGE, vrp_val_min (expr_type),
+ vrp_val_max (expr_type));
extract_range_from_multiplicative_op (vr, code, &vr0, &vr1);
return;
}
{
min = wide_int_to_tree (expr_type, res_lb);
max = wide_int_to_tree (expr_type, res_ub);
- vr->set_and_canonicalize (VR_RANGE, min, max, NULL);
+ vr->set_and_canonicalize (VR_RANGE, min, max);
return;
}
}
vr->set_undefined ();
return;
}
- set_value_range (vr, VR_RANGE,
- wide_int_to_tree (expr_type, wmin),
- wide_int_to_tree (expr_type, wmax), NULL);
+ vr->set (VR_RANGE, wide_int_to_tree (expr_type, wmin),
+ wide_int_to_tree (expr_type, wmax));
if (extra_range_p)
{
- value_range extra_range;
- set_value_range (&extra_range, VR_RANGE,
- wide_int_to_tree (expr_type, extra_min),
- wide_int_to_tree (expr_type, extra_max), NULL);
+ value_range_base
+ extra_range (VR_RANGE, wide_int_to_tree (expr_type, extra_min),
+ wide_int_to_tree (expr_type, extra_max));
vr->union_ (&extra_range);
}
return;
vr0_min, vr0_max, vr1_min, vr1_max);
min = wide_int_to_tree (expr_type, wmin);
max = wide_int_to_tree (expr_type, wmax);
- set_value_range (vr, VR_RANGE, min, max, NULL);
+ vr->set (VR_RANGE, min, max);
return;
}
else if (code == BIT_AND_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR)
{
min = wide_int_to_tree (expr_type, wmin);
max = wide_int_to_tree (expr_type, wmax);
- set_value_range (vr, VR_RANGE, min, max, NULL);
+ vr->set (VR_RANGE, min, max);
}
else
vr->set_varying ();
{
min = wide_int_to_tree (expr_type, wmin);
max = wide_int_to_tree (expr_type, wmax);
- set_value_range (vr, VR_RANGE, min, max, NULL);
+ vr->set (VR_RANGE, min, max);
}
else
vr->set_varying ();
{
min = wide_int_to_tree (expr_type, wmin);
max = wide_int_to_tree (expr_type, wmax);
- set_value_range (vr, VR_RANGE, min, max, NULL);
+ vr->set (VR_RANGE, min, max);
}
else
vr->set_varying ();
vr->set_varying ();
}
else
- set_value_range (vr, type, min, max, NULL);
+ vr->set (type, min, max);
}
/* Extract range information from a unary operation CODE based on
The resulting range is stored in *VR. */
void
-extract_range_from_unary_expr (value_range *vr,
+extract_range_from_unary_expr (value_range_base *vr,
enum tree_code code, tree type,
- const value_range *vr0_, tree op0_type)
+ const value_range_base *vr0_, tree op0_type)
{
signop sign = TYPE_SIGN (type);
unsigned int prec = TYPE_PRECISION (type);
- value_range vr0 = *vr0_;
- value_range vrtem0, vrtem1;
+ value_range_base vr0 = *vr0_;
+ value_range_base vrtem0, vrtem1;
/* VRP only operates on integral and pointer types. */
if (!(INTEGRAL_TYPE_P (op0_type)
}
/* Handle operations that we express in terms of others. */
- if (code == PAREN_EXPR || code == OBJ_TYPE_REF)
+ if (code == PAREN_EXPR)
{
/* PAREN_EXPR and OBJ_TYPE_REF are simple copies. */
- vr->deep_copy (&vr0);
+ *vr = vr0;
return;
}
else if (code == NEGATE_EXPR)
{
/* -X is simply 0 - X, so re-use existing code that also handles
anti-ranges fine. */
- value_range zero;
- set_value_range_to_value (&zero, build_int_cst (type, 0), NULL);
- extract_range_from_binary_expr_1 (vr, MINUS_EXPR, type, &zero, &vr0);
+ value_range_base zero;
+ zero.set (build_int_cst (type, 0));
+ extract_range_from_binary_expr (vr, MINUS_EXPR, type, &zero, &vr0);
return;
}
else if (code == BIT_NOT_EXPR)
{
/* ~X is simply -1 - X, so re-use existing code that also handles
anti-ranges fine. */
- value_range minusone;
- set_value_range_to_value (&minusone, build_int_cst (type, -1), NULL);
- extract_range_from_binary_expr_1 (vr, MINUS_EXPR,
- type, &minusone, &vr0);
+ value_range_base minusone;
+ minusone.set (build_int_cst (type, -1));
+ extract_range_from_binary_expr (vr, MINUS_EXPR, type, &minusone, &vr0);
return;
}
extract_range_from_unary_expr (vr, code, type, &vrtem0, op0_type);
if (!vrtem1.undefined_p ())
{
- value_range vrres;
+ value_range_base vrres;
extract_range_from_unary_expr (&vrres, code, type,
&vrtem1, op0_type);
vr->union_ (&vrres);
if (POINTER_TYPE_P (type) || POINTER_TYPE_P (op0_type))
{
if (!range_includes_zero_p (&vr0))
- set_value_range_to_nonnull (vr, type);
+ vr->set_nonnull (type);
else if (range_is_null (&vr0))
- set_value_range_to_null (vr, type);
+ vr->set_null (type);
else
vr->set_varying ();
return;
{
tree min = wide_int_to_tree (outer_type, wmin);
tree max = wide_int_to_tree (outer_type, wmax);
- vr->set_and_canonicalize (VR_RANGE, min, max, NULL);
+ vr->set_and_canonicalize (VR_RANGE, min, max);
}
else
vr->set_varying ();
extract_range_into_wide_ints (&vr0, sign, prec, vr0_min, vr0_max);
if (wide_int_range_abs (wmin, wmax, sign, prec, vr0_min, vr0_max,
TYPE_OVERFLOW_UNDEFINED (type)))
- set_value_range (vr, VR_RANGE,
- wide_int_to_tree (type, wmin),
- wide_int_to_tree (type, wmax), NULL);
+ vr->set (VR_RANGE, wide_int_to_tree (type, wmin),
+ wide_int_to_tree (type, wmax));
else
vr->set_varying ();
return;
return;
}
- /* Save the original vr0 so we can return it as conservative intersection
- result when our worker turns things to varying. */
- value_range saved (*vr0);
-
value_range_kind vr0type = vr0->kind ();
tree vr0min = vr0->min ();
tree vr0max = vr0->max ();
intersect_ranges (&vr0type, &vr0min, &vr0max,
vr1->kind (), vr1->min (), vr1->max ());
/* Make sure to canonicalize the result though as the inversion of a
- VR_RANGE can still be a VR_RANGE. */
- vr0->set_and_canonicalize (vr0type, vr0min, vr0max, vr0->m_equiv);
+ VR_RANGE can still be a VR_RANGE. Work on a temporary so we can
+ fall back to vr0 when this turns things to varying. */
+ value_range tem;
+ tem.set_and_canonicalize (vr0type, vr0min, vr0max);
/* If that failed, use the saved original VR0. */
- if (vr0->varying_p ())
- {
- *vr0 = saved;
- return;
- }
+ if (tem.varying_p ())
+ return;
+ vr0->update (tem.kind (), tem.min (), tem.max ());
+
/* If the result is VR_UNDEFINED there is no need to mess with
the equivalencies. */
if (vr0->undefined_p ())
return;
}
- value_range saved (*vr0);
value_range_kind vr0type = vr0->kind ();
tree vr0min = vr0->min ();
tree vr0max = vr0->max ();
union_ranges (&vr0type, &vr0min, &vr0max,
vr1->kind (), vr1->min (), vr1->max ());
- *vr0 = value_range (vr0type, vr0min, vr0max);
- if (vr0->varying_p ())
+ /* Work on a temporary so we can still use vr0 when union returns varying. */
+ value_range tem;
+ tem.set_and_canonicalize (vr0type, vr0min, vr0max);
+ if (tem.varying_p ())
{
/* Failed to find an efficient meet. Before giving up and setting
the result to VARYING, see if we can at least derive a useful
anti-range. */
- if (range_includes_zero_p (&saved) == 0
+ if (range_includes_zero_p (vr0) == 0
&& range_includes_zero_p (vr1) == 0)
{
- set_value_range_to_nonnull (vr0, saved.type ());
-
- /* Since this meet operation did not result from the meeting of
- two equivalent names, VR0 cannot have any equivalences. */
- if (vr0->m_equiv)
- bitmap_clear (vr0->m_equiv);
+ vr0->set_nonnull (vr0->type ());
return;
}
vr0->set_varying ();
return;
}
- vr0->set_and_canonicalize (vr0->kind (), vr0->min (), vr0->max (),
- vr0->equiv ());
- if (vr0->varying_p ())
- return;
+ vr0->update (tem.kind (), tem.min (), tem.max ());
/* The resulting set of equivalences is always the intersection of
the two sets. */
value_range vr0, vr1;
determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0));
determine_value_range_1 (&vr1, TREE_OPERAND (expr, 1));
- extract_range_from_binary_expr_1 (vr, TREE_CODE (expr), TREE_TYPE (expr),
- &vr0, &vr1);
+ extract_range_from_binary_expr (vr, TREE_CODE (expr), TREE_TYPE (expr),
+ &vr0, &vr1);
}
else if (UNARY_CLASS_P (expr))
{
&vr0, TREE_TYPE (TREE_OPERAND (expr, 0)));
}
else if (TREE_CODE (expr) == INTEGER_CST)
- set_value_range_to_value (vr, expr, NULL);
+ vr->set (expr);
else
{
value_range_kind kind;
if (TREE_CODE (expr) == SSA_NAME
&& INTEGRAL_TYPE_P (TREE_TYPE (expr))
&& (kind = get_range_info (expr, &min, &max)) != VR_VARYING)
- set_value_range (vr, kind, wide_int_to_tree (TREE_TYPE (expr), min),
- wide_int_to_tree (TREE_TYPE (expr), max), NULL);
+ vr->set (kind, wide_int_to_tree (TREE_TYPE (expr), min),
+ wide_int_to_tree (TREE_TYPE (expr), max));
else
vr->set_varying ();
}
value_range_base ();
value_range_base (value_range_kind, tree, tree);
+ void set (value_range_kind, tree, tree);
+ void set (tree);
+ void set_nonnull (tree);
+ void set_null (tree);
+
enum value_range_kind kind () const;
tree min () const;
tree max () const;
void dump () const;
protected:
- void set (value_range_kind, tree, tree);
void check ();
enum value_range_kind m_kind;
public:
value_range ();
value_range (const value_range_base &);
+ /* Deep-copies equiv bitmap argument. */
value_range (value_range_kind, tree, tree, bitmap = NULL);
+
+ /* Shallow-copies equiv bitmap. */
+ value_range (const value_range &) /* = delete */;
+ /* Shallow-copies equiv bitmap. */
+ value_range& operator=(const value_range&) /* = delete */;
+
+ /* Move equiv bitmap from source range. */
+ void move (value_range *);
+
+ /* Leaves equiv bitmap alone. */
void update (value_range_kind, tree, tree);
+ /* Deep-copies equiv bitmap argument. */
+ void set (value_range_kind, tree, tree, bitmap = NULL);
+ void set (tree);
+ void set_nonnull (tree);
+ void set_null (tree);
+
bool operator== (const value_range &) const;
bool operator!= (const value_range &) const;
void intersect (const value_range *);
/* Misc methods. */
void deep_copy (const value_range *);
- void set_and_canonicalize (enum value_range_kind, tree, tree, bitmap);
+ void set_and_canonicalize (enum value_range_kind, tree, tree, bitmap = NULL);
void dump (FILE *) const;
void dump () const;
private:
- void set (value_range_kind, tree, tree, bitmap);
+ /* Deep-copies bitmap argument. */
void set_equiv (bitmap);
void check ();
bool equal_p (const value_range &, bool ignore_equivs) const;
extern bool range_includes_zero_p (const value_range_base *);
extern bool infer_value_range (gimple *, tree, tree_code *, tree *);
-extern void set_value_range_to_nonnull (value_range *, tree);
-extern void set_value_range_to_null (value_range *, tree);
-extern void set_value_range (value_range *, enum value_range_kind, tree,
- tree, bitmap);
-extern void set_value_range_to_value (value_range *, tree, bitmap);
-
extern bool vrp_bitmap_equal_p (const_bitmap, const_bitmap);
extern tree value_range_constant_singleton (const value_range_base *);
extern tree vrp_val_min (const_tree);
extern tree vrp_val_max (const_tree);
-extern void extract_range_from_unary_expr (value_range *vr,
+extern void extract_range_from_unary_expr (value_range_base *vr,
enum tree_code code,
tree type,
- const value_range *vr0_,
+ const value_range_base *vr0_,
tree op0_type);
-extern void extract_range_from_binary_expr_1 (value_range *, enum tree_code,
- tree, const value_range *,
- const value_range *);
+extern void extract_range_from_binary_expr (value_range_base *,
+ enum tree_code,
+ tree, const value_range_base *,
+ const value_range_base *);
extern bool vrp_operand_equal_p (const_tree, const_tree);
extern enum value_range_kind intersect_range_with_nonzero_bits
if (POINTER_TYPE_P (TREE_TYPE (sym))
&& (nonnull_arg_p (sym)
|| get_ptr_nonnull (var)))
- set_value_range_to_nonnull (vr, TREE_TYPE (sym));
+ vr->set_nonnull (TREE_TYPE (sym));
else if (INTEGRAL_TYPE_P (TREE_TYPE (sym)))
{
get_range_info (var, *vr);
}
else if (TREE_CODE (sym) == RESULT_DECL
&& DECL_BY_REFERENCE (sym))
- set_value_range_to_nonnull (vr, TREE_TYPE (sym));
+ vr->set_nonnull (TREE_TYPE (sym));
}
return vr;
return true;
}
else
- set_value_range (old_vr, new_vr->kind (),
- new_vr->min (), new_vr->max (), new_vr->equiv ());
+ old_vr->set (new_vr->kind (),
+ new_vr->min (), new_vr->max (), new_vr->equiv ());
}
new_vr->equiv_clear ();
/* Return true if value range VR involves exactly one symbol SYM. */
static bool
-symbolic_range_based_on_p (value_range *vr, const_tree sym)
+symbolic_range_based_on_p (value_range_base *vr, const_tree sym)
{
bool neg, min_has_symbol, max_has_symbol;
tree inv;
if (!var_vr->varying_p ())
vr->deep_copy (var_vr);
else
- set_value_range (vr, VR_RANGE, var, var, NULL);
+ vr->set (var);
vr->equiv_add (var, get_value_range (var), &vrp_equiv_obstack);
}
{
/* Get value ranges for each operand. For constant operands, create
a new value range with the operand to simplify processing. */
- value_range vr0, vr1;
+ value_range_base vr0, vr1;
if (TREE_CODE (op0) == SSA_NAME)
vr0 = *(get_value_range (op0));
else if (is_gimple_min_invariant (op0))
- set_value_range_to_value (&vr0, op0, NULL);
+ vr0.set (op0);
else
vr0.set_varying ();
if (TREE_CODE (op1) == SSA_NAME)
vr1 = *(get_value_range (op1));
else if (is_gimple_min_invariant (op1))
- set_value_range_to_value (&vr1, op1, NULL);
+ vr1.set (op1);
else
vr1.set_varying ();
vrp_val_max (expr_type));
}
- extract_range_from_binary_expr_1 (vr, code, expr_type, &vr0, &vr1);
+ ::extract_range_from_binary_expr (vr, code, expr_type, &vr0, &vr1);
/* Set value_range for n in following sequence:
def = __builtin_memchr (arg, 0, sz)
wide_int wmax = wi::to_wide (max, TYPE_PRECISION (TREE_TYPE (max)));
tree range_min = build_zero_cst (expr_type);
tree range_max = wide_int_to_tree (expr_type, wmax - 1);
- set_value_range (vr, VR_RANGE, range_min, range_max, NULL);
+ vr->set (VR_RANGE, range_min, range_max);
return;
}
}
/* Try with VR0 and [-INF, OP1]. */
if (is_gimple_min_invariant (minus_p ? vr0.max () : vr0.min ()))
- set_value_range (&n_vr1, VR_RANGE, vrp_val_min (expr_type), op1, NULL);
+ n_vr1.set (VR_RANGE, vrp_val_min (expr_type), op1);
/* Try with VR0 and [OP1, +INF]. */
else if (is_gimple_min_invariant (minus_p ? vr0.min () : vr0.max ()))
- set_value_range (&n_vr1, VR_RANGE, op1, vrp_val_max (expr_type), NULL);
+ n_vr1.set (VR_RANGE, op1, vrp_val_max (expr_type));
/* Try with VR0 and [OP1, OP1]. */
else
- set_value_range (&n_vr1, VR_RANGE, op1, op1, NULL);
+ n_vr1.set (VR_RANGE, op1, op1);
- extract_range_from_binary_expr_1 (vr, code, expr_type, &vr0, &n_vr1);
+ ::extract_range_from_binary_expr (vr, code, expr_type, &vr0, &n_vr1);
}
if (vr->varying_p ()
/* Try with [-INF, OP0] and VR1. */
if (is_gimple_min_invariant (minus_p ? vr1.max () : vr1.min ()))
- set_value_range (&n_vr0, VR_RANGE, vrp_val_min (expr_type), op0, NULL);
+ n_vr0.set (VR_RANGE, vrp_val_min (expr_type), op0);
/* Try with [OP0, +INF] and VR1. */
else if (is_gimple_min_invariant (minus_p ? vr1.min (): vr1.max ()))
- set_value_range (&n_vr0, VR_RANGE, op0, vrp_val_max (expr_type), NULL);
+ n_vr0.set (VR_RANGE, op0, vrp_val_max (expr_type));
/* Try with [OP0, OP0] and VR1. */
else
- set_value_range (&n_vr0, VR_RANGE, op0, op0, NULL);
+ n_vr0.set (op0);
- extract_range_from_binary_expr_1 (vr, code, expr_type, &n_vr0, &vr1);
+ ::extract_range_from_binary_expr (vr, code, expr_type, &n_vr0, &vr1);
}
/* If we didn't derive a range for MINUS_EXPR, and
|| (vr1.kind () == VR_ANTI_RANGE
&& vr1.min () == op0
&& vr1.min () == vr1.max ())))
- set_value_range_to_nonnull (vr, expr_type);
+ vr->set_nonnull (expr_type);
}
/* Extract range information from a unary expression CODE OP0 based on
vr_values::extract_range_from_unary_expr (value_range *vr, enum tree_code code,
tree type, tree op0)
{
- value_range vr0;
+ value_range_base vr0;
/* Get value ranges for the operand. For constant operands, create
a new value range with the operand to simplify processing. */
if (TREE_CODE (op0) == SSA_NAME)
vr0 = *(get_value_range (op0));
else if (is_gimple_min_invariant (op0))
- set_value_range_to_value (&vr0, op0, NULL);
+ vr0.set (op0);
else
vr0.set_varying ();
/* Get value ranges for each operand. For constant operands, create
a new value range with the operand to simplify processing. */
tree op0 = gimple_assign_rhs2 (stmt);
- value_range vr0;
+ value_range tem0;
+ value_range *vr0 = &tem0;
if (TREE_CODE (op0) == SSA_NAME)
- vr0 = *(get_value_range (op0));
+ vr0 = get_value_range (op0);
else if (is_gimple_min_invariant (op0))
- set_value_range_to_value (&vr0, op0, NULL);
+ tem0.set (op0);
else
- vr0.set_varying ();
+ tem0.set_varying ();
tree op1 = gimple_assign_rhs3 (stmt);
- value_range vr1;
+ value_range tem1;
+ value_range *vr1 = &tem1;
if (TREE_CODE (op1) == SSA_NAME)
- vr1 = *(get_value_range (op1));
+ vr1 = get_value_range (op1);
else if (is_gimple_min_invariant (op1))
- set_value_range_to_value (&vr1, op1, NULL);
+ tem1.set (op1);
else
- vr1.set_varying ();
+ tem1.set_varying ();
/* The resulting value range is the union of the operand ranges */
- vr->deep_copy (&vr0);
- vr->union_ (&vr1);
+ vr->deep_copy (vr0);
+ vr->union_ (vr1);
}
type. */
val = fold_convert (type, val);
if (is_gimple_min_invariant (val))
- set_value_range_to_value (vr, val, NULL);
+ vr->set (val);
else
vr->update (VR_RANGE, val, val);
}
vr_values::check_for_binary_op_overflow (enum tree_code subcode, tree type,
tree op0, tree op1, bool *ovf)
{
- value_range vr0, vr1;
+ value_range_base vr0, vr1;
if (TREE_CODE (op0) == SSA_NAME)
vr0 = *get_value_range (op0);
else if (TREE_CODE (op0) == INTEGER_CST)
- set_value_range_to_value (&vr0, op0, NULL);
+ vr0.set (op0);
else
vr0.set_varying ();
if (TREE_CODE (op1) == SSA_NAME)
vr1 = *get_value_range (op1);
else if (TREE_CODE (op1) == INTEGER_CST)
- set_value_range_to_value (&vr1, op1, NULL);
+ vr1.set (op1);
else
vr1.set_varying ();
&& TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL
&& cfun->after_inlining)
{
- set_value_range_to_null (vr, type);
+ vr->set_null (type);
return;
}
break;
maxi = prec - 1;
goto bitop_builtin;
bitop_builtin:
- set_value_range (vr, VR_RANGE, build_int_cst (type, mini),
- build_int_cst (type, maxi), NULL);
+ vr->set (VR_RANGE, build_int_cst (type, mini),
+ build_int_cst (type, maxi));
return;
case CFN_UBSAN_CHECK_ADD:
subcode = PLUS_EXPR;
size = targetm.goacc.dim_limit (axis);
tree type = TREE_TYPE (gimple_call_lhs (stmt));
- set_value_range (vr, VR_RANGE,
- build_int_cst (type, is_pos ? 0 : 1),
- size ? build_int_cst (type, size - is_pos)
- : vrp_val_max (type), NULL);
+ vr->set(VR_RANGE, build_int_cst (type, is_pos ? 0 : 1),
+ size
+ ? build_int_cst (type, size - is_pos) : vrp_val_max (type));
}
return;
case CFN_BUILT_IN_STRLEN:
wide_int wmax = wi::to_wide (max, TYPE_PRECISION (TREE_TYPE (max)));
tree range_min = build_zero_cst (type);
tree range_max = wide_int_to_tree (type, wmax - 1);
- set_value_range (vr, VR_RANGE, range_min, range_max, NULL);
+ vr->set (VR_RANGE, range_min, range_max);
return;
}
break;
{
/* This is the boolean return value whether compare and
exchange changed anything or not. */
- set_value_range (vr, VR_RANGE, build_int_cst (type, 0),
- build_int_cst (type, 1), NULL);
+ vr->set (VR_RANGE, build_int_cst (type, 0),
+ build_int_cst (type, 1));
return;
}
break;
bool ovf = false;
if (check_for_binary_op_overflow (subcode, type,
op0, op1, &ovf))
- set_value_range_to_value (vr,
- build_int_cst (type, ovf),
- NULL);
+ vr->set (build_int_cst (type, ovf));
else if (TYPE_PRECISION (type) == 1
&& !TYPE_UNSIGNED (type))
vr->set_varying ();
else
- set_value_range (vr, VR_RANGE, build_int_cst (type, 0),
- build_int_cst (type, 1), NULL);
+ vr->set (VR_RANGE, build_int_cst (type, 0),
+ build_int_cst (type, 1));
}
else if (types_compatible_p (type, TREE_TYPE (op0))
&& types_compatible_p (type, TREE_TYPE (op1)))
type, op0);
extract_range_from_unary_expr (&vr1, NOP_EXPR,
type, op1);
- extract_range_from_binary_expr_1 (vr, subcode, type,
+ ::extract_range_from_binary_expr (vr, subcode, type,
&vr0, &vr1);
flag_wrapv = saved_flag_wrapv;
}
&& gimple_stmt_nonnegative_warnv_p (stmt, &sop))
set_value_range_to_nonnegative (vr, type);
else if (vrp_stmt_computes_nonzero (stmt))
- set_value_range_to_nonnull (vr, type);
+ vr->set_nonnull (type);
else
vr->set_varying ();
}
gimple_assign_rhs2 (stmt));
else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS
&& is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
- set_value_range_to_value (vr, gimple_assign_rhs1 (stmt), NULL);
+ vr->set (gimple_assign_rhs1 (stmt));
else
vr->set_varying ();
/* Like in PR19590, scev can return a constant function. */
if (is_gimple_min_invariant (chrec))
{
- set_value_range_to_value (vr, chrec, NULL);
+ vr->set (chrec);
return;
}
/* Likewise if the addition did. */
if (maxvr.kind () == VR_RANGE)
{
- value_range initvr;
+ value_range_base initvr;
if (TREE_CODE (init) == SSA_NAME)
initvr = *(get_value_range (init));
else if (is_gimple_min_invariant (init))
- set_value_range_to_value (&initvr, init, NULL);
+ initvr.set (init);
else
return;
}
else if (is_gimple_min_invariant (tem))
{
- set_value_range_to_value (vr, tem, NULL);
+ vr->set (tem);
return;
}
}
/* Helper that gets the value range of the SSA_NAME with version I
or a symbolic range containing the SSA_NAME only if the value range
- is varying or undefined. */
+ is varying or undefined. Uses TEM as storage for the alternate range. */
-value_range
-vr_values::get_vr_for_comparison (int i)
+value_range *
+vr_values::get_vr_for_comparison (int i, value_range *tem)
{
- value_range vr = *get_value_range (ssa_name (i));
+ /* Shallow-copy equiv bitmap. */
+ value_range *vr = get_value_range (ssa_name (i));
/* 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
have N_i in their ranges. */
- if (vr.varying_p () || vr.undefined_p ())
- vr = value_range (VR_RANGE, ssa_name (i), ssa_name (i), NULL);
+ if (vr->varying_p () || vr->undefined_p ())
+ {
+ tem->set (ssa_name (i));
+ return tem;
+ }
return vr;
}
tree retval, t;
int used_strict_overflow;
bool sop;
- value_range equiv_vr;
+ value_range *equiv_vr, tem_vr;
/* Get the set of equivalences for VAR. */
e = get_value_range (var)->equiv ();
used_strict_overflow = -1;
/* Compare vars' value range with val. */
- equiv_vr = get_vr_for_comparison (SSA_NAME_VERSION (var));
+ equiv_vr = get_vr_for_comparison (SSA_NAME_VERSION (var), &tem_vr);
sop = false;
- retval = compare_range_with_value (comp, &equiv_vr, val, &sop);
+ retval = compare_range_with_value (comp, equiv_vr, val, &sop);
if (retval)
used_strict_overflow = sop ? 1 : 0;
&& prop_simulate_again_p (SSA_NAME_DEF_STMT (name)))
continue;
- equiv_vr = get_vr_for_comparison (i);
+ equiv_vr = get_vr_for_comparison (i, &tem_vr);
sop = false;
- t = compare_range_with_value (comp, &equiv_vr, val, &sop);
+ t = compare_range_with_value (comp, equiv_vr, val, &sop);
if (t)
{
/* If we get different answers from different members
if (! ssa_name (i1))
continue;
- value_range vr1 = get_vr_for_comparison (i1);
+ value_range tem_vr1;
+ value_range *vr1 = get_vr_for_comparison (i1, &tem_vr1);
t = retval = NULL_TREE;
EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)
bool sop = false;
- value_range vr2 = get_vr_for_comparison (i2);
+ value_range tem_vr2;
+ value_range *vr2 = get_vr_for_comparison (i2, &tem_vr2);
- t = compare_ranges (comp, &vr1, &vr2, &sop);
+ t = compare_ranges (comp, vr1, vr2, &sop);
if (t)
{
/* If we get different answers from different members
if (e->flags & EDGE_EXECUTABLE)
{
tree arg = PHI_ARG_DEF (phi, i);
- value_range vr_arg;
+ value_range vr_arg_tem;
+ value_range *vr_arg = &vr_arg_tem;
++edges;
&& e->flags & EDGE_DFS_BACK)
may_simulate_backedge_again = true;
- vr_arg = *(get_value_range (arg));
+ value_range *vr_arg_ = get_value_range (arg);
/* Do not allow equivalences or symbolic ranges to leak in from
backedges. That creates invalid equivalencies.
See PR53465 and PR54767. */
if (e->flags & EDGE_DFS_BACK)
{
- if (!vr_arg.varying_p () && !vr_arg.undefined_p ())
+ if (!vr_arg_->varying_p () && !vr_arg_->undefined_p ())
{
- vr_arg.equiv_clear ();
- if (vr_arg.symbolic_p ())
- vr_arg.set_varying ();
+ vr_arg_tem.set (vr_arg_->kind (), vr_arg_->min (),
+ vr_arg_->max (), NULL);
+ if (vr_arg_tem.symbolic_p ())
+ vr_arg_tem.set_varying ();
}
+ else
+ vr_arg = vr_arg_;
}
/* If the non-backedge arguments range is VR_VARYING then
we can still try recording a simple equivalence. */
- else if (vr_arg.varying_p ())
- vr_arg = value_range (VR_RANGE, arg, arg, NULL);
+ else if (vr_arg_->varying_p ())
+ vr_arg_tem.set (arg);
+ else
+ vr_arg = vr_arg_;
}
else
{
if (TREE_OVERFLOW_P (arg))
arg = drop_tree_overflow (arg);
- vr_arg = value_range (VR_RANGE, arg, arg);
+ vr_arg_tem.set (arg);
}
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\t");
print_generic_expr (dump_file, arg, dump_flags);
fprintf (dump_file, ": ");
- dump_value_range (dump_file, &vr_arg);
+ dump_value_range (dump_file, vr_arg);
fprintf (dump_file, "\n");
}
if (first)
- vr_result->deep_copy (&vr_arg);
+ vr_result->deep_copy (vr_arg);
else
- vr_result->union_ (&vr_arg);
+ vr_result->union_ (vr_arg);
first = false;
if (vr_result->varying_p ())
vrp_val_max (vr_result->type ()),
build_int_cst (vr_result->type (), 1));
- *vr_result = value_range (vr_result->kind (), new_min, new_max,
- vr_result->equiv ());
+ vr_result->update (vr_result->kind (), new_min, new_max);
/* If we dropped either bound to +-INF then if this is a loop
PHI node SCEV may known more about its value-range. */
tree op0 = gimple_assign_rhs1 (stmt);
tree op1 = gimple_assign_rhs2 (stmt);
tree op = NULL_TREE;
- value_range vr0, vr1;
+ value_range_base vr0, vr1;
wide_int may_be_nonzero0, may_be_nonzero1;
wide_int must_be_nonzero0, must_be_nonzero1;
wide_int mask;
if (TREE_CODE (op0) == SSA_NAME)
vr0 = *(get_value_range (op0));
else if (is_gimple_min_invariant (op0))
- set_value_range_to_value (&vr0, op0, NULL);
+ vr0.set (op0);
else
return false;
if (TREE_CODE (op1) == SSA_NAME)
vr1 = *(get_value_range (op1));
else if (is_gimple_min_invariant (op1))
- set_value_range_to_value (&vr1, op1, NULL);
+ vr1.set (op1);
else
return false;
bool vrp_stmt_computes_nonzero (gimple *);
bool op_with_boolean_value_range_p (tree);
bool check_for_binary_op_overflow (enum tree_code, tree, tree, tree, bool *);
- value_range get_vr_for_comparison (int);
+ value_range *get_vr_for_comparison (int, value_range *);
tree compare_name_with_value (enum tree_code, tree, tree, bool *, bool);
tree compare_names (enum tree_code, tree, tree, bool *);
bool two_valued_val_range_p (tree, tree *, tree *);
projects / gcc.git / commitdiff