From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/testsuite/gcc.dg/autopar/autopar.exp | 40 +++++++++++ gcc/testsuite/gcc.dg/autopar/outer-1.c | 33 +++++++++ gcc/testsuite/gcc.dg/autopar/outer-2.c | 33 +++++++++ gcc/testsuite/gcc.dg/autopar/outer-3.c | 33 +++++++++ gcc/testsuite/gcc.dg/autopar/outer-4.c | 37 ++++++++++ gcc/testsuite/gcc.dg/autopar/outer-5.c | 50 +++++++++++++ gcc/testsuite/gcc.dg/autopar/outer-6.c | 51 +++++++++++++ gcc/testsuite/gcc.dg/autopar/parallelization-1.c | 33 +++++++++ gcc/testsuite/gcc.dg/autopar/pr39500-1.c | 28 ++++++++ gcc/testsuite/gcc.dg/autopar/pr39500-2.c | 20 ++++++ gcc/testsuite/gcc.dg/autopar/pr46066.c | 18 +++++ gcc/testsuite/gcc.dg/autopar/pr46099.c | 47 ++++++++++++ gcc/testsuite/gcc.dg/autopar/pr46194.c | 24 +++++++ gcc/testsuite/gcc.dg/autopar/pr46561.c | 17 +++++ gcc/testsuite/gcc.dg/autopar/pr46799.c | 12 ++++ gcc/testsuite/gcc.dg/autopar/pr46885.c | 23 ++++++ gcc/testsuite/gcc.dg/autopar/pr46969.c | 31 ++++++++ gcc/testsuite/gcc.dg/autopar/pr47060.c | 21 ++++++ gcc/testsuite/gcc.dg/autopar/reduc-1.c | 73 +++++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-1char.c | 67 +++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-1short.c | 66 +++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-2.c | 70 ++++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-2char.c | 68 ++++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-2short.c | 66 +++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-3.c | 57 +++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-6.c | 63 ++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-7.c | 91 ++++++++++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-8.c | 90 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/autopar/reduc-9.c | 90 +++++++++++++++++++++++ 29 files changed, 1352 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/autopar/autopar.exp create mode 100644 gcc/testsuite/gcc.dg/autopar/outer-1.c create mode 100644 gcc/testsuite/gcc.dg/autopar/outer-2.c create mode 100644 gcc/testsuite/gcc.dg/autopar/outer-3.c create mode 100644 gcc/testsuite/gcc.dg/autopar/outer-4.c create mode 100644 gcc/testsuite/gcc.dg/autopar/outer-5.c create mode 100644 gcc/testsuite/gcc.dg/autopar/outer-6.c create mode 100644 gcc/testsuite/gcc.dg/autopar/parallelization-1.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr39500-1.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr39500-2.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46066.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46099.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46194.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46561.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46799.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46885.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr46969.c create mode 100644 gcc/testsuite/gcc.dg/autopar/pr47060.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-1.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-1char.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-1short.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-2.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-2char.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-2short.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-3.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-6.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-7.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-8.c create mode 100644 gcc/testsuite/gcc.dg/autopar/reduc-9.c (limited to 'gcc/testsuite/gcc.dg/autopar') diff --git a/gcc/testsuite/gcc.dg/autopar/autopar.exp b/gcc/testsuite/gcc.dg/autopar/autopar.exp new file mode 100644 index 000000000..d19e51f7f --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/autopar.exp @@ -0,0 +1,40 @@ +# Copyright (C) 2008 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# . + +# GCC testsuite that uses the `dg.exp' driver. + +# Load support procs. +load_lib gcc-dg.exp + +if ![check_effective_target_pthread] { + return +} + +# If a testcase doesn't have special options, use these. +global DEFAULT_CFLAGS +if ![info exists DEFAULT_CFLAGS] then { + set DEFAULT_CFLAGS " -ansi -pedantic-errors" +} + +# Initialize `dg'. +dg-init + +# Main loop. +dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] \ + "" $DEFAULT_CFLAGS + +# All done. +dg-finish diff --git a/gcc/testsuite/gcc.dg/autopar/outer-1.c b/gcc/testsuite/gcc.dg/autopar/outer-1.c new file mode 100644 index 000000000..913d390f6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/outer-1.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +void parloop (int N) +{ + int i, j; + int x[10000][10000]; + + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + x[i][j] = i + j + 3; + + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + if (x[i][j] != i + j + 3) + abort (); +} + +int main(void) +{ + parloop(10000); + + return 0; +} + + +/* Check that outer loop is parallelized. */ +/* { dg-final { scan-tree-dump-times "parallelizing outer loop" 1 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/outer-2.c b/gcc/testsuite/gcc.dg/autopar/outer-2.c new file mode 100644 index 000000000..b2e515982 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/outer-2.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +void parloop (int N) +{ + int i, j,ii; + int x[401][10][401]; + +for (ii = 0; ii < N; ii++) + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + x[i][j][ii] = ii+i + j + 3; + +for (ii = 0; ii < N; ii++) + for (i = 0; i < N;i++) + for (j = 0; j < N; j++) + if (x[i][j][ii] != ii+i + j + 3) + abort (); +} + +int main(void) +{ + parloop(400); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "parallelizing outer loop" 1 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/outer-3.c b/gcc/testsuite/gcc.dg/autopar/outer-3.c new file mode 100644 index 000000000..2f1033f98 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/outer-3.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +void parloop (int N) +{ + int i, j; + int x[500][500]; + + for (i = 0; i < N; i++) + for (j = 0; j < i; j++) + x[i][j] = i + j + 3; + + for (i = 0; i < N; i++) + for (j = 0; j < i; j++) + if (x[i][j] != i + j + 3) + abort (); +} + +int main(void) +{ + parloop(500); + + return 0; +} + + +/* Check that outer loop is parallelized. */ +/* { dg-final { scan-tree-dump-times "parallelizing outer loop" 1 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/outer-4.c b/gcc/testsuite/gcc.dg/autopar/outer-4.c new file mode 100644 index 000000000..56f612338 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/outer-4.c @@ -0,0 +1,37 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +int g_sum=0; +int x[500][500]; + +__attribute__((noinline)) +void parloop (int N) +{ + int i, j; + int sum; + + /* Double reduction is currently not supported, outer loop is not + parallelized. Inner reduction is detected, inner loop is + parallelized. */ + sum = 0; + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + sum += x[i][j]; + + g_sum = sum; +} + +int main(void) +{ + parloop(500); + + return 0; +} + + +/* { dg-final { scan-tree-dump-times "parallelizing outer loop" 1 "parloops" { xfail *-*-* } } } */ +/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/outer-5.c b/gcc/testsuite/gcc.dg/autopar/outer-5.c new file mode 100644 index 000000000..3a542988c --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/outer-5.c @@ -0,0 +1,50 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +int x[500][500]; +int y[500]; +int g_sum=0; + +__attribute__((noinline)) +void init (int i, int j) +{ + x[i][j]=1; +} + +__attribute__((noinline)) +void parloop (int N) +{ + int i, j; + int sum; + + /* Inner cycle is currently not supported, outer loop is not + parallelized. Inner reduction is detected, inner loop is + parallelized. */ + for (i = 0; i < N; i++) + { + sum = 0; + for (j = 0; j < N; j++) + sum += x[i][j]; + y[i]=sum; + } + g_sum = sum; +} + +int main(void) +{ + int i,j; + for (i = 0; i < 500; i++) + for (j = 0; j < 500; j++) + init(i, j); + + parloop(500); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "parallelizing outer loop" 1 "parloops" { xfail *-*-* } } } */ +/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/outer-6.c b/gcc/testsuite/gcc.dg/autopar/outer-6.c new file mode 100644 index 000000000..6e027d2f6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/outer-6.c @@ -0,0 +1,51 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +int x[500][500]; +int y[500]; +int g_sum=0; + +__attribute__((noinline)) +void init (int i, int j) +{ + x[i][j]=1; +} + +__attribute__((noinline)) +void parloop (int N) +{ + int i, j; + int sum; + + /* Outer loop reduction, outerloop is parallelized. */ + sum=0; + for (i = 0; i < N; i++) + { + for (j = 0; j < N; j++) + y[i]=x[i][j]; + sum += y[i]; + } + g_sum = sum; +} + +int main(void) +{ + int i,j; + for (i = 0; i < 500; i++) + for (j = 0; j < 500; j++) + init(i, j); + + parloop(500); + + return 0; +} + + +/* Check that outer loop is parallelized. */ +/* { dg-final { scan-tree-dump-times "parallelizing outer loop" 1 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "parallelizing inner loop" 0 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "loopfn" 5 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/parallelization-1.c b/gcc/testsuite/gcc.dg/autopar/parallelization-1.c new file mode 100644 index 000000000..f53be8598 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/parallelization-1.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +void abort (void); + +void parloop (int N) +{ + int i; + int x[10000990]; + + for (i = 0; i < N; i++) + x[i] = i + 3; + + for (i = 0; i < N; i++) + { + if (x[i] != i + 3) + abort (); + } +} + +int main(void) +{ + parloop(10000); + + return 0; +} + +/* 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 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/pr39500-1.c b/gcc/testsuite/gcc.dg/autopar/pr39500-1.c new file mode 100644 index 000000000..6428bd062 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr39500-1.c @@ -0,0 +1,28 @@ +/* pr39500: autopar fails to parallel */ +/* origin: nemokingdom@gmail.com(LiFeng) */ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details" } */ + +void abort (void); + +int main (void) +{ + int i; + int x[100000]; + + for (i = 0; i < 10000; i++) + x[i] = x[i+10000]; + + for (i = 0; i < 10000; i++) + { + if (x[i] != x[i+10000]) + abort (); + } + + return 0; +} + +/* Check that the first loop in parloop got parallelized. */ + +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 1 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/pr39500-2.c b/gcc/testsuite/gcc.dg/autopar/pr39500-2.c new file mode 100644 index 000000000..eabac3f88 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr39500-2.c @@ -0,0 +1,20 @@ +/* pr39500: autopar fails to parallel */ +/* origin: nemokingdom@gmail.com(LiFeng) */ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details" } */ + +int main (void) +{ + int i; + int x[1000]; + + for (i = 0; i < 101; i++) + x[i] = x[i+100]; + + return x[12]; +} + +/* This loop cannot be parallelized due to a dependence. */ + +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 0 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/pr46066.c b/gcc/testsuite/gcc.dg/autopar/pr46066.c new file mode 100644 index 000000000..e9bf6c59e --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46066.c @@ -0,0 +1,18 @@ +/* PR tree-optimization/46066 */ +/* { dg-do compile } */ +/* { dg-options "-fcompare-debug -O -ftree-parallelize-loops=4" } */ + +void +parloop (int N) +{ + int i, j, ii; + int x[400][10][400]; + for (ii = 0; ii < N; ii++) + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + x[i][j][ii] = 3; + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + if (x[i][j][0] != 3) + __builtin_abort (); +} diff --git a/gcc/testsuite/gcc.dg/autopar/pr46099.c b/gcc/testsuite/gcc.dg/autopar/pr46099.c new file mode 100644 index 000000000..074278e64 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46099.c @@ -0,0 +1,47 @@ +/* PR tree-optimization/46099 */ +/* { dg-do compile } */ +/* { dg-options "-ftree-parallelize-loops=2 -fcompare-debug -O" } */ + +static inline void +bar (int *i) +{ + int j = *i; +} + +void baz (int *, int *, int *); + +void +f1 (int n) +{ + int i; + for (i = 0; i < n; i++) + bar (&i); +} + +void +f2 (int n) +{ + int i; + int a[10000], b[10000], c[10000]; + baz (a, b, c); + for (i = 0; i < n; i++) + { + void *p = c; + a[i] = b[i] + c[i]; + } + baz (a, b, c); +} + +void +f3 (int n) +{ + int i; + int a[10000], b[10000], c[10000]; + baz (a, b, c); + for (i = 0; i < n; i++) + { + a[i] = b[i] + c[i]; + void *p = c; + } + baz (a, b, c); +} diff --git a/gcc/testsuite/gcc.dg/autopar/pr46194.c b/gcc/testsuite/gcc.dg/autopar/pr46194.c new file mode 100644 index 000000000..574d6e672 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46194.c @@ -0,0 +1,24 @@ +/* PR tree-optimization/46194 */ +/* { dg-do compile } */ +/* { dg-options "-O -ftree-parallelize-loops=2 -fdump-tree-parloops-details" } */ + +#define N 1000 +int a[N]; + +int foo (void) +{ + int j; + int i; + + /* This is not blocked as it is not profitable. */ + for (i = 0; i < N; i++) + for (j = 0; j < N; j++) + a[j] = a[i] + 1; + + return a[0]; +} + +/* This loop cannot be parallelized due to a dependence. */ + +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 0 "parloops" } } */ +/* { dg-final { cleanup-tree-dump "parloops" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/pr46561.c b/gcc/testsuite/gcc.dg/autopar/pr46561.c new file mode 100644 index 000000000..a9499f340 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46561.c @@ -0,0 +1,17 @@ +/* PR debug/46561 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-vectorize -ftree-parallelize-loops=2 -fcompare-debug" } */ + +extern void abort (void); + +void foo (char *c) +{ + int i; + unsigned x = 0; + { + for (i = 0; i < 64; i += 4) + x = x | *((unsigned *) (&c[i])); + if (x) + abort (); + } +} diff --git a/gcc/testsuite/gcc.dg/autopar/pr46799.c b/gcc/testsuite/gcc.dg/autopar/pr46799.c new file mode 100644 index 000000000..575e12c55 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46799.c @@ -0,0 +1,12 @@ +/* PR debug/46799 */ +/* { dg-do compile } */ +/* { dg-options "-O -ftree-parallelize-loops=2 -fno-tree-dce -ftree-pre -fcompare-debug" } */ + +int +foo (int i, int *a) +{ + int e; + for (; i; i++) + e = *a; + return e; +} diff --git a/gcc/testsuite/gcc.dg/autopar/pr46885.c b/gcc/testsuite/gcc.dg/autopar/pr46885.c new file mode 100644 index 000000000..9560c92bf --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46885.c @@ -0,0 +1,23 @@ +/* PR debug/46885 */ +/* { dg-do compile } */ +/* { dg-options "-O -ftree-parallelize-loops=4 -fcompare-debug -fno-tree-dominator-opts -funswitch-loops" } */ + +static inline void +bar (int i) +{ + (void) i; +} + +int +foo (int *begin, int *end) +{ + int s = 0; + int *i; + for (i = begin; i != end; ++i) + { + bar (0); + if (begin) + return s; + } + return 0; +} diff --git a/gcc/testsuite/gcc.dg/autopar/pr46969.c b/gcc/testsuite/gcc.dg/autopar/pr46969.c new file mode 100644 index 000000000..807ce4f92 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr46969.c @@ -0,0 +1,31 @@ +/* PR tree-optimization/46969 */ +/* { dg-do compile } */ +/* { dg-options "-O3 -ftree-parallelize-loops=2 -fcompare-debug" } */ + +extern void abort (void); +#define F(name) \ +int \ +name (unsigned char *x) \ +{ \ + int i; \ + unsigned int c, d, e; \ + if (x != 0) \ + { \ + for (i = 0, d = 0, e = 0xFFFFFFFF; \ + i < 64; \ + i += (int) sizeof(unsigned int)) \ + { \ + c = *((unsigned int *)(&x[i])); \ + d = d | c; \ + e = e & c; \ + } \ + if (!((d == e) && ((d >> 8) == (e & 0x00FFFFFF)))) \ + abort (); \ + } \ + return 0; \ +} +F (foo0) F (foo1) +F (foo2) F (foo3) +F (foo4) F (foo5) +F (foo6) F (foo7) +F (foo8) F (foo9) diff --git a/gcc/testsuite/gcc.dg/autopar/pr47060.c b/gcc/testsuite/gcc.dg/autopar/pr47060.c new file mode 100644 index 000000000..e8cdfd667 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/pr47060.c @@ -0,0 +1,21 @@ +/* PR tree-optimization/47060 */ +/* { dg-do compile } */ +/* { dg-options "-O -ffast-math -ftree-parallelize-loops=2 -fno-tree-dce" } */ + +struct S +{ + int n; + float *a; +}; + +float +foo (struct S *b) +{ + float c, d; + int j; + for (j = 0; j < b->n; j++) + d += b->a[j]; + for (j = 0; j < b->n; j++) + c += b->a[j]; + return d; +} diff --git a/gcc/testsuite/gcc.dg/autopar/reduc-1.c b/gcc/testsuite/gcc.dg/autopar/reduc-1.c new file mode 100644 index 000000000..8018a558c --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/reduc-1.c @@ -0,0 +1,73 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +#include +#include + + #define N 1600 + #define DIFF 2558402 + +unsigned int ub[N]; +unsigned int uc[N]; + + /* Reduction of unsigned-int. */ + + void main1 (unsigned int x, unsigned int max_result, unsigned int min_result) + { + int i; + unsigned int udiff = 2; + unsigned int umax = x; + unsigned int umin = x; + + /* Summation. */ + for (i = 0; i < N; i++) { + udiff += (ub[i] - uc[i]); + } + + /* Maximum. */ + for (i = 0; i < N; i++) { + umax = umax < uc[i] ? uc[i] : umax; + } + + /* Minimum. */ + for (i = 0; i < N; i++) { + umin = umin > uc[i] ? uc[i] : umin; + } + + /* check results: */ + if (udiff != DIFF) + abort (); + if (umax != max_result) + abort (); + if (umin != min_result) + abort (); + } + + __attribute__((noinline)) + void init_arrays () + { + int i; + + ub[0] = 1; + uc[0] = 1; + for (i=1; i +#include + +#define N 1600 +#define DIFF 242 + +unsigned char ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; +unsigned char uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +__attribute__ ((noinline)) void +main1 (unsigned char x, unsigned char max_result, unsigned char min_result) +{ + int i; + unsigned char udiff = 2; + unsigned char umax = x; + unsigned char umin = x; + + for (i = 0; i < N; i++) { + udiff += (unsigned char)(ub[i] - uc[i]); + } + + for (i = 0; i < N; i++) { + umax = umax < uc[i] ? uc[i] : umax; + } + + for (i = 0; i < N; i++) { + umin = umin > uc[i] ? uc[i] : umin; + } + + /* check results: */ + if (udiff != DIFF) + abort (); + if (umax != max_result) + abort (); + if (umin != min_result) + abort (); +} + + __attribute__((noinline)) + void init_arrays () + { + int i; + + for (i=16; i +#include + +#define N 1600 +#define DIFF 242 + +unsigned short ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; +unsigned short uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +__attribute__ ((noinline)) void +main1 (unsigned short x, unsigned short max_result, unsigned short min_result) +{ + int i; + unsigned short udiff = 2; + unsigned short umax = x; + unsigned short umin = x; + + for (i = 0; i < N; i++) { + udiff += (unsigned short)(ub[i] - uc[i]); + } + + for (i = 0; i < N; i++) { + umax = umax < uc[i] ? uc[i] : umax; + } + + for (i = 0; i < N; i++) { + umin = umin > uc[i] ? uc[i] : umin; + } + + /* check results: */ + if (udiff != DIFF) + abort (); + if (umax != max_result) + abort (); + if (umin != min_result) + abort (); +} + + __attribute__((noinline)) + void init_arrays () + { + int i; + + for (i=16; i +#include + +#define N 1600 +#define DIFF 2558400 + +int b[N]; +int c[N]; + +/* Reduction of signed-int. */ + +__attribute__ ((noinline)) +void main1 (int x, int max_result, int min_result) +{ + int i; + int diff = 0; + int max = x; + int min = x; + + for (i = 0; i < N; i++) { + diff += (b[i] - c[i]); + } + + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != min_result) + abort (); +} + + __attribute__((noinline)) + void init_arrays () + { + int i; + + b[0] = 1; + c[0] = 1; + for (i=1; i +#include + +#define N 1600 +#define DIFF 121 + +signed char b[N] = {1,2,3,6,8,10,12,14,16,18,20,22,24,26,28,30}; +signed char c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +__attribute__ ((noinline)) +void main1 (signed char x, signed char max_result, signed char min_result) +{ + int i; + signed char diff = 2; + signed char max = x; + signed char min = x; + + for (i = 0; i < N; i++) { + diff += (signed char)(b[i] - c[i]); + } + + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != min_result) + abort (); +} + + __attribute__((noinline)) + void init_arrays () + { + int i; + + for (i=16; i +#include + +#define N 1600 +#define DIFF 242 + +short b[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; +short c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +__attribute__ ((noinline)) +void main1 (short x, short max_result, short min_result) +{ + int i; + short diff = 2; + short max = x; + short min = x; + + for (i = 0; i < N; i++) { + diff += (short)(b[i] - c[i]); + } + for (i = 0; i < N; i++) { + max = max < c[i] ? c[i] : max; + } + + for (i = 0; i < N; i++) { + min = min > c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != min_result) + abort (); +} + + __attribute__((noinline)) + void init_arrays () + { + int i; + + for (i=16; i +#include + +#define N 1600 + +unsigned int ub[N]; +unsigned int uc[N]; + +/* Reduction of unsigned-int. */ + +__attribute__ ((noinline)) +int main1 (int n, int res) +{ + int i; + unsigned int udiff; + + udiff = 0; + for (i = 0; i < n; i++) { + udiff += (ub[i] - uc[i]); + } + + /* check results: */ + if (udiff != res) + abort (); + + return 0; +} + +__attribute__((noinline)) +void init_arrays () +{ + int i; + + for (i=0; i +#include + +#define N 1600 +#define DIFF 2558402 + + +__attribute__ ((noinline)) +int main1 (float x, float max_result) +{ + int i; + float b[N]; + float c[N]; + float diff = 2; + float max = x; + float min = 10; + + for (i=0; i c[i] ? c[i] : min; + } + + /* check results: */ + if (diff != DIFF) + abort (); + if (max != max_result) + abort (); + if (min != 0) + abort (); + + return 0; +} + +int main (void) +{ + main1 (2000, 2000); + main1 (0, 1599); + return 0; +} + + +/* need -ffast-math to parallelize these loops. */ +/* { dg-final { scan-tree-dump-times "Detected reduction" 0 "parloops" } } */ +/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 1 "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 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/autopar/reduc-7.c b/gcc/testsuite/gcc.dg/autopar/reduc-7.c new file mode 100644 index 000000000..f66069e56 --- /dev/null +++ b/gcc/testsuite/gcc.dg/autopar/reduc-7.c @@ -0,0 +1,91 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-optimized" } */ + +#include + +#define N 3200 + +extern void abort (void); +typedef unsigned char T; + +__attribute__ ((noinline)) void +testmax (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum < lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +__attribute__ ((noinline)) void +testmin (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum > lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +int main (void) +{ + static unsigned char A[N] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f + }; + + static unsigned char B[N] = { + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f + }; + + static unsigned char C[N] = { + 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + }; + + int i; + + for (i=32; i + +#define N 3200 + +extern void abort (void); +typedef signed char T; + +__attribute__ ((noinline)) void +testmax (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum < lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +__attribute__ ((noinline)) void +testmin (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum > lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +int main (void) +{ + static signed char A[N] = { + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f + }; + + static signed char B[N] = { + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f + }; + + static signed char C[N] = { + 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + }; + + int i; + + for (i=32; i + +#define N 3200 + +extern void abort (void); +typedef unsigned short T; + +__attribute__ ((noinline)) void +testmax (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum < lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +__attribute__ ((noinline)) void +testmin (const T *c, T init, T result) +{ + T lc[N], accum = init; + int i; + + __builtin_memcpy (lc, c, sizeof(lc)); + + for (i = 0; i < N; i++) { + accum = accum > lc[i] ? lc[i] : accum; + } + + if (accum != result) + abort (); +} + +int main (void) +{ + static unsigned short A[N] = { + 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, + 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, + 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, + 0x7ff8, 0x7ff9, 0x7ffa, 0x7ffb, 0x7ffc, 0x7ffd, 0x7ffe, 0x7fff + }; + + static unsigned short B[N] = { + 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, + 0x7ff8, 0x7ff9, 0x7ffa, 0x7ffb, 0x7ffc, 0x7ffd, 0x7ffe, 0x7fff, + 0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007, + 0x8008, 0x8009, 0x800a, 0x800b, 0x800c, 0x800d, 0x800e, 0x800f + }; + + static unsigned short C[N] = { + 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9, 0xfff8, + 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, + 0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007, + 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, + }; + + int i; + + for (i=32; i