This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[RFA] expand from SSA form (2/2)
- From: Michael Matz <matz at suse dot de>
- To: gcc-patches at gcc dot gnu dot org
- Date: Wed, 22 Apr 2009 18:44:43 +0200 (CEST)
- Subject: [RFA] expand from SSA form (2/2)
Hi,
and this is the testsuite changes. Mostly because we don't have the
final_cleanup pass anymore (hence s/final_cleanup/optimized). Some
also due to not having a fully TERed dump anymore, and some others because
we have to match SSA names, not full decls. All straight forward.
Ciao,
Michael.
--
Expand from SSA.
* gcc.dg/tree-ssa/20030728-1.c: Use -rtl-expand-details dump and
change regexps.
* gcc.target/i386/pr37248-1.c: Modified.
* gcc.target/i386/pr37248-3.c: Modified.
* gcc.target/i386/pr37248-2.c: Modified.
* gnat.dg/aliasing1.adb: Modified.
* gnat.dg/pack9.adb: Modified.
* gnat.dg/aliasing2.adb: Modified.
* gcc.dg/strict-overflow-2.c: Modified.
* gcc.dg/autopar/reduc-1char.c: Modified.
* gcc.dg/autopar/reduc-2char.c: Modified.
* gcc.dg/autopar/reduc-1.c: Modified.
* gcc.dg/autopar/reduc-2.c: Modified.
* gcc.dg/autopar/reduc-3.c: Modified.
* gcc.dg/autopar/reduc-6.c: Modified.
* gcc.dg/autopar/reduc-7.c: Modified.
* gcc.dg/autopar/reduc-8.c: Modified.
* gcc.dg/autopar/reduc-9.c: Modified.
* gcc.dg/autopar/reduc-1short.c: Modified.
* gcc.dg/autopar/reduc-2short.c: Modified.
* gcc.dg/autopar/parallelization-1.c: Modified.
* gcc.dg/strict-overflow-4.c: Modified.
* gcc.dg/strict-overflow-6.c: Modified.
* gcc.dg/gomp/combined-1.c: Modified.
* gcc.dg/no-strict-overflow-1.c: Modified.
* gcc.dg/no-strict-overflow-3.c: Modified.
* gcc.dg/no-strict-overflow-5.c: Modified.
* gcc.dg/tree-ssa/reassoc-13.c: Modified.
* gcc.dg/tree-ssa/pr18134.c: Modified.
* gcc.dg/tree-ssa/20030824-1.c: Modified.
* gcc.dg/tree-ssa/vector-2.c: Modified.
* gcc.dg/tree-ssa/forwprop-9.c: Modified.
* gcc.dg/tree-ssa/loop-21.c: Modified.
* gcc.dg/tree-ssa/20030824-2.c: Modified.
* gcc.dg/tree-ssa/vector-3.c: Modified.
* gcc.dg/tree-ssa/asm-3.c: Modified.
* gcc.dg/tree-ssa/pr23294.c: Modified.
* gcc.dg/tree-ssa/loop-22.c: Modified.
* gcc.dg/tree-ssa/loop-15.c: Modified.
* gcc.dg/tree-ssa/prefetch-4.c: Modified.
* gcc.dg/tree-ssa/pr22051-1.c: Modified.
* gcc.dg/tree-ssa/pr20139.c: Modified.
* gcc.dg/tree-ssa/scev-cast.c: Modified.
* gcc.dg/tree-ssa/pr22051-2.c: Modified.
* gcc.dg/tree-ssa/reassoc-1.c: Modified.
* gcc.dg/tree-ssa/loop-5.c: Modified.
* gcc.dg/tree-ssa/pr19431.c: Modified.
* gcc.dg/tree-ssa/pr32044.c: Modified.
* gcc.dg/tree-ssa/prefetch-7.c: Modified.
* gcc.dg/tree-ssa/loop-19.c: Modified.
* gcc.dg/tree-ssa/loop-28.c: Modified.
* gcc.dg/tree-ssa/ssa-pre-15.c: Modified.
* gcc.dg/tree-ssa/divide-1.c: Modified.
* gcc.dg/tree-ssa/inline-1.c: Modified.
* gcc.dg/tree-ssa/divide-3.c: Modified.
* gcc.dg/tree-ssa/pr30978.c: Modified.
* gcc.dg/tree-ssa/alias-6.c: Modified.
* gcc.dg/tree-ssa/divide-4.c: Modified.
* gcc.dg/tree-ssa/alias-11.c: Modified.
* gcc.dg/no-strict-overflow-7.c: Modified.
* gcc.dg/strict-overflow-1.c: Modified.
* gcc.dg/pr15784-4.c: Modified.
* gcc.dg/pr34263.c: Modified.
* gcc.dg/strict-overflow-3.c: Modified.
* gcc.dg/tree-prof/stringop-1.c: Modified.
* gcc.dg/tree-prof/val-prof-1.c: Modified.
* gcc.dg/tree-prof/val-prof-2.c: Modified.
* gcc.dg/tree-prof/val-prof-3.c: Modified.
* gcc.dg/tree-prof/val-prof-4.c: Modified.
* gcc.dg/no-strict-overflow-2.c: Modified.
* gcc.dg/no-strict-overflow-4.c: Modified.
* gcc.dg/no-strict-overflow-6.c: Modified.
* g++.dg/tree-ssa/pr27090.C: Modified.
* g++.dg/tree-ssa/tmmti-2.C: Modified.
* g++.dg/tree-ssa/ptrmemfield.C: Modified.
* g++.dg/tree-ssa/pr19807.C: Modified.
* g++.dg/opt/pr30965.C: Modified.
* g++.dg/init/new17.C: Modified.
* gfortran.dg/whole_file_6.f90: Modified.
* gfortran.dg/whole_file_5.f90: Modified.
* gfortran.dg/reassoc_1.f90: Modified.
* gfortran.dg/reassoc_3.f90: Modified.
Index: gcc/testsuite/gcc.dg/tree-ssa/20030728-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/20030728-1.c
+++ gcc/testsuite/gcc.dg/tree-ssa/20030728-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fdump-rtl-expand-details" } */
union tree_node;
@@ -42,6 +42,6 @@ objects_must_conflict_p (t1, t2)
}
/* There should be two assignments of variables to the value zero. */
-/* { dg-final { scan-tree-dump-times " = 0" 2 "final_cleanup"} } */
+/* { dg-final { scan-rtl-dump-times "PART.. = 0" 2 "expand"} } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-rtl-dump "expand" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/20030824-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/20030824-1.c
+++ gcc/testsuite/gcc.dg/tree-ssa/20030824-1.c
@@ -19,5 +19,5 @@ int foo (int x, int y)
}
/* The addition should be optimized into 'y+x'. */
-/* { dg-final { scan-tree-dump-times "\[xy\] \\+ \[xy]" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "\[xy\]_..D. \\+ \[xy]_..D." 1 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/20030824-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/20030824-2.c
+++ gcc/testsuite/gcc.dg/tree-ssa/20030824-2.c
@@ -19,5 +19,5 @@ int foo (int x, int y)
}
/* This function should be optimized into 'return y+x'. */
-/* { dg-final { scan-tree-dump-times "return \[xy\] \\+ \[xy\]" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "\[xy\]_..D. \\+ \[xy]_..D." 1 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/alias-11.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/alias-11.c
+++ gcc/testsuite/gcc.dg/tree-ssa/alias-11.c
@@ -14,6 +14,8 @@ int bar(void)
return a[0] + *p.a;
}
-/* { dg-final { scan-tree-dump "return \\*p\\.a \\\+ a.0.;" "optimized" } } */
+/* We need to have both: a load from "a[0]" and a load from "*p.a",
+ the latter can be an ssa temporary. */
+/* { dg-final { scan-tree-dump "= a.0.;" "optimized" } } */
+/* { dg-final { scan-tree-dump "= \\*\[pD\]" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
-
Index: gcc/testsuite/gcc.dg/tree-ssa/alias-6.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/alias-6.c
+++ gcc/testsuite/gcc.dg/tree-ssa/alias-6.c
@@ -14,6 +14,8 @@ int bar(void)
return a[0] + *p.a;
}
-/* { dg-final { scan-tree-dump "return \\*p\\.a \\\+ a.0.;" "optimized" } } */
+/* We need to have both: a load from "a[0]" and a load from "*p.a",
+ the latter can be an ssa temporary. */
+/* { dg-final { scan-tree-dump "= a.0.;" "optimized" } } */
+/* { dg-final { scan-tree-dump "= \\*\[pD\]" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
-
Index: gcc/testsuite/gcc.dg/tree-ssa/forwprop-9.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/forwprop-9.c
+++ gcc/testsuite/gcc.dg/tree-ssa/forwprop-9.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O1 -fdump-tree-final_cleanup -fdump-tree-fre -W -Wall -fno-early-inlining" } */
+/* { dg-options "-O1 -fdump-tree-optimized -fdump-tree-fre -W -Wall -fno-early-inlining" } */
int b;
unsigned a;
@@ -15,7 +15,7 @@ void f(void)
/* We should have converted the assignments to two = 1. FRE does this. */
-/* { dg-final { scan-tree-dump-times " = 1" 2 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-times " = 1" 2 "optimized"} } */
/* { dg-final { scan-tree-dump-not " = a;" "fre"} } */
/* { dg-final { cleanup-tree-dump "fre" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/inline-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/inline-1.c
+++ gcc/testsuite/gcc.dg/tree-ssa/inline-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
typedef struct {
@@ -20,6 +20,6 @@ interval foo (interval a, interval b, in
}
-/* { dg-final { scan-tree-dump-times "\\(struct interval\\)" 0 "final_cleanup"} } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "\\(struct interval\\)" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/loop-19.c
+++ gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
@@ -6,7 +6,7 @@
/* { dg-do compile { target { i?86-*-* || { x86_64-*-* || powerpc_hard_double } } } } */
/* { dg-require-effective-target nonpic } */
-/* { dg-options "-O3 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O3 -fdump-tree-optimized" } */
# define N 2000000
static double a[N],c[N];
@@ -22,7 +22,7 @@ void tuned_STREAM_Copy()
However, due to a bug in jump threading, we end up peeling one iteration from
the loop, which creates an additional occurence. */
-/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )a," 2 "final_cleanup" } } */
-/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )c," 2 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )a," 2 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )c," 2 "optimized" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/loop-21.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/loop-21.c
+++ gcc/testsuite/gcc.dg/tree-ssa/loop-21.c
@@ -1,7 +1,7 @@
/* PR tree-optimization/30322 */
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
extern void op( int, int);
void foo(int f0, int f1, int e0, int e1)
@@ -13,5 +13,5 @@ void foo(int f0, int f1, int e0, int e1)
op(i0, i1);
}
-/* { dg-final { scan-tree-dump-times "~" 0 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "~" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/loop-22.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/loop-22.c
+++ gcc/testsuite/gcc.dg/tree-ssa/loop-22.c
@@ -1,4 +1,4 @@
-/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
int a[100];
@@ -13,5 +13,5 @@ void test (int n)
/* We used to replace the exit test "i < n" by "i != ((n-1)/3) * 3 + 1". Although
correct, this transformation is obviously harmful. */
-/* { dg-final { scan-tree-dump-times "/" 0 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "/" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/loop-28.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/loop-28.c
+++ gcc/testsuite/gcc.dg/tree-ssa/loop-28.c
@@ -1,6 +1,6 @@
/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
/* { dg-require-effective-target ilp32 } */
-/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-final_cleanup -fdump-tree-aprefetch --param max-unrolled-insns=1000" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-optimized -fdump-tree-aprefetch --param max-unrolled-insns=1000" } */
char x[100000];
@@ -15,10 +15,10 @@ void foo(int n)
/* There should be 64 MEMs in the unrolled loop and one more in the copy of the loop
for the rest of the iterations. */
-/* { dg-final { scan-tree-dump-times "MEM" 65 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "MEM" 65 "optimized" } } */
/* There should be no i_a = i_b assignments. */
/* { dg-final { scan-tree-dump-times "i_.*= i_\[0-9\]*;" 0 "aprefetch" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
/* { dg-final { cleanup-tree-dump "aprefetch" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr20139.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr20139.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr20139.c
@@ -3,7 +3,7 @@
that the optimization happens at tree level. */
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
extern double fabs (double);
extern void link_error (void);
@@ -19,5 +19,5 @@ foo (double x)
link_error ();
}
-/* { dg-final { scan-tree-dump-times "link_error" 0 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr32044.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr32044.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr32044.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-empty -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fdump-tree-empty -fdump-tree-optimized" } */
int foo (int n)
{
@@ -48,8 +48,8 @@ int baz (int n)
/* 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 { scan-tree-dump-times "/" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "%" 0 "optimized" } } */
/* { dg-final { cleanup-tree-dump "empty" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/prefetch-4.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/prefetch-4.c
+++ gcc/testsuite/gcc.dg/tree-ssa/prefetch-4.c
@@ -2,7 +2,7 @@
/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
/* { dg-require-effective-target ilp32 } */
-/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-optimized" } */
int xxx[20];
@@ -14,5 +14,5 @@ void foo (int n)
xxx[i] = i;
}
-/* { dg-final { scan-tree-dump-times "prefetch" 0 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "prefetch" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/prefetch-7.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/prefetch-7.c
+++ gcc/testsuite/gcc.dg/tree-ssa/prefetch-7.c
@@ -1,6 +1,6 @@
/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
/* { dg-require-effective-target ilp32 } */
-/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -msse2 -mfpmath=sse --param simultaneous-prefetches=100 --param max-unrolled-insns=1 -fdump-tree-aprefetch-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -msse2 -mfpmath=sse --param simultaneous-prefetches=100 --param max-unrolled-insns=1 -fdump-tree-aprefetch-details -fdump-tree-optimized" } */
#define K 1000000
int a[K], b[K];
@@ -45,9 +45,9 @@ void test(int *p)
/* { dg-final { scan-tree-dump-times "Issued nontemporal prefetch" 3 "aprefetch" } } */
/* { dg-final { scan-tree-dump-times "nontemporal store" 2 "aprefetch" } } */
-/* { dg-final { scan-tree-dump-times "builtin_prefetch" 8 "final_cleanup" } } */
-/* { dg-final { scan-tree-dump-times "=\\{nt\\}" 2 "final_cleanup" } } */
-/* { dg-final { scan-tree-dump-times "__builtin_ia32_mfence" 2 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "builtin_prefetch" 8 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "=\\{nt\\}" 2 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_ia32_mfence" 2 "optimized" } } */
/* { dg-final { scan-assembler-times "prefetchw" 5 } } */
/* { dg-final { scan-assembler-times "prefetcht" 1 } } */
@@ -56,4 +56,4 @@ void test(int *p)
/* { dg-final { scan-assembler-times "mfence" 2 } } */
/* { dg-final { cleanup-tree-dump "aprefetch" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/vector-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/vector-2.c
+++ gcc/testsuite/gcc.dg/tree-ssa/vector-2.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-w -O1 -fdump-tree-final_cleanup" } */
+/* { dg-options "-w -O1 -fdump-tree-optimized" } */
#define vector __attribute__(( vector_size(16) ))
@@ -16,7 +16,7 @@ float f(vector float a, int b, vector fl
}
/* We should be able to optimize this to just "return 0.0;" */
-/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "final_cleanup"} } */
-/* { dg-final { scan-tree-dump-times "0.0" 1 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "0.0" 1 "optimized"} } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/vector-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/vector-3.c
+++ gcc/testsuite/gcc.dg/tree-ssa/vector-3.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-w -O1 -fdump-tree-final_cleanup" } */
+/* { dg-options "-w -O1 -fdump-tree-optimized" } */
#define vector __attribute((vector_size(16) ))
vector float a;
@@ -13,8 +13,8 @@ float f(float b)
}
/* We should be able to optimize this to just "return 0.0;" */
-/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "final_cleanup"} } */
-/* { dg-final { scan-tree-dump-times "0.0" 1 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "0.0" 1 "optimized"} } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/parallelization-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/parallelization-1.c
+++ gcc/testsuite/gcc.dg/autopar/parallelization-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
void abort (void);
@@ -28,6 +28,6 @@ int main(void)
/* Check that the first loop in parloop got parallelized. */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 1 "parloops" } } */
-/* { dg-final { scan-tree-dump-times "loopfn" 5 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-1.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -54,5 +54,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-1char.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-1char.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-1char.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -49,5 +49,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-1short.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-1short.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-1short.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -49,5 +49,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-2.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-2.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -51,5 +51,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-2char.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-2char.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-2char.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -49,6 +49,6 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-2short.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-2short.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-2short.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -48,5 +48,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-3.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-3.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -39,5 +39,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 1 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 1 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-6.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-6.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-6.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdarg.h>
#include <stdlib.h>
@@ -52,4 +52,4 @@ int main (void)
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 0 "parloops" } } */
/* { dg-final { scan-tree-dump-times "FAILED: it is not a part of reduction" 3 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-7.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-7.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-7.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdlib.h>
@@ -78,5 +78,5 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-8.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-8.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-8.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdlib.h>
@@ -77,4 +77,4 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/autopar/reduc-9.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/autopar/reduc-9.c
+++ gcc/testsuite/gcc.dg/autopar/reduc-9.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */
#include <stdlib.h>
@@ -77,4 +77,4 @@ int main (void)
/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
/* { dg-final { cleanup-tree-dump "parloops" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/gomp/combined-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/gomp/combined-1.c
+++ gcc/testsuite/gcc.dg/gomp/combined-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O1 -fopenmp -fdump-tree-final_cleanup" } */
+/* { dg-options "-O1 -fopenmp -fdump-tree-optimized" } */
int a[10];
int foo (void)
@@ -20,5 +20,5 @@ int foo (void)
}
}
-/* { dg-final { scan-tree-dump-times "__builtin_GOMP_parallel_loop_runtime_start" 3 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_GOMP_parallel_loop_runtime_start" 3 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-1.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of strict-overflow-1.c. */
@@ -12,5 +12,5 @@ foo (int i)
return i - 5 < 10;
}
-/* { dg-final { scan-tree-dump "-[ ]*5" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump "-[ ]*5" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-2.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-2.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of strict-overflow-2.c. */
@@ -12,5 +12,5 @@ foo (int i)
return (i * 100) / 10;
}
-/* { dg-final { scan-tree-dump "100" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump "100" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-3.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-3.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of strict-overflow-3.c. */
@@ -12,5 +12,5 @@ foo (int i, int j)
return i + 100 < j + 1000;
}
-/* { dg-final { scan-tree-dump "1000" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump "1000" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-4.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-4.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-4.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of strict-overflow-4.c. */
@@ -14,6 +14,6 @@ foo (int i)
/* We expect to see "<bb N>"; confirm that, so that we know to count
it in the real test. */
-/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "final_cleanup" } } */
-/* { dg-final { scan-tree-dump-times ">|<" 3 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times ">|<" 3 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-5.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-5.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-5.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Dual of strict-overflow-5.c. */
@@ -16,5 +16,5 @@ int foo (int i)
return r;
}
-/* { dg-final { scan-tree-dump-times "r = 3" 0 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "r = 3" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-6.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-6.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-6.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. */
@@ -17,5 +17,5 @@ foo ()
return bits;
}
-/* { dg-final { scan-tree-dump "return bits" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump "return bits" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/no-strict-overflow-7.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/no-strict-overflow-7.c
+++ gcc/testsuite/gcc.dg/no-strict-overflow-7.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of strict-overflow-6.c. */
@@ -12,5 +12,5 @@ foo (char* p)
return p + 1000 < p;
}
-/* { dg-final { scan-tree-dump "\[+\]\[ \]*1000" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump "\[+\]\[ \]*1000" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/pr15784-4.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/pr15784-4.c
+++ gcc/testsuite/gcc.dg/pr15784-4.c
@@ -8,6 +8,6 @@ int b (int x) {
return -x -1; /* ~x */
}
-/* { dg-final { scan-tree-dump "~x;" "optimized" } } */
-/* { dg-final { scan-tree-dump "-x;" "optimized" } } */
+/* { dg-final { scan-tree-dump "~x_..D.;" "optimized" } } */
+/* { dg-final { scan-tree-dump "-x_..D.;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/pr34263.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/pr34263.c
+++ gcc/testsuite/gcc.dg/pr34263.c
@@ -54,6 +54,6 @@ int look( struct s *p, struct s **pp )
return( 1 );
}
-/* { dg-final { scan-tree-dump "Cleaned-up latch block of loop with single BB" "optimized" } } */
+/* { dg-final { scan-tree-dump "Cleaned-up latch block of loop with single BB" "optimized" { xfail { *-*-* } } } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/strict-overflow-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/strict-overflow-1.c
+++ gcc/testsuite/gcc.dg/strict-overflow-1.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of no-strict-overflow-1.c. */
@@ -12,5 +12,5 @@ foo (int i)
return i - 5 < 10;
}
-/* { dg-final { scan-tree-dump-not "-[ ]*5" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-not "-\[ \]*5" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/strict-overflow-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/strict-overflow-2.c
+++ gcc/testsuite/gcc.dg/strict-overflow-2.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of no-strict-overflow-2.c. */
@@ -12,5 +12,5 @@ foo (int i)
return (i * 100) / 10;
}
-/* { dg-final { scan-tree-dump-not "100" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-not "100" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/strict-overflow-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/strict-overflow-3.c
+++ gcc/testsuite/gcc.dg/strict-overflow-3.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of no-strict-overflow-3.c. */
@@ -12,5 +12,5 @@ foo (int i, int j)
return i + 100 < j + 1000;
}
-/* { dg-final { scan-tree-dump-not "1000" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-not "1000" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/strict-overflow-4.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/strict-overflow-4.c
+++ gcc/testsuite/gcc.dg/strict-overflow-4.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of no-strict-overflow-4.c. */
@@ -14,6 +14,6 @@ foo (int i)
/* We expect to see "<bb N>"; confirm that, so that we know to count
it in the real test. */
-/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "final_cleanup" } } */
-/* { dg-final { scan-tree-dump-times ">|<" 2 "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times ">|<" 2 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/strict-overflow-6.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/strict-overflow-6.c
+++ gcc/testsuite/gcc.dg/strict-overflow-6.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-optimized" } */
/* Source: Ian Lance Taylor. Dual of no-strict-overflow-7.c. */
@@ -12,5 +12,5 @@ foo (char* p)
return p + 1000 < p;
}
-/* { dg-final { scan-tree-dump-not "\[+\]\[ \]*1000" "final_cleanup" } } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-not "\[+\]\[ \]*1000" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-prof/stringop-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-prof/stringop-1.c
+++ gcc/testsuite/gcc.dg/tree-prof/stringop-1.c
@@ -16,6 +16,7 @@ main()
/* { dg-final-use { scan-tree-dump "Single value 4 stringop" "tree_profile"} } */
/* Really this ought to simplify into assignment, but we are not there yet. */
/* a[0] = b[0] is what we fold the resulting memcpy into. */
-/* { dg-final-use { scan-tree-dump "a.0. = b.0." "optimized"} } */
+/* { dg-final-use { scan-tree-dump "a.0. = " "optimized"} } */
+/* { dg-final-use { scan-tree-dump "= b.0." "optimized"} } */
/* { dg-final-use { cleanup-tree-dump "optimized" } } */
/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
Index: gcc/testsuite/gcc.dg/tree-prof/val-prof-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-prof/val-prof-1.c
+++ gcc/testsuite/gcc.dg/tree-prof/val-prof-1.c
@@ -16,7 +16,7 @@ main ()
return 0;
}
/* { dg-final-use { scan-tree-dump "Div.mod by constant n=257 transformation on insn" "tree_profile"} } */
-/* { dg-final-use { scan-tree-dump "if \\(n != 257\\)" "optimized"} } */
+/* { dg-final-use { scan-tree-dump "if \\(n_\[0-9\]* != 257\\)" "optimized"} } */
/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
/* { dg-final-use { cleanup-tree-dump "optimized" } } */
/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
Index: gcc/testsuite/gcc.dg/tree-prof/val-prof-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-prof/val-prof-2.c
+++ gcc/testsuite/gcc.dg/tree-prof/val-prof-2.c
@@ -26,7 +26,7 @@ main ()
/* { dg-final-use { scan-tree-dump "Mod power of 2 transformation on insn" "tree_profile"} } */
/* This is part of code checking that n is power of 2, so we are sure that the transformation
didn't get optimized out. */
-/* { dg-final-use { scan-tree-dump "n \\+ 0xffff" "optimized"} } */
+/* { dg-final-use { scan-tree-dump "n_\[0-9\]* \\+ 0xffff" "optimized"} } */
/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
/* { dg-final-use { cleanup-tree-dump "optimized" } } */
/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
Index: gcc/testsuite/gcc.dg/tree-prof/val-prof-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-prof/val-prof-3.c
+++ gcc/testsuite/gcc.dg/tree-prof/val-prof-3.c
@@ -26,7 +26,7 @@ main ()
/* { dg-final-use { scan-tree-dump "Mod subtract transformation on insn" "tree_profile"} } */
/* This is part of code checking that n is greater than the divisor so we are sure that it
didn't get optimized out. */
-/* { dg-final-use { scan-tree-dump "if \\(n \\>" "optimized"} } */
+/* { dg-final-use { scan-tree-dump "if \\(n_\[0-9\]* \\>" "optimized"} } */
/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
/* { dg-final-use { cleanup-tree-dump "optimized" } } */
/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
Index: gcc/testsuite/gcc.dg/tree-prof/val-prof-4.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-prof/val-prof-4.c
+++ gcc/testsuite/gcc.dg/tree-prof/val-prof-4.c
@@ -26,7 +26,7 @@ main ()
/* { dg-final-use { scan-tree-dump "Mod subtract transformation on insn" "tree_profile"} } */
/* This is part of code checking that n is greater than the divisor so we are sure that it
didn't get optimized out. */
-/* { dg-final-use { scan-tree-dump "if \\(n \\>" "optimized"} } */
+/* { dg-final-use { scan-tree-dump "if \\(n_\[0-9\]* \\>" "optimized"} } */
/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
/* { dg-final-use { cleanup-tree-dump "optimized" } } */
/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/asm-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/asm-3.c
+++ gcc/testsuite/gcc.dg/tree-ssa/asm-3.c
@@ -27,6 +27,6 @@ void test(void)
/* { dg-final { scan-tree-dump-times "hardreg" 3 "optimized" } } */
/* In particular, hardreg should *not* appear in the call to bar. */
-/* { dg-final { scan-tree-dump-times "bar \[(\]t\[)\]" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "bar \[(\]t_.\[)\]" 1 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/divide-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/divide-1.c
+++ gcc/testsuite/gcc.dg/tree-ssa/divide-1.c
@@ -7,8 +7,8 @@ int f(int a)
}
-/* { dg-final { scan-tree-dump-times "-a / 10" 0 "optimized"} } */
-/* { dg-final { scan-tree-dump-times "a / -10" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "-a" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a_..D. / -10" 1 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/divide-3.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/divide-3.c
+++ gcc/testsuite/gcc.dg/tree-ssa/divide-3.c
@@ -6,8 +6,8 @@ int f(int a)
return -(a/10);
}
-/* { dg-final { scan-tree-dump-times "a / 10" 0 "optimized"} } */
-/* { dg-final { scan-tree-dump-times "a / -10" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a_\[0-9()D\]* / 10" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a_..D. / -10" 1 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/divide-4.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/divide-4.c
+++ gcc/testsuite/gcc.dg/tree-ssa/divide-4.c
@@ -6,8 +6,8 @@ int f(int a)
return -(-a/10);
}
-/* { dg-final { scan-tree-dump-times "-a / 10" 0 "optimized"} } */
-/* { dg-final { scan-tree-dump-times "a / 10" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "-a" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a_..D. / 10" 1 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/loop-15.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/loop-15.c
+++ gcc/testsuite/gcc.dg/tree-ssa/loop-15.c
@@ -20,7 +20,7 @@ int bla(void)
/* Since the loop is removed, there should be no addition. */
/* { dg-final { scan-tree-dump-times "\\+" 0 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "n \\* n" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "n_. \\* n_." 1 "optimized" } } */
/* The if from the loop header copying remains in the code. */
/* { dg-final { scan-tree-dump-times "if " 1 "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/loop-5.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/loop-5.c
+++ gcc/testsuite/gcc.dg/tree-ssa/loop-5.c
@@ -19,7 +19,9 @@ void xxx(void)
/* Only iter variable should remain. */
/* { dg-final { scan-tree-dump-times "int iter" 1 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "jter" 0 "optimized" } } */
+
+/* And jter shouldn't be an induction variable anymore (no PHI node). */
+/* { dg-final { scan-tree-dump-times "jter_\[0-9\]* = PHI" 0 "optimized" } } */
/* And the use of jter should be replaced by iter + 2 */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr18134.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr18134.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr18134.c
@@ -17,7 +17,7 @@ return 0;
/* Everything should have been cleaned up leaving a simple
return statement. */
-/* { dg-final { scan-tree-dump-times "return.*a != 0" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "= a_..D. != 0" 1 "optimized" } } */
/* There should not be any abnormal edges as DOM removed the
computed gotos. */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr19431.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr19431.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr19431.c
@@ -24,6 +24,6 @@ int f(int k, int i1, int j1)
return *f1;
}
-/* { dg-final { scan-tree-dump "i1 = j1" "optimized" } } */
-/* { dg-final { scan-tree-dump "return i1;" "optimized" } } */
+/* { dg-final { scan-tree-dump "i1_. = PHI <i1_\[^,\]*, j1_\[^>\]*>" "optimized" } } */
+/* { dg-final { scan-tree-dump "return i1_.;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr22051-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr22051-1.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr22051-1.c
@@ -17,7 +17,7 @@ foo()
/* The cast to a function pointer type must remain after all optimizations
are complete so that function pointer canonicalization works on those
targets which require it. */
-/* { dg-final { scan-tree-dump-times "if \\(\\(void \\(\\*<.*>\\) \\(void\\)\\) p" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "= \\(void \\(\\*<.*>\\) \\(void\\)\\) p_" 1 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr22051-2.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr22051-2.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr22051-2.c
@@ -20,6 +20,6 @@ foo()
/* The cast to an int type must remain after all optimizations are complete
so that we do not try to canonicalize a function pointer for the
comparison when no such canonicalization is wanted. */
-/* { dg-final { scan-tree-dump-times "if \\(\\(int\\).*q" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "r_. = \\(int\\) q" 1 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr23294.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr23294.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr23294.c
@@ -31,7 +31,7 @@ int f6(int a, int b)
return 6*a - 2*b;
}
-/* { dg-final { scan-tree-dump-times "a \\\* 5" 3 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "\\\) \\\* 2" 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "a_..D. \\\* 5" 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " \\\* 2" 3 "optimized" } } */
/* { dg-final { scan-tree-dump-not "\\\* 6" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/pr30978.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/pr30978.c
+++ gcc/testsuite/gcc.dg/tree-ssa/pr30978.c
@@ -10,5 +10,5 @@ int foo(int a)
return e;
}
-/* { dg-final { scan-tree-dump "return a > 0;" "optimized" } } */
+/* { dg-final { scan-tree-dump "e_. = a_..D. > 0;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/reassoc-1.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/reassoc-1.c
+++ gcc/testsuite/gcc.dg/tree-ssa/reassoc-1.c
@@ -14,5 +14,6 @@ int main(void)
printf ("%d %d\n", e, f);
}
-/* { dg-final { scan-tree-dump-times "b \\\+ a" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "b.._. \\\+ a.._." 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times " \\\+ " 2 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/reassoc-13.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/reassoc-13.c
+++ gcc/testsuite/gcc.dg/tree-ssa/reassoc-13.c
@@ -10,6 +10,6 @@ double foo(double a)
}
/* { dg-final { scan-tree-dump-not "\\\+ 0.0" "reassoc1" } } */
-/* { dg-final { scan-tree-dump "return a;" "optimized" } } */
+/* { dg-final { scan-tree-dump "return a_..D.;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "reassoc1" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/scev-cast.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/scev-cast.c
+++ gcc/testsuite/gcc.dg/tree-ssa/scev-cast.c
@@ -20,7 +20,7 @@ void tst(void)
blau ((unsigned char) i); /* This one is necessary. */
}
-/* { dg-final { scan-tree-dump-times "\\(int\\) \\(unsigned char\\)" 1 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "\\(int\\) \\(char\\)" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "= \\(unsigned char\\)" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "= \\(char\\)" 1 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-15.c
===================================================================
--- gcc.orig/testsuite/gcc.dg/tree-ssa/ssa-pre-15.c
+++ gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-15.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-options "-O2 -fdump-rtl-expand-details" } */
/* Verify we PRE the strlen call, as strlen("") folds to zero. */
@@ -12,5 +12,5 @@ __SIZE_TYPE__ mystrlen (const char *s)
return strlen(s);
}
-/* { dg-final { scan-tree-dump "= 0;" "optimized" } } */
-/* { dg-final { cleanup-tree-dump "optimized" } } */
+/* { dg-final { scan-rtl-dump "PART.. = 0" "expand" } } */
+/* { dg-final { cleanup-rtl-dump "expand" } } */
Index: gcc/testsuite/gcc.target/i386/pr37248-1.c
===================================================================
--- gcc.orig/testsuite/gcc.target/i386/pr37248-1.c
+++ gcc/testsuite/gcc.target/i386/pr37248-1.c
@@ -15,5 +15,6 @@ foo (struct S x)
return x.a && x.b && x.c;
}
-/* { dg-final { scan-tree-dump "& 7\[^\n\t\]*== 7" "optimized" } } */
+/* { dg-final { scan-tree-dump "& 7;" "optimized" } } */
+/* { dg-final { scan-tree-dump "== 7;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.target/i386/pr37248-2.c
===================================================================
--- gcc.orig/testsuite/gcc.target/i386/pr37248-2.c
+++ gcc/testsuite/gcc.target/i386/pr37248-2.c
@@ -19,5 +19,6 @@ foo (struct S x)
return x.a && x.g && x.b && x.f && x.c && x.e;
}
-/* { dg-final { scan-tree-dump "& (3758096391|0x0e0000007)\[^\n\t\]*== (3758096391|0x0e0000007)" "optimized" } } */
+/* { dg-final { scan-tree-dump "& (3758096391|0x0e0000007);" "optimized" } } */
+/* { dg-final { scan-tree-dump "== (3758096391|0x0e0000007);" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/gcc.target/i386/pr37248-3.c
===================================================================
--- gcc.orig/testsuite/gcc.target/i386/pr37248-3.c
+++ gcc/testsuite/gcc.target/i386/pr37248-3.c
@@ -21,5 +21,6 @@ foo (struct S x)
return x.a && x.i && x.b && x.h && x.c && x.g && x.e == 131;
}
-/* { dg-final { scan-tree-dump "& (3766484487|0x0e07ffe07)\[^\n\t\]*== (3758163463|0x0e0010607)" "optimized" } } */
+/* { dg-final { scan-tree-dump "& (3766484487|0x0e07ffe07);" "optimized" } } */
+/* { dg-final { scan-tree-dump "== (3758163463|0x0e0010607);" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/g++.dg/init/new17.C
===================================================================
--- gcc.orig/testsuite/g++.dg/init/new17.C
+++ gcc/testsuite/g++.dg/init/new17.C
@@ -1,5 +1,5 @@
// { dg-do compile }
-// { dg-options "-O2 -fstrict-aliasing -fdump-tree-final_cleanup" }
+// { dg-options "-O2 -fstrict-aliasing -fdump-tree-optimized" }
// Test that placement new does not introduce an unnecessary memory
// barrier.
@@ -33,5 +33,5 @@ void foo(Vector<float, 3> *m)
*m = v;
}
-// { dg-final { scan-tree-dump-times "= 0\.0" 1 "final_cleanup" } }
-// { dg-final { cleanup-tree-dump "final_cleanup" } }
+// { dg-final { scan-tree-dump-times "= 0\.0" 1 "optimized" } }
+// { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/g++.dg/opt/pr30965.C
===================================================================
--- gcc.orig/testsuite/g++.dg/opt/pr30965.C
+++ gcc/testsuite/g++.dg/opt/pr30965.C
@@ -16,5 +16,5 @@ extern void assign( long& variable, long
}
/* { dg-final { scan-tree-dump-times ";; Function" 2 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "variable = v" 2 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "variable_..D. = v_..D." 2 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/g++.dg/tree-ssa/pr19807.C
===================================================================
--- gcc.orig/testsuite/g++.dg/tree-ssa/pr19807.C
+++ gcc/testsuite/g++.dg/tree-ssa/pr19807.C
@@ -19,6 +19,12 @@ void bar(int i)
}
/* { dg-final { scan-tree-dump-times "&a\\\[2\\\]" 3 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "&a\\\[.* \\+ -1\\\]" 1 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "&a\\\[.* \\+ 1\\\]" 1 "optimized" } } */
+
+/* We want &a[D.bla + 1] and &a[D.foo - 1] in the final code, but
+ tuples mean that the offset is calculated in a separate instruction.
+ Simply test for the existence of +1 and -1 once, which also ensures
+ the above. If the addition/subtraction would be applied to the
+ pointer we would instead see +-4 (or 8, depending on sizeof(int)). */
+/* { dg-final { scan-tree-dump-times "\\\+ -1;" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\\\+ 1;" 1 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/g++.dg/tree-ssa/pr27090.C
===================================================================
--- gcc.orig/testsuite/g++.dg/tree-ssa/pr27090.C
+++ gcc/testsuite/g++.dg/tree-ssa/pr27090.C
@@ -17,5 +17,5 @@ int foo(Foo& f)
return f.get();
}
-/* { dg-final { scan-tree-dump "return f->x;" "optimized" } } */
+/* { dg-final { scan-tree-dump "f_..D.->x;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/g++.dg/tree-ssa/ptrmemfield.C
===================================================================
--- gcc.orig/testsuite/g++.dg/tree-ssa/ptrmemfield.C
+++ gcc/testsuite/g++.dg/tree-ssa/ptrmemfield.C
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-// { dg-options "-O2 -fdump-tree-final_cleanup" }
+// { dg-options "-O2 -fdump-tree-optimized" }
struct f
@@ -20,8 +20,8 @@ int h(void)
}
/* We should have no cast to offset_type. */
-/* { dg-final { scan-tree-dump-times "offset_type" 0 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-times "offset_type" 0 "optimized"} } */
// And we should optimized this code to just return 0
-/* { dg-final { scan-tree-dump-times "return 0" 1 "final_cleanup"} } */
-/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "return 0" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
Index: gcc/testsuite/g++.dg/tree-ssa/tmmti-2.C
===================================================================
--- gcc.orig/testsuite/g++.dg/tree-ssa/tmmti-2.C
+++ gcc/testsuite/g++.dg/tree-ssa/tmmti-2.C
@@ -3,7 +3,7 @@
int a[4][8];
-int foo(int i)
+int foo(long i)
{
return *(&a[0][0] + i*8); // a[i][0]
}
@@ -12,7 +12,7 @@ struct Foo { double x, y; };
Foo b[4];
-double bar(int i)
+double bar(long i)
{
return *(&b[0].x + i*2); // b[i].x
}
Index: gcc/testsuite/gfortran.dg/reassoc_1.f90
===================================================================
--- gcc.orig/testsuite/gfortran.dg/reassoc_1.f90
+++ gcc/testsuite/gfortran.dg/reassoc_1.f90
@@ -7,5 +7,7 @@ function test(b)
test = a
end
-! { dg-final { scan-tree-dump "\\\+ 5.*\\\)\\\) - 5" "optimized" } }
+! We need an explicit +5 and -5, and an intermediate ((bla)) expression
+! (the reassoc barrier). Make use of "." matching lineends.
+! { dg-final { scan-tree-dump "\\\+ 5.*\\\)\\\).* - 5" "optimized" } }
! { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/gfortran.dg/reassoc_3.f90
===================================================================
--- gcc.orig/testsuite/gfortran.dg/reassoc_3.f90
+++ gcc/testsuite/gfortran.dg/reassoc_3.f90
@@ -14,6 +14,7 @@ function test(a)
end
! { dg-final { scan-tree-dump "b = 5" "original" } }
-! { dg-final { scan-tree-dump "return .a" "optimized" } }
+! { dg-final { scan-tree-dump "c_. = .a" "optimized" } }
+! { dg-final { scan-tree-dump "return c_.;" "optimized" } }
! { dg-final { cleanup-tree-dump "original" } }
! { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/gfortran.dg/whole_file_5.f90
===================================================================
--- gcc.orig/testsuite/gfortran.dg/whole_file_5.f90
+++ gcc/testsuite/gfortran.dg/whole_file_5.f90
@@ -16,3 +16,4 @@ PROGRAM main
END PROGRAM
! { dg-final { scan-tree-dump-times "= f\(\)" 0 "optimized" } }
+! { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/gfortran.dg/whole_file_6.f90
===================================================================
--- gcc.orig/testsuite/gfortran.dg/whole_file_6.f90
+++ gcc/testsuite/gfortran.dg/whole_file_6.f90
@@ -16,3 +16,4 @@ INTEGER FUNCTION f()
END FUNCTION
! { dg-final { scan-tree-dump-times "= f\(\)" 0 "optimized" } }
+! { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/gnat.dg/aliasing1.adb
===================================================================
--- gcc.orig/testsuite/gnat.dg/aliasing1.adb
+++ gcc/testsuite/gnat.dg/aliasing1.adb
@@ -1,5 +1,5 @@
-- { dg-do compile }
--- { dg-options "-O2 -gnatp -fdump-tree-final_cleanup" }
+-- { dg-options "-O2 -gnatp -fdump-tree-optimized" }
-- The raise statement must be optimized away by
-- virtue of DECL_NONADDRESSABLE_P set on R.I.
@@ -18,5 +18,5 @@ package body Aliasing1 is
end Aliasing1;
--- { dg-final { scan-tree-dump-not "__gnat_rcheck" "final_cleanup" } }
--- { dg-final { cleanup-tree-dump "final_cleanup" } }
+-- { dg-final { scan-tree-dump-not "__gnat_rcheck" "optimized" } }
+-- { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/gnat.dg/aliasing2.adb
===================================================================
--- gcc.orig/testsuite/gnat.dg/aliasing2.adb
+++ gcc/testsuite/gnat.dg/aliasing2.adb
@@ -1,5 +1,5 @@
-- { dg-do compile }
--- { dg-options "-O2 -gnatp -fdump-tree-final_cleanup" }
+-- { dg-options "-O2 -gnatp -fdump-tree-optimized" }
-- The raise statement must be optimized away by
-- virtue of TYPE_NONALIASED_COMPONENT set on A.
@@ -18,5 +18,5 @@ package body Aliasing2 is
end Aliasing2;
--- { dg-final { scan-tree-dump-not "__gnat_rcheck" "final_cleanup" } }
--- { dg-final { cleanup-tree-dump "final_cleanup" } }
+-- { dg-final { scan-tree-dump-not "__gnat_rcheck" "optimized" } }
+-- { dg-final { cleanup-tree-dump "optimized" } }
Index: gcc/testsuite/gnat.dg/pack9.adb
===================================================================
--- gcc.orig/testsuite/gnat.dg/pack9.adb
+++ gcc/testsuite/gnat.dg/pack9.adb
@@ -1,5 +1,5 @@
-- { dg-do compile }
--- { dg-options "-O2 -gnatp -cargs --param sra-max-structure-size=24 --param sra-max-structure-count=6 -fdump-tree-final_cleanup" }
+-- { dg-options "-O2 -gnatp -cargs --param sra-max-structure-size=24 --param sra-max-structure-count=6 -fdump-tree-optimized" }
package body Pack9 is
@@ -14,5 +14,5 @@ package body Pack9 is
end Pack9;
--- { dg-final { scan-tree-dump-not "__gnat_rcheck" "final_cleanup" } }
--- { dg-final { cleanup-tree-dump "final_cleanup" } }
+-- { dg-final { scan-tree-dump-not "__gnat_rcheck" "optimized" } }
+-- { dg-final { cleanup-tree-dump "optimized" } }