From: Bin Cheng Date: Fri, 22 Jul 2016 13:25:59 +0000 (+0000) Subject: common.opt (funsafe-loop-optimizations): Mark ignore. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=78f63b79d9edb87545c40c116dd7859b74e67263;p=gcc.git common.opt (funsafe-loop-optimizations): Mark ignore. * common.opt (funsafe-loop-optimizations): Mark ignore. * doc/invoke.texi (funsafe-loop-optimizations): Remove. * loop-iv.c (get_simple_loop_desc): Remove unsafe-loop-optimizations related code. * tree-ssa-loop-niter.c (finite_loop_p): Ditto. * config/bfin/bfin.c (bfin_can_use_doloop_p): Ditto. From-SVN: r238642 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e8c40d829e9..4f67430ec6f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,12 @@ +2016-07-22 Bin Cheng + + * common.opt (funsafe-loop-optimizations): Mark ignore. + * doc/invoke.texi (funsafe-loop-optimizations): Remove. + * loop-iv.c (get_simple_loop_desc): Remove unsafe-loop-optimizations + related code. + * tree-ssa-loop-niter.c (finite_loop_p): Ditto. + * config/bfin/bfin.c (bfin_can_use_doloop_p): Ditto. + 2016-07-22 Bin Cheng * tree-ssa-loop-niter.h (number_of_iterations_exit_assumptions): New diff --git a/gcc/common.opt b/gcc/common.opt index b56ba47d0a7..8a292ed78c8 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -2507,8 +2507,8 @@ Perform loop unrolling for all loops. ; that control loops do not overflow and that the loops with nontrivial ; exit condition are not infinite funsafe-loop-optimizations -Common Report Var(flag_unsafe_loop_optimizations) Optimization -Allow loop optimizations to assume that the loops behave in normal way. +Common Ignore +Does nothing. Preserved for backward compatibility. fassociative-math Common Report Var(flag_associative_math) SetByCombined Optimization diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c index 75ddcf04725..b6edf2c1c32 100644 --- a/gcc/config/bfin/bfin.c +++ b/gcc/config/bfin/bfin.c @@ -3375,10 +3375,7 @@ bfin_can_use_doloop_p (const widest_int &, const widest_int &iterations_max, /* Due to limitations in the hardware (an initial loop count of 0 does not loop 2^32 times) we must avoid to generate a hardware loops when we cannot rule out this case. */ - if (!flag_unsafe_loop_optimizations - && wi::geu_p (iterations_max, 0xFFFFFFFF)) - return false; - return true; + return (wi::ltu_p (iterations_max, 0xFFFFFFFF)); } /* Increment the counter for the number of loop instructions in the diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 9e039869cc6..c9e8e1d7157 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -414,7 +414,7 @@ Objective-C and Objective-C++ Dialects}. -ftree-switch-conversion -ftree-tail-merge -ftree-ter @gol -ftree-vectorize -ftree-vrp -funconstrained-commons @gol -funit-at-a-time -funroll-all-loops -funroll-loops @gol --funsafe-loop-optimizations -funsafe-math-optimizations -funswitch-loops @gol +-funsafe-math-optimizations -funswitch-loops @gol -fipa-ra -fvariable-expansion-in-unroller -fvect-cost-model -fvpt @gol -fweb -fwhole-program -fwpa -fuse-linker-plugin @gol --param @var{name}=@var{value} @@ -6818,15 +6818,6 @@ number of iterations of a loop are used to guide loop unrolling and peeling and loop exit test optimizations. This option is enabled by default. -@item -funsafe-loop-optimizations -@opindex funsafe-loop-optimizations -This option tells the loop optimizer to assume that loop indices do not -overflow, and that loops with nontrivial exit condition are not -infinite. This enables a wider range of loop optimizations even if -the loop optimizer itself cannot prove that these assumptions are valid. -If you use @option{-Wunsafe-loop-optimizations}, the compiler warns you -if it finds this kind of loop. - @item -funconstrained-commons @opindex funconstrained-commons This option tells the compiler that variables declared in common blocks diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c index 68cfd0ef9c8..78bec9e8521 100644 --- a/gcc/loop-iv.c +++ b/gcc/loop-iv.c @@ -3027,42 +3027,6 @@ get_simple_loop_desc (struct loop *loop) iv_analysis_loop_init (loop); find_simple_exit (loop, desc); loop->simple_loop_desc = desc; - - if (desc->simple_p && (desc->assumptions || desc->infinite)) - { - const char *wording; - - /* Assume that no overflow happens and that the loop is finite. - We already warned at the tree level if we ran optimizations there. */ - if (!flag_tree_loop_optimize && warn_unsafe_loop_optimizations) - { - if (desc->infinite) - { - wording = - flag_unsafe_loop_optimizations - ? N_("assuming that the loop is not infinite") - : N_("cannot optimize possibly infinite loops"); - warning (OPT_Wunsafe_loop_optimizations, "%s", - gettext (wording)); - } - if (desc->assumptions) - { - wording = - flag_unsafe_loop_optimizations - ? N_("assuming that the loop counter does not overflow") - : N_("cannot optimize loop, the loop counter may overflow"); - warning (OPT_Wunsafe_loop_optimizations, "%s", - gettext (wording)); - } - } - - if (flag_unsafe_loop_optimizations && single_exit (loop)) - { - desc->assumptions = NULL_RTX; - desc->infinite = NULL_RTX; - } - } - return desc; } diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c index ee6d5cfe0fd..b7d7c324efd 100644 --- a/gcc/tree-ssa-loop-niter.c +++ b/gcc/tree-ssa-loop-niter.c @@ -2362,8 +2362,6 @@ finite_loop_p (struct loop *loop) widest_int nit; int flags; - if (flag_unsafe_loop_optimizations) - return true; flags = flags_from_decl_or_type (current_function_decl); if ((flags & (ECF_CONST|ECF_PURE)) && !(flags & ECF_LOOPING_CONST_OR_PURE)) {