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/torture/stackalign/alloca-1.c | 45 +++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c | 49 ++++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c | 49 ++++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c | 41 ++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c | 32 +++++++++ gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c | 34 ++++++++++ .../gcc.dg/torture/stackalign/builtin-apply-1.c | 9 +++ .../gcc.dg/torture/stackalign/builtin-apply-2.c | 30 +++++++++ .../gcc.dg/torture/stackalign/builtin-apply-3.c | 31 +++++++++ .../gcc.dg/torture/stackalign/builtin-apply-4.c | 29 ++++++++ .../gcc.dg/torture/stackalign/builtin-return-1.c | 34 ++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/check.h | 36 ++++++++++ .../gcc.dg/torture/stackalign/comp-goto-1.c | 41 ++++++++++++ .../gcc.dg/torture/stackalign/fastcall-1.c | 31 +++++++++ gcc/testsuite/gcc.dg/torture/stackalign/global-1.c | 28 ++++++++ gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c | 29 ++++++++ gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c | 46 +++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c | 45 +++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c | 46 +++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c | 63 +++++++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c | 34 ++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c | 38 +++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c | 28 ++++++++ .../gcc.dg/torture/stackalign/non-local-goto-1.c | 55 +++++++++++++++ .../gcc.dg/torture/stackalign/non-local-goto-2.c | 56 ++++++++++++++++ .../gcc.dg/torture/stackalign/non-local-goto-3.c | 42 ++++++++++++ .../gcc.dg/torture/stackalign/non-local-goto-4.c | 38 +++++++++++ .../gcc.dg/torture/stackalign/non-local-goto-5.c | 11 +++ .../gcc.dg/torture/stackalign/pr16660-1.c | 18 +++++ .../gcc.dg/torture/stackalign/pr16660-2.c | 12 ++++ .../gcc.dg/torture/stackalign/pr16660-3.c | 14 ++++ gcc/testsuite/gcc.dg/torture/stackalign/push-1.c | 51 ++++++++++++++ .../gcc.dg/torture/stackalign/regparm-1.c | 60 +++++++++++++++++ .../gcc.dg/torture/stackalign/ret-struct-1.c | 36 ++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c | 43 ++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c | 46 +++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c | 37 ++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c | 39 +++++++++++ .../gcc.dg/torture/stackalign/sibcall-1.c | 35 ++++++++++ .../gcc.dg/torture/stackalign/stackalign.exp | 50 ++++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c | 29 ++++++++ .../gcc.dg/torture/stackalign/thiscall-1.c | 31 +++++++++ gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c | 60 +++++++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c | 66 ++++++++++++++++++ gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c | 78 ++++++++++++++++++++++ 45 files changed, 1755 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/check.h create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/global-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/push-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c (limited to 'gcc/testsuite/gcc.dg/torture/stackalign') diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c new file mode 100644 index 000000000..e226e7f03 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c @@ -0,0 +1,45 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +foo (int size) +{ + char *p = __builtin_alloca (size + 1); + aligned i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +int +main() +{ + foo (5); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c new file mode 100644 index 000000000..139b74ed9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c @@ -0,0 +1,49 @@ +/* PR middle-end/37009 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-msse2" } */ +/* { dg-require-effective-target sse2_runtime } */ + +#include +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 16 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +__attribute__ ((noinline)) +foo (__m128 x, __m128 y ,__m128 z , int size) +{ + char *p = __builtin_alloca (size + 1); + aligned i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +int +main (void) +{ + __m128 x = { 1.0 }; + foo (x, x, x, 5); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c new file mode 100644 index 000000000..31cb0c472 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c @@ -0,0 +1,49 @@ +/* PR middle-end/37009 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-msse2" } */ +/* { dg-require-effective-target sse2_runtime } */ + +#include +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 16 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +__attribute__ ((noinline)) +foo (__m128 x, __m128 y ,__m128 z ,__m128 a, int size) +{ + char *p = __builtin_alloca (size + 1); + aligned i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +int +main (void) +{ + __m128 x = { 1.0 }; + foo (x, x, x, x, 5); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c new file mode 100644 index 000000000..c3e554acf --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c @@ -0,0 +1,41 @@ +/* PR middle-end/37009 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mincoming-stack-boundary=2 -mpreferred-stack-boundary=2" } */ + +#include "check.h" + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +__attribute__ ((noinline)) +foo (double x, double y ,double z ,double a, int size) +{ + char *p = __builtin_alloca (size + 1); + double i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + check (&i, __alignof__(i)); +} + +int +main (void) +{ + double x = 1.0 ; + + foo (x, x, x, x, 5); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c new file mode 100644 index 000000000..2ef4443f2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c @@ -0,0 +1,32 @@ +/* PR middle-end/45234 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mincoming-stack-boundary=2 -mpreferred-stack-boundary=2" } */ + +#include "check.h" + +void +__attribute__ ((noinline)) +bar (__float128 f) +{ + check (&f, __alignof__(f)); +} + +int +main (void) +{ + char *p = __builtin_alloca (6); + + bar (0); + + __builtin_strncpy (p, "good", 5); + if (__builtin_strncmp (p, "good", 5) != 0) + { +#ifdef DEBUG + p[5] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c new file mode 100644 index 000000000..f0e4513de --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c @@ -0,0 +1,34 @@ +/* PR middle-end/45234 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-mincoming-stack-boundary=2 -mpreferred-stack-boundary=2" } */ + +#include "check.h" + +void +__attribute__ ((noinline)) +bar (__float128 f) +{ + check (&f, __alignof__(f)); +} + +volatile int z = 6; + +int +main (void) +{ + char *p = __builtin_alloca (z); + + bar (0); + + __builtin_strncpy (p, "good", 5); + if (__builtin_strncmp (p, "good", 5) != 0) + { +#ifdef DEBUG + p[z - 1] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c new file mode 100644 index 000000000..38b384e7c --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c @@ -0,0 +1,9 @@ +/* PR 11184 */ +/* Origin: Dara Hazeghi */ + +void * +objc_msg_sendv (char * arg_frame, void (*foo)()) +{ + return __builtin_apply ( foo, arg_frame, 4); +} + diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c new file mode 100644 index 000000000..a1ba20fce --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c @@ -0,0 +1,30 @@ +/* PR target/12503 */ +/* Origin: */ + +/* Verify that __builtin_apply behaves correctly on targets + with pre-pushed arguments (e.g. SPARC). */ + +/* { dg-do run } */ + + +#define INTEGER_ARG 5 + +extern void abort(void); + +void foo(char *name, double d, double e, double f, int g) +{ + if (g != INTEGER_ARG) + abort(); +} + +void bar(char *name, ...) +{ + __builtin_apply(foo, __builtin_apply_args(), 64); +} + +int main(void) +{ + bar("eeee", 5.444567, 8.90765, 4.567789, INTEGER_ARG); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c new file mode 100644 index 000000000..1335d0902 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c @@ -0,0 +1,31 @@ +/* PR middle-end/12210 */ +/* Origin: Ossadchy Yury A. */ + +/* This used to fail on i686 because the argument was not copied + to the right location by __builtin_apply after the direct call. */ + +/* { dg-do run } */ + + +#define INTEGER_ARG 5 + +extern void abort(void); + +void foo(int arg) +{ + if (arg != INTEGER_ARG) + abort(); +} + +void bar(int arg) +{ + foo(arg); + __builtin_apply(foo, __builtin_apply_args(), 16); +} + +int main(void) +{ + bar(INTEGER_ARG); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c new file mode 100644 index 000000000..28dc6106d --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c @@ -0,0 +1,29 @@ +/* PR tree-optimization/20076 */ +/* { dg-do run } */ + +extern void abort (void); + +double +foo (int arg) +{ + if (arg != 116) + abort(); + return arg + 1; +} + +inline double +bar (int arg) +{ + foo (arg); + __builtin_return (__builtin_apply ((void (*) ()) foo, + __builtin_apply_args (), 16)); +} + +int +main (int argc, char **argv) +{ + if (bar (116) != 117.0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c new file mode 100644 index 000000000..75c9acdf7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c @@ -0,0 +1,34 @@ +/* PR middle-end/11151 */ +/* Originator: Andrew Church */ +/* { dg-do run } */ + +/* This used to fail on SPARC because the (undefined) return + value of 'bar' was overwriting that of 'foo'. */ + +extern void abort(void); + +int foo(int n) +{ + return n+1; +} + +int bar(int n) +{ + __builtin_return(__builtin_apply((void (*)(void))foo, __builtin_apply_args(), 64)); +} + +char *g; + +int main(void) +{ + /* Allocate 64 bytes on the stack to make sure that __builtin_apply + can read at least 64 bytes above the return address. */ + char dummy[64]; + + g = dummy; + + if (bar(1) != 2) + abort(); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/check.h b/gcc/testsuite/gcc.dg/torture/stackalign/check.h new file mode 100644 index 000000000..af1988512 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/check.h @@ -0,0 +1,36 @@ +#include +#ifdef DEBUG +#include +#endif + +#ifdef __cplusplus +extern "C" void abort (void); +#else +extern void abort (void); +#endif + +int +check_int (int *i, int align) +{ + *i = 20; + if ((((ptrdiff_t) i) & (align - 1)) != 0) + { +#ifdef DEBUG + printf ("\nUnalign address (%d): %p!\n", align, i); +#endif + abort (); + } + return *i; +} + +void +check (void *p, int align) +{ + if ((((ptrdiff_t) p) & (align - 1)) != 0) + { +#ifdef DEBUG + printf ("\nUnalign address (%d): %p!\n", align, p); +#endif + abort (); + } +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c new file mode 100644 index 000000000..7558f01e2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c @@ -0,0 +1,41 @@ +/* { dg-do run } */ + +#ifdef STACK_SIZE +#define DEPTH ((STACK_SIZE) / 512 + 1) +#else +#define DEPTH 1000 +#endif + +extern void abort (void); +extern void exit (int); + +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) +int +x(a) +{ + __label__ xlab; + void y(a) + { + void *x = &&llab; + if (a==-1) + goto *x; + if (a==0) + goto xlab; + llab: + y (a-1); + } + y (a); + xlab:; + return a; +} +#endif + +int +main () +{ +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) + if (x (DEPTH) != DEPTH) + abort (); +#endif + exit (0); +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c new file mode 100644 index 000000000..d1cda1010 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c @@ -0,0 +1,31 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +__attribute__ ((fastcall)) +void +foo (int j, int k, int m, int n, int o) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (i != 20 || j != 1 || k != 2 || m != 3 || n != 4 || o != 5) + abort (); +} + +int +main() +{ + foo (1, 2, 3, 4, 5); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c new file mode 100644 index 000000000..332103a76 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c @@ -0,0 +1,28 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +foo (void) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +int +main() +{ + foo (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c new file mode 100644 index 000000000..38127fd50 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +static void +inline __attribute__((always_inline)) +foo (void) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +int +main() +{ + foo (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c new file mode 100644 index 000000000..85a2ee3f3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c @@ -0,0 +1,46 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +static void +inline __attribute__((always_inline)) +foo (int size) +{ + char *p = __builtin_alloca (size + 1); + aligned i; + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +int +main() +{ + foo (5); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c new file mode 100644 index 000000000..8402f95f5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c @@ -0,0 +1,45 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +foo (void) +{ + aligned j; + + void bar () + { + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (check_int (&j, __alignof__(j)) != j) + abort (); + + j = -20; + } + bar (); + + if (j != -20) + abort (); + + if (check_int (&j, __alignof__(j)) != j) + abort (); +} + +int +main() +{ + foo (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c new file mode 100644 index 000000000..dabc310d7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c @@ -0,0 +1,46 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +foo (void) +{ + aligned j; + + __attribute__ ((__noinline__)) + void bar () + { + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (check_int (&j, __alignof__(j)) != j) + abort (); + + j = -20; + } + bar (); + + if (j != -20) + abort (); + + if (check_int (&j, __alignof__(j)) != j) + abort (); +} + +int +main() +{ + foo (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c new file mode 100644 index 000000000..d35c9a7ce --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c @@ -0,0 +1,63 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +copy (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +foo (int size) +{ + aligned j; + + __attribute__ ((__noinline__)) + void bar (int size) + { + char *p = __builtin_alloca (size + 1); + aligned i; + + copy (p, size); + if (strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (check_int (&j, __alignof__(j)) != j) + abort (); + + j = -20; + } + bar (size); + + if (j != -20) + abort (); + + if (check_int (&j, __alignof__(j)) != j) + abort (); +} + +int +main() +{ + foo (5); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c b/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c new file mode 100644 index 000000000..05cb83301 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c @@ -0,0 +1,34 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int n; + +void +g (void) +{ + __label__ lab; + void h (void) + { + aligned t; + if (check_int (&t, __alignof__(t)) != t) + abort (); + if (n+t == 0) goto lab; + } + h(); +lab: + return; +} + +int main() +{ + g(); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c b/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c new file mode 100644 index 000000000..95eba0482 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c @@ -0,0 +1,38 @@ +/* { dg-do run } */ + +extern void abort (void); +extern void exit (int); + +#ifndef NO_TRAMPOLINES +static void recursive (int n, void (*proc) (void)) +{ + __label__ l1; + + void do_goto (void) + { + goto l1; + } + + if (n == 3) + recursive (n - 1, do_goto); + else if (n > 0) + recursive (n - 1, proc); + else + (*proc) (); + return; + +l1: + if (n == 3) + exit (0); + else + abort (); +} + +int main () +{ + recursive (10, abort); + abort (); +} +#else +int main () { return 0; } +#endif diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c b/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c new file mode 100644 index 000000000..d853825fe --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c @@ -0,0 +1,28 @@ +/* { dg-do run } */ + +#ifndef NO_TRAMPOLINES + +typedef __SIZE_TYPE__ size_t; +extern void abort (void); +extern void exit (int); +extern void qsort(void *, size_t, size_t, int (*)(const void *, const void *)); + +int main () +{ + __label__ nonlocal; + int compare (const void *a, const void *b) + { + goto nonlocal; + } + + char array[3]; + qsort (array, 3, 1, compare); + abort (); + + nonlocal: + exit (0); +} + +#else +int main() { return 0; } +#endif diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c new file mode 100644 index 000000000..263d4486c --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c @@ -0,0 +1,55 @@ +/* { dg-do run } */ + +extern void abort (void); + +int global; + +static void foo(void) __attribute__((noinline)); + +static void foo(void) +{ + global = 1; +} + +static void bar(void) +{ + foo (); +} + +int execute(int cmd) +{ + __label__ start; + + void raise(void) + { + goto start; + } + + int last = -1; + + bar (); + + last = 0; + +start: + + if (last == 0) + while (1) + { + last = 1; + raise (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c new file mode 100644 index 000000000..5a64d5419 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c @@ -0,0 +1,56 @@ +/* { dg-do run } */ + +extern void abort (void); + +int global; + +static void foo(void) __attribute__((noinline)); + +static void foo(void) +{ + global = 1; +} + +static void bar(void) +{ + foo (); + global = 0; +} + +int execute(int cmd) +{ + __label__ start; + + void raise(void) + { + goto start; + } + + int last = -1; + + bar (); + + last = 0; + +start: + + if (last == 0) + while (1) + { + last = 1; + raise (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c new file mode 100644 index 000000000..3afc8cc6a --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c @@ -0,0 +1,42 @@ +/* { dg-do run } */ + +#ifndef NO_TRAMPOLINES +extern void abort (void); + +int x(int a, int b) +{ + __label__ xlab; + + void y(int b) + { + switch (b) + { + case 1: goto xlab; + case 2: goto xlab; + } + } + + a = a + 2; + y (b); + + xlab: + return a; +} + +int main () +{ + int i, j; + + for (j = 1; j <= 2; ++j) + for (i = 1; i <= 2; ++i) + { + int a = x (j, i); + if (a != 2 + j) + abort (); + } + + return 0; +} +#else +int main() { return 0; } +#endif diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c new file mode 100644 index 000000000..3673f1ac3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c @@ -0,0 +1,38 @@ +/* { dg-do run } */ + +extern void abort (void); +extern void exit (int); + +#ifdef STACK_SIZE +#define DEPTH ((STACK_SIZE) / 512 + 1) +#else +#define DEPTH 1000 +#endif + +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) +int + +x(a) +{ + __label__ xlab; + void y(a) + { + if (a==0) + goto xlab; + y (a-1); + } + y (a); + xlab:; + return a; +} +#endif + +int +main () +{ +#if ! defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) + if (x (DEPTH) != DEPTH) + abort (); +#endif + exit (0); +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c new file mode 100644 index 000000000..d198c9a97 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c @@ -0,0 +1,11 @@ +/* { dg-do run } */ + +extern void exit (int); +#if !defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES) +extern void abort (void); +int s(i){if(i>0){__label__ l1;int f(int i){if(i==2)goto l1;return 0;}return f(i);l1:;}return 1;} +int x(){return s(0)==1&&s(1)==0&&s(2)==1;} +int main(){if(x()!=1)abort();exit(0);} +#else +int main(){ exit (0); } +#endif diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c new file mode 100644 index 000000000..b917e824b --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c @@ -0,0 +1,18 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +void +f () +{ + unsigned long tmp[4] __attribute__((aligned(64))); + check (&tmp, 64); +} + +int +main() +{ + f(); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c new file mode 100644 index 000000000..9a039eb2b --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c @@ -0,0 +1,12 @@ +/* { dg-do run } */ + +#include "check.h" + +typedef __SIZE_TYPE__ size_t; +#define ALIGNMENT 256 +int main(void) +{ + int a[ALIGNMENT/sizeof(int)] __attribute__((aligned(ALIGNMENT))); + check (&a, ALIGNMENT); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c new file mode 100644 index 000000000..1c1ddd1dd --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c @@ -0,0 +1,14 @@ +/* { dg-do run } */ + +#include "check.h" + +typedef __SIZE_TYPE__ size_t; +#define ALIGNMENT 256 +int main(void) +{ + int a[ALIGNMENT/sizeof(int)] __attribute__((aligned(ALIGNMENT))); + check (&a, ALIGNMENT); + int b[ALIGNMENT/sizeof(int)] __attribute__((aligned(ALIGNMENT))); + check (&b, ALIGNMENT); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c new file mode 100644 index 000000000..dd5dffc15 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c @@ -0,0 +1,51 @@ +/* PR middle-end/37010 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-msse2 -mpreferred-stack-boundary=2" } */ +/* { dg-require-effective-target sse2_runtime } */ + +#include + +typedef __PTRDIFF_TYPE__ ptrdiff_t; +typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__)); +typedef int aligned __attribute__((aligned(16))); + +extern void abort (void); + +__m128 r; + +int +__attribute__ ((noinline)) +check_int (int *i, int align) +{ + *i = 20; + if ((((ptrdiff_t) i) & (align - 1)) != 0) + { + abort (); + } + return *i; +} + +void +__attribute__ ((noinline)) +foo (__m128 x, __m128 y ,__m128 z ,__m128 a, int size) +{ + aligned i; + + if (size != 5 || check_int (&i, __alignof__(i)) != i) + abort (); + + r = a; +} + +int +main (void) +{ + __m128 x = { 1.0 }; + + foo (x, x, x, x, 5); + + if (__builtin_memcmp (&r, &x, sizeof (r))) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c new file mode 100644 index 000000000..9dac024cc --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c @@ -0,0 +1,60 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int test_nested (int i) +{ + aligned y; + + int __attribute__ ((__noinline__, __regparm__(2))) foo (int j, int k, int l) + { + aligned x; + + if (check_int (&x, __alignof__(x)) != x) + abort (); + + if (x != 20) + abort (); + + return i + j + k + l; + } + + if (check_int (&y, __alignof__(y)) != y) + abort (); + + if (y != 20) + abort (); + + return foo(i, i+1, i+2) * i; +} + +int __attribute__ ((__noinline__, __regparm__(3), __force_align_arg_pointer__)) +test_realigned (int j, int k, int l) +{ + aligned y; + + if (check_int (&y, __alignof__(y)) != y) + abort (); + + if (y != 20) + abort (); + + return j + k + l; +} + +int main () +{ + if (test_nested(10) != 430) + abort (); + + if (test_realigned(10, 11, 12) != 33) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c new file mode 100644 index 000000000..b218a14ed --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c @@ -0,0 +1,36 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +extern void abort(); +typedef struct my_struct +{ + char str[31]; +} stype ; + +stype g_s; + +stype __attribute__((noinline)) +foo (char arg1, char arg2, char arg3) +{ + stype __attribute__((aligned(ALIGNMENT))) s; + s.str[0] = arg1; + s.str[1] = arg2; + s.str[30] = arg3; + check(&s, ALIGNMENT); + return s; +} + +int main() +{ + g_s = foo(1,2,3); + + if (g_s.str[0] != 1 || g_s.str[1] != 2 || g_s.str[30] !=3) + abort(); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c new file mode 100644 index 000000000..6ab67e395 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c @@ -0,0 +1,43 @@ +/* { dg-do run } */ + +extern int strcmp(const char *, const char *); +extern char *strcpy(char *, const char *); +extern void abort(void); +extern void exit(int); + +void *buf[20]; + +void __attribute__((noinline)) +sub2 (void) +{ + __builtin_longjmp (buf, 1); +} + +int +main () +{ + char *p = 0; + + p = (char *) __builtin_alloca (20); + + strcpy (p, "test"); + + if (__builtin_setjmp (buf)) + { + if (strcmp (p, "test") != 0) + abort (); + + exit (0); + } + + { + int *q = (int *) __builtin_alloca (p[2] * sizeof (int)); + int i; + + for (i = 0; i < p[2]; i++) + q[i] = 0; + + while (1) + sub2 (); + } +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c new file mode 100644 index 000000000..c93ffa867 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c @@ -0,0 +1,46 @@ +/* { dg-do run { target i?86-*-linux* x86_64-*-linux* } } */ + +#include +#include + +#ifndef NULL +#define NULL ((void *)0) +#endif +static jmp_buf segv_jmpbuf; + +static void segv_handler(int seg) +{ + __builtin_longjmp(segv_jmpbuf, 1); +} + +static int is_addressable(void *p, size_t size) +{ + volatile char * volatile cp = (volatile char *)p; + volatile int ret; + struct sigaction sa, origsa; + sigset_t mask; + + sa.sa_handler = segv_handler; + sa.sa_flags = 0; + sigfillset(&sa.sa_mask); + sigaction(SIGSEGV, &sa, &origsa); + sigprocmask(SIG_SETMASK, NULL, &mask); + + if (__builtin_setjmp(segv_jmpbuf) == 0) { + while(size--) + *cp++; + ret = 1; + } else + ret = 0; + + sigaction(SIGSEGV, &origsa, NULL); + sigprocmask(SIG_SETMASK, &mask, NULL); + + return ret; +} + +int main(int argc, char **argv) +{ + is_addressable(0x0, 1); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c new file mode 100644 index 000000000..fee0d281f --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c @@ -0,0 +1,37 @@ +/* { dg-do run } */ + +#include + +extern void abort (void); + +jmp_buf buf; + +void raise0(void) +{ + __builtin_longjmp (buf, 1); +} + +int execute(int cmd) +{ + int last = 0; + + if (__builtin_setjmp (buf) == 0) + while (1) + { + last = 1; + raise0 (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c new file mode 100644 index 000000000..d1671223a --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c @@ -0,0 +1,39 @@ +/* { dg-do run } */ + +#include + +extern void abort (void); + +jmp_buf buf; + +void raise0(void) +{ + __builtin_longjmp (buf, 1); +} + +int execute(int cmd) +{ + int last = 0; + + __builtin_setjmp (buf); + + if (last == 0) + while (1) + { + last = 1; + raise0 (); + } + + if (last == 0) + return 0; + else + return cmd; +} + +int main(void) +{ + if (execute (1) == 0) + abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c new file mode 100644 index 000000000..8c174758f --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c @@ -0,0 +1,35 @@ +/* { dg-do run } */ + +extern int ok (int); +extern void exit (); +static int gen_x86_64_shrd (int); +static int +gen_x86_64_shrd(int a __attribute__ ((__unused__))) +{ + return 0; +} + +extern int gen_x86_shrd_1 (int); +extern void ix86_split_ashr (int); + +void +ix86_split_ashr (int mode) +{ + (mode != 0 + ? ok + : gen_x86_64_shrd) (0); +} + +volatile int one = 1; +int +main (void) +{ + ix86_split_ashr (one); + return 1; +} + +int +ok (int i) +{ + exit (i); +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp b/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp new file mode 100644 index 000000000..a975c6b52 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp @@ -0,0 +1,50 @@ +# Copyright (C) 2008, 2010 +# 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 +# . + +# This harness is for tests that should be run at all optimisation levels. + +load_lib gcc-dg.exp + +set additional_flags "" +if { [check_effective_target_automatic_stack_alignment] } then { + lappend additional_flags "-mstackrealign" + lappend additional_flags "-mpreferred-stack-boundary=5" +} +if { [istarget i?86*-*-*] || [istarget x86_64-*-*] } then { + lappend additional_flags "-mno-mmx" +} + +dg-init + +gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.c]] $additional_flags +if { [check_effective_target_fpic] } then { + set pic_additional_flags $additional_flags + lappend pic_additional_flags "-fpic" + gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.c]] $pic_additional_flags +} + +if { [check_effective_target_automatic_stack_alignment] } then { + lappend additional_flags "-mforce-drap" + gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.c]] $additional_flags + if { [check_effective_target_fpic] } then { + set pic_additional_flags $additional_flags + lappend pic_additional_flags "-fpic" + gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.c]] $pic_additional_flags + } +} + +dg-finish diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c new file mode 100644 index 000000000..860213298 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +void +foo (void) +{ + struct i + { + aligned i; + } i; + + if (check_int (&i.i, __alignof__(i.i)) != i.i) + abort (); +} + +int +main() +{ + foo (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c new file mode 100644 index 000000000..6f22e07e3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c @@ -0,0 +1,31 @@ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ + +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +__attribute__ ((thiscall)) +void +foo (int j, int k, int m, int n, int o) +{ + aligned i; + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + if (i != 20 || j != 1 || k != 2 || m != 3 || n != 4 || o != 5) + abort (); +} + +int +main() +{ + foo (1, 2, 3, 4, 5); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c b/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c new file mode 100644 index 000000000..5b36f2cd4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c @@ -0,0 +1,60 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +foo (const char *fmt, ...) +{ + va_list arg; + char *p; + aligned i; + int size; + double x; + + va_start (arg, fmt); + size = va_arg (arg, int); + if (size != 5) + abort (); + p = __builtin_alloca (size + 1); + + x = va_arg (arg, double); + if (x != 5.0) + abort (); + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + va_end (arg); +} + +int +main() +{ + foo ("foo", 5, 5.0); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c b/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c new file mode 100644 index 000000000..6740e994e --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c @@ -0,0 +1,66 @@ +/* { dg-do run } */ +/* { dg-skip-if "Stack alignment is too small" { hppa*-*-hpux* } "*" "" } */ + +#include +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 64 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +int global; + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +void +test (va_list arg) +{ + char *p; + aligned i; + int size; + double x; + + size = va_arg (arg, int); + if (size != 5) + abort (); + + p = __builtin_alloca (size + 1); + + x = va_arg (arg, double); + if (x != 5.0) + abort (); + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); +} + +void +foo (const char *fmt, ...) +{ + va_list arg; + va_start (arg, fmt); + test (arg); + va_end (arg); +} +int +main() +{ + foo ("foo", 5, 5.0); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c b/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c new file mode 100644 index 000000000..5b49685fa --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c @@ -0,0 +1,78 @@ +/* PR middle-end/37009 */ +/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ +/* { dg-options "-msse2" } */ +/* { dg-require-effective-target sse2_runtime } */ + +#include +#include +#include "check.h" + +#ifndef ALIGNMENT +#define ALIGNMENT 16 +#endif + +typedef int aligned __attribute__((aligned(ALIGNMENT))); + +void +bar (char *p, int size) +{ + __builtin_strncpy (p, "good", size); +} + +__m128 a = { 1.0 }; + +void +test (va_list arg) +{ + char *p; + aligned i; + int size; + double x; + __m128 e; + + size = va_arg (arg, int); + if (size != 5) + abort (); + + p = __builtin_alloca (size + 1); + + x = va_arg (arg, double); + if (x != 5.0) + abort (); + + bar (p, size); + if (__builtin_strncmp (p, "good", size) != 0) + { +#ifdef DEBUG + p[size] = '\0'; + printf ("Failed: %s != good\n", p); +#endif + abort (); + } + + if (check_int (&i, __alignof__(i)) != i) + abort (); + + e = va_arg (arg, __m128); + if (__builtin_memcmp (&e, &a, sizeof (e))) + abort (); +} + +void +foo (const char *fmt, ...) +{ + va_list arg; + va_start (arg, fmt); + test (arg); + va_end (arg); +} + +int +main (void) +{ + __m128 x = { 1.0 }; + + foo ("foo", 5, 5.0, x); + + return 0; +} -- cgit v1.2.3