* [PATCH] More VRP strict-overflow stuff
@ 2017-05-09 8:32 Richard Biener
0 siblings, 0 replies; only message in thread
From: Richard Biener @ 2017-05-09 8:32 UTC (permalink / raw)
To: gcc-patches
This removes the remaining case (hopefully) where we disabled
optimization during propagation when we encountered cases that
require undefined overflow knowledge.
Bootstrapped and tested on x86_64-unknown-linux-gnu, applied to trunk.
I don't plan to immediately remove the warnings emitted at final
folding time (though given test coverage for the propagation stuff
I don't expect any fallout if I'd do that).
Richard.
2017-05-09 Richard Biener <rguenther@suse.de>
* tree-vrp.c (get_single_symbol): Add assert that we don't
get overflowed constants as invariant part.
(compare_values_warnv): Add comment before the TREE_NO_WARNING
checks. Use wi::cmp instead of recursing for integer constants.
(compare_values): Just ignore whether we assumed undefined
overflow instead of failing the compare.
(extract_range_for_var_from_comparison_expr): Add comment before the
TREE_NO_WARNING sets.
(test_for_singularity): Likewise.
(extract_range_from_comparison): Do not disable optimization
when we assumed undefined overflow.
(extract_range_basic): Remove init of unused var.
Index: gcc/tree-vrp.c
===================================================================
--- gcc/tree-vrp.c (revision 247738)
+++ gcc/tree-vrp.c (working copy)
@@ -803,6 +803,8 @@ get_single_symbol (tree t, bool *neg, tr
if (TREE_CODE (t) != SSA_NAME)
return NULL_TREE;
+ gcc_assert (! inv_ || ! TREE_OVERFLOW_P (inv_));
+
*neg = neg_;
*inv = inv_;
return t;
@@ -1069,6 +1071,8 @@ compare_values_warnv (tree val1, tree va
return -2;
if (strict_overflow_p != NULL
+ /* Symbolic range building sets TREE_NO_WARNING to declare
+ that overflow doesn't happen. */
&& (!inv1 || !TREE_NO_WARNING (val1))
&& (!inv2 || !TREE_NO_WARNING (val2)))
*strict_overflow_p = true;
@@ -1078,7 +1082,7 @@ compare_values_warnv (tree val1, tree va
if (!inv2)
inv2 = build_int_cst (TREE_TYPE (val2), 0);
- return compare_values_warnv (inv1, inv2, strict_overflow_p);
+ return wi::cmp (inv1, inv2, TYPE_SIGN (TREE_TYPE (val1)));
}
const bool cst1 = is_gimple_min_invariant (val1);
@@ -1092,6 +1096,8 @@ compare_values_warnv (tree val1, tree va
return -2;
if (strict_overflow_p != NULL
+ /* Symbolic range building sets TREE_NO_WARNING to declare
+ that overflow doesn't happen. */
&& (!sym1 || !TREE_NO_WARNING (val1))
&& (!sym2 || !TREE_NO_WARNING (val2)))
*strict_overflow_p = true;
@@ -1119,14 +1125,9 @@ compare_values_warnv (tree val1, tree va
if (!POINTER_TYPE_P (TREE_TYPE (val1)))
{
- /* We cannot compare overflowed values, except for overflow
- infinities. */
+ /* We cannot compare overflowed values. */
if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2))
- {
- if (strict_overflow_p != NULL)
- *strict_overflow_p = true;
- return -2;
- }
+ return -2;
return tree_int_cst_compare (val1, val2);
}
@@ -1162,21 +1163,13 @@ compare_values_warnv (tree val1, tree va
}
}
-/* Compare values like compare_values_warnv, but treat comparisons of
- nonconstants which rely on undefined overflow as incomparable. */
+/* Compare values like compare_values_warnv. */
static int
compare_values (tree val1, tree val2)
{
bool sop;
- int ret;
-
- sop = false;
- ret = compare_values_warnv (val1, val2, &sop);
- if (sop
- && (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2)))
- ret = -2;
- return ret;
+ return compare_values_warnv (val1, val2, &sop);
}
@@ -1499,6 +1492,7 @@ extract_range_for_var_from_comparison_ex
else
max = fold_build2 (MINUS_EXPR, TREE_TYPE (max), max,
build_int_cst (TREE_TYPE (max), 1));
+ /* Signal to compare_values_warnv this expr doesn't overflow. */
if (EXPR_P (max))
TREE_NO_WARNING (max) = 1;
}
@@ -1538,6 +1532,7 @@ extract_range_for_var_from_comparison_ex
else
min = fold_build2 (PLUS_EXPR, TREE_TYPE (min), min,
build_int_cst (TREE_TYPE (min), 1));
+ /* Signal to compare_values_warnv this expr doesn't overflow. */
if (EXPR_P (min))
TREE_NO_WARNING (min) = 1;
}
@@ -3448,18 +3441,12 @@ static void
extract_range_from_comparison (value_range *vr, enum tree_code code,
tree type, tree op0, tree op1)
{
- bool sop = false;
+ bool sop;
tree val;
val = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, false, &sop,
NULL);
-
- /* A disadvantage of using a special infinity as an overflow
- representation is that we lose the ability to record overflow
- when we don't have an infinity. So we have to ignore a result
- which relies on overflow. */
-
- if (val && !sop)
+ if (val)
{
/* Since this expression was found on the RHS of an assignment,
its type may be different from _Bool. Convert VAL to EXPR's
@@ -3589,7 +3576,7 @@ check_for_binary_op_overflow (enum tree_
static void
extract_range_basic (value_range *vr, gimple *stmt)
{
- bool sop = false;
+ bool sop;
tree type = gimple_expr_type (stmt);
if (is_gimple_call (stmt))
@@ -9498,6 +9485,7 @@ test_for_singularity (enum tree_code con
{
tree one = build_int_cst (TREE_TYPE (op0), 1);
max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one);
+ /* Signal to compare_values_warnv this expr doesn't overflow. */
if (EXPR_P (max))
TREE_NO_WARNING (max) = 1;
}
@@ -9513,6 +9501,7 @@ test_for_singularity (enum tree_code con
{
tree one = build_int_cst (TREE_TYPE (op0), 1);
min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one);
+ /* Signal to compare_values_warnv this expr doesn't overflow. */
if (EXPR_P (min))
TREE_NO_WARNING (min) = 1;
}
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2017-05-09 8:13 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2017-05-09 8:32 [PATCH] More VRP strict-overflow stuff Richard Biener
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).