On Wed, May 27, 2026 at 5:51 AM Daniel Barboza
<[email protected]> wrote:
>
> fold_undefer_overflow_warnings () is one of the last few places where
> Wstrict_overflow warnings are issued. It uses a
> fold_deferring_overflow_warnings int to determine whether the warning should
> be shown, a fold_defer_overflow_warnings helper that increments it,
> a fold_deferred_overflow_warning string that stores the
> deferred warning, an enum for the warning level of the deferred warning.
>
> Remove all of them along with any related logic.
>
> gcc/c-family/ChangeLog:
>
> * c-common.cc (pointer_int_sum): Removed
> fold_*_overflow_warnings uses.
>
> gcc/c/ChangeLog:
>
> * c-fold.cc (c_disable_warnings): Likewise.
> (c_enable_warnings): Likewise.
>
> gcc/ChangeLog:
>
> * flags.h (issue_strict_overflow_warning): Removed.
> * fold-const.cc (fold_defer_overflow_warnings): Removed.
> (fold_undefer_overflow_warnings): Removed.
> (fold_undefer_and_ignore_overflow_warnings): Removed.
> (fold_deferring_overflow_warnings_p): Removed.
> * fold-const.h (fold_defer_overflow_warnings): Removed.
> (fold_undefer_overflow_warnings): Removed.
> (fold_undefer_and_ignore_overflow_warnings): Removed.
> (fold_deferring_overflow_warnings_p): Removed.
> * gimple-fold.cc (fold_stmt_1): Removed
> fold_*_overflow_warnings uses and all related logic.
> * passes.cc (verify_interpass_invariants): Likewise.
> (execute_one_ipa_transform_pass): Likewise.
> (execute_one_pass): Likewise.
> * tree-cfgcleanup.cc (cleanup_control_expr_graph): Likewise.
> * tree-data-ref.cc (create_runtime_alias_checks): Likewise.
> * tree-ssa-ccp.cc (evaluate_stmt): Likewise.
> * tree-ssa-forwprop.cc (combine_cond_expr_cond): Likewise.
> * tree-ssa-loop-niter.cc (expand_simple_operations): Likewise.
> (number_of_iterations_exit_assumptions): Likewise.
> (loop_niter_by_eval): Likewise.
> (estimate_numbers_of_iterations): Likewise.
> (loop_exits_before_overflow): Likewise.
> * tree-ssa-threadedge.cc: Likewise.
> * tree-vrp.cc (compare_values): Likewise.
Ok.
> ---
> gcc/c-family/c-common.cc | 10 ----
> gcc/c/c-fold.cc | 2 -
> gcc/flags.h | 3 --
> gcc/fold-const.cc | 99 --------------------------------------
> gcc/fold-const.h | 4 --
> gcc/gimple-fold.cc | 5 --
> gcc/passes.cc | 12 -----
> gcc/tree-cfgcleanup.cc | 17 +------
> gcc/tree-data-ref.cc | 2 -
> gcc/tree-ssa-ccp.cc | 7 +--
> gcc/tree-ssa-forwprop.cc | 14 +-----
> gcc/tree-ssa-loop-niter.cc | 40 ++-------------
> gcc/tree-ssa-threadedge.cc | 7 ---
> gcc/tree-vrp.cc | 13 +----
> 14 files changed, 9 insertions(+), 226 deletions(-)
>
> diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
> index 874530f065d..34bade53f6a 100644
> --- a/gcc/c-family/c-common.cc
> +++ b/gcc/c-family/c-common.cc
> @@ -3422,12 +3422,6 @@ pointer_int_sum (location_t loc, enum tree_code
> resultcode,
> }
> }
>
> - /* We are manipulating pointer values, so we don't need to warn
> - about relying on undefined signed overflow. We disable the
> - warning here because we use integer types so fold won't know that
> - they are really pointers. */
> - fold_defer_overflow_warnings ();
> -
> /* If what we are about to multiply by the size of the elements
> contains a constant term, apply distributive law
> and multiply that constant term separately.
> @@ -3476,8 +3470,6 @@ pointer_int_sum (location_t loc, enum tree_code
> resultcode,
>
> ret = fold_build_pointer_plus_loc (loc, ptrop, intop);
>
> - fold_undefer_and_ignore_overflow_warnings ();
> -
> return ret;
> }
>
> @@ -3506,8 +3498,6 @@ pointer_int_sum (location_t loc, enum tree_code
> resultcode,
>
> ret = fold_build_pointer_plus_loc (loc, ptrop, intop);
>
> - fold_undefer_and_ignore_overflow_warnings ();
> -
> return ret;
> }
>
> diff --git a/gcc/c/c-fold.cc b/gcc/c/c-fold.cc
> index 122049daf87..42f8a6fb33d 100644
> --- a/gcc/c/c-fold.cc
> +++ b/gcc/c/c-fold.cc
> @@ -40,7 +40,6 @@ c_disable_warnings (bool disable)
> if (disable)
> {
> ++c_inhibit_evaluation_warnings;
> - fold_defer_overflow_warnings ();
> }
> }
>
> @@ -52,7 +51,6 @@ c_enable_warnings (bool enable)
> if (enable)
> {
> --c_inhibit_evaluation_warnings;
> - fold_undefer_and_ignore_overflow_warnings ();
> }
> }
>
> diff --git a/gcc/flags.h b/gcc/flags.h
> index c92a7bdfa6f..2b744be72a3 100644
> --- a/gcc/flags.h
> +++ b/gcc/flags.h
> @@ -113,9 +113,6 @@ extern class target_flag_state *this_target_flag_state;
> #define abi_version_at_least(N) \
> (flag_abi_version == 0 || flag_abi_version >= (N))
>
> -/* Whether to emit an overflow warning whose code is C. */
> -#define issue_strict_overflow_warning(c) (warn_strict_overflow >= (int) (c))
> -
> #endif /* ! in target library */
>
> #endif /* ! GCC_FLAGS_H */
> diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
> index 352083e146b..fc215828b34 100644
> --- a/gcc/fold-const.cc
> +++ b/gcc/fold-const.cc
> @@ -264,105 +264,6 @@ protected_set_expr_location_unshare (tree x, location_t
> loc)
> }
> return x;
> }
> -
> -/* This is nonzero if we should defer warnings about undefined
> - overflow. This facility exists because these warnings are a
> - special case. The code to estimate loop iterations does not want
> - to issue any warnings, since it works with expressions which do not
> - occur in user code. Various bits of cleanup code call fold(), but
> - only use the result if it has certain characteristics (e.g., is a
> - constant); that code only wants to issue a warning if the result is
> - used. */
> -
> -static int fold_deferring_overflow_warnings;
> -
> -/* If a warning about undefined overflow is deferred, this is the
> - warning. Note that this may cause us to turn two warnings into
> - one, but that is fine since it is sufficient to only give one
> - warning per expression. */
> -
> -static const char* fold_deferred_overflow_warning;
> -
> -/* If a warning about undefined overflow is deferred, this is the
> - level at which the warning should be emitted. */
> -
> -static enum warn_strict_overflow_code fold_deferred_overflow_code;
> -
> -/* Start deferring overflow warnings. We could use a stack here to
> - permit nested calls, but at present it is not necessary. */
> -
> -void
> -fold_defer_overflow_warnings (void)
> -{
> - ++fold_deferring_overflow_warnings;
> -}
> -
> -/* Stop deferring overflow warnings. If there is a pending warning,
> - and ISSUE is true, then issue the warning if appropriate. STMT is
> - the statement with which the warning should be associated (used for
> - location information); STMT may be NULL. CODE is the level of the
> - warning--a warn_strict_overflow_code value. This function will use
> - the smaller of CODE and the deferred code when deciding whether to
> - issue the warning. CODE may be zero to mean to always use the
> - deferred code. */
> -
> -void
> -fold_undefer_overflow_warnings (bool issue, const gimple *stmt, int code)
> -{
> - const char *warnmsg;
> - location_t locus;
> -
> - gcc_assert (fold_deferring_overflow_warnings > 0);
> - --fold_deferring_overflow_warnings;
> - if (fold_deferring_overflow_warnings > 0)
> - {
> - if (fold_deferred_overflow_warning != NULL
> - && code != 0
> - && code < (int) fold_deferred_overflow_code)
> - fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
> - return;
> - }
> -
> - warnmsg = fold_deferred_overflow_warning;
> - fold_deferred_overflow_warning = NULL;
> -
> - if (!issue || warnmsg == NULL)
> - return;
> -
> - if (warning_suppressed_p (stmt, OPT_Wstrict_overflow))
> - return;
> -
> - /* Use the smallest code level when deciding to issue the
> - warning. */
> - if (code == 0 || code > (int) fold_deferred_overflow_code)
> - code = fold_deferred_overflow_code;
> -
> - if (!issue_strict_overflow_warning (code))
> - return;
> -
> - if (stmt == NULL)
> - locus = input_location;
> - else
> - locus = gimple_location (stmt);
> - warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
> -}
> -
> -/* Stop deferring overflow warnings, ignoring any deferred
> - warnings. */
> -
> -void
> -fold_undefer_and_ignore_overflow_warnings (void)
> -{
> - fold_undefer_overflow_warnings (false, NULL, 0);
> -}
> -
> -/* Whether we are deferring overflow warnings. */
> -
> -bool
> -fold_deferring_overflow_warnings_p (void)
> -{
> - return fold_deferring_overflow_warnings > 0;
> -}
>
> /* Return true if the built-in mathematical function specified by CODE
> is odd, i.e. -f(x) == f(-x). */
> diff --git a/gcc/fold-const.h b/gcc/fold-const.h
> index ca464ce60af..592b42c72df 100644
> --- a/gcc/fold-const.h
> +++ b/gcc/fold-const.h
> @@ -99,10 +99,6 @@ extern tree fold_convert_loc (location_t, tree, tree);
> extern tree fold_ignored_result (tree);
> extern tree fold_abs_const (tree, tree);
> extern tree fold_indirect_ref_1 (location_t, tree, tree);
> -extern void fold_defer_overflow_warnings (void);
> -extern void fold_undefer_overflow_warnings (bool, const gimple *, int);
> -extern void fold_undefer_and_ignore_overflow_warnings (void);
> -extern bool fold_deferring_overflow_warnings_p (void);
> extern enum tree_code fold_div_compare (enum tree_code, tree, tree,
> tree *, tree *, bool *);
> extern bool operand_equal_p (const_tree, const_tree, unsigned int flags = 0);
> diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
> index a2f9de53855..effea60f827 100644
> --- a/gcc/gimple-fold.cc
> +++ b/gcc/gimple-fold.cc
> @@ -6723,9 +6723,7 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace,
> tree (*valueize) (tree),
> {
> bool changed = false;
> gimple *stmt = gsi_stmt (*gsi);
> - bool nowarning = warning_suppressed_p (stmt, OPT_Wstrict_overflow);
> unsigned i;
> - fold_defer_overflow_warnings ();
>
> /* First do required canonicalization of [TARGET_]MEM_REF addresses
> after propagation.
> @@ -7000,9 +6998,6 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace,
> tree (*valueize) (tree),
> default:;
> }
>
> - stmt = gsi_stmt (*gsi);
> -
> - fold_undefer_overflow_warnings (changed && !nowarning, stmt, 0);
> return changed;
> }
>
> diff --git a/gcc/passes.cc b/gcc/passes.cc
> index 9ec37eeb2a9..a2f0d694b8b 100644
> --- a/gcc/passes.cc
> +++ b/gcc/passes.cc
> @@ -2181,15 +2181,6 @@ execute_todo (unsigned int flags)
> df_finish_pass ((flags & TODO_df_verify) != 0);
> }
>
> -/* Verify invariants that should hold between passes. This is a place
> - to put simple sanity checks. */
> -
> -static void
> -verify_interpass_invariants (void)
> -{
> - gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
> -}
I was going to suggest we keep verify_interpass_invariants but have it empty.
But we already have other places which verify the other invariants in
execute_function_todo via TODO_verify_il which is now done by all
passes now.
> -
> /* Helper function. Verify that the properties has been turn into the
> properties expected by the pass. */
>
> @@ -2338,7 +2329,6 @@ execute_one_ipa_transform_pass (struct cgraph_node
> *node,
> /* Run post-pass cleanup. */
> gcc_checking_assert (!(todo_after & TODO_verify_il));
> execute_todo (todo_after);
> - verify_interpass_invariants ();
>
> /* Stop timevar. */
> if (pass->tv_id != TV_NONE)
> @@ -2714,8 +2704,6 @@ execute_one_pass (opt_pass *pass)
> }
> }
>
> - verify_interpass_invariants ();
> -
> /* Stop timevar. */
> if (pass->tv_id != TV_NONE)
> timevar_pop (pass->tv_id);
> diff --git a/gcc/tree-cfgcleanup.cc b/gcc/tree-cfgcleanup.cc
> index 85b9a3cedaa..84a40e8d5f1 100644
> --- a/gcc/tree-cfgcleanup.cc
> +++ b/gcc/tree-cfgcleanup.cc
> @@ -173,7 +173,6 @@ cleanup_control_expr_graph (basic_block bb,
> gimple_stmt_iterator gsi)
> {
> edge e;
> edge_iterator ei;
> - bool warned;
> tree val = NULL_TREE;
>
> /* Try to convert a switch with just a single non-default case to
> @@ -185,7 +184,6 @@ cleanup_control_expr_graph (basic_block bb,
> gimple_stmt_iterator gsi)
> if (gimple_code (stmt) == GIMPLE_COND)
> canonicalize_bool_cond (as_a<gcond*> (stmt), bb);
>
> - fold_defer_overflow_warnings ();
> switch (gimple_code (stmt))
> {
> case GIMPLE_COND:
> @@ -207,24 +205,13 @@ cleanup_control_expr_graph (basic_block bb,
> gimple_stmt_iterator gsi)
> }
> taken_edge = find_taken_edge (bb, val);
> if (!taken_edge)
> - {
> - fold_undefer_and_ignore_overflow_warnings ();
> - return false;
> - }
> + return false;
>
> /* Remove all the edges except the one that is always executed. */
> - warned = false;
> for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
> {
> if (e != taken_edge)
> {
> - if (!warned)
> - {
> - fold_undefer_overflow_warnings
> - (true, stmt, WARN_STRICT_OVERFLOW_CONDITIONAL);
> - warned = true;
> - }
> -
> taken_edge->probability += e->probability;
> remove_edge_and_dominated_blocks (e);
> retval = true;
> @@ -232,8 +219,6 @@ cleanup_control_expr_graph (basic_block bb,
> gimple_stmt_iterator gsi)
> else
> ei_next (&ei);
> }
> - if (!warned)
> - fold_undefer_and_ignore_overflow_warnings ();
> }
> else
> taken_edge = single_succ_edge (bb);
> diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc
> index e60039b4776..a0c727ff83c 100644
> --- a/gcc/tree-data-ref.cc
> +++ b/gcc/tree-data-ref.cc
> @@ -2676,7 +2676,6 @@ create_runtime_alias_checks (class loop *loop,
> {
> tree part_cond_expr;
>
> - fold_defer_overflow_warnings ();
> for (const dr_with_seg_len_pair_t &alias_pair : alias_pairs)
> {
> gcc_assert (alias_pair.flags);
> @@ -2694,7 +2693,6 @@ create_runtime_alias_checks (class loop *loop,
> else
> *cond_expr = part_cond_expr;
> }
> - fold_undefer_and_ignore_overflow_warnings ();
> }
>
> /* Check if OFFSET1 and OFFSET2 (DR_OFFSETs of some data-refs) are identical
> diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc
> index d9a41c2e135..a9508b0827c 100644
> --- a/gcc/tree-ssa-ccp.cc
> +++ b/gcc/tree-ssa-ccp.cc
> @@ -2263,7 +2263,6 @@ evaluate_stmt (gimple *stmt)
> not attempt to fold them, including builtins that may profit. */
> if (likelyvalue == CONSTANT)
> {
> - fold_defer_overflow_warnings ();
> simplified = ccp_fold (stmt);
> if (simplified
> && TREE_CODE (simplified) == SSA_NAME)
> @@ -2275,10 +2274,7 @@ evaluate_stmt (gimple *stmt)
> {
> ccp_prop_value_t *val = get_value (simplified);
> if (val && val->lattice_val != VARYING)
> - {
> - fold_undefer_overflow_warnings (true, stmt, 0);
> - return *val;
> - }
> + return *val;
> }
> else
> /* We may also not place a non-valueized copy in the lattice
> @@ -2286,7 +2282,6 @@ evaluate_stmt (gimple *stmt)
> simplified = NULL_TREE;
> }
> is_constant = simplified && is_gimple_min_invariant (simplified);
> - fold_undefer_overflow_warnings (is_constant, stmt, 0);
> if (is_constant)
> {
> /* The statement produced a constant value. */
> diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc
> index 06eb81b9a28..4fbdaf7c16b 100644
> --- a/gcc/tree-ssa-forwprop.cc
> +++ b/gcc/tree-ssa-forwprop.cc
> @@ -407,13 +407,9 @@ combine_cond_expr_cond (gimple *stmt, enum tree_code
> code, tree type,
>
> gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
>
> - fold_defer_overflow_warnings ();
> t = fold_binary_loc (gimple_location (stmt), code, type, op0, op1);
> if (!t)
> - {
> - fold_undefer_overflow_warnings (false, NULL, 0);
> - return NULL_TREE;
> - }
> + return NULL_TREE;
>
> /* Require that we got a boolean type out if we put one in. */
> gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type));
> @@ -423,13 +419,7 @@ combine_cond_expr_cond (gimple *stmt, enum tree_code
> code, tree type,
>
> /* Bail out if we required an invariant but didn't get one. */
> if (!t || (invariant_only && !is_gimple_min_invariant (t)))
> - {
> - fold_undefer_overflow_warnings (false, NULL, 0);
> - return NULL_TREE;
> - }
> -
> - bool nowarn = warning_suppressed_p (stmt, OPT_Wstrict_overflow);
> - fold_undefer_overflow_warnings (!nowarn, stmt, 0);
> + return NULL_TREE;
>
> return t;
> }
> diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
> index f179be1ffc7..13b0b5bf201 100644
> --- a/gcc/tree-ssa-loop-niter.cc
> +++ b/gcc/tree-ssa-loop-niter.cc
> @@ -2842,9 +2842,7 @@ expand_simple_operations (tree expr, tree stop,
> hash_map<tree, tree> &cache)
> if (!ret)
> return expr;
>
> - fold_defer_overflow_warnings ();
> ret = fold (ret);
> - fold_undefer_and_ignore_overflow_warnings ();
> return ret;
> }
>
> @@ -3288,10 +3286,6 @@ number_of_iterations_exit_assumptions (class loop
> *loop, edge exit,
> if (iv0_niters && iv1_niters)
> return false;
>
> - /* We don't want to see undefined signed overflow warnings while
> - computing the number of iterations. */
> - fold_defer_overflow_warnings ();
> -
> iv0.base = expand_simple_operations (iv0.base);
> iv1.base = expand_simple_operations (iv1.base);
> bool body_from_caller = true;
> @@ -3306,7 +3300,6 @@ number_of_iterations_exit_assumptions (class loop
> *loop, edge exit,
> if (!number_of_iterations_cond (loop, type, &iv0, code, &iv1, niter,
> only_exit_p, safe))
> {
> - fold_undefer_and_ignore_overflow_warnings ();
> return false;
> }
>
> @@ -3349,8 +3342,6 @@ number_of_iterations_exit_assumptions (class loop
> *loop, edge exit,
> = simplify_using_initial_conditions (loop,
> niter->may_be_zero);
>
> - fold_undefer_and_ignore_overflow_warnings ();
> -
> /* If NITER has simplified into a constant, update MAX. */
> if (TREE_CODE (niter->niter) == INTEGER_CST)
> niter->max = wi::to_widest (niter->niter);
> @@ -3747,9 +3738,6 @@ loop_niter_by_eval (class loop *loop, edge exit)
> }
> }
>
> - /* Don't issue signed overflow warnings. */
> - fold_defer_overflow_warnings ();
> -
> for (i = 0; i < MAX_ITERATIONS_TO_TRACK; i++)
> {
> for (j = 0; j < 2; j++)
> @@ -3758,7 +3746,6 @@ loop_niter_by_eval (class loop *loop, edge exit)
> acnd = fold_binary (cmp, boolean_type_node, aval[0], aval[1]);
> if (acnd && integer_zerop (acnd))
> {
> - fold_undefer_and_ignore_overflow_warnings ();
> if (dump_file && (dump_flags & TDF_DETAILS))
> fprintf (dump_file,
> "Proved that loop %d iterates %d times using brute
> force.\n",
> @@ -3771,10 +3758,7 @@ loop_niter_by_eval (class loop *loop, edge exit)
> aval[j] = val[j];
> val[j] = get_val_for (next[j], val[j]);
> if (!is_gimple_min_invariant (val[j]))
> - {
> - fold_undefer_and_ignore_overflow_warnings ();
> - return chrec_dont_know;
> - }
> + return chrec_dont_know;
> }
>
> /* If the next iteration would use the same base values
> @@ -3784,8 +3768,6 @@ loop_niter_by_eval (class loop *loop, edge exit)
> break;
> }
>
> - fold_undefer_and_ignore_overflow_warnings ();
> -
> return chrec_dont_know;
> }
>
> @@ -5242,14 +5224,8 @@ estimated_stmt_executions (class loop *loop,
> widest_int *nit)
> void
> estimate_numbers_of_iterations (function *fn)
> {
> - /* We don't want to issue signed overflow warnings while getting
> - loop iteration estimates. */
> - fold_defer_overflow_warnings ();
> -
> for (auto loop : loops_list (fn, 0))
> estimate_numbers_of_iterations (loop);
> -
> - fold_undefer_and_ignore_overflow_warnings ();
> }
>
> /* Returns true if statement S1 dominates statement S2. */
> @@ -5394,9 +5370,6 @@ loop_exits_before_overflow (tree base, tree step,
> tree type = TREE_TYPE (step);
> tree unsigned_type, valid_niter;
>
> - /* Don't issue signed overflow warnings. */
> - fold_defer_overflow_warnings ();
> -
> /* Compute the number of iterations before we reach the bound of the
> type, and verify that the loop is exited before this occurs. */
> unsigned_type = unsigned_type_for (type);
> @@ -5428,20 +5401,13 @@ loop_exits_before_overflow (tree base, tree step,
> wide_int_to_tree (TREE_TYPE (valid_niter),
> niter))) != NULL
> && integer_nonzerop (e))
> - {
> - fold_undefer_and_ignore_overflow_warnings ();
> - return true;
> - }
> + return true;
> if (at_stmt)
> for (bound = loop->bounds; bound; bound = bound->next)
> {
> if (n_of_executions_at_most (at_stmt, bound, valid_niter))
> - {
> - fold_undefer_and_ignore_overflow_warnings ();
> - return true;
> - }
> + return true;
> }
> - fold_undefer_and_ignore_overflow_warnings ();
>
> /* Try to prove loop is exited before {base, step} overflows with the
> help of analyzed loop control IV. This is done only for IVs with
> diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc
> index 9fc0c5ed2a2..3996730d937 100644
> --- a/gcc/tree-ssa-threadedge.cc
> +++ b/gcc/tree-ssa-threadedge.cc
> @@ -500,18 +500,11 @@ jump_threader::simplify_control_stmt_condition_1
> gimple_cond_set_lhs (dummy_cond, op0);
> gimple_cond_set_rhs (dummy_cond, op1);
>
> - /* We absolutely do not care about any type conversions
> - we only care about a zero/nonzero value. */
> - fold_defer_overflow_warnings ();
> -
> tree res = fold_binary (cond_code, boolean_type_node, op0, op1);
> if (res)
> while (CONVERT_EXPR_P (res))
> res = TREE_OPERAND (res, 0);
>
> - fold_undefer_overflow_warnings ((res && is_gimple_min_invariant (res)),
> - stmt, WARN_STRICT_OVERFLOW_CONDITIONAL);
> -
> /* If we have not simplified the condition down to an invariant,
> then use the pass specific callback to simplify the condition. */
> if (!res
> diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
> index a112e5e1be2..4b09f18126b 100644
> --- a/gcc/tree-vrp.cc
> +++ b/gcc/tree-vrp.cc
> @@ -670,27 +670,18 @@ compare_values (tree val1, tree val2)
> if (operand_equal_p (val1, val2, 0))
> return 0;
>
> - fold_defer_overflow_warnings ();
> -
> /* If VAL1 is a lower address than VAL2, return -1. */
> tree t = fold_binary_to_constant (LT_EXPR, boolean_type_node, val1,
> val2);
> if (t && integer_onep (t))
> - {
> - fold_undefer_and_ignore_overflow_warnings ();
> - return -1;
> - }
> + return -1;
>
> /* If VAL1 is a higher address than VAL2, return +1. */
> t = fold_binary_to_constant (LT_EXPR, boolean_type_node, val2, val1);
> if (t && integer_onep (t))
> - {
> - fold_undefer_and_ignore_overflow_warnings ();
> - return 1;
> - }
> + return 1;
>
> /* If VAL1 is different than VAL2, return +2. */
> t = fold_binary_to_constant (NE_EXPR, boolean_type_node, val1, val2);
> - fold_undefer_and_ignore_overflow_warnings ();
> if (t && integer_onep (t))
> return 2;
>
> --
> 2.43.0
>
