From 1728f9df6169d57864e01c4f6ca9cad2b422972b Mon Sep 17 00:00:00 2001 From: Uwe Kleine-Koenig Date: Thu, 29 Jan 2009 11:04:39 +0000 Subject: backport fix for gcc PR#32044 This fixes an optimisation regression of gcc-4.3. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=32044 http://thread.gmane.org/gmane.linux.ports.arm.omap/15540/focus=15557 http://thread.gmane.org/gmane.linux.ports.arm.kernel/47539/focus=51934 for the glory details. git-svn-id: https://svn.pengutronix.de/svn/oselas/toolchain/trunks/OSELAS.Toolchain-trunk@9396 f8d472c7-5700-0410-ac5a-87979cec3adf --- ChangeLog | 3 + patches/gcc-4.3.2/generic/gcc-43-pr32044.diff | 206 ++++++++++++++++++++++++++ patches/gcc-4.3.2/generic/series | 1 + 3 files changed, 210 insertions(+) create mode 100644 patches/gcc-4.3.2/generic/gcc-43-pr32044.diff diff --git a/ChangeLog b/ChangeLog index 166e08c..cb2d456 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,6 @@ +2009-01-29 Uwe Kleine-König + * add patch for gcc 4.3.2 fixing some optimisation regressions. + 2008-09-18 Robert Schwebel * ptxconfigs: add toolchains based on gcc-4.3.2, glibc-2.8 and diff --git a/patches/gcc-4.3.2/generic/gcc-43-pr32044.diff b/patches/gcc-4.3.2/generic/gcc-43-pr32044.diff new file mode 100644 index 0000000..f754676 --- /dev/null +++ b/patches/gcc-4.3.2/generic/gcc-43-pr32044.diff @@ -0,0 +1,206 @@ +PR tree-optimization/32044 + +From: rakdver +Date: 2008-12-12 21:32:47 +0100 + +* tree-scalar-evolution.h (expression_expensive_p): Declare. +* tree-scalar-evolution.c (expression_expensive_p): New function. +(scev_const_prop): Avoid introducing expensive expressions. +* tree-ssa-loop-ivopts.c (may_eliminate_iv): Ditto. + +* gcc.dg/pr34027-1.c: Change outcome. +* gcc.dg/tree-ssa/pr32044.c: New test. + +cherry picked from svn://gcc.gnu.org/svn/gcc/trunk, rev 142719 and adapted to +apply on gcc 4.3.2 + +------------------------------------------------------------------------ +Index: gcc-4.3.2/gcc/tree-scalar-evolution.c +=================================================================== +--- gcc-4.3.2.orig/gcc/tree-scalar-evolution.c 2009-01-28 10:14:37.000000000 +0100 ++++ gcc-4.3.2/gcc/tree-scalar-evolution.c 2009-01-28 10:17:50.000000000 +0100 +@@ -2716,6 +2716,50 @@ + scalar_evolution_info = NULL; + } + ++/* Returns true if the expression EXPR is considered to be too expensive ++ for scev_const_prop. */ ++ ++bool ++expression_expensive_p (tree expr) ++{ ++ enum tree_code code; ++ ++ if (is_gimple_val (expr)) ++ return false; ++ ++ code = TREE_CODE (expr); ++ if (code == TRUNC_DIV_EXPR ++ || code == CEIL_DIV_EXPR ++ || code == FLOOR_DIV_EXPR ++ || code == ROUND_DIV_EXPR ++ || code == TRUNC_MOD_EXPR ++ || code == CEIL_MOD_EXPR ++ || code == FLOOR_MOD_EXPR ++ || code == ROUND_MOD_EXPR ++ || code == EXACT_DIV_EXPR) ++ { ++ /* Division by power of two is usually cheap, so we allow it. ++ Forbid anything else. */ ++ if (!integer_pow2p (TREE_OPERAND (expr, 1))) ++ return true; ++ } ++ ++ switch (TREE_CODE_CLASS (code)) ++ { ++ case tcc_binary: ++ case tcc_comparison: ++ if (expression_expensive_p (TREE_OPERAND (expr, 1))) ++ return true; ++ ++ /* Fallthru. */ ++ case tcc_unary: ++ return expression_expensive_p (TREE_OPERAND (expr, 0)); ++ ++ default: ++ return true; ++ } ++} ++ + /* Replace ssa names for that scev can prove they are constant by the + appropriate constants. Also perform final value replacement in loops, + in case the replacement expressions are cheap. +@@ -2802,12 +2846,6 @@ + continue; + + niter = number_of_latch_executions (loop); +- /* We used to check here whether the computation of NITER is expensive, +- and avoided final value elimination if that is the case. The problem +- is that it is hard to evaluate whether the expression is too +- expensive, as we do not know what optimization opportunities the +- the elimination of the final value may reveal. Therefore, we now +- eliminate the final values of induction variables unconditionally. */ + if (niter == chrec_dont_know) + continue; + +@@ -2838,7 +2876,15 @@ + /* Moving the computation from the loop may prolong life range + of some ssa names, which may cause problems if they appear + on abnormal edges. */ +- || contains_abnormal_ssa_name_p (def)) ++ || contains_abnormal_ssa_name_p (def) ++ /* Do not emit expensive expressions. The rationale is that ++ when someone writes a code like ++ ++ while (n > 45) n -= 45; ++ ++ he probably knows that n is not large, and does not want it ++ to be turned into n %= 45. */ ++ || expression_expensive_p (def)) + continue; + + /* Eliminate the PHI node and replace it by a computation outside +Index: gcc-4.3.2/gcc/tree-scalar-evolution.h +=================================================================== +--- gcc-4.3.2.orig/gcc/tree-scalar-evolution.h 2009-01-28 10:22:47.000000000 +0100 ++++ gcc-4.3.2/gcc/tree-scalar-evolution.h 2009-01-28 10:23:10.000000000 +0100 +@@ -35,6 +35,7 @@ + extern void scev_analysis (void); + unsigned int scev_const_prop (void); + ++bool expression_expensive_p (tree); + extern bool simple_iv (struct loop *, tree, tree, affine_iv *, bool); + + /* Returns the loop of the polynomial chrec CHREC. */ +Index: gcc-4.3.2/gcc/testsuite/gcc.dg/pr34027-1.c +=================================================================== +--- gcc-4.3.2.orig/gcc/testsuite/gcc.dg/pr34027-1.c 2009-01-28 10:24:09.000000000 +0100 ++++ gcc-4.3.2/gcc/testsuite/gcc.dg/pr34027-1.c 2009-01-28 10:24:43.000000000 +0100 +@@ -8,5 +8,9 @@ + return ns; + } + +-/* { dg-final { scan-tree-dump "ns % 10000" "optimized" } } */ ++/* This test was originally introduced to test that we transform ++ to ns % 10000. See the discussion of PR 32044 why we do not do ++ that anymore. */ ++/* { dg-final { scan-tree-dump-times "%" 0 "optimized" } } */ ++/* { dg-final { scan-tree-dump-times "/" 0 "optimized" } } */ + /* { dg-final { cleanup-tree-dump "optimized" } } */ +Index: gcc-4.3.2/gcc/testsuite/gcc.dg/tree-ssa/pr32044.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ gcc-4.3.2/gcc/testsuite/gcc.dg/tree-ssa/pr32044.c 2009-01-28 10:25:50.000000000 +0100 +@@ -0,0 +1,55 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fdump-tree-empty -fdump-tree-final_cleanup" } */ ++ ++int foo (int n) ++{ ++ while (n >= 45) ++ n -= 45; ++ ++ return n; ++} ++ ++int bar (int n) ++{ ++ while (n >= 64) ++ n -= 64; ++ ++ return n; ++} ++ ++int bla (int n) ++{ ++ int i = 0; ++ ++ while (n >= 45) ++ { ++ i++; ++ n -= 45; ++ } ++ ++ return i; ++} ++ ++int baz (int n) ++{ ++ int i = 0; ++ ++ while (n >= 64) ++ { ++ i++; ++ n -= 64; ++ } ++ ++ return i; ++} ++ ++/* The loops computing division/modulo by 64 should be eliminated. */ ++/* { dg-final { scan-tree-dump-times "Removing empty loop" 2 "empty" } } */ ++ ++/* There should be no division/modulo in the final dump (division and modulo ++ by 64 are done using bit operations). */ ++/* { dg-final { scan-tree-dump-times "/" 0 "final_cleanup" } } */ ++/* { dg-final { scan-tree-dump-times "%" 0 "final_cleanup" } } */ ++ ++/* { dg-final { cleanup-tree-dump "empty" } } */ ++/* { dg-final { cleanup-tree-dump "final_cleanup" } } */ +Index: gcc-4.3.2/gcc/tree-ssa-loop-ivopts.c +=================================================================== +--- gcc-4.3.2.orig/gcc/tree-ssa-loop-ivopts.c 2009-01-28 10:26:04.000000000 +0100 ++++ gcc-4.3.2/gcc/tree-ssa-loop-ivopts.c 2009-01-28 10:27:09.000000000 +0100 +@@ -3778,7 +3778,12 @@ + return false; + + cand_value_at (loop, cand, use->stmt, nit, &bnd); ++ + *bound = aff_combination_to_tree (&bnd); ++ /* It is unlikely that computing the number of iterations using division ++ would be more profitable than keeping the original induction variable. */ ++ if (expression_expensive_p (*bound)) ++ return false; + return true; + } + diff --git a/patches/gcc-4.3.2/generic/series b/patches/gcc-4.3.2/generic/series index cd6287e..12d6d93 100644 --- a/patches/gcc-4.3.2/generic/series +++ b/patches/gcc-4.3.2/generic/series @@ -5,6 +5,7 @@ no-host-includes.diff arm-softfloat.diff # bugfixes +gcc-43-pr32044.diff gcc-43-pr37220.diff # from uclibc -- cgit v1.2.3