Initial checkin of GCC 4.9.0 from trunk (r208799).

Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba

45 files changed, 1792 insertions, 0 deletions

diff --git a/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c
new file mode 100644
index 000000000..e226e7f03
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c
new file mode 100644
index 000000000..2ef17629d
--- /dev/null
+++ b/gcc-4.9/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-*-* } && ia32 } } } */
+/* { dg-additional-options "-mmmx -msse2" } */
+/* { dg-require-effective-target sse2_runtime } */
+
+#include <emmintrin.h>
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c
new file mode 100644
index 000000000..c3dd12479
--- /dev/null
+++ b/gcc-4.9/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-additional-options "-mmmx -msse2" } */
+/* { dg-require-effective-target sse2_runtime } */
+
+#include <emmintrin.h>
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c
new file mode 100644
index 000000000..bc16f5789
--- /dev/null
+++ b/gcc-4.9/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-*-* } && ia32 } } } */
+/* { dg-additional-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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-5.c
new file mode 100644
index 000000000..4c6506d1a
--- /dev/null
+++ b/gcc-4.9/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-*-* } && ia32 } } } */
+/* { dg-additional-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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/alloca-6.c
new file mode 100644
index 000000000..301fff7a2
--- /dev/null
+++ b/gcc-4.9/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-*-* } && ia32 } } } */
+/* { dg-additional-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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c
new file mode 100644
index 000000000..38b384e7c
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c
@@ -0,0 +1,9 @@
+/* PR 11184 */
+/* Origin:  Dara Hazeghi <dhazeghi@yahoo.com> */
+
+void *
+objc_msg_sendv (char * arg_frame, void (*foo)())
+{
+  return __builtin_apply ( foo, arg_frame, 4);
+}
+
diff --git a/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
new file mode 100644
index 000000000..8eba13aed
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
@@ -0,0 +1,48 @@
+/* PR target/12503 */
+/* Origin: <pierre.nguyen-tuong@asim.lip6.fr> */
+
+/* Verify that __builtin_apply behaves correctly on targets
+   with pre-pushed arguments (e.g. SPARC).  */
+
+/* { dg-do run } */
+
+/* arm_hf_eabi: Variadic funcs use Base AAPCS.  Normal funcs use VFP variant.
+   avr: Variadic funcs don't pass arguments in registers, while normal funcs
+        do.  */
+/* { dg-skip-if "Variadic funcs use different argument passing from normal funcs" { arm_hf_eabi || { avr-*-* } } "*" "" } */
+/* { dg-skip-if "Variadic funcs have all args on stack. Normal funcs have args in registers." { nds32*-*-* } "*" "" } */
+   
+
+#define INTEGER_ARG  5
+
+#if defined(__ARM_PCS) || defined(__epiphany__)
+/* For Base AAPCS, NAME is passed in r0.  D is passed in r2 and r3.
+   E, F and G are passed on stack.  So the size of the stack argument
+   data is 20.  */
+#define STACK_ARGUMENTS_SIZE  20
+#elif defined __aarch64__ || defined __arc__ || defined __MMIX__
+/* No parameters on stack for bar.  */
+#define STACK_ARGUMENTS_SIZE 0
+#else
+#define STACK_ARGUMENTS_SIZE  64
+#endif
+
+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(), STACK_ARGUMENTS_SIZE);
+}
+
+int main(void)
+{
+  bar("eeee", 5.444567, 8.90765, 4.567789, INTEGER_ARG);
+
+  return 0;
+}
diff --git a/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c
new file mode 100644
index 000000000..1335d0902
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c
@@ -0,0 +1,31 @@
+/* PR middle-end/12210 */
+/* Origin: Ossadchy Yury A. <waspcoder@mail.ru> */
+
+/* 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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c
new file mode 100644
index 000000000..28dc6106d
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c
new file mode 100644
index 000000000..75c9acdf7
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c
@@ -0,0 +1,34 @@
+/* PR middle-end/11151 */
+/* Originator: Andrew Church <gcczilla@achurch.org> */
+/* { 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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/check.h b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/check.h
new file mode 100644
index 000000000..af1988512
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/check.h
@@ -0,0 +1,36 @@
+#include <stddef.h>
+#ifdef DEBUG
+#include <stdio.h>
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c
new file mode 100644
index 000000000..7558f01e2
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c
new file mode 100644
index 000000000..24dab4d13
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c
@@ -0,0 +1,31 @@
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ia32 } } } */
+
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c
new file mode 100644
index 000000000..332103a76
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c
new file mode 100644
index 000000000..38127fd50
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c
new file mode 100644
index 000000000..85a2ee3f3
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c
new file mode 100644
index 000000000..8402f95f5
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c
new file mode 100644
index 000000000..dabc310d7
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c
new file mode 100644
index 000000000..d35c9a7ce
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c
new file mode 100644
index 000000000..05cb83301
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c
new file mode 100644
index 000000000..95eba0482
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c
new file mode 100644
index 000000000..d853825fe
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c
new file mode 100644
index 000000000..263d4486c
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c
new file mode 100644
index 000000000..5a64d5419
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c
new file mode 100644
index 000000000..3afc8cc6a
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c
new file mode 100644
index 000000000..3673f1ac3
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c
new file mode 100644
index 000000000..d198c9a97
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c
new file mode 100644
index 000000000..b917e824b
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c
new file mode 100644
index 000000000..9a039eb2b
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c
new file mode 100644
index 000000000..1c1ddd1dd
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c
new file mode 100644
index 000000000..c23faf411
--- /dev/null
+++ b/gcc-4.9/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-*-* } && ia32 } } } */
+/* { dg-additional-options "-mmmx -msse2 -mpreferred-stack-boundary=2" } */
+/* { dg-require-effective-target sse2_runtime } */
+
+#include <emmintrin.h>
+
+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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c
new file mode 100644
index 000000000..b9acacf9e
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c
@@ -0,0 +1,60 @@
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ia32 } } } */
+
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c
new file mode 100644
index 000000000..b218a14ed
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c
new file mode 100644
index 000000000..6ab67e395
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c
new file mode 100644
index 000000000..2fd3be8fd
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c
@@ -0,0 +1,46 @@
+/* { dg-do run { target i?86-*-linux* i?86-*-gnu* x86_64-*-linux* } } */
+
+#include <setjmp.h>
+#include <signal.h>
+
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c
new file mode 100644
index 000000000..fee0d281f
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c
@@ -0,0 +1,37 @@
+/* { dg-do run } */
+
+#include <setjmp.h>
+
+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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c
new file mode 100644
index 000000000..d1671223a
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+
+#include <setjmp.h>
+
+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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c
new file mode 100644
index 000000000..8c174758f
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp
new file mode 100644
index 000000000..8ef84fe35
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp
@@ -0,0 +1,69 @@
+# Copyright (C) 2008-2014 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
+# <http://www.gnu.org/licenses/>.
+
+# This harness is for tests that should be run at all optimisation levels.
+
+load_lib gcc-dg.exp
+load_lib torture-options.exp
+
+global DG_TORTURE_OPTIONS LTO_TORTURE_OPTIONS
+
+dg-init
+torture-init
+
+# default_flags are replaced by a dg-options test directive, or appended
+# to by using dg-additional-options.  Use default_flags for options that
+# are used in all of the torture sets to limit the amount of noise in
+# test summaries.
+set default_flags ""
+
+# torture_flags are combined with other torture options and do not
+# affect options specified within a test.
+set torture_flags ""
+
+set stackalign_options [list]
+if { [check_effective_target_automatic_stack_alignment] } then {
+    append default_flags " -mstackrealign"
+    append default_flags " -mpreferred-stack-boundary=5"
+}
+if { [istarget i?86*-*-*] || [istarget x86_64-*-*] } then {
+    append default_flags " -mno-mmx"
+}
+lappend stackalign_options [join $torture_flags]
+
+if { [check_effective_target_fpic] } then {
+    set pic_torture_flags $torture_flags
+    append pic_torture_flags " -fpic"
+    lappend stackalign_options [join $pic_torture_flags]
+}
+
+if { [check_effective_target_automatic_stack_alignment] } then {
+    append torture_flags " -mforce-drap"
+    lappend stackalign_options [join $torture_flags]
+    if { [check_effective_target_fpic] } then {
+	set pic_torture_flags $torture_flags
+	append pic_torture_flags " -fpic"
+	lappend stackalign_options [join $pic_torture_flags]
+    }
+}
+
+# Combine stackalign options with the usual torture optimization flags.
+set-torture-options [concat $DG_TORTURE_OPTIONS $LTO_TORTURE_OPTIONS] $stackalign_options
+
+gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.c]] "$default_flags"
+
+torture-finish
+dg-finish
diff --git a/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c
new file mode 100644
index 000000000..860213298
--- /dev/null
+++ b/gcc-4.9/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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c
new file mode 100644
index 000000000..27b71b60c
--- /dev/null
+++ b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/thiscall-1.c
@@ -0,0 +1,31 @@
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ia32 } } } */
+
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c
new file mode 100644
index 000000000..5b36f2cd4
--- /dev/null
+++ b/gcc-4.9/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 <stdarg.h>
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c
new file mode 100644
index 000000000..6740e994e
--- /dev/null
+++ b/gcc-4.9/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 <stdarg.h>
+#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-4.9/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c b/gcc-4.9/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c
new file mode 100644
index 000000000..baf398c12
--- /dev/null
+++ b/gcc-4.9/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-additional-options "-mmmx -msse2" } */
+/* { dg-require-effective-target sse2_runtime } */
+
+#include <stdarg.h>
+#include <emmintrin.h>
+#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;
+}