commit gcc-4.4.3 which is used to build gcc-4.4.3 Android toolchain in master.

The source is based on fsf gcc-4.4.3 and contains local patches which
are recorded in gcc-4.4.3/README.google.

Change-Id: Id8c6d6927df274ae9749196a1cc24dbd9abc9887

5213 files changed, 204530 insertions, 0 deletions

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000108-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000108-1.c
new file mode 100644
index 000000000..4391be2ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000108-1.c
@@ -0,0 +1,20 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do run } */
+/* { dg-options "-O3" } */
+
+extern void abort (void);
+
+void foo () {} /* unused, but essential to trigger the bug */
+
+int main () {
+  int i;
+  /* use asms to prevent optimizations */
+  /* i = -1; */ asm ("" : "=r" (i) : "0" (-1));
+  /* i =  1; */ asm ("" : "=r" (i) : "0" (i ? 1 : 2));
+  if (i != 1)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000111-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000111-1.c
new file mode 100644
index 000000000..a042656d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000111-1.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do compile } */
+
+__inline int
+foo (int **q) {
+  return *q && **q;
+}
+
+void
+bar () {
+  int **p;
+  if (foo (p))
+    do_something ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000623-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000623-1.c
new file mode 100644
index 000000000..bbc8c10ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000623-1.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-options "-O3 -fno-strict-aliasing" } */
+
+extern void exit (int);
+extern void abort (void);
+
+struct foos { int l; }; 
+int foo;
+static struct foos *getfoo(void);
+int main (void)
+{
+  struct foos *f = getfoo();
+  f->l = 1;
+  foo = 2;
+  if (f->l == 1)
+    abort();
+  exit(0);
+}
+static struct foos *getfoo(void) 
+{ return (struct foos *)&foo; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000629-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000629-1.c
new file mode 100644
index 000000000..b8c7f286d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000629-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+void foo(register char *p)
+{
+  char c, *q, *sp;
+  while (1) {
+    *p++=0;
+    sp=p+1;
+    c=*sp;
+    *p++=0;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000707-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000707-1.c
new file mode 100644
index 000000000..5328dfa63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000707-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+extern void foo(void *here);
+extern inline void bar(void)
+{
+  __label__ here;
+  foo(&&here);
+here:
+  ;
+}
+
+void baz(void)
+{
+  bar();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000906-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000906-1.c
new file mode 100644
index 000000000..90d09d4db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000906-1.c
@@ -0,0 +1,78 @@
+/* { dg-do run } */
+
+/* Testcase distilled from glibc's nss_parse_service_list in nss/nsswitch.c
+   It can't be distilled further.  Fails with `-O2' for i[3456]86.  */
+
+/* this simulates a bounded-pointer type.  */
+struct ucharp { unsigned char *v, *l, *h; };
+
+/* this simulates bounded-pointer check prior to pointer dereference.  */
+#define AREF(var, idx) ((((((((var).v+(idx)) < (var).l) \
+			   || (((var).v+(idx)+1) > (var).h))) \
+			  && (__builtin_trap (), 0)), \
+			 (var).v)[(idx)])
+
+struct list
+{
+  struct list *next;
+};
+
+struct list *
+alloc_list (void)
+{
+  static struct list l;
+  return &l;
+}
+
+int one = 1;
+
+void
+foo (struct ucharp cp, struct ucharp lp, struct list **nextp)
+{
+  while (1)
+    {
+      struct list *list;
+      while (AREF (lp, 0) && AREF (cp, AREF (lp, 0)))
+        ++lp.v;
+      list = alloc_list ();
+      while (AREF (cp, AREF (lp, 0)))
+        ++lp.v;
+      if (AREF (lp, 0) == one)
+	do
+	  ++lp.v;
+	while (AREF (lp, 0) && AREF (cp, AREF (lp, 0)));
+      /* The above AREF (cp, ...) fails because the pseudo created to
+	 hold cp.v holds garbage, having never been set.
+	 The easiest way to see the problem is to compile wiht `-O2 -da'
+	 then look at *.09.loop.  Search for something like this:
+
+	 Hoisted regno 183 r/o from (mem/s:SI (reg:SI 16 argp) 10)
+	   Replaced reg 91, deleting init_insn (213).
+
+	 Now, look for the use of reg 91, which has no set.  */
+
+      *nextp = list;
+      nextp = &list->next;
+      if (!*lp.v)
+	break;
+    }
+}
+
+extern void exit (int);
+
+int
+main (void)
+{
+  static unsigned char cp0[] = "\0\0\0\0";
+  struct ucharp cp = { cp0, cp0, cp0 + sizeof (cp0) };
+
+  static unsigned char lp0[] = "\1\1\0\0";
+  struct ucharp lp = { lp0, lp0, lp0 + sizeof (lp0) };
+
+  struct list list;
+  struct list *nextp = &list;
+
+  foo (cp, lp, &nextp);
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20000926-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000926-1.c
new file mode 100644
index 000000000..2f5ca10a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20000926-1.c
@@ -0,0 +1,27 @@
+/* Copyright (C) 2000  Free Software Foundation.
+   by William Cohen  <wcohen@redhat.com>  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+#include <limits.h>
+
+struct PDATA
+{
+    unsigned int  Dummy:(sizeof(int)*CHAR_BIT);
+    const char*   PName;
+};
+
+typedef struct PDATA    P_DATA;
+
+struct PLAYBOOK {
+        const char * BookName;
+        P_DATA       Play[0];
+};
+
+struct PLAYBOOK playbook  =
+{
+  "BookName",
+  {
+    { 1, "PName0" }, /* { dg-warning "(excess elements)|(near initialization)" "" } */
+  }
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001009-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001009-1.c
new file mode 100644
index 000000000..1a5567779
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001009-1.c
@@ -0,0 +1,47 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+extern void foo (void *a, double x, double y);
+void
+bar (void *a, double b, double c, double d, double e, double f, double g, double h, double i, double j, double k[6])
+{
+  double l, m, n, o, p;
+  double q, r, s, t, u;
+  double x, y, v, w;
+  double z = 0.5 * j;
+  double aa;
+  l = b - 3 * d;
+  m = 4 * f;
+  n = f - h;
+  q = c + 3 * g - i;
+  r = 2 * (e - 2 * g + i);
+  s = g - i;
+  if (l != 0.0)
+    {
+      aa = 0.0;
+      o = (- m + aa);
+      p = (- m - aa);
+      if (o > 0.0)
+        {
+          x = ((b-h)*o + 3*(d+h)*o + 3*(f-h)*o);
+          y = ((c-i)*o + 3*(e+i)*o + 3*(g-i)*o);
+          foo (a, z, w);
+          foo (a, -z, w);
+        }
+      if (p > 0.0)
+        {
+          x = ((b+3*f-h)*p + 3*(d-2*f+h)*p + 3*p);
+          y = ((c+3*g-i)*p + 3*(e-2*g+i)*p + 3*p);
+          v = x * k[0] + y * k[2];
+          w = x * k[1] + y * k[3];
+          foo (a, z, w);
+          foo (a, - z, w);
+        }
+    }
+  if (q != 0.0)
+    {
+      aa = 0.0;
+      t = (- r + aa) / (2 * q);
+      u = (- r - aa) / (2 * q);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001012-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001012-1.c
new file mode 100644
index 000000000..eda69c029
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001012-1.c
@@ -0,0 +1,18 @@
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+extern void abort (void);
+extern void exit (int);
+
+double
+foo (void)
+{
+  return (__extension__ ((union { unsigned __l __attribute__((__mode__(__SI__))); float __d; }) { __l: 0x3f800000UL }).__d);
+}
+
+main ()
+{
+  if (foo() != 1.0)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001012-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001012-2.c
new file mode 100644
index 000000000..32dc27c59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001012-2.c
@@ -0,0 +1,36 @@
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+extern void abort (void);
+extern void exit (int);
+
+void foo (char *x, const char *y, ...)
+{
+}
+
+double bar (const char *x, long y)
+{
+  return 0.0;
+}
+
+typedef __SIZE_TYPE__ size_t;
+extern size_t strlen (const char *);
+
+double baz (const char *x)
+{
+  if (x[0] != '\0')
+    {
+      char y[6 + strlen (x)];
+      foo (y, "FOO", x);
+      return bar (y, 0);
+    }
+
+  return (__extension__ ((union { unsigned __l __attribute__((__mode__(__SI__))); float __d; }) { __l: 0x3f800000UL }).__d);
+}
+
+main ()
+{
+  if (baz("") != 1.0)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001023-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001023-1.c
new file mode 100644
index 000000000..10cb27259
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001023-1.c
@@ -0,0 +1,62 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fomit-frame-pointer" } */
+
+extern void abort (void);
+extern void exit (int);
+
+unsigned char a[256], b[256], c[256], d[256];
+
+void foo(unsigned char *x, int y, unsigned char *z)
+{
+}
+
+void bar(int x, ...)
+{
+}
+
+void baz(int y)
+{
+  if (y != 0x10)
+    abort();
+}
+
+void test(int x, unsigned char *y)
+{
+  unsigned char g,h,j, k[5],l[5], m[30];
+  int i;
+
+  bar(x, y[0], y[1], y[2], y[3], y[4], y[5], y[6], y[7], y[8], y[9]);
+  for (i = 5; --i >= 0; )
+    k[i] = y[5 + i] ^ a[i] ^ c[i];
+
+  foo(&m[29], sizeof m, k);
+  g = d[x] ^ c[x];
+  bar(x, d[x], x, c[x]);
+  baz(g);
+  for (i = 5, h = 0; --i >= 0; h = y[i])
+    {
+      j = m[25 + i] ^ y[i];
+      j = b[j] ^ g;
+      k[i] = c[j] ^ h;
+    }
+  for (i = 5, h = 0; --i >= 0; h = k[i])
+    {
+      j = m[20 + i] ^ k[i];
+      j = b[j] ^ g;
+      l[i] = c[j] ^ h;
+    }
+  for (i = 5, h = 0; --i >= 0; h = l[i]) {
+    j = m[15 + i] ^ l[i];
+    j = b[j] ^ g;
+    j = c[j] ^ h;
+    k[i] = a[j] ^ c[j];
+  }
+}
+
+int main()
+{
+  c[4] = 0xdc;
+  d[4] = 0xcc;
+  test(4, a);
+  exit(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001108-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001108-1.c
new file mode 100644
index 000000000..682257fdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001108-1.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fomit-frame-pointer" } */
+
+extern void abort (void);
+extern void exit (int);
+
+void die (long) __attribute__ ((noreturn));
+
+void die (long e)
+{
+  abort ();
+  for (;;);
+}
+
+long foo (double i)
+{
+  if (i != 2.0)
+    abort ();
+  return 26;
+}
+
+long bar (long i, double x)
+{
+  if (x < 0) die (1);
+  return foo (x);
+}
+
+main()
+{
+  if (bar (0, 2.0) != 26)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001116-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001116-1.c
new file mode 100644
index 000000000..8b1e919c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001116-1.c
@@ -0,0 +1,11 @@
+/* This looks like a warning test, but it's actually a regression test for a
+   nasty ICE due to messed up parser context.  Problem originally found
+   during bootstrap; this is synthetic.  -zw  */
+/* { dg-do compile } 
+   { dg-options -Wempty-body } */
+
+void foo (int x)
+{
+  if (x)
+    ;	/* { dg-warning "empty body in an" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001117-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001117-1.c
new file mode 100644
index 000000000..baf069193
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001117-1.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -finstrument-functions" } */
+
+extern void abort (void);
+extern void exit (int);
+
+double
+foo (double a, double b)
+{
+  double c;
+  if (0.0 < a)
+    c = a;
+  else if (b > 0.0)
+    c = 0.0;
+  else
+    return 0;
+  return 2.0 * (b - c);
+}
+
+int main ()
+{
+  if (foo (1.0, 4.0) != 6.0)
+    abort ();
+  exit (0);
+}
+
+void __attribute__((no_instrument_function)) __cyg_profile_func_enter(void *this_fn, void *call_site) { }
+void __attribute__((no_instrument_function)) __cyg_profile_func_exit(void *this_fn, void *call_site) { } 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001201-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001201-1.c
new file mode 100644
index 000000000..195801a41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001201-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+char *s =
+"0123456789101214161820222426283032343638404244464850525456586062646668707274767880828486889092949698100103106109112115118121124127130133136139142145148151154157160163166169172175178181184187190193196199202205208211214217220223226229232235238241244247250253256259262265268271274277280283286289292295298301304307310313316319322325328331334337340343346349352355358361364367370373376379382385388391394397400403406409412415418421424427430433436439442445448451454457460463466469472475478481484487490493496499502"
+"505x";  /* { dg-bogus "greater than the minimum length" } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20001228-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001228-1.c
new file mode 100644
index 000000000..49aec9617
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20001228-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math -O2" } */
+
+typedef struct
+{
+  float vs_data[75], vs_peak[75], vs_peak_speed[75];
+  int vs_refresh_delay;
+  int vs_doublesize;
+} Vis;
+ 
+void vis_timeout_func(Vis * vis)
+{
+  if (vis->vs_peak[0] < 0.0)
+    vis->vs_peak[0] = 0.0;
+} 
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20010202-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010202-1.c
new file mode 100644
index 000000000..5f789042e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010202-1.c
@@ -0,0 +1,27 @@
+/* { dg-do compile { target i?86-*-* sparc*-*-* x86_64-*-* } } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+
+typedef enum { false, true } __attribute__ ((packed)) boolean;
+typedef struct {
+  enum {
+    A0 = 0, A1 = 1, A2 = 2
+  } __attribute__((packed)) A:3;
+  enum {
+    B0 = 0, B1 = 1, B2 = 2
+  } __attribute__((packed)) B:3;
+  boolean C:1;
+  boolean D:1;
+  unsigned char :8;
+} foo;
+foo x = { A2, B1, false, true };
+
+int main(void)
+{
+  if (sizeof (foo) != 2 || __alignof__ (foo) != 1)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20010405-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010405-1.c
new file mode 100644
index 000000000..b4d57a5d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010405-1.c
@@ -0,0 +1,19 @@
+__inline__ double bar(double *x)
+{
+  static double a;
+  a = *x >= 0 ? *x : -*x;
+  return a;
+}
+
+int main(void)
+{
+  extern double bar();
+  double a;
+  static double b;
+  int r;
+  for (r = 1; r < 3; r++) {
+    a = 1.0;
+    b = bar(&a);
+  }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20010516-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010516-1.c
new file mode 100644
index 000000000..6ddabd093
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010516-1.c
@@ -0,0 +1,7 @@
+/* { dg-options "-fshow-column" } */
+
+foo()
+{
+      char d;
+      __asm volatile ( "" :: "m"(&d)); /* { dg-error "34:" "non-lvalue" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20010622-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010622-1.c
new file mode 100644
index 000000000..dc4b28ccb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010622-1.c
@@ -0,0 +1,11 @@
+/* Test for segfault doing -Wsequence-point processing on an empty
+   statement expression.  */
+/* Origin: PR c/3259 from <David.Decotigny@irisa.fr>.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+void
+f (void)
+{
+  ({ });
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20010822-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010822-1.c
new file mode 100644
index 000000000..b1c1cd45a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010822-1.c
@@ -0,0 +1,44 @@
+/* { dg-do run } */
+/* { dg-options "-Os" } */
+
+extern void abort (void);
+
+void foo (unsigned long x)
+{
+}
+
+typedef struct a {
+  volatile unsigned int a1, a2, a3, a4, a5;
+} *A;
+typedef struct {
+  volatile unsigned int b1, b2, b3, b4, b5;
+} *B;
+struct C {
+  void *c1, *c2;
+  A c3;
+  unsigned char c4;
+};
+
+void
+bar (struct C *c, unsigned int *d)
+{
+  *d = *d | 1;
+  ((c->c4 >= 2)
+   ? (*(volatile unsigned int *) ((void *)(&((A)c->c3)->a5)) = *d)
+   : (*(volatile unsigned int *) ((void *)(&((B)c->c3)->b5)) = *d));
+
+  foo (50);
+}
+
+int main (void)
+{
+  struct a a;
+  struct C c;
+  unsigned int d = 8;
+  c.c3 = &a;
+  c.c4 = 0;
+  bar (&c, &d);
+  if (a.a5 != 9)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20010912-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010912-1.c
new file mode 100644
index 000000000..bf81e3bac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20010912-1.c
@@ -0,0 +1,48 @@
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int bar (int x, char **y)
+{
+  if (x != 56)
+    abort ();
+  if (**y != 'a')
+    abort ();
+  *y = "def";
+  return 1;
+}
+
+int baz (int x, char **y)
+{
+  if (x != 56)
+    abort ();
+  if (**y != 'a')
+    abort ();
+  return 26;
+}
+
+int foo (int x, char *y)
+{
+  int a;
+  char *b = y;
+  a = bar (x, &y);
+  if (a)
+    {
+      y = b;
+      a = baz (x, &y);
+    }
+  if (a)
+    return a;
+
+  baz (x, &y);
+  return 0;
+}
+
+int main ()
+{
+  if (foo (56, "abc") != 26)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20011008-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011008-1.c
new file mode 100644
index 000000000..e3991471a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011008-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O0 -fshow-column" } */
+
+struct { int; int q; } a; /* { dg-warning "13:does not declare anything" } */
+struct { union {int x;}; int q; } b;
+struct { struct {int x;}; int q; } c;
+union { union {int x;}; int q; } d;
+union { struct {int x;}; int q; } e;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20011008-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011008-2.c
new file mode 100644
index 000000000..01ff172b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011008-2.c
@@ -0,0 +1,23 @@
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct { union {int x; int y;}; int q; } b;
+union { struct {int x;}; int q; } e;
+
+main()
+{
+  b.y = 10;
+  b.x = 15;
+  if (b.y != 15)
+    abort();
+
+  e.x = 10;
+  e.q = 15;
+  if (e.x != 15)
+    abort();
+
+  exit(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20011015-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011015-1.c
new file mode 100644
index 000000000..0b751bf40
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011015-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -std=gnu99" } */
+
+char foo (char *x)
+{
+  return *x;
+}
+
+void bar (char *x)
+{
+  void *arr[foo (x)] __attribute__((unused));
+}
+
+void baz (char *x)
+{
+  bar (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20011021-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011021-1.c
new file mode 100644
index 000000000..dc998c8af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011021-1.c
@@ -0,0 +1,45 @@
+/* Test for various initializer warnings being suppressed by use of
+   designated initializers.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -W -Wall -Wtraditional" } */
+
+
+struct t
+{
+  int a;
+  int b;
+  int c;
+};
+
+union u
+{
+  int n;
+  float i;
+};
+
+struct multilevel
+{
+   int x;
+   struct t t;
+   union u u;
+   union u v;
+   char *f;
+};
+
+struct t T0 = { 1 };		/* { dg-warning "missing init" } */
+/* { dg-warning "near init" "near init" { target *-*-* } 30 } */
+struct t T1 = { .a = 1 };	/* { dg-bogus "(missing|near) init" } */
+
+union u U0 = { 1 };		/* { dg-warning "initialization of union" } */
+union u U1 = { .i = 1 };	/* { dg-bogus "initialization of union" } */
+
+struct multilevel M =
+{
+  12,
+  { .b = 3 },			/* { dg-bogus "missing init" } */
+  { 4 },			/* { dg-warning "initialization of union" } */
+  { .n = 9 },			/* { dg-bogus "initialization of union" } */
+  /* "string here" */
+};				/* { dg-warning "missing init" } */
+/* { dg-warning "near init" "near init" { target *-*-* } 44 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20011130-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011130-1.c
new file mode 100644
index 000000000..60a2738fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011130-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -g -finline-limit=100" } */
+
+#define WORK(x, y) __asm__ ("" : "=r" (x) : "0" (x)); y += x + 26
+#define SOME_WORK(x, y) WORK(x, y); WORK(x, y); WORK(x, y); WORK(x, y)
+#define MORE_WORK(x, y) SOME_WORK(x, y); SOME_WORK(x, y); SOME_WORK(x, y)
+#define EVEN_MORE_WORK(x, y) MORE_WORK(x, y); MORE_WORK(x, y); MORE_WORK(x, y)
+#define LOTS_OF_WORK(x, y) EVEN_MORE_WORK(x, y); EVEN_MORE_WORK(x, y)
+
+static int __attribute__((unused)) foo (int x)
+{
+  inline int bar (int x)
+    {
+      int y;
+      y = x;
+      LOTS_OF_WORK(x, y);
+      LOTS_OF_WORK(x, y);
+      LOTS_OF_WORK(x, y);
+      LOTS_OF_WORK(x, y);
+      LOTS_OF_WORK(x, y);
+      LOTS_OF_WORK(x, y);
+      return y;
+    }
+  return bar(x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20011214-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011214-1.c
new file mode 100644
index 000000000..dd05798fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20011214-1.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+
+extern void abort (void);
+extern void exit (int);
+
+#define small   __attribute__((mode(QI))) int
+int main()
+{
+  int x, y = 0x400;
+
+  x = (small) y;                                /* { dg-bogus "ignored" } */
+  if (sizeof (small) != sizeof (char))          /* { dg-bogus "ignored" } */
+    abort ();
+  if (sizeof (x) != sizeof (char) && x == y)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020103-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020103-1.c
new file mode 100644
index 000000000..81ffdb1b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020103-1.c
@@ -0,0 +1,39 @@
+/* Verify that constant equivalences get reloaded properly, either by being
+   spilled to the stack, or regenerated, but not dropped to memory.  */
+/* { dg-do compile { target { { i?86-*-* rs6000-*-* alpha*-*-* x86_64-*-* } || { powerpc*-*-* && ilp32 } } } } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O2 -fpic -fno-omit-frame-pointer -fno-asynchronous-unwind-tables" } */
+/* { dg-final { scan-assembler-not "LC\[0-9\]" } } */
+
+/* Clobber all call-saved registers that can hold a pointer value.  */
+#if defined(__i386__)
+#define clobber \
+  asm volatile("#asm" : : : "si", "di")
+#elif defined(__powerpc__) || defined(__PPC__) || defined(__ppc__) || defined(__POWERPC__) || defined(PPC) || defined (_IBMR2)
+#define clobber \
+  asm volatile("#asm" : : : "14", "15", "16", "17", "18", "19", "20", \
+	       "21", "22", "23", "24", "25", "26", "27", "28", "29")
+#elif defined(__alpha__)
+#define clobber \
+  asm volatile("#asm" : : : "$9", "$10", "$11", "$12", "$13", "$14", \
+	       "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", "$f8", "$f9")
+#elif defined(__x86_64__)
+#define clobber \
+  asm volatile("#asm" : : : "rcx", "rdx", "rsi", "rdi", "r8", "r9", "r10", "r11")
+#else
+#error no clobber macro defined
+#endif
+
+extern void f1(int, int, int);
+extern void f2(int*, int*, int*);
+
+extern int ext;
+static int loc_small;
+static int loc_big[100];
+
+void bar(void)
+{
+  f1(ext, loc_small, loc_big[0]);
+  clobber;
+  f2(&ext, &loc_small, &loc_big[0]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020104-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020104-1.c
new file mode 100644
index 000000000..be36a7427
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020104-1.c
@@ -0,0 +1,22 @@
+/* Test whether statement with no effect warnings are not given for last
+   statements inside of statement expression.  */
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+void bar (char *p, char *q);
+
+int main()
+{
+  char foo [32], *p;
+
+  ({
+    void *s = (foo);
+    __builtin_memset (s, '\0', sizeof (foo));
+    s; /* { dg-warning "no effect" "statement with no effect warning" } */
+    s; /* { dg-bogus "no effect" "bogus statement with no effect warning" } */
+  });
+  p = foo;
+  p;   /* { dg-warning "no effect" "statement with no effect warning" } */
+  bar (foo, p);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020108-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020108-1.c
new file mode 100644
index 000000000..d61944c59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020108-1.c
@@ -0,0 +1,17 @@
+/* This testcase failed on i686 because (const_int -1) was changed into
+   (const_int 0xffff) when storing it into SImode pseudo, but was not
+   converted back to (const_int -1) when returning from store_expr,
+   eventhough target was (subreg:HI (reg/v:SI indx)).  But (const_int 0xffff)
+   is not valid general_operand in HImode.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+
+void
+foo (unsigned short *cp)
+{
+  unsigned short indx;
+
+  *cp = indx = 0xFFFF;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020115-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020115-1.c
new file mode 100644
index 000000000..9d4ea5491
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020115-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+
+/* Test attributes in function arguments.  */
+/* Origin: Aldy Hernandez <aldyh@redhat.com>.  */
+
+#define blah __attribute__((__mode__(QI)))
+
+extern void bar(int *);
+
+void foo (blah int abc)
+{
+
+	int b[sizeof(abc) == 1 ? 1 : -1];
+	bar (b);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020116-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020116-1.c
new file mode 100644
index 000000000..d554675bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020116-1.c
@@ -0,0 +1,16 @@
+/* This testcase ICEd on Alpha because ldq_u argument was not subject to
+   small_symbolic_mem_operand splitting.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -fpic -mexplicit-relocs -mcpu=ev4" { target alpha*-*-* } } */
+
+static char a;
+char *b;
+
+void foo (void)
+{
+  register char *c;
+
+  c = b;
+  *c = a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-1.c
new file mode 100644
index 000000000..b13752f64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-1.c
@@ -0,0 +1,21 @@
+/* Copyright (C) 2002  Free Software Foundation.
+   by Hans-Peter Nilsson  <hp@axis.com> */
+
+/* { dg-do compile } */
+
+typedef struct
+ {
+   unsigned short s;
+ } t;
+
+struct u
+ {
+   t v;
+ };
+
+int
+foo (struct u *uu)
+{
+  int i = ((unsigned int) ((uu->v) & 42)); /* { dg-error "invalid operands to binary" } */
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-2.c
new file mode 100644
index 000000000..275dceed7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-2.c
@@ -0,0 +1,41 @@
+/* This test was supplied with PR target/5379.  It caused the compiler
+   to get a segmentation fault.  */
+  
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -w" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern int access( char* );
+extern int a();
+char* foocp();
+
+void
+_KDE_IceGetPoValidAuthIndices (protocol_name, num_indices_ret, indices_ret)
+const char *protocol_name;
+int *num_indices_ret;
+int *indices_ret;
+{
+    int auth_file;
+    char *filename;
+    int index_ret, i;
+
+    if (!(filename = foocp ()))
+        return;
+
+    if (access (filename))
+        return;
+
+    if (auth_file = access (filename))
+        return;
+
+    for (;;)
+    {
+        if (strcmp (protocol_name, protocol_name) == 0 )
+        {
+            for (i = 0; i < *num_indices_ret; i++)
+                if (index_ret == indices_ret[i])
+                    break;
+        }
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-3.c
new file mode 100644
index 000000000..28f68719e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-3.c
@@ -0,0 +1,15 @@
+/* Check that the combination of -Os and -fprefetch-loop-arrays does not
+   cause the compiler to crash, which it originally did on i?86.
+   Warnings are turned off because not all targets support prefetch.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Os -fprefetch-loop-arrays -w" } */
+/* { dg-options "-Os -fprefetch-loop-arrays -mtune=pentium3 -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+int foo (int *p, int n)
+{
+  int i, r;
+  for (i = 0; i < n; i++)
+    r += p[i];
+  return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-4.c
new file mode 100644
index 000000000..50aef1950
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020122-4.c
@@ -0,0 +1,11 @@
+/* Alpha -msmall-data didn't transform (mem (symbol_ref)) to
+   (mem (lo_sum pic (symbol_ref))) within an asm at the right time.  */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+void foo()
+{
+  static int test;
+  int dummy;
+  asm volatile ("" : "=m"(test), "=r"(dummy) : "m"(test));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020201-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020201-1.c
new file mode 100644
index 000000000..6002c5981
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020201-1.c
@@ -0,0 +1,42 @@
+/* Check that arc profiling instrumentation code does not cause problems for
+   a program that calls functions that are likely to be in a shared library.
+   This was added to check the fix for PR target/5469, which prevents arc
+   profiling code from being inserted between a call and the restore of the
+   call-clobbered global pointer.  */
+
+/* { dg-options "-fprofile-arcs" } */
+/* { dg-do run { target native } } */
+
+extern void abort (void);
+extern void exit (int);
+
+int rand (void);
+void srand (unsigned int seed);
+
+int globvar;
+
+void
+leave (int i)
+{
+  if (i != 0)
+    abort ();
+  exit (0);
+}
+
+void
+doit ()
+{
+  srand (12);
+  globvar = rand ();
+  if (rand () > 0)
+    globvar = 0;
+  leave (globvar);
+}
+
+int
+main ()
+{
+  doit ();
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020206-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020206-1.c
new file mode 100644
index 000000000..837718b6c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020206-1.c
@@ -0,0 +1,45 @@
+/* This code is from the beginning of combine_reloads in reload.c in
+   GCC 3.1-20020117, with simplifications.  It compiled incorrectly
+   for -O2 -fprefetch-loop-arrays for ix86 targets.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -w" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -mtune=pentium3 -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+
+struct reload
+{
+  int first_member;
+  int out;
+  int final_member;
+};
+
+int n_reloads;
+struct reload rld[10];
+
+static int
+combine_reloads ()
+{
+  int i;
+  int output_reload = -1;
+  int secondary_out = -1;
+
+  for (i = 0; i < n_reloads; i++)
+    if (rld[i].out != 0)
+      {
+	if (output_reload >= 0)
+	  return output_reload;
+	output_reload = i;
+      }
+  return output_reload;
+}
+
+int
+main ()
+{
+  n_reloads = 4;
+  rld[2].out = 2;
+  if (combine_reloads () != 2)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020210-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020210-1.c
new file mode 100644
index 000000000..369963b25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020210-1.c
@@ -0,0 +1,28 @@
+/* This used to fail on H8/300 due to incorrect specification of pushi1.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -fomit-frame-pointer" { target h8300-*-* } } */
+
+extern void abort (void);
+extern void exit (int);
+
+void
+bar (int a, int b, int c, int d, int e)
+{
+  if (d != 1)
+    abort ();
+}
+
+void
+foo (int a, int b, int c, int d, int e)
+{
+  bar (a, b, c, d, e);
+}
+
+int
+main ()
+{
+  foo (0, 0, 0, 1, 2);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020219-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020219-1.c
new file mode 100644
index 000000000..36649490e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020219-1.c
@@ -0,0 +1,47 @@
+/* PR c/4389
+   This testcase failed because host_integerp (x, 0) was returning
+   1 even for constants bigger than 2^31.  It fails under under hppa
+   hpux without -mdisable-indexing because the pointer x - 1 is used
+   as the base address of an indexed load.  Because the struct A is not
+   actually allocated, x - 1 lies in the text segment and this causes
+   the wrong space register to be selected for the load.  It fails on
+   IA64 hpux in ILP32 mode because extending x - 1 before adding the
+   array offset gives a different answer then adding first and then
+   extending.  The underlying problem is the same as with hppa, x - 1 is
+   not a legal data address.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mdisable-indexing" { target hppa*-*-hpux* } } */
+/* { dg-skip-if "" { "ia64-*-hpux*" } "*" "-mlp64" } */
+
+/* Disable the test entirely for 16-bit targets.  */
+#if __INT_MAX__ > 32767
+
+extern void abort (void);
+extern void exit (int);
+struct A {
+  int a[10000][10000];
+};
+int b[2] = { 213151, 0 };
+
+void foo (struct A *x, int y)
+{
+  if (x->a[9999][9999] != x->a[y][y])
+    abort ();
+  if (x->a[9999][9999] != 213151)
+    abort ();
+}
+
+int main (void)
+{
+  struct A *x;
+  asm ("" : "=r" (x) : "0" (&b[1]));
+  foo (x - 1, 9999);
+  exit (0);
+}
+
+#else
+
+int main () { return 0; }
+
+#endif /* __INT_MAX__ */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020220-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020220-1.c
new file mode 100644
index 000000000..aa948aa15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020220-1.c
@@ -0,0 +1,19 @@
+/* PR c++/4574
+   This testcase ICEd because expand_and did not handle VOIDmode
+   CONST_DOUBLE arguments.  */
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+struct A {
+  unsigned long long b : 8;
+  unsigned long long c : 18;
+};
+
+int main()
+{
+  struct A a;
+  long long l;
+
+  l = a.c = 0x123456789aULL;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020220-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020220-2.c
new file mode 100644
index 000000000..c6c57a921
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020220-2.c
@@ -0,0 +1,12 @@
+/* PR c/4697
+   Test whether value computed not used warning is given for compound
+   expression.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wunused" } */
+
+int b;
+int foo (int a)
+{
+  a = a + 1, 5 * b;	/* { dg-warning "value computed is not used" } */
+  return a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020222-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020222-1.c
new file mode 100644
index 000000000..d2cf5fe6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020222-1.c
@@ -0,0 +1,34 @@
+/* PR optimization/5747
+   This testcase ICEd on sparc because move_movables created new pseudos,
+   but did not update reg info which load_mems needed.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -fPIC" { target fpic } } */
+
+extern void foo (void);
+static char a[256];
+
+void
+bar (void)
+{
+  unsigned int i;
+  static int b = 0;
+  int c;
+
+  if (b == 0)
+    {
+      b = 1;
+      foo ();
+      c = 0;
+      for (i = 0; i < 10; i++)
+	a[i + '0'] = c++;
+      for (i = 'A'; i <= 'Z'; i++)
+	a[i] = c++;
+      a['$'] = c++;
+      a['%'] = c++;
+      a['.'] = c++;
+      a['_'] = c++;
+      for (i = 'a'; i <= 'z'; i++)
+	a[i] = c++;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020310-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020310-1.c
new file mode 100644
index 000000000..bdd29672b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020310-1.c
@@ -0,0 +1,54 @@
+/* PR optimization/5844
+   This testcase was miscompiled because of an rtx sharing bug.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=i586" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+struct A
+{
+  struct A *a;
+  int b;
+};
+
+struct B
+{
+  struct A *c;
+  unsigned int d;
+};
+
+struct A p = { &p, -1 };
+struct B q = { &p, 0 };
+
+extern void abort (void);
+extern void exit (int);
+
+struct B *
+foo (void)
+{
+  return &q;
+}
+
+void
+bar (void)
+{
+  struct B *e = foo ();
+  struct A *f = e->c;
+  int g = f->b;
+
+  if (++g == 0)
+    {
+      e->d++;
+      e->c = f->a;
+    }
+
+  f->b = g;
+}
+
+int
+main ()
+{
+  bar ();
+  if (p.b != 0 || q.d != 1 || q.c != &p)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020312-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020312-1.c
new file mode 100644
index 000000000..978401862
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020312-1.c
@@ -0,0 +1,10 @@
+/* This testcase ICEd on alpha because of an unrecognized insn formed
+   by conditional move optimization using an incorrect mode.  */
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math" } */
+
+char*
+barf (double x)
+{
+    return (x<0.0) ? "foo" : "bar";
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020312-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020312-2.c
new file mode 100644
index 000000000..c4a27744a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020312-2.c
@@ -0,0 +1,138 @@
+/* PR 5878. 
+
+   We ICEd in verify_local_live_at_start because we incorrectly forced
+   the PIC register live between BAR and BAZ.  We did this because the
+   definition of PIC_OFFSET_TABLE_REGNUM was incorrectly not INVALID_REGNUM
+   when !flag_pic for most targets.  */
+
+/* { dg-do run } */
+/* { dg-options "-O -fno-pic" } */
+
+extern void abort (void);
+
+#if defined(__alpha__)
+/* PIC register is $29, but is used even without -fpic.  */
+#elif defined(__arc__)
+# define PIC_REG  "26"
+#elif defined(__arm__)
+# define PIC_REG  "9"
+#elif defined(AVR)
+/* No pic register.  */
+#elif defined(__cris__)
+# define PIC_REG  "0"
+#elif defined(__fr30__)
+/* No pic register.  */
+#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__)
+/* No pic register.  */
+#elif defined(_IBMR2)
+/* No pic register.  */
+#elif defined(__i386__)
+# define PIC_REG  "ebx"
+#elif defined(__ia64__)
+/* PIC register is r1, but is used even without -fpic.  */
+#elif defined(__M32R__)
+/* No pic register.  */
+#elif defined(__m68k__)
+# define PIC_REG  "a5"
+#elif defined(__mc68hc1x__)
+/* No pic register.  */
+#elif defined(__mcore__)
+/* No pic register.  */
+#elif defined(__mips__)
+/* PIC register is $28, but is used even without -fpic.  */
+#elif defined(__MMIX__)
+/* No pic register.  */
+#elif defined(__mn10300__)
+/* No pic register.  */
+#elif defined(__hppa__)
+/* PIC register is %r27 or %r19, but is used even without -fpic.  */
+#elif defined(__pdp11__)
+/* No pic register.  */
+#elif defined(__powerpc__) || defined(__PPC__) || defined(__POWERPC__)
+# ifdef __MACH__
+#  define PIC_REG  "31"
+# else
+#  define PIC_REG  "30"
+# endif
+#elif defined(__s390__)
+# define PIC_REG  "12"
+#elif defined(__sparc__)
+# define PIC_REG  "l7"
+#elif defined(__v850)
+/* No pic register.  */
+#elif defined(__vax__)
+/* No pic register.  */
+#elif defined(__xstormy16__)
+/* No pic register.  */
+#elif defined(__XTENSA__)
+/* No pic register.  */
+#elif defined(__sh__)
+# define PIC_REG  "r12"
+#elif defined(__x86_64__)
+/* No pic register.  */
+#elif defined(__m32c__)
+/* No pic register.  */
+#elif defined(__SPU__)
+#  define PIC_REG  "126"
+#elif defined (__frv__)
+# ifdef __FRV_FDPIC__
+#  define PIC_REG "gr15"
+# else
+#  define PIC_REG "gr17"
+#endif
+#else
+# error "Modify the test for your target."
+#endif
+
+#if defined PIC_REG && !defined __PIC__ && !defined __pic__
+register void *reg __asm__(PIC_REG);
+#else
+/* We really need a global register variable set to the PIC register
+   to expose the bug.  Oh well, let the test case not fail.  */
+static void *reg;
+#endif
+
+void * __attribute__((noinline))
+dummy (void *x)
+{
+  return x;
+}
+
+void
+f (void)
+{
+  goto *dummy (&&bar);
+  for (;;)
+    {
+    foo:
+      reg = (void *) 1;
+      if (!reg)
+        goto baz;
+      reg = &&foo;
+    }
+
+ bar:
+ baz:
+  reg = 0;
+}
+
+int
+main()
+{
+  void *old_reg = reg;
+  reg = (void *) 1;
+
+  f ();
+
+  /* Additionally test that the prologue/epilogue properly does *not*
+     save and restore global registers.  Not possible when the PIC
+     register is in a register window, of course.  On Darwin, you can't
+     call library routines from non-PIC code.  */
+#if !defined (__sparc__) && !defined(__MACH__)
+  if (reg)
+    abort ();
+#endif
+
+  reg = old_reg;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020319-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020319-1.c
new file mode 100644
index 000000000..46a756d77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020319-1.c
@@ -0,0 +1,10 @@
+/* PR optimization/5999
+   This testcase ICEd because one a/b -> a * (1/b) optimization
+   did not handle complex divides.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+__complex__ double foo (__complex__ double x, __complex__ double y)
+{
+  return x / y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020411-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020411-1.c
new file mode 100644
index 000000000..47a8fed50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020411-1.c
@@ -0,0 +1,54 @@
+/* PR c/6223
+   This testcase ICEd in internal check because a constant was not truncated
+   for its mode.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -march=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#if __INT_MAX__ > 32767
+
+typedef struct
+{
+  unsigned a : 16;
+  unsigned b : 16;
+  unsigned c : 5;
+  unsigned d : 2;
+  unsigned e : 1;
+  unsigned f : 4;
+  unsigned g : 1;
+  unsigned h : 1;
+  unsigned i : 1;
+  unsigned j : 1;
+} T;
+
+inline void
+foo (T *x, unsigned int y)
+{
+  if ((x->j = (y >= 0x100000)))
+    y >>= 12;
+  x->a = y;
+  x->f = (y >> 16);
+}
+
+void __attribute__((noinline))
+bar (T *x)
+{
+}
+
+void
+baz (unsigned int x, unsigned char y)
+{
+  T t;
+
+  foo (&t, x - 1);
+  t.e = 1;
+  t.c = y;
+  t.g = 0;
+  t.h = 0;
+  t.i = (y & 0x40) != 0;
+  if (x == 1)
+    foo (&t, 1);
+  bar (&t);
+}
+
+#endif /* __INT_MAX__ */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020415-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020415-1.c
new file mode 100644
index 000000000..7d5b5aebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020415-1.c
@@ -0,0 +1,35 @@
+/* PR target/6303
+   This testcase ICEd because s390 did not define
+   ASM_SIMPLIFY_DWARF_ADDR hook.  */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic -g" } */
+
+static inline char *
+bar (unsigned long x, char *y)
+{
+  extern const char ext[];
+  const char *a = ext;
+  char *b = y;
+
+  do *--b = a[x % 10]; while ((x /= 10) != 0);
+  return b;
+}
+
+struct A { char *p, *q; };
+struct B { int r, s; };
+
+int
+foo (struct A *a, const struct B *b)
+{
+  char c[(b->r > b->s) ? b->r : b->s];
+  char *d = &c[sizeof c];
+  register char *e;
+
+  e = bar (b->r, d);
+  while (e < d)
+    {
+      register const int f = *e++;
+      if (((a->p >= a->q) ? 1 : (unsigned char) (*a->p++ = f)) == -1)
+	break;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020418-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020418-1.c
new file mode 100644
index 000000000..7314ec000
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020418-1.c
@@ -0,0 +1,26 @@
+/* PR optimization/5887 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -msse -ffast-math" { target i?86-*-* x86_64-*-* } } */
+
+void bar (float *a, float *b);
+
+void foo (char *x)
+{
+  float a, b;
+  char c[256];
+  int i, j;
+
+  bar (&a, &b);
+  for (i = 0; i < 256; i++)
+    {
+      float v = a;
+      if (v < 0.0f) v = 0.0f;
+      if (v < 255.0f) v = 255.0f;
+      c[i] = v;
+      a += b;
+    }
+
+  for (j = 0; j < 256; j++)
+    x[j] = c[j];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020418-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020418-2.c
new file mode 100644
index 000000000..93688d270
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020418-2.c
@@ -0,0 +1,21 @@
+/* PR optimization/6010 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -funroll-all-loops" } */
+/* { dg-options "-O2 -funroll-all-loops -march=pentium3" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+void bar (float);
+
+void foo (float y, unsigned long z)
+{
+  int b;
+  float c = y;
+
+  for (b = 0; b < z; b++)
+    {
+      bar (c);
+      if (c == y)
+	c = -y;
+      else
+	c = y;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020425-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020425-1.c
new file mode 100644
index 000000000..7783c8870
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020425-1.c
@@ -0,0 +1,15 @@
+/* PR c/2161: parser stack overflow.  */
+/* { dg-do compile } */
+/* { dg-timeout-factor 4.0 } */
+
+#define ONE	else if (0) { }
+#define TEN	ONE ONE ONE ONE ONE ONE ONE ONE ONE ONE
+#define HUN	TEN TEN TEN TEN TEN TEN TEN TEN TEN TEN
+#define THOU	HUN HUN HUN HUN HUN HUN HUN HUN HUN HUN
+
+void foo()
+{
+  if (0) { }
+  /* 11,000 else if's.  */
+  THOU THOU THOU THOU THOU THOU THOU THOU THOU THOU THOU
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020426-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020426-2.c
new file mode 100644
index 000000000..3a892ed0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020426-2.c
@@ -0,0 +1,176 @@
+/* PR optimization/6475
+   Distilled from zlib sources.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -frename-registers -fomit-frame-pointer -fPIC -mtune=i686" { target { { i?86-*-* x86_64-*-* } && { ilp32 && fpic } } } } */
+
+extern void exit (int);
+
+typedef struct
+{
+  union
+  {
+    struct
+    {
+      unsigned char a3;
+      unsigned char a4;
+    } a2;
+    unsigned int a5;
+  } a0;
+  unsigned int a1;
+} A;
+
+static int
+foo (unsigned int *b, unsigned int n, unsigned int s, const unsigned int *d,
+     const unsigned int *e, A **t, unsigned int *m, A *hp, unsigned int *hn,
+     unsigned int *v)
+{
+  unsigned int a, c[15 + 1], f;
+  int g, h;
+  unsigned int i, j, k;
+  int l;
+  unsigned int ee;
+  unsigned int *p;
+  A *q, r, *u[15];
+  int w;
+  unsigned int x[15 + 1], *xx;
+  int y;
+  unsigned int z;
+  p = c;
+  *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0;
+  *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0;
+  *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0;
+  *p++ = 0; *p++ = 0; *p++ = 0; *p++ = 0;
+  p = b;
+  i = n;
+  do
+    c[*p++]++;
+  while (--i);
+  if (c[0] == n)
+    {
+      *t = (A *) 0;
+      *m = 0;
+      return 0;
+    }
+  l = *m;
+  for (j = 1; j <= 15; j++)
+    if (c[j])
+      break;
+  k = j;
+  if ((unsigned int) l < j)
+    l = j;
+  for (i = 15; i; i--)
+    if (c[i])
+      break;
+  g = i;
+  if ((unsigned int) l > i)
+    l = i;
+  *m = l;
+  for (y = 1 << j; j < i; j++, y <<= 1)
+    if ((y -= c[j]) < 0)
+      return -3;
+  if ((y -= c[i]) < 0)
+    return -3;
+  c[i] += y;
+  x[1] = j = 0;
+  p = c + 1;
+  xx = x + 2;
+  while (--i)
+    *xx++ = (j += *p++);
+  p = b;
+  i = 0;
+  do
+    if ((j = *p++) != 0)
+      v[x[j]++] = i;
+  while (++i < n);
+  n = x[g];
+  x[0] = i = 0;
+  p = v;
+  h = -1;
+  w = -l;
+  u[0] = (A *) 0;
+  q = (A *) 0;
+  z = 0;
+  for (; k <= g; k++)
+    {
+      a = c[k];
+      while (a--)
+	{
+	  while (k > w + l)
+	    {
+	      h++;
+	      w += l;
+	      z = g - w;
+	      z = z > (unsigned int) l ? l : z;
+	      if ((f = 1 << (j = k - w)) > a + 1)
+		{
+		  f -= a + 1;
+		  xx = c + k;
+		  if (j < z)
+		    while (++j < z)
+		      {
+			if ((f <<= 1) <= *++xx)
+			  break;
+			f -= *xx;
+		      }
+		}
+	      z = 1 << j;
+	      if (*hn + z > 1440)
+		return -3;
+	      u[h] = q = hp + *hn;
+	      *hn += z;
+	      if (h)
+		{
+		  x[h] = i;
+		  r.a0.a2.a4 = (unsigned char) l;
+		  r.a0.a2.a3 = (unsigned char) j;
+		  j = i >> (w - l);
+		  r.a1 = (unsigned int) (q - u[h - 1] - j);
+		  u[h - 1][j] = r;
+		}
+	      else
+		*t = q;
+	    }
+	  r.a0.a2.a4 = (unsigned char) (k - w);
+	  if (p >= v + n)
+	    r.a0.a2.a3 = 128 + 64;
+	  else if (*p < s)
+	    {
+	      r.a0.a2.a3 = (unsigned char) (*p < 256 ? 0 : 32 + 64);
+	      r.a1 = *p++;
+	    }
+	  else
+	    {
+	      r.a0.a2.a3 = (unsigned char) (e[*p - s] + 16 + 64);
+	      r.a1 = d[*p++ - s];
+	    }
+	  f = 1 << (k - w);
+	  for (j = i >> w; j < z; j += f)
+	    q[j] = r;
+	  for (j = 1 << (k - 1); i & j; j >>= 1)
+	    i ^= j;
+	  i ^= j;
+	  ee = (1 << w) - 1;
+	  while ((i & ee) != x[h])
+	    {
+	      h--;
+	      w -= l;
+	      ee = (1 << w) - 1;
+	    }
+	}
+    }
+  return y != 0 && g != 1 ? (-5) : 0;
+}
+
+unsigned int a[19] = { 3, 4, 0, 2, 2, [17] = 3, 3 };
+unsigned int d[19];
+A h[1440];
+
+int
+main (void)
+{
+  unsigned int b = 0, c = 0;
+  A *e = 0;
+  foo (a, 19, 19, 0, 0, &e, &b, h, &c, d);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020430-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020430-1.c
new file mode 100644
index 000000000..8fcdfba0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020430-1.c
@@ -0,0 +1,190 @@
+/* PR opt/6516 */
+/* On x86, something about the structure of this function prevented
+   cross-jumping from combining the three arms of the switch statement
+   until the last moment.  After which we did not delete dead code, 
+   which left a reference to the deleted ADDR_VEC.  */
+
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -frename-registers -fpic" } */
+
+typedef unsigned long XID;
+typedef XID Window;
+typedef void Display;
+typedef unsigned long Time;
+
+typedef struct {
+        int type;
+        unsigned long serial;
+        int send_event;
+        Display *display;
+        Window window;
+        Window root;
+        Window subwindow;
+        Time time;
+        int x, y;
+        int x_root, y_root;
+        unsigned int state;
+        unsigned int button;
+        int same_screen;
+} XButtonEvent;
+typedef struct {
+        int type;
+        unsigned long serial;
+        int send_event;
+        Display *display;
+        Window window;
+        Window root;
+        Window subwindow;
+        Time time;
+        int x, y;
+        int x_root, y_root;
+        unsigned int state;
+        char is_hint;
+        int same_screen;
+} XMotionEvent;
+typedef struct {
+        int type;
+        unsigned long serial;
+        int send_event;
+        Display *display;
+        Window window;
+        Window root;
+        Window subwindow;
+        Time time;
+        int x, y;
+        int x_root, y_root;
+        int mode;
+        int detail;
+        int same_screen;
+        int focus;
+        unsigned int state;
+} XCrossingEvent;
+typedef union _XEvent {
+        int type;
+        XButtonEvent xbutton;
+        XMotionEvent xmotion;
+        XCrossingEvent xcrossing;
+} XEvent;
+
+typedef struct {
+        int width, height;
+        Display *display;
+} Screen;
+typedef struct _CorePart {
+    Screen *screen;
+} CorePart;
+typedef struct _WidgetRec {
+    CorePart core;
+} WidgetRec;
+typedef struct _WidgetRec *Widget;
+
+typedef struct _SmeRec *SmeObject;
+typedef struct _SimpleMenuPart {
+    SmeObject entry_set;
+} SimpleMenuPart;
+typedef struct _SimpleMenuRec {
+    SimpleMenuPart simple_menu;
+} SimpleMenuRec;
+typedef struct _SimpleMenuRec* SimpleMenuWidget;
+
+typedef short Position;
+typedef unsigned short Dimension;
+typedef char Boolean;
+
+typedef struct _RectObjPart {
+    Position x, y;
+    Dimension width, height;
+    Dimension border_width;
+    Boolean managed;
+    Boolean sensitive;
+    Boolean ancestor_sensitive;
+}RectObjPart;
+typedef struct _RectObjRec {
+    RectObjPart rectangle;
+} RectObjRec;
+typedef struct _RectObjRec *RectObj;
+
+SmeObject DoGetEventEntry();
+
+SmeObject
+GetEventEntry(Widget w, XEvent *event)
+{
+    int x_loc, y_loc, x_root;
+    SimpleMenuWidget smw = (SimpleMenuWidget)w;
+    SmeObject entry;
+    int warp, move;
+    switch (event->type) {
+        case 6:
+            x_loc = event->xmotion.x;
+            y_loc = event->xmotion.y;
+            x_root = event->xmotion.x_root;
+            break;
+        case 7:
+        case 8:
+            x_loc = event->xcrossing.x;
+            y_loc = event->xcrossing.y;
+            x_root = event->xcrossing.x_root;
+            break;
+        case 4:
+        case 5:
+            x_loc = event->xbutton.x;
+            y_loc = event->xbutton.y;
+            x_root = event->xbutton.x_root;
+            break;
+        default:
+            XtAppError(XtWidgetToApplicationContext(w),
+                       "Unknown event type in GetEventEntry().");
+            return (((void *)0));
+    }
+    if (x_loc < 0 || x_loc >= (((RectObj)smw)->rectangle.width) ||
+        y_loc < 0 || y_loc >= (((RectObj)smw)->rectangle.height))
+        return (((void *)0));
+    if (x_root == ((((w)->core.screen))->width) - 1 &&
+        (((RectObj)w)->rectangle.x) + (((RectObj)w)->rectangle.width) + ((((RectObj)w)->rectangle.border_width)) > x_root) {
+        warp = -8;
+        if (smw->simple_menu.entry_set) {
+            entry = DoGetEventEntry(w,
+                                    (((RectObj)smw->simple_menu.entry_set)->rectangle.x)
+                                    + (((RectObj)smw->simple_menu.entry_set)->rectangle.width) + 1,
+                                    y_loc);
+            Unhighlight(w, event, ((void *)0), ((void *)0));
+            if (entry) {
+                warp = -(int)(((RectObj)entry)->rectangle.width) >> 1;
+                move = x_loc - (((RectObj)entry)->rectangle.width) - (((RectObj)entry)->rectangle.x) + (((RectObj)w)->rectangle.border_width);
+            }
+            else {
+                warp = 0;
+                move = ((((w)->core.screen))->width) -
+                       ((((RectObj)w)->rectangle.x) + (((RectObj)w)->rectangle.width) + ((((RectObj)w)->rectangle.border_width) << 1));
+            }
+        }
+        else {
+            warp = 0;
+            move = ((((w)->core.screen))->width) -
+                   ((((RectObj)w)->rectangle.x) + (((RectObj)w)->rectangle.width) + ((((RectObj)w)->rectangle.border_width) << 1));
+        }
+    }
+    else if (x_root == 0 && (((RectObj)w)->rectangle.x) < 0) {
+        warp = 8;
+        if (smw->simple_menu.entry_set) {
+            entry = DoGetEventEntry(w, (((RectObj)smw->simple_menu.entry_set)->rectangle.x) - 1,
+                                    y_loc);
+            Unhighlight(w, event, ((void *)0), ((void *)0));
+            if (entry) {
+                warp = (((RectObj)entry)->rectangle.width) >> 1;
+                move = x_loc - (((RectObj)entry)->rectangle.x);
+            }
+            else
+                move = x_loc + (((RectObj)w)->rectangle.border_width);
+        }
+        else
+            move = x_loc + (((RectObj)w)->rectangle.border_width);
+    }
+    else
+        move = warp = 0;
+    if (move)
+        XtMoveWidget(w, (((RectObj)w)->rectangle.x) + move, (((RectObj)w)->rectangle.y));
+    if (warp)
+        XWarpPointer((((w)->core.screen)->display), 0L, 0L, 0, 0, 0, 0, warp, 0);
+    return (DoGetEventEntry(w, x_loc, y_loc));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020503-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020503-1.c
new file mode 100644
index 000000000..3edc7cf98
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020503-1.c
@@ -0,0 +1,11 @@
+/* PR target/6542
+   This testcase caused ICE on SPARC because the function uses no registers
+   after optimizing, so even if -mflat make all registers not permitted
+   for leaf functions, the function was still leaf, but LEAF_REG_REMAP
+   returned -1 for some registers (like %o0).  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+void foo (char *a, char *b, char *c, char *d)
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020517-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020517-1.c
new file mode 100644
index 000000000..032ccd23b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020517-1.c
@@ -0,0 +1,28 @@
+/* This testcase caused ICE in do_SUBST on IA-32, because 0xf6 constant
+   was not sign-extended for QImode.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#include <limits.h>
+
+void abort (void);
+void exit (int);
+
+void foo (void)
+{
+  int i;
+  char *p;
+
+  p = (char *) &i;
+  *p = -10;
+  if (* (unsigned char *) p != 0x100 - 10)
+    abort ();
+}
+
+int main (void)
+{
+  if (UCHAR_MAX == 255)
+    foo ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020525-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020525-1.c
new file mode 100644
index 000000000..7db44f0b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020525-1.c
@@ -0,0 +1,24 @@
+/* PR optimization/6703
+   Origin: Glen Nakamura <glen@imodulo.com> */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+
+void foo (int *x, int y)
+{
+  __builtin_memset (x, 0, y);
+}
+  
+int main ()
+{
+  int x[2] = { -1, -1 };
+    
+  if (x[1] != -1)
+    abort ();
+  foo (x, sizeof (int) + 1);
+  if (x[1] == -1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020527-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020527-1.c
new file mode 100644
index 000000000..6f963ed9f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020527-1.c
@@ -0,0 +1,54 @@
+/* PR c/6660
+   Test whether an unnamed field with user defined type - struct or union is
+   accepted.  */
+/* { dg-do compile } */
+/* { dg-options "-fms-extensions" } */
+
+typedef struct {
+  unsigned short a;
+  unsigned short b;
+} __attribute__ ((__packed__)) A;
+
+typedef struct B_ {
+  unsigned int c;
+  unsigned int d;
+} B;
+
+typedef struct C_ {
+  B;
+  unsigned int e;
+  unsigned int f;
+} C;
+
+typedef C D;
+
+typedef struct {
+  A;
+  D;
+  struct {
+    unsigned short g;
+    unsigned short h;
+  } __attribute__ ((__packed__));
+  union {
+    int i;
+    long j;
+  };
+  int k;
+} __attribute__ ((__packed__)) E;
+
+E x;
+
+void foo (void)
+{
+  x.a = 1;
+  x.b = 2;
+  x.c = 3;
+  x.d = 4;
+  x.e = 5;
+  x.f = 6;
+  x.g = 7;
+  x.h = 8;
+  x.i = 9;
+  x.j = 10;
+  x.k = 11;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020530-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020530-1.c
new file mode 100644
index 000000000..b2d0ecda5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020530-1.c
@@ -0,0 +1,20 @@
+/* PR c/6809
+   Test -fverbose-asm with unnamed fields.  */
+/* { dg-do compile } */
+/* { dg-options "-fverbose-asm" } */
+
+typedef union U
+{
+  struct
+  {
+    unsigned int a;
+    int b;
+  };
+  long long c;
+} *T;
+
+int foo (T x)
+{
+  int r = x->a + x->b;
+  return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020607-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020607-1.c
new file mode 100644
index 000000000..afad78d8c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020607-1.c
@@ -0,0 +1,40 @@
+/* PR middle-end/6950
+   gcc 3.0.4 mistakenly set lhs.low to 0 at the beginning of the num_eq
+   expansion; it should use a temporary.
+/* { dg-do run } */
+
+typedef struct cpp_num cpp_num;
+struct cpp_num
+{
+  long high;
+  long low;
+  char overflow;
+};
+
+#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
+
+static cpp_num
+num_equality_op (lhs, rhs)
+     cpp_num lhs, rhs;
+{
+  lhs.low = num_eq (lhs, rhs);
+  lhs.high = 0;
+  lhs.overflow = 0;
+  return lhs;
+}
+
+int main()
+{
+  cpp_num a = { 1, 2 };
+  cpp_num b = { 3, 4 };
+
+  cpp_num result = num_equality_op (a, b);
+  if (result.low)
+    return 1;
+
+  result = num_equality_op (a, a);
+  if (!result.low)
+    return 2;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020607-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020607-2.c
new file mode 100644
index 000000000..239aa9b38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020607-2.c
@@ -0,0 +1,74 @@
+/* Copyright (C) 2002 Free Software Foundation.
+
+   Test for correctness of floating point comparisons.
+
+   Written by Roger Sayle, 3rd June 2002.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void abort (void);
+
+int test1 (double x, int ok)
+{
+  if ((x - 1.0) > 0.0)
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int test1f (float x, int ok)
+{
+  if ((x - 1.0f) > 0.0f)
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int test2 (double x, int ok)
+{
+  if ((x + 1.0) < 0.0)
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+int test2f (float x, int ok)
+{
+  if ((x + 1.0f) < 0.0f)
+    {
+      if (!ok) abort ();
+    }
+  else
+    if (ok) abort ();
+}
+
+
+int
+main ()
+{
+  test1 (-2.0, 0);
+  test1 ( 0.0, 0);
+  test1 ( 2.0, 1);
+
+  test1f (-2.0f, 0);
+  test1f ( 0.0f, 0);
+  test1f ( 2.0f, 1);
+
+  test2 (-2.0, 1);
+  test2 ( 0.0, 0);
+  test2 ( 2.0, 0);
+
+  test2f (-2.0f, 1);
+  test2f ( 0.0f, 0);
+  test2f ( 2.0f, 0);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20020919-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020919-1.c
new file mode 100644
index 000000000..e0fab2702
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20020919-1.c
@@ -0,0 +1,257 @@
+/* Copyright (C) 2002  Free Software Foundation.
+   by Hans-Peter Nilsson  <hp@axis.com>
+
+   Making sure that asm clobbers conflicting with asm-declared input
+   operands are detected: ``You may not write a clobber description in a
+   way that overlaps with an input or output operand''.
+
+   You must be this tall ---> fit two long longs in asm-declared registers
+   to enter this amusement.  */
+
+/* { dg-do compile { target alpha*-*-* cris-*-* crisv32-*-* i?86-*-* mmix-*-* powerpc*-*-* rs6000-*-* x86_64-*-* } } */
+/* { dg-options "-O2" } */
+
+/* Constructed examples; input/output (same register), output, input, and
+   input and output (different registers).  */
+
+/* The long longs are used to test overlap overlap for multi-register
+   registers.  REG2 and REG4 must be the second halves (defined as
+   higher-numbered parts) of REG1 and REG3 respectively when two registers
+   are needed.  */
+
+#if defined (__alpha__)
+# define REG1 "$1"
+# define REG2 "$2"
+#elif defined (__CRIS__)
+# define REG1 "r10"
+# define REG2 "r11"
+# define REG3 "r12"
+# define REG4 "r13"
+# define REG5 "r9"
+#elif defined (__i386__)
+# define REG1 "%eax"
+# define REG2 "%edx"
+/* On Darwin -fpic is on by default, so don't use %ebx. */
+# define REG3 "%esi"
+# define REG4 "%edi"
+#elif defined (__MMIX__)
+# define REG1 "$8"
+# define REG2 "$9"
+#elif defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) \
+	|| defined (__POWERPC__) || defined (PPC) || defined (_IBMR2)
+# define REG1 "6"
+# define REG2 "7"
+# if !defined(__powerpc64__) && !defined(__LP64__)
+#  define REG3 "8"
+#  define REG4 "9"
+# endif
+#elif defined (__x86_64__)
+# define REG1 "rax"
+# define REG2 "rdx"
+#endif
+
+/* For readability of the tests.  */
+#ifdef REG3
+# define REG1a REG1
+# define REG1b REG2
+# define REG2a REG3
+# define REG2b REG4
+#else
+# define REG1a REG1
+# define REG1b REG1
+# define REG2a REG2
+# define REG2b REG2
+#endif
+
+/* REG5 is just another reg if there is one; the difference to REG4 is to
+   keep the original set of registers for CRIS.  */
+#ifndef REG5
+#define REG5 REG2b
+#endif
+
+void *
+foo (void *p)
+{
+  register void *q asm (REG1) = p;
+  asm ("foo1 %0" : "=r" (q) : "0" (q) : REG1); /* { dg-error "conflict" } */
+  return q;
+}
+
+void *
+nfoo (void *p)
+{
+  register void *q asm (REG1) = p;
+  asm ("foo1 %0" : "=r" (q) : "0" (q) : REG2);
+  return q;
+}
+
+long long
+foolla (long long llp)
+{
+  register long long ll asm (REG1a) = llp;
+  asm ("foo1a %0" : "=r" (ll) : "0" (ll) : REG1a); /* { dg-error "conflict" } */
+  return ll;
+}
+
+long long
+nfoolla (long long llp)
+{
+  register long long ll asm (REG1a) = llp;
+  asm ("foo1a %0" : "=r" (ll) : "0" (ll) : REG2a);
+  return ll;
+}
+
+long long
+foollb (long long llp)
+{
+  register long long ll asm (REG1a) = llp;
+  asm ("foo1b %0" : "=r" (ll) : "0" (ll) : REG1b); /* { dg-error "conflict" } */
+  return ll;
+}
+
+void *
+bar (void *p)
+{
+  register void *q asm (REG1);
+  register void *w asm (REG2) = p;
+  asm ("bar1 %1,%0" : "=r" (q) : "r" (w) : REG1); /* { dg-error "conflict" } */
+  return q;
+}
+
+long long
+barlla (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm asm (REG2a) = llp;
+  asm ("bar1a %1,%0" : "=r" (ll) : "r" (mm) : REG1b); /* { dg-error "conflict" } */
+  return ll;
+}
+
+long long
+barllb (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm asm (REG2a) = llp;
+  asm ("bar1b %1,%0" : "=r" (ll) : "r" (mm) : REG2b); /* { dg-error "conflict" } */
+  return ll;
+}
+
+void *
+foobar (void *p)
+{
+  register void *q asm (REG1);
+  register void *w asm (REG2) = p;
+  asm ("foobar1 %1,%0" : "=r" (q) : "r" (w) : REG2); /* { dg-error "conflict" } */
+  return q;
+}
+
+void *
+nfoobar (void *p)
+{
+  register void *q asm (REG1);
+  register void *w = p;
+  asm ("foobar1 %1,%0" : "=r" (q) : "r" (w) : REG2);
+  return q;
+}
+
+long long
+foobarlla (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm asm (REG2a) = llp;
+  asm ("foobar1a %1,%0" : "=r" (ll) : "r" (mm) : REG1b); /* { dg-error "conflict" } */
+  return ll;
+}
+
+long long
+nfoobarlla (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm = llp;
+  asm ("foobar1a %1,%0" : "=r" (ll) : "r" (mm) : REG2a);
+  return ll;
+}
+
+long long
+foobarllb (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm asm (REG2a) = llp;
+  asm ("foobar1b %1,%0" : "=r" (ll) : "r" (mm) : REG2b); /* { dg-error "conflict" } */
+  return ll;
+}
+
+long long
+nfoobarllb (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm = llp;
+  asm ("foobar1b %1,%0" : "=r" (ll) : "r" (mm) : REG2b);
+  return ll;
+}
+
+void *
+baz (void *p)
+{
+  register void *q asm (REG1);
+  register void *w asm (REG2) = p;
+  asm ("baz1 %1,%0" : "=r" (q) : "r" (w) : REG1, REG2); /* { dg-error "conflict" } */
+  return q;
+}
+
+void *
+nbaz (void *p)
+{
+  register void *q;
+  register void *w = p;
+  asm ("baz1 %1,%0" : "=r" (q) : "r" (w) : REG1, REG2);
+  return q;
+}
+
+void *
+nbaz2 (void *p)
+{
+  register void *q asm (REG1);
+  register void *w asm (REG2) = p;
+  asm ("baz1 %1,%0" : "=r" (q) : "r" (w));
+  return q;
+}
+
+long long
+bazlla (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm asm (REG2a) = llp;
+  asm ("baz1a %1,%0" : "=r" (ll) : "r" (mm) : REG1a, REG2a); /* { dg-error "conflict" } */
+  return ll;
+}
+
+long long
+bazllb (long long llp)
+{
+  register long long ll asm (REG1a);
+  register long long mm asm (REG2a) = llp;
+  asm ("baz2a %1,%0" : "=r" (ll) : "r" (mm) : REG1b, REG2b); /* { dg-error "conflict" } */
+  return ll;
+}
+
+/* Real-world example of bug.  */
+
+#ifdef _WIN64
+typedef unsigned int loc_size_t __attribute__ ((mode (DI)));
+#else
+typedef __SIZE_TYPE__ loc_size_t;
+#endif
+
+struct stat;
+int
+_dl_stat (const char *file_name, struct stat *buf)
+{
+  register long a asm (REG1) = (long) (loc_size_t) file_name;
+  register long b asm (REG2) = (long) (loc_size_t) buf;
+
+  asm volatile ("movu.w %1,$r9\n\tbreak 13" : "=r" (a) : "g" (106), "0" (a), "r" (b) : REG1, REG5); /* { dg-error "conflict" } */
+  if (a >= 0)
+    return (int) a;
+  return (int) -1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021006-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021006-1.c
new file mode 100644
index 000000000..63cc8a5af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021006-1.c
@@ -0,0 +1,27 @@
+/* PR target/7559
+   This testcase was miscompiled on x86-64 due to wrong access to the struct
+   members.  */
+
+extern void abort();
+
+struct A {
+  long x;
+};
+
+struct R {
+  struct A a, b;
+};
+
+struct R R = {
+  {100}, {200}
+};
+
+void f(struct R r) {
+  if (r.a.x != R.a.x || r.b.x != R.b.x)
+    abort();
+}
+
+int main() {
+  f(R);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021014-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021014-1.c
new file mode 100644
index 000000000..41aa3c376
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021014-1.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-require-profiling "-p" } */
+/* { dg-options "-O2 -p" } */
+/* { dg-options "-O2 -p -static" { target hppa*-*-hpux* } } */
+/* { dg-error "profiler" "No profiler support" { target xstormy16-*-* } 0 } */
+/* { dg-error "" "consider using `-pg' instead of `-p' with gprof(1)" { target *-*-freebsd* } 0 } */
+
+extern void abort (void);
+extern void exit (int);
+
+int foo (void)
+{
+  int bar (int x)
+  {
+    return x + 3;
+  }
+  return bar (1) + bar (2);
+}
+
+int main (void)
+{
+  if (foo () != 9)
+    abort ();
+  exit (0);
+}
+
+/* { dg-final { cleanup-profile-file } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021018-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021018-1.c
new file mode 100644
index 000000000..bbc889566
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021018-1.c
@@ -0,0 +1,29 @@
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+extern void abort (void);
+extern void exit (int);
+
+#if __INT_MAX__ >= 2147483647L
+static const long foo [10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+long __attribute__((noinline))
+bar (int x)
+{
+  return foo [x - 0x6ffffffa];
+}
+
+int
+main (void)
+{
+  if (bar (0x6ffffffc) != 2)
+    abort ();
+  exit (0);
+}
+#else
+int
+main (void)
+{
+  exit (0);
+}
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021023-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021023-1.c
new file mode 100644
index 000000000..855b2cc1e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021023-1.c
@@ -0,0 +1,24 @@
+/* This testcase ICEd on x86-64 because LABEL_REF + small const was not
+   considered as local_symbolic_operand.  */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+typedef __builtin_va_list va_list;
+
+static unsigned int
+foo (void *a, float b, const char *c, va_list d, void *e)
+{
+  return -1;
+}
+
+unsigned int
+bar (void *a, float b, const char *c, ...)
+{
+  va_list args;
+  unsigned int d;
+
+  __builtin_va_start (args, c);
+  d = foo (a, b, c, args, a);
+  __builtin_va_end (args);
+  return d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021029-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021029-1.c
new file mode 100644
index 000000000..bc330c56f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021029-1.c
@@ -0,0 +1,17 @@
+/* Test whether difference of local labels doesn't force
+   variables into writable sections.  */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+/* { dg-options "-O2 -fpic -mpt-fixed" { target sh64*-*-* } } */
+/* { dg-final { scan-assembler-not ".data.rel.ro.local" } } */
+
+int foo (int a)
+{
+  static const int ar[] = { &&l1 - &&l1, &&l2 - &&l1 };
+  void *p = &&l1 + ar[a];
+  goto *p;
+  l1:
+    return 1;
+  l2:
+    return 2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021029-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021029-2.c
new file mode 100644
index 000000000..e99342478
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021029-2.c
@@ -0,0 +1,14 @@
+/* Test whether variables with relocations aren't put into
+   mergeable sections even with -fmerge-all-constants.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fmerge-all-constants" } */
+/* { dg-final { scan-assembler-not ".rodata.cst" } } */
+
+int foo (int a)
+{
+  static void * const ar[] = { &&l2 };
+  void *p = ar[a];
+  goto *p;
+l2:
+  return 2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20021116-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021116-1.c
new file mode 100644
index 000000000..4d3afc7b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20021116-1.c
@@ -0,0 +1,31 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+void **
+foo (void **x, int y, void *z)
+{
+  switch (y)
+    {
+    case 162:
+      *x = z;
+      break;
+    case 164:
+      *x = z;
+      break;
+    case 165:
+      *x = z;
+      break;
+    case 166:
+      *x = z;
+      break;
+    case 163:
+      *x = z;
+      break;
+    default:
+      goto out;
+    }
+  return x;
+
+out:
+  return (void **) 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030107-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030107-1.c
new file mode 100644
index 000000000..a3c2df7f6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030107-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-fprofile-arcs" } */
+
+extern void bar(void) __attribute__((noreturn));
+int foo (void) { bar(); }
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030120-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030120-1.c
new file mode 100644
index 000000000..2d3e2ce65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030120-1.c
@@ -0,0 +1,9 @@
+/* PR 7154 */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O -fpic" } */
+
+const int x[1]={ 1 };
+void foo(int i, int *p)
+{
+  asm volatile("" : "+r"(i) : "m" (x[0]), "r"(p));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030204-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030204-1.c
new file mode 100644
index 000000000..701ded28c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030204-1.c
@@ -0,0 +1,17 @@
+/* PR optimization/8555 */
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math -funroll-loops" } */
+/* { dg-options "-march=pentium3 -O -ffast-math -funroll-loops" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+
+float foo (float *a, int i)
+{
+  int j;
+  float x = a[j = i - 1], y;
+
+  for (j = i; --j >= 0; )
+    if ((y = a[j]) > x)
+      x = y;
+
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030213-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030213-1.c
new file mode 100644
index 000000000..35bfe22fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030213-1.c
@@ -0,0 +1,36 @@
+/* Testcase for http://gcc.gnu.org/ml/gcc-patches/2003-02/msg01017.html */
+/* { dg-do link { target fpic } } */
+/* { dg-options "-O -fpic" } */
+
+int *g;
+
+int main (void)
+{
+  switch (*g)
+    {
+    case 0:
+      {
+        switch (*g)
+          {
+          case 0: *g = 1; break;
+          case 1:
+          case 2: *g = 1; break;
+          case 3:
+          case 4: *g = 1; break;
+          }
+        break;
+      }
+    case 1:
+      {
+        switch (*g)
+          {
+          case 0: *g = 1; break;
+          case 1:
+          case 2: *g = 1; break;
+          case 3:
+          case 4: *g = 1; break;
+          }
+      }
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030225-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030225-1.c
new file mode 100644
index 000000000..97a436b4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030225-1.c
@@ -0,0 +1,101 @@
+/* PR target/9732
+   This testcase segfaulted on PPC because PIC_OFFSET_TABLE_REGNUM was no
+   fixed register.
+   Distilled from the xvid sources by Guillaume Morin <guillaume@morinfr.org>
+   and Benjamin Herrenschmidt <benh@kernel.crashing.org>.  */
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O2 -fPIC" } */
+
+extern void exit (int);
+
+#define W1 2841					/* 2048*sqrt(2)*cos(1*pi/16) */
+#define W2 2676					/* 2048*sqrt(2)*cos(2*pi/16) */
+#define W3 2408					/* 2048*sqrt(2)*cos(3*pi/16) */
+#define W5 1609					/* 2048*sqrt(2)*cos(5*pi/16) */
+#define W6 1108					/* 2048*sqrt(2)*cos(6*pi/16) */
+#define W7 565					/* 2048*sqrt(2)*cos(7*pi/16) */
+
+
+/* private data */
+static short iclip[1024];		/* clipping table */
+static short *iclp;
+
+void
+idct_int32(short *const block)
+{
+  static short *blk;
+  static long i;
+  static long X0, X1, X2, X3, X4, X5, X6, X7, X8;
+
+  for (i = 0; i < 8; i++)		/* idct columns */
+    {
+      blk = block + i;
+      /* shortcut  */
+      if (! ((X1 = (blk[8 * 4] << 8)) | (X2 = blk[8 * 6])
+	     | (X3 = blk[8 * 2]) | (X4 = blk[8 * 1]) | (X5 = blk[8 * 7])
+	     | (X6 = blk[8 * 5]) | (X7 = blk[8 * 3])))
+	{
+	  blk[8 * 0] = blk[8 * 1] = blk[8 * 2] = 
+	    blk[8 * 3] = blk[8 * 4] =
+	    blk[8 * 5] = blk[8 * 6] = blk[8 * 7] =
+	    iclp[(blk[8 * 0] + 32) >> 6];
+	  continue;
+	}
+      X0 = (blk[8 * 0] << 8) + 8192;
+
+      /* first stage  */
+      X8 = W7 * (X4 + X5) + 4;
+      X4 = (X8 + (W1 - W7) * X4) >> 3;
+      X5 = (X8 - (W1 + W7) * X5) >> 3;
+      X8 = W3 * (X6 + X7) + 4;
+      X6 = (X8 - (W3 - W5) * X6) >> 3;
+      X7 = (X8 - (W3 + W5) * X7) >> 3;
+
+      /* second stage  */
+      X8 = X0 + X1;
+      X0 -= X1;
+      X1 = W6 * (X3 + X2) + 4;
+      X2 = (X1 - (W2 + W6) * X2) >> 3;
+      X3 = (X1 + (W2 - W6) * X3) >> 3;
+      X1 = X4 + X6;
+      X4 -= X6;
+      X6 = X5 + X7;
+      X5 -= X7;
+
+      /* third stage  */
+      X7 = X8 + X3;
+      X8 -= X3;
+      X3 = X0 + X2;
+      X0 -= X2;
+      X2 = (181 * (X4 + X5) + 128) >> 8;
+      X4 = (181 * (X4 - X5) + 128) >> 8;
+
+      /* fourth stage  */
+      blk[8 * 0] = iclp[(X7 + X1) >> 14];
+      blk[8 * 1] = iclp[(X3 + X2) >> 14];
+      blk[8 * 2] = iclp[(X0 + X4) >> 14];
+      blk[8 * 3] = iclp[(X8 + X6) >> 14];
+      blk[8 * 4] = iclp[(X8 - X6) >> 14];
+      blk[8 * 5] = iclp[(X0 - X4) >> 14];
+      blk[8 * 6] = iclp[(X3 - X2) >> 14];
+      blk[8 * 7] = iclp[(X7 - X1) >> 14];
+    }
+}								/* end function idct_int32(block) */
+
+
+int main(void) {
+  int i;
+  unsigned short tab[64];
+
+  for (i = 0 ; i < 64 ; ++i) 
+    {  
+      tab[i] = (1+(int) (65535)*8000/(2147483647+1.0));
+    }
+  
+  iclp = iclip + 512;
+  for (i = -512; i < 512; i++)
+    iclp[i] = (i < -256) ? -256 : ((i > 255) ? 255 : i);
+
+  idct_int32((short *) tab);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030309-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030309-1.c
new file mode 100644
index 000000000..2431bc1b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030309-1.c
@@ -0,0 +1,42 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+struct A0 { int x; };
+struct A1 { int x; int y[1]; };
+struct A2 { int x; int y[2]; };
+struct A3 { int x; int y[3]; };
+struct A4 { int x; int y[4]; };
+
+void *s;
+int u;
+
+int
+main (void)
+{
+  int x;
+  void *t = s;
+
+  switch (u)
+    {
+    case 0:
+      x = ((struct A0 *) t)->x;
+      break;
+    case 1:
+      x = ((struct A1 *) t)->x;
+      break;
+    case 2:
+      x = ((struct A2 *) t)->x;
+      break;
+    case 3:
+      x = ((struct A3 *) t)->x;
+      break;
+    case 4:
+      x = ((struct A4 *) t)->x;
+      break;
+    default:
+      x = 0;
+      break;
+    }
+
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030321-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030321-1.c
new file mode 100644
index 000000000..1150c7f76
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030321-1.c
@@ -0,0 +1,18 @@
+/* This used to ICE on s390 due to displacement overflow 
+   when accessing the low-order subword.  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct array 
+{
+  char align[4092];
+  long long elem[2] __attribute__ ((__packed__)); /* { dg-warning "attribute ignored" "" { target default_packed } } */
+};
+
+long long
+test (struct array *array, int i)
+{
+  return array->elem[i];
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030323-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030323-1.c
new file mode 100644
index 000000000..8a563ec5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030323-1.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+
+/* PR c/8224 */
+/* Contributed by Mikulas Patocka <mikulas@artax.karlin.mff.cuni.cz> */
+
+extern void abort (void);
+
+unsigned f (int x)
+{
+  return (unsigned) (x / 2) / 2;
+}
+
+unsigned f1 (int x)
+{
+  unsigned xx = x / 2;
+  return xx / 2;
+}
+
+int main ()
+{
+  if (f1 (-5) != f (-5))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030324-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030324-1.c
new file mode 100644
index 000000000..67db669fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030324-1.c
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-O -fstrict-aliasing -fgcse" } */
+
+/* PR optimization/10087 */
+/* Contributed by Peter van Hoof <p.van-hoof@qub.ac.uk> */
+ 
+extern void abort(void);
+
+void b(int*,int*);
+    
+typedef struct {
+    double T1;
+    char c;
+} S;
+
+int main(void)
+{
+  int i,j;
+  double s;
+
+  S x1[2][2];
+  S *x[2] = { x1[0], x1[1] };
+  S **E = x;
+
+  for( i=0; i < 2; i++ )
+    for( j=0; j < 2; j++ )
+      E[j][i].T1 = 1;
+
+  for( i=0; i < 2; i++ )
+    for( j=0; j < 2; j++ )
+      s = E[j][i].T1;
+
+  b(&j,&i);
+  if (s != 1)
+    abort ();
+  return 0;
+}
+
+void b(int *i, int *j) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030331-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030331-2.c
new file mode 100644
index 000000000..2fce78ea9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030331-2.c
@@ -0,0 +1,12 @@
+// { dg-options "" }
+
+extern int printf (const char *, ...);
+
+int foo() {
+  int yd;
+  float in[1][yd];
+ 
+  void bar() {
+    printf("%p\n",in[0]);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030414-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030414-1.c
new file mode 100644
index 000000000..9ba595318
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030414-1.c
@@ -0,0 +1,39 @@
+/* PR target/10377
+   Distilled by Hans-Peter Nilsson <hp@axis.com> from ncurses-5.3 infocmp.c.
+   Copyright (C) 2003 Free Software Foundation.  */
+
+/* { dg-do assemble } */
+/* { dg-options "-O2 -fPIC" { target *-*-*gnu* } } */
+
+extern int f2 (char *, char *);
+extern char *ss[];
+extern char *cc;
+void
+f1 (char *dd, char *bb)
+{
+  char *sp = bb + 1;
+  char *ap;
+  int i;
+  char *ee = 0;
+  char *cp;
+
+  for (i = 0, cp = cc; i < 42; i++)
+    if (cp)
+      {
+	if (f2 (dd, "xx") || f2 (ss[i], "xx") || f2 (ss[i], "yy"))
+	  if (bb < cp)
+	    continue;
+	ee = ss[i];
+	break;
+      }
+
+  if (!ee)
+    for (ap = cc; *ap; ap++)
+      if (f2(ap, sp))
+	{
+	  ee = ap;
+	  break;
+	}
+
+  cc = ee;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030414-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030414-2.c
new file mode 100644
index 000000000..f4eb8bf36
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030414-2.c
@@ -0,0 +1,38 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding (c1 - x) op c2 into x swap(op) c1-c2
+   doesn't break anything.
+
+   Written by Roger Sayle, 27th March 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void abort (void);
+
+int foo(double x)
+{
+  return (10.0 - x) > 3.0;
+}
+
+int bar (double x)
+{
+  return (10.0 - x) == 5.0;
+}
+
+int main()
+{
+  if (foo (8.0))
+    abort ();
+
+  if (! foo (6.0))
+    abort ();
+
+  if (bar (1.0))
+    abort ();
+
+  if (! bar (5.0))
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030612-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030612-1.c
new file mode 100644
index 000000000..f08751243
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030612-1.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+int A, B;
+
+void foo()
+{
+  long x = 3;
+  (void)({
+    A = B + x + ((1) - 1);
+    return;	/* { dg-warning "statement-expressions should end with a non-void expression" "" { xfail *-*-* } } */
+  });
+}
+
+main()
+{
+  B = 5;
+  foo();
+  if (A != 8)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030625-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030625-1.c
new file mode 100644
index 000000000..4e78ae4ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030625-1.c
@@ -0,0 +1,9 @@
+/* Testcase from http://gcc.gnu.org/ml/gcc-patches/2003-06/msg02557.html */
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+typedef struct _foo foo;
+struct _foo {
+  struct _moo moo;	/* { dg-error "moo" "has incomplete type" } */
+};
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030626-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030626-1.c
new file mode 100644
index 000000000..3a96786fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030626-1.c
@@ -0,0 +1,18 @@
+/* PR optimization/11210 */
+/* Originator: Guido Classen <guido@clagi.de> */
+/* Reduced testcase by Falk Hueffner <falk@debian.org> */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+/* Verify that the constant expressions folder doesn't
+   throw away the cast operation in the comparison.  */
+
+struct str { 
+  int head; 
+  signed char data[8];
+};
+
+int foo(struct str t)
+{
+  return t.data[0] || (unsigned char) t.data[2] != 130; /* { dg-bogus "comparison is always 1" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030627-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030627-1.c
new file mode 100644
index 000000000..4135f71e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030627-1.c
@@ -0,0 +1,20 @@
+/* This tests whether non-offsettable memory operands are reloaded 
+   correctly in certain corner cases on s390 targets.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+void test_inout (char *bd, int xd, char *bs, int xs)
+{
+  *(long long *)(bd + xd + 4093) = *(long long *)(bs + xs + 4093);
+}
+
+void test_in (char *bd, int xd, char *bs, int xs)
+{
+  *(long long *)(bd + xd) = *(long long *)(bs + xs + 4093);
+}
+
+void test_out (char *bd, int xd, char *bs, int xs)
+{
+  *(long long *)(bd + xd + 4093) = *(long long *)(bs + xs);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030702-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030702-1.c
new file mode 100644
index 000000000..4dbb4c50f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030702-1.c
@@ -0,0 +1,12 @@
+/* This tests whether REG_ALWAYS_RETURN notes are handled
+   correctly in combine.  */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic -fprofile-arcs" } */
+/* { dg-skip-if "requires unsupported run-time relocation" { spu-*-* } { "*" } { "" } } */
+
+void test (void)
+{
+  fork ();
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030707-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030707-1.c
new file mode 100644
index 000000000..cd3e88ebb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030707-1.c
@@ -0,0 +1,16 @@
+/* Derived from PR target/10979.  */
+/* This testcase used to ICE on x86.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+void t(double);
+double atan2(double,double);
+
+void temp(double *c)
+{
+  double c2 = 8;
+  double s2 = 0;
+  *c = atan2(s2,c2);
+  t(1/s2);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030708-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030708-1.c
new file mode 100644
index 000000000..344bb4e18
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030708-1.c
@@ -0,0 +1,14 @@
+/* PR c/11420 */
+/* { dg-do link { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+void (* volatile fn) (void);
+static void foo (void)
+{
+}
+
+int main (void)
+{
+  fn = foo;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030711-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030711-1.c
new file mode 100644
index 000000000..e76f54f21
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030711-1.c
@@ -0,0 +1,30 @@
+/* Test whether strncmp has not been "optimized" into memcmp
+   nor any code with memcmp semantics.  */
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* ia64-*-linux* alpha*-*-linux* powerpc*-*-linux* s390*-*-linux* sparc*-*-linux* *-*-darwin* } } */
+/* { dg-options "-O2" } */
+#include <stddef.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+#include <stdlib.h>
+
+void __attribute__((noinline)) test (const char *p)
+{
+  if (__builtin_strncmp (p, "abcdefghijklmnopq", 17) == 0)
+    abort ();
+}
+
+int main (void)
+{
+  char *p = mmap (NULL, 131072, PROT_READ | PROT_WRITE,
+                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (p == MAP_FAILED)
+    return 0;
+  if (munmap (p + 65536, 65536) < 0)
+    return 0;
+  __builtin_memcpy (p + 65536 - 5, "abcd", 5);
+  test (p + 65536 - 5);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030717-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030717-1.c
new file mode 100644
index 000000000..6a7f6de6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030717-1.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+int zero (void)
+{
+  return 0;
+}
+
+int one (void)
+{
+  return 1;
+}
+
+int main (void)
+{
+  int i = 1;
+  int r = (i ? one : zero)();
+  if (r != 1)
+    abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030721-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030721-1.c
new file mode 100644
index 000000000..5e8ed0b43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030721-1.c
@@ -0,0 +1,41 @@
+/* { dg-options "-O2" } */
+/* PR optimization/11536 */
+/* Origin: samal@kam.mff.cuni.cz <samal@kam.mff.cuni.cz> */
+/* Testcase by Andrew Pinski <pinskia@physics.uc.edu> */
+
+/* Verify that the loop optimizer doesn't use moving targets
+   to calculate the number of iterations of a loop.  */
+
+extern void abort(void);
+
+void foo(int) __attribute__((__noinline__));
+
+void foo(int i)
+{
+  abort();
+}
+
+int main()
+{
+  int i;
+  int first= 0;
+  int last= 0;
+
+  while (last<3) {
+    last = first;
+
+    while (first<=last) {
+      first++;
+
+      for (i=0;i<3;i++)
+        last++;
+
+      if (last>10)
+        return 0;
+    }
+    
+    foo(first);
+  }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030804-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030804-1.c
new file mode 100644
index 000000000..cbc66474a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030804-1.c
@@ -0,0 +1,75 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of mathematical expressions doesn't
+   break anything.
+
+   Written by Roger Sayle, 3rd August 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void link_error(void);
+
+void test(double x)
+{
+  if (x+x != 2.0*x)
+    link_error ();
+  if (x+x != x*2.0)
+    link_error ();
+
+  if (x+x+x != 3.0*x)
+    link_error ();
+  if (x+x+x != x*3.0)
+    link_error ();
+
+  if ((x+x)+x != 3.0*x)
+    link_error ();
+  if ((x+x)+x != x*3.0)
+    link_error ();
+
+  if (x+(x+x) != 3.0*x)
+    link_error ();
+  if (x+(x+x) != x*3.0)
+    link_error ();
+
+  if (x+4.0*x != 5.0*x)
+    link_error ();
+  if (x+4.0*x != x*5.0)
+    link_error ();
+  if (x+x*4.0 != 5.0*x)
+    link_error ();
+  if (x+x*4.0 != x*5.0)
+    link_error ();
+  if (4.0*x+x != 5.0*x)
+    link_error ();
+  if (4.0*x+x != x*5.0)
+    link_error ();
+  if (x*4.0+x != 5.0*x)
+    link_error ();
+  if (x*4.0+x != x*5.0)
+    link_error ();
+
+  if (3.0*x + 5.0*x != 8.0*x)
+    link_error ();
+  if (3.0*x + 5.0*x != x*8.0)
+    link_error ();
+  if (x*3.0 + 5.0*x != 8.0*x)
+    link_error ();
+  if (x*3.0 + 5.0*x != x*8.0)
+    link_error ();
+  if (3.0*x + x*5.0 != 8.0*x)
+    link_error ();
+  if (3.0*x + x*5.0 != x*8.0)
+    link_error ();
+  if (x*3.0 + x*5.0 != 8.0*x)
+    link_error ();
+  if (x*3.0 + x*5.0 != x*8.0)
+    link_error ();
+}
+
+int main()
+{
+  test(2.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030805-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030805-1.c
new file mode 100644
index 000000000..6297c5d83
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030805-1.c
@@ -0,0 +1,23 @@
+/* Test that gcc understands that the call to g might clobber i.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+__inline int f ()
+{
+  static int i;
+  int i2 = i;
+  i = i2 + 1;
+  return i;
+}
+
+int g () { return f (); }
+
+int main ()
+{
+  if (f() != 1
+      || g() != 2
+      || f() != 3)
+    return 1;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030815-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030815-1.c
new file mode 100644
index 000000000..7bf21bd46
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030815-1.c
@@ -0,0 +1,18 @@
+/* Test completion of incomplete types.
+   There used to be a bug where some types from incomplete
+   list were accidentally lost.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef struct a E;
+typedef struct b F;
+typedef struct c G;
+typedef struct d H;
+struct a { int a; };
+struct c { int c; };
+struct d { int d; };
+struct b { int b; };
+int se = sizeof (E);
+int sf = sizeof (F);
+int sg = sizeof (G);
+int sh = sizeof (H);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030820-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030820-1.c
new file mode 100644
index 000000000..f86fb3978
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030820-1.c
@@ -0,0 +1,13 @@
+/* PR middle-end/11984 */
+/* The following program used to ICE in fold because we didn't check
+   whether the constants we were reassociating were integer constants
+   before calling tree_int_cst_lt.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double f(double x)
+{
+  return 1.0 - x - 0.1;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030826-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030826-1.c
new file mode 100644
index 000000000..b344ad2dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030826-1.c
@@ -0,0 +1,33 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of mathematical expressions doesn't
+   break anything.
+
+   Written by Roger Sayle, 24th August 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+void abort(void);
+
+double foo(double x)
+{
+  return 12.0/(x*3.0);
+}
+
+double bar(double x)
+{
+  return (3.0/x)*4.0;
+}
+
+int main()
+{
+  if (foo(2.0) != 2.0)
+    abort ();
+
+  if (bar(2.0) != 6.0)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030826-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030826-2.c
new file mode 100644
index 000000000..32db09195
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030826-2.c
@@ -0,0 +1,64 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fomit-frame-pointer" } */
+/* { dg-options "-O2 -fomit-frame-pointer -march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct S
+{
+  int *a;
+  unsigned char *b, c;
+};
+
+int u, v, w;
+
+void
+foo (unsigned short x)
+{
+  u += x;
+}
+
+int
+bar (struct S **x, int *y)
+{
+  w += *y;
+  *y = w + 25;
+  return 0;
+}
+
+int
+baz (struct S **x)
+{
+  struct S *y = *x;
+  unsigned char *a = y->b;
+
+  foo (*a);
+
+  if (__builtin_expect (y->c != 0 || y->a == &v, 0))
+    return 1;
+
+  if (__builtin_expect (*a == 1, 0))
+    {
+      int a, b = bar (x, &a);
+
+      if (a)
+	return b;
+    }
+
+  return 0;
+}
+
+int
+main (void)
+{
+  struct S a, *b = &a;
+  unsigned char c;
+
+  __builtin_memset (b, 0, sizeof (a));
+  a.a = &v;
+  a.b = &c;
+  if (baz (&b) != 1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030906-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030906-1.c
new file mode 100644
index 000000000..c416f55ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030906-1.c
@@ -0,0 +1,21 @@
+/* Bug 9862 -- Spurious warnings with -finline-functions.
+   Copyright (C) 2003 Free Software Foundation Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -finline-functions -Wreturn-type" } */
+
+extern int i;
+extern int foo (void);
+extern int bar (void);
+
+int foo (void)
+{
+  if( i ) return 0;
+  else    return 1;
+}
+
+int bar (void)
+{
+  if( i ) return; /* { dg-warning "'return' with no value, in function returning non-void" } */
+  else    return 1;
+}		
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20030906-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030906-2.c
new file mode 100644
index 000000000..1191133e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20030906-2.c
@@ -0,0 +1,21 @@
+/* Bug 9862 -- Spurious warnings with -finline-functions.
+   Copyright (C) 2003 Free Software Foundation Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -finline-functions -Wreturn-type" } */
+
+extern int i;
+extern int foo (void);
+extern int bar (void);
+
+int foo (void)
+{
+  if( i ) return; /* { dg-warning "'return' with no value, in function returning non-void" } */
+  else    return 1;
+}
+
+int bar (void)
+{
+  if( i ) return 0;
+  else    return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031002-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031002-1.c
new file mode 100644
index 000000000..57a31ed7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031002-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+void generic_sendmsg (char *fmt, ...)
+{
+  __builtin_next_arg(fmt);
+}
+
+void generic_sendstat()
+{
+  double t;
+
+  generic_sendmsg("F %3.2f", t);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031012-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031012-1.c
new file mode 100644
index 000000000..f83e1d3f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031012-1.c
@@ -0,0 +1,18 @@
+/* { dg-options "-Waddress" } */
+/* Origin: Andrew Morton <akpm@osdl.org> */
+/* Warn if a function addres of a non-weak function is used
+   as a truth value.  */
+/* See thread starting at http://gcc.gnu.org/ml/gcc/2003-10/msg00414.html  */
+
+void foo(void)
+{}
+
+void bar(void)
+{}
+
+int main() {
+	if (foo) /* { dg-warning "" } */
+		bar();
+	return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031102-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031102-1.c
new file mode 100644
index 000000000..5a02a704a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031102-1.c
@@ -0,0 +1,37 @@
+/* PR optimization/12799 */
+/* Origin: Pratap Subrahmanyam <pratap@vmware.com> */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -march=i686" { target { { i686-*-* x86_64-*-* } && ilp32 } } } */
+
+/* Verify that reload_cse_move2add doesn't add unexpected CLOBBERs. */
+
+extern void abort(void);
+
+int loo = 1;
+
+__inline__ char InlineFunc(void)
+{
+  return __builtin_expect(!!(loo == 1), 1);
+}
+
+int FooBar(void)
+{
+  int i;
+  int var1 = InlineFunc() ? 2046 : 1023;
+  int var2 = InlineFunc() ? 512 : 1024;
+
+  for (i = 0; i < var1; i++)
+    ;
+
+  if (InlineFunc() && var2 != 512)
+    abort();
+
+  return 0;
+}
+
+int main(void)
+{
+  return FooBar();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031111-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031111-1.c
new file mode 100644
index 000000000..f4de52257
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031111-1.c
@@ -0,0 +1,13 @@
+/* Make sure that dead code isn't eliminated too early, avoiding 
+   detection of errors.  */
+/* { dg-do compile } */
+
+void foo(void)
+{
+  if (0)
+    break;		/* { dg-error "" } */
+  if (1)
+    ;
+  else
+    continue;		/* { dg-error "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031201-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031201-1.c
new file mode 100644
index 000000000..91f2d9ddf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031201-1.c
@@ -0,0 +1,20 @@
+/* PR optimization/12628 */
+/* The following test used to ICE in init_alias_analysis because the
+   given command line options meant that reg_scan wasn't (re)run before
+   the jump bypassing pass.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-expensive-optimizations" } */
+
+int outbuf[100];
+int outcnt;
+int bi_buf;
+void send_bits(void)
+{
+    bi_buf = 0;
+    outbuf[outcnt++] = 8;
+    outbuf[outcnt++] = 8;
+    if (outcnt)
+        bi_buf = 1;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031201-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031201-2.c
new file mode 100644
index 000000000..c32b5ebd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031201-2.c
@@ -0,0 +1,41 @@
+/* PR optimization/11634 */
+
+/* The following code used to ICE in verify_local_live_at_start on
+   PA when compiled with -O2.  The cause was that split_all_insns was
+   not updating liveness information when deleting no-op moves that
+   had REG_UNUSED notes.  */
+
+/* { dg-do compile { target hppa*-*-* } } */
+/* { dg-options "-O2" } */
+
+void *f(void *s);
+void H5T_conv_vlen (unsigned long long nelmts, unsigned char *bg_ptr)
+{
+  long long seq_len;
+  unsigned long long bg_seq_len = 0;
+  unsigned src_base_size, dst_base_size;
+  void *tmp_buf = 0;
+  unsigned tmp_buf_size = 0;
+  unsigned long long elmtno;
+  for (elmtno = 0; elmtno < nelmts; elmtno++)
+    {
+      unsigned char *tmp = bg_ptr;
+      bg_seq_len = *tmp;
+      if (bg_seq_len > 0
+          && tmp_buf_size <
+          (unsigned) (bg_seq_len *
+                      (src_base_size > dst_base_size
+                       ? src_base_size
+		       : dst_base_size)))
+	{
+	  tmp_buf_size =
+	    (unsigned) (bg_seq_len *
+			(src_base_size > dst_base_size
+			 ? src_base_size
+			 : dst_base_size));
+	}
+      if (bg_seq_len < seq_len)
+	f ((unsigned char *) tmp_buf + dst_base_size * bg_seq_len);
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031202-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031202-1.c
new file mode 100644
index 000000000..c7fbfe524
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031202-1.c
@@ -0,0 +1,44 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct A { char p[6]; } __attribute__((packed));
+struct B {
+    struct A a;
+    void * const b;
+    struct A const * const c;
+    struct A const *d;
+};
+
+char v;
+
+int __attribute__((noinline))
+foo (struct B *b)
+{
+  int i;
+  for (i = 0; i < 6; ++i)
+    if (b->a.p[i])
+      abort ();
+  if (b->b != &v || b->c || b->d)
+    abort ();
+  return 12;
+}
+
+int __attribute__((noinline))
+bar (void *x)
+{
+  __asm __volatile ("" : "=r" (x) : "0" (x));
+  struct B y = { .b = x, .c = (void *) 0 };
+  return foo (&y) + 1;
+}
+
+int
+main (void)
+{
+  if (bar (&v) != 13)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031216-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031216-1.c
new file mode 100644
index 000000000..7c706d86b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031216-1.c
@@ -0,0 +1,39 @@
+/* This used to abort due to a loop bug on s390*.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -fPIC" { target s390*-*-* } } */
+
+extern void abort (void);
+
+int count = 0;
+char *str;
+
+void test (int flag)
+{
+  char *p;
+
+  for (;;)
+    {
+      if (count > 5)
+	return;
+
+      p = "test";
+
+      if (flag)
+	count++;
+
+      str = p;
+    }
+}
+
+int main (void)
+{
+  test (1);
+
+  if (str[0] != 't')
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-1.c
new file mode 100644
index 000000000..87cc1059f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-1.c
@@ -0,0 +1,19 @@
+/* Orgin: v.haisman@sh.cvut.cz
+   Reduced by: Wolfgang Bangerth <bangerth@dealii.org>
+   PR debug/12923  ICE in gen_subprogram_die with -O1 -g
+   The problem was that this just to ICE with -O1  -g.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -g" } */
+
+struct S {
+  unsigned n;
+};
+
+inline void foo (struct S * mx) {
+  mx->n = 1;
+}
+
+void bar () {
+  foo (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-2.c
new file mode 100644
index 000000000..497c963d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-2.c
@@ -0,0 +1,12 @@
+/* Orgin: Richard Sandiford <rsandifo@gcc.gnu.org> 
+   PR debug/12923  ICE in gen_subprogram_die with -O2 -g
+   The problem was that this just to ICE with -O2 -g.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+int f1 (int y)
+{
+  int f2() { return y; }
+  return f2();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-3.c
new file mode 100644
index 000000000..0bae456b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031218-3.c
@@ -0,0 +1,14 @@
+/* Orgin: Chris Demetriou <cgd@broadcom.com>
+   PR debug/12923  ICE in gen_subprogram_die with -O2 -g
+   The problem was that this just to ICE with -O2 -g.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+extern __SIZE_TYPE__ strlen (const char *);
+
+int x (char *s)
+{
+  int y () { return (strlen (s)); }
+  return y (s);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031222-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031222-1.c
new file mode 100644
index 000000000..b0d1a2dc4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031222-1.c
@@ -0,0 +1,18 @@
+/* PR c/9163 */
+/* The following test used to ICE after an error message in C99 mode
+   because GCC was trying to expand the tree to rtl.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+
+
+void f ()
+{
+	for (; int ; ); /* { dg-error "" } */
+}
+
+void foo ()
+{
+        while (int i); /* { dg-error "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20031223-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031223-1.c
new file mode 100644
index 000000000..c2f35fcfe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20031223-1.c
@@ -0,0 +1,13 @@
+/* PR c/11995 */
+/* The following test used to ICE after an error message
+   because GCC was trying to expand the trees to rtl.  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f ()
+{
+ l: int; /* { dg-error "a label can only be part of a statement and a declaration is not a statement" } */
+ /* { dg-warning "useless type name in empty declaration" "" { target *-*-* } 10 } */
+ /* { dg-error "label at end of compound statement" "" { target *-*-* } 10 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040123-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040123-1.c
new file mode 100644
index 000000000..2a73382dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040123-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler "abort" } } */
+
+extern void abort (void);
+extern char a[];
+
+void foo (void)
+{
+  if ((void *) a == (void *) 0x4000UL)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040127-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040127-1.c
new file mode 100644
index 000000000..0ea6062a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040127-1.c
@@ -0,0 +1,24 @@
+/* PR target/10904 */
+/* Origin: <kminola@eng.umd.edu> */
+
+/* Verify that the register allocator correctly aligns
+   floating-point registers on SPARC64.  */
+
+/* { dg-do assemble } */
+/* { dg-options "-O2" } */
+
+extern int foo1();
+extern int foo2();
+
+void foo(int n, int b)
+{
+  int i, a;
+
+  foo1();
+
+  a = (long)(b * ((double) 0.1));
+
+  for (i=0; i < n; i++) {
+    foo2(a);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040127-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040127-2.c
new file mode 100644
index 000000000..6e56dd8fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040127-2.c
@@ -0,0 +1,32 @@
+/* PR target/13058 */
+/* Origin: Lloyd Parkes <lloyd@must-have-coffee.gen.nz> */
+/* Reduced testcase by  Falk Hueffner <falk@debian.org> */
+
+/* Verify that the register allocator correctly aligns
+   floating-point registers on SPARC64.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+typedef struct { int ThumbnailSize; } ImageInfo_t;
+
+double ConvertAnyFormat(void)
+{
+  return 0;
+}
+
+void ProcessExifDir(ImageInfo_t *ImageInfoP, int NumDirEntries)
+{
+  unsigned int ThumbnailSize;
+
+  for (; NumDirEntries;) {
+    Get16u();
+    switch (NumDirEntries) {
+      case 0x0201:
+      case 0x0202:
+        ThumbnailSize = ConvertAnyFormat();
+    }
+  }
+
+  ImageInfoP->ThumbnailSize = ThumbnailSize;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040202-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040202-1.c
new file mode 100644
index 000000000..f0f4e7410
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040202-1.c
@@ -0,0 +1,8 @@
+/* PR middle-end/13325 */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+void *memcpy(void *dest, const void *src, __SIZE_TYPE__ n);
+void f (void *dest, const void *src) {
+    memcpy (dest, src, 0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040203-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040203-1.c
new file mode 100644
index 000000000..59c824ea4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040203-1.c
@@ -0,0 +1,17 @@
+/* PR/13994; bug_cond2 was rejected on gcc up to version 3.4.x */
+/* { dg-do compile  }*/
+/* { dg-options "-std=gnu89"  }*/
+
+struct s { char c[1]; };
+struct s a;
+
+int bug_if(void) { if (a.c) return 1; else return 0; }
+int bug_while(void) { while (a.c); }
+int bug_do_while(void) { do ; while (a.c); }
+int bug_for(void) { for ( ; a.c; ) ; }
+int bug_or(void) { return (a.c || 1); }
+int bug_and(void) { return (a.c && 1); }
+int bug_cond(void) { return (a.c ? 1 : 0); }
+char *bug_cond2(void) { return (a.c ? : 0); }
+int bug_not(void) { return !a.c; }
+int bug_bool(void) { return (_Bool) a.c; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040206-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040206-1.c
new file mode 100644
index 000000000..c9c776f0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040206-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -W -Wall" } */
+/*  PR c/13127
+    On the tree-ssa this used to warn about an anonymous
+    uninitialized variable.
+
+    The warning about "no return statement in function
+    returning non-void" is PR 13000. */
+
+static int foo (int a __attribute__((unused)) ) { } /* { dg-warning "no return statement" } */
+int main (void) { return foo (0); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040217-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040217-1.c
new file mode 100644
index 000000000..7ca7388fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040217-1.c
@@ -0,0 +1,19 @@
+/* This used to ICE on s390x due to a bug in simplify_if_then_else.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern void use (int);
+void test (void)
+{
+  union 
+   {
+     unsigned long ul;
+     signed char sc;
+   } u;
+
+  u.sc = 8;
+  u.sc &= 25;
+
+  use (u.sc);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040219-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040219-1.c
new file mode 100644
index 000000000..1a277d696
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040219-1.c
@@ -0,0 +1,74 @@
+/* Testing save/restore of floating point caller-save registers, on ia64
+   this resulted in bad code.  Not all targets will use caller-save regs.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -minline-float-divide-max-throughput" { target ia64-*-* } } */
+
+/* Testing save/restore of floating point caller-save registers on ia64.  */
+
+extern void abort (void);
+
+double foo(double a, double b, double c)
+{
+	return (a+b+c);
+}
+
+main ()
+{
+	double  f1, f2, f3, f4, f5, f6, f7, f8, f9,f10;
+	double f11,f12,f13,f14,f15,f16,f17,f18,f19,f20;
+	double f21,f22,f23,f24,f25,f26,f27,f28,f29,f30;
+	double x;
+	int i,j,k;
+
+	f1  = 0.1; f2  = 0.2; f3  = 0.3; f4  = 0.4; f5  = 0.5;
+	f6  = 0.6; f7  = 0.7; f8  = 0.8; f9  = 0.9; f10 = 1.0;
+	f11 = 1.1; f12 = 1.2; f13 = 1.3; f14 = 1.4; f15 = 1.5;
+	f16 = 1.6; f17 = 1.7; f18 = 1.8; f19 = 1.9; f20 = 2.0;
+	f21 = 2.1; f22 = 2.2; f23 = 2.3; f24 = 2.4; f25 = 2.5;
+	f26 = 2.6; f27 = 2.7; f28 = 2.8; f29 = 2.9; f30 = 3.0;
+
+	i = (int) foo(1.0,1.0,1.0);
+	while (i > 0) {
+		f1  = f2  / f3  * f30;
+		f2  = f3  / f4  * f30;
+		f3  = f4  / f5  * f30;
+		f4  = f5  / f6  * f30;
+		f5  = f6  / f7  * f30;
+		f6  = f7  / f8  * f30;
+		f7  = f8  / f9  * f30;
+		f8  = f9  / f10 * f30;
+		f9  = f10 / f11 * f30;
+		f10 = f11 / f12 * f30;
+		f11 = f12 / f13 * f30;
+		f12 = f13 / f14 * f25;
+		f13 = f14 / f15 * f30;
+		f14 = f15 / f16 * f30;
+		f15 = f16 / f17 * f30;
+		f16 = f17 / f18 * f30;
+		f17 = f18 / f19 * f30;
+		f18 = f19 / f20 * f30;
+		f19 = f20 / f21 * f30;
+		f20 = f21 / f22 * f20;
+		f21 = f22 / f23 * f30;
+		f22 = f23 / f24 * f30;
+		f23 = f24 / f25 * f30;
+		f24 = f25 / f26 * f30;
+		f25 = f26 / f27 * f30;
+		f26 = f27 / f28 * f30;
+		f27 = f28 / f29 * f30;
+		f28 = f29 / f30 * f30;
+		f29 = f30 / f1  * f30;
+		f30 = f1  / f2  * f30;
+		x = foo(f1,f2,f3);
+		i = i - 1;
+	}
+	x = (f1+f2+f3+f4+f5+f6+f7+f8+f9+f10) *
+            (f11+f12+f13+f14+f15+f16+f17+f18+f19+f20) *
+            (f21+f22+f23+f24+f25+f26+f27+f28+f29+f30);
+
+	/* Exact value is not needed, on IA64 it is massively off. */
+        if (x < 19503.0 || x > 19504.0) abort();
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040223-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040223-1.c
new file mode 100644
index 000000000..71ddf099e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040223-1.c
@@ -0,0 +1,41 @@
+/* GCC was not warning about taking the address of parameters or
+   fields of struct parameters when returning them.  */
+/* PR c/14156 */
+
+/* { dg-do compile  } */
+
+
+int * f( int a)
+{
+	return &a;/* { dg-warning "address" "" } */
+}
+
+int * g()
+{
+	int b = 0;
+	return &b;/* { dg-warning "address" "" } */
+}
+
+struct ll
+{
+  int i;
+};
+
+int *h(struct ll c)
+{
+  return &c.i;/* { dg-warning "address" "" } */
+}
+
+
+struct ll d;
+
+int *i()
+{
+  return &d.i;/* { dg-bogus "address" "" } */
+}
+
+
+int *j(struct ll *c)
+{
+  return &c->i; /* { dg-bogus "address" "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040305-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040305-2.c
new file mode 100644
index 000000000..ffaf353e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040305-2.c
@@ -0,0 +1,49 @@
+/* PR target/14262 */
+/* { dg-do run } */
+
+extern void abort (void);
+
+typedef char   ACS;
+typedef char   LSM;
+typedef char   PANEL;
+typedef char   DRIVE;
+typedef struct {
+    ACS             acs;
+    LSM             lsm;
+} LSMID;
+typedef struct {
+    LSMID           lsm_id;
+    PANEL           panel;
+} PANELID;
+typedef struct {
+    PANELID         panel_id;
+    DRIVE           drive;
+} DRIVEID;
+
+void sub (DRIVEID driveid)
+{
+  if (driveid.drive != 1)
+    abort ();
+  if (driveid.panel_id.panel != 2)
+    abort ();
+  if (driveid.panel_id.lsm_id.lsm != 3)
+    abort ();
+  if (driveid.panel_id.lsm_id.acs != 4)
+    abort ();
+}
+
+int main(void)
+{
+  DRIVEID driveid;
+
+  driveid.drive = 1;
+  driveid.panel_id.panel = 2;
+  driveid.panel_id.lsm_id.lsm = 3;
+  driveid.panel_id.lsm_id.acs = 4;
+
+  sub(driveid);
+
+  return 0;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040306-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040306-1.c
new file mode 100644
index 000000000..903d20ac2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040306-1.c
@@ -0,0 +1,22 @@
+/* This used to ICE due to a reload bug on s390*.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+
+typedef struct test
+{
+  unsigned short pad;
+  unsigned char type[6];
+} t;
+
+extern void set (t *a, t *b, t *c, t *d, t *e, t *f, t *g, t *h, 
+		 t *i, t *j, t *k, t *l, t *m, t *n, t *o, t *p);
+extern void use (t a, t b, t c, t d, t e, t f, t g, t h,
+		 t i, t j, t k, t l, t m, t n, t o, t p);
+void test (void)
+{
+    t a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
+    set (&a, &b, &c, &d, &e, &f, &g, &h, &i, &j, &k, &l, &m, &n, &o, &p);
+    use (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040309-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040309-1.c
new file mode 100644
index 000000000..736150731
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040309-1.c
@@ -0,0 +1,17 @@
+/* Test integer mod on ia64.  There was a bug in the inline integer
+   division code. */
+
+/* { dg-do run } */
+/* { dg-options "-minline-int-divide-max-throughput" { target ia64-*-* } } */
+
+extern void abort (void);
+
+volatile int i = 10;
+volatile int j = 10;
+
+int main()
+{
+        int k = i % j;
+        if (k != 0) abort();
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040310-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040310-1.c
new file mode 100644
index 000000000..104e98d08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040310-1.c
@@ -0,0 +1,34 @@
+/* This caused cc1 to segfault on s390x-ibm-linux
+   due to a bug in if_then_else_cond (combine.c).  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+extern void use (unsigned int x);
+
+int main (void)
+{
+  union 
+    {
+      unsigned int x;
+      unsigned long pad;
+    } A;
+
+  struct 
+    {
+      unsigned int x : 1;
+    } B;
+
+  A.x = 1;
+  B.x = 1;
+  A.x /= B.x;
+  use (A.x);
+
+  A.x = 1;
+  B.x = 1;
+  B.x /= A.x;
+  use (B.x);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040311-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040311-2.c
new file mode 100644
index 000000000..9dfbb9947
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040311-2.c
@@ -0,0 +1,36 @@
+/* PR target/14533 */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+void bar (char *, int);
+
+extern char b[];
+extern int d, e;
+struct S
+{
+  struct S *m;
+  int n;
+} **g;
+
+void
+foo (int x, char *y)
+{
+  struct S *h;
+  int k = 1, l;
+
+again:
+  for (h = *g; h != (struct S *) g; h = h->m)
+    {
+      if (k == 0 && h->n & 0x100000);
+      l = y - b;
+      if (e)
+        bar (b, l);
+      if (d)
+        bar (b, l);
+    }
+  if (k)
+    {
+      k = 0;
+      goto again;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040322-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040322-1.c
new file mode 100644
index 000000000..139511262
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040322-1.c
@@ -0,0 +1,4 @@
+/* PR c/14069 */
+/* { dg-do compile } */
+struct S { int a; char b[]; char *c; }; /* { dg-error "" "flexible array member not" } */
+struct S s = { .b = "foo", .c = .b }; /* { dg-error "" "parse error before" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040331-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040331-1.c
new file mode 100644
index 000000000..4cef3d329
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040331-1.c
@@ -0,0 +1,14 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fwrapv" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  struct { int count: 2; } s = { -2 };
+  while (s.count-- != -2)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040409-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040409-1.c
new file mode 100644
index 000000000..dc9206a0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040409-1.c
@@ -0,0 +1,4 @@
+/* This tests to make sure that the attribute noreturn 
+   can be used on function pointers. */
+
+int (*temp) (void) __attribute__((noreturn));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040609-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040609-1.c
new file mode 100644
index 000000000..ef181476e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040609-1.c
@@ -0,0 +1,73 @@
+/* PRs target/15569, rtl-optimization/15681 */
+/* { dg-do compile } */
+/* { dg-options "-Os -frename-registers" } */
+/* { dg-options "-mconstant-gp -Os -frename-registers" { target ia64-*-* } } */
+
+struct S { struct S *a, *b; };
+struct T { struct S e; unsigned long a; int b, c; void *d; } f;
+
+unsigned long f1 (unsigned long);
+void f2 (int, struct T *);
+void *f3 (void *);
+unsigned long volatile g;
+
+static void
+f4 (struct T *p)
+{
+  f1 (f1 (((unsigned long) g - p->a) >> 20));
+}
+
+static struct T *
+f5 (void)
+{
+  struct T *g, *p;
+  struct T *q = 0;
+  for (g = p = &f; (g = p = (struct T *) (g->e.a)) != &f;)
+    if (p->b)
+      {
+	f4 (p);
+	if (p->c & 0x80000)
+	  return p;
+      }
+  return q;
+}
+
+static void
+f6 (struct T *p)
+{
+  f2 (9, p);
+}
+
+static inline void *
+f7 (struct T *t)
+{
+  void *d;
+  d = t->d;
+  if (d)
+    d = f3 (d);
+  return d;
+}
+
+static void *
+f8 (struct T *p)
+{
+  void *d = f7 (p);
+  if (!d)
+    return 0;
+  f6 (p);
+  return d;
+}
+
+static void
+f9 (void)
+{
+  struct T *p;
+  p = f5 ();
+  f8 (p);
+}
+
+void
+test (void)
+{
+  f9 ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040622-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040622-2.c
new file mode 100644
index 000000000..0be320fa4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040622-2.c
@@ -0,0 +1,11 @@
+/* { dg-do link } */
+/* { dg-require-effective-target ptr32plus } */
+/* This validates codegen for [r1+32760] on Darwin. */
+void f(char x[32688], double *y, double *z) __attribute__((noinline));
+void f(char x[32688], double *y, double *z) {}
+main() {
+  char x[32688];
+  double y, z;
+  y = z = 3.0;
+  f(x, &y, &z);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040625-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040625-1.c
new file mode 100644
index 000000000..0a576a5b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040625-1.c
@@ -0,0 +1,37 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-mminimal-toc" { target { { powerpc*-*-* && lp64 } || { powerpc-ibm-aix* } } } } */
+
+extern void abort (void);
+extern void exit (int);
+
+double __attribute__((noinline))
+foo (void)
+{
+  return 16441577472.0;
+}
+
+double __attribute__((noinline))
+bar (double x)
+{
+  return x;
+}
+
+int __attribute__((noinline))
+test (void)
+{
+  double x = foo ();
+  x = bar (x);
+  x /= 1024L * 1024L * 1024L;
+  x *= 70;
+  x = x < 70 ? x : 70;
+  x += 30;
+  return x;
+}
+
+int main (void)
+{
+  if (test () != 100)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040627-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040627-1.c
new file mode 100644
index 000000000..2b4f09fef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040627-1.c
@@ -0,0 +1,42 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error (void);
+
+
+void test(int x)
+{
+  if ((x & ~x) != 0)
+    link_error ();
+  if ((~x & x) != 0)
+    link_error ();
+
+  if ((x ^ ~x) != -1)
+    link_error ();
+  if ((~x ^ x) != -1)
+    link_error ();
+
+  if ((x | ~x) != -1)
+    link_error ();
+  if ((~x | x) != -1)
+    link_error ();
+
+  if (x && !x)
+    link_error ();
+  if (!x && x)
+    link_error ();
+
+  if (!(x || !x))
+    link_error ();
+  if (!(!x || x))
+    link_error ();
+}
+
+int main()
+{
+  test (0);
+  test (1);
+  test (-1);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040813-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040813-1.c
new file mode 100644
index 000000000..fa01a5302
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040813-1.c
@@ -0,0 +1,15 @@
+/* Test lang in N_SO stab.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile } */
+/* { dg-skip-if "No stabs" { mmix-*-* *-*-aix* *-*-netware* alpha*-*-* hppa*64*-*-* ia64-*-* *-*-vxworks* } { "*" } { "" } } */
+/* { dg-options "-gstabs" } */
+
+int
+main ()
+{
+  return 0;
+}
+
+/* { dg-final { scan-assembler ".stabs.*100,0,2" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040910-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040910-1.c
new file mode 100644
index 000000000..ff772ab57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040910-1.c
@@ -0,0 +1,2 @@
+/* Tests error recovery for invalid code.  */
+__attribute__((foo)  int f (){} /* { dg-error "(parse error|syntax error|expected '\\)') before 'int'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040916-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040916-1.c
new file mode 100644
index 000000000..fbea9e385
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040916-1.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+/* PR17513 - we hit a bug where EDGE_EXECUTABLE was not cleared on
+   successors of the entry block.  This lead to a flow verification
+   error much later in the compilation (after gcse).  */
+typedef unsigned char uint8; 
+typedef unsigned int uint32; 
+ 
+uint32 marker = 0; 
+uint8 *buff = 0; 
+uint32 bsize = 0; 
+ 
+extern int foo (void); 
+ 
+uint32 
+bar (void) 
+{ 
+  int len, d; 
+ 
+  for (;;) 
+    { 
+      if (foo () == 0) 
+        return (0); 
+ 
+      switch (marker) 
+        { 
+        case 0xfe: 
+          { 
+            len |= (*buff++); 
+            bsize -= 2; 
+ 
+            while (len > 0) 
+              { 
+                d = *buff++; 
+                len--; 
+              } 
+          } 
+          break; 
+        default: 
+          break; 
+        } 
+    } 
+} 
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20040920-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040920-1.c
new file mode 100644
index 000000000..a38ff8889
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20040920-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+int bob;
+struct a
+{
+  int foo;
+};
+int main(void)
+{
+  struct a bar;
+  bob(5); /* { dg-error "called object 'bob' is not a function" } */
+  bar.foo(); /* { dg-error "called object 'bar.foo' is not a function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041014-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041014-1.c
new file mode 100644
index 000000000..699844074
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041014-1.c
@@ -0,0 +1,10 @@
+/* PR c/17023 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f(a, b)
+     int a;
+     int b[({ void h() {} 1; })];	/* { dg-error "braced-group" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041104-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041104-1.c
new file mode 100644
index 000000000..b4d359d1e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041104-1.c
@@ -0,0 +1,18 @@
+/* This testcase exposed the same bug as PR 15342.  */
+/* { dg-options "-O2 -frename-registers -fno-schedule-insns" } */
+
+void *memcpy (void *, const void *, __SIZE_TYPE__);
+
+void f (int n, int (*x)[4])
+{
+  while (n--)
+    {
+      int f = x[0][0];
+      if (f <= 0)
+	memcpy (&x[1], &x[0], sizeof (x[0]));
+      else
+	memcpy (&x[f], &x[0], sizeof (x[0]));
+      f = x[0][2];
+      x[0][1] = f;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041106-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041106-1.c
new file mode 100644
index 000000000..f83e835ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041106-1.c
@@ -0,0 +1,31 @@
+/* { dg-do run { target *-*-linux* *-*-solaris* } } */
+/* { dg-options -O2 } */
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+struct S { long x __attribute__((packed)); }; /* { dg-warning "attribute ignored" "" { target default_packed } } */
+volatile long sink;
+
+void foo (struct S *s)
+{
+  sink = s->x;
+}
+
+int main ()
+{
+  size_t ps = getpagesize ();
+  char *ptr, *page;
+  struct S *s;
+
+  ptr = malloc (3*ps);
+  page = (char *)(((size_t)ptr + (ps - 1)) & -ps);
+  munmap (page + ps, ps);
+
+  s = (struct S *)(page + ps - sizeof(struct S));
+  foo(s);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041122-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041122-1.c
new file mode 100644
index 000000000..2d9faccba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041122-1.c
@@ -0,0 +1,17 @@
+/* PR rtl-optimization/18611 */
+/* { dg-do compile } */
+/* { dg-options "-O1 -fmove-loop-invariants" } */
+typedef struct {
+	int channels_per_image;
+	int channel[8];
+} CineonImageInformation;
+void
+dumpCineonImageInfo(CineonImageInformation* imageInfo) {
+
+	int i;
+	for (i = 0; i < imageInfo->channels_per_image; ++i) {
+		dumpCineonChannelInfo(&imageInfo->channel[i]);
+	}
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041213-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041213-1.c
new file mode 100644
index 000000000..aeff7443c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041213-1.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-fshow-column" } */
+/* test redeclarations with void and implicit int */
+extern foo1(); /* { dg-message "8:note: previous declaration" } */
+extern void foo1(); /* { dg-error "13:conflicting types" } */
+
+extern void foo2(); /* { dg-message "13:note: previous declaration" } */
+extern foo2(); /* { dg-error "8:conflicting types" } */
+
+void foo3() {} /* { dg-message "6:note: previous definition" } */
+extern foo3(); /* { dg-error "8:conflicting types" } */
+
+extern foo4(); /* { dg-message "8:note: previous declaration" } */
+void foo4() {} /* { dg-error "6:conflicting types" } */
+
+extern void foo5(); /* { dg-message "13:note: previous declaration" } */
+foo5() {} /* { dg-warning "1:conflicting types" } */
+
+foo6() {} /* { dg-message "1:note: previous definition" } */
+extern void foo6(); /* { dg-error "13:conflicting types" } */
+
+foo7() {} /* { dg-message "1:note: previous definition" } */
+void foo7() {} /* { dg-error "6:conflicting types" } */
+
+void foo8() {} /* { dg-message "6:note: previous definition" } */
+foo8() {} /* { dg-error "1:conflicting types" } */
+
+int use9() { foo9(); } /* { dg-message "note: previous implicit declaration" } */
+extern void foo9(); /* { dg-warning "13:conflicting types" } */
+
+int use10() { foo10(); } /* { dg-message "note: previous implicit declaration" } */
+void foo10() {} /* { dg-warning "6:conflicting types" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041219-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041219-1.c
new file mode 100644
index 000000000..4fdc9540d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041219-1.c
@@ -0,0 +1,47 @@
+/* PR18191 Struct member is not getting default-initialized.
+   Origin: Grigory Zagorodnev  <grigory.zagorodnev@intel.com>  */
+
+/* { dg-do run } */
+
+extern int printf (__const char *__restrict __format, ...);
+
+typedef struct S {
+  const char* s;
+  int         i;
+} S;
+
+void
+foo (void)
+{
+  S dummy[2];
+  unsigned i;
+
+  /* Put some garbage on the stack.  */
+  for (i = 0; i < sizeof(dummy); i++)
+    ((char *)&dummy)[i] = -1;
+}
+
+int
+bar (void)
+{
+  /* Allocate object on the stack.  */
+  S obj[2] = { {"m0"}, {"m1"} };
+
+  /* Assume fields those not explicitly initialized
+     are default initialized to 0 [8.5.1/7 and 8.5/5].  */
+  if (obj[0].i == 0)
+    return 0;
+  else
+    {
+      printf("Failed: obj[0].i == '%d', expecting '0'\n", obj[0].i);
+      return 1;
+    }
+}
+
+int
+main (void)
+{
+  foo();
+  return bar();
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20041231-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041231-1.c
new file mode 100644
index 000000000..37c9fe04a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20041231-1.c
@@ -0,0 +1,15 @@
+/* PR17544 Incorrect -Wunreachable-code warning
+   Origin: Giovanni Bajo
+
+   In C99 we append a "return 0;" when finishing a function, but it was
+   not given a source location.  The gimplifier thinks a return statement
+   needs a locus so it would add one, making the compiler generated code
+   visible to the unreachable code warning.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -O -Wunreachable-code" } */
+
+int main (void)    // 1
+{                  // 2
+  return 0;        // 3
+}                  // 4
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050105-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050105-1.c
new file mode 100644
index 000000000..58a75150b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050105-1.c
@@ -0,0 +1,31 @@
+/* PR rtl-optimization/18861 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+int
+foo (int code)
+{
+  if (code >= 3)
+    switch (code)
+      {
+      case 3: return 4;
+      case 4: return 3;
+      case 5: return 6;
+      case 6: return 7;
+      case 7: return 8;
+      case 8: return 5;
+      default: abort ();
+      }
+  switch (code)
+    {
+    case 3: return 4;
+    case 4: return 3;
+    case 5: return 6;
+    case 6: return 7;
+    case 7: return 8;
+    case 8: return 5;
+    default: abort ();
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050105-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050105-2.c
new file mode 100644
index 000000000..02ac1596b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050105-2.c
@@ -0,0 +1,32 @@
+/* PR tree-optimization/18828 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+void foo (int x, ...)
+{
+  va_list ap;
+  if (x != 21)
+    abort ();
+  va_start (ap, x);
+  va_end (ap);
+}
+
+void bar (int x, ...)
+{
+  va_list ap;
+  x++;
+  va_start (ap, x);
+  va_end (ap);
+}
+
+void baz (int x, ...)
+{
+  va_list ap;
+  x = 0;
+  va_start (ap, x);
+  va_end (ap);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050111-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050111-1.c
new file mode 100644
index 000000000..7cf04e806
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050111-1.c
@@ -0,0 +1,21 @@
+/* PR middle-end/19084, rtl-optimization/19348 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -march=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+unsigned int
+foo (unsigned long long x)
+{
+  unsigned int u;
+
+  if (x == 0)
+    return 0;
+  u = (unsigned int) (x >> 32);
+  return u;
+}
+
+unsigned long long
+bar (unsigned short x)
+{
+  return (unsigned long long) x << 32;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050111-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050111-2.c
new file mode 100644
index 000000000..17e59ce96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050111-2.c
@@ -0,0 +1,21 @@
+/* PR rtl-optimization/15139 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -funroll-loops" } */
+
+void
+foo (double **a, double **z)
+{
+  long int i, j;
+  double d = -1.0;
+
+  for (i = 0; i < 6; i++)
+    for (j = 0; j < 5; j++)
+      d = z[i][j] > d ? z[i][j] : d;
+
+  for (i = 0; i < 6; i++)
+    for (j = 0; j < 5; j++)
+      z[i][j] /= d;
+
+  for (i = 0; i < 5; i++)
+    a[i][j] = z[i][j];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050121-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050121-1.c
new file mode 100644
index 000000000..3fe299a6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050121-1.c
@@ -0,0 +1,9 @@
+/* I accidentally broke this while developing a patch for PR 13000,
+   and didn't notice since the testsuite didn't catch it -- ian  */
+/* { dg-do-compile } */
+
+void foo()
+{
+  return;
+  break;	/* { dg-error "break statement not within" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050121-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050121-2.c
new file mode 100644
index 000000000..6a6092c90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050121-2.c
@@ -0,0 +1,67 @@
+/* PR middle-end/19551 */
+/* { dg-options "-O2" } */
+/* { dg-do link } */
+
+extern void abort ();
+
+#define T(type, name) \
+extern __attribute__((pure)) _Complex type	\
+foo_c##name (int x);				\
+						\
+void						\
+bar_c##name (type *x)				\
+{						\
+  type f = __real foo_c##name (5);		\
+  if (0) *x = f;				\
+}						\
+						\
+void						\
+baz_c##name (type *x)				\
+{						\
+  type f = __imag foo_c##name (5);		\
+  if (0) *x = f;				\
+}						\
+						\
+extern __attribute__((pure)) type		\
+foo_##name (int x);				\
+						\
+void						\
+bar_##name (type *x)				\
+{						\
+  type f = foo_##name (5);			\
+  if (0) *x = f;				\
+}
+
+typedef long double ldouble_t;
+typedef long long llong;
+
+T (float, float)
+T (double, double)
+T (long double, ldouble_t)
+T (char, char)
+T (short, short)
+T (int, int)
+T (long, long)
+T (long long, llong)
+#undef T
+
+int
+main (void)
+{
+#define T(type, name) \
+  {						\
+    type var = 0;				\
+    bar_c##name (&var);				\
+    baz_c##name (&var);				\
+    bar_##name (&var);				\
+  }
+  T (float, float)
+  T (double, double)
+  T (long double, ldouble_t)
+  T (char, char)
+  T (short, short)
+  T (int, int)
+  T (long, long)
+  T (long long, llong)
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050209-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050209-1.c
new file mode 100644
index 000000000..0a62ce351
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050209-1.c
@@ -0,0 +1,5 @@
+/* Test for infinite loop in parser error recovery.  From Serge
+   Belyshev <ssb> on IRC.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+int f() { return 1); } /* { dg-error "parse|syntax|expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050307-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050307-1.c
new file mode 100644
index 000000000..0e8dac69a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050307-1.c
@@ -0,0 +1,52 @@
+/* PR target/20322 */
+
+extern void abort (void);
+
+typedef unsigned long T;
+typedef struct
+{
+  T a, b;
+  unsigned char c, d;
+} S;
+
+#define M (sizeof (T) * 4)
+
+S __attribute__((noinline))
+foo (T x, T y)
+{
+  S e;
+  T f[2], g;
+
+  e.b = (x & (~(T) 0 >> M)) * (y & (~(T) 0 >> M));
+  e.a = (x >> M) * (y >> M);
+
+  f[0] = (x & (~(T) 0 >> M)) * (y >> M);
+  f[1] = (x >> M) * (y & (~(T) 0 >> M));
+
+  g = e.b;
+  e.b += (f[0] & (~(T) 0 >> M)) << M;
+  if (e.b < g)
+    e.a++;
+
+  g = e.b;
+  e.b += (f[1] & (~(T) 0 >> M)) << M;
+  if (e.b < g)
+    e.a++;
+
+  e.a += (f[0] >> M);
+  e.a += (f[1] >> M);
+  e.c = 1;
+  e.d = 0;
+
+  return e;
+}
+
+int
+main (void)
+{
+  T x = 1UL << (M * 2 - 1);
+  S y = foo (1, x);
+  if (y.a || y.b != x || y.c != 1 || y.d)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050309-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050309-1.c
new file mode 100644
index 000000000..545cdb168
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050309-1.c
@@ -0,0 +1,38 @@
+/* This caused an ICE on s390 due to incorrect secondary
+   output reloads.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprofile-generate" } */
+
+char *
+test(char *ret, int *counter, void *schema,
+     const char* name, const char *namespace,
+     void *node, int topLevel)
+{
+  char buf[30];
+  int val;
+
+  if (counter == 0) return 0;
+  if (schema == 0) return 0;
+  if (name == 0) return 0;
+
+  __builtin_memset (ret, 0, 100);
+  lookup (schema, name, -1);
+  val = hash (schema, name, namespace, name, ret);
+  if (val == 0) return ret;
+
+  if (topLevel != 0)
+    {
+      error (1, 0, 0, node, "%s", name);
+      return 0;
+    }
+
+  __snprintf_chk (buf, 29, 1, 30, "#eCont %d", ++*counter);
+  val = hash (schema, name, buf, namespace, ret);
+  if (val == 0) return ret;
+
+  error (1, 0, 0, node, "%s", name);
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050321-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050321-1.c
new file mode 100644
index 000000000..79f62a326
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050321-1.c
@@ -0,0 +1,26 @@
+/* This caused an ICE on powerpc-linux-gnu due to not 
+   up-to-date life info (PR middle-end/20177).  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fmodulo-sched" } */
+extern void * malloc (__SIZE_TYPE__);
+
+struct s {
+    int k;
+};
+
+int n;
+struct s *a1, *(*use)[];
+float (*vector)[];
+
+void
+foo (float *V)
+{
+  int i, used = 0;
+
+  vector = malloc (i * sizeof (float));
+  while ((*use)[used] != a1)
+    used += 1;
+  for (i = 0; i < n; i++)
+    *V += (*vector)[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050321-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050321-2.c
new file mode 100644
index 000000000..1c5575bde
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050321-2.c
@@ -0,0 +1,55 @@
+/* This testcase could not assemble on ppc32, because the compiler assumed
+   the huge ADDR_DIFF_VEC will be emitted into rodata section, yet because
+   of some notes inserted between jump table's CODE_LABEL and the jump table
+   it ended up in the .text section and thus shorten_branches couldn't
+   figure out branch to lab is too far.  */
+/* { dg-do link { target fpic } } */
+/* { dg-options "-g1 -fpic" } */
+/* { dg-require-effective-target int32plus } */
+
+#define A(n) \
+  case n##1: return n##1 * 131 + 63;	\
+  case n##3: return n##3 * 1231 + 182;	\
+  case n##5: return n##5 * 351 + 1;	\
+  case n##7: return n##7 * 312 + 61;	\
+  case n##9: return n##9 * 17 - 1;
+#define B(n) \
+A(n##0) A(n##1) A(n##2) A(n##3) A(n##4) \
+A(n##5) A(n##6) A(n##7) A(n##8) A(n##9)
+#define C(n) \
+B(n##0) B(n##1) B(n##2) B(n##3) B(n##4) \
+B(n##5) B(n##6) B(n##7) B(n##8) B(n##9)
+#define D(n) \
+C(n##0) C(n##1) B(n##20) B(n##21) B(n##22)
+      
+int
+foo (int x)
+{
+  {
+lab:;
+    int a = x;
+    while (a < 60000)
+      {
+        int b = a;
+        {
+          int c = b;
+          switch (c)
+            {
+              D(1)
+              default: break;
+            }
+        }
+        a += 10000;
+        if (a == 4168)
+          goto lab;
+      }
+  }
+  return x;
+}
+
+int
+main (void)
+{
+  foo (71);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050325-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050325-1.c
new file mode 100644
index 000000000..b58cb5b47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050325-1.c
@@ -0,0 +1,21 @@
+/* PR 20249 */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprofile-arcs" } */
+
+extern int *g (int x, void* y);
+extern void fg (long long x, int y);
+
+static void
+ff (int y, long long z)
+{
+  fg (z, 1);
+}
+
+void
+f ()
+{
+  g (42, ff);
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050330-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050330-1.c
new file mode 100644
index 000000000..69b5f9dcf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050330-1.c
@@ -0,0 +1,14 @@
+/* This test is a reduced test case for a bug that caused 
+   ICE while bootstrapping with -fmodulo-sched on powerpc-apple-darwin
+   related to (PR middle-end/20177).  */
+ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -fmodulo-sched" } */
+
+void  
+foo ( const char *bytes, int len , char *buf)
+{
+  int i;
+  for ( i = 0; i < len; ++i )
+    buf[i] = bytes[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050330-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050330-2.c
new file mode 100644
index 000000000..7a1d343fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050330-2.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprofile-generate" } */
+
+struct S
+{
+  int a;
+  void **b;
+};
+
+void
+foo (struct S *x, int y)
+{
+  if (!x)
+    return;
+  if (y >= x->a)
+    return;
+  x->a--;
+  for (; y < x->a; y++)
+    x->b[y] = x->b[y + 1];
+  x->b[x->a] = (void *) 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050503-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050503-1.c
new file mode 100644
index 000000000..7a198f85e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050503-1.c
@@ -0,0 +1,51 @@
+/* PR middle-end/21265
+   Test whether tail call information is propagated through builtin
+   expanders.  */
+/* { dg-do compile } */
+/* { dg-skip-if "" { { i?86-*-* x86_64-*-* } && { ilp32 && { ! nonpic } } } { "*" } { "" } } */
+/* { dg-options "-O2 -minline-compares" { target { i?86-*-* || x86_64-*-* } } } */
+/* { dg-options "-O2" { target {! { i?86-*-* || x86_64-*-* } } } } */
+
+typedef __SIZE_TYPE__ size_t;
+
+#define F(n, rettype, name, args, callargs) \
+extern rettype name args;				\
+rettype test##n args					\
+{							\
+  return name callargs;					\
+}
+#define F1(n, rettype, name, t1, callargs) \
+  F (n, rettype, name, (t1 a1), callargs)
+#define F2(n, rettype, name, t1, t2, callargs) \
+  F (n, rettype, name, (t1 a1, t2 a2), callargs)
+#define F3(n, rettype, name, t1, t2, t3, callargs) \
+  F (n, rettype, name, (t1 a1, t2 a2, t3 a3), callargs)
+
+F3 (1a, void *, memcpy, void *, const void *, size_t, (a1, a2, a3))
+F3 (1b, void *, memcpy, void *, const void *, size_t, (a1, a2, 10))
+F3 (2a, void *, mempcpy, void *, const void *, size_t, (a1, a2, a3))
+F3 (2b, void *, mempcpy, void *, const void *, size_t, (a1, a2, 10))
+F3 (3a, void *, memmove, void *, const void *, size_t, (a1, a2, a3))
+F3 (3b, void *, memmove, void *, const void *, size_t, (a1, "abcdefghijklmno", a3))
+F3 (4a, void *, memset, void *, int, size_t, (a1, a2, a3))
+F3 (4b, void *, memset, void *, int, size_t, (a1, a2, 156))
+F3 (4c, void *, memset, void *, int, size_t, (a1, 0, a3))
+F3 (4d, void *, memset, void *, int, size_t, (a1, 0, 10000))
+F3 (5a, int, memcmp, const void *, const void *, size_t, (a1, a2, a3))
+F3 (5b, int, memcmp, const void *, const void *, size_t, (a1, "abcdefghijkl", a3))
+F2 (6, char *, strcpy, char *, const char *, (a1, a2))
+F2 (7, char *, stpcpy, char *, const char *, (a1, a2))
+F3 (8, char *, strncpy, char *, const char *, size_t, (a1, a2, a3))
+F3 (9, char *, stpncpy, char *, const char *, size_t, (a1, a2, a3))
+F2 (10, char *, strcat, char *, const char *, (a1, a2))
+F3 (11, char *, strncat, char *, const char *, size_t, (a1, a2, a3))
+F1 (12a, size_t, strlen, const char *, (a1))
+F1 (12b, size_t, strlen, const char *, ("foobar"))
+F2 (13a, int, strcmp, const char *, const char *, (a1, a2))
+F2 (13b, int, strcmp, const char *, const char *, (a1, "abcdefghijklm"))
+F3 (14a, int, strncmp, const char *, const char *, size_t, (a1, a2, a3))
+F3 (14b, int, strncmp, const char *, const char *, size_t, (a1, "abcdefghijklm", 10))
+F2 (15, char *, strchr, const char *, int, (a1, a2))
+
+/* All the calls above should be tail call optimized on i?86/x86-64.  */
+/* { dg-final { scan-assembler-not "call" { target i?86-*-linux* x86_64-*-linux* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050517-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050517-1.c
new file mode 100644
index 000000000..856fda206
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050517-1.c
@@ -0,0 +1,8 @@
+/* Tree PRE is going to transform this so that it doesn't call cos on the 
+   d = 0 path, and in doing so, it needs to regenerate the cos call.
+   This was ICE'ing due to an overly strict check on what it knew how
+   to regenerate.   */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+double cos(double);
+double f(double d, double i, int j) { if (j == 1) d = 0; return d * cos(i); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050527-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050527-1.c
new file mode 100644
index 000000000..1b3232447
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050527-1.c
@@ -0,0 +1,55 @@
+/* PR c/21536 */
+/* { dg-do run } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void *malloc (size_t);
+extern void free (void *);
+
+void *
+foo (int x, int y)
+{
+  void *d = malloc (x * y * sizeof (double));
+  double (*e)[x][y] = d;
+  x += 10;
+  y += 10;
+  if (x > 18)
+    (*e)[x - 12][y - 12] = 0.0;
+  else
+    (*e)[x - 11][y - 11] = 1.0;
+  return d;
+}
+
+void *
+bar (int x, int y)
+{
+  void *d = malloc (x * y * sizeof (double));
+  struct S
+    {
+      double (*e)[x][y];
+      double (*f)[x][y];
+    } s;
+  s.e = d;
+  s.f = d;
+  x += 10;
+  y += 10;
+  if (x > 18)
+    (*s.e)[x - 12][y - 12] = 0.0;
+  else
+    (*s.e)[x - 11][y - 11] = 1.0;
+  if (x > 16)
+    (*s.f)[x - 13][y - 13] = 0.0;
+  else
+    (*s.f)[x - 14][y - 14] = 1.0;
+  return d;
+}
+
+int
+main ()
+{
+  void *d1 = foo (10, 10);
+  void *d2 = bar (10, 10);
+  free (d1);
+  free (d2);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050603-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050603-2.c
new file mode 100644
index 000000000..363e3cdf3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050603-2.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+#include <stdlib.h>
+struct s {
+  unsigned short f: 16;
+  unsigned short y: 8;
+  unsigned short g: 2;
+  unsigned int x;
+};
+
+void set (struct s*, int) __attribute__((noinline));
+void set (struct s* p, int flags) {
+  p->g = flags << 1;
+}
+main() {
+  struct s foo = {0 , 0, 3, 0};
+  set (&foo, -1);
+  if (foo.g != 2)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050607-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050607-1.c
new file mode 100644
index 000000000..83c096748
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050607-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target trampolines } */
+/* { dg-options "-Wpadded" }
+/* The struct internally constructed for the nested function should
+   not result in a warning from -Wpadded. */
+extern int baz(int (*) (int));
+int foo(void)
+{
+  int k = 3;
+  int bar(int x) {
+    return x + k;
+  }
+  return baz(bar);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050620-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050620-1.c
new file mode 100644
index 000000000..befdd9636
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050620-1.c
@@ -0,0 +1,15 @@
+/* PR middle-end/22028 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+foo (void)
+{
+  struct { int i[]; } u;	/* { dg-error "flexible array member" } */
+}
+
+void
+bar (void)
+{
+  struct { struct a b; } c;	/* { dg-error "has incomplete type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050629-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050629-1.c
new file mode 100644
index 000000000..0dd47f702
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050629-1.c
@@ -0,0 +1,297 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -w" } */
+
+/* This file was automatically reduced from tree-ssa-operands.c.  It
+   contains many warnings, but it exposes a copy propagation bug that
+   is somewhat difficult to reproduce otherwise.  */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+  extern void fancy_abort (const char *, int, const char *) __attribute__ ((__noreturn__));
+  typedef union tree_node *tree;
+  enum tree_code {
+ TREE_LIST, ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, STRING_CST, LT_EXPR, GE_EXPR, LABEL_EXPR, ASM_EXPR, SSA_NAME, };
+  enum tree_code_class {
+   tcc_type,   tcc_reference,   tcc_expression };
+  extern const enum tree_code_class tree_code_type[];
+  extern const unsigned char tree_code_length[];
+  struct tree_common {
+   union tree_ann_d *ann;
+   __extension__ enum tree_code code : 8;
+ };
+  struct tree_string {
+   char str[1];
+ };
+  struct tree_list {
+   tree purpose;
+   tree value;
+ };
+  struct tree_exp {
+   tree     operands[1];
+ };
+  typedef struct ssa_use_operand_d {
+   struct ssa_use_operand_d* prev;
+   struct ssa_use_operand_d* next;
+   tree stmt;
+   tree * use;
+ }
+  ssa_use_operand_t;
+  struct tree_ssa_name {
+   struct ssa_use_operand_d imm_uses;
+ };
+  union tree_node {
+   struct tree_common common;
+   struct tree_string string;
+   struct tree_list list;
+   struct tree_exp exp;
+   struct tree_ssa_name ssa_name;
+ };
+  typedef struct bitmap_head_def *bitmap;
+  typedef union varray_data_tag {
+   char c[1];
+   int i[1];
+   tree * tp[1];
+ }
+  varray_data;
+  struct varray_head_tag {
+   size_t num_elements;
+   size_t elements_used;
+   varray_data data;
+ };
+  typedef struct varray_head_tag *varray_type;
+  extern void varray_check_failed (varray_type, size_t, const char *, int,      const char *) __attribute__ ((__noreturn__));
+  typedef ssa_use_operand_t *use_operand_p;
+  struct use_optype_d {
+   struct use_optype_d *next;
+   struct ssa_use_operand_d use_ptr;
+ };
+  typedef struct use_optype_d *use_optype_p;
+  struct ssa_operand_memory_d {
+   char mem[(2048 - sizeof (void *))];
+ };
+  struct stmt_operands_d {
+   struct use_optype_d * use_ops;
+ };
+  struct ptr_info_def {
+   tree name_mem_tag;
+ };
+  typedef struct subvar *subvar_t;
+  struct var_ann_d {
+   size_t uid;
+ };
+  struct stmt_ann_d {
+   unsigned modified : 1;
+   struct stmt_operands_d operands;
+   bitmap addresses_taken;
+ };
+  typedef struct var_ann_d *var_ann_t;
+  typedef struct stmt_ann_d *stmt_ann_t;
+  static __inline__ var_ann_t var_ann (tree t) {
+ }
+  static __inline__ stmt_ann_t stmt_ann (tree t) {
+   ((void)(!(is_gimple_stmt (t)) ? fancy_abort ("/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-flow-inline.h", 55, __FUNCTION__), 0 : 0));
+   return (stmt_ann_t) t->common.ann;
+ }
+  static __inline__ unsigned char stmt_modified_p (tree t) {
+   stmt_ann_t ann = stmt_ann (t);
+   return ann ? ann->modified : 1;
+ }
+  static __inline__ void delink_imm_use (ssa_use_operand_t *linknode) {
+   if (linknode->prev == ((void *)0))     return;
+   linknode->prev->next = linknode->next;
+   linknode->next->prev = linknode->prev;
+   linknode->prev = ((void *)0);
+   linknode->next = ((void *)0);
+ }
+  static __inline__ void link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list) {
+   linknode->prev = list;
+   linknode->next = list->next;
+   list->next = linknode;
+ }
+  static __inline__ void link_imm_use (ssa_use_operand_t *linknode, tree def) {
+   ssa_use_operand_t *root;
+   if (!def || ((enum tree_code) (def)->common.code) != SSA_NAME)     linknode->prev = ((void *)0);
+   else     {
+       root = &(__extension__ ({ const tree __t = (def); if (((enum tree_code) (__t)->common.code) != (SSA_NAME)) tree_check_failed (__t, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-flow-inline.h", 222, __FUNCTION__, (SSA_NAME), 0); __t; }
+)->ssa_name.imm_uses);
+       link_imm_use_to_list (linknode, root);
+     }
+ }
+  static __inline__ void link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, tree stmt) {
+     link_imm_use (linknode, def);
+ }
+  struct ggc_root_tab {
+ };
+  struct opbuild_list_d {
+   varray_type vars;
+   varray_type uid;
+   varray_type next;
+   int first;
+   unsigned num;
+ };
+  static struct opbuild_list_d build_uses;
+  static struct opbuild_list_d build_v_may_defs;
+  static struct ssa_operand_memory_d *operand_memory = ((void *)0);
+  static unsigned operand_memory_index;
+  static use_optype_p free_uses = ((void *)0);
+  static __inline__ int opbuild_next (struct opbuild_list_d *list, int prev) {
+   return __extension__ (*({
+ varray_type const _va = (list->next);
+ const size_t _n = (prev);
+ if (_n >= _va->num_elements) varray_check_failed (_va, _n, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 323, __FUNCTION__);
+ &_va->data.i[_n];
+ }
+));
+ }
+  static __inline__ tree * opbuild_elem_real (struct opbuild_list_d *list, int elem) {
+   return __extension__ (*({
+ varray_type const _va = (list->vars);
+ const size_t _n = (elem);
+ if (_n >= _va->num_elements) varray_check_failed (_va, _n, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 332, __FUNCTION__);
+ &_va->data.tp[_n];
+ }
+));
+ }
+  static __inline__ void opbuild_clear (struct opbuild_list_d *list) {
+   ((list->vars)->elements_used = 0);
+   ((list->next)->elements_used = 0);
+ }
+  static __inline__ void * ssa_operand_alloc (unsigned size) {
+   char *ptr;
+   if (operand_memory_index + size >= (2048 - sizeof (void *)))     {
+       ptr = ggc_alloc_stat (sizeof (struct ssa_operand_memory_d) );
+     }
+   ptr = &(operand_memory->mem[operand_memory_index]);
+   return ptr;
+ }
+  static __inline__ void correct_use_link (use_operand_p ptr, tree stmt) {
+   use_operand_p prev;
+   tree root;
+   prev = ptr->prev;
+   if (prev)     {
+       unsigned char stmt_mod = 1;
+       while (stmt_mod)  {    while (prev->stmt == stmt || prev->stmt == ((void *)0))      prev = prev->prev;    if (prev->use == ((void *)0))      stmt_mod = 0;    else      if ((stmt_mod = stmt_modified_p (prev->stmt)))        prev = prev->prev;  }
+       if (prev->use == ((void *)0))  root = prev->stmt;
+       else  root = *(prev->use);
+       if (root == *(ptr->use))  return;
+     }
+   delink_imm_use (ptr);
+   link_imm_use (ptr, *(ptr->use));
+ }
+  static __inline__ struct use_optype_d * alloc_use (void) {
+   struct use_optype_d *ret;
+     {
+       free_uses = free_uses->next;
+     }
+     ret = (struct use_optype_d *)ssa_operand_alloc (sizeof (struct use_optype_d));
+   return ret;
+ }
+  static __inline__ void finalize_ssa_use_ops (tree stmt) {
+   int new_i;
+   struct use_optype_d *old_ops, *ptr, *last;
+   tree * old_base;
+   struct use_optype_d new_list;
+   last = &new_list;
+   if (old_ops)     old_base = ((old_ops)->use_ptr.use);
+   while (old_ops && new_i != -1)     {
+       tree * new_base = opbuild_elem_real (&build_uses, (new_i));
+       if (old_base == new_base)         {    last->next = old_ops;    last = old_ops;    correct_use_link ((&((last)->use_ptr)), stmt);    old_ops = old_ops->next;    new_i = opbuild_next (&build_uses, new_i);  }
+       else         if (old_base < new_base)    {      use_operand_p use_p = (&((old_ops)->use_ptr));      delink_imm_use (use_p);      old_ops = old_ops->next;      ptr->next = free_uses;    }
+  else    {      ptr = alloc_use ();      (ptr)->use_ptr.use = (opbuild_elem_real (&build_uses, (new_i))); link_imm_use_stmt (&((ptr)->use_ptr), *(opbuild_elem_real (&build_uses, (new_i))), (stmt));      new_i = opbuild_next (&build_uses, new_i);    }
+       if (old_ops)         old_base = ((old_ops)->use_ptr.use);
+     }
+   for ( ;
+  new_i != -1;
+  new_i = opbuild_next (&build_uses, new_i))     {
+       ptr = alloc_use ();
+       (ptr)->use_ptr.use = (opbuild_elem_real (&build_uses, (new_i)));
+ link_imm_use_stmt (&((ptr)->use_ptr), *(opbuild_elem_real (&build_uses, (new_i))), (stmt));
+     }
+     {
+  {    use_operand_p use_p = (&((ptr)->use_ptr));    delink_imm_use (use_p);  }
+     }
+   (stmt_ann (stmt)->operands.use_ops) = new_list.next;
+   {
+     unsigned x = 0;
+     for (ptr = (stmt_ann (stmt)->operands.use_ops);
+ ptr;
+ ptr = ptr->next)       x++;
+   }
+ }
+  finalize_ssa_uses (tree stmt) {
+   {
+     unsigned x;
+       ((void)(!(*(opbuild_elem_real (&build_uses, x)) != stmt) ? fancy_abort ("/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 581, __FUNCTION__), 0 : 0));
+   }
+   finalize_ssa_use_ops (stmt);
+   opbuild_clear (&build_uses);
+ }
+  finalize_ssa_v_may_def_ops (tree stmt) {
+   int new_i;
+     {
+     }
+   for ( ;
+  new_i != -1;
+  new_i = opbuild_next (&build_v_may_defs, new_i))     {
+     }
+   {
+   }
+ }
+  get_expr_operands (tree stmt, tree *expr_p, int flags) {
+   enum tree_code code;
+   tree expr = *expr_p;
+     {
+       {  subvar_t svars;  if (var_can_have_subvars (expr)      && (svars = get_subvars_for_var (expr)))    {    }    {    }       }
+       {    {      if (code == LT_EXPR   || code == GE_EXPR)        {   swap_tree_operands (stmt,         &__extension__ (*({const tree __t = __extension__ ({ const tree __t = (expr); char const __c = tree_code_type[(int) (((enum tree_code) (__t)->common.code))]; if (!((__c) >= tcc_reference && (__c) <= tcc_expression)) tree_class_check_failed (__t, tcc_expression, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1435, __FUNCTION__); __t; }); const int __i = (0); if (__i < 0 || __i >= tree_code_length[(int) (((enum tree_code) (__t)->common.code))]) tree_operand_check_failed (__i, ((enum tree_code) (__t)->common.code), "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1435, __FUNCTION__); &__t->exp.operands[__i]; })),         &__extension__ (*({const tree __t = __extension__ ({ const tree __t = (expr); char const __c = tree_code_type[(int) (((enum tree_code) (__t)->common.code))]; if (!((__c) >= tcc_reference && (__c) <= tcc_expression)) tree_class_check_failed (__t, tcc_expression, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1436, __FUNCTION__); __t; }); const int __i = (1); if (__i < 0 || __i >= tree_code_length[(int) (((enum tree_code) (__t)->common.code))]) tree_operand_check_failed (__i, ((enum tree_code) (__t)->common.code), "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1436, __FUNCTION__); &__t->exp.operands[__i]; })));        }        {        }    }       }
+     }
+ }
+  get_asm_expr_operands (tree stmt) {
+   int noutputs = list_length (__extension__ (*({
+const tree __t = __extension__ ({ const tree __t = (__extension__ ({ const tree __t = (stmt); if (((enum tree_code) (__t)->common.code) != (ASM_EXPR)) tree_check_failed (__t, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1495, __FUNCTION__, (ASM_EXPR), 0); __t; })); char const __c = tree_code_type[(int) (((enum tree_code) (__t)->common.code))]; if (!((__c) >= tcc_reference && (__c) <= tcc_expression)) tree_class_check_failed (__t, tcc_expression, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1495, __FUNCTION__); __t; }
+);
+ const int __i = (1);
+ if (__i < 0 || __i >= tree_code_length[(int) (((enum tree_code) (__t)->common.code))]) tree_operand_check_failed (__i, ((enum tree_code) (__t)->common.code), "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1495, __FUNCTION__);
+ &__t->exp.operands[__i];
+ }
+)));
+   const char **oconstraints     = (const char **) __builtin_alloca((noutputs) * sizeof (const char *));
+   int i;
+   tree link;
+   const char *constraint;
+   unsigned char allows_mem, allows_reg, is_inout;
+     {
+       oconstraints[i] = constraint  = ((const char *)(__extension__ ({ const tree __t = ((__extension__ ({ const tree __t = ((__extension__ ({ const tree __t = (link); if (((enum tree_code) (__t)->common.code) != (TREE_LIST)) tree_check_failed (__t, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1506, __FUNCTION__, (TREE_LIST), 0); __t; })->list.purpose)); if (((enum tree_code) (__t)->common.code) != (TREE_LIST)) tree_check_failed (__t, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1506, __FUNCTION__, (TREE_LIST), 0); __t; })->list.value)); if (((enum tree_code) (__t)->common.code) != (STRING_CST)) tree_check_failed (__t, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1506, __FUNCTION__, (STRING_CST), 0); __t; }
+)->string.str));
+       parse_output_constraint (&constraint, i, 0, 0,    &allows_mem, &allows_reg, &is_inout);
+       }
+ }
+  get_indirect_ref_operands (tree stmt, tree expr, int flags) {
+   tree *pptr = &__extension__ (*({
+const tree __t = __extension__ ({ const tree __t = (expr); char const __c = tree_code_type[(int) (((enum tree_code) (__t)->common.code))]; if (!((__c) >= tcc_reference && (__c) <= tcc_expression)) tree_class_check_failed (__t, tcc_expression, "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1591, __FUNCTION__); __t; }
+);
+ const int __i = (0);
+ if (__i < 0 || __i >= tree_code_length[(int) (((enum tree_code) (__t)->common.code))]) tree_operand_check_failed (__i, ((enum tree_code) (__t)->common.code), "/home/cygnus/dnovillo/gcc/src.ppc64/gcc/tree-ssa-operands.c", 1591, __FUNCTION__);
+ &__t->exp.operands[__i];
+ }
+));
+   tree ptr = *pptr;
+     {
+       struct ptr_info_def *pi = ((void *)0);
+       if (((enum tree_code) (ptr)->common.code) == SSA_NAME    && pi->name_mem_tag)  {  }
+     }
+ }
+  note_addressable (tree var, stmt_ann_t s_ann) {
+   subvar_t svars;
+     {
+       if (var_can_have_subvars (var)    && (svars = get_subvars_for_var (var)))  bitmap_set_bit (s_ann->addresses_taken, var_ann (var)->uid);
+     }
+ }
+  const struct ggc_root_tab gt_ggc_r_gt_tree_ssa_operands_h[] = {
+   {
+     &operand_memory,   }
+,   {
+   }
+,   {
+   }
+,   {
+   }
+, };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050702-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050702-1.c
new file mode 100644
index 000000000..ce151d361
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050702-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* We going into an infinite loop in fold because we
+    were mishandling the return value of 
+    fold_to_nonsharp_ineq_using_bound. */
+_Bool f();
+void g(int);
+void h (int old_size)
+{
+   int new_size = old_size, i;
+   g(old_size - 1);
+   i = 0;
+   while (i < old_size - 1)
+   {
+     if (f())
+     {
+       i++;
+       continue;
+     }
+     while (i < old_size - 1)
+       i++;
+   }
+   g(new_size);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050811-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050811-1.c
new file mode 100644
index 000000000..a9f860bb8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050811-1.c
@@ -0,0 +1,20 @@
+/* Test whether -dv -fdump-rtl-all doesn't crash.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -dv -fdump-rtl-all" } */
+
+int foo (void)
+{
+  return 6;
+}
+
+int bar (int x)
+{
+  if (x < 0)
+    return foo () + 8;
+  else if (x > 0)
+    return 2 * foo ();
+  else
+    return foo ();
+}
+
+// { dg-final { cleanup-rtl-dump "*" } }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050811-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050811-2.c
new file mode 100644
index 000000000..ffd1f3904
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050811-2.c
@@ -0,0 +1,20 @@
+/* Test whether -dov doesn't crash.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -dv -fdump-rtl-postreload" } */
+
+int foo (void)
+{
+  return 6;
+}
+
+int bar (int x)
+{
+  if (x < 0)
+    return foo () + 8;
+  else if (x > 0)
+    return 2 * foo ();
+  else
+    return foo ();
+}
+
+// { dg-final { cleanup-rtl-dump "postreload*" } }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050826-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050826-1.c
new file mode 100644
index 000000000..9101fb022
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050826-1.c
@@ -0,0 +1,46 @@
+/* Test whether strncmp has not been "optimized" into memcmp
+   nor any code with memcmp semantics.  */
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* ia64-*-linux* alpha*-*-linux* powerpc*-*-linux* s390*-*-linux* sparc*-*-linux* *-*-darwin* } } */
+/* { dg-options "-O2" } */
+#include <stddef.h>
+#include <stdio.h>
+#include <sys/mman.h>
+/* Darwin spells this differently */
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+#include <stdlib.h>
+
+    struct Flags {
+ int filler[18];
+ unsigned int a:14;
+ unsigned int b:14;
+ unsigned int c:1;
+ unsigned int d:1;
+ unsigned int e:1;
+ unsigned int f:1;
+    };
+static void __attribute__((noinline)) set (struct Flags *);
+static void set (struct Flags *fp)
+{
+  fp->b = 5;
+  fp->d = 1;
+}
+
+static int __attribute__((noinline)) bar (int);
+static int bar(int x) { return !(x==1); }
+int main (void)
+{
+  char *p = mmap (NULL, 131072, PROT_READ | PROT_WRITE,
+                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  struct Flags *fp;
+  if (p == MAP_FAILED)
+    return 0;
+  if (munmap (p + 65536, 65536) < 0)
+    return 0;
+  fp = (struct Flags*)(p + 65536 - sizeof(struct Flags));
+  set(fp);
+  if (fp->b > 0)
+    return (bar(fp->d));
+  return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050922-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050922-1.c
new file mode 100644
index 000000000..ed5a3c63e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050922-1.c
@@ -0,0 +1,47 @@
+/* This revealed a bug when rotates are expanded into
+   two shifts.  */
+
+/* { dg-do run } */
+/* { dg-options "-O1 -std=c99" } */
+
+#include <stdlib.h>
+
+#if __INT_MAX__ == 2147483647
+typedef unsigned int uint32_t;
+#elif __LONG_MAX__ == 2147483647
+typedef unsigned long uint32_t;
+#else
+#error unable to find 32-bit integer type
+#endif
+
+uint32_t
+f (uint32_t *S, int j)
+{
+  uint32_t A, B, k, L[2] = {1234, 5678};
+  int i, m;
+
+  A = B = 0;
+  for (i = 0; i < j; i++)
+    {
+      k = (S[i] + A + B) & 0xffffffffL;
+      A = S[i] =
+      ((k << (3 & 0x1f)) | ((k & 0xffffffff) >> (32 - (3 & 0x1f)))); 
+
+      m = (int) (A + B);
+      k = (L[i] + A + B) & 0xffffffffL;
+      B = L[i] =
+	((k << (m & 0x1f)) | ((k & 0xffffffff) >> (32 - (m & 0x1f))));
+    }
+  return L[0] + L[1];
+}
+
+int
+main ()
+{
+  uint32_t S[2] = {0xffff, 0xffffff};
+
+  if (f (S,2)!= 1392607300)
+    abort();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20050922-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050922-2.c
new file mode 100644
index 000000000..c2974d03d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20050922-2.c
@@ -0,0 +1,33 @@
+/* 20050922-1.c does not trigger the expand_shift rotate bug on sh4-elf, but  
+   this does.  */
+
+/* { dg-do run } */
+/* { dg-options "-O1 -std=c99" } */
+
+#include <stdlib.h>
+
+#if __INT_MAX__ == 2147483647
+typedef unsigned int uint32_t;
+#elif __LONG_MAX__ == 2147483647
+typedef unsigned long uint32_t;
+#else
+#error unable to find 32-bit integer type
+#endif
+
+#define rotl(x,n)   (((x) << ((int)(n))) | ((x) >> (32 - (int)(n))))
+
+uint32_t
+f (uint32_t a, uint32_t b)
+{
+
+  b = rotl (a, b & 31);
+  return b;
+}
+
+int
+main ()
+{
+  if (f(2,31) != 1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20051201-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051201-1.c
new file mode 100644
index 000000000..c13c10852
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051201-1.c
@@ -0,0 +1,28 @@
+/* This failed with profiling due to a missing check in
+   tree_flow_call_edges_add.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fprofile-generate" } */
+
+static __attribute__ ((always_inline)) void 
+baz ()
+{
+}
+
+static __attribute__ ((always_inline)) int
+bar ()
+{
+ out:
+  baz ();
+  goto out;
+}
+
+int
+foo ()
+{
+  long res;
+  
+  res = bar ();
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-1.c
new file mode 100644
index 000000000..326fb0271
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-1.c
@@ -0,0 +1,5 @@
+/* GCC doesn't generate any .eh_frame data for this TU itself, so it
+   shouldn't warn about "a" conflicting with the built-in idea of
+   .eh_frame, even if it thinks that .eh_frame should be read-only.  */
+/* { dg-require-named-sections "" } */
+int a __attribute__((section (".eh_frame"))) = 1;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-2.c
new file mode 100644
index 000000000..8a8708794
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-2.c
@@ -0,0 +1,5 @@
+/* GCC doesn't generate any .eh_frame data for this TU itself, so it
+   shouldn't warn about "a" conflicting with the built-in idea of
+   .eh_frame, even if it thinks that .eh_frame should be read-write.  */
+/* { dg-require-named-sections "" } */
+const int a __attribute__((section (".eh_frame"))) = 1;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-3.c
new file mode 100644
index 000000000..3d4b2a48c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20051207-3.c
@@ -0,0 +1,7 @@
+/* GCC doesn't generate any .eh_frame data for this TU itself, so it
+   shouldn't warn about "a" conflicting with the built-in idea of
+   .eh_frame.  The warning therefore belongs on the second decl.  */
+/* { dg-options "-fno-unit-at-a-time" } */
+/* { dg-require-named-sections "" } */
+int a __attribute__((section (".eh_frame"))) = 1;
+const int b __attribute__((section (".eh_frame"))) = 1; /* { dg-error "section type conflict" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20060410.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060410.c
new file mode 100644
index 000000000..88253bb43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060410.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+/* Make sure we didn't eliminate foo because we thought it was unused.  */
+
+struct foo 
+{
+    int i;
+};
+
+int bar (void)
+{
+    return ((struct foo *)0x1234)->i;
+}
+
+/* { dg-final { scan-assembler "foo" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20060419-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060419-1.c
new file mode 100644
index 000000000..754774162
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060419-1.c
@@ -0,0 +1,4 @@
+struct T {
+  unsigned char f[1] __attribute__((packed)); /* { dg-warning "ignored for field of type.*unsigned char\\\[1\\\]" } */
+  unsigned char g[14] __attribute__((packed)); /* { dg-warning "ignored for field of type.*unsigned char\\\[14\\\]" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20060425-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060425-1.c
new file mode 100644
index 000000000..7d899b2bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060425-1.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-O1" } */
+
+/* This failed because if conversion didn't handle insv patterns properly.  */
+
+void abort (void);
+
+union y
+{
+  int a;
+  unsigned short b;
+};
+
+void __attribute__ ((noinline))
+bar (unsigned short u, union y v)
+{
+  if (u != 1)
+    abort ();
+}
+
+void __attribute__ ((noinline))
+foo (int check)
+{
+  union y x;
+
+  if (check != 0)
+    x.b = 1;
+  else
+    x.b = 2;
+  bar (x.b, x);
+}
+
+int
+main ()
+{
+  foo (1);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20060425-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060425-2.c
new file mode 100644
index 000000000..2a5e131a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060425-2.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+double
+crashme (double v, double *p)
+{
+  if (v < 0. && *p == 1.)
+    v = 0.;
+  return v;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20060801-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060801-1.c
new file mode 100644
index 000000000..c036acbec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20060801-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-require-effective-target lp64 } */
+/* { dg-options "-fPIC" } */
+char *ptr = 0;
+char array[100];
+void
+f()
+{
+  ptr = &array[0x100000000ULL];	/* A 33-bit constant.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20061026.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061026.c
new file mode 100644
index 000000000..fb3de2375
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061026.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+/* This testcase failed on s390.  The frame size for function f will be
+   exactly 32768 bytes.  The back end has to recognize that this is to
+   large for a 16bit constant and therefore should reserve the literal
+   pool base pointer.  */
+
+int f () {
+  char a[32608];
+
+  g (a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20061109-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061109-1.c
new file mode 100644
index 000000000..2ba30bf84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061109-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target { int32plus } } } */
+/* { dg-options "-O1" } */
+
+/* This assignment might be implemented with a mem copy from the
+   literal pool with two BLKmode operands.  This produced an ICE on S/390
+   since simplify_subreg was called for such a BLKmode operand.  */
+
+struct a
+{
+  unsigned int b:24;
+};
+
+void
+foo (struct a *t)
+{
+  t->b = 32;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20061109-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061109-2.c
new file mode 100644
index 000000000..30be434d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061109-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+/* This assignment might be implemented with a mem copy from the
+   literal pool with two BLKmode operands.  This produced an ICE on S/390
+   since simplify_subreg was called for such a BLKmode operand.  */
+
+struct a
+{
+  unsigned long b:24;
+};
+
+void
+foo (struct a *t)
+{
+  t->b = 32;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20061124-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061124-1.c
new file mode 100644
index 000000000..dab57ef48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061124-1.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_char_short } */
+
+/* This testcase failed on s390 because no compare instruction for
+   the check of FLAG was emitted.  */
+
+unsigned short int count = 0;
+int flag = 1;
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main ()
+{
+  __sync_add_and_fetch (&count, -1);
+
+  if (!flag)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20061127-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061127-1.c
new file mode 100644
index 000000000..0b70a5ae2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20061127-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-require-effective-target lp64 } */
+/* { dg-options "-O1 -fPIC" } */
+
+/* PR target/29319 */
+
+extern void abort(void);
+static char l_info[100];
+
+void
+bug1 (unsigned long tag)
+{
+  char *info = l_info;
+  info[tag - 0x100000000 + 1] = 1;
+}
+
+void
+bug2 (unsigned long tag)
+{
+  char *info = l_info;
+  info[tag - 0x700000000 + 2] = 2;
+}
+
+void
+bug3 (unsigned long tag)
+{
+  char *info = l_info;
+  info[tag - 0x100000000 + 1] = 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20070112-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20070112-1.c
new file mode 100644
index 000000000..bd7833567
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20070112-1.c
@@ -0,0 +1,24 @@
+/* We used to ICE on this testcase: the address of bad_spill_regs is
+   only taken in a phi node, which we missed and cleared its TREE_ADDRESSABLE
+   flag.  This gets revealed when the loop is completely unrolled, thus
+   exposing the addresses as ordinary statements.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+
+typedef unsigned HARD_REG_SET[2];
+static HARD_REG_SET bad_spill_regs;
+
+void
+order_regs_for_reload ()
+{
+  register int i;
+
+  register unsigned *scan_tp_ = bad_spill_regs;
+
+  for (i = 0; i < 2; i++)
+    *scan_tp_++ = 0;
+
+  bad_spill_regs[0] |= 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20070507-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20070507-1.c
new file mode 100644
index 000000000..2884d1aa8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20070507-1.c
@@ -0,0 +1,103 @@
+/* This failed on s390x due to bug in loop.c.
+   loop.c failed to remove a REG_EQUAL note when
+   hoisting an insn from a loop body.  */
+
+/* { dg-options "-O3 -fPIC" } */
+/* { dg-do run { target fpic } } */
+
+typedef __SIZE_TYPE__ size_t;
+int memcmp(const void *s1, const void *s2, size_t n);
+
+typedef struct
+{
+  char name[30];
+  int a;
+} LOCAL;
+
+int global = 0;
+int sy = 1;
+int subroutine_offset;
+
+LOCAL local = { "local", 0 };
+LOCAL keywords = { "keywords", 1 };
+int local_table = 0;
+int keywords_table = 0;
+
+void __attribute__((noinline)) bar (char *p_buffer)
+{
+  p_buffer[255] = 1;
+}
+
+int __attribute__((noinline)) foo (char *p_str1)
+{
+  global = 1;
+  return 1;
+}
+
+int __attribute__((noinline)) loop_next (int *p_table, char *p_table_head)
+{
+  static loop_next = 0;
+
+  if (loop_next == 1)
+    return 1;
+
+  loop_next = 1;
+  return 0;
+}
+
+int
+main ()
+{
+  char buffer[256];
+  int ende = 0;
+  int index;
+  int local_base = 2;
+
+  keywords.a = 1;
+  for (sy = 0;; sy++)
+    {
+      for (index = 1;;)
+	{
+	  bar (buffer);
+	  if (buffer[sy] != 0)
+	    {
+	      ende = 1;
+	      break;
+	    };
+	  if (foo (buffer))
+	    {
+	      keywords.a += index - 1;
+	      break;
+	    }
+	  index++;
+	}
+      if (ende)
+	break;
+    }
+
+  subroutine_offset = 0;
+
+  for (;;)
+    {
+      if (loop_next (&keywords_table, (char*)&keywords))
+	break;
+
+      if ((!memcmp (keywords.name, "+++", 3)))
+	local_base = 100;
+      else
+	local_base = 0;
+
+      if ((!memcmp (keywords.name, "+++", 3)))
+	subroutine_offset += local_table;
+
+      for (;;)
+	{
+	  if (loop_next (&local_table, (char*)&local))
+	    break;;
+	  if ((local.a == 0))
+	    continue;;
+	  foo (local.name);
+	}
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20070725-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20070725-1.c
new file mode 100644
index 000000000..07b609cf8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20070725-1.c
@@ -0,0 +1,64 @@
+/* This used to fail due to a ifcombine problem wrecking 64bit
+   checks.  Fixed with rev. 126876.  */
+/* { dg-do run } */
+/* { dg-options "-O1" } */
+
+struct tree_base
+{
+  unsigned code:16;
+
+  unsigned side_effects_flag:1;
+  unsigned constant_flag:1;
+  unsigned addressable_flag:1;
+  unsigned volatile_flag:1;
+  unsigned readonly_flag:1;
+  unsigned unsigned_flag:1;
+  unsigned asm_written_flag:1;
+  unsigned nowarning_flag:1;
+
+  unsigned used_flag:1;
+  unsigned nothrow_flag:1;
+  unsigned static_flag:1;
+  unsigned public_flag:1;
+  unsigned private_flag:1;
+  unsigned protected_flag:1;
+  unsigned deprecated_flag:1;
+  unsigned invariant_flag:1;
+
+  unsigned lang_flag_0:1;
+  unsigned lang_flag_1:1;
+  unsigned lang_flag_2:1;
+  unsigned lang_flag_3:1;
+  unsigned lang_flag_4:1;
+  unsigned lang_flag_5:1;
+  unsigned lang_flag_6:1;
+  unsigned visited:1;
+
+  unsigned spare1:16;
+  unsigned spare2:8;
+  unsigned long  a;
+};
+
+int
+foo (struct tree_base *rhs)
+{
+  if (({const struct tree_base* __t = (rhs);  __t;})->readonly_flag
+      && (rhs)->static_flag)
+    return 1;
+
+  return 0;
+}
+
+extern void abort (void);
+
+int
+main ()
+{
+  struct tree_base t;
+
+  t.readonly_flag = t.static_flag = 0;
+  if (foo (&t))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20080522-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080522-1.c
new file mode 100644
index 000000000..e2598439b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080522-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile }
+/* { dg-options "-O2 -fsee" } */
+
+int f(const char* ptr, int bar) {
+  return (((const char *)0 - ptr ) & (bar - 1)) == 0;
+}
+
+
+int g(const char* ptr, const char *test, int N, int bar)  {
+  if (N == 0) {
+  }
+  else if (N > 0) {
+    int count = 0;
+    while ( count < N) {
+      if (!f(ptr, bar))
+        count++;
+    }
+  }
+  return f(test, bar) ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20080528-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080528-1.c
new file mode 100644
index 000000000..9fe978051
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080528-1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fsee" } */
+
+unsigned long g(int a, int b) {
+  return a / b;
+}
+unsigned long f(long int a) {
+  return g(a, 1<<13);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20080615-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080615-1.c
new file mode 100644
index 000000000..bce9476cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080615-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile }  */
+/* { dg-options "-w -O2" } */
+
+static int *see_bb_splay_ar = ((void *) 0);
+static void
+see_merge_and_eliminate_extensions (void)
+{
+  int i = 0;
+  printf ("* Phase 2: Merge and eliminate locally redundant extensions.  *\n");
+  splay_tree_foreach (see_bb_splay_ar[i], ((void *) 0), ((void *) 0));
+}
+static void
+see_main (void)
+{
+  int i = 0;
+  see_merge_and_eliminate_extensions ();
+  printf ("Searching register properties in bb %d\n", i);
+}
+gate_handle_see (void)
+{
+}
+rest_of_handle_see (void)
+{
+  see_main ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20080820.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080820.c
new file mode 100644
index 000000000..b9dd8a7c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20080820.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* { dg-options "-fshow-column -fms-extensions -pedantic" } */
+
+struct { struct a { int x; }; int bar; } hot; /* { dg-warning "29:ISO C doesn't support unnamed" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/20090902-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/20090902-1.c
new file mode 100644
index 000000000..6120ee907
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/20090902-1.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+#define STRING(x) #x
+char buf[] = STRING(L'\x123');
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/920413-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/920413-1.c
new file mode 100644
index 000000000..6e8fff7eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/920413-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+int
+x (b)
+{
+  return
+  4294967295U   /* { dg-warning "width of integer|traditional C rejects" } */
+   / (unsigned long) b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/940409-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/940409-1.c
new file mode 100644
index 000000000..2d20b891f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/940409-1.c
@@ -0,0 +1,6 @@
+/* GCC should allow struct S to be in a register.  */
+/* { dg-do compile } */
+
+struct S { volatile int field; };
+int f (register struct S arg);  /* { dg-bogus "volatile field" "with arg" } */
+int g (register struct S);	/* { dg-bogus "volatile field" "no arg" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/940510-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/940510-1.c
new file mode 100644
index 000000000..2c27e0090
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/940510-1.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic" } */
+struct { int a[]; } x = { 0 };	/* { dg-warning "ISO C90 does not support flexible array members" } */
+/* { dg-error "flexible array member in otherwise empty struct"  "" { target *-*-* }  3 } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/951130-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/951130-1.c
new file mode 100644
index 000000000..60013e267
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/951130-1.c
@@ -0,0 +1,5 @@
+/* { dg-do compile }
+   { dg-options "-Werror" } */
+
+unsigned long long x = -(unsigned long long)(-(long long)
+				(((unsigned long long)0 - 1) >> 1) - 1);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/980502-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/980502-1.c
new file mode 100644
index 000000000..f06491cd9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/980502-1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile  }*/
+/* { dg-options "-O2" } */
+
+char *const f(void)
+{
+        char *const line = "/dev/ptyXX";
+        line[8] = 1;
+        return line;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/980523-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/980523-1.c
new file mode 100644
index 000000000..970b57c59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/980523-1.c
@@ -0,0 +1,53 @@
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+extern void exit (int);
+
+void foo1(int a, char *b, int c)
+{
+   c =a+c+234;
+}
+
+int foo2(int d)
+{
+   return d*d;
+}
+
+int bar1, bar2, bar3;
+char * bar4;
+
+int main(void) {
+    int h;
+    bar1 = foo2(1);
+    bar2 = foo2(1);
+
+    h = foo2(1);
+    foo1(1, "a", foo2(1));
+    foo1(bar1, "a", foo2(1));
+    foo2(1);
+
+    h = foo2(1);
+    bar3 = 1;
+    bar4 = "a";
+    foo1(1, "n", foo2(1));
+    foo1(1, "o", foo2(1));
+    foo1(1, "p", foo2(1));
+    foo1(bar1, "a", foo2(1));
+
+    bar3 = h;
+    bar4 = "b";  foo1(bar1, "b", foo2(1));
+    foo1(1, "q", foo2(1));
+    bar4 = "c";  foo1(1, "c", foo2(1));
+    bar4 = "d";  foo1(1, "d", foo2(1));
+    bar4 = "e";  foo1(1, "e", foo2(1));
+    bar4 = "f";  foo1(1, "f", foo2(1));
+    bar4 = "g";  foo1(1, "g", foo2(1));
+    bar4 = "h";  foo1(1, "h", foo2(1));
+    bar4 = "i";  foo1(1, "i", foo2(1));
+    bar4 = "j";  foo1(1, "j", foo2(1));
+    bar4 = "k";  foo1(1, "k", foo2(1));
+    bar4 = "l";  foo1(1, "l", foo2(1));
+    bar4 = "m";
+    foo1(bar2, "m", foo2(1));
+    exit(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/980526-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/980526-1.c
new file mode 100644
index 000000000..6ab9db679
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/980526-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+int
+test(void)
+{
+    double value, maxValue = - (__extension__	((union { unsigned __l __attribute__((__mode__(__DI__))); double __d; }) { __l: 0x7ff0000000000000ULL }).__d)  ;
+    int idx, maxIdx = 1;
+
+    for (idx = 1; idx < 22; idx++) {
+        if (value > maxValue) {
+            maxValue = value;
+            maxIdx = idx;
+        }
+    }
+    return 0 ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/980816-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/980816-1.c
new file mode 100644
index 000000000..d4f59c40c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/980816-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+
+int
+div_and_round_double (lden_orig, hden_orig)
+     int lden_orig, hden_orig;
+{
+  int quo[4];
+  register int i;
+  unsigned int  work;
+  register unsigned int  carry = 0;
+  int  lden = lden_orig;
+  int  hden = hden_orig;
+  neg_double (&lden, &hden);
+  for (i = 4 - 1; i >= 0; i--)
+    {
+      quo[i] = work / (unsigned int ) lden;
+      carry = work % (unsigned int ) lden;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/990213-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/990213-1.c
new file mode 100644
index 000000000..a7c9f2489
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/990213-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-W -Wall -Werror" } */
+
+static inline int unused_fn(int dummyarg)
+{
+	return dummyarg*dummyarg;
+}
+
+int main()
+{
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/990506-0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/990506-0.c
new file mode 100644
index 000000000..15d8ac736
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/990506-0.c
@@ -0,0 +1,9 @@
+/* Verify that a diagnostic is issued without crashing due to
+   --enable-checking catching a bug in the C front end.  */
+/* { dg-do compile } */
+x()
+{
+  foo (i);
+  /* { dg-error "undeclared" "undeclared-variable message" { target *-*-* } { 6 } } */
+  /* { dg-error "function it appears in" "reminder message" { target *-*-* } { 6 } } */ 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Foundation.framework/empty b/gcc-4.4.3/gcc/testsuite/gcc.dg/Foundation.framework/empty
new file mode 100644
index 000000000..41347913e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Foundation.framework/empty
@@ -0,0 +1 @@
+This directory is empty.
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/O16384.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/O16384.c
new file mode 100644
index 000000000..32e17d4e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/O16384.c
@@ -0,0 +1,15 @@
+/* Test insane -O argument.  */
+/* { dg-do compile } */
+/* { dg-options "-O16384" } */
+
+__attribute__((__optimize__(16396), __noinline__)) void
+foo (void)
+{
+}
+
+int
+main (void)
+{
+  foo ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/README b/gcc-4.4.3/gcc/testsuite/gcc.dg/README
new file mode 100644
index 000000000..6f14899ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/README
@@ -0,0 +1,16 @@
+Notes for testsuite/gcc.dg.
+
+1) There should be only one driver, dg.exp.
+
+2) Try to organize the tests by topic using file name prefixes.
+
+   Eg: All bitfield tests are named "bf-*.c".
+
+   This lets the person running the tests choose particular sets of tests to
+   run easily (using wildcards).
+
+   Eg: make check RUNTESTFLAGS='dg.exp=bf-*.c'
+
+3) Remember DOS file name restrictions (8.3).  Sigh.
+
+4) Send bugs, comments, etc. to dje@cygnus.com.
\ No newline at end of file
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wall.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wall.c
new file mode 100644
index 000000000..898484717
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wall.c
@@ -0,0 +1,9 @@
+/* PR 30437: Test -Wall 
+   Don't change this without changing Wno-all.c as well.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+void foo(int a)
+{
+  5 * (a == 1) | (a == 2);  /* { dg-warning "no effect" "no effect" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Walways-true-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Walways-true-1.c
new file mode 100644
index 000000000..32b921c3f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Walways-true-1.c
@@ -0,0 +1,57 @@
+/* Test -Waddress for testing an address against NULL.
+   Origin: Ian Lance Taylor <iant@google.com>.  */
+
+/* { dg-do compile} */
+/* { dg-options "-Waddress -fshow-column" } */
+
+extern int foo (int);
+
+int i;
+
+void
+bar (int a)
+{
+ lab:
+  if (foo)	/* { dg-warning "7:always evaluate as" "correct warning" } */
+    foo (0);
+  if (foo (1))
+    ;
+  if (&i)	/* { dg-warning "7:always evaluate as" "correct warning" } */
+    foo (2);
+  if (i)
+    foo (3);
+  if (&a)	/* { dg-warning "7:always evaluate as" "correct warning" } */
+    foo (4);
+  if (a)
+    foo (5);
+  if (&&lab)	/* { dg-warning "7:always evaluate as" "correct warning" } */
+    foo (6);
+  if (foo == 0)	/* { dg-warning "11:never be NULL" "correct warning" } */
+    foo (7);
+  if (foo (1) == 0)
+    foo (8);
+  if (&i == 0)	/* { dg-warning "10:never be NULL" "correct warning" } */
+    foo (9);
+  if (i == 0)
+    foo (10);
+  if (&a == 0)	/* { dg-warning "10:never be NULL" "correct warning" } */
+    foo (11);
+  if (a == 0)
+    foo (12);
+  if (&&lab == 0) /* { dg-warning "13:never be NULL" "correct warning" } */
+    foo (13);
+  if (0 == foo)	/* { dg-warning "9:never be NULL" "correct warning" } */
+    foo (14);
+  if (0 == foo (1))
+    foo (15);
+  if (0 == &i)	/* { dg-warning "9:never be NULL" "correct warning" } */
+    foo (16);
+  if (0 == i)
+    foo (17);
+  if (0 == &a)	/* { dg-warning "9:never be NULL" "correct warning" } */
+    foo (18);
+  if (0 == a)
+    foo (19);
+  if (0 == &&lab) /* { dg-warning "9:never be NULL" "correct warning" } */
+    foo (20);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Walways-true-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Walways-true-2.c
new file mode 100644
index 000000000..c14857eae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Walways-true-2.c
@@ -0,0 +1,60 @@
+/* Make sure we don't assume that a weak symbol is always non-NULL.
+   This is just like Walways-true-1.C, except that it uses a weak
+   symbol.
+   Origin: Ian Lance Taylor <iant@google.com>.  */
+
+/* { dg-do compile} */
+/* { dg-options "-Waddress" } */
+/* { dg-require-weak "" } */
+
+extern int foo (int) __attribute__ ((weak));
+
+int i __attribute__ ((weak));
+
+void
+bar (int a)
+{
+ lab:
+  if (foo)
+    foo (0);
+  if (foo (1))
+    ;
+  if (&i)
+    foo (2);
+  if (i)
+    foo (3);
+  if (&a)	/* { dg-warning "always evaluate as" "correct warning" } */
+    foo (4);
+  if (a)
+    foo (5);
+  if (&&lab)	/* { dg-warning "always evaluate as" "correct warning" } */
+    foo (6);
+  if (foo == 0)
+    foo (7);
+  if (foo (1) == 0)
+    foo (8);
+  if (&i == 0)
+    foo (9);
+  if (i == 0)
+    foo (10);
+  if (&a == 0)	/* { dg-warning "never be NULL" "correct warning" } */
+    foo (11);
+  if (a == 0)
+    foo (12);
+  if (&&lab == 0) /* { dg-warning "never be NULL" "correct warning" } */
+    foo (13);
+  if (0 == foo)
+    foo (14);
+  if (0 == foo (1))
+    foo (15);
+  if (0 == &i)
+    foo (16);
+  if (0 == i)
+    foo (17);
+  if (0 == &a)	/* { dg-warning "never be NULL" "correct warning" } */
+    foo (18);
+  if (0 == a)
+    foo (19);
+  if (0 == &&lab) /* { dg-warning "never be NULL" "correct warning" } */
+    foo (20);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-2.c
new file mode 100644
index 000000000..796483e0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* Test that -Warray-bounds is enabled by -Wall */
+/* { dg-options "-O2 -Wall" } */
+
+int a[10];
+
+int* f(void) {
+
+    a[-1] = 0;             /* { dg-warning "array subscript" } */
+
+    return a;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-3.c
new file mode 100644
index 000000000..19cdb8e5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-3.c
@@ -0,0 +1,108 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Warray-bounds" } */
+/* based on PR 31227 */
+
+typedef __SIZE_TYPE__ size_t;
+
+extern size_t strlen (const char *);
+
+struct iovec
+{
+  void *iov_base;
+  size_t iov_len;
+};
+
+struct S
+{
+  const char *abday[7];
+  const char *day[7];
+  const char *abmon[12];
+  const char *mon[12];
+  const char *am_pm[2];
+};
+
+extern void foo (size_t, struct iovec *);
+
+void
+bar (struct S *time)
+{
+  struct iovec iov[43];
+  size_t cnt;
+  iov[0].iov_base = (void *) "abc";
+  iov[0].iov_len = 3;
+
+  iov[1].iov_base = (void *) "def";
+  iov[1].iov_len = 3;
+
+  for (cnt = 0; cnt <= 7; ++cnt)
+    {
+      iov[2 + cnt].iov_base = (void *) (time->abday[cnt] ?: "");
+      iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
+    }
+
+  for (; cnt <= 14; ++cnt)
+    {
+      iov[2 + cnt].iov_base = (void *) (time->day[cnt - 7] ?: "");
+      iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
+    }
+
+  for (; cnt <= 26; ++cnt)
+    {
+      iov[2 + cnt].iov_base = (void *) (time->abmon[cnt - 14] ?: "");
+      iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
+    }
+
+  for (; cnt <= 38; ++cnt)
+    {
+      iov[2 + cnt].iov_base = (void *) (time->mon[cnt - 26] ?: "");
+      iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
+    }
+
+  for (; cnt <= 40; ++cnt)
+    {
+      iov[2 + cnt].iov_base =  (void *) (time->am_pm[cnt - 38] ?: "");
+      iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
+    }
+
+  foo (2 + cnt, iov);
+}
+
+struct malloc_chunk {
+  long prev_size;
+  long size;
+  struct malloc_chunk* fd;
+  struct malloc_chunk* bk;
+};
+typedef struct malloc_chunk* mchunkptr;
+struct malloc_state {
+  mchunkptr        top;
+  mchunkptr        last_remainder;
+  mchunkptr        bins[128 * 2 - 2];
+};
+#define bin_at(m, i) \
+  (mchunkptr) (((char *) &((m)->bins[((i) - 1) * 2]))                         \
+             - __builtin_offsetof (struct malloc_chunk, fd))
+
+void malloc_init_state(struct malloc_state *av)
+{
+  int     i;
+  mchunkptr bin;
+
+  for (i = 1; i < 128; ++i) {
+    bin = bin_at(av,i);
+    bin->fd = bin->bk = bin;
+  }
+}
+
+typedef unsigned short WCHAR;
+typedef WCHAR *LPWSTR;
+
+static void g(LPWSTR dest, int len) {
+     dest[len-1] = 0;
+}
+
+void f() {
+    WCHAR szPathW[260];
+
+    g(szPathW, 260);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-4.c
new file mode 100644
index 000000000..71526f27f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-4.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+typedef unsigned int DWORD;
+
+static void g(DWORD * p, int n)
+{
+        int i;
+
+        for (i = 0; i < n && !p[n - 1]; i++);  /* { dg-bogus "subscript is above array bounds" } */
+}
+
+void f() {
+        DWORD arr[8];
+
+        g(arr, 4);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-5.c
new file mode 100644
index 000000000..ba9cd2aa0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-5.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wall" } */
+/* based on PR 37861 */
+
+extern int printf (__const char *__restrict __format, ...);
+
+static int f2(char formatstr[10][100])  
+{
+  int anz;
+  for( anz = 0; anz < 10; ++anz ) {
+    printf( "%d %s\n", anz, formatstr[anz] );
+  } 
+  return anz;
+}
+
+
+static   char formatstr[10][100];
+int main( void ) 
+{
+  int anz;
+  anz = f2(formatstr);
+  printf( "   %d\n",anz);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-6.c
new file mode 100644
index 000000000..44a513bba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds-6.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wall" } */
+/* based on PR 37861 */
+
+extern int printf (__const char *__restrict __format, ...);
+
+static int f3(int v)
+{
+  int i,j = 0;
+  for (i = 0; i <= v; i++)
+    j++;
+  return j;
+}
+
+static int f2(char formatstr[10][100]) {
+  printf( "%d %s\n", 0, formatstr[f3(0)] );
+  printf( "%d %s\n", 1, formatstr[f3(1)] );
+  printf( "%d %s\n", 2, formatstr[f3(2)] );
+  printf( "%d %s\n", 3, formatstr[f3(3)] );
+  return 3;
+}
+
+static   char formatstr[10][100];
+int main( void ) {
+  int anz;
+  anz = f2(formatstr);
+  printf( "   %d\n",anz);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds.c
new file mode 100644
index 000000000..53da38392
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Warray-bounds.c
@@ -0,0 +1,92 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Warray-bounds" } */
+
+int a[10];
+
+static inline int n(void) {
+    __SIZE_TYPE__ strlen(const char *s);
+    return strlen("12345");
+}
+
+void g(int *p);
+void h(int p);
+
+int* f(void) {
+    int b[10];
+    int i;
+    struct {
+       int c[10];
+    } c;
+
+    a[-1] = 0;             /* { dg-warning "array subscript" } */
+    a[ 0] = 0;
+    a[ 1] = 0;
+
+
+    a[ 9] = 0;
+    a[10] = 0;             /* { dg-warning "array subscript" } */
+    a[11] = 0;             /* { dg-warning "array subscript" } */
+    a[2 * n() - 11] = 1;    /* { dg-warning "array subscript" } */
+    a[2 * n() - 10] = 1;
+    a[2 * n() -  1] = 1;
+    a[2 * n() -  0] = 1;    /* { dg-warning "array subscript" } */
+
+    b[-1] = 0;             /* { dg-warning "array subscript" } */
+    b[ 0] = 0;
+    b[ 1] = 0;
+    b[ 9] = 0;
+    b[10] = 0;             /* { dg-warning "array subscript" } */
+    b[11] = 0;             /* { dg-warning "array subscript" } */
+    b[2 * n() - 11] = 1;    /* { dg-warning "array subscript" } */
+    b[2 * n() - 10] = 1;
+    b[2 * n() -  1] = 1;
+    b[2 * n() -  0] = 1;    /* { dg-warning "array subscript" } */
+
+    c.c[-1] = 0;           /* { dg-warning "array subscript" } */
+    c.c[ 0] = 0;
+    c.c[ 1] = 0;
+    c.c[ 9] = 0;
+    c.c[10] = 0;           /* { dg-warning "array subscript" } */
+    c.c[11] = 0;           /* { dg-warning "array subscript" } */
+    c.c[2 * n() - 11] = 1;  /* { dg-warning "array subscript" } */
+    c.c[2 * n() - 10] = 1;
+    c.c[2 * n() -  1] = 1;
+    c.c[2 * n() -  0] = 1;  /* { dg-warning "array subscript" } */
+
+    g(&a[8]);
+    g(&a[9]);
+    g(&a[10]);
+    g(&a[11]);             /* { dg-warning "array subscript" "" { xfail *-*-* } } */
+    g(&a[-30]+10);             /* { dg-warning "array subscript" } */
+    g(&a[-30]+30);
+
+    g(&b[10]);
+    g(&c.c[10]);
+    g(&b[11]);             /* { dg-warning "array subscript" "" { xfail *-*-* } } */
+    g(&c.c[11]);           /* { dg-warning "array subscript" } */
+
+    g(&a[0]);
+    g(&b[0]);
+    g(&c.c[0]);
+
+    g(&a[-1]);             /* { dg-warning "array subscript" } */
+    g(&b[-1]);             /* { dg-warning "array subscript" } */ 
+    h(sizeof a[-1]);
+    h(sizeof a[10]);
+    h(sizeof b[-1]);
+    h(sizeof b[10]);
+    h(sizeof c.c[-1]);
+    h(sizeof c.c[10]);
+
+    if (10 < 10)
+       a[10] = 0;
+    if (10 < 10)
+       b[10] = 0;
+    if (-1 >= 0)
+       c.c[-1] = 0;
+
+    for (i = 20; i < 30; ++i)
+             a[i] = 1;       /* { dg-warning "array subscript" } */
+
+    return a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-1.c
new file mode 100644
index 000000000..29e07e412
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-1.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options -Wattributes } */
+
+void __attribute__((dj)) foo() { }	/* { dg-warning "attribute directive ignored" } */
+
+int j __attribute__((unrecognized));	/* { dg-warning "attribute directive ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-2.c
new file mode 100644
index 000000000..691870420
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options -Wno-attributes } */
+
+void __attribute__((dj)) foo() { }	/* { dg-bogus "attribute directive ignored" } */
+
+int j __attribute__((unrecognized));	/* { dg-bogus "attribute directive ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-3.c
new file mode 100644
index 000000000..59d14c7b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wattributes-3.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+
+void __attribute__((dj)) foo() { }	/* { dg-warning "attribute directive ignored" } */
+
+int j __attribute__((unrecognized));	/* { dg-warning "attribute directive ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wbad-function-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wbad-function-cast-1.c
new file mode 100644
index 000000000..4a0547f0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wbad-function-cast-1.c
@@ -0,0 +1,51 @@
+/* Test operation of -Wbad-function-cast.  Bug 6980 complained of the
+   wording of the diagnostic.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-Wbad-function-cast" } */
+
+void vf(void);
+int if1(void);
+char if2(void);
+long if3(void);
+float rf1(void);
+double rf2(void);
+_Complex double cf(void);
+enum e { E1 } ef(void);
+_Bool bf(void);
+char *pf1(void);
+int *pf2(void);
+
+void
+foo(void)
+{
+  /* Casts to void types are always OK.  */
+  (void)vf();
+  (void)if1();
+  (void)cf();
+  (const void)bf();
+  /* Casts to the same type or similar types are OK.  */
+  (int)if1();
+  (long)if2();
+  (char)if3();
+  (float)rf1();
+  (long double)rf2();
+  (_Complex float)cf();
+  (enum f { F1 })ef();
+  (_Bool)bf();
+  (void *)pf1();
+  (char *)pf2();
+  /* Casts to types with different TREE_CODE (which is how this
+     warning has been defined) are not OK, except for casts to void
+     types.  */
+  (float)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'float'" } */
+  (double)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'double'" } */
+  (_Bool)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Bool'" } */
+  (int)rf1(); /* { dg-warning "cast from function call of type 'float' to non-matching type 'int'" } */
+  (long)rf2(); /* { dg-warning "cast from function call of type 'double' to non-matching type 'long int'" } */
+  (double)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'double'" } */
+  (int)ef(); /* { dg-warning "cast from function call of type 'enum e' to non-matching type 'int'" } */
+  (int)bf(); /* { dg-warning "cast from function call of type '_Bool' to non-matching type 'int'" } */
+  (__SIZE_TYPE__)pf1(); /* { dg-warning "cast from function call of type 'char \\*' to non-matching type '\[^\\n\]*'" } */
+  (__PTRDIFF_TYPE__)pf2(); /* { dg-warning "cast from function call of type 'int \\*' to non-matching type '\[^\\n\]*'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wc++-compat.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wc++-compat.c
new file mode 100644
index 000000000..aa435be9f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wc++-compat.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2005  Free Software Foundation.
+
+   by Gabriel Dos Reis  <gdr@integrable-solutions.net>  */
+
+/* { dg-do compile }  */
+/* { dg-options "-Wc++-compat" } */
+
+extern const int foo = 42;
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wchar-subscripts-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wchar-subscripts-1.c
new file mode 100644
index 000000000..3f5adeb31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wchar-subscripts-1.c
@@ -0,0 +1,29 @@
+/* Test -Wchar-subscripts.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wchar-subscripts" } */
+
+extern int a[];
+int *p;
+char c;
+signed char sc;
+unsigned char uc;
+
+void
+f (void)
+{
+  a[sc];
+  a[uc];
+  sc[a];
+  uc[a];
+  p[sc];
+  p[uc];
+  sc[p];
+  uc[p];
+  a[c]; /* { dg-warning "array subscript has type 'char'" } */
+  p[c]; /* { dg-warning "array subscript has type 'char'" } */
+  /* -Wchar-subscripts does not warn if the char is not syntactically
+      the subscript.  */
+  c[a];
+  c[p];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wchar-subscripts.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wchar-subscripts.c
new file mode 100644
index 000000000..acc6d2357
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wchar-subscripts.c
@@ -0,0 +1,12 @@
+/* Copyright (C) 2005  Free Software Foundation.
+
+   by Gabriel Dos Reis  <gdr@integrable-solutions.net>  */
+
+/* { dg-do compile }  */
+/* { dg-options "-Wchar-subscripts" } */
+
+int main(void)
+{
+  int ary[256] = { 0 };
+  return ary['a'];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-3.c
new file mode 100644
index 000000000..d45749d69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-3.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wconversion" } */
+
+unsigned f(unsigned a) { return a + -1; }  /* { dg-warning "negative" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-4.c
new file mode 100644
index 000000000..ddd19879f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-4.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+unsigned f(unsigned a) { return a + -1; }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-5.c
new file mode 100644
index 000000000..be749a9a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-5.c
@@ -0,0 +1,35 @@
+/* PR c++/34198 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wconversion" } */
+
+signed char sc;
+unsigned char uc;
+short int ss;
+unsigned short int us;
+int si;
+unsigned int ui;
+
+void test1 (void)
+{
+  int a = uc & 0xff;
+  int b = sc & 0x7f;
+  int c = 0xff & uc;
+  int d = 0x7f & sc;
+  int e = uc & sc;
+  unsigned char f = (int) uc;
+  signed char g = (int) sc;
+  unsigned char h = (unsigned int) (short int) uc;
+  signed char i = (int) (unsigned short int) sc;	/* { dg-warning "may alter its value" "" { target { int32plus } } } */
+  unsigned char j = (unsigned int) (short int) us;	/* { dg-warning "may alter its value" } */
+  signed char k = (int) (unsigned short int) ss;	/* { dg-warning "may alter its value" } */
+}
+
+void test2 (void)
+{
+  signed char a = (unsigned char) sc;		/* { dg-warning "may change the sign" } */
+  unsigned char b = (signed char) uc;		/* { dg-warning "may change the sign" } */
+  signed char c = (int) (unsigned char) sc;	/* { dg-warning "may change the sign" } */
+  unsigned char d = (int) (signed char) uc;	/* { dg-warning "may change the sign" } */
+  int e = (unsigned int) si;			/* { dg-warning "may change the sign" } */
+  unsigned int f = (int) ui;			/* { dg-warning "may change the sign" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c
new file mode 100644
index 000000000..c17d502d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c
@@ -0,0 +1,96 @@
+/* Test for diagnostics for implicit conversions between integer types
+   These tests come from gcc/testsuite/gcc.dg/overflow-warn-2.c  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fsigned-char -Wconversion -Wno-sign-conversion" } */
+
+#include <limits.h>
+
+void fsc (signed char sc);
+void fuc (unsigned char uc);
+unsigned fui (unsigned int  ui);
+void fsi (signed int ui);
+
+void h (int x)
+{
+  unsigned int ui = 3;
+  int   si = 3;
+  unsigned char uc = 3;
+  signed char   sc = 3;
+
+  uc = ui; /* { dg-warning "conversion" } */
+  uc = si; /* { dg-warning "conversion" } */
+  sc = ui; /* { dg-warning "conversion" } */
+  sc = si; /* { dg-warning "conversion" } */
+  fuc (ui); /* { dg-warning "conversion" } */
+  fuc (si); /* { dg-warning "conversion" } */
+  fsc (ui); /* { dg-warning "conversion" } */
+  fsc (si); /* { dg-warning "conversion" } */
+
+  fsi (si);
+  fui (ui);
+  fsi (uc);
+  si = uc;
+  fui (uc);
+  ui = uc;
+  fui ('A');
+  ui = 'A';
+  fsi ('A');
+  si = 'A';
+  fuc ('A');
+  uc = 'A';
+
+  uc = x ? 1U : -1; /* { dg-warning "conversion" } */
+  uc = x ? SCHAR_MIN : 1U; /* { dg-warning "conversion" } */
+  uc = x ? 1 : -1; /* Warned by -Wsign-conversion.  */
+  uc = x ? SCHAR_MIN : 1; /* Warned by -Wsign-conversion.  */
+  ui = x ? 1U : -1; /* Warned by -Wsign-conversion.  */
+  ui = x ? INT_MIN : 1U; /* Warned by -Wsign-conversion.  */
+  ui = ui ? SCHAR_MIN : 1U; /* Warned by -Wsign-conversion.  */
+  ui = 1U * -1; /* Warned by -Wsign-conversion.  */
+  ui = ui + INT_MIN; /* Warned by -Wsign-conversion.  */
+  ui = x ? 1 : -1; /* Warned by -Wsign-conversion.  */
+  ui = ui ? SCHAR_MIN : 1; /* Warned by -Wsign-conversion.  */
+
+  fuc (-1); /* Warned by -Wsign-conversion.  */
+  uc = -1; /* Warned by -Wsign-conversion.  */
+  fui (-1); /* Warned by -Wsign-conversion.  */
+  ui = -1; /* Warned by -Wsign-conversion.  */
+  fuc ('\xa0'); /* Warned by -Wsign-conversion.  */
+  uc = '\xa0'; /* Warned by -Wsign-conversion.  */
+  fui ('\xa0'); /* Warned by -Wsign-conversion.  */
+  ui = '\xa0';  /* Warned by -Wsign-conversion.  */
+  fsi ((unsigned) INT_MAX + 1U); /* Warned by -Wsign-conversion.  */
+  si = (unsigned) INT_MAX + 1U;  /* Warned by -Wsign-conversion.  */
+
+
+  fsi (UINT_MAX - 1);  /* Warned by -Wsign-conversion.  */
+  si = UINT_MAX - 1;   /* Warned by -Wsign-conversion.  */
+  fsi (UINT_MAX - 1U); /* Warned by -Wsign-conversion.  */
+  si = UINT_MAX - 1U;  /* Warned by -Wsign-conversion.  */
+  fsi (UINT_MAX/3U);
+  si = UINT_MAX/3U;
+  fsi (UINT_MAX/3);
+  si = UINT_MAX/3;
+  fui (UINT_MAX - 1);
+  ui = UINT_MAX - 1;
+
+  uc = (unsigned char) -1;
+  ui = -1 * (1 * -1);
+  ui = (unsigned) -1;
+
+  fsc (uc); /* Warned by -Wsign-conversion.  */
+  sc = uc;  /* Warned by -Wsign-conversion.  */
+  fuc (sc); /* Warned by -Wsign-conversion.  */
+  uc = sc;  /* Warned by -Wsign-conversion.  */
+  fsi (ui); /* Warned by -Wsign-conversion.  */
+  si = ui;  /* Warned by -Wsign-conversion.  */
+  fui (si); /* Warned by -Wsign-conversion.  */ 
+  ui = si;  /* Warned by -Wsign-conversion.  */ 
+  fui (sc); /* Warned by -Wsign-conversion.  */
+  ui = sc;  /* Warned by -Wsign-conversion.  */
+}
+
+unsigned fui (unsigned a) { return a + -1; } /* Warned by -Wsign-conversion.  */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-integer.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-integer.c
new file mode 100644
index 000000000..b2101076f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-integer.c
@@ -0,0 +1,98 @@
+/* Test for diagnostics for implicit conversions between integer types
+   These tests come from gcc/testsuite/gcc.dg/overflow-warn-2.c  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fsigned-char -Wconversion" } */
+
+#include <limits.h>
+
+void fsc (signed char sc);
+void fuc (unsigned char uc);
+unsigned fui (unsigned int  ui);
+void fsi (signed int ui);
+
+void h (int x)
+{
+  unsigned int ui = 3;
+  int   si = 3;
+  unsigned char uc = 3;
+  signed char   sc = 3;
+
+  uc = ui; /* { dg-warning "conversion" } */
+  uc = si; /* { dg-warning "conversion" } */
+  sc = ui; /* { dg-warning "conversion" } */
+  sc = si; /* { dg-warning "conversion" } */
+  fuc (ui); /* { dg-warning "conversion" } */
+  fuc (si); /* { dg-warning "conversion" } */
+  fsc (ui); /* { dg-warning "conversion" } */
+  fsc (si); /* { dg-warning "conversion" } */
+
+  fsi (si);
+  fui (ui);
+  fsi (uc);
+  si = uc;
+  fui (uc);
+  ui = uc;
+  fui ('A');
+  ui = 'A';
+  fsi ('A');
+  si = 'A';
+  fuc ('A');
+  uc = 'A';
+
+  uc = x ? 1U : -1; /* { dg-warning "conversion" } */
+  /* { dg-warning "negative integer implicitly converted to unsigned type" "" { target *-*-* } 43 } */
+  uc = x ? SCHAR_MIN : 1U; /* { dg-warning "conversion" } */
+  /* { dg-warning "negative integer implicitly converted to unsigned type" "" { target *-*-* } 45 } */
+  uc = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = x ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+
+  fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = -1;  /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fui (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fuc ('\xa0'); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fui ('\xa0');/* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fsi (0x80000000); /* { dg-warning "conversion" } */
+  si = 0x80000000;  /* { dg-warning "conversion" } */
+
+
+  fsi (UINT_MAX - 1);  /* { dg-warning "conversion" } */
+  si = UINT_MAX - 1;   /* { dg-warning "conversion" } */
+  fsi (UINT_MAX - 1U); /* { dg-warning "conversion" } */
+  si = UINT_MAX - 1U;  /* { dg-warning "conversion" } */
+  fsi (UINT_MAX/3U);
+  si = UINT_MAX/3U;
+  fsi (UINT_MAX/3);
+  si = UINT_MAX/3;
+  fui (UINT_MAX - 1);
+  ui = UINT_MAX - 1;
+
+  uc = (unsigned char) -1;
+  ui = -1 * (1 * -1);
+  ui = (unsigned) -1;
+
+  fsc (uc); /* { dg-warning "conversion" } */
+  sc = uc;  /* { dg-warning "conversion" } */
+  fuc (sc); /* { dg-warning "conversion" } */
+  uc = sc;  /* { dg-warning "conversion" } */
+  fsi (ui); /* { dg-warning "conversion" } */
+  si = ui;  /* { dg-warning "conversion" } */
+  fui (si); /* { dg-warning "conversion" } */ 
+  ui = si;  /* { dg-warning "conversion" } */ 
+  fui (sc); /* { dg-warning "conversion" } */
+  ui = sc;  /* { dg-warning "conversion" } */
+}
+
+unsigned fui (unsigned a) { return a + -1; } /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-pr34389.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-pr34389.c
new file mode 100644
index 000000000..1a4336802
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-pr34389.c
@@ -0,0 +1,55 @@
+/* PR 34389 */
+/* { dg-do compile } */
+/* { dg-options "-Wconversion -Wsign-conversion" } */
+/* { dg-require-effective-target int32plus } */
+
+short  mask1(short x)
+{
+  short y = 0x7fff;
+  return x & y;
+}
+
+short  mask2(short ssx)
+{
+  short ssy;
+  short ssz;
+
+  ssz = ((int)ssx) & 0x7fff;
+  ssy = ((int)ssx) | 0x7fff;
+  ssz = ((int)ssx) ^ 0x7fff;
+  return ssx & 0x7fff;
+}
+
+short  mask3(int si, unsigned int ui)
+{
+  short ss;
+  unsigned short us;
+
+  ss = si & 0x7fff;
+  ss = si & 0xAAAA; /* { dg-warning "conversion" } */
+  ss = ui & 0x7fff;
+  ss = ui & 0xAAAA; /* { dg-warning "conversion" } */
+
+  us = si & 0x7fff;
+  us = si & 0xAAAA; /* { dg-warning "conversion" } */
+  us = ui & 0x7fff;
+  us = ui & 0xAAAA; /* 0xAAAA is zero-extended, thus it masks the
+		       upper bits of 'ui' making it fit in 'us'.  */
+
+  return ss;
+}
+
+short  mask4(int x, int y)
+{
+  return x & y; /* { dg-warning "conversion" } */
+}
+
+short  mask5(int x)
+{
+  return x & -1; /* { dg-warning "conversion" } */
+}
+
+short  mask6(short x)
+{
+  return x & -1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-real-integer.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-real-integer.c
new file mode 100644
index 000000000..1625fc035
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-real-integer.c
@@ -0,0 +1,112 @@
+/* Test for diagnostics for Wconversion between floating-point and
+   integers.  */
+
+/* { dg-do compile }
+/* { dg-skip-if "doubles are floats,ints are 16bits" { "avr-*-*" } { "*" } { "" } } */
+/* { dg-options "-std=c99 -Wconversion" } */
+/* { dg-require-effective-target int32plus } */
+#include <limits.h>
+
+void fsi (signed int x);
+void fui (unsigned int x);
+void ffloat (float x);
+void fdouble (double x);
+
+float  vfloat;
+double vdouble;
+
+void h (void)
+{
+  unsigned int ui = 3;
+  int   si = 3;
+  unsigned char uc = 3;
+  signed char sc = 3;
+  float  f = 3;
+  double d = 3;
+
+  fsi (3.1f); /* { dg-warning "conversion" } */
+  si = 3.1f; /* { dg-warning "conversion" } */
+  fsi (3.1);  /* { dg-warning "conversion" } */
+  si = 3.1;  /* { dg-warning "conversion" } */
+  fsi (d);    /* { dg-warning "conversion" } */
+  si = d;    /* { dg-warning "conversion" } */
+  fui (-1.0); /* { dg-warning "overflow" } */
+  ui = -1.0;   /* { dg-warning "overflow" } */
+  ffloat (INT_MAX);  /* { dg-warning "conversion" } */
+  vfloat = INT_MAX;  /* { dg-warning "conversion" } */
+  ffloat (16777217); /* { dg-warning "conversion" } */
+  vfloat = 16777217; /* { dg-warning "conversion" } */
+  ffloat (si); /* { dg-warning "conversion" } */
+  vfloat = si; /* { dg-warning "conversion" } */
+  ffloat (ui); /* { dg-warning "conversion" } */
+  vfloat = ui; /* { dg-warning "conversion" } */
+
+  fsi (3);
+  si = 3;
+  fsi (3.0f);
+  si = 3.0f;
+  fsi (3.0);
+  si = 3.0;
+  fsi (16777217.0f);
+  si = 16777217.0f;
+  fsi ((int) 3.1);
+  si = (int) 3.1;
+  ffloat (3U);
+  vfloat = 3U;
+  ffloat (3);
+  vfloat = 3;
+  ffloat (INT_MIN);
+  vfloat = INT_MIN;
+  ffloat (uc);
+  vfloat = uc;
+  ffloat (sc);
+  vfloat = sc;
+
+  fdouble (UINT_MAX);
+  vdouble = UINT_MAX;
+  fdouble (ui);
+  vdouble = ui;
+  fdouble (si);
+  vdouble = si;
+}
+
+
+void fss (signed short x);
+void fus (unsigned short x);
+void fsc (signed char x);
+void fuc (unsigned char x);
+
+void h2 (void)
+{
+  unsigned short int us;
+  short int   ss;
+  unsigned char uc;
+  signed char sc;
+  
+  fss (4294967294.0); /* { dg-warning "conversion" } */
+  ss = 4294967294.0; /* { dg-warning "conversion" } */
+  fss (-4294967294.0);  /* { dg-warning "conversion" } */
+  ss = -4294967294.0;  /* { dg-warning "conversion" } */
+  fus (4294967294.0); /* { dg-warning "conversion" } */
+  us = 4294967294.0; /* { dg-warning "conversion" } */
+  fus (-4294967294.0);  /* { dg-warning "conversion" } */
+  us = -4294967294.0;  /* { dg-warning "conversion" } */
+
+  fsc (500.0); /* { dg-warning "conversion" } */
+  sc = 500.0; /* { dg-warning "conversion" } */
+  fsc (-500.0);  /* { dg-warning "conversion" } */
+  sc = -500.0;  /* { dg-warning "conversion" } */
+  fuc (500.0); /* { dg-warning "conversion" } */
+  uc = 500.0; /* { dg-warning "conversion" } */
+  fuc (-500.0);  /* { dg-warning "conversion" } */
+  uc = -500.0;  /* { dg-warning "conversion" } */
+
+  fss (500.0);
+  ss = 500.0;
+  fss (-500.0);
+  ss = -500.0;
+  fus (500.0); 
+  us = 500.0; 
+  fus (-500.0);   /* { dg-warning "conversion" } */
+  us = -500.0;    /* { dg-warning "conversion" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-real.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-real.c
new file mode 100644
index 000000000..06396fba3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wconversion-real.c
@@ -0,0 +1,83 @@
+/* Test for diagnostics for Wconversion for floating-point.  */
+
+/* { dg-do compile } */
+/* { dg-skip-if "doubles are floats" { "avr-*-*" } { "*" } { "" } } */
+/* { dg-options "-std=c99 -Wconversion" } */
+
+float  vfloat;
+double vdouble;
+long double vlongdouble;
+
+void ffloat (float f);
+void fdouble (double d);
+void flongdouble (long double ld);
+
+void h (void)
+{
+  float f = 0;
+  double d = 0;
+  long double ld = 0;
+
+  ffloat (3.1); /* { dg-warning "conversion" } */
+  vfloat = 3.1; /* { dg-warning "conversion" } */
+  ffloat (3.1L); /* { dg-warning "conversion" } */
+  vfloat = 3.1L;  /* { dg-warning "conversion" } */
+  fdouble (3.1L); /* { dg-warning "conversion" "" { target large_long_double } } */
+  vdouble = 3.1L; /* { dg-warning "conversion" "" { target large_long_double } } */
+  ffloat (vdouble); /* { dg-warning "conversion" } */
+  vfloat = vdouble; /* { dg-warning "conversion" } */
+  ffloat (vlongdouble); /* { dg-warning "conversion" } */
+  vfloat = vlongdouble; /* { dg-warning "conversion" } */
+  fdouble (vlongdouble); /* { dg-warning "conversion" "" { target large_long_double } } */
+  vdouble = vlongdouble; /* { dg-warning "conversion" "" { target large_long_double } } */
+
+
+  ffloat ((float) 3.1); 
+  vfloat = (float) 3.1;
+  ffloat ((float) 3.1L);
+  vfloat = (float) 3.1L; 
+  fdouble ((double) 3.1L); 
+  vdouble = (double) 3.1L; 
+  ffloat ((float) vdouble); 
+  vfloat = (float) vdouble; 
+  ffloat ((float) vlongdouble); 
+  vfloat = (float) vlongdouble;
+  fdouble ((double) vlongdouble);
+  vdouble = (double) vlongdouble;
+
+
+  ffloat (3.0);
+  vfloat = 3.0;
+  ffloat (3.1f);
+  vfloat = 3.1f;
+  ffloat (0.25L);
+  vfloat = 0.25L;
+
+
+  fdouble (3.0);
+  vdouble = 3.0;
+  fdouble (3.1f);
+  vdouble = 3.1f;
+  fdouble (0.25L);
+  vdouble = 0.25L;
+
+  flongdouble (3.0);
+  vlongdouble = 3.0;
+  flongdouble (3.1f);
+  vlongdouble = 3.1f;
+  flongdouble (0.25L);
+  vlongdouble = 0.25L;
+
+  ffloat (f);
+  vfloat = f;
+  fdouble (f);
+  vdouble = f;
+  fdouble (d);
+  vdouble = d;
+  flongdouble (f);
+  vlongdouble = f;
+  flongdouble (d);
+  vlongdouble = d;
+  flongdouble (ld);
+  vlongdouble = ld;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wcxx-compat-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wcxx-compat-1.c
new file mode 100644
index 000000000..91500421e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wcxx-compat-1.c
@@ -0,0 +1,11 @@
+/* PR c/21759  */
+/* { dg-options "-Wc++-compat" } */
+
+int
+main(void)
+{
+   void *p = 0;
+   int *q = p;                  /* { dg-warning "not permitted" } */
+   double* t = (void *)0;
+   return p != q;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wcxx-compat-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wcxx-compat-2.c
new file mode 100644
index 000000000..a091c6dd8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wcxx-compat-2.c
@@ -0,0 +1,36 @@
+/* { dg-options "-Wc++-compat" } */
+
+_Bool foo;			/* This is okay.  */
+int bool;			/* { dg-warning "keyword" } */
+int catch;			/* { dg-warning "keyword" } */
+int char16_t;			/* { dg-warning "keyword" } */
+int char32_t;			/* { dg-warning "keyword" } */
+int class;			/* { dg-warning "keyword" } */
+int const_cast;			/* { dg-warning "keyword" } */
+int decltype;			/* { dg-warning "keyword" } */
+int delete;			/* { dg-warning "keyword" } */
+int dynamic_cast;		/* { dg-warning "keyword" } */
+int explicit;			/* { dg-warning "keyword" } */
+int export;			/* { dg-warning "keyword" } */
+int false;			/* { dg-warning "keyword" } */
+int friend;			/* { dg-warning "keyword" } */
+int mutable;			/* { dg-warning "keyword" } */
+int namespace;			/* { dg-warning "keyword" } */
+int new;			/* { dg-warning "keyword" } */
+int operator;			/* { dg-warning "keyword" } */
+int private;			/* { dg-warning "keyword" } */
+int protected;			/* { dg-warning "keyword" } */
+int public;			/* { dg-warning "keyword" } */
+int reinterpret_cast;		/* { dg-warning "keyword" } */
+int static_assert;		/* { dg-warning "keyword" } */
+int static_cast;		/* { dg-warning "keyword" } */
+int template;			/* { dg-warning "keyword" } */
+int this;			/* { dg-warning "keyword" } */
+int throw;			/* { dg-warning "keyword" } */
+int true;			/* { dg-warning "keyword" } */
+int try;			/* { dg-warning "keyword" } */
+int typename;			/* { dg-warning "keyword" } */
+int typeid;			/* { dg-warning "keyword" } */
+int using;			/* { dg-warning "keyword" } */
+int virtual;			/* { dg-warning "keyword" } */
+int wchar_t;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-1.c
new file mode 100644
index 000000000..64a173a9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-1.c
@@ -0,0 +1,26 @@
+/* Test for -Wdeclaration-after-statement emitting warnings when no
+   standard-specifying option is given.  See also c9?-mixdecl-*.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-Wdeclaration-after-statement" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int i = 0;
+  if (i != 0)
+    abort ();
+  i++;
+  if (i != 1)
+    abort ();
+  int j = i;				/* { dg-warning "" "declaration after statement" } */
+  if (j != 1)
+    abort ();
+  struct foo { int i0; } k = { 4 };	/* { dg-warning "" "declaration after statement" } */
+  if (k.i0 != 4)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-2.c
new file mode 100644
index 000000000..ac89bbc26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-2.c
@@ -0,0 +1,26 @@
+/* Test for C99 mixed declarations and code giving warnings, not error with
+   -Wdeclaration-after-statement.  See also c9?-mixdecl-*.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=c99 -pedantic-errors -Wdeclaration-after-statement" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int i = 0;
+  if (i != 0)
+    abort ();
+  i++;
+  if (i != 1)
+    abort ();
+  int j = i;				/* { dg-warning "" "declaration-after-statement" } */
+  if (j != 1)
+    abort ();
+  struct foo { int i0; } k = { 4 };	/* { dg-warning "" "declaration-after-statement" } */
+  if (k.i0 != 4)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-3.c
new file mode 100644
index 000000000..63b2bac5d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wdeclaration-after-statement-3.c
@@ -0,0 +1,24 @@
+/* PR 35058: -Werror= works only with some warnings. */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic -Werror=declaration-after-statement" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int i = 0;
+  if (i != 0)
+    abort ();
+  i++;
+  if (i != 1)
+    abort ();
+  int j = i;				/* { dg-error "" "declaration-after-statement" } */
+  if (j != 1)
+    abort ();
+  struct foo { int i0; } k = { 4 };	/* { dg-error "" "declaration-after-statement" } */
+  if (k.i0 != 4)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-1.c
new file mode 100644
index 000000000..001af2452
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-Waddress -Wattributes -Werror -fshow-column" } */
+/* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */
+
+/* This is the first in a series of test cases that test the
+   interaction between -Wfoo, -Werror, -Werror=foo, and #pragma GCC
+   diagnostic error foo.  This one has all the bits we're testing, the
+   others are subsets of this one.  */
+
+#pragma GCC diagnostic error "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-error ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-error "7:.* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-10.c
new file mode 100644
index 000000000..dced20cf0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-10.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes -Werror" } */
+/* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */
+
+/* Make sure #pragma can work with -Werror.  */
+
+#pragma GCC diagnostic error "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-error ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-error ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-11.c
new file mode 100644
index 000000000..3fb892ee6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-11.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes -Werror" } */
+/* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */
+
+/* Make sure #pragma can override -Werror.  */
+
+#pragma GCC diagnostic warning "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-error ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-warning ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-12.c
new file mode 100644
index 000000000..4f0bd1762
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-12.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes -Waddress" } */
+
+/* Make sure #pragma can override -Wfoo.  */
+
+#pragma GCC diagnostic ignored "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-warning "attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-bogus "true" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-2.c
new file mode 100644
index 000000000..65f285edd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* This one is the baseline.  Make sure with no option we get no
+   warnings.  */
+
+void __attribute__((dj)) bar() { }	/* { dg-warning ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-3.c
new file mode 100644
index 000000000..97874075d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-3.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-Waddress -Wattributes" } */
+
+/* Make sure the command line option enables the warning.  */
+
+void __attribute__((dj)) bar() { }	/* { dg-warning ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-warning ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-4.c
new file mode 100644
index 000000000..272f123c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-4.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes" } */
+
+/* Make sure the pragma enables the error.  */
+
+#pragma GCC diagnostic error "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-warning ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-error ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-5.c
new file mode 100644
index 000000000..c03fc3b51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-5.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-Waddress -Wattributes -Werror" } */
+/* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */
+
+/* Make sure -Werror turns warnings in to errors.  */
+
+void __attribute__((dj)) bar() { }	/* { dg-error ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-error ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-6.c
new file mode 100644
index 000000000..2c3771716
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-6.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes -Werror=address" } */
+
+/* Make sure -Werror-foo emits an error and not a warning */
+
+void __attribute__((dj)) bar() { }	/* { dg-warning ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-error ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-7.c
new file mode 100644
index 000000000..bafb5c924
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-7.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-Waddress -Werror -Wno-error=address -Wattributes" } */
+/* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */
+
+/* Make sure -Wno-error= overrides -Werror.  */
+
+void __attribute__((dj)) bar() { }	/* { dg-error ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-warning ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-8.c
new file mode 100644
index 000000000..23079ce9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-8.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes" } */
+
+/* Make sure #pragma can enable a warning.  */
+
+#pragma GCC diagnostic warning "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-warning ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-warning ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-9.c
new file mode 100644
index 000000000..87051146a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-9.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-Wattributes" } */
+
+/* Make sure #pragma can enable a warning as an error.  */
+
+#pragma GCC diagnostic error "-Waddress"
+
+void __attribute__((dj)) bar() { }	/* { dg-warning ".* attribute directive ignored" } */
+
+int i;
+
+void
+foo ()
+{
+  if (&i)	/* { dg-error ".* will always evaluate as 'true'" } */
+    grill ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-implicit-function-declaration.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-implicit-function-declaration.c
new file mode 100644
index 000000000..05b8c0296
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Werror-implicit-function-declaration.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -Werror-implicit-function-declaration" } */
+
+void f(void) 
+{ 
+  puts("Hello"); /* { dg-error "implicit declaration of function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfatal-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfatal-2.c
new file mode 100644
index 000000000..ba76e77bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfatal-2.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-Woverflow -Wdiv-by-zero -Werror -Wfatal-errors" } */
+#include <limits.h>
+
+int i = INT_MAX + 1; /* { dg-error "integer overflow in expression" } */
+int k = 1 / 0; 
+int j = INT_MIN - 1;
+/* { dg-message "being treated as errors" "" { target *-*-* } 0 } */
+/* { dg-message "terminated due to -Wfatal-errors" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfatal.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfatal.c
new file mode 100644
index 000000000..3a101000d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfatal.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-Woverflow -Werror=div-by-zero -Wfatal-errors" } */
+#include <limits.h>
+
+int i = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+int k = 1 / 0; /* { dg-error "division by zero" } */
+int j = INT_MIN - 1;
+/* { dg-message "terminated due to -Wfatal-errors" "" { target *-*-* } 0 } */
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfloat-equal-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfloat-equal-1.c
new file mode 100644
index 000000000..36b3fa53f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wfloat-equal-1.c
@@ -0,0 +1,10 @@
+/* PR c/19999 */
+/* { dg-do compile } */
+/* { dg-options "-Wfloat-equal" } */
+
+double a, b;
+_Complex double c, d;
+int f(void) { return a == b; } /* { dg-warning "comparing floating point" } */
+int g(void) { return c == d; } /* { dg-warning "comparing floating point" } */
+int h(void) { return a != b; } /* { dg-warning "comparing floating point" } */
+int i(void) { return c != d; } /* { dg-warning "comparing floating point" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wframe-larger-than.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wframe-larger-than.c
new file mode 100644
index 000000000..fab0adf37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wframe-larger-than.c
@@ -0,0 +1,13 @@
+/* Test -Wframe-larger-than for warning
+   when the frame size is bigger than specified.
+   Origin: Seongbae Park <seongbae.park@gmail.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wframe-larger-than=2048" } */
+
+extern void func(char *);
+
+void foo (void) {
+  char array[4096];
+  func(array);
+} /* { dg-warning "the frame size of .* bytes is larger than 2048 bytes" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89-default.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89-default.c
new file mode 100644
index 000000000..c725ffaca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89-default.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+
+void f(void) 
+{ 
+  puts("Hello"); /* { dg-bogus "warning: implicit declaration of function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89-pedantic.c
new file mode 100644
index 000000000..5491aea79
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89-pedantic.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic-errors -Wimplicit-function-declaration" } */
+
+void f(void) 
+{ 
+  puts("Hello"); /* { dg-warning "implicit declaration of function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89.c
new file mode 100644
index 000000000..441899edb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c89.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -Wimplicit-function-declaration" } */
+
+void f(void) 
+{ 
+  puts("Hello"); /* { dg-warning "implicit declaration of function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c99-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c99-pedantic.c
new file mode 100644
index 000000000..05cca9a2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c99-pedantic.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors -Wall" } */
+
+void f(void) 
+{ 
+  puts("Hello"); /* { dg-error "implicit declaration of function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c99.c
new file mode 100644
index 000000000..254f7e70e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wimplicit-function-declaration-c99.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+void f(void) 
+{ 
+  puts("Hello"); /* { dg-warning "implicit declaration of function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-1.c
new file mode 100644
index 000000000..a7687a607
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-1.c
@@ -0,0 +1,12 @@
+/* Test -Wint-to-pointer-cast - on by default.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+char c;
+
+void *
+f (void)
+{
+  return (void *) c; /* { dg-warning "cast to pointer from integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-2.c
new file mode 100644
index 000000000..5546abb81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-2.c
@@ -0,0 +1,12 @@
+/* Test -Wint-to-pointer-cast.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wint-to-pointer-cast" } */
+
+char c;
+
+void *
+f (void)
+{
+  return (void *) c; /* { dg-warning "cast to pointer from integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-3.c
new file mode 100644
index 000000000..f4309a907
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wint-to-pointer-cast-3.c
@@ -0,0 +1,20 @@
+/* Test -Wno-int-to-pointer-cast.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wno-int-to-pointer-cast" } */
+
+char c;
+
+void *
+f (void)
+{
+  return (void *) c;
+}
+
+void *p;
+
+char
+g (void)
+{
+  return (char) p; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlarger-than.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlarger-than.c
new file mode 100644
index 000000000..609a7ae4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlarger-than.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wlarger-than-32768" } */
+
+/* -Wlarger-than with functions returning void used to segfault.
+   Source: PR 602, testsuite-ized by Neil Booth 21 Jan 2000.  */
+
+static void foo (void) {}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlarger-than2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlarger-than2.c
new file mode 100644
index 000000000..eac67f48b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlarger-than2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-Wlarger-than=8" } */
+static void foo (void) 
+{
+  char buf[9]; /* { dg-warning "size of.*9 bytes" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlogical-op-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlogical-op-1.c
new file mode 100644
index 000000000..d9687bf09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wlogical-op-1.c
@@ -0,0 +1,47 @@
+/*
+   { dg-do compile}
+   { dg-options "-Wlogical-op" }
+*/
+
+enum { a, ba, b };
+
+enum testenum { t1, t2};
+
+extern int c;
+extern char bool_a, bool_b;
+
+extern int testa();
+
+void foo()
+{
+    if ( testa() && b )     /* { dg-warning "always evaluate as" } */
+         (void)testa();
+
+    if ( c && b )           /* { dg-warning "always evaluate as" } */
+	(void)testa();
+
+    if ( c && 0x42 )        /* { dg-warning "always evaluate as" } */
+	(void)testa();
+
+    if ( c && 0x42 )        /* { dg-warning "always evaluate as" } */
+	(void) testa();
+
+    if ( c && 0x80 >>6)     /* { dg-warning "always evaluate as" } */
+	(void)testa();
+
+
+    if ( b && c == a )      /* { dg-bogus "always evaluate as" } */
+          (void)testa();
+
+    if ( 1 && c )           /* { dg-bogus "always evaluate as" } */
+         (void)testa();
+
+    if ( t2 && b )          /* { dg-bogus "always evaluate as" } */
+          (void)testa();
+
+    if ( 0 && c == a )      /* { dg-bogus "always evaluate as" } */
+          (void)testa();
+
+    if ( b && 1 )           /* { dg-bogus "always evaluate as" } */
+          (void)testa();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type-Wextra.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type-Wextra.c
new file mode 100644
index 000000000..37e1a571b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type-Wextra.c
@@ -0,0 +1,7 @@
+/* Test -Wmissing-parameter-type is enabled by -Wextra */
+/* { dg-do compile } */
+/* { dg-options "-Wextra" } */
+
+int foo(bar) { return bar;} /* { dg-warning "type of 'bar' defaults to 'int'" } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type-no.c
new file mode 100644
index 000000000..1031e57a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type-no.c
@@ -0,0 +1,7 @@
+/* Test that we can disable -Wmissing-parameter-type */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wextra -Wno-missing-parameter-type" } */
+
+int foo(bar) { return bar;} /* { dg-bogus "type of 'bar' defaults to 'int'" } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type.c
new file mode 100644
index 000000000..8ec94e2ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wmissing-parameter-type.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-Wmissing-parameter-type" } */
+
+int foo(bar) { return bar; } /* { dg-warning "type of 'bar' defaults to 'int'" } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wnested-externs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wnested-externs-1.c
new file mode 100644
index 000000000..5c4b5ddd8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wnested-externs-1.c
@@ -0,0 +1,22 @@
+/* Test -Wnested-externs.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wnested-externs" } */
+
+int a;
+static int b;
+extern int c;
+void f0(void);
+static void f1(void);
+
+void
+g(void)
+{
+  extern int a; /* { dg-warning "nested extern declaration of 'a'" } */
+  extern int b; /* { dg-warning "nested extern declaration of 'b'" } */
+  extern int c; /* { dg-warning "nested extern declaration of 'c'" } */
+  extern int d; /* { dg-warning "nested extern declaration of 'd'" } */
+  extern void f0(void); /* { dg-warning "nested extern declaration of 'f0'" } */
+  extern void f1(void); /* { dg-warning "nested extern declaration of 'f1'" } */
+  extern void f2(void); /* { dg-warning "nested extern declaration of 'f2'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-all.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-all.c
new file mode 100644
index 000000000..de55bbcda
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-all.c
@@ -0,0 +1,10 @@
+/* PR 30437: Test negative of -Wall
+   Don't change this without changing Wall.c as well.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wno-all" } */
+
+void foo(int a)
+{
+  5 * (a == 1) | (a == 2);  /* { dg-bogus "no effect" "no effect" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-c++-compat.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-c++-compat.c
new file mode 100644
index 000000000..1fda016e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-c++-compat.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2005  Free Software Foundation.
+
+   by Gabriel Dos Reis  <gdr@integrable-solutions.net>  */
+
+/* { dg-do compile }  */
+/* { dg-options "-Wno-c++-compat" } */
+
+extern const int foo = 42;      /* { dg-warning "initialized and declared" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-pointer-sign.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-pointer-sign.c
new file mode 100644
index 000000000..780c9d4e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wno-pointer-sign.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-Wno-pointer-sign" } */
+
+void f1(long *);
+void f2(unsigned long *);
+
+int main()
+{
+  long *lp;
+  unsigned long *ulp;
+  char *cp;
+  unsigned char *ucp;
+  signed char *scp;
+
+  ulp = lp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  lp = ulp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  f1(ulp);	/* { dg-bogus " differ in signedness" } */
+  f2(lp);	/* { dg-bogus " differ in signedness" } */
+
+  cp = ucp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  cp = scp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  ucp = scp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  ucp = cp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  scp = ucp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+  scp = cp;	/* { dg-bogus " pointer targets in assignment differ in signedness" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wold-style-definition-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wold-style-definition-1.c
new file mode 100644
index 000000000..aa016338b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wold-style-definition-1.c
@@ -0,0 +1,24 @@
+/* Test for warning about old-style function definition.  */
+
+/* Origin: Andreas Jaeger <aj@suse.de> */
+/* { dg-do compile } */
+/* { dg-options "-Wold-style-definition" } */
+
+void
+bar (a) int a; { } /* { dg-warning "old-style function definition" } */
+
+void bar1 () {} /* { dg-warning "old-style function definition" } */
+
+extern void bar2 (void);
+
+void bar2 () {} /* { dg-warning "old-style function definition" } */
+
+extern void bar3 (int);
+
+void bar3 (a) {} /* { dg-warning "old-style function definition" } */
+
+void bar4 (a) {} /* { dg-warning "old-style function definition" } */
+
+void bar5 (int a) {}
+
+void bar6 (void) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wold-style-definition-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wold-style-definition-2.c
new file mode 100644
index 000000000..a69aae6fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wold-style-definition-2.c
@@ -0,0 +1,10 @@
+/* PR c/12466
+   Test for not warning about ellipsises with -Wold-style-definition. */
+
+/* Origin: Kelley Cook <kcook@gcc.gnu.org> */
+/* { dg-do compile } */
+/* { dg-options "-Wold-style-definition" } */
+
+void bar1 ( ... ) {} /* { dg-error "ISO C requires a named argument" } */
+
+void bar2 (int a, ... ) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-1.c
new file mode 100644
index 000000000..064af4561
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+#include <limits.h>
+
+int foo = INT_MAX + 1;  /* { dg-warning "integer overflow" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-2.c
new file mode 100644
index 000000000..44368b66f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Woverflow" } */
+
+#include <limits.h>
+
+int foo = INT_MAX + 1;  /* { dg-warning "integer overflow" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-3.c
new file mode 100644
index 000000000..73a021b59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverflow-3.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wno-overflow" } */
+
+#include <limits.h>
+
+int foo = INT_MAX + 1;
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c89-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c89-no.c
new file mode 100644
index 000000000..a2ccbddf2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c89-no.c
@@ -0,0 +1,19 @@
+/* -Woverlength-strings complains about string constants which are too long
+   for the C standard's "minimum maximum" limits.  It is off by default,
+   but implied by -pedantic.  */
+
+/* { dg-options "-std=c89 -pedantic -Wno-overlength-strings" } */
+
+#define TEN "xxxxxxxxxx"
+#define HUN TEN TEN TEN TEN TEN  TEN TEN TEN TEN TEN
+#define THO HUN HUN HUN HUN HUN  HUN HUN HUN HUN HUN
+
+/* C89's minimum-maximum is 509. */
+const char x510[] = HUN HUN HUN HUN HUN TEN;
+
+/* C99's minimum-maximum is 4095.  */
+const char x4096[] =
+  THO THO THO THO     /* 4000 */
+  TEN TEN TEN TEN TEN /* 4050 */
+  TEN TEN TEN TEN     /* 4090 */
+  "123456";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c89.c
new file mode 100644
index 000000000..9370acf84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c89.c
@@ -0,0 +1,19 @@
+/* -Woverlength-strings complains about string constants which are too long
+   for the C standard's "minimum maximum" limits.  It is off by default,
+   but implied by -pedantic.  */
+
+/* { dg-options "-std=c89 -pedantic" } */
+
+#define TEN "xxxxxxxxxx"
+#define HUN TEN TEN TEN TEN TEN  TEN TEN TEN TEN TEN
+#define THO HUN HUN HUN HUN HUN  HUN HUN HUN HUN HUN
+
+/* C89's minimum-maximum is 509. */
+const char x510[] = HUN HUN HUN HUN HUN TEN; /* { dg-warning "greater than" } */
+
+/* C99's minimum-maximum is 4095.  */
+const char x4096[] =
+  THO THO THO THO     /* 4000 */
+  TEN TEN TEN TEN TEN /* 4050 */
+  TEN TEN TEN TEN     /* 4090 */
+  "123456";  /* { dg-warning "greater than" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c99-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c99-no.c
new file mode 100644
index 000000000..a44a21409
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c99-no.c
@@ -0,0 +1,19 @@
+/* -Woverlength-strings complains about string constants which are too long
+   for the C standard's "minimum maximum" limits.  It is off by default,
+   but implied by -pedantic.  */
+
+/* { dg-options "-std=c99 -pedantic -Wno-overlength-strings" } */
+
+#define TEN "xxxxxxxxxx"
+#define HUN TEN TEN TEN TEN TEN  TEN TEN TEN TEN TEN
+#define THO HUN HUN HUN HUN HUN  HUN HUN HUN HUN HUN
+
+/* C89's minimum-maximum is 509. */
+const char x510[] = HUN HUN HUN HUN HUN TEN;
+
+/* C99's minimum-maximum is 4095.  */
+const char x4096[] =
+  THO THO THO THO     /* 4000 */
+  TEN TEN TEN TEN TEN /* 4050 */
+  TEN TEN TEN TEN     /* 4090 */
+  "123456";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c99.c
new file mode 100644
index 000000000..e7f512192
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings-pedantic-c99.c
@@ -0,0 +1,19 @@
+/* -Woverlength-strings complains about string constants which are too long
+   for the C standard's "minimum maximum" limits.  It is off by default,
+   but implied by -pedantic.  */
+
+/* { dg-options "-std=c99 -pedantic" } */
+
+#define TEN "xxxxxxxxxx"
+#define HUN TEN TEN TEN TEN TEN  TEN TEN TEN TEN TEN
+#define THO HUN HUN HUN HUN HUN  HUN HUN HUN HUN HUN
+
+/* C89's minimum-maximum is 509. */
+const char x510[] = HUN HUN HUN HUN HUN TEN;
+
+/* C99's minimum-maximum is 4095.  */
+const char x4096[] =
+  THO THO THO THO     /* 4000 */
+  TEN TEN TEN TEN TEN /* 4050 */
+  TEN TEN TEN TEN     /* 4090 */
+  "123456";  /* { dg-warning "greater than" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings.c
new file mode 100644
index 000000000..d02e18ea2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverlength-strings.c
@@ -0,0 +1,19 @@
+/* -Woverlength-strings complains about string constants which are too long
+   for the C standard's "minimum maximum" limits.  It is off by default,
+   but implied by -pedantic.  */
+
+/* { dg-options "" } */
+
+#define TEN "xxxxxxxxxx"
+#define HUN TEN TEN TEN TEN TEN  TEN TEN TEN TEN TEN
+#define THO HUN HUN HUN HUN HUN  HUN HUN HUN HUN HUN
+
+/* C89's minimum-maximum is 509. */
+const char x510[] = HUN HUN HUN HUN HUN TEN;
+
+/* C99's minimum-maximum is 4095.  */
+const char x4096[] =
+  THO THO THO THO     /* 4000 */
+  TEN TEN TEN TEN TEN /* 4050 */
+  TEN TEN TEN TEN     /* 4090 */
+  "123456";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-1.c
new file mode 100644
index 000000000..29eca3095
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-1.c
@@ -0,0 +1,28 @@
+/* Test for warnings for overriding designated initializers:
+   -Woverride-init.  Bug 24010.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Woverride-init" } */
+
+struct s { int a; int b; int c; };
+union u { char a; long long b; };
+
+struct s s0 = {
+  .a = 1,
+  .b = 2,
+  .a = 3, /* { dg-warning "initialized field overwritten|near init" } */
+  4, /* { dg-warning "initialized field overwritten|near init" } */
+  5
+};
+
+union u u0 = {
+  .a = 1,
+  .b = 2, /* { dg-warning "initialized field overwritten|near init" } */
+  .a = 3 }; /* { dg-warning "initialized field overwritten|near init" } */
+
+int a[5] = {
+  [0] = 1,
+  [1] = 2,
+  [0] = 3, /* { dg-warning "initialized field overwritten|near init" } */
+  [2] = 4
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-2.c
new file mode 100644
index 000000000..c5490b5ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-2.c
@@ -0,0 +1,28 @@
+/* Test for warnings for overriding designated initializers:
+   -Wextra.  Bug 24010.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wextra" } */
+
+struct s { int a; int b; int c; };
+union u { char a; long long b; };
+
+struct s s0 = {
+  .a = 1,
+  .b = 2,
+  .a = 3, /* { dg-warning "initialized field overwritten|near init" } */
+  4, /* { dg-warning "initialized field overwritten|near init" } */
+  5
+};
+
+union u u0 = {
+  .a = 1,
+  .b = 2, /* { dg-warning "initialized field overwritten|near init" } */
+  .a = 3 }; /* { dg-warning "initialized field overwritten|near init" } */
+
+int a[5] = {
+  [0] = 1,
+  [1] = 2,
+  [0] = 3, /* { dg-warning "initialized field overwritten|near init" } */
+  [2] = 4
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-3.c
new file mode 100644
index 000000000..3fec7385d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Woverride-init-3.c
@@ -0,0 +1,29 @@
+/* Test for warnings for overriding designated initializers: not
+   warned for with -Wextra -Wno-override-init.  Bug 24010.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wextra -Wno-override-init" } */
+
+struct s { int a; int b; int c; };
+union u { char a; long long b; };
+
+struct s s0 = {
+  .a = 1,
+  .b = 2,
+  .a = 3,
+  4,
+  5
+};
+
+union u u0 = {
+  .a = 1,
+  .b = 2,
+  .a = 3
+};
+
+int a[5] = {
+  [0] = 1,
+  [1] = 2,
+  [0] = 3,
+  [2] = 4
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpadded.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpadded.c
new file mode 100644
index 000000000..9e69a9fef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpadded.c
@@ -0,0 +1,13 @@
+/* Source: EMC.  */
+
+/* { dg-do compile } */
+/* -fpack-struct is necessary because the warning expected requires the initial
+   packing to be larger than 1, which cannot be guaranteed for all targets.
+   We won't get a warning anyway if the target has "packed" structure
+   layout.  */
+/* { dg-options "-Wpadded -fpack-struct=8" } */
+
+struct foo {
+  char bar;
+  long baz; /* { dg-warning "padding struct to align" ""  { target { ! default_packed } } } */
+} futz;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-1.c
new file mode 100644
index 000000000..d6e86eb48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-1.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options -Wparentheses } */
+
+/* Source: Neil Booth, 1 Nov 2001.  PR 3170, 3422 - bogus warnings
+   about suggesting parentheses.  */
+
+int foo (int a, int b)
+{
+  int c = (a && b) || 0;	/* { dg-bogus "suggest parentheses" }  */
+  c = a && b || 0;		/* { dg-warning "suggest parentheses" }  */
+
+  return (a && b && 1) || 0;	/* { dg-bogus "suggest parentheses" }  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-10.c
new file mode 100644
index 000000000..aafcae2ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-10.c
@@ -0,0 +1,42 @@
+/* Test operation of -Wparentheses.  Warnings for assignments used as
+   truth-values shouldn't apply other than for plain assignment.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses -std=gnu99" } */
+
+int foo (int);
+
+int a, b, c;
+_Bool d;
+
+void
+bar (void)
+{
+  if (a += b)
+    foo (0);
+  if (a -= a)
+    foo (1);
+  if (b *= c)
+    foo (2);
+  else
+    foo (3);
+  if (b /= b)
+    foo (4);
+  else
+    foo (5);
+  while (c %= b)
+    foo (6);
+  while (c <<= c)
+    foo (7);
+  do foo (8); while (a >>= b);
+  do foo (9); while (a &= a);
+  for (;c ^= b;)
+    foo (10);
+  for (;c |= c;)
+    foo (11);
+  d = a += b;
+  foo (12);
+  d = a -= a;
+  foo (13);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-11.c
new file mode 100644
index 000000000..8858a7fb3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-11.c
@@ -0,0 +1,258 @@
+/* PR 7543. Test operation of -Wparentheses.  Precedence warnings.  
+   !a | b and !a & b. */
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (!a & b); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b < c));
+  foo (!a & (b > c));
+  foo (!a & (b == c));
+  foo (!a & (b != c));
+  foo (!a & (b <= c));
+  foo (!a & (b >= c));
+  foo (!a & (b && c));
+  foo (!a & (b || c));
+  foo (!a & !b);
+  foo (!(a & b));
+  foo ((!a) & b);
+  foo (!a & 2); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 < c));
+  foo (!a & (2 > c));
+  foo (!a & (2 == c));
+  foo (!a & (2 != c));
+  foo (!a & (2 <= c));
+  foo (!a & (2 >= c));
+  foo (!a & (2 && c));
+  foo (!a & (2 || c));
+  foo (!a & !2);
+  foo (!(a & 2));
+  foo ((!a) & 2);
+  foo (!1 & 2); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 < c));
+  foo (!1 & (2 > c));
+  foo (!1 & (2 == c));
+  foo (!1 & (2 != c));
+  foo (!1 & (2 <= c));
+  foo (!1 & (2 >= c));
+  foo (!1 & (2 && c));
+  foo (!1 & (2 || c));
+  foo (!1 & !2);
+  foo (!(1 & 2));
+
+  foo (!a | b); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b < c));
+  foo (!a | (b > c));
+  foo (!a | (b == c));
+  foo (!a | (b != c));
+  foo (!a | (b <= c));
+  foo (!a | (b >= c));
+  foo (!a | (b && c));
+  foo (!a | (b || c));
+  foo (!a | !b);
+  foo (!(a | b));
+  foo ((!a) | b);
+  foo (!a | 2); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 < c));
+  foo (!a | (2 > c));
+  foo (!a | (2 == c));
+  foo (!a | (2 != c));
+  foo (!a | (2 <= c));
+  foo (!a | (2 >= c));
+  foo (!a | (2 && c));
+  foo (!a | (2 || c));
+  foo (!a | !2);
+  foo (!(a | 2));
+  foo ((!a) | 2);
+  foo (!1 | 2); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 < c));
+  foo (!1 | (2 > c));
+  foo (!1 | (2 == c));
+  foo (!1 | (2 != c));
+  foo (!1 | (2 <= c));
+  foo (!1 | (2 >= c));
+  foo (!1 | (2 && c));
+  foo (!1 | (2 || c));
+  foo (!1 | !2);
+  foo (!(1 | 2));
+  foo ((!1) | 2);
+
+  foo (b & !a); /* { dg-bogus "parentheses" "bogus warning" } */
+  foo ((b < c) & !a);
+  foo ((b > c) & !a);
+  foo ((b == c) & !a);
+  foo ((b != c) & !a);
+  foo ((b <= c) & !a);
+  foo ((b >= c) & !a);
+  foo ((b && c) & !a);
+  foo ((b || c) & !a);
+  foo (!b & !a);
+  foo (!(b & a));
+  foo (b & (!a));
+  foo (2 & !a); /* { dg-bogus "parentheses" "correct warning" } */
+  foo ((2 < c) & !a);
+  foo ((2 > c) & !a);
+  foo ((2 == c) & !a);
+  foo ((2 != c) & !a);
+  foo ((2 <= c) & !a);
+  foo ((2 >= c) & !a);
+  foo ((2 && c) & !a);
+  foo ((2 || c) & !a);
+  foo (!2 & !a);
+  foo (!(2 & a));
+  foo (2 & (!a));
+  foo (2 & !1); /* { dg-bogus "parentheses" "correct warning" } */
+  foo ((2 < c) & !1);
+  foo ((2 > c) & !1);
+  foo ((2 == c) & !1);
+  foo ((2 != c) & !1);
+  foo ((2 <= c) & !1);
+  foo ((2 >= c) & !1);
+  foo ((2 && c) & !1);
+  foo ((2 || c) & !1);
+  foo (!2 & !1);
+  foo (!(2 & 1));
+
+  foo (b | !a); /* { dg-bogus "parentheses" "correct warning" } */
+  foo ((b < c) | !a);
+  foo ((b > c) | !a);
+  foo ((b == c) | !a);
+  foo ((b != c) | !a);
+  foo ((b <= c) | !a);
+  foo ((b >= c) | !a);
+  foo ((b && c) | !a);
+  foo ((b || c) | !a);
+  foo (!b | !a);
+  foo (!(b | a));
+  foo (b | (!a));
+  foo (2 | !a); /* { dg-bogus "parentheses" "correct warning" } */
+  foo ((2 < c) | !a);
+  foo ((2 > c) | !a);
+  foo ((2 == c) | !a);
+  foo ((2 != c) | !a);
+  foo ((2 <= c) | !a);
+  foo ((2 >= c) | !a);
+  foo ((2 && c) | !a);
+  foo ((2 || c) | !a);
+  foo (!2 | !a);
+  foo (!(2 | a));
+  foo (2 | (!a));
+  foo (2 | !1); /* { dg-bogus "parentheses" "correct warning" } */
+  foo ((2 < c) | !1);
+  foo ((2 > c) | !1);
+  foo ((2 == c) | !1);
+  foo ((2 != c) | !1);
+  foo ((2 <= c) | !1);
+  foo ((2 >= c) | !1);
+  foo ((2 && c) | !1);
+  foo ((2 || c) | !1);
+  foo (!2 | !1);
+  foo (!(2 | 1));
+  foo (2 | (!1));
+}
+
+int
+baz (int a, int b, int c)
+{
+  foo (!a & (b << c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b >> c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b + c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b - c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b = c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & ~b);      /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b & c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (b | c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & 2);       /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 << c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & ~2);      /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a & (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 << c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & ~2);      /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 & (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b << c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b >> c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b + c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b - c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b = c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | ~b);      /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b & c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (b | c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 << c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | ~2);      /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!a | (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 << c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 >> c));/* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 + c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 - c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (c = 2)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | ~2);      /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 & c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo (!1 | (2 | c)); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((b << c) & !a);
+  foo ((b >> c) & !a);
+  foo ((b + c) & !a);
+  foo ((b - c) & !a);
+  foo ((b = c) & !a);
+  foo (~b & !a);
+  foo ((b & c) & !a);
+  foo ((b | c) & !a);
+  foo ((2 << c) & !a);
+  foo ((2 >> c) & !a);
+  foo ((2 + c) & !a);
+  foo ((2 - c) & !a);
+  foo ((c = 2) & !a);
+  foo (~2 & !a);
+  foo ((2 & c) & !a);
+  foo ((2 | c) & !a);
+  foo ((2 << c) & !1);
+  foo ((2 >> c) & !1);
+  foo ((2 + c) & !1);
+  foo ((2 - c) & !1);
+  foo ((c = 2) & !1);
+  foo (~2 & !1);
+  foo ((2 & c) & !1);
+  foo ((2 | c) & !1);
+  foo ((b << c) | !a);
+  foo ((b >> c) | !a);
+  foo ((b + c) | !a);
+  foo ((b - c) | !a);
+  foo ((b = c) | !a);
+  foo (~b | !a);
+  foo ((b & c) | !a);
+  foo ((b | c) | !a);
+  foo ((2 << c) | !a);
+  foo ((2 >> c) | !a);
+  foo ((2 + c) | !a);
+  foo ((2 - c) | !a);
+  foo ((c = 2) | !a);
+  foo (~2 | !a);
+  foo ((2 & c) | !a);
+  foo ((2 | c) | !a);
+  foo ((2 << c) | !1);
+  foo ((2 >> c) | !1);
+  foo ((2 + c) | !1);
+  foo ((2 - c) | !1);
+  foo ((c = 2) | !1);
+  foo (~2 | !1);
+  foo ((2 & c) | !1);
+  foo ((2 | c) | !1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-2.c
new file mode 100644
index 000000000..51038c2d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-2.c
@@ -0,0 +1,121 @@
+/* Test operation of -Wparentheses.  Warnings for X<=Y<=Z should be
+   there rather than hidden in -Wextra.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (a <= b <= c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((a <= b) <= c);
+  foo (a <= (b <= c));
+  foo (1 <= 2 <= c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 <= 2) <= c);
+  foo (1 <= (2 <= c));
+  foo (1 <= 2 <= 3); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 <= 2) <= 3);
+  foo (1 <= (2 <= 3));
+  foo (a > b > c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((a > b) > c);
+  foo (a > (b > c));
+  foo (1 > 2 > c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 > 2) > c);
+  foo (1 > (2 > c));
+  foo (1 > 2 > 3); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 > 2) > 3);
+  foo (1 > (2 > 3));
+  foo (a < b <= c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((a < b) <= c);
+  foo (a < (b <= c));
+  foo (1 < 2 <= c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 < 2) <= c);
+  foo (1 < (2 <= c));
+  foo (1 < 2 <= 3); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 < 2) <= 3);
+  foo (1 < (2 <= 3));
+  foo (a <= b > c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((a <= b) > c);
+  foo (a <= (b > c));
+  foo (1 <= 2 > c); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 <= 2) > c);
+  foo (1 <= (2 > c));
+  foo (1 <= 2 > 3); /* { dg-warning "mathematical meaning" "correct warning" } */
+  foo ((1 <= 2) > 3);
+  foo (1 <= (2 > 3));
+  foo (a <= b == c); /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a <= b) == c);
+  foo (a <= (b == c));
+  foo (1 <= 2 == c); /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 <= 2) == c);
+  foo (1 <= (2 == c));
+  foo (1 <= 2 == 3); /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 <= 2) == 3);
+  foo (1 <= (2 == 3));
+  foo (a != b != c); /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a != b) != c);
+  foo (a != (b != c));
+  foo (1 != 2 != c); /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 != 2) != c);
+  foo (1 != (2 != c));
+  foo (1 != 2 != 3); /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 != 2) != 3);
+  foo (1 != (2 != 3));
+  foo (a < b == c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a < b) == c);
+  foo (a < (b == c));
+  foo (a > b == c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a > b) == c);
+  foo (a > (b == c));
+  foo (a == b < c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a == b) < c);
+  foo (a == (b < c));
+  foo (a == b > c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a == b) > c);
+  foo (a == (b > c));
+  foo (a == b == c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a == b) == c);
+  foo (a == (b == c));
+  foo (1 == 2 == 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 == 2) == 3);
+  foo (1 == (2 == 3));
+  foo (1 < 2 == 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 < 2) == 3);
+  foo (1 < (2 == 3));
+  foo (1 > 2 == 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 > 2) == 3);
+  foo (1 > (2 == 3));
+  foo (1 == 2 < 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 == 2) < 3);
+  foo (1 == (2 < 3));
+  foo (1 == 2 > 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 == 2) > 3);
+  foo (1 == (2 > 3));
+  foo (a < b != c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a < b) != c);
+  foo (a < (b != c));
+  foo (a > b != c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a > b) != c);
+  foo (a > (b != c));
+  foo (a != b < c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a != b) < c);
+  foo (a != (b < c));
+  foo (a != b > c);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((a != b) > c);
+  foo (a != (b > c));
+  foo (1 < 2 != 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 < 2) != 3);
+  foo (1 < (2 != 3));
+  foo (1 > 2 != 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 > 2) != 3);
+  foo (1 > (2 != 3));
+  foo (1 != 2 < 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 != 2) < 3);
+  foo (1 != (2 < 3));
+  foo (1 != 2 > 3);  /* { dg-warning "suggest parentheses around comparison" "correct warning" } */
+  foo ((1 != 2) > 3);
+  foo (1 != (2 > 3));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-3.c
new file mode 100644
index 000000000..64899887c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-3.c
@@ -0,0 +1,68 @@
+/* Test operation of -Wparentheses.  Warnings for assignments used as
+   truth-values.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses -std=gnu99" } */
+
+int foo (int);
+
+int a, b, c;
+_Bool d;
+
+int
+bar (void)
+{
+  if (a = b) /* { dg-warning "assignment" "correct warning" } */
+    foo (0);
+  if ((a = b))
+    foo (1);
+  if (a = a) /* { dg-warning "assignment" "correct warning" } */
+    foo (2);
+  if ((a = a))
+    foo (3);
+  if (b = c) /* { dg-warning "assignment" "correct warning" } */
+    foo (4);
+  else
+    foo (5);
+  if ((b = c))
+    foo (6);
+  else
+    foo (7);
+  if (b = b) /* { dg-warning "assignment" "correct warning" } */
+    foo (8);
+  else
+    foo (9);
+  if ((b = b))
+    foo (10);
+  else
+    foo (11);
+  while (c = b) /* { dg-warning "assignment" "correct warning" } */
+    foo (12);
+  while ((c = b))
+    foo (13);
+  while (c = c) /* { dg-warning "assignment" "correct warning" } */
+    foo (14);
+  while ((c = c))
+    foo (15);
+  do foo (16); while (a = b); /* { dg-warning "assignment" "correct warning" } */
+  do foo (17); while ((a = b));
+  do foo (18); while (a = a); /* { dg-warning "assignment" "correct warning" } */
+  do foo (19); while ((a = a));
+  for (;c = b;) /* { dg-warning "assignment" "correct warning" } */
+    foo (20);
+  for (;(c = b);)
+    foo (21);
+  for (;c = c;) /* { dg-warning "assignment" "correct warning" } */
+    foo (22);
+  for (;(c = c);)
+    foo (23);
+  d = a = b; /* { dg-warning "assignment" "correct warning" } */
+  foo (24);
+  d = (a = b);
+  foo (25);
+  d = a = a; /* { dg-warning "assignment" "correct warning" } */
+  foo (26);
+  d = (a = a);
+  foo (27);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-4.c
new file mode 100644
index 000000000..dfc9d1008
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-4.c
@@ -0,0 +1,85 @@
+/* Test operation of -Wparentheses.  Precedence warnings.  + or -
+   inside shift.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (a + b << c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a + b) << c);
+  foo (a + (b << c));
+  foo (1 + 2 << c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) << c);
+  foo (1 + (2 << c));
+  foo (1 + 2 << 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) << 3);
+  foo (1 + (2 << 3));
+  foo (a << b + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a << b) + c);
+  foo (a << (b + c));
+  foo (1 << 2 + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 << 2) + c);
+  foo (1 << (2 + c));
+  foo (1 << 2 + 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 << 2) + 3);
+  foo (1 << (2 + 3));
+  foo (a + b >> c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a + b) >> c);
+  foo (a + (b >> c));
+  foo (1 + 2 >> c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) >> c);
+  foo (1 + (2 >> c));
+  foo (1 + 2 >> 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) >> 3);
+  foo (1 + (2 >> 3));
+  foo (a >> b + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a >> b) + c);
+  foo (a >> (b + c));
+  foo (1 >> 2 + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 >> 2) + c);
+  foo (1 >> (2 + c));
+  foo (1 >> 2 + 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 >> 2) + 3);
+  foo (1 >> (2 + 3));
+  foo (a - b << c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a - b) << c);
+  foo (a - (b << c));
+  foo (6 - 5 << c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 - 5) << c);
+  foo (6 - (5 << c));
+  foo (6 - 5 << 4); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 - 5) << 4);
+  foo (6 - (5 << 4));
+  foo (a << b - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a << b) - c);
+  foo (a << (b - c));
+  foo (6 << 5 - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 << 5) - c);
+  foo (6 << (5 - c));
+  foo (6 << 5 - 4); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 << 5) - 4);
+  foo (6 << (5 - 4));
+  foo (a - b >> c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a - b) >> c);
+  foo (a - (b >> c));
+  foo (6 - 5 >> c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 - 5) >> c);
+  foo (6 - (5 >> c));
+  foo (6 - 5 >> 4); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 - 5) >> 4);
+  foo (6 - (5 >> 4));
+  foo (a >> b - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a >> b) - c);
+  foo (a >> (b - c));
+  foo (6 >> 5 - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 >> 5) - c);
+  foo (6 >> (5 - c));
+  foo (6 >> 5 - 4); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((6 >> 5) - 4);
+  foo (6 >> (5 - 4));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-5.c
new file mode 100644
index 000000000..49c65c21a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-5.c
@@ -0,0 +1,31 @@
+/* Test operation of -Wparentheses.  Precedence warnings.  && inside
+   ||.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (a && b || c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a && b) || c);
+  foo (a && (b || c));
+  foo (1 && 2 || c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 && 2) || c);
+  foo (1 && (2 || c));
+  foo (1 && 2 || 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 && 2) || 3);
+  foo (1 && (2 || 3));
+  foo (a || b && c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a || b) && c);
+  foo (a || (b && c));
+  foo (1 || 2 && c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 || 2) && c);
+  foo (1 || (2 && c));
+  foo (1 || 2 && 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 || 2) && 3);
+  foo (1 || (2 && 3));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-6.c
new file mode 100644
index 000000000..2d2cc1613
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-6.c
@@ -0,0 +1,121 @@
+/* Test operation of -Wparentheses.  Precedence warnings.  & or ^ or +
+   or - or comparison inside |.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (a & b | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) | c);
+  foo (a & (b | c));
+  foo (1 & 2 | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) | c);
+  foo (1 & (2 | c));
+  foo (1 & 2 | 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) | 3);
+  foo (1 & (2 | 3));
+  foo (a | b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a | b) & c);
+  foo (a | (b & c));
+  foo (1 | 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) & c);
+  foo (1 | (2 & c));
+  foo (1 | 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) & 3);
+  foo (1 | (2 & 3));
+  foo (a ^ b | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) | c);
+  foo (a ^ (b | c));
+  foo (1 ^ 2 | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) | c);
+  foo (1 ^ (2 | c));
+  foo (1 ^ 2 | 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) | 3);
+  foo (1 ^ (2 | 3));
+  foo (a | b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a | b) ^ c);
+  foo (a | (b ^ c));
+  foo (1 | 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) ^ c);
+  foo (1 | (2 ^ c));
+  foo (1 | 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) ^ 3);
+  foo (1 | (2 ^ 3));
+  foo (a + b | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a + b) | c);
+  foo (a + (b | c));
+  foo (1 + 2 | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) | c);
+  foo (1 + (2 | c));
+  foo (1 + 2 | 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) | 3);
+  foo (1 + (2 | 3));
+  foo (a | b + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a | b) + c);
+  foo (a | (b + c));
+  foo (1 | 2 + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) + c);
+  foo (1 | (2 + c));
+  foo (1 | 2 + 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) + 3);
+  foo (1 | (2 + 3));
+  foo (a - b | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a - b) | c);
+  foo (a - (b | c));
+  foo (1 - 2 | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 - 2) | c);
+  foo (1 - (2 | c));
+  foo (1 - 2 | 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 - 2) | 3);
+  foo (1 - (2 | 3));
+  foo (a | b - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a | b) - c);
+  foo (a | (b - c));
+  foo (1 | 2 - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) - c);
+  foo (1 | (2 - c));
+  foo (1 | 2 - 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) - 3);
+  foo (1 | (2 - 3));
+  foo (a > b | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a > b) | c);
+  foo (a > (b | c));
+  foo (1 > 2 | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 > 2) | c);
+  foo (1 > (2 | c));
+  foo (1 > 2 | 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 > 2) | 3);
+  foo (1 > (2 | 3));
+  foo (a | b > c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a | b) > c);
+  foo (a | (b > c));
+  foo (1 | 2 > c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) > c);
+  foo (1 | (2 > c));
+  foo (1 | 2 > 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) > 3);
+  foo (1 | (2 > 3));
+  foo (a <= b | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a <= b) | c);
+  foo (a <= (b | c));
+  foo (1 <= 2 | c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 <= 2) | c);
+  foo (1 <= (2 | c));
+  foo (1 <= 2 | 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 <= 2) | 3);
+  foo (1 <= (2 | 3));
+  foo (a | b <= c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a | b) <= c);
+  foo (a | (b <= c));
+  foo (1 | 2 <= c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) <= c);
+  foo (1 | (2 <= c));
+  foo (1 | 2 <= 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 | 2) <= 3);
+  foo (1 | (2 <= 3));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-7.c
new file mode 100644
index 000000000..f3516969d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-7.c
@@ -0,0 +1,121 @@
+/* Test operation of -Wparentheses.  Precedence warnings.  & or + or -
+   or comparison inside ^.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (a & b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) ^ c);
+  foo (a & (b ^ c));
+  foo (1 & 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) ^ c);
+  foo (1 & (2 ^ c));
+  foo (1 & 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) ^ 3);
+  foo (1 & (2 ^ 3));
+  foo (a ^ b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) & c);
+  foo (a ^ (b & c));
+  foo (1 ^ 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) & c);
+  foo (1 ^ (2 & c));
+  foo (1 ^ 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) & 3);
+  foo (1 ^ (2 & 3));
+  foo (a + b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a + b) ^ c);
+  foo (a + (b ^ c));
+  foo (1 + 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) ^ c);
+  foo (1 + (2 ^ c));
+  foo (1 + 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) ^ 3);
+  foo (1 + (2 ^ 3));
+  foo (a ^ b + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) + c);
+  foo (a ^ (b + c));
+  foo (1 ^ 2 + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) + c);
+  foo (1 ^ (2 + c));
+  foo (1 ^ 2 + 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) + 3);
+  foo (1 ^ (2 + 3));
+  foo (a - b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a - b) ^ c);
+  foo (a - (b ^ c));
+  foo (1 - 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 - 2) ^ c);
+  foo (1 - (2 ^ c));
+  foo (1 - 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 - 2) ^ 3);
+  foo (1 - (2 ^ 3));
+  foo (a ^ b - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) - c);
+  foo (a ^ (b - c));
+  foo (1 ^ 2 - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) - c);
+  foo (1 ^ (2 - c));
+  foo (1 ^ 2 - 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) - 3);
+  foo (1 ^ (2 - 3));
+  foo (a >= b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a >= b) ^ c);
+  foo (a >= (b ^ c));
+  foo (1 >= 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 >= 2) ^ c);
+  foo (1 >= (2 ^ c));
+  foo (1 >= 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 >= 2) ^ 3);
+  foo (1 >= (2 ^ 3));
+  foo (a ^ b >= c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) >= c);
+  foo (a ^ (b >= c));
+  foo (1 ^ 2 >= c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) >= c);
+  foo (1 ^ (2 >= c));
+  foo (1 ^ 2 >= 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) >= 3);
+  foo (1 ^ (2 >= 3));
+  foo (a == b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a == b) ^ c);
+  foo (a == (b ^ c));
+  foo (1 == 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 == 2) ^ c);
+  foo (1 == (2 ^ c));
+  foo (1 == 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 == 2) ^ 3);
+  foo (1 == (2 ^ 3));
+  foo (a ^ b == c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) == c);
+  foo (a ^ (b == c));
+  foo (1 ^ 2 == c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) == c);
+  foo (1 ^ (2 == c));
+  foo (1 ^ 2 == 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) == 3);
+  foo (1 ^ (2 == 3));
+  foo (a < b ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a < b) ^ c);
+  foo (a < (b ^ c));
+  foo (1 < 2 ^ c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 < 2) ^ c);
+  foo (1 < (2 ^ c));
+  foo (1 < 2 ^ 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 < 2) ^ 3);
+  foo (1 < (2 ^ 3));
+  foo (a ^ b < c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a ^ b) < c);
+  foo (a ^ (b < c));
+  foo (1 ^ 2 < c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) < c);
+  foo (1 ^ (2 < c));
+  foo (1 ^ 2 < 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 ^ 2) < 3);
+  foo (1 ^ (2 < 3));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-8.c
new file mode 100644
index 000000000..ff34ee0a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-8.c
@@ -0,0 +1,103 @@
+/* Test operation of -Wparentheses.  Precedence warnings.  + or - or
+   comparison inside &.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int
+bar (int a, int b, int c)
+{
+  foo (a + b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a + b) & c);
+  foo (a + (b & c));
+  foo (1 + 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) & c);
+  foo (1 + (2 & c));
+  foo (1 + 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 + 2) & 3);
+  foo (1 + (2 & 3));
+  foo (a & b + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) + c);
+  foo (a & (b + c));
+  foo (1 & 2 + c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) + c);
+  foo (1 & (2 + c));
+  foo (1 & 2 + 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) + 3);
+  foo (1 & (2 + 3));
+  foo (a - b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a - b) & c);
+  foo (a - (b & c));
+  foo (1 - 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 - 2) & c);
+  foo (1 - (2 & c));
+  foo (1 - 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 - 2) & 3);
+  foo (1 - (2 & 3));
+  foo (a & b - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) - c);
+  foo (a & (b - c));
+  foo (1 & 2 - c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) - c);
+  foo (1 & (2 - c));
+  foo (1 & 2 - 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) - 3);
+  foo (1 & (2 - 3));
+  foo (a < b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a < b) & c);
+  foo (a < (b & c));
+  foo (1 < 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 < 2) & c);
+  foo (1 < (2 & c));
+  foo (1 < 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 < 2) & 3);
+  foo (1 < (2 & 3));
+  foo (a & b < c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) < c);
+  foo (a & (b < c));
+  foo (1 & 2 < c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) < c);
+  foo (1 & (2 < c));
+  foo (1 & 2 < 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) < 3);
+  foo (1 & (2 < 3));
+  foo (a == b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a == b) & c);
+  foo (a == (b & c));
+  foo (1 == 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 == 2) & c);
+  foo (1 == (2 & c));
+  foo (1 == 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 == 2) & 3);
+  foo (1 == (2 & 3));
+  foo (a & b == c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) == c);
+  foo (a & (b == c));
+  foo (1 & 2 == c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) == c);
+  foo (1 & (2 == c));
+  foo (1 & 2 == 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) == 3);
+  foo (1 & (2 == 3));
+  foo (a != b & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a != b) & c);
+  foo (a != (b & c));
+  foo (1 != 2 & c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 != 2) & c);
+  foo (1 != (2 & c));
+  foo (1 != 2 & 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 != 2) & 3);
+  foo (1 != (2 & 3));
+  foo (a & b != c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((a & b) != c);
+  foo (a & (b != c));
+  foo (1 & 2 != c); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) != c);
+  foo (1 & (2 != c));
+  foo (1 & 2 != 3); /* { dg-warning "parentheses" "correct warning" } */
+  foo ((1 & 2) != 3);
+  foo (1 & (2 != 3));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-9.c
new file mode 100644
index 000000000..0fff6ea1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wparentheses-9.c
@@ -0,0 +1,61 @@
+/* Test operation of -Wparentheses.  Warnings for ambiguous else.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+int foo (int);
+
+int a, b, c;
+
+int
+bar (void)
+{
+  if (a)
+    foo (0);
+  if (b)
+    foo (1);
+  else
+    foo (2);
+  if (c) /* { dg-warning "ambiguous" "correct warning" } */
+    if (a)
+      foo (3);
+    else
+      foo (4);
+  if (a)
+    if (c)
+      foo (5);
+  if (a)
+    if (b) /* { dg-warning "ambiguous" "correct warning" } */
+      if (c)
+	foo (6);
+      else
+	foo (7);
+  if (a) /* { dg-warning "ambiguous" "correct warning" } */
+    if (b)
+      if (c)
+	foo (8);
+      else
+	foo (9);
+    else
+      foo (10);
+  if (a)
+    if (b)
+      if (c)
+	foo (11);
+      else
+	foo (12);
+    else
+      foo (13);
+  else
+    foo (14);
+  if (a) {
+    if (b)
+      if (c)
+	foo (15);
+      else
+	foo (16);
+    else
+      foo (17);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-arith.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-arith.c
new file mode 100644
index 000000000..d7a19079c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-arith.c
@@ -0,0 +1,10 @@
+/* PR 35058: -Werror= works only with some warnings. */
+/* { dg-do compile } */
+/* { dg-options "-Werror=pointer-arith" } */
+void *a;
+
+void *test(){
+  int x=5;
+  if(a) a++; /* { dg-error "wrong type argument to increment" } */
+  return a+x; /* { dg-error "pointer of type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-Wall-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-Wall-no.c
new file mode 100644
index 000000000..23df20721
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-Wall-no.c
@@ -0,0 +1,9 @@
+/* This is from PR c/25892.  See Wpointer-sign.c for more details.  */
+
+/* { dg-options "-Wno-pointer-sign -Wall" } */
+
+void foo(unsigned long* ulp);
+
+void bar(long* lp) {
+  foo(lp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-Wall.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-Wall.c
new file mode 100644
index 000000000..302d50e5c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-Wall.c
@@ -0,0 +1,10 @@
+/* This is from PR c/25892.  See Wpointer-sign.c for more details.  */
+
+/* { dg-options "-Wall" } */
+
+void foo(unsigned long* ulp); /* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" { target *-*-* } 5 } */
+
+
+void bar(long* lp) {
+  foo(lp); /* { dg-warning "differ in signedness" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-pedantic-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-pedantic-no.c
new file mode 100644
index 000000000..d4f597fe7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-pedantic-no.c
@@ -0,0 +1,9 @@
+/* This is from PR c/25892.  See Wpointer-sign.c for more details.  */
+
+/* { dg-options "-Wno-pointer-sign -pedantic" } */
+
+void foo(unsigned long* ulp);
+
+void bar(long* lp) {
+  foo(lp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-pedantic.c
new file mode 100644
index 000000000..8b9211098
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign-pedantic.c
@@ -0,0 +1,9 @@
+/* This is from PR c/25892.  See Wpointer-sign.c for more details.  */
+
+/* { dg-options "-pedantic" } */
+
+void foo(unsigned long* ulp);/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 5 } */
+
+void bar(long* lp) {
+  foo(lp); /* { dg-warning "differ in signedness" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign.c
new file mode 100644
index 000000000..74cdbe4bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-sign.c
@@ -0,0 +1,13 @@
+/* This is from PR c/25892.  The SC promised RMS that -Wpointer-sign
+   would be off by default in GCC 4.1 to avoid inconvenient warnings
+   while compiling GNU Emacs.  It should be enabled with -Wall and/or
+   -pedantic, though.  Make sure it's off by default in this test (so
+   use dg-options "" to avoid passing -pedantic-errors).  */
+
+/* { dg-options "" } */
+
+void foo(unsigned long* ulp);
+
+void bar(long* lp) {
+  foo(lp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-1.c
new file mode 100644
index 000000000..ff011c75d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-1.c
@@ -0,0 +1,12 @@
+/* Test -Wpointer-to-int-cast - on by default.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void *p;
+
+char
+f (void)
+{
+  return (char) p; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-2.c
new file mode 100644
index 000000000..9ece965d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-2.c
@@ -0,0 +1,12 @@
+/* Test -Wpointer-to-int-cast.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wpointer-to-int-cast" } */
+
+void *p;
+
+char
+f (void)
+{
+  return (char) p; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-3.c
new file mode 100644
index 000000000..c82ca5cf5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wpointer-to-int-cast-3.c
@@ -0,0 +1,21 @@
+/* Test -Wno-pointer-to-int-cast.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wno-pointer-to-int-cast" } */
+
+void *p;
+
+char
+f (void)
+{
+  return (char) p;
+}
+
+
+char c;
+
+void *
+g (void)
+{
+  return (void *) c; /* { dg-warning "cast to pointer from integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreal-conversion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreal-conversion-1.c
new file mode 100644
index 000000000..eec4e3f50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreal-conversion-1.c
@@ -0,0 +1,25 @@
+// { dg-do compile }
+// { dg-options "-Wreal-conversion" }
+
+#include <stddef.h>
+
+int func1(int a) {
+  double f = a;
+  return f;           // { dg-warning "conversion to" }
+}
+
+double func3();
+
+void func2() {
+  double g = 3.2;
+  float f;
+  int t = g;          // { dg-warning "conversion to" }
+  int p;
+  p = f;              // { dg-warning "conversion to" }
+  func1(g);           // { dg-warning "conversion to" }
+  char c = f;         // { dg-warning "conversion to" }
+  size_t s;
+  p = s;
+  int q;
+  q = func3();        // { dg-warning "conversion to" }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wredundant-decls-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wredundant-decls-1.c
new file mode 100644
index 000000000..c38c7b554
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wredundant-decls-1.c
@@ -0,0 +1,7 @@
+/* PR 16684: no redundant declaration warnings should issue the first
+   time a built-in function is declared.
+   { dg-do compile }
+   { dg-options "-Wredundant-decls" } */
+
+void *malloc (__SIZE_TYPE__);  /* { dg-bogus "redundant" } */
+void *malloc (__SIZE_TYPE__);  /* { dg-warning "redundant" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wredundant-decls-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wredundant-decls-2.c
new file mode 100644
index 000000000..89f57b427
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wredundant-decls-2.c
@@ -0,0 +1,27 @@
+/* Test for -Wredundant-decls warnings */
+/* { dg-do compile } */
+/* { dg-options "-Wredundant-decls" } */
+
+int j = 5; /* { dg-message "note: previous" } */
+int j;     /* { dg-warning "redundant" } */
+
+static int k;
+static int k = 5; /* { dg-message "note: previous" } */
+static int k;     /* { dg-warning "redundant" } */
+
+static int l = 5; /* { dg-message "note: previous" } */
+static int l;     /* { dg-warning "redundant" } */
+
+static int m;     /* { dg-message "note: previous" } */
+static int m;     /* { dg-warning "redundant" } */
+static int m = 5;
+
+int n;           /* { dg-message "note: previous" } */
+int n;           /* { dg-warning "redundant" } */
+int n = 5; 
+
+static int o;
+static int o = 5;
+
+int p;
+int p = 5;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreturn-type.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreturn-type.c
new file mode 100644
index 000000000..a122e5291
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreturn-type.c
@@ -0,0 +1,5 @@
+/* PR c++/4872 */
+/* { dg-do compile } */
+/* { dg-options "-Wreturn-type" } */
+
+static inline int f() {}     /* { dg-warning "return" "missing return" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreturn-type2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreturn-type2.c
new file mode 100644
index 000000000..781414a1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wreturn-type2.c
@@ -0,0 +1,9 @@
+/* Test for cases that should not get the unconditional warning about
+   missing return.  */
+/* { dg-do compile } */
+
+extern void abort (void);
+
+f() {}				/* { dg-bogus "" "no return warning" } */
+int g() { abort (); }		/* { dg-bogus "" "no return warning" } */
+int main() {}			/* { dg-bogus "" "no return warning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wsequence-point-pr18050.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wsequence-point-pr18050.c
new file mode 100644
index 000000000..63aecd0f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wsequence-point-pr18050.c
@@ -0,0 +1,24 @@
+/* PR 18050 : bogus warning with -Wsequence-point */
+/* { dg-do compile } */
+/* { dg-options "-Wsequence-point" } */
+
+struct x
+{
+  int i;
+};
+void bar(struct x*, int *);
+
+void foo(struct x *y)
+{
+  bar(y++, &y->i); /* { dg-warning "operation on 'y' may be undefined" } */
+}
+
+void zz(int a, int *b)
+{
+  *b = a;
+}
+
+void baz(void) {
+  int a = 5;
+  zz(++a, &a);  /* { dg-bogus "operation on 'a' may be undefined" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-1.c
new file mode 100644
index 000000000..40073f337
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-1.c
@@ -0,0 +1,32 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wshadow -pedantic-errors" } */
+
+/* Source: Neil Booth, 5 Dec 2001.  */
+
+int decl1;			/* { dg-warning "shadowed declaration" } */
+void foo (double decl1)		/* { dg-warning "shadows a global decl" } */
+{				
+}
+
+void foo1 (int d)		/* { dg-message "note: previous definition" } */
+{
+  double d;	 /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "redeclared as different" "" { target *-*-* } 15 } */
+}
+
+void foo2 (int d)		/* { dg-warning "shadowed declaration" } */
+{
+  {
+    double d;			/* { dg-warning "shadows a parameter" } */
+  }
+}
+
+void foo3 ()
+{
+  int local;			/* { dg-warning "shadowed declaration" } */
+  {
+    int local;			/* { dg-warning "shadows a previous local" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-2.c
new file mode 100644
index 000000000..b0c051271
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-2.c
@@ -0,0 +1,10 @@
+/* Bogus warning for a double declaration of the same extern variable,
+   first at file scope, then at block scope.  PR 13129.  */
+
+/* { dg-options "-Wshadow" } */
+
+extern struct foo bar;
+void dummy()
+{
+  extern struct foo bar;  /* { dg-bogus "shadows" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-3.c
new file mode 100644
index 000000000..a7f06a26f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-3.c
@@ -0,0 +1,21 @@
+/* Test warnings for shadowing in function prototype scope: generally
+   useless but of use if the parameter is used within the scope.  Bug
+   529.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -Wshadow" } */
+
+int v; /* { dg-warning "shadowed declaration" } */
+int f1(int v);
+int f2(int v, int x[v]); /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f3(int v, int y[sizeof(v)]); /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f4(int v) { return 0; } /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f5(int v, int x[v]) { return 0; } /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f6(int x) { return 0; }
+int f7(v) int v; { return 0; } /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f8(v, w) int v; int w[v]; { return 0; } /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f9(x) int x; { return 0; }
+int f10(v) { return 0; } /* { dg-warning "declaration of 'v' shadows a global declaration" } */
+int f11(int a, int b(int a));
+int f12(int a, int b(int a, int x[a])); /* { dg-warning "declaration of 'a' shadows a parameter" } */
+/* { dg-warning "shadowed declaration" "outer parm" { target *-*-* } 20 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-compatible-local-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-compatible-local-1.c
new file mode 100644
index 000000000..cb21be9ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-compatible-local-1.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-Wshadow-compatible-local" } */
+
+struct Bar {
+};
+
+struct Bar bar;       /* { dg-bogus "shadowed declaration" } */
+
+int val;              /* { dg-bogus "shadowed declaration" } */
+
+int func1(int x) {    /* { dg-bogus "shadowed declaration" } */
+  int val;            /* { dg-bogus "shadows a global" } */
+  val = x;
+  return val;
+}
+
+int func2(int i) {
+  int a = 3;          /* { dg-warning "shadowed declaration" } */
+  int j;              /* { dg-warning "shadowed declaration" } */
+
+  for (j = 0; j < i; ++j) {
+    int a = j;        /* { dg-warning "shadows a previous local" } */
+    int j = a + 1;    /* { dg-warning "shadows a previous local" } */
+    func1(j);
+  }
+
+  return a;
+}
+
+void func4() {
+  struct Bar bar;     /* { dg-bogus "shadowed declaration" } */
+  if (val) {
+    int bar;          /* { dg-bogus "shadows a previous local" } */
+    func1(bar);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-1.c
new file mode 100644
index 000000000..d0e0dea28
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-Wshadow-local" } */
+
+int decl1;			/* should not warn */
+void foo (double decl1)		/* should not warn */
+{				
+}
+
+void foo2 (int d)		/* { dg-warning "shadowed declaration" } */
+{
+  {
+    double d;			/* { dg-warning "shadows a parameter" } */
+  }
+}
+
+void foo3 ()
+{
+  int local;			/* { dg-warning "shadowed declaration" } */
+  {
+    int local;			/* { dg-warning "shadows a previous local" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-2.c
new file mode 100644
index 000000000..9d52fac6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-2.c
@@ -0,0 +1,49 @@
+/* { dg-do compile } */
+/* { dg-options "-Wshadow-local" } */
+
+struct Bar {
+};
+
+struct Bar bar;       /* { dg-bogus "shadowed declaration" } */
+
+int val;              /* { dg-bogus "shadowed declaration" } */
+
+int func1(int x) {    /* { dg-bogus "shadowed declaration" } */
+  int val;            /* { dg-bogus "shadows a global" } */
+  val = x;
+  return val;
+}
+
+int func2(int i) {
+  int a = 3;          /* { dg-warning "shadowed declaration" } */
+  int j;              /* { dg-warning "shadowed declaration" } */
+
+  for (j = 0; j < i; ++j) {
+    int a = j;        /* { dg-warning "shadows a previous local" } */
+    int j = a + 1;    /* { dg-warning "shadows a previous local" } */
+    func1(j);
+  }
+
+  return a;
+}
+
+int func3() {
+  int bar;            /* { dg-bogus "shadows a global" } */
+  float func1 = 0.3;  /* { dg-bogus "shadows a global" } */
+
+  if (func1 > 1)
+    bar = 2;
+  else
+    bar = 1;
+  return bar;
+}
+
+void func4() {
+  struct Bar bar;     /* { dg-warning "shadowed declaration" } */
+  if (val) {
+    int bar;          /* { dg-warning "shadows a previous local" } */
+    func1(bar);
+  }
+}
+
+/* { dg-bogus "shadows a global" ""  { target *-*-* } 42 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-3.c
new file mode 100644
index 000000000..429df37f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wshadow-local-3.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-Wno-shadow" } */
+
+void func() {
+  int i;
+    {
+      int i; /* should not warn */
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wsign-conversion.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wsign-conversion.c
new file mode 100644
index 000000000..0300850f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wsign-conversion.c
@@ -0,0 +1,96 @@
+/* Test for diagnostics for implicit conversions between signed and
+   unsigned integer types.
+   These tests come from gcc/testsuite/gcc.dg/overflow-warn-2.c  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fsigned-char -Wsign-conversion" } */
+#include <limits.h>
+
+void fsc (signed char sc);
+void fuc (unsigned char uc);
+unsigned fui (unsigned int  ui);
+void fsi (signed int ui);
+
+void h (int x)
+{
+  unsigned int ui = 3;
+  int   si = 3;
+  unsigned char uc = 3;
+  signed char   sc = 3;
+
+  uc = ui; 
+  uc = si; 
+  sc = ui; 
+  sc = si; 
+  fuc (ui);
+  fuc (si);
+  fsc (ui);
+  fsc (si);
+
+  fsi (si);
+  fui (ui);
+  fsi (uc);
+  si = uc;
+  fui (uc);
+  ui = uc;
+  fui ('A');
+  ui = 'A';
+  fsi ('A');
+  si = 'A';
+  fuc ('A');
+  uc = 'A';
+
+  uc = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = x ? SCHAR_MIN : 1U;  /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = x ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+
+  fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = -1;  /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fui (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fuc ('\xa0'); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fui ('\xa0');/* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fsi (0x80000000); /* { dg-warning "conversion" } */
+  si = 0x80000000;  /* { dg-warning "conversion" } */
+
+
+  fsi (UINT_MAX - 1);  /* { dg-warning "conversion" } */
+  si = UINT_MAX - 1;   /* { dg-warning "conversion" } */
+  fsi (UINT_MAX - 1U); /* { dg-warning "conversion" } */
+  si = UINT_MAX - 1U;  /* { dg-warning "conversion" } */
+  fsi (UINT_MAX/3U);
+  si = UINT_MAX/3U;
+  fsi (UINT_MAX/3);
+  si = UINT_MAX/3;
+  fui (UINT_MAX - 1);
+  ui = UINT_MAX - 1;
+
+  uc = (unsigned char) -1;
+  ui = -1 * (1 * -1);
+  ui = (unsigned) -1;
+
+  fsc (uc); /* { dg-warning "conversion" } */
+  sc = uc;  /* { dg-warning "conversion" } */
+  fuc (sc); /* { dg-warning "conversion" } */
+  uc = sc;  /* { dg-warning "conversion" } */
+  fsi (ui); /* { dg-warning "conversion" } */
+  si = ui;  /* { dg-warning "conversion" } */
+  fui (si); /* { dg-warning "conversion" } */ 
+  ui = si;  /* { dg-warning "conversion" } */ 
+  fui (sc); /* { dg-warning "conversion" } */
+  ui = sc;  /* { dg-warning "conversion" } */
+}
+
+unsigned fui (unsigned a) { return a + -1; } /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-const-ptr-nonconst-ptr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-const-ptr-nonconst-ptr.c
new file mode 100644
index 000000000..8a5dcd8e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-const-ptr-nonconst-ptr.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wstrict-aliasing -fstrict-aliasing" } */
+
+const int* foo (void)
+{
+  int *i;
+  const int** cpi = (const int**) &i; /* { dg-bogus "const vs. non-const" } */
+  i = 0;
+  return *cpi;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-never-dereferenced.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-never-dereferenced.c
new file mode 100644
index 000000000..fd3f767ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-never-dereferenced.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wstrict-aliasing -fstrict-aliasing" } */
+
+
+int foo ()
+{
+  int x = 10;
+  int *p;
+  float *q;
+
+  q = (float*) &x;  /* { dg-bogus "not referenced" } */
+
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-pta-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-pta-1.c
new file mode 100644
index 000000000..a48827474
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-pta-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+struct S { int *p; int *q; };
+
+void foo (struct S *);
+
+int bar (int b)
+{
+  struct S s;
+  int *p;
+  float f;
+  foo (&s);
+  if (b)
+    p = s.q;
+  else
+    p = (int *)&f;
+  return *p;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-ref-all-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-ref-all-2.c
new file mode 100644
index 000000000..29b1e98ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-ref-all-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
+
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_load_si128 (__m128i const *__P)
+{
+  return *__P;
+}
+
+static const short __attribute__((__aligned__(16))) tbl[8] =
+{ 1, 2, 3, 4, 5, 6, 7, 8};
+
+
+__m128i get_vec(void)
+{
+  __m128i ret;
+
+  ret = _mm_load_si128((__m128i *)tbl); /* { dg-bogus "type-punning" } */
+
+  return ret;
+}
+
+/* Ignore a warning that is irrelevant to the purpose of this test.  */
+/* { dg-prune-output ".*GCC vector returned by reference.*" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-ref-all.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-ref-all.c
new file mode 100644
index 000000000..7e8d17715
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-ref-all.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+struct g { long a; };
+unsigned long f(struct g *a) { return *(unsigned long *)&a->a; }
+
+struct A
+{
+  void *a;
+};
+
+int g(const struct A *x, long *y)
+{
+  typedef long __attribute__ ((may_alias)) long_a;
+  *y = *(const long_a *) (&x->a);
+  return 1;
+}
+
+void *a;
+
+int
+f0 (long *y)
+{
+  *y = *(const long *) &a; /* { dg-warning "will break" } */
+  return 1;
+}
+
+int
+f1 (long *y)
+{
+  typedef long __attribute__ ((may_alias)) long_a;
+  *y = *(const long_a *) &a;
+  return 1;
+}
+
+int
+f2 (long *y)
+{
+  *y = *(const long *) &a; /* { dg-warning "will break" } */
+  return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-struct-included.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-struct-included.c
new file mode 100644
index 000000000..382fecd6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-struct-included.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wstrict-aliasing -fstrict-aliasing" } */
+
+
+struct U
+{
+  float f;
+  int i;
+};
+
+
+int foo ()
+{
+  struct U u;
+  float *pf = (float*)&u;  /* { dg-bogus "float included in struct U" } */
+  *pf = 2.0;
+  return u.i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-vla-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-vla-1.c
new file mode 100644
index 000000000..e9f63d368
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-bogus-vla-1.c
@@ -0,0 +1,10 @@
+/* PR 41673: bogus -Wstrict-aliasing warning from VLA dereference.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O2 -Wall" } */
+
+int main(int argc, char *argv[])
+{
+    float x[argc];
+    float y[argc];
+    return 0 == __builtin_memcpy(y, x, argc * sizeof(*x));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c
new file mode 100644
index 000000000..1fef7947c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wstrict-aliasing -fstrict-aliasing" } */
+
+
+int foo()
+{
+  int i;
+  *(long*)&i = 0;  /* { dg-warning "type-punn" } */
+  return i;
+}
+
+/* { dg-message "does break strict-aliasing" "" { target { *-*-* && lp64 } } 8 } */
+/* { dg-message "initialized" "" { target { *-*-* && lp64 } } 8 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c
new file mode 100644
index 000000000..fccc178d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wstrict-aliasing -fstrict-aliasing" } */
+
+extern int flag;
+
+int foo() {
+
+  int x;
+  int y = 9;
+  float* q;
+  float* r;
+
+  if (flag) {
+    q = (float*) &x;  /* { dg-message "initialized" } */
+  } else {
+    q = (float*) &y;  /* { dg-message "initialized" } */
+  }
+
+  *q = 1.0;  /* { dg-warning "does break strict-aliasing" } */
+
+  return x;
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-1.c
new file mode 100644
index 000000000..068bfe494
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=3" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-1.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return i - 5 < 10; /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-10.c
new file mode 100644
index 000000000..d2c259728
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-10.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=1" } */
+
+/* Source: Ian Lance Taylor.  */
+
+int
+foo (int i)
+{
+  return __builtin_abs (i) >= 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-11.c
new file mode 100644
index 000000000..3caf1cb6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-11.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=1" } */
+
+/* Based on strict-overflow-5.c.  */
+
+/* We can only unroll when using strict overflow semantics.  But we
+   don't issue a warning for relying on undefined overflow in
+   loops.  */
+
+int foo (int i)
+{
+  int index;
+  int r=0;
+ 
+  for (index = i; index <= i+4; index+=2)
+    r++;
+ 
+  return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-12.c
new file mode 100644
index 000000000..177904db7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-12.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=2" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-6.c.  */
+
+/* VRP test.  This turns into an infinite loop when using strict
+   overflow semantics.  */
+
+int
+foo ()
+{
+  int i, bits;
+  for (i = 1, bits = 1; i > 0; i += i) /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+    ++bits;
+  return bits;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-13.c
new file mode 100644
index 000000000..170d13777
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-13.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=2" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-6.c.  */
+
+/* VRP test.  This turns into an infinite loop (depending on what
+   bigtime_test does), but at least we warn about it.  */
+
+extern int bigtime_test (int);
+int
+foo ()
+{
+  int j;
+  for (j = 1; 0 < j; j *= 2) /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+    if (! bigtime_test (j))
+      return 1;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-14.c
new file mode 100644
index 000000000..6f3c5a24f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-14.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=4" } */
+
+/* Source: Ian Lance Taylor.  */
+
+int
+foo (int j)
+{
+  int i;
+  int sum = 0;
+
+  for (i = 1; i < j; i += i)
+    sum += i / 16; /* { dg-warning "assuming signed overflow does not occur" "" } */
+  return sum;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-15.c
new file mode 100644
index 000000000..d1627d2f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-15.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=4" } */
+
+/* Source: Ian Lance Taylor.  */
+
+int
+foo (int j)
+{
+  int i;
+  int sum = 0;
+
+  for (i = 1; i < j; i += i)
+    sum += __builtin_abs (i); /* { dg-warning "assuming signed overflow does not occur" "" } */
+  return sum;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-16.c
new file mode 100644
index 000000000..e8c31cf50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-16.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* From PR 31522.  */
+
+int f (int x) {
+  int y;
+  if (x <= 4) y = 1;
+  else y = x / 4;
+  return y <= 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-17.c
new file mode 100644
index 000000000..5625bc2a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-17.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* This erroneously gave an overflow warning.  */
+
+extern void bar (char);
+void
+foo (char *s)
+{
+  int len, i;
+
+  for (len = 1; len < 5000; ++len)
+    {
+      for (i = 0; i < len; ++i)
+	{
+	  if (s[i] != '\0')
+	    bar (s[i]);
+	}
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-18.c
new file mode 100644
index 000000000..e26e7e914
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-18.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* Don't warn about an overflow when folding i > 0.  The loop analysis
+   should determine that i does not wrap.  */
+
+struct c { unsigned int a; unsigned int b; };
+extern void bar (struct c *);
+int
+foo (struct c *p)
+{
+  int i;
+  int sum = 0;
+
+  for (i = 0; i < p->a - p->b; ++i)
+    {
+      if (i > 0)
+	sum += 2;
+      bar (p);
+    }
+  return sum;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-19.c
new file mode 100644
index 000000000..daf98b0ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-19.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* Don't warn about an overflow when threading jumps.  We used to get
+   a warning from comparing bounds generated by VRP.  */
+
+int
+bar(int a, int b, int n)
+{
+  if (b > a)
+    n = a - b;
+  if (a >= b)
+    n = 1;
+  return n;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-2.c
new file mode 100644
index 000000000..2112571ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=2" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-1.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return i - 5 < 10;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-20.c
new file mode 100644
index 000000000..207162d0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-20.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* Don't warn about an overflow in a copied loop header.  We used to
+   get a warning in value numbering.  This is PR 33565.  */
+
+void f (int m, int n)
+{
+  int j;
+ 
+  for (j = m; j	< m + 10 && j <	n; j ++)
+    do_something (j);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-21.c
new file mode 100644
index 000000000..57e946526
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-21.c
@@ -0,0 +1,12 @@
+/* PR 32102: -Wall stomps on -Wstrict-overflow */
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=2 -Wall" } */
+int
+foo ()
+{
+  int i, bits;
+  for (i = 1, bits = 1; i > 0; i += i) /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+    ++bits;
+  return bits;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-22.c
new file mode 100644
index 000000000..4b8438733
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-22.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=3" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-6.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (char* p)
+{
+  return p + 1000 < p; /* { dg-warning "assuming pointer wraparound does not occur" "correct warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-3.c
new file mode 100644
index 000000000..22f6a56a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=4" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-2.c.  */
+
+/* We can only simplify the division when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return (i * 100) / 10; /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-4.c
new file mode 100644
index 000000000..e880bef45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-4.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=3" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-2.c.  */
+
+/* We can only simplify the division when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return (i * 100) / 10;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-5.c
new file mode 100644
index 000000000..9af0adb99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-5.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=3" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-3.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i, int j)
+{
+  return i + 100 < j + 1000; /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-6.c
new file mode 100644
index 000000000..c3a160c60
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-6.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=2" } */
+
+/* Source: Ian Lance Taylor.  Based on strict-overflow-3.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i, int j)
+{
+  return i + 100 < j + 1000;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-7.c
new file mode 100644
index 000000000..5bf7b6005
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-7.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow" } */
+
+/* Source: Ian Lance Taylor.  */
+
+int
+foo (int i)
+{
+  return i + 10 > i; /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-8.c
new file mode 100644
index 000000000..566729fe3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-8.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wall -Wno-strict-overflow" } */
+
+/* Source: Ian Lance Taylor.  */
+
+int
+foo (int i)
+{
+  return i + 10 > i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-9.c
new file mode 100644
index 000000000..425a121d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstrict-overflow-9.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -Wstrict-overflow=2" } */
+
+/* Source: Ian Lance Taylor.  */
+
+int
+foo (int i)
+{
+  return __builtin_abs (i) >= 0; /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-1.c
new file mode 100644
index 000000000..97e317644
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-1.c
@@ -0,0 +1,29 @@
+/* PR c/7776 */
+/* { dg-do compile } */
+/* { dg-options "-Waddress" } */
+
+int test1(char *ptr)
+{
+  return ptr == "foo";  /* { dg-warning "comparison with string" } */
+}
+
+int test2()
+{
+  return "foo" != (const char*)0;
+}
+
+int test3()
+{
+  return "foo" == (const char*)0;
+}
+
+int test4()
+{
+  return (const char*)0 != "foo";
+}
+
+int test5()
+{
+  return (const char*)0 == "foo";
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-2.c
new file mode 100644
index 000000000..3eb91eeca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-2.c
@@ -0,0 +1,29 @@
+/* PR c/7776 */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+int test1(char *ptr)
+{
+  return ptr == "foo";  /* { dg-warning "comparison with string" } */
+}
+
+int test2()
+{
+  return "foo" != (const char*)0;
+}
+
+int test3()
+{
+  return "foo" == (const char*)0;
+}
+
+int test4()
+{
+  return (const char*)0 != "foo";
+}
+
+int test5()
+{
+  return (const char*)0 == "foo";
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-3.c
new file mode 100644
index 000000000..f700a51a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-3.c
@@ -0,0 +1,29 @@
+/* PR c/7776 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int test1(char *ptr)
+{
+  return ptr == "foo";
+}
+
+int test2()
+{
+  return "foo" != (const char*)0;
+}
+
+int test3()
+{
+  return "foo" == (const char*)0;
+}
+
+int test4()
+{
+  return (const char*)0 != "foo";
+}
+
+int test5()
+{
+  return (const char*)0 == "foo";
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-4.c
new file mode 100644
index 000000000..f2a711aeb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wstring-literal-comparison-4.c
@@ -0,0 +1,29 @@
+/* PR c/7776 */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wno-address" } */
+
+int test1(char *ptr)
+{
+  return ptr == "foo";
+}
+
+int test2()
+{
+  return "foo" != (const char*)0;
+}
+
+int test3()
+{
+  return "foo" == (const char*)0;
+}
+
+int test4()
+{
+  return (const char*)0 != "foo";
+}
+
+int test5()
+{
+  return (const char*)0 == "foo";
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-2.c
new file mode 100644
index 000000000..79ba4bdcb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-2.c
@@ -0,0 +1,31 @@
+/* Further -Wswitch tests.  */
+/* { dg-do compile } */
+/* { dg-options "-Wswitch" } */
+
+enum e { e1 = 0, e2 = 1, e3 = 1, e4 = 2 };
+
+int
+foo (enum e ei, int j)
+{
+  switch (ei)
+    {
+    case e1: return 1;
+    case e3: return 2;
+    case e4: return 3;
+    }	/* No warning here since e2 has the same value as e3.  */
+  switch (ei) /* { dg-warning "enumeration value 'e4' not handled in switch" "enum e4" } */
+    {
+    case e1: return 1;
+    case e2: return 2;
+    }
+  switch ((int) ei)
+    {
+    case e1: return 1;
+    }	/* No warning here since switch condition was cast to int.  */
+  switch ((enum e) j) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+    {
+    case e2: return 1;
+    case e4: return 2;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-default.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-default.c
new file mode 100644
index 000000000..2d4e7994c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-default.c
@@ -0,0 +1,62 @@
+/* { dg-do compile } */
+/* { dg-options "-Wswitch-default" } */
+
+enum e { e1, e2 };
+
+int
+foo (int i, int j, enum e ei, enum e ej, enum e ek, enum e el,
+     enum e em, enum e en, enum e eo, enum e ep)
+{
+  switch (i) /* { dg-warning "switch missing default case" } */
+    {
+    case 1: return 1;
+    case 2: return 2;
+    }
+  switch (j)
+    {
+    case 3: return 4;
+    case 4: return 3;
+    default: break;
+    }
+  switch (ei) /* { dg-warning "switch missing default case" } */
+    {
+    }
+  switch (ej)
+    {
+    default: break;
+    }
+  switch (ek) /* { dg-warning "switch missing default case" } */
+    {
+    case e1: return 1;
+    }
+  switch (el)
+    {
+    case e1: return 1;
+    default: break;
+    }
+  switch (em) /* { dg-warning "switch missing default case" } */
+    {
+    case e1: return 1;
+    case e2: return 2;
+    }
+  switch (en)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    default: break;
+    }
+  switch (eo) /* { dg-warning "switch missing default case" } */
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3;
+    }
+  switch (ep)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3;
+    default: break;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-2.c
new file mode 100644
index 000000000..6b5ca1d30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-2.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wswitch-enum" } */
+
+typedef enum { a = 2 } T;
+
+int main()
+{
+    T x = a;
+    switch(x)
+    {
+    case a ... 3: /* { dg-warning "case value '3' not in enumerated" "3" } */
+        break;
+    }
+    switch(x)
+    {
+    case 1 ... a: /* { dg-warning "case value '1' not in enumerated" "1" } */
+        break;
+    }
+    return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-3.c
new file mode 100644
index 000000000..98db4d578
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-3.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wswitch-enum" } */
+
+typedef enum { a = 2 } T;
+
+int main()
+{
+    switch((T)a) /* { dg-warning "enumeration value 'a' not handled" "a" } */
+    {
+    case 1: /* { dg-warning "case value '1' not in enumerated" "1" } */
+        break;
+    }
+    return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-error.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-error.c
new file mode 100644
index 000000000..ae9a2c783
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum-error.c
@@ -0,0 +1,63 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Werror=switch-enum -Wswitch" } */
+
+enum e { e1, e2 };
+
+int
+foo (int i, int j, enum e ei, enum e ej, enum e ek, enum e el,
+     enum e em, enum e en, enum e eo, enum e ep)
+{
+  switch (i)
+    {
+    case 1: return 1;
+    case 2: return 2;
+    }
+  switch (j)
+    {
+    case 3: return 4;
+    case 4: return 3;
+    default: break;
+    }
+  switch (ei) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+    }
+  switch (ej) /* { dg-error "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /* { dg-error "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 25 } */
+    default: break;
+    }
+  switch (ek) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    }
+  switch (el) /* { dg-error "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    default: break;
+    }
+  switch (em)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    }
+  switch (en)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    default: break;
+    }
+  switch (eo)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    }
+  switch (ep)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-error "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    default: break;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum.c
new file mode 100644
index 000000000..28c60d879
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-enum.c
@@ -0,0 +1,63 @@
+/* PR c/5044 */
+/* { dg-do compile } */
+/* { dg-options "-Wswitch-enum" } */
+
+enum e { e1, e2 };
+
+int
+foo (int i, int j, enum e ei, enum e ej, enum e ek, enum e el,
+     enum e em, enum e en, enum e eo, enum e ep)
+{
+  switch (i)
+    {
+    case 1: return 1;
+    case 2: return 2;
+    }
+  switch (j)
+    {
+    case 3: return 4;
+    case 4: return 3;
+    default: break;
+    }
+  switch (ei) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+    }
+  switch (ej) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 25 } */
+    default: break;
+    }
+  switch (ek) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    }
+  switch (el) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    default: break;
+    }
+  switch (em)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    }
+  switch (en)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    default: break;
+    }
+  switch (eo)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    }
+  switch (ep)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    default: break;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-error.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-error.c
new file mode 100644
index 000000000..4aa0c2a15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch-error.c
@@ -0,0 +1,63 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Werror=switch -Wswitch-enum" } */
+
+enum e { e1, e2 };
+
+int
+foo (int i, int j, enum e ei, enum e ej, enum e ek, enum e el,
+     enum e em, enum e en, enum e eo, enum e ep)
+{
+  switch (i)
+    {
+    case 1: return 1;
+    case 2: return 2;
+    }
+  switch (j)
+    {
+    case 3: return 4;
+    case 4: return 3;
+    default: break;
+    }
+  switch (ei) /* { dg-error "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /* { dg-error "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+    }
+  switch (ej) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 25 } */
+    default: break;
+    }
+  switch (ek) /* { dg-error "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    }
+  switch (el) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    default: break;
+    }
+  switch (em)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    }
+  switch (en)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    default: break;
+    }
+  switch (eo)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-error "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    }
+  switch (ep)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    default: break;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch.c
new file mode 100644
index 000000000..686fd4161
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wswitch.c
@@ -0,0 +1,63 @@
+/* PR c/4475, PR c++/3780 */
+/* { dg-do compile } */
+/* { dg-options "-Wswitch" } */
+
+enum e { e1, e2 };
+
+int
+foo (int i, int j, enum e ei, enum e ej, enum e ek, enum e el,
+     enum e em, enum e en, enum e eo, enum e ep)
+{
+  switch (i)
+    {
+    case 1: return 1;
+    case 2: return 2;
+    }
+  switch (j)
+    {
+    case 3: return 4;
+    case 4: return 3;
+    default: break;
+    }
+  switch (ei) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+    { /*{ dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+    }
+  switch (ej)
+    {
+    default: break;
+    }
+  switch (ek) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
+    {
+    case e1: return 1;
+    }
+  switch (el)
+    {
+    case e1: return 1;
+    default: break;
+    }
+  switch (em)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    }
+  switch (en)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    default: break;
+    }
+  switch (eo)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
+    }
+  switch (ep)
+    {
+    case e1: return 1;
+    case e2: return 2;
+    case 3: return 3;
+    default: break;
+    } /* Since there is a default, no warning about ``case 3'' */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtraditional-conversion-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtraditional-conversion-2.c
new file mode 100644
index 000000000..b3c7e3c6c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtraditional-conversion-2.c
@@ -0,0 +1,64 @@
+/* Test messages for -Wtraditional-conversion, including that they are not
+   pedwarns.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors -Wtraditional-conversion" } */
+
+void fsc(signed char);
+void fsi(signed int);
+void fsll(signed long long);
+void fuc(unsigned char);
+void fui(unsigned int);
+void full(unsigned long long);
+void ff(float);
+void fld(long double);
+void fcf(_Complex float);
+
+struct s {
+  void (*fsc)(signed char);
+  void (*fsi)(signed int);
+  void (*fsll)(signed long long);
+  void (*fuc)(unsigned char);
+  void (*fui)(unsigned int);
+  void (*full)(unsigned long long);
+  void (*ff)(float);
+  void (*fld)(long double);
+  void (*fcf)(_Complex float);
+} x;
+
+signed char sc;
+signed int si;
+signed long long sll;
+unsigned char uc;
+unsigned int ui;
+unsigned long long ull;
+float f;
+long double ld;
+_Complex float cf;
+
+void
+g (void)
+{
+  fsi(f); /* { dg-warning "passing argument 1 of 'fsi' as integer rather than floating due to prototype" } */
+  x.fsi(f); /* { dg-warning "passing argument 1 of 'x.fsi' as integer rather than floating due to prototype" } */
+  fsi(cf); /* { dg-warning "passing argument 1 of 'fsi' as integer rather than complex due to prototype" } */
+  x.fsi(cf); /* { dg-warning "passing argument 1 of 'x.fsi' as integer rather than complex due to prototype" } */
+  fcf(f); /* { dg-warning "passing argument 1 of 'fcf' as complex rather than floating due to prototype" } */
+  x.fcf(f); /* { dg-warning "passing argument 1 of 'x.fcf' as complex rather than floating due to prototype" } */
+  fcf(si); /* { dg-warning "passing argument 1 of 'fcf' as complex rather than integer due to prototype" } */
+  x.fcf(si); /* { dg-warning "passing argument 1 of 'x.fcf' as complex rather than integer due to prototype" } */
+  ff(sc); /* { dg-warning "passing argument 1 of 'ff' as floating rather than integer due to prototype" } */
+  x.ff(sc); /* { dg-warning "passing argument 1 of 'x.ff' as floating rather than integer due to prototype" } */
+  ff(cf); /* { dg-warning "passing argument 1 of 'ff' as floating rather than complex due to prototype" } */
+  x.ff(cf); /* { dg-warning "passing argument 1 of 'x.ff' as floating rather than complex due to prototype" } */
+  ff(1.0); /* { dg-warning "passing argument 1 of 'ff' as 'float' rather than 'double' due to prototype" } */
+  x.ff(1.0); /* { dg-warning "passing argument 1 of 'x.ff' as 'float' rather than 'double' due to prototype" } */
+  fsll(sc); /* { dg-warning "passing argument 1 of 'fsll' with different width due to prototype" } */
+  x.fsll(sc); /* { dg-warning "passing argument 1 of 'x.fsll' with different width due to prototype" } */
+  fsc(sll); /* { dg-warning "passing argument 1 of 'fsc' with different width due to prototype" } */
+  x.fsc(sll); /* { dg-warning "passing argument 1 of 'x.fsc' with different width due to prototype" } */
+  fsi(ui); /* { dg-warning "passing argument 1 of 'fsi' as signed due to prototype" } */
+  x.fsi(ui); /* { dg-warning "passing argument 1 of 'x.fsi' as signed due to prototype" } */
+  full(sll); /* { dg-warning "passing argument 1 of 'full' as unsigned due to prototype" } */
+  x.full(sll); /* { dg-warning "passing argument 1 of 'x.full' as unsigned due to prototype" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtraditional-conversion.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtraditional-conversion.c
new file mode 100644
index 000000000..a3f04acb5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtraditional-conversion.c
@@ -0,0 +1,20 @@
+/* Source: PR 137.
+
+   We would not warn about passing an enum, but would warn about
+   passing a enum that was part of an array.  TYPE_MAIN_VARIANT was
+   not used in the appropriate place in the warning code.  */
+
+/* { dg-do compile } */
+/* { dg-options -Wtraditional-conversion } */
+
+typedef enum { a } __attribute__((packed)) t;
+void f(t x) {}
+
+int main(void)
+{
+  t x[2], y;
+  f(x[0]);			/* { dg-bogus "different width" } */
+  f(y);				/* { dg-bogus "different width" } */
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits-Wextra.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits-Wextra.c
new file mode 100644
index 000000000..f8f528c99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits-Wextra.c
@@ -0,0 +1,70 @@
+/* Test that -Wtype-limits is enabled by -Wextra */
+/* { dg-do compile } */
+/* { dg-excess-errors "short=int" { target { avr-*-* } } }  */
+/* { dg-options "-Wextra" } */
+
+void a (unsigned char x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison is always false due to limited range of data type" } */
+  if (x >= 0) return;/* { dg-warning "comparison is always true due to limited range of data type" } */
+  if (0 > x)  return;/* { dg-warning "comparison is always false due to limited range of data type" } */
+  if (0 <= x) return;/* { dg-warning "comparison is always true due to limited range of data type" } */
+  if (x <= 255) /* { dg-warning "comparison is always true due to limited range of data type" } */
+    return;
+  if (255 >= x) /* { dg-warning "comparison is always true due to limited range of data type" } */
+    return;
+  if ((int)x <= 255) /* { dg-bogus "comparison is always true due to limited range of data type" "" { xfail *-*-* } 16 } */
+    return;
+  if (255 >= (unsigned char) 1)
+    return;
+
+}
+
+void b (unsigned short x)
+{                    /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } 25 } */
+  if (x < 0)  return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
+                     /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } 27 } */
+  if (x >= 0) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
+                     /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } 29 } */
+  if (0 > x)  return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
+                     /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } 31 } */
+  if (0 <= x) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
+}
+
+void c (unsigned int x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (1U >= 0) return;
+  if (1U < 0) return;
+  if (0 <= 1U) return;
+  if (0 > 1U) return;
+}
+
+void d (unsigned long x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+}
+
+void e (unsigned long long x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+}
+
+int test (int x) 
+{
+  if ((long long)x <= 0x123456789ABCLL) /* { dg-bogus "comparison is always true due to limited range of data type" "" { xfail *-*-* } 64 } */
+    return 1;
+  else 
+    return 0;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits-no.c
new file mode 100644
index 000000000..2af909abf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits-no.c
@@ -0,0 +1,66 @@
+/* Test disabling -Wtype-limits */
+/* { dg-do compile } */
+/* { dg-options "-Wextra -Wno-type-limits" } */
+
+
+void a (unsigned char x)
+{
+  if (x < 0)  return;/* { dg-bogus "comparison is always false due to limited range of data type" } */
+  if (x >= 0) return;/* { dg-bogus "comparison is always true due to limited range of data type" } */
+  if (0 > x)  return;/* { dg-bogus "comparison is always false due to limited range of data type" } */
+  if (0 <= x) return;/* { dg-bogus "comparison is always true due to limited range of data type" } */
+  if (x <= 255) /* { dg-bogus "comparison is always true due to limited range of data type" } */
+    return;
+  if (255 >= x) /* { dg-bogus "comparison is always true due to limited range of data type" } */
+    return;
+  if ((int)x <= 255)
+    return;
+  if (255 >= (unsigned char) 1)
+    return;
+
+}
+
+void b (unsigned short x)
+{
+  if (x < 0)  return;/* { dg-bogus "comparison is always false due to limited range of data type" } */
+  if (x >= 0) return;/* { dg-bogus "comparison is always true due to limited range of data type" } */
+  if (0 > x)  return;/* { dg-bogus "comparison is always false due to limited range of data type" } */
+  if (0 <= x) return;/* { dg-bogus "comparison is always true due to limited range of data type" } */
+}
+
+void c (unsigned int x)
+{
+  if (x < 0)  return;/* { dg-bogus "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-bogus "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-bogus "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-bogus "comparison of unsigned expression >= 0 is always true" } */
+  if (1U >= 0) return;
+  if (1U < 0) return;
+  if (0 <= 1U) return;
+  if (0 > 1U) return;
+}
+
+void d (unsigned long x)
+{
+  if (x < 0)  return;/* { dg-bogus "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-bogus "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-bogus "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-bogus "comparison of unsigned expression >= 0 is always true" } */
+}
+
+void e (unsigned long long x)
+{
+  if (x < 0)  return;/* { dg-bogus "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-bogus "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-bogus "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-bogus "comparison of unsigned expression >= 0 is always true" } */
+}
+
+int test (int x) 
+{
+  if ((long long)x <= 0x123456789ABCLL) 
+    return 1;
+  else 
+    return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits.c
new file mode 100644
index 000000000..5ff9ac053
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wtype-limits.c
@@ -0,0 +1,70 @@
+/* { dg-do compile } */
+/* { dg-excess-errors "short=int" { target { avr-*-* } } }  */
+/* { dg-options "-Wtype-limits" } */
+
+
+void a (unsigned char x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison is always false due to limited range of data type" } */
+  if (x >= 0) return;/* { dg-warning "comparison is always true due to limited range of data type" } */
+  if (0 > x)  return;/* { dg-warning "comparison is always false due to limited range of data type" } */
+  if (0 <= x) return;/* { dg-warning "comparison is always true due to limited range of data type" } */
+  if (x <= 255) /* { dg-warning "comparison is always true due to limited range of data type" } */
+    return;
+  if (255 >= x) /* { dg-warning "comparison is always true due to limited range of data type" } */
+    return;
+  if ((int)x <= 255) /* { dg-bogus "comparison is always true due to limited range of data type" "" { xfail *-*-* } 16 } */
+    return;
+  if (255 >= (unsigned char) 1)
+    return;
+
+}
+
+void b (unsigned short x)
+{                    /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } 25 } */
+  if (x < 0)  return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
+                     /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } 27 } */
+  if (x >= 0) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */  
+                     /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } 29 } */
+  if (0 > x)  return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
+                     /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } 31 } */
+  if (0 <= x) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
+}
+
+void c (unsigned int x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (1U >= 0) return;
+  if (1U < 0) return;
+  if (0 <= 1U) return;
+  if (0 > 1U) return;
+}
+
+void d (unsigned long x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+}
+
+void e (unsigned long long x)
+{
+  if (x < 0)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+  if (0 > x)  return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
+  if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+}
+
+int test (int x) 
+{
+  if ((long long)x <= 0x123456789ABCLL) /* { dg-bogus "comparison is always true due to limited range of data type" "" { xfail *-*-* } 64 } */
+    return 1;
+  else 
+    return 0;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunknownprag.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunknownprag.c
new file mode 100644
index 000000000..c5ba58f76
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunknownprag.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wunknown-pragmas" } */
+
+/* We used to get "unspellable token: CPP_EOF" warnings.  */
+
+#pragma				/* { dg-warning "ignoring #pragma" } */
+#pragma ~			/* { dg-warning "ignoring #pragma" } */
+#pragma baz			/* { dg-warning "ignoring #pragma" } */
+#pragma baz baz			/* { dg-warning "ignoring #pragma" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-1.c
new file mode 100644
index 000000000..d6d59b481
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wunreachable-code" } */
+
+extern void foo (void);
+extern void baz (void);
+
+void bar (int i)
+{
+  if (i < 2)
+    {
+      baz ();
+      return;
+    }
+  else
+    {
+      if (i >= 4 && i <= 5)
+        foo ();
+      return;
+    }
+
+  baz ();	/* { dg-warning "will never be executed" "" } */
+  baz ();
+  baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-2.c
new file mode 100644
index 000000000..8242441b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-2.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wunreachable-code" } */
+
+extern int foo (const char *);
+extern void baz (void);
+const char *a[] = { "one", "two" };
+
+void bar (void)
+{
+  int i;
+
+  for (i = 0; i < 2; i++)
+    if (! foo (a[i]))
+      return;
+
+  baz ();	/* { dg-bogus "will never be executed" } */
+  baz ();
+  baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-3.c
new file mode 100644
index 000000000..966d89e3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-3.c
@@ -0,0 +1,17 @@
+/* PR c/10175 */
+/* { dg-do compile } */
+/* { dg-options "-Wunreachable-code" } */
+
+int i,j;
+int main(void)
+{
+  if (0) {
+    i = 0;		   /* { dg-warning "will never be executed" "" } */
+    j = 0;
+  } else {
+    i = 1;
+    j = 1;
+  }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-4.c
new file mode 100644
index 000000000..38ae6f808
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-4.c
@@ -0,0 +1,12 @@
+/* PR middle-end/10336 */
+/* { dg-options "-Wunreachable-code" } */
+
+void foo(int i)
+{
+  switch(i) {
+    case 0:
+      break;
+    case 1:
+      break;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-5.c
new file mode 100644
index 000000000..11dc3204d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-5.c
@@ -0,0 +1,17 @@
+/* PR c/10175 */
+
+/* { dg-do compile } */
+/* { dg-options "-Wunreachable-code" } */
+
+int value;
+
+int main(void)
+{
+    if (0)
+        value = 0;  /* { dg-warning "will never be executed" "" } */
+    else
+        value = 1;
+
+    return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-6.c
new file mode 100644
index 000000000..6aac7aab2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-6.c
@@ -0,0 +1,21 @@
+/* PR c/11370  */
+/* { dg-do compile } */
+/* { dg-options "-Wunreachable-code" } */
+
+extern int printf (const char *, ...);
+extern void exit (int);
+
+int main(int argc, char *argv[])
+{
+  if (argc != 1)
+    exit(1);
+
+  {
+    int ix;  /* { dg-bogus "will never be executed" } */
+    ix = printf("hello\n");
+    printf("%d\n", ix);
+  }
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-7.c
new file mode 100644
index 000000000..9a4d411be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-7.c
@@ -0,0 +1,21 @@
+/* PR c/11370  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wunreachable-code" } */
+
+extern int printf (const char *, ...);
+extern void exit (int);
+
+int main(int argc, char *argv[])
+{
+  if (argc != 1)
+    exit(1);
+
+  {
+    int ix;  /* { dg-bogus "will never be executed" } */
+    ix = printf("hello\n");
+    printf("%d\n", ix);
+  }
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-8.c
new file mode 100644
index 000000000..81254ba3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunreachable-8.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wunreachable-code" } */
+float Factorial(float X)
+{
+  float val = 1.0;
+  int k,j;
+  for (k=1; k < 5; k++)
+    {
+      val += 1.0; /* { dg-bogus "will never be executed" "" { xfail *-*-* } } */
+    }
+  return (val); /* { dg-bogus "will never be executed" } */
+}
+
+int main (void)
+{
+  float result;
+  result=Factorial(2.1);
+  return (0);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-function.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-function.c
new file mode 100644
index 000000000..1c59c5003
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-function.c
@@ -0,0 +1,6 @@
+/* PR c/4076  -Wunused doesn't warn about static function only called by itself.  */
+/* { dg-do compile } */
+/* { dg-options "-Wunused-function" } */
+
+static void foo (void) {} /* { dg-warning "'foo' defined but not used" } */
+static void bar (void) { bar (); } /* { dg-warning "'bar' defined but not used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-1.c
new file mode 100644
index 000000000..0fc7c364b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-1.c
@@ -0,0 +1,31 @@
+/* Test -Wunused-value.  Bug 23113.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wunused-value" } */
+
+int f (void);
+void g (void);
+int *p;
+
+void
+h (void)
+{
+  1 + f (); /* { dg-warning "value computed is not used" } */
+  f () + f (); /* { dg-warning "value computed is not used" } */
+  f () + f (), f (); /* { dg-warning "value computed is not used" } */
+  (char) f (); /* { dg-warning "value computed is not used" } */
+  g ();
+  f ();
+  (void) f ();
+  *p++; /* { dg-warning "value computed is not used" } */
+  ++*p;
+  (*p ? f() : 0);
+  ({ f(); });
+  /* Statement expressions may be used in macro expansions which like
+     functions return values which may or may not be of use, so don't
+     warn for them but do warn inside them.  */
+  ({ f() + 1; });
+  ({ f(); 0; });
+  ({ f() + 1; 0; }); /* { dg-warning "value computed is not used" } */
+  1 + ({ f(); }); /* { dg-warning "value computed is not used" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-2.c
new file mode 100644
index 000000000..4858bfade
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-2.c
@@ -0,0 +1,18 @@
+/* Test -Wunused-value.  Bug 30729.  */
+/* { dg-do compile } */
+/* { dg-options "-Wunused-value" } */
+/* Make sure va_arg does not cause a value computed is not used warning
+   because it has side effects.   */
+#include <stdarg.h>
+
+int f(int t, ...)
+{
+  va_list a;
+  va_start (a, t);
+  va_arg(a, int);/* { dg-bogus "value computed is not used" } */
+  int t1 = va_arg(a, int);
+  va_end(a);
+  return t1;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-3.c
new file mode 100644
index 000000000..333ddea4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wunused-value-3.c
@@ -0,0 +1,9 @@
+/* PR c/39889 */
+/* { dg-do compile } */
+/* { dg-options "-Wunused-value" } */
+
+int x;
+int foo (void)
+{
+  return (1 ? x = 0 : (void) 0), 0; /* { dg-bogus "value computed is not used" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/Wwrite-strings-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wwrite-strings-1.c
new file mode 100644
index 000000000..03bb40941
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/Wwrite-strings-1.c
@@ -0,0 +1,8 @@
+/* Test pointer initialization and dereference don't lose qualifiers
+   on array types.  This test wrongly failed to diagnose the loss of
+   const.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wwrite-strings" } */
+typedef char T[1];
+T *p = &""; /* { dg-warning "initialization from incompatible pointer type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-1.c
new file mode 100644
index 000000000..388cb3bf5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-1.c
@@ -0,0 +1,28 @@
+// { dg-do compile }
+// { dg-options "-Wstrict-aliasing=2 -fstrict-aliasing" }
+
+// Copyright (C) 2002 Free Software Foundation, Inc.
+// Contributed by Nathan Sidwell 29 Sep 2002 <nathan@codesourcery.com>
+
+// 8083. warn about odd casts
+
+typedef int YYSTYPE;
+typedef struct tDefEntry 
+{
+  unsigned t;
+  
+} tDefEntry;
+struct incomplete;
+
+
+YYSTYPE
+ addSibMacro(
+         YYSTYPE  list )
+ {
+     tDefEntry** ppT   = (tDefEntry**)&list; // { dg-warning "type-punned pointer will" "" }
+ 
+     struct incomplete *p = (struct incomplete *)&list; // { dg-warning "type-punning to incomplete" "" }
+     
+     return list;
+ }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-10.c
new file mode 100644
index 000000000..6e9cb3f3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-10.c
@@ -0,0 +1,32 @@
+/* For PR tree-optimization/14784  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -funswitch-loops -fdump-tree-unswitch-details" } */
+
+typedef struct bitmap_element_def
+{
+  unsigned int indx;
+} bitmap_element;
+
+typedef struct bitmap_head_def {
+    bitmap_element *first;
+    int using_obstack;
+} bitmap_head;
+typedef struct bitmap_head_def *bitmap;
+
+bitmap_element *bitmap_free;
+
+void foo (bitmap head, bitmap_element *elt)
+{
+  while (1)
+    {
+      /* Alias analysis problems used to prevent us from recognizing
+	 that this condition is invariant.  */
+      if (head->using_obstack)
+	bitmap_free = elt;
+    }
+}
+
+
+/* { dg-final { scan-tree-dump-times "Unswitching" 1 "unswitch"} } */
+/* { dg-final { cleanup-tree-dump "unswitch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-11.c
new file mode 100644
index 000000000..36175d7c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-11.c
@@ -0,0 +1,111 @@
+/* { dg-do run } */
+/* { dg-require-alias "" } */
+/* { dg-options "-O2" } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct dw_cfi_struct
+{
+  struct dw_cfi_struct *dw_cfi_next;
+  const char *dw_cfi_addr;
+}
+dw_cfi_node;
+
+typedef struct dw_fde_struct
+{
+  const char *dw_fde_current_label;
+  dw_cfi_node *dw_fde_cfi;
+}
+dw_fde_node;
+
+dw_cfi_node *cie_cfi_head;
+unsigned fde_table_in_use;
+dw_fde_node *fde_table;
+
+__inline__ void
+add_cfi (dw_cfi_node **list_head, dw_cfi_node *cfi)
+{
+  dw_cfi_node **p;
+
+  for (p = list_head; (*p) != ((void *)0); p = &(*p)->dw_cfi_next)
+    ;
+
+  *p = cfi;
+}
+
+__inline__ struct dw_cfi_struct *
+new_cfi (void)
+{
+  dw_cfi_node *cfi = (dw_cfi_node *) malloc (sizeof (dw_cfi_node));
+
+  memset (cfi, 0, sizeof (dw_cfi_node));
+  return cfi;
+}
+
+char *
+dwarf2out_cfi_label (void)
+{
+  static char label[20];
+  static unsigned long label_num = 0;
+
+  sprintf (label, "*.%s%u", "LCFI", (unsigned) (label_num++));
+  return label;
+}
+
+void
+add_fde_cfi (const char *label, dw_cfi_node *cfi)
+{
+  if (label)
+    {
+      dw_fde_node *fde = fde_table + fde_table_in_use - 1;
+
+      if (*label == 0)
+	label = dwarf2out_cfi_label ();
+
+      if (fde->dw_fde_current_label == ((void *)0)
+	  || strcmp (label, fde->dw_fde_current_label))
+	{
+	  dw_cfi_node *xcfi;
+
+	  fde->dw_fde_current_label = label = strdup (label);
+
+	  xcfi = new_cfi ();
+	  xcfi->dw_cfi_addr = label;
+	  add_cfi (&fde->dw_fde_cfi, xcfi);
+	}
+
+      add_cfi (&fde->dw_fde_cfi, cfi);
+    }
+  else
+    add_cfi (&cie_cfi_head, cfi);
+}
+
+int
+main ()
+{
+  dw_cfi_node *cfi;
+  dw_fde_node *fde;
+
+  fde_table_in_use = 1;
+  fde_table = (dw_fde_node *) realloc (fde_table,
+				       sizeof (dw_fde_node));
+  memset (fde_table, 0, sizeof (dw_fde_node));
+  cfi = new_cfi ();
+  add_fde_cfi ("", cfi);
+
+  fde = &fde_table[0];
+  cfi = fde->dw_fde_cfi;
+
+  if (cfi == NULL)
+    abort ();
+
+  if (cfi->dw_cfi_addr == NULL)
+    abort ();
+
+  if (strcmp ("*.LCFI0", cfi->dw_cfi_addr))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-2.c
new file mode 100644
index 000000000..d507416b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-2.c
@@ -0,0 +1,16 @@
+// { dg-do compile }
+// { dg-options "-Wstrict-aliasing=2 -fstrict-aliasing" }
+
+struct foo {
+  char c;
+  char d;
+  short s;
+  int i;
+} bar;
+
+int
+sub1 (long long int foobar)
+{
+  struct foo *tmp = (struct foo *) &foobar; // { dg-warning "type-punned pointer might" "" }
+  return tmp->i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-3.c
new file mode 100644
index 000000000..3dc25a91c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-3.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-require-alias "" } */
+/* { dg-options "" } */
+
+extern int foo();
+
+int baz () { return foo(); }
+
+static inline int bar () __attribute__ ((alias ("foo"))); /* { dg-error "aliased to" } */
+
+int main () { return bar (); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-4.c
new file mode 100644
index 000000000..0a2633932
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-4.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-require-alias "" } */
+/* { dg-options "-O2 -funit-at-a-time" } */
+
+extern int foo();
+
+int baz () { return foo(); }
+
+static inline int bar () __attribute__ ((alias ("foo"))); /* { dg-error "aliased to" } */
+
+int main () { return bar (); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-5.c
new file mode 100644
index 000000000..56848c9a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-5.c
@@ -0,0 +1,7 @@
+/* { dg-do link } */
+/* { dg-require-alias "" } */
+/* { dg-options "" } */
+
+static inline int foo () { return 0; }
+static int bar () __attribute__ ((alias ("foo")));
+int main () { return bar (); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-6.c
new file mode 100644
index 000000000..3ba101aa1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-6.c
@@ -0,0 +1,7 @@
+/* { dg-do link } */
+/* { dg-require-alias "" } */
+/* { dg-options "-O2 -funit-at-a-time" } */
+
+static inline int foo () { return 0; }
+static int bar () __attribute__ ((alias ("foo")));
+int main () { return bar (); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-7.c
new file mode 100644
index 000000000..591c3028e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-7.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-require-alias "" } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+#define ASMNAME(cname)  ASMNAME2 (__USER_LABEL_PREFIX__, cname)
+#define ASMNAME2(prefix, cname) STRING (prefix) cname
+#define STRING(x)    #x
+
+int foo __asm__ (ASMNAME ("foo")) __attribute__((nocommon));
+extern __typeof (foo) bar __attribute__ ((weak, alias ("foo")));
+
+int
+main (void)
+{
+  if (&foo != &bar || foo || bar)
+    abort ();
+  return bar;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-8.c
new file mode 100644
index 000000000..690f1b62d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-8.c
@@ -0,0 +1,12 @@
+// { dg-do compile }
+// { dg-options "-Wstrict-aliasing=2 -fstrict-aliasing" }
+
+struct s {
+  char    *p;
+};
+
+void
+func(struct s *ptr)
+{
+  *(void **)&ptr->p = 0; /* { dg-warning "type-punned pointer" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-9.c
new file mode 100644
index 000000000..f8c100316
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/alias-9.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-Wstrict-aliasing=2 -O2" } */
+
+int a[2];
+
+double *foo1(void)
+{
+  return (double *)a; /* { dg-warning "strict-aliasing" } */
+}
+
+double *foo2(void)
+{
+  return (double *)&a[0]; /* { dg-warning "strict-aliasing" } */
+}
+
+_Complex x;
+int *bar(void)
+{
+  return (int *)&__imag x; /* { dg-warning "strict-aliasing" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/align-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/align-1.c
new file mode 100644
index 000000000..187eb5271
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/align-1.c
@@ -0,0 +1,28 @@
+/* PR java/10145
+   Test that requesting an alignment of 1 does not increase the alignment
+   of a long long field.
+
+   { dg-do run }
+   { dg-options "" }
+*/
+
+extern void abort (void);
+
+struct A
+{
+  char c;
+  long long i;
+};
+
+struct B
+{
+  char c;
+  long long i __attribute ((__aligned__ (1)));
+};
+
+int main ()
+{
+  if (sizeof (struct A) != sizeof (struct B))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/align-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/align-2.c
new file mode 100644
index 000000000..f5c00fd0c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/align-2.c
@@ -0,0 +1,6 @@
+/* PR 17962 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef float v4 __attribute__((vector_size(sizeof(float)*4)));
+extern char compile_time_assert[__alignof__(v4) == sizeof(float)*4 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/all_one_m128i.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/all_one_m128i.c
new file mode 100644
index 000000000..1b8a6fe73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/all_one_m128i.c
@@ -0,0 +1,41 @@
+/* { dg-do run { target x86_64-*-* i?86-*-* } } */
+/* { dg-options "-save-temps -O2 -msse2" } */
+
+
+#include <stdio.h>
+#include <xmmintrin.h>
+#include <emmintrin.h>
+__m128i m;
+__m128i m2;
+__attribute__((noinline))  __m128i foo()
+{
+  __m128i  minus_1 = __extension__(__m128i)(__v4si){-1,-1,-1,-1};
+  m = minus_1;
+  return minus_1;
+}
+
+
+int main ()
+{
+    unsigned *p, *p2;
+    p = (unsigned *)&m;
+    p2 =(unsigned *)&m2;
+    m2 = foo();
+
+    if (p[0] != (unsigned)-1 
+        || p[1] != (unsigned) -1
+        || p[2] != (unsigned) -1
+        || p[3] != (unsigned) -1)
+      return 1;
+
+    if (p2[0] != (unsigned)-1 
+        || p2[1] != (unsigned) -1
+        || p2[2] != (unsigned) -1
+        || p2[3] != (unsigned) -1)
+      return 2;
+        
+    return 0;
+}
+
+/* { dg-final { scan-assembler "pcmpeqd" } } */
+/* { dg-final { cleanup-saved-temps } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline.c
new file mode 100644
index 000000000..08119f1a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2" } */
+#include <stdarg.h>
+inline __attribute__ ((always_inline)) void
+e(int t, ...) /* { dg-message "sorry\[^\n\]*variable argument" "" } */
+{
+  va_list q;
+  va_start (q, t);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline2.c
new file mode 100644
index 000000000..c65df24ea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline2.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2" } */
+inline __attribute__ ((always_inline)) void t(void); /* { dg-message "sorry\[^\n\]*body not available" "" } */
+void
+q(void)
+{
+  t(); 				/* { dg-message "sorry\[^\n\]*called from here" "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline3.c
new file mode 100644
index 000000000..97c80aa52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/always_inline3.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2" } */
+int do_something_evil (void);
+inline __attribute__ ((always_inline)) void
+q2(void) /* { dg-message "sorry\[^\n\]*recursive" "" } */
+{
+  if (do_something_evil ())
+    return;
+  q2(); 			/* { dg-message "sorry\[^\n\]*called from here" "" } */
+  q2(); /* With -O2 we don't warn here, it is eliminated by tail recursion.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/and-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/and-1.c
new file mode 100644
index 000000000..c05e20512
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/and-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target powerpc*-*-* spu-*-* } } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler "and" } } */
+/* There should be no nand for this testcase (for either PPC or SPU). */
+/* xfail: PR tree-optimization/33512  */
+/* { dg-final { scan-assembler-not "nand" { xfail *-*-* } } } */
+
+int f(int y)
+{
+  return y & ~(y & -y);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-1.c
new file mode 100644
index 000000000..587d59d72
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-1.c
@@ -0,0 +1,56 @@
+/* { dg-options "-std=iso9899:1990" } */
+/* In strict ISO C mode, we don't recognize the anonymous struct/union
+   extension or any Microsoft extensions.  */
+
+struct A { char a; };
+
+/* MS extension.  */
+struct B {
+  struct A;			/* { dg-warning "does not declare anything" } */
+  char b;
+};
+char testB[sizeof(struct B) == sizeof(struct A) ? 1 : -1];
+
+/* MS extension.  */
+struct C {
+  struct D { char d; };		/* { dg-warning "does not declare anything" } */
+  char c;
+};
+char testC[sizeof(struct C) == sizeof(struct A) ? 1 : -1];
+char testD[sizeof(struct D) == sizeof(struct A) ? 1 : -1];
+
+/* GNU extension.  */
+struct E {
+  struct { char z; };		/* { dg-warning "does not declare anything" } */
+  char e;
+};
+char testE[sizeof(struct E) == sizeof(struct A) ? 1 : -1];
+
+/* MS extension.  */
+typedef struct A typedef_A;
+struct F {
+  typedef_A;			/* { dg-warning "does not declare anything" } */
+  char f;
+};
+char testF[sizeof(struct F) == sizeof(struct A) ? 1 : -1];
+
+/* __extension__ enables GNU C mode for the duration of the declaration.  */
+__extension__ struct G {
+  struct { char z; };
+  char g;
+};
+char testG[sizeof(struct G) == 2 * sizeof(struct A) ? 1 : -1];
+
+struct H {
+  __extension__ struct { char z; };
+  char h;
+};
+char testH[sizeof(struct H) == 2 * sizeof(struct A) ? 1 : -1];
+
+/* Make sure __extension__ gets turned back off.  */
+struct I {
+  struct { char z; };		/* { dg-warning "does not declare anything" } */
+  char i;
+};
+char testI[sizeof(struct I) == sizeof(struct A) ? 1 : -1];
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-2.c
new file mode 100644
index 000000000..4bd2d0f33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-2.c
@@ -0,0 +1,48 @@
+/* { dg-options "-std=gnu89" } */
+/* In GNU C mode, we recognize the anonymous struct/union extension,
+   but not Microsoft extensions.  */
+
+struct A { char a; };
+
+/* MS extension.  */
+struct B {
+  struct A;			/* { dg-warning "does not declare anything" } */
+  char b;
+};
+char testB[sizeof(struct B) == sizeof(struct A) ? 1 : -1];
+
+/* MS extension.  */
+struct C {
+  struct D { char d; };		/* { dg-warning "does not declare anything" } */
+  char c;
+};
+char testC[sizeof(struct C) == sizeof(struct A) ? 1 : -1];
+char testD[sizeof(struct D) == sizeof(struct A) ? 1 : -1];
+
+/* GNU extension.  */
+struct E {
+  struct { char z; };
+  char e;
+};
+char testE[sizeof(struct E) == 2 * sizeof(struct A) ? 1 : -1];
+
+/* MS extension.  */
+typedef struct A typedef_A;
+struct F {
+  typedef_A;			/* { dg-warning "does not declare anything" } */
+  char f;
+};
+char testF[sizeof(struct F) == sizeof(struct A) ? 1 : -1];
+
+/* Test that __extension__ does the right thing coming _from_ GNU C mode.  */
+__extension__ struct G {
+  struct { char z; };
+  char g;
+};
+char testG[sizeof(struct G) == 2 * sizeof(struct A) ? 1 : -1];
+
+struct H {
+  struct { char z; };
+  char h;
+};
+char testH[sizeof(struct H) == 2 * sizeof(struct A) ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-3.c
new file mode 100644
index 000000000..3ed6e672b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-3.c
@@ -0,0 +1,32 @@
+/* { dg-options "-std=gnu89 -fms-extensions" } */
+/* Enabling Microsoft mode makes all of the tests equivalent.  Checked vs
+   Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8168 for 80x86
+ */
+
+struct A { char a; };
+
+struct B {
+  struct A;
+  char b;
+};
+char testB[sizeof(struct B) == 2 * sizeof(struct A) ? 1 : -1];
+
+struct C {
+  struct D { char d; };
+  char c;
+};
+char testC[sizeof(struct C) == 2 * sizeof(struct A) ? 1 : -1];
+char testD[sizeof(struct D) == sizeof(struct A) ? 1 : -1];
+
+struct E {
+  struct { char z; };
+  char e;
+};
+char testE[sizeof(struct E) == 2 * sizeof(struct A) ? 1 : -1];
+
+typedef struct A typedef_A;
+struct F {
+  typedef_A;
+  char f;
+};
+char testF[sizeof(struct F) == 2 * sizeof(struct A) ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-4.c
new file mode 100644
index 000000000..dc30b0cc0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-4.c
@@ -0,0 +1,10 @@
+/* Test anonymous structures with type qualifiers.  Bug 8420.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+struct s {
+  struct { int a; };
+  const struct { int b; };
+  struct { int c; } volatile;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-5.c
new file mode 100644
index 000000000..af1690ed3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-5.c
@@ -0,0 +1,7 @@
+/* Test bad warning for anonymous int in structure.  Bug 17189.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+struct Foo { int; }; /* { dg-bogus "unnamed" } */
+/* { dg-error "declaration does not declare anything" "int;" { target *-*-* } 5 } */
+/* { dg-error "struct has no members" "no members" { target *-*-* } 5 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-6.c
new file mode 100644
index 000000000..8ce14f484
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-6.c
@@ -0,0 +1,12 @@
+/* Test diagnostics for structure member with no type specifier or
+   declarator.  Test with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s {
+  int a;
+  const;
+};
+/* { dg-warning "useless type qualifier in empty declaration" "empty" { target *-*-* } 9 } */
+/* { dg-warning "empty declaration" "empty 2" { target *-*-* } 9 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-7.c
new file mode 100644
index 000000000..0f05583c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-7.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for structure member with no type specifier or
+   declarator.  Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+struct s {
+  int a;
+  const; /* { dg-warning "ISO C forbids member declarations with no members" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-8.c
new file mode 100644
index 000000000..66db0834e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/anon-struct-8.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for structure member with no type specifier or
+   declarator.  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+struct s {
+  int a;
+  const; /* { dg-error "ISO C forbids member declarations with no members" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-1.c
new file mode 100644
index 000000000..6d1e69a17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-1.c
@@ -0,0 +1,15 @@
+/* Simplified from ncurses 5.0's pad.c
+   by Alexandre Oliva <oliva@lsd.ic.unicamp.br>
+
+   Copyright (C) 1999 Free Software Foundation  */
+
+/* { dg-do compile } */
+
+extern char foo[1];
+char foo[] = "";
+
+int
+bar()
+{
+  return foo[0];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-10.c
new file mode 100644
index 000000000..aab1538d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-10.c
@@ -0,0 +1,33 @@
+/* Test invalid array sizes at file scope: should not cause ICEs.
+   Bugs 25161 and 27020.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int a;
+
+int b0[a]; /* { dg-error "at file scope" } */
+int (*b1)[a]; /* { dg-error "at file scope" } */
+int (*b2())[a]; /* { dg-error "at file scope" } */
+struct b3 { int x[a]; }; /* { dg-error "at file scope" } */
+struct b4 { int (*x)[a]; }; /* { dg-error "at file scope" } */
+typeof (int [a]) b5; /* { dg-error "at file scope|outside of any function" } */
+
+int c0[(__SIZE_TYPE__)&a]; /* { dg-error "at file scope" } */
+int (*c1)[(__SIZE_TYPE__)&a]; /* { dg-error "at file scope" } */
+int (*c2())[(__SIZE_TYPE__)&a]; /* { dg-error "at file scope" } */
+struct c3 { int x[(__SIZE_TYPE__)&a]; }; /* { dg-error "at file scope" } */
+struct c4 { int (*x)[(__SIZE_TYPE__)&a]; }; /* { dg-error "at file scope" } */
+typeof (int [(__SIZE_TYPE__)&a]) c5; /* { dg-error "at file scope" } */
+
+int d0[1/0]; /* { dg-error "at file scope" } */
+/* { dg-warning "division by zero" "" { target *-*-* } 23 } */
+int (*d1)[1/0]; /* { dg-error "at file scope" } */
+/* { dg-warning "division by zero" "" { target *-*-* } 25 } */
+int (*d2())[1/0]; /* { dg-error "at file scope" } */
+/* { dg-warning "division by zero" "" { target *-*-* } 27 } */
+struct d3 { int x[1/0]; }; /* { dg-error "at file scope" } */
+/* { dg-warning "division by zero" "" { target *-*-* } 29 } */
+struct d4 { int (*x)[1/0]; }; /* { dg-error "at file scope" } */
+/* { dg-warning "division by zero" "" { target *-*-* } 31 } */
+typeof (int [1/0]) d5; /* { dg-error "at file scope" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-2.c
new file mode 100644
index 000000000..497c58666
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-2.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Verify that we can't do things to get ourselves in trouble
+   with GCC's initialized flexible array member extension.  */
+
+struct f { int w; int x[]; };
+struct g { struct f f; };
+struct g g1 = { { 0, { } } };
+struct g g2 = { { 0, { 1 } } }; /* { dg-error "nested context" "nested" } */
+				/* { dg-error "near init" "near" { target *-*-* } 10 } */
+struct h { int x[0]; int y; };
+struct h h1 = { { 0 }, 1 }; /* { dg-warning "excess elements" "excess" } */
+			    /* { dg-warning "near init" "before end" { target *-*-* } 13 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-3.c
new file mode 100644
index 000000000..f0709d220
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-3.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* ISO C99 flexible array members don't have a size.  GCC's zero-length
+   array extension does.  */
+
+struct f { int w; int x[0]; } f;
+struct g { int w; int x[]; } g;
+
+char test_gcc[sizeof (f.x) ? -1 : 1];
+char test_iso[sizeof (g.x) ? -1 : 1]; /* { dg-error "incomplete type" "iso" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-4.c
new file mode 100644
index 000000000..b3e4f6c50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-4.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+
+/* Verify that GCC's initialized flexible array member extension
+   works properly.  */
+
+extern void abort(void);
+extern void exit(int);
+
+struct f { int w; int x[]; };
+struct g { int w; int x[0]; };
+
+static struct f f = { 4, { 0, 1, 2, 3 } };
+static int junk1[] = { -1, -1, -1, -1 };
+static struct g g = { 4, { 0, 1, 2, 3 } }; /* { dg-warning "(excess elements)|(near initialization)" "" } */
+static int junk2[] = { -1, -1, -1, -1 };
+
+int main()
+{
+  int i;
+  for (i = 0; i < f.w; ++i)
+    if (f.x[i] != i)
+      abort ();
+  exit(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-5.c
new file mode 100644
index 000000000..4083c92ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-5.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Check compatibility of array declarations.  */
+
+/* Incomplete decl matches.  */
+extern char arr0[];
+char arr0[1];
+
+/* Two integral expressions must be the same.  Note that 0 is
+   a gcc extension, but it should work like any other constant.  */
+extern char arr1[1];
+char arr1[1];
+extern char arr2[0];
+char arr2[0];
+extern char arr3[0];            /* { dg-message "note: previous declaration" } */
+char arr3[1];                   /* { dg-error "conflicting types" } */
+
+/* Variable size matches.  */
+void func(int n, int m)
+{
+  /* The next two are from the example in c99 6.7.5.2/9.  */
+  {
+    /* Invalid: not compatible because 4 != 6.  */
+    int a[n][6][m];
+    int (*p)[4][n+1];
+    p = a;			/* { dg-warning "incompatible" } */
+  }
+  {
+    /* Compatible, but defined behavior only if n == 6 and m == n+1.  */
+    int c[n][n][6][m];
+    int (*r)[n][n][n+1];
+    r = c;
+  }
+  {
+    /* Compatible, but undefined behavior; (2, 2) is not a constant
+       expression, and thus A is a VLA.  */
+    int a[6][(2, 2)];
+    int (*p)[3];
+    p = a; /* { dg-bogus "incompatible" "bad vla handling" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-6.c
new file mode 100644
index 000000000..6ef64625b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-6.c
@@ -0,0 +1,18 @@
+/* PR c/5597 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Verify that GCC forbids non-static initialization of
+   flexible array members. */
+
+struct str { int len; char s[]; };
+
+struct str a = { 2, "a" };
+
+void foo()
+{
+  static struct str b = { 2, "b" };
+  struct str c = { 2, "c" }; /* { dg-error "(non-static)|(near initialization)" } */
+  struct str d = (struct str) { 2, "d" }; /* { dg-error "(non-static)|(near initialization)" } */
+  struct str e = (struct str) { d.len, "e" }; /* { dg-error "(non-static)|(initialization)" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-7.c
new file mode 100644
index 000000000..9e70b2682
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-7.c
@@ -0,0 +1,14 @@
+/* Test for array of incomplete structure type - Zack Weinberg in
+   <http://gcc.gnu.org/ml/gcc-patches/2004-08/msg00108.html>.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct foo;
+
+void
+f (void)
+{
+  struct foo { int a; int b; };
+}
+
+struct foo array[5]; /* { dg-error "array type has incomplete element type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-8.c
new file mode 100644
index 000000000..f50fe6db0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-8.c
@@ -0,0 +1,49 @@
+/* Test diagnostics for array references.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+struct s { char c[1]; };
+struct s f (void);
+_Bool b;
+char c;
+enum e { E } e;
+extern int a[];
+int *p;
+void *pv;
+void (*fp)(void);
+struct si *sip;
+
+void
+g (void)
+{
+  a[b];
+  a[c];
+  a[e];
+  p[b];
+  p[c];
+  p[e];
+  b[a];
+  c[a];
+  e[a];
+  b[p];
+  c[p];
+  e[p];
+  /* These two should be treated the same.  In particular, a "neither
+     array nor pointer" bogus warning used to be given for the
+     second.  */
+  f().c[0];
+  0[f().c];
+  /* Various invalid cases.  */
+  c[c]; /* { dg-error "subscripted value is neither array nor pointer" } */
+  p[1.0]; /* { dg-error "array subscript is not an integer" } */
+  1.0[a]; /* { dg-error "array subscript is not an integer" } */
+  fp[0]; /* { dg-error "subscripted value is pointer to function" } */
+  0[fp]; /* { dg-error "subscripted value is pointer to function" } */
+  pv[0]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  0[pv]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  sip[0]; /* { dg-error "invalid use of undefined type 'struct si'" } */
+  /* { dg-error "dereferencing pointer to incomplete type" "incomplete" { target *-*-* } 45 } */
+  0[sip]; /* { dg-error "invalid use of undefined type 'struct si'" } */
+  /* { dg-error "dereferencing pointer to incomplete type" "incomplete" { target *-*-* } 47 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-9.c
new file mode 100644
index 000000000..f173f6569
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-9.c
@@ -0,0 +1,10 @@
+/* PR target/27421 */
+/* { dg-do compile } */
+
+struct A
+{
+  int i;
+  void x[1];  /* { dg-error "array of voids" } */
+};
+
+void foo(struct A a) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-init-1.c
new file mode 100644
index 000000000..0ab86346f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-init-1.c
@@ -0,0 +1,25 @@
+/* Test that both arrays are initialized by store_by_pieces.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+struct A { char c[10]; };
+extern void baz (struct A *);
+
+void
+foo (void)
+{
+  struct A a = { "abcdefghi" };
+  baz (&a);
+}
+
+void
+bar (void)
+{
+  struct A a;
+  __builtin_strcpy (&a.c[0], "abcdefghi");
+  baz (&a);
+}
+
+/* { dg-final { scan-assembler-not "abcdefghi" { target i?86-*-* x86_64-*-* ia64-*-* } } } */
+/* { dg-final { scan-assembler-times "7017280452245743464\|7523094288207667809\|6867666564636261\|1684234849\|64636261" 2 { target i?86-*-* x86_64-*-* ia64-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-init-2.c
new file mode 100644
index 000000000..9c425818f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-init-2.c
@@ -0,0 +1,51 @@
+/* Test array initializion by store_by_pieces.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+struct A { char c[10]; };
+extern void abort (void);
+
+void
+__attribute__((noinline))
+check (struct A * a, int b)
+{
+  const char *p;
+  switch (b)
+    {
+    case 0:
+      p = "abcdefghi";
+      break;
+    case 1:
+      p = "j\0\0\0\0\0\0\0\0";
+      break;
+    case 2:
+      p = "kl\0\0\0\0\0\0\0";
+      break;
+    case 3:
+      p = "mnop\0\0\0\0\0";
+      break;
+    case 4:
+      p = "qrstuvwx\0";
+      break;
+    default:
+      abort ();
+    }
+  if (__builtin_memcmp (a->c, p, 10) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct A a = { "abcdefghi" };
+  check (&a, 0);
+  struct A b = { "j" };
+  check (&b, 1);
+  struct A c = { "kl" };
+  check (&c, 2);
+  struct A d = { "mnop" };
+  check (&d, 3);
+  struct A e = { "qrstuvwx" };
+  check (&e, 4);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-quals-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-quals-1.c
new file mode 100644
index 000000000..f01db686b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-quals-1.c
@@ -0,0 +1,30 @@
+/* Test for various combinations of const, arrays and typedefs:
+   should never actually get const on the final array type, but
+   all should end up in a read-only section.  PR c/12165.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* The MMIX port always switches to the .data section at the end of a file.  */
+/* { dg-final { scan-assembler-not "\\.data(?!\\.rel\\.ro)" { xfail powerpc*-*-aix* mmix-*-* x86_64-*-mingw* picochip--*-* avr-*-*} } } */
+static const int a[2] = { 1, 2 };
+const int a1[2] = { 1, 2 };
+typedef const int ci;
+static ci b[2] = { 3, 4 };
+ci b1[2] = { 3, 4 };
+typedef int ia[2];
+static const ia c = { 5, 6 };
+const ia c1 = { 5, 6 };
+typedef const int cia[2];
+static cia d = { 7, 8 };
+cia d1 = { 7, 8 };
+static cia e[2] = { { 1, 2 }, { 3, 4 } };
+cia e1[2] = { { 1, 2 }, { 3, 4 } };
+void *const p = &a;
+void *const q = &b;
+void *const r = &c;
+void *const s = &d;
+void *const t = &e;
+void *const p1 = &a1;
+void *const q1 = &b1;
+void *const r1 = &c1;
+void *const s1 = &d1;
+void *const t1 = &e1;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/array-quals-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-quals-2.c
new file mode 100644
index 000000000..2f1304e2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/array-quals-2.c
@@ -0,0 +1,14 @@
+/* Test that pointers to arrays of differently qualified types aren't
+   permitted in conditional expressions, and that qualifiers aren't
+   lost in forming composite types.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+typedef const char T[1];
+typedef const char T2[1];
+typedef volatile char U[1];
+T *p;
+T2 *p2;
+U *q;
+void *f(void) { return 1 ? p : q; } /* { dg-warning "pointer type mismatch in conditional expression" } */
+T *g(void) { return 1 ? p : p2; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-1.c
new file mode 100644
index 000000000..fecac780f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target int32plus } */
+
+struct x {
+  int selector;
+};
+
+void f()
+{
+  struct x* addr;
+  __asm__("mov %%gs,%0":"=r" ((unsigned short)addr->selector)); /* { dg-error "lvalue" "casts make rvalues" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-2.c
new file mode 100644
index 000000000..9c464ce89
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-2.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f()
+{
+  asm volatile ("foo%%bar" : : );
+}
+
+/* { dg-final { scan-assembler "foo%bar" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-3.c
new file mode 100644
index 000000000..917942d7b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-3.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f()
+{
+  asm ("foo%%bar");
+}
+
+/* { dg-final { scan-assembler "foo%%bar" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-4.c
new file mode 100644
index 000000000..00675982a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-4.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int main()
+{
+  int x, y, z;
+
+  asm volatile ("test0 X%0Y%[arg]Z" : [arg] "=g" (x));
+  asm volatile ("test1 X%[out]Y%[in]Z" : [out] "=g" (y) : [in] "0"(y));
+  asm volatile ("test2 X%a0Y%a[arg]Z" : : [arg] "p" (&z));
+  asm volatile ("test3 %[in]" : [inout] "=g"(x) : "[inout]" (x), [in] "g" (y));
+}
+
+/* ??? Someone explain why the back reference dosn't work.  */
+/* { dontdg-final { scan-assembler "test0 X(.*)Y\1Z" } } */
+/* { dontdg-final { scan-assembler "test1 X(.*)Y\1Z" } } */
+/* { dontdg-final { scan-assembler "test2 X(.*)Y\1Z" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-6.c
new file mode 100644
index 000000000..9c0ac1eb2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-6.c
@@ -0,0 +1,7 @@
+/* Check error messages for named asm operands.  */
+void foo ()
+{
+  int i;
+  __asm__ ("" : [data] "=r" (i) : [data] "i" (100)); /* { dg-error "duplicate asm operand" } */
+  __asm__ ("%[foo]" :: [bar] "i" (1)); /* { dg-error "undefined named operand" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-7.c
new file mode 100644
index 000000000..65b0353fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-7.c
@@ -0,0 +1,28 @@
+/* Gcc 3.3.1 deprecates memory inputs of non-lvalues.  */
+/* { dg-do compile } */
+
+void test(void)
+{
+  register int r;
+  register int r2;
+  int i;
+  static int m;
+  int *p;
+
+  __asm__ ("" : : "m"(r));	/* { dg-error "" } */
+  __asm__ ("" : : "m"(i));
+  __asm__ ("" : : "m"(m));
+  __asm__ ("" : : "m"(0));	/* { dg-error "" } */
+  __asm__ ("" : : "m"(i+1));	/* { dg-error "" } */
+  __asm__ ("" : : "m"(*p++));
+
+  __asm__ ("" : : "g"(r));
+  __asm__ ("" : : "g"(i));
+  __asm__ ("" : : "g"(m));
+  __asm__ ("" : : "g"(0));
+  __asm__ ("" : : "g"(i+1));
+
+  __asm__ ("" : "=m"(r2));	/* { dg-error "" } */
+  __asm__ ("" : "=m"(i));
+  __asm__ ("" : "=m"(m));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-8.c
new file mode 100644
index 000000000..a3f3962eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-8.c
@@ -0,0 +1,9 @@
+/* PR inline-asm/11676 */
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+void foo(void)
+{
+  long x = 0;
+  asm volatile ("" : "=r"(x) : "r"(x)); /* { dg-bogus "uninitialized" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-9.c
new file mode 100644
index 000000000..4e3244169
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-9.c
@@ -0,0 +1,11 @@
+/* PR inline-asm/15740 */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+void foo(void)
+{
+  int a, b;
+  a = 1;
+  b = a + 1;
+  asm ("" : : "m" (a));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-a.c
new file mode 100644
index 000000000..a676c9ebc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-a.c
@@ -0,0 +1,15 @@
+/* { dg-options "-O2" } */
+/* { dg-do compile } */
+/* { dg-require-effective-target ilp32 } */
+
+/* The problem was we were not striping the long cast here.
+   Note this really should be invalid code but not for the
+   current release (4.0) as we have people using it.  */
+
+void blockCopy_MMX2(int*);
+void postProcess_MMX2()
+{
+  int c, x,y, width;
+  asm( "" :: "m" ((long)x));
+  blockCopy_MMX2(&c);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-b.c
new file mode 100644
index 000000000..beb35f28d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-b.c
@@ -0,0 +1,39 @@
+/* { dg-do run  { target powerpc*-*-* i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O1" } */
+/* Test to make sure that inline-asm causes the tree optimizers to get the
+   V_MAY_DEFs and clobber memory.  */
+/* Test from Jakub Jelinek, modified by Andrew Pinski to work on all powerpc targets.  */
+extern void abort (void);
+
+unsigned short v = 0x0300;
+
+void
+foo (unsigned short *p)
+{
+  *p = v;
+}
+
+int
+bar (void)
+{
+  unsigned short x;
+  volatile unsigned short *z;
+  foo (&x);
+  const unsigned int y = x;
+  z = &x;
+#if defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) || defined (_POWER) || defined (__ppc64__)
+  __asm __volatile ("sthbrx %1,0,%2" : "=m" (*z) : "r" (y), "r" (z));
+#elif defined __i386__ || defined __x86_64__
+  __asm __volatile ("movb %b1,1(%2)\n\tmovb %h1,(%2)"
+		    : "=m" (*z) : "Q" (y), "R" (z));
+#endif
+  return (x & 1) == 0;
+}
+
+int
+main (void)
+{
+  if (bar ())
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-fs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-fs-1.c
new file mode 100644
index 000000000..f215ee8ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-fs-1.c
@@ -0,0 +1,14 @@
+/* Origin: <hp@bitrange.com>
+   Make sure we do not get spurious '*' characters in section names or
+   elsewhere, with asm-specified names.  */
+/* { dg-do compile } */
+/* { dg-options "-w -ffunction-sections -fdata-sections" } */
+
+void foo (void) asm ("_bar");
+void foo (void) {}
+
+extern int foobar asm ("_baz");
+int foobar = 3;
+
+/* { dg-final { scan-assembler-not "\\*_bar" } } */
+/* { dg-final { scan-assembler-not "\\*_baz" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-names.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-names.c
new file mode 100644
index 000000000..f5e44e65f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-names.c
@@ -0,0 +1,16 @@
+/* The name specified by an asm("...") suffix on a declaration is not
+   to have an underscore prefixed, even if normal symbols are.
+   Problem reported by Krister Walfridsson <cato@df.lth.se>.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fleading-underscore" } */
+/* { dg-final { scan-assembler-not "____frob14" } } */
+
+extern void frobnicate (void) asm ("___frob14");  /* three underscores */
+
+int
+main (void)
+{
+  frobnicate ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-pr24146.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-pr24146.c
new file mode 100644
index 000000000..0b1be7da7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-pr24146.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+/* Test that asm with no outputs are treated as volatile.  */
+
+void f(int x)
+{
+  __asm__ ("extended asm not discarded" : : "r" (x));
+}
+
+void g (void)
+{
+  __asm__ ("simple asm not discarded");
+}
+/* { dg-final { scan-assembler "extended asm not discarded" } } */
+/* { dg-final { scan-assembler "simple asm not discarded" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-qual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-qual-1.c
new file mode 100644
index 000000000..5ec9a29a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-qual-1.c
@@ -0,0 +1,12 @@
+/* Test that qualifiers other than volatile are ignored on asm.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void
+f (void)
+{
+  asm volatile ("");
+  asm const (""); /* { dg-warning "const qualifier ignored on asm" } */
+  asm restrict (""); /* { dg-warning "restrict qualifier ignored on asm" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-wide-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-wide-1.c
new file mode 100644
index 000000000..a42271fd4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/asm-wide-1.c
@@ -0,0 +1,32 @@
+/* Wide string literals should not be allowed in asm.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int foo asm (L"bar"); /* { dg-error "wide string literal in 'asm'" } */
+
+asm (L"foo"); /* { dg-error "wide string literal in 'asm'" } */
+
+void
+f (void)
+{
+  int x = 1;
+  asm (L"foo"); /* { dg-error "wide string literal in 'asm'" } */
+  asm ("foo" :
+       L"=g" (x)); /* { dg-error "wide string literal in 'asm'" } */
+  asm ("foo" : [x]
+       L"=g" (x)); /* { dg-error "wide string literal in 'asm'" } */
+  asm ("foo" : [x] "=g" (x),
+       L"=g" (x)); /* { dg-error "wide string literal in 'asm'" } */
+  asm ("foo" : :
+       L"g" (x)); /* { dg-error "wide string literal in 'asm'" } */
+  asm ("foo" : : :
+       L"memory"); /* { dg-error "wide string literal in 'asm'" } */
+  asm ("foo" : : : "memory",
+       L"memory"); /* { dg-error "wide string literal in 'asm'" } */
+}
+
+/* Extra errors from the substitution of "" for wide strings: */
+/* { dg-error "output" "output" { target *-*-* } 16 } */
+/* { dg-error "output" "output" { target *-*-* } 18 } */
+/* { dg-error "output" "output" { target *-*-* } 20 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-1.c
new file mode 100644
index 000000000..a0cfd890f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-1.c
@@ -0,0 +1,128 @@
+/* Test diagnostics for bad implicit type conversions.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+#define TESTARG(ID, TL, TR) void ID##F(TL); void ID##F2(TR x) { ID##F(x); } extern int dummy
+#define TESTARP(ID, TL, TR) struct { void (*x)(TL); } ID##Fp; void ID##F2(TR x) { ID##Fp.x(x); } extern int dummy
+#define TESTASS(ID, TL, TR) void ID##F(TR x) { TL y; y = x; } extern int dummy
+#define TESTINI(ID, TL, TR) void ID##F(TR x) { TL y = x; } extern int dummy
+#define TESTRET(ID, TL, TR) TR ID##V; TL ID##F(void) { return ID##V; } extern int dummy
+
+typedef void (*fp)(void);
+typedef void (*nrfp)(void) __attribute__((noreturn));
+
+TESTARG(fqa, nrfp, fp); /* { dg-warning "passing argument 1 of 'fqaF' makes qualified function pointer from unqualified" } */
+TESTARP(fqb, nrfp, fp); /* { dg-warning "passing argument 1 of 'fqbFp.x' makes qualified function pointer from unqualified" } */
+TESTASS(fqc, nrfp, fp); /* { dg-warning "assignment makes qualified function pointer from unqualified" } */
+TESTINI(fqd, nrfp, fp); /* { dg-warning "initialization makes qualified function pointer from unqualified" } */
+TESTRET(fqe, nrfp, fp); /* { dg-warning "return makes qualified function pointer from unqualified" } */
+
+TESTARG(ofqa, fp, nrfp);
+TESTARP(ofqb, fp, nrfp);
+TESTASS(ofqc, fp, nrfp);
+TESTINI(ofqd, fp, nrfp);
+TESTRET(ofqe, fp, nrfp);
+
+TESTARG(qa, char *, const char *); /* { dg-warning "passing argument 1 of 'qaF' discards qualifiers from pointer target type" } */
+TESTARP(qb, char *, const char *); /* { dg-warning "passing argument 1 of 'qbFp.x' discards qualifiers from pointer target type" } */
+TESTASS(qc, char *, const char *); /* { dg-warning "assignment discards qualifiers from pointer target type" } */
+TESTINI(qd, char *, const char *); /* { dg-warning "initialization discards qualifiers from pointer target type" } */
+TESTRET(qe, char *, const char *); /* { dg-warning "return discards qualifiers from pointer target type" } */
+
+TESTARG(oqa, const char *, char *);
+TESTARP(oqb, const char *, char *);
+TESTASS(oqc, const char *, char *);
+TESTINI(oqd, const char *, char *);
+TESTRET(oqe, const char *, char *);
+
+TESTARG(fda, fp, void *); /* { dg-warning "ISO C forbids passing argument 1 of 'fdaF' between function pointer and 'void \\*'" } */
+TESTARP(fdb, fp, void *); /* { dg-warning "ISO C forbids passing argument 1 of 'fdbFp.x' between function pointer and 'void \\*'" } */
+TESTASS(fdc, fp, void *); /* { dg-warning "ISO C forbids assignment between function pointer and 'void \\*'" } */
+TESTINI(fdd, fp, void *); /* { dg-warning "ISO C forbids initialization between function pointer and 'void \\*'" } */
+TESTRET(fde, fp, void *); /* { dg-warning "ISO C forbids return between function pointer and 'void \\*'" } */
+
+TESTARG(dfa, void *, fp); /* { dg-warning "ISO C forbids passing argument 1 of 'dfaF' between function pointer and 'void \\*'" } */
+TESTARP(dfb, void *, fp); /* { dg-warning "ISO C forbids passing argument 1 of 'dfbFp.x' between function pointer and 'void \\*'" } */
+TESTASS(dfc, void *, fp); /* { dg-warning "ISO C forbids assignment between function pointer and 'void \\*'" } */
+TESTINI(dfd, void *, fp); /* { dg-warning "ISO C forbids initialization between function pointer and 'void \\*'" } */
+TESTRET(dfe, void *, fp); /* { dg-warning "ISO C forbids return between function pointer and 'void \\*'" } */
+
+TESTARG(sua, int *, unsigned int *); /* { dg-warning "pointer targets in passing argument 1 of 'suaF' differ in signedness" } */
+TESTARP(sub, int *, unsigned int *); /* { dg-warning "pointer targets in passing argument 1 of 'subFp.x' differ in signedness" } */
+TESTASS(suc, int *, unsigned int *); /* { dg-warning "pointer targets in assignment differ in signedness" } */
+TESTINI(sud, int *, unsigned int *); /* { dg-warning "pointer targets in initialization differ in signedness" } */
+TESTRET(sue, int *, unsigned int *); /* { dg-warning "pointer targets in return differ in signedness" } */
+
+TESTARG(usa, unsigned int *, int *); /* { dg-warning "pointer targets in passing argument 1 of 'usaF' differ in signedness" } */
+TESTARP(usb, unsigned int *, int *); /* { dg-warning "pointer targets in passing argument 1 of 'usbFp.x' differ in signedness" } */
+TESTASS(usc, unsigned int *, int *); /* { dg-warning "pointer targets in assignment differ in signedness" } */
+TESTINI(usd, unsigned int *, int *); /* { dg-warning "pointer targets in initialization differ in signedness" } */
+TESTRET(use, unsigned int *, int *); /* { dg-warning "pointer targets in return differ in signedness" } */
+
+TESTARG(cua, char *, unsigned char *); /* { dg-warning "pointer targets in passing argument 1 of 'cuaF' differ in signedness" } */
+TESTARP(cub, char *, unsigned char *); /* { dg-warning "pointer targets in passing argument 1 of 'cubFp.x' differ in signedness" } */
+TESTASS(cuc, char *, unsigned char *); /* { dg-warning "pointer targets in assignment differ in signedness" } */
+TESTINI(cud, char *, unsigned char *); /* { dg-warning "pointer targets in initialization differ in signedness" } */
+TESTRET(cue, char *, unsigned char *); /* { dg-warning "pointer targets in return differ in signedness" } */
+
+TESTARG(uca, unsigned char *, char *); /* { dg-warning "pointer targets in passing argument 1 of 'ucaF' differ in signedness" } */
+TESTARP(ucb, unsigned char *, char *); /* { dg-warning "pointer targets in passing argument 1 of 'ucbFp.x' differ in signedness" } */
+TESTASS(ucc, unsigned char *, char *); /* { dg-warning "pointer targets in assignment differ in signedness" } */
+TESTINI(ucd, unsigned char *, char *); /* { dg-warning "pointer targets in initialization differ in signedness" } */
+TESTRET(uce, unsigned char *, char *); /* { dg-warning "pointer targets in return differ in signedness" } */
+
+TESTARG(csa, char *, signed char *); /* { dg-warning "pointer targets in passing argument 1 of 'csaF' differ in signedness" } */
+TESTARP(csb, char *, signed char *); /* { dg-warning "pointer targets in passing argument 1 of 'csbFp.x' differ in signedness" } */
+TESTASS(csc, char *, signed char *); /* { dg-warning "pointer targets in assignment differ in signedness" } */
+TESTINI(csd, char *, signed char *); /* { dg-warning "pointer targets in initialization differ in signedness" } */
+TESTRET(cse, char *, signed char *); /* { dg-warning "pointer targets in return differ in signedness" } */
+
+TESTARG(sca, signed char *, char *); /* { dg-warning "pointer targets in passing argument 1 of 'scaF' differ in signedness" } */
+TESTARP(scb, signed char *, char *); /* { dg-warning "pointer targets in passing argument 1 of 'scbFp.x' differ in signedness" } */
+TESTASS(scc, signed char *, char *); /* { dg-warning "pointer targets in assignment differ in signedness" } */
+TESTINI(scd, signed char *, char *); /* { dg-warning "pointer targets in initialization differ in signedness" } */
+TESTRET(sce, signed char *, char *); /* { dg-warning "pointer targets in return differ in signedness" } */
+
+TESTARG(cia, char *, int *); /* { dg-warning "passing argument 1 of 'ciaF' from incompatible pointer type" } */
+TESTARP(cib, char *, int *); /* { dg-warning "passing argument 1 of 'cibFp.x' from incompatible pointer type" } */
+TESTASS(cic, char *, int *); /* { dg-warning "assignment from incompatible pointer type" } */
+TESTINI(cid, char *, int *); /* { dg-warning "initialization from incompatible pointer type" } */
+TESTRET(cie, char *, int *); /* { dg-warning "return from incompatible pointer type" } */
+
+TESTARG(ica, int *, char *); /* { dg-warning "passing argument 1 of 'icaF' from incompatible pointer type" } */
+TESTARP(icb, int *, char *); /* { dg-warning "passing argument 1 of 'icbFp.x' from incompatible pointer type" } */
+TESTASS(icc, int *, char *); /* { dg-warning "assignment from incompatible pointer type" } */
+TESTINI(icd, int *, char *); /* { dg-warning "initialization from incompatible pointer type" } */
+TESTRET(ice, int *, char *); /* { dg-warning "return from incompatible pointer type" } */
+
+TESTARG(ciia, char *, int); /* { dg-warning "passing argument 1 of 'ciiaF' makes pointer from integer without a cast" } */
+TESTARP(ciib, char *, int); /* { dg-warning "passing argument 1 of 'ciibFp.x' makes pointer from integer without a cast" } */
+TESTASS(ciic, char *, int); /* { dg-warning "assignment makes pointer from integer without a cast" } */
+TESTINI(ciid, char *, int); /* { dg-warning "initialization makes pointer from integer without a cast" } */
+TESTRET(ciie, char *, int); /* { dg-warning "return makes pointer from integer without a cast" } */
+
+TESTARG(iica, int, char *); /* { dg-warning "passing argument 1 of 'iicaF' makes integer from pointer without a cast" } */
+TESTARP(iicb, int, char *); /* { dg-warning "passing argument 1 of 'iicbFp.x' makes integer from pointer without a cast" } */
+TESTASS(iicc, int, char *); /* { dg-warning "assignment makes integer from pointer without a cast" } */
+TESTINI(iicd, int, char *); /* { dg-warning "initialization makes integer from pointer without a cast" } */
+TESTRET(iice, int, char *); /* { dg-warning "return makes integer from pointer without a cast" } */
+
+struct s { int a; };
+
+TESTARG(stria, struct s, int); /* { dg-error "incompatible type for argument 1 of 'striaF'" } */
+TESTARP(strib, struct s, int); /* { dg-error "incompatible type for argument 1 of 'stribFp.x'" } */
+TESTASS(stric, struct s, int); /* { dg-error "incompatible types when assigning to type 'struct s' from type 'int'" } */
+TESTINI(strid, struct s, int); /* { dg-error "invalid initializer" } */
+TESTRET(strie, struct s, int); /* { dg-error "incompatible types when returning type 'int' but 'struct s' was expected" } */
+
+TESTARG(istra, int, struct s); /* { dg-error "incompatible type for argument 1 of 'istraF'" } */
+
+TESTARP(istrb, int, struct s); /* { dg-error "incompatible type for argument 1 of 'istrbFp.x'" } */
+
+TESTASS(istrc, int, struct s); /* { dg-error "incompatible types when assigning to type 'int' from type 'struct s'" } */
+TESTINI(istrd, int, struct s); /* { dg-error "incompatible types when initializing type 'int' using type 'struct s'" } */
+TESTRET(istre, int, struct s); /* { dg-error "incompatible types when returning type 'struct s' but 'int' was expected" } */
+
+/* Match all extra informative notes.  */
+/* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-2.c
new file mode 100644
index 000000000..f3d861d74
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-2.c
@@ -0,0 +1,125 @@
+/* Test diagnostics for bad implicit type conversions.
+   -pedantic-errors test.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+#define TESTARG(ID, TL, TR) void ID##F(TL); void ID##F2(TR x) { ID##F(x); } extern int dummy
+#define TESTARP(ID, TL, TR) struct { void (*x)(TL); } ID##Fp; void ID##F2(TR x) { ID##Fp.x(x); } extern int dummy
+#define TESTASS(ID, TL, TR) void ID##F(TR x) { TL y; y = x; } extern int dummy
+#define TESTINI(ID, TL, TR) void ID##F(TR x) { TL y = x; } extern int dummy
+#define TESTRET(ID, TL, TR) TR ID##V; TL ID##F(void) { return ID##V; } extern int dummy
+
+typedef void (*fp)(void);
+typedef void (*nrfp)(void) __attribute__((noreturn));
+
+TESTARG(fqa, nrfp, fp); /* { dg-error "passing argument 1 of 'fqaF' makes qualified function pointer from unqualified" } */
+TESTARP(fqb, nrfp, fp); /* { dg-error "passing argument 1 of 'fqbFp.x' makes qualified function pointer from unqualified" } */
+TESTASS(fqc, nrfp, fp); /* { dg-error "assignment makes qualified function pointer from unqualified" } */
+TESTINI(fqd, nrfp, fp); /* { dg-error "initialization makes qualified function pointer from unqualified" } */
+TESTRET(fqe, nrfp, fp); /* { dg-error "return makes qualified function pointer from unqualified" } */
+
+TESTARG(ofqa, fp, nrfp);
+TESTARP(ofqb, fp, nrfp);
+TESTASS(ofqc, fp, nrfp);
+TESTINI(ofqd, fp, nrfp);
+TESTRET(ofqe, fp, nrfp);
+
+TESTARG(qa, char *, const char *); /* { dg-error "passing argument 1 of 'qaF' discards qualifiers from pointer target type" } */
+TESTARP(qb, char *, const char *); /* { dg-error "passing argument 1 of 'qbFp.x' discards qualifiers from pointer target type" } */
+TESTASS(qc, char *, const char *); /* { dg-error "assignment discards qualifiers from pointer target type" } */
+TESTINI(qd, char *, const char *); /* { dg-error "initialization discards qualifiers from pointer target type" } */
+TESTRET(qe, char *, const char *); /* { dg-error "return discards qualifiers from pointer target type" } */
+
+TESTARG(oqa, const char *, char *);
+TESTARP(oqb, const char *, char *);
+TESTASS(oqc, const char *, char *);
+TESTINI(oqd, const char *, char *);
+TESTRET(oqe, const char *, char *);
+
+TESTARG(fda, fp, void *); /* { dg-error "ISO C forbids passing argument 1 of 'fdaF' between function pointer and 'void \\*'" } */
+TESTARP(fdb, fp, void *); /* { dg-error "ISO C forbids passing argument 1 of 'fdbFp.x' between function pointer and 'void \\*'" } */
+TESTASS(fdc, fp, void *); /* { dg-error "ISO C forbids assignment between function pointer and 'void \\*'" } */
+TESTINI(fdd, fp, void *); /* { dg-error "ISO C forbids initialization between function pointer and 'void \\*'" } */
+TESTRET(fde, fp, void *); /* { dg-error "ISO C forbids return between function pointer and 'void \\*'" } */
+
+TESTARG(dfa, void *, fp); /* { dg-error "ISO C forbids passing argument 1 of 'dfaF' between function pointer and 'void \\*'" } */
+TESTARP(dfb, void *, fp); /* { dg-error "ISO C forbids passing argument 1 of 'dfbFp.x' between function pointer and 'void \\*'" } */
+TESTASS(dfc, void *, fp); /* { dg-error "ISO C forbids assignment between function pointer and 'void \\*'" } */
+TESTINI(dfd, void *, fp); /* { dg-error "ISO C forbids initialization between function pointer and 'void \\*'" } */
+TESTRET(dfe, void *, fp); /* { dg-error "ISO C forbids return between function pointer and 'void \\*'" } */
+
+TESTARG(sua, int *, unsigned int *); /* { dg-error "pointer targets in passing argument 1 of 'suaF' differ in signedness" } */
+TESTARP(sub, int *, unsigned int *); /* { dg-error "pointer targets in passing argument 1 of 'subFp.x' differ in signedness" } */
+TESTASS(suc, int *, unsigned int *); /* { dg-error "pointer targets in assignment differ in signedness" } */
+TESTINI(sud, int *, unsigned int *); /* { dg-error "pointer targets in initialization differ in signedness" } */
+TESTRET(sue, int *, unsigned int *); /* { dg-error "pointer targets in return differ in signedness" } */
+
+TESTARG(usa, unsigned int *, int *); /* { dg-error "pointer targets in passing argument 1 of 'usaF' differ in signedness" } */
+TESTARP(usb, unsigned int *, int *); /* { dg-error "pointer targets in passing argument 1 of 'usbFp.x' differ in signedness" } */
+TESTASS(usc, unsigned int *, int *); /* { dg-error "pointer targets in assignment differ in signedness" } */
+TESTINI(usd, unsigned int *, int *); /* { dg-error "pointer targets in initialization differ in signedness" } */
+TESTRET(use, unsigned int *, int *); /* { dg-error "pointer targets in return differ in signedness" } */
+
+TESTARG(cua, char *, unsigned char *); /* { dg-error "pointer targets in passing argument 1 of 'cuaF' differ in signedness" } */
+TESTARP(cub, char *, unsigned char *); /* { dg-error "pointer targets in passing argument 1 of 'cubFp.x' differ in signedness" } */
+TESTASS(cuc, char *, unsigned char *); /* { dg-error "pointer targets in assignment differ in signedness" } */
+TESTINI(cud, char *, unsigned char *); /* { dg-error "pointer targets in initialization differ in signedness" } */
+TESTRET(cue, char *, unsigned char *); /* { dg-error "pointer targets in return differ in signedness" } */
+
+TESTARG(uca, unsigned char *, char *); /* { dg-error "pointer targets in passing argument 1 of 'ucaF' differ in signedness" } */
+TESTARP(ucb, unsigned char *, char *); /* { dg-error "pointer targets in passing argument 1 of 'ucbFp.x' differ in signedness" } */
+TESTASS(ucc, unsigned char *, char *); /* { dg-error "pointer targets in assignment differ in signedness" } */
+TESTINI(ucd, unsigned char *, char *); /* { dg-error "pointer targets in initialization differ in signedness" } */
+TESTRET(uce, unsigned char *, char *); /* { dg-error "pointer targets in return differ in signedness" } */
+
+TESTARG(csa, char *, signed char *); /* { dg-error "pointer targets in passing argument 1 of 'csaF' differ in signedness" } */
+TESTARP(csb, char *, signed char *); /* { dg-error "pointer targets in passing argument 1 of 'csbFp.x' differ in signedness" } */
+TESTASS(csc, char *, signed char *); /* { dg-error "pointer targets in assignment differ in signedness" } */
+TESTINI(csd, char *, signed char *); /* { dg-error "pointer targets in initialization differ in signedness" } */
+TESTRET(cse, char *, signed char *); /* { dg-error "pointer targets in return differ in signedness" } */
+
+TESTARG(sca, signed char *, char *); /* { dg-error "pointer targets in passing argument 1 of 'scaF' differ in signedness" } */
+TESTARP(scb, signed char *, char *); /* { dg-error "pointer targets in passing argument 1 of 'scbFp.x' differ in signedness" } */
+TESTASS(scc, signed char *, char *); /* { dg-error "pointer targets in assignment differ in signedness" } */
+TESTINI(scd, signed char *, char *); /* { dg-error "pointer targets in initialization differ in signedness" } */
+TESTRET(sce, signed char *, char *); /* { dg-error "pointer targets in return differ in signedness" } */
+
+TESTARG(cia, char *, int *); /* { dg-error "passing argument 1 of 'ciaF' from incompatible pointer type" } */
+TESTARP(cib, char *, int *); /* { dg-error "passing argument 1 of 'cibFp.x' from incompatible pointer type" } */
+TESTASS(cic, char *, int *); /* { dg-error "assignment from incompatible pointer type" } */
+TESTINI(cid, char *, int *); /* { dg-error "initialization from incompatible pointer type" } */
+TESTRET(cie, char *, int *); /* { dg-error "return from incompatible pointer type" } */
+
+TESTARG(ica, int *, char *); /* { dg-error "passing argument 1 of 'icaF' from incompatible pointer type" } */
+TESTARP(icb, int *, char *); /* { dg-error "passing argument 1 of 'icbFp.x' from incompatible pointer type" } */
+TESTASS(icc, int *, char *); /* { dg-error "assignment from incompatible pointer type" } */
+TESTINI(icd, int *, char *); /* { dg-error "initialization from incompatible pointer type" } */
+TESTRET(ice, int *, char *); /* { dg-error "return from incompatible pointer type" } */
+
+TESTARG(ciia, char *, int); /* { dg-error "passing argument 1 of 'ciiaF' makes pointer from integer without a cast" } */
+TESTARP(ciib, char *, int); /* { dg-error "passing argument 1 of 'ciibFp.x' makes pointer from integer without a cast" } */
+TESTASS(ciic, char *, int); /* { dg-error "assignment makes pointer from integer without a cast" } */
+TESTINI(ciid, char *, int); /* { dg-error "initialization makes pointer from integer without a cast" } */
+TESTRET(ciie, char *, int); /* { dg-error "return makes pointer from integer without a cast" } */
+
+TESTARG(iica, int, char *); /* { dg-error "passing argument 1 of 'iicaF' makes integer from pointer without a cast" } */
+TESTARP(iicb, int, char *); /* { dg-error "passing argument 1 of 'iicbFp.x' makes integer from pointer without a cast" } */
+TESTASS(iicc, int, char *); /* { dg-error "assignment makes integer from pointer without a cast" } */
+TESTINI(iicd, int, char *); /* { dg-error "initialization makes integer from pointer without a cast" } */
+TESTRET(iice, int, char *); /* { dg-error "return makes integer from pointer without a cast" } */
+
+struct s { int a; };
+
+TESTARG(stria, struct s, int); /* { dg-error "incompatible type for argument 1 of 'striaF'" } */
+TESTARP(strib, struct s, int); /* { dg-error "incompatible type for argument 1 of 'stribFp.x'" } */
+TESTASS(stric, struct s, int); /* { dg-error "incompatible types when assigning to type 'struct s' from type 'int'" } */
+TESTINI(strid, struct s, int); /* { dg-error "invalid initializer" } */
+TESTRET(strie, struct s, int); /* { dg-error "incompatible types when returning type 'int' but 'struct s' was expected" } */
+
+TESTARG(istra, int, struct s); /* { dg-error "incompatible type for argument 1 of 'istraF'" } */
+TESTARP(istrb, int, struct s); /* { dg-error "incompatible type for argument 1 of 'istrbFp.x'" } */
+TESTASS(istrc, int, struct s); /* { dg-error "incompatible types when assigning to type 'int' from type 'struct s'" } */
+TESTINI(istrd, int, struct s); /* { dg-error "incompatible types when initializing type 'int' using type 'struct s'" } */
+TESTRET(istre, int, struct s); /* { dg-error "incompatible types when returning type 'struct s' but 'int' was expected" } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-3.c
new file mode 100644
index 000000000..f415cc6a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/assign-warn-3.c
@@ -0,0 +1,13 @@
+/* Test diagnostics for bad type conversion when inlining unprototyped
+   functions: should not be errors with -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-O3 -std=c99 -pedantic-errors" } */
+
+/* This is valid to execute, so maybe shouldn't warn at all.  */
+inline void f0(x) signed char *x; { }
+void g0(unsigned char *x) { f0(x); } /* { dg-bogus "warning: pointer targets in passing argument 1 of 'f0' differ in signedness" } */
+
+/* This is undefined on execution but still must compile.  */
+inline void f1(x) int *x; { }
+void g1(unsigned int *x) { f1(x); } /* { dg-bogus "warning: pointer targets in passing argument 1 of 'f1' differ in signedness" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-1.c
new file mode 100644
index 000000000..8f530a84c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-1.c
@@ -0,0 +1,8 @@
+/* PR c++/12795 */
+/* { dg-require-alias "" } */
+
+void foo()
+{
+  extern void bar () __attribute__ ((__alias__ ("BAR"))); /* { dg-warning "ignored" } */
+  bar ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-2.c
new file mode 100644
index 000000000..c4179a47c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-2.c
@@ -0,0 +1,20 @@
+/* PR 19031 */
+/* { dg-do link } */
+/* { dg-require-alias "" } */
+/* { dg-options "-funit-at-a-time" } */
+
+static int f1 (void) { return 0; }
+extern int g1 (void) __attribute__((__alias__("f1")));
+
+#define STR(x) STR1(__USER_LABEL_PREFIX__, x)
+#define STR1(x,y) STR2(x, y)
+#define STR2(x,y) #x #y
+
+static int f2 (void) __asm__(STR(a2));
+static int f2 (void) { return 0; }
+extern int g2 (void) __attribute__((__alias__("a2")));
+
+int main ()
+{
+  return g1() + g2();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-3.c
new file mode 100644
index 000000000..02637b231
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-3.c
@@ -0,0 +1,62 @@
+// { dg-do link }
+// { dg-xfail-if "" { "powerpc-ibm-aix*" } { "*" } { "" } }
+// { dg-require-alias "" }
+// { dg-options "-O2 -fno-common" }
+
+// Copyright 2005 Free Software Foundation, Inc.
+// Contributed by Alexandre Oliva <aoliva@redhat.com>
+
+// PR middle-end/24295
+
+// The unit-at-a-time call graph code used to fail to emit variables
+// without external linkage that were only used indirectly, through
+// aliases.  Although the PR above is about #pragma weak-introduced
+// aliases, the underlying machinery is the same.
+
+#ifndef ATTRIBUTE_USED
+# define ATTRIBUTE_USED __attribute__((used))
+#endif
+
+static int lv1;
+extern int Av1a __attribute__((alias ("lv1")));
+int *pv1a = &Av1a;
+
+static int lv2;
+extern int Av2a __attribute__((alias ("lv2")));
+int *pv2a = &lv2;
+
+static int lv3;
+extern int Av3a __attribute__((alias ("lv3")));
+static int *pv3a ATTRIBUTE_USED = &Av3a;
+
+static int lv4;
+extern int Av4a __attribute__((alias ("lv4")));
+static int *pv4a = &Av4a;
+
+typedef void ftype(void);
+
+static void lf1(void) {}
+extern ftype Af1a __attribute__((alias ("lf1")));
+ftype *pf1a = &Af1a;
+
+static void lf2(void) {}
+extern ftype Af2a __attribute__((alias ("lf2")));
+ftype *pf2a = &Af2a;
+
+static void lf3(void) {}
+extern ftype Af3a __attribute__((alias ("lf3")));
+static ftype *pf3a ATTRIBUTE_USED = &Af3a;
+
+static void lf4(void) {}
+extern ftype Af4a __attribute__((alias ("lf4")));
+static ftype *pf4a = &Af4a;
+
+main() {
+#ifdef __mips
+  /* Use real asm for MIPS, to stop the assembler warning about
+     orphaned high-part relocations.  */
+  asm volatile ("lw $2,%0\n\tlw $2,%1" : : "m" (pv4a), "m" (pf4a) : "$2");
+#else
+  asm volatile ("" : : "m" (pv4a), "m" (pf4a));
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-4.c
new file mode 100644
index 000000000..fb15a20bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alias-4.c
@@ -0,0 +1,4 @@
+/* ICE on invalid alias attribute: PR 35434.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+typedef int i __attribute__((alias("j"))); /* { dg-warning "ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alloc_size-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alloc_size-2.c
new file mode 100644
index 000000000..3cac80737
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alloc_size-2.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+
+char *foo() __attribute__((alloc_size(1))); /* { dg-warning "outside range" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alloc_size.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alloc_size.c
new file mode 100644
index 000000000..47d7c0050
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alloc_size.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+extern void abort (void);
+
+#include "../gcc.c-torture/execute/builtins/chk.h"
+
+extern char *mallocminus1(int size) __attribute__((alloc_size(-1))); /* { dg-warning "parameter outside range" } */
+extern char *malloc0(int size) __attribute__((alloc_size(0))); /* { dg-warning "parameter outside range" } */
+extern char *malloc1(int size) __attribute__((alloc_size(1)));
+extern char *malloc2(int empty, int size) __attribute__((alloc_size(2)));
+extern char *calloc1(int size, int elements) __attribute__((alloc_size(1,2)));
+extern char *calloc2(int size, int empty, int elements) __attribute__((alloc_size(1,3)));
+extern char *balloc1(void *size) __attribute__((alloc_size(1)));
+
+void
+test (void)
+{
+  char *p;
+
+  p = malloc0 (6);
+  strcpy (p, "Hello");
+  p = malloc1 (6);
+  strcpy (p, "Hello");
+  strcpy (p, "Hello World"); /* { dg-warning "will always overflow" "strcpy" } */
+  p = malloc2 (__INT_MAX__ >= 1700000 ? 424242 : __INT_MAX__ / 4, 6);
+  strcpy (p, "World");
+  strcpy (p, "Hello World"); /* { dg-warning "will always overflow" "strcpy" } */
+  p = calloc1 (2, 5);
+  strcpy (p, "World");
+  strcpy (p, "Hello World"); /* { dg-warning "will always overflow" "strcpy" } */
+  p = calloc2 (2, __INT_MAX__ >= 1700000 ? 424242 : __INT_MAX__ / 4, 5);
+  strcpy (p, "World");
+  strcpy (p, "Hello World"); /* { dg-warning "will always overflow" "strcpy" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alwaysinline.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alwaysinline.c
new file mode 100644
index 000000000..8ff92b23a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-alwaysinline.c
@@ -0,0 +1,19 @@
+/* Test always_inline attribute, which forces inlining of functions
+   even at no optimization.  */
+/* Origin: Aldy Hernandez <aldyh@redhat.com>.  */
+/* { dg-do compile } */
+/* { dg-options "-O0" } */
+
+static inline int sabrina (void) __attribute__((always_inline));
+
+static inline int sabrina (void)
+{
+  return 13;
+}
+
+int bar (void)
+{
+  return sabrina () + 68;
+}
+
+/* { dg-final { scan-assembler-not "sabrina" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-error-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-error-1.c
new file mode 100644
index 000000000..c136484a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-error-1.c
@@ -0,0 +1,12 @@
+/* PR c/35744 */
+
+typedef char a[N] __attribute__((aligned(4))); /* { dg-error "undeclared" } */
+
+void c[1] __attribute__((vector_size(8))); /* { dg-error "array of voids" } */
+
+void b[1] __attribute__((may_alias)); /* { dg-error "array of voids" } */
+
+struct A
+{
+  void d[1] __attribute__((packed)); /* { dg-error "array of voids" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-externally-visible-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-externally-visible-1.c
new file mode 100644
index 000000000..e1db6923a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-externally-visible-1.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fwhole-program" } */
+/* { dg-final { scan-assembler "foo1" } } */
+/* { dg-final { scan-assembler "foo2" } } */
+/* { dg-final { scan-assembler "foo3" } } */
+/* { dg-final { scan-assembler "foo4" } } */
+/* { dg-final { scan-assembler "foo5" } } */
+/* { dg-final { scan-assembler-not "foo6" } } */
+/* { dg-final { scan-assembler "bar1" } } */
+/* { dg-final { scan-assembler "bar2" } } */
+/* { dg-final { scan-assembler "bar3" } } */
+/* { dg-final { scan-assembler "bar4" } } */
+/* { dg-final { scan-assembler "bar5" } } */
+/* { dg-final { scan-assembler-not "bar6" } } */
+
+extern void foo1 (void) __attribute__((externally_visible));
+void foo1 (void) { }
+
+extern void foo2 (void) __attribute__((externally_visible));
+__attribute__((externally_visible)) void foo2 (void) { }
+
+extern void foo3 (void);
+__attribute__((externally_visible)) void foo3 (void) { }
+
+__attribute__((externally_visible)) void foo4 (void) { }
+
+void foo5 (void) { }
+extern void foo5 (void) __attribute__((externally_visible));
+
+void foo6 (void) { }
+
+extern char *bar1 __attribute__((externally_visible));
+char *bar1;
+
+extern char *bar2 __attribute__((externally_visible));
+char *bar2 __attribute__((externally_visible));
+
+extern char *bar3;
+char *bar3 __attribute__((externally_visible));
+
+char *bar4 __attribute__((externally_visible));
+
+char *bar5;
+extern char *bar5 __attribute__((externally_visible));
+
+char *bar6;
+
+int main (void) { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-externally-visible-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-externally-visible-2.c
new file mode 100644
index 000000000..0a925bab3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-externally-visible-2.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fwhole-program" } */
+
+static void foo1 (void) { }					/* { dg-warning "have effect only on public" } */
+extern void foo1 (void) __attribute__((externally_visible));
+
+void foo2 (void)
+{
+  __attribute__((externally_visible)) void foo3 (void) { }	/* { dg-warning "have effect only on public" } */
+}
+
+__attribute__((externally_visible)) static void foo3 (void) { }	/* { dg-warning "have effect only on public" } */
+
+static int bar1;
+extern int bar1 __attribute__((externally_visible));		/* { dg-warning "have effect only on public" } */
+
+static int bar2 __attribute__((externally_visible));		/* { dg-warning "have effect only on public" } */
+
+void fn1 (void)
+{
+  static int bar3 __attribute__((externally_visible));		/* { dg-warning "have effect only on public" } */
+}
+
+void fn2 (void)
+{
+  int bar4 __attribute__((externally_visible));			/* { dg-warning "have effect only on public" } */
+}
+
+struct A
+{
+} __attribute__((externally_visible));				/* { dg-warning "does not apply to types" } */
+
+typedef int B __attribute__((externally_visible));		/* { dg-warning "attribute ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-invalid.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-invalid.c
new file mode 100644
index 000000000..6568c1ab2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-invalid.c
@@ -0,0 +1,100 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+#define CONCAT_(A,B) A ## B
+#define CONCAT(A,B) CONCAT_(A,B)
+
+#define ATTR __attribute__((AT))
+#define ATSYM(suf) CONCAT (AT, CONCAT_ (_, suf))
+
+#define AT noinline
+
+typedef int ATSYM(type) ATTR; /* { dg-warning "attribute ignored" "" } */
+
+typedef int (*ATSYM(fntype))(void) ATTR; /* { dg-warning "attribute ignored" "" } */
+
+struct ATSYM(struct) {
+  char dummy ATTR; /* { dg-warning "attribute ignored" "" } */
+} ATTR; /* { dg-warning "does not apply to types" "" } */
+
+int ATSYM(var) ATTR;  /* { dg-warning "attribute ignored" "" } */
+
+int ATSYM(fn_knrarg) (arg)
+  int arg ATTR; /* { dg-warning "attribute ignored" "" } */
+{ return 0; }
+
+int ATSYM(fn_isoarg) (int arg ATTR) { return 0; } /* { dg-warning "attribute ignored" "" } */
+
+int ATSYM(fn_vars) (void) {
+  static int svar ATTR; /* { dg-warning "attribute ignored" "" } */
+  auto int lvar ATTR; /* { dg-warning "attribute ignored" "" } */
+  return 0;
+}
+
+
+#undef AT
+#define AT used
+
+typedef int ATSYM(type) ATTR; /* { dg-warning "attribute ignored" "" } */
+
+typedef int (*ATSYM(fntype))(void) ATTR; /* { dg-warning "attribute ignored" "" } */
+
+struct ATSYM(struct) {
+  char dummy ATTR; /* { dg-warning "attribute ignored" "" } */
+} ATTR; /* { dg-warning "does not apply to types" "" } */
+
+int ATSYM(var) ATTR;
+
+int ATSYM(fn_knrarg) (arg)
+  int arg ATTR; /* { dg-warning "attribute ignored" "" } */
+{ return 0; }
+
+int ATSYM(fn_isoarg) (int arg ATTR) { return 0; } /* { dg-warning "attribute ignored" "" } */
+
+int ATSYM(fn_vars) (void) {
+  static int svar ATTR;
+  auto int lvar ATTR; /* { dg-warning "attribute ignored" "" } */
+  return 0;
+}
+
+
+/* PR 28287 */
+/* These are invalid on all targets.  Applying to PARM_ or FIELD_DECL
+   also caused a tree checking ice on targets that support weak,  */
+#undef AT
+#define AT weak
+
+typedef int ATSYM(type) ATTR; /* { dg-warning "attribute ignored" "" } */
+
+typedef int (*ATSYM(fntype))(void) ATTR; /* { dg-warning "attribute ignored" "" } */
+
+struct ATSYM(struct) {
+  char dummy ATTR; /* { dg-warning "attribute ignored" "" } */
+};
+
+int ATSYM(fn_knrarg) (arg)
+  int arg ATTR; /* { dg-warning "attribute ignored" "" } */
+{ return 0; }
+
+int ATSYM(fn_isoarg) (int arg ATTR) { return 0; } /* { dg-warning "attribute ignored" "" } */
+
+
+/* PR target/28648  */
+/* These are invalid on all targets.  Applying to PARM_ or FIELD_DECL
+   also caused a tree checking ice on targets that support dllimport.  */
+#undef AT
+#define AT dllimport
+
+typedef int ATSYM(type) ATTR;  /* { dg-warning "attribute |directive ignored" "" } */
+
+typedef int (*ATSYM(fntype))(void) ATTR;   /* { dg-warning "attribute |directive ignored" "" } */
+
+struct ATSYM(struct) {
+  char dummy ATTR;  /* { dg-warning "attribute |directive ignored" "" } */
+};
+
+int ATSYM(fn_knrarg) (arg)
+  int arg ATTR;  /* { dg-warning "attribute |directive ignored" "" } */
+{ return 0; }
+
+int ATSYM(fn_isoarg) (int arg ATTR) { return 0; }  /* { dg-warning "attribute |directive ignored" "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-nosave_low_regs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-nosave_low_regs.c
new file mode 100644
index 000000000..3bda1014c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-nosave_low_regs.c
@@ -0,0 +1,28 @@
+/* { dg-do compile { target { { sh-*-* sh[1234ble]*-*-* } && nonpic } } } */
+/* { dg-options "-O" } */
+
+extern void bar ();
+
+void foo ()
+{
+}
+
+#pragma interrupt
+void ( __attribute__ ((nosave_low_regs)) isr) ()
+{
+  bar ();
+}
+
+void delay(int a)
+{
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
+/* A call will clobber all call-saved registers, but because of
+   #pragma nosave_low_regs, r0..r7 need not be saved/restored.
+   One of these registers will also do fine to hold the function address.
+   Call-saved registers r8..r13 also don't need to be restored.  */
+/* { dg-final { scan-assembler-not "\[^f\]r\[0-9\]\[ \t\]*," } } */
+/* { dg-final { scan-assembler-not "\[^f\]r\[89\]" } } */
+/* { dg-final { scan-assembler-not "\[^f\]r1\[,0-3\]" } } */
+/* { dg-final { scan-assembler-times "macl" 2} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-trap_exit.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-trap_exit.c
new file mode 100644
index 000000000..7ea24c494
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-trap_exit.c
@@ -0,0 +1,23 @@
+/* { dg-do compile { target sh-*-* sh[1234ble]*-*-* } } */
+/* { dg-options "-O" } */
+/* Check that trapa / interrput_handler attributes can paired in
+   either order.  */
+void h0() __attribute__ ((trap_exit (4))) __attribute__ ((interrupt_handler));
+void h1() __attribute__ ((interrupt_handler)) __attribute__ ((trap_exit (5)));
+
+void foo ()
+{
+}
+
+void h0 () {}
+/* { dg-final { scan-assembler "trapa\[ \t\]\[ \t\]*#4"} } */
+/* { dg-final { scan-assembler-times "trapa" 1} } */
+
+void delay(int a)
+{
+}
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-trapa.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-trapa.c
new file mode 100644
index 000000000..47caf2112
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr-trapa.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target { { sh-*-* sh[1234ble]*-*-* } && nonpic } } } */
+/* { dg-options "-O" } */
+extern void foo ();
+
+void
+(__attribute__ ((trapa_handler)) isr) ()
+{
+  foo ();
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
+/* No interrupt-specific saves should be needed.  /
+/* { dg-final { scan-assembler-not "\[^f\]r\[0-7\]\[ \t,\]\[^\n\]*r15" } } */
+/* { dg-final { scan-assembler-not "@r15\[^\n\]*\[^f\]r\[0-7\]\n" } } */
+/* { dg-final { scan-assembler-not "\[^f\]r\[8-9\]" } } */
+/* { dg-final { scan-assembler-not "\[^f\]r1\[,0-3\]" } } */
+/* { dg-final { scan-assembler-not "macl" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr.c
new file mode 100644
index 000000000..3e8663173
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-isr.c
@@ -0,0 +1,19 @@
+/* { dg-do compile { target { { sh-*-* sh[1234ble]*-*-* } && nonpic } } } */
+/* { dg-options "-O" } */
+extern void foo ();
+
+void
+(__attribute ((interrupt_handler)) isr)()
+{
+  foo ();
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
+/* The call will clobber r0..r7, which will need not be saved/restored.
+   One of these registers will do fine to hold the function address,
+   hence the all-saved registers r8..r13 don't need to be restored.  */
+/* { dg-final { scan-assembler-times "r15\[+\],\[ \t\]*r\[0-9\]\[ \t\]*\n" 8 } } */
+/* { dg-final { scan-assembler-times "\[^f\]r\[0-9\]\[ \t\]*," 8 } } */
+/* { dg-final { scan-assembler-not "\[^f\]r1\[0-3\]" } } */
+/* { dg-final { scan-assembler-times "macl" 2} } */
+/* { dg-final { scan-assembler-not "rte.*\n.*r15\[+\],r\[0-7\]\n" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-may-alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-may-alias-1.c
new file mode 100644
index 000000000..30e2bca6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-may-alias-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler "dont_delete" } } */
+
+typedef struct { int x; } __attribute__((may_alias)) S;
+
+extern void dont_delete (void);
+
+void f(S *s, float *f)
+{
+  s->x = 1;
+  *f = 0;
+  if (s->x != 1)
+    dont_delete ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-mode-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-mode-1.c
new file mode 100644
index 000000000..e60d01b33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-mode-1.c
@@ -0,0 +1,13 @@
+/* PR c/17384 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef struct __attribute__((mode(SI))) { 
+    unsigned    INT0    :1, 
+                RES0    :1, 
+                        :6, 
+                INT1    :1, 
+                RES1    :1, 
+                        :6, 
+                        :16; 
+} MCR;  /* { dg-error "inappropriate type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-mode-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-mode-2.c
new file mode 100644
index 000000000..1a025212e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-mode-2.c
@@ -0,0 +1,22 @@
+/* PR c/18282 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int tword __attribute__((mode(word)));
+
+typedef enum { B1 = 1 } B;
+typedef enum { C1 = 1 } C __attribute__ ((mode(QI)));
+typedef enum { D1 = 1 } __attribute__ ((mode(word))) D;
+
+B __attribute__ ((mode (QI))) bqi;
+B __attribute__ ((mode (word))) bword;
+
+int sqi[sizeof (bqi) == 1 ? 1 : -1];
+int sword[sizeof (bword) == sizeof(tword) ? 1 : -1];
+int sc[sizeof (C) == 1 ? 1 : -1];
+int sd[sizeof (D) == sizeof(tword) ? 1 : -1];
+
+int aqi[__alignof (bqi) == 1 ? 1 : -1];
+int aword[__alignof (bword) == __alignof(tword) ? 1 : -1];
+int ac[__alignof (C) == 1 ? 1 : -1];
+int ad[__alignof (D) == __alignof(tword) ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-1.c
new file mode 100644
index 000000000..4cbff013f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-1.c
@@ -0,0 +1,165 @@
+/* Test for MS structure sizes.  */
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort ();
+
+#define ATTR __attribute__((__ms_struct__))
+
+#define size_struct_0 1
+#define size_struct_1 4
+#define size_struct_2 24
+#define size_struct_3 8
+#define size_struct_4 32
+#define size_struct_5 12
+#define size_struct_6 40
+#define size_struct_7 8
+#define size_struct_8 20
+#define size_struct_9 32
+
+struct _struct_0
+{
+  char member_0;
+} ATTR;
+typedef struct _struct_0 struct_0;
+
+struct _struct_1
+{
+  char member_0;
+  short member_1:13;
+} ATTR;
+typedef struct _struct_1 struct_1;
+
+struct _struct_2
+{
+  double member_0;
+  unsigned char member_1:8;
+  long member_2:32;
+  unsigned char member_3:5;
+  short member_4:14;
+  short member_5:13;
+  unsigned char:0;
+} ATTR;
+typedef struct _struct_2 struct_2;
+
+struct _struct_3
+{
+  unsigned long member_0:26;
+  unsigned char member_1:2;
+
+} ATTR;
+typedef struct _struct_3 struct_3;
+
+struct _struct_4
+{
+  unsigned char member_0:7;
+  double member_1;
+  double member_2;
+  short member_3:5;
+  char member_4:2;
+
+} ATTR;
+typedef struct _struct_4 struct_4;
+
+struct _struct_5
+{
+  unsigned short member_0:12;
+  long member_1:1;
+  unsigned short member_2:6;
+
+} ATTR;
+typedef struct _struct_5 struct_5;
+
+struct _struct_6
+{
+  unsigned char member_0:7;
+  unsigned long member_1:25;
+  char member_2:1;
+  double member_3;
+  short member_4:9;
+  double member_5;
+
+} ATTR;
+typedef struct _struct_6 struct_6;
+
+struct _struct_7
+{
+  double member_0;
+
+} ATTR;
+typedef struct _struct_7 struct_7;
+
+struct _struct_8
+{
+  unsigned char member_0:7;
+  long member_1:11;
+  long member_2:5;
+  long:0;
+  char member_4:8;
+  unsigned short member_5:4;
+  unsigned char member_6:3;
+  long member_7:23;
+
+} ATTR;
+typedef struct _struct_8 struct_8;
+
+struct _struct_9
+{
+  double member_0;
+  unsigned long member_1:6;
+  long member_2:17;
+  double member_3;
+  unsigned long member_4:22;
+
+} ATTR;
+typedef struct _struct_9 struct_9;
+
+struct_0 test_struct_0 = { 123 };
+struct_1 test_struct_1 = { 82, 1081 };
+struct_2 test_struct_2 = { 20.0, 31, 407760, 1, 14916, 6712 };
+struct_3 test_struct_3 = { 64616999, 1 };
+struct_4 test_struct_4 = { 61, 20.0, 20.0, 12, 0 };
+struct_5 test_struct_5 = { 909, 1, 57 };
+struct_6 test_struct_6 = { 12, 21355796, 0, 20.0, 467, 20.0 };
+struct_7 test_struct_7 = { 20.0 };
+struct_8 test_struct_8 = { 126, 1821, 22, 125, 6, 0, 2432638 };
+struct_9 test_struct_9 = { 20.0, 3, 23957, 20.0, 1001631 };
+
+
+int
+main (void)
+{
+
+  if (size_struct_0 != sizeof (struct_0))
+    abort ();
+
+  if (size_struct_1 != sizeof (struct_1))
+    abort ();
+
+  if (size_struct_2 != sizeof (struct_2))
+    abort ();
+
+  if (size_struct_3 != sizeof (struct_3))
+    abort ();
+
+  if (size_struct_4 != sizeof (struct_4))
+    abort ();
+
+  if (size_struct_5 != sizeof (struct_5))
+    abort ();
+
+  if (size_struct_6 != sizeof (struct_6))
+    abort ();
+
+  if (size_struct_7 != sizeof (struct_7))
+    abort ();
+
+  if (size_struct_8 != sizeof (struct_8))
+    abort ();
+
+  if (size_struct_9 != sizeof (struct_9))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-2.c
new file mode 100644
index 000000000..58804525b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-2.c
@@ -0,0 +1,36 @@
+/* Test for MS structure sizes.  */
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort ();
+
+#define ATTR __attribute__((__ms_struct__))
+
+struct _struct_0
+{
+  long  member_0   : 25 ;
+  short  member_1   : 6 ;
+  char  member_2   : 2 ;
+  unsigned  short  member_3   : 1 ;
+  unsigned  char  member_4   : 7 ;
+  short  member_5   : 16 ;
+  long  : 0 ;
+  char  member_7  ;
+
+} ATTR;
+typedef struct _struct_0 struct_0;
+
+#define size_struct_0 20
+
+struct_0 test_struct_0 = { 18557917, 17, 3, 0, 80, 6487, 93 };
+
+int
+main (void)
+{
+
+  if (size_struct_0 != sizeof (struct_0))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-packed1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-packed1.c
new file mode 100644
index 000000000..d885c6ff3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-ms_struct-packed1.c
@@ -0,0 +1,25 @@
+/* Test for MS structure with packed attribute.  */
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } }
+/* { dg-options "-std=gnu99" } */
+
+extern void abort ();
+
+union u
+{
+  int a;
+} __attribute__((__ms_struct__, __packed__));
+
+struct s
+{
+  char c;
+  union u u;
+};
+
+int
+main (void)
+{
+  if (sizeof (struct s) != (sizeof (char) + sizeof (union u))) 
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-nest.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-nest.c
new file mode 100644
index 000000000..16a79c6e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-nest.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+#define ATTR_PRINTF __attribute__ ((format (printf, 1, 2)))
+#define ATTR_USED __attribute__ ((used))
+
+void bar (int, ...);
+
+/* gcc would segfault on the nested attribute.  */
+void foo (void)
+{
+  bar (0, (void (*ATTR_PRINTF) (const char *, ...)) 0);
+}
+
+/* For consistency, unnamed decls should give the same warnings as
+   named ones.  */
+void proto1 (int (*ATTR_USED) (void)); /* { dg-warning "attribute ignored" } */
+void proto2 (int (*ATTR_USED bar) (void)); /* { dg-warning "attribute ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-noinline.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-noinline.c
new file mode 100644
index 000000000..9f7abcd07
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-noinline.c
@@ -0,0 +1,66 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -finline-functions" } */
+
+static inline void __attribute__((__noinline__)) function_definition(void) {} /* { dg-warning "inline function \[^\n\]* given attribute noinline" "" } */
+
+static inline void __attribute__((__noinline__)) function_declaration_both_before(void); /* { dg-warning "inline function \[^\n\]* given attribute noinline" "" } */
+
+static void function_declaration_both_before(void) {}
+
+static void function_declaration_both_after(void);
+
+static inline void __attribute__((__noinline__)) function_declaration_both_after(void); /* { dg-warning "(inline function \[^\n\]* given attribute noinline|declared inline after its definition)" "" } */
+
+static void function_declaration_both_after(void) {}
+
+static void function_declaration_noinline_before(void) __attribute__((__noinline__)); /* { dg-message "note: previous declaration" "" } */
+
+static inline void function_declaration_noinline_before(void) {} /* { dg-warning "follows declaration with attribute noinline" "" } */
+
+static inline void function_declaration_noinline_after(void) {} /* { dg-message "note: previous definition" "" } */
+
+static void function_declaration_noinline_after(void) __attribute__((__noinline__)); /* { dg-warning "follows inline declaration" "" } */
+
+static inline void function_declaration_inline_before(void); /* { dg-message "note: previous declaration" "" } */
+
+static void __attribute__((__noinline__)) function_declaration_inline_before(void) {} /* { dg-warning "follows inline declaration" "" } */
+
+static inline void function_declaration_inline_noinline_before(void); /* { dg-message "note: previous declaration" "" } */
+
+static void function_declaration_inline_noinline_before(void) __attribute__((__noinline__)); /* { dg-warning "follows inline declaration" "" } */
+
+static void function_declaration_inline_noinline_before(void) {}
+
+static inline void function_declaration_inline_noinline_after(void);
+
+static void function_declaration_inline_noinline_after(void) {} /* { dg-message "note: previous definition" "" } */
+
+static void function_declaration_inline_noinline_after(void) __attribute__((__noinline__)); /* { dg-warning "follows inline declaration" "" } */
+
+static void function_declaration_noinline_inline_before(void) __attribute__((__noinline__)); /* { dg-message "note: previous declaration" "" } */
+
+static inline void function_declaration_noinline_inline_before(void); /* { dg-warning "follows declaration with attribute noinline" "" } */
+
+static void function_declaration_noinline_inline_before(void) {}
+
+void f () {
+  function_definition ();
+  function_declaration_both_before ();
+  function_declaration_both_after ();
+  function_declaration_noinline_before ();
+  function_declaration_noinline_after ();
+  function_declaration_inline_before ();
+  function_declaration_inline_noinline_before ();
+  function_declaration_inline_noinline_after ();
+  function_declaration_noinline_inline_before ();
+}
+
+/* { dg-final { scan-assembler "function_definition" } } */
+/* { dg-final { scan-assembler "function_declaration_both_before" } } */
+/* { dg-final { scan-assembler "function_declaration_both_after" } } */
+/* { dg-final { scan-assembler "function_declaration_noinline_before" } } */
+/* { dg-final { scan-assembler "function_declaration_noinline_after" } } */
+/* { dg-final { scan-assembler "function_declaration_inline_before" } } */
+/* { dg-final { scan-assembler "function_declaration_inline_noinline_before" } } */
+/* { dg-final { scan-assembler "function_declaration_inline_noinline_after" } } */
+/* { dg-final { scan-assembler "function_declaration_noinline_inline_before" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-used-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-used-2.c
new file mode 100644
index 000000000..f78b94b53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-used-2.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -O2" } */
+
+static int xyzzy __attribute__((__used__)) = 1; 
+
+void foo()
+{
+  int x __attribute__((__used__)); /* { dg-warning "attribute ignored|unused variable" } */
+}
+
+/* { dg-final { scan-assembler "xyzzy" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-used.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-used.c
new file mode 100644
index 000000000..ba7705aaa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-used.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+static void function_declaration_before(void) __attribute__((__used__));
+
+static void function_declaration_before(void) {}
+
+static void function_declaration_after(void) {}
+
+static void function_declaration_after(void) __attribute__((__used__));
+
+/* { dg-final { scan-assembler "function_declaration_before" } } */
+/* { dg-final { scan-assembler "function_declaration_after" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-warn-unused-result.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-warn-unused-result.c
new file mode 100644
index 000000000..0404ceceb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-warn-unused-result.c
@@ -0,0 +1,188 @@
+/* warn_unused_result attribute tests.  */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+#define WUR __attribute__((warn_unused_result))
+#define WURAI __attribute__((warn_unused_result, always_inline)) inline
+typedef WUR int (*fnt) (void);
+
+typedef struct { long i; } A;
+typedef struct { long i; long j; } B;
+typedef struct { char big[1024]; fnt fn; } C;
+
+WUR int check1 (void);
+WUR void check2 (void); /* { dg-warning "attribute ignored" } */
+int foo WUR;	  /* { dg-warning "only applies" } */
+int bar (void);
+extern WURAI int check3 (void) { return bar (); }
+WUR A check4 (void);
+WUR B check5 (void);
+WUR C check6 (void);
+A bar7 (void);
+B bar8 (void);
+C bar9 (void);
+extern WURAI A check7 (void) { return bar7 (); }
+extern WURAI B check8 (void) { return bar8 (); }
+extern WURAI C check9 (void) { return bar9 (); }
+/* This is useful for checking whether return value of statement
+   expressions (returning int in this case) is used.  */
+extern WURAI int check_int_result (int res) { return res; }
+#define GU(v) ({ int e = 0; (v) = bar (); if ((v) < 23) e = 14; e; })
+fnt fnptr;
+WUR int check10 (void);
+int baz (void);
+extern WURAI int check11 (void) { return baz (); }
+int k;
+
+void
+test (void)
+{
+  int i = 0, j;
+  const fnt pcheck1 = check1;
+  const fnt pcheck3 = check3;
+  A a;
+  B b;
+  C c;
+  if (check1 ())
+    return;
+  i += check1 ();
+  i += ({ check1 (); });
+  check1 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check1 ();	/* { dg-warning "ignoring return value of" } */
+  check1 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  check2 ();
+  (void) check2 ();
+  check2 (), bar ();
+  if (check3 ())
+    return;
+  i += check3 ();
+  i += ({ check3 (); });
+  check3 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check3 ();	/* { dg-warning "ignoring return value of" } */
+  check3 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  a = check4 ();
+  if (a.i)
+    return;
+  if (check4 ().i)
+    return;
+  if (({ check4 (); }).i)
+    return;
+  check4 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check4 ();	/* { dg-warning "ignoring return value of" } */
+  check4 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  b = check5 ();
+  if (b.i + b.j)
+    return;
+  if (check5 ().j)
+    return;
+  if (({ check5 (); }).j)
+    return;
+  check5 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check5 ();	/* { dg-warning "ignoring return value of" } */
+  check5 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  c = check6 ();
+  if (c.big[12] + c.big[29])
+    return;
+  if (check6 ().big[27])
+    return;
+  if (({ check6 (); }).big[0])
+    return;
+  check6 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check6 ();	/* { dg-warning "ignoring return value of" } */
+  check6 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  a = check7 ();
+  if (a.i)
+    return;
+  if (check7 ().i)
+    return;
+  if (({ check7 (); }).i)
+    return;
+  check7 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check7 ();	/* { dg-warning "ignoring return value of" } */
+  check7 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  b = check8 ();
+  if (b.i + b.j)
+    return;
+  if (check8 ().j)
+    return;
+  if (({ check8 (); }).j)
+    return;
+  check8 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check8 ();	/* { dg-warning "ignoring return value of" } */
+  check8 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  c = check9 ();
+  if (c.big[12] + c.big[29])
+    return;
+  if (check9 ().big[27])
+    return;
+  if (({ check9 (); }).big[0])
+    return;
+  check9 ();		/* { dg-warning "ignoring return value of" } */
+  (void) check9 ();	/* { dg-warning "ignoring return value of" } */
+  check9 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  if (check_int_result (GU (j)))
+    return;
+  i += check_int_result (GU (j));
+  i += ({ check_int_result (GU (j)); });
+  check_int_result (GU (j)); /* { dg-warning "ignoring return value of" } */
+  (void) check_int_result (GU (j)); /* { dg-warning "ignoring return value of" } */
+  check_int_result (GU (j)), bar (); /* { dg-warning "ignoring return value of" } */
+  if (fnptr ())
+    return;
+  i += fnptr ();
+  i += ({ fnptr (); });
+  fnptr ();		/* { dg-warning "ignoring return value of" } */
+  (void) fnptr ();	/* { dg-warning "ignoring return value of" } */
+  fnptr (), bar ();	/* { dg-warning "ignoring return value of" } */
+  fnptr = check1;
+  if (fnptr ())
+    return;
+  i += fnptr ();
+  i += ({ fnptr (); });
+  fnptr ();		/* { dg-warning "ignoring return value of" } */
+  (void) fnptr ();	/* { dg-warning "ignoring return value of" } */
+  fnptr (), bar ();	/* { dg-warning "ignoring return value of" } */
+  fnptr = check3;
+  if (fnptr ())
+    return;
+  i += fnptr ();
+  i += ({ fnptr (); });
+  fnptr ();		/* { dg-warning "ignoring return value of" } */
+  (void) fnptr ();	/* { dg-warning "ignoring return value of" } */
+  fnptr (), bar ();	/* { dg-warning "ignoring return value of" } */
+  if (bar9 ().fn ())
+    return;
+  i += bar9 ().fn ();
+  i += ({ bar9 ().fn (); });
+  bar9 ().fn ();	/* { dg-warning "ignoring return value of" } */
+  (void) bar9 ().fn ();	/* { dg-warning "ignoring return value of" } */
+  bar9 ().fn (), bar (); /* { dg-warning "ignoring return value of" } */
+  if ((k ? check1 : check10) ())
+    return;
+  i += (k ? check1 : check10) ();
+  i += ({ (k ? check1 : check10) (); });
+  (k ? check1 : check10) (); /* { dg-warning "ignoring return value of" } */
+  (void) (k ? check1 : check10) (); /* { dg-warning "ignoring return value of" } */
+  (k ? check1 : check10) (), bar (); /* { dg-warning "ignoring return value of" } */
+  if ((k ? check3 : check11) ())
+    return;
+  i += (k ? check3 : check11) ();
+  i += ({ (k ? check3 : check11) (); });
+  (k ? check3 : check11) (); /* { dg-warning "ignoring return value of" } */
+  (void) (k ? check3 : check11) (); /* { dg-warning "ignoring return value of" } */
+  (k ? check3 : check11) (), bar (); /* { dg-warning "ignoring return value of" } */
+  if (pcheck1 ())
+    return;
+  i += pcheck1 ();
+  i += ({ pcheck1 (); });
+  pcheck1 ();		/* { dg-warning "ignoring return value of" } */
+  (void) pcheck1 ();	/* { dg-warning "ignoring return value of" } */
+  pcheck1 (), bar ();	/* { dg-warning "ignoring return value of" } */
+  if (pcheck3 ())
+    return;
+  i += pcheck3 ();
+  i += ({ pcheck3 (); });
+  pcheck3 ();		/* { dg-warning "ignoring return value of" } */
+  (void) pcheck3 ();	/* { dg-warning "ignoring return value of" } */
+  pcheck3 (), bar ();	/* { dg-warning "ignoring return value of" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weak-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weak-1.c
new file mode 100644
index 000000000..014e37d4d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weak-1.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+
+__inline void foo(void) __attribute__((weak));  /* { dg-error "inline.*weak" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1-darwin.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1-darwin.c
new file mode 100644
index 000000000..c6835ed7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1-darwin.c
@@ -0,0 +1,223 @@
+// { dg-do run { target { *-*-darwin* } } }
+// { dg-require-weak "" }
+// { dg-options "-O2" }
+// { dg-options "-O2 -mmacosx-version-min=10.2" { target { powerpc-*-darwin* } } }
+// { dg-additional-sources "attr-weakref-1a.c attr-weakref-1b.c" }
+
+// Copyright 2005 Free Software Foundation, Inc.
+// Contributed by Alexandre Oliva <aoliva@redhat.com>
+
+// Torture test for weakrefs.  The first letter of an identifier
+// indicates whether/how it is defined; the second letter indicates
+// whether it is part of a variable or function test; the number that
+// follows is a test counter, and a letter that may follow enables
+// multiple identifiers within the same test (e.g., multiple weakrefs
+// or pointers to the same identifier).
+
+// Identifiers starting with W are weakrefs; those with p are
+// pointers; those with g are global definitions; those with l are
+// local definitions; those with w are expected to be weak undefined
+// in the symbol table; those with u are expected to be marked as
+// non-weak undefined in the symbol table.
+
+#include <stdlib.h>
+
+#define USED __attribute__((used))
+
+typedef int vtype;
+
+extern vtype wv1;
+static vtype Wv1a __attribute__((weakref ("wv1")));
+static vtype *pv1a USED = &Wv1a;
+
+vtype gv2;
+static vtype Wv2a __attribute__((weakref ("gv2")));
+static vtype *pv2a USED = &Wv2a;
+
+static vtype lv3;
+static vtype Wv3a __attribute__((weakref ("lv3")));
+static vtype *pv3a USED = &Wv3a;
+
+extern vtype uv4;
+static vtype Wv4a __attribute__((weakref ("uv4")));
+static vtype *pv4a USED = &Wv4a;
+static vtype *pv4 USED = &uv4;
+
+static vtype Wv5a __attribute__((weakref ("uv5")));
+static vtype *pv5a USED = &Wv5a;
+extern vtype uv5;
+static vtype *pv5 USED = &uv5;
+
+static vtype Wv6a __attribute__((weakref ("wv6")));
+static vtype *pv6a USED = &Wv6a;
+extern vtype wv6;
+
+static vtype Wv7a __attribute__((weakref ("uv7")));
+static vtype* USED fv7 (void) {
+  return &Wv7a;
+}
+extern vtype uv7;
+static vtype* USED fv7a (void) {
+  return &uv7;
+}
+
+extern vtype uv8;
+static vtype* USED fv8a (void) {
+  return &uv8;
+}
+static vtype Wv8a __attribute__((weakref ("uv8")));
+static vtype* USED fv8 (void) {
+  return &Wv8a;
+}
+
+extern vtype wv9 __attribute__((weak));
+static vtype Wv9a __attribute__((weakref ("wv9")));
+static vtype *pv9a USED = &Wv9a;
+
+static vtype Wv10a __attribute__((weakref ("Wv10b")));
+static vtype Wv10b __attribute__((weakref ("Wv10c")));
+static vtype Wv10c __attribute__((weakref ("Wv10d")));
+static vtype Wv10d __attribute__((weakref ("wv10")));
+extern vtype wv10;
+
+extern vtype wv11;
+static vtype Wv11d __attribute__((weakref ("wv11")));
+static vtype Wv11c __attribute__((weakref ("Wv11d")));
+static vtype Wv11b __attribute__((weakref ("Wv11c")));
+static vtype Wv11a __attribute__((weakref ("Wv11b")));
+
+static vtype Wv12 __attribute__((weakref ("wv12")));
+extern vtype wv12 __attribute__((weak));
+
+static vtype Wv13 __attribute__((weakref ("wv13")));
+extern vtype wv13 __attribute__((weak));
+
+static vtype Wv14a __attribute__((weakref ("wv14")));
+static vtype Wv14b __attribute__((weakref ("wv14")));
+extern vtype wv14 __attribute__((weak));
+
+typedef void ftype(void);
+
+extern ftype wf1;
+static ftype Wf1a __attribute__((weakref ("wf1")));
+static ftype *pf1a USED = &Wf1a;
+static ftype Wf1c __attribute__((weakref));
+extern ftype Wf1c __attribute__((alias ("wf1")));
+static ftype *pf1c USED = &Wf1c;
+
+void gf2(void) {}
+static ftype Wf2a __attribute__((weakref ("gf2")));
+static ftype *pf2a USED = &Wf2a;
+
+static void lf3(void) {}
+static ftype Wf3a __attribute__((weakref ("lf3")));
+static ftype *pf3a USED = &Wf3a;
+
+extern ftype uf4;
+static ftype Wf4a __attribute__((weakref ("uf4")));
+static ftype *pf4a USED = &Wf4a;
+static ftype *pf4 USED = &uf4;
+
+static ftype Wf5a __attribute__((weakref ("uf5")));
+static ftype *pf5a USED = &Wf5a;
+extern ftype uf5;
+static ftype *pf5 USED = &uf5;
+
+static ftype Wf6a __attribute__((weakref ("wf6")));
+static ftype *pf6a USED = &Wf6a;
+extern ftype wf6;
+
+static ftype Wf7a __attribute__((weakref ("uf7")));
+static ftype* USED ff7 (void) {
+  return &Wf7a;
+}
+extern ftype uf7;
+static ftype* USED ff7a (void) {
+  return &uf7;
+}
+
+extern ftype uf8;
+static ftype* USED ff8a (void) {
+  return &uf8;
+}
+static ftype Wf8a __attribute__((weakref ("uf8")));
+static ftype* USED ff8 (void) {
+  return &Wf8a;
+}
+
+extern ftype wf9 __attribute__((weak));
+static ftype Wf9a __attribute__((weakref ("wf9")));
+static ftype *pf9a USED = &Wf9a;
+
+static ftype Wf10a __attribute__((weakref ("Wf10b")));
+static ftype Wf10b __attribute__((weakref ("Wf10c")));
+static ftype Wf10c __attribute__((weakref ("Wf10d")));
+static ftype Wf10d __attribute__((weakref ("wf10")));
+extern ftype wf10;
+
+extern ftype wf11;
+static ftype Wf11d __attribute__((weakref ("wf11")));
+static ftype Wf11c __attribute__((weakref ("Wf11d")));
+static ftype Wf11b __attribute__((weakref ("Wf11c")));
+static ftype Wf11a __attribute__((weakref ("Wf11b")));
+
+static ftype Wf12 __attribute__((weakref ("wf12")));
+extern ftype wf12 __attribute__((weak));
+
+static ftype Wf13 __attribute__((weakref ("wf13")));
+extern ftype wf13 __attribute__((weak));
+
+static ftype Wf14a __attribute__((weakref ("wf14")));
+static ftype Wf14b __attribute__((weakref ("wf14")));
+extern ftype wf14 __attribute__((weak));
+
+#ifndef __APPLE__
+#define chk(p) do { if (!p) abort (); } while (0)
+#else
+#define chk(p) /* */
+#endif
+
+int main () {
+  chk (!pv1a);
+  chk (pv2a);
+  chk (pv3a);
+  chk (pv4a);
+  chk (pv4);
+  chk (pv5a);
+  chk (pv5);
+  chk (!pv6a);
+  chk (fv7 ());
+  chk (fv7a ());
+  chk (fv8 ());
+  chk (fv8a ());
+  chk (!pv9a);
+  chk (!&Wv10a);
+  chk (!&Wv11a);
+  chk (!&Wv12);
+  chk (!&wv12);
+  chk (!&wv13);
+  chk (!&Wv14a);
+
+  chk (!pf1a);
+  chk (!pf1c);
+  chk (pf2a);
+  chk (pf3a);
+  chk (pf4a);
+  chk (pf4);
+  chk (pf5a);
+  chk (pf5);
+  chk (!pf6a);
+  chk (ff7 ());
+  chk (ff7a ());
+  chk (ff8 ());
+  chk (ff8a ());
+  chk (!pf9a);
+  chk (!&Wf10a);
+  chk (!&Wf11a);
+  chk (!&Wf12);
+  chk (!&wf12);
+  chk (!&wf13);
+  chk (!&Wf14a);
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1.c
new file mode 100644
index 000000000..19a511b82
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1.c
@@ -0,0 +1,227 @@
+// { dg-do run }
+// { dg-require-weak "" }
+// On darwin, we use attr-weakref-1-darwin.c.
+// This test requires support for undefined weak symbols.  This support
+// is not available on hppa*-*-hpux*.  The test is skipped rather than
+// xfailed to suppress the warning that would otherwise arise.
+// { dg-skip-if "" { "*-*-darwin*" "hppa*-*-hpux*" } "*" { "" } }
+// { dg-options "-O2" }
+// { dg-additional-sources "attr-weakref-1a.c" }
+
+// Copyright 2005 Free Software Foundation, Inc.
+// Contributed by Alexandre Oliva <aoliva@redhat.com>
+
+// Torture test for weakrefs.  The first letter of an identifier
+// indicates whether/how it is defined; the second letter indicates
+// whether it is part of a variable or function test; the number that
+// follows is a test counter, and a letter that may follow enables
+// multiple identifiers within the same test (e.g., multiple weakrefs
+// or pointers to the same identifier).
+
+// Identifiers starting with W are weakrefs; those with p are
+// pointers; those with g are global definitions; those with l are
+// local definitions; those with w are expected to be weak undefined
+// in the symbol table; those with u are expected to be marked as
+// non-weak undefined in the symbol table.
+
+#include <stdlib.h>
+
+#define USED __attribute__((used))
+
+typedef int vtype;
+
+extern vtype wv1;
+static vtype Wv1a __attribute__((weakref ("wv1")));
+static vtype *pv1a USED = &Wv1a;
+
+vtype gv2;
+static vtype Wv2a __attribute__((weakref ("gv2")));
+static vtype *pv2a USED = &Wv2a;
+
+static vtype lv3;
+static vtype Wv3a __attribute__((weakref ("lv3")));
+static vtype *pv3a USED = &Wv3a;
+
+extern vtype uv4;
+static vtype Wv4a __attribute__((weakref ("uv4")));
+static vtype *pv4a USED = &Wv4a;
+static vtype *pv4 USED = &uv4;
+
+static vtype Wv5a __attribute__((weakref ("uv5")));
+static vtype *pv5a USED = &Wv5a;
+extern vtype uv5;
+static vtype *pv5 USED = &uv5;
+
+static vtype Wv6a __attribute__((weakref ("wv6")));
+static vtype *pv6a USED = &Wv6a;
+extern vtype wv6;
+
+static vtype Wv7a __attribute__((weakref ("uv7")));
+static vtype* USED fv7 (void) {
+  return &Wv7a;
+}
+extern vtype uv7;
+static vtype* USED fv7a (void) {
+  return &uv7;
+}
+
+extern vtype uv8;
+static vtype* USED fv8a (void) {
+  return &uv8;
+}
+static vtype Wv8a __attribute__((weakref ("uv8")));
+static vtype* USED fv8 (void) {
+  return &Wv8a;
+}
+
+extern vtype wv9 __attribute__((weak));
+static vtype Wv9a __attribute__((weakref ("wv9")));
+static vtype *pv9a USED = &Wv9a;
+
+static vtype Wv10a __attribute__((weakref ("Wv10b")));
+static vtype Wv10b __attribute__((weakref ("Wv10c")));
+static vtype Wv10c __attribute__((weakref ("Wv10d")));
+static vtype Wv10d __attribute__((weakref ("wv10")));
+extern vtype wv10;
+
+extern vtype wv11;
+static vtype Wv11d __attribute__((weakref ("wv11")));
+static vtype Wv11c __attribute__((weakref ("Wv11d")));
+static vtype Wv11b __attribute__((weakref ("Wv11c")));
+static vtype Wv11a __attribute__((weakref ("Wv11b")));
+
+static vtype Wv12 __attribute__((weakref ("wv12")));
+extern vtype wv12 __attribute__((weak));
+
+static vtype Wv13 __attribute__((weakref ("wv13")));
+extern vtype wv13 __attribute__((weak));
+
+static vtype Wv14a __attribute__((weakref ("wv14")));
+static vtype Wv14b __attribute__((weakref ("wv14")));
+extern vtype wv14 __attribute__((weak));
+
+typedef void ftype(void);
+
+extern ftype wf1;
+static ftype Wf1a __attribute__((weakref ("wf1")));
+static ftype *pf1a USED = &Wf1a;
+static ftype Wf1c __attribute__((weakref));
+extern ftype Wf1c __attribute__((alias ("wf1")));
+static ftype *pf1c USED = &Wf1c;
+
+void gf2(void) {}
+static ftype Wf2a __attribute__((weakref ("gf2")));
+static ftype *pf2a USED = &Wf2a;
+
+static void lf3(void) {}
+static ftype Wf3a __attribute__((weakref ("lf3")));
+static ftype *pf3a USED = &Wf3a;
+
+extern ftype uf4;
+static ftype Wf4a __attribute__((weakref ("uf4")));
+static ftype *pf4a USED = &Wf4a;
+static ftype *pf4 USED = &uf4;
+
+static ftype Wf5a __attribute__((weakref ("uf5")));
+static ftype *pf5a USED = &Wf5a;
+extern ftype uf5;
+static ftype *pf5 USED = &uf5;
+
+static ftype Wf6a __attribute__((weakref ("wf6")));
+static ftype *pf6a USED = &Wf6a;
+extern ftype wf6;
+
+static ftype Wf7a __attribute__((weakref ("uf7")));
+static ftype* USED ff7 (void) {
+  return &Wf7a;
+}
+extern ftype uf7;
+static ftype* USED ff7a (void) {
+  return &uf7;
+}
+
+extern ftype uf8;
+static ftype* USED ff8a (void) {
+  return &uf8;
+}
+static ftype Wf8a __attribute__((weakref ("uf8")));
+static ftype* USED ff8 (void) {
+  return &Wf8a;
+}
+
+extern ftype wf9 __attribute__((weak));
+static ftype Wf9a __attribute__((weakref ("wf9")));
+static ftype *pf9a USED = &Wf9a;
+
+static ftype Wf10a __attribute__((weakref ("Wf10b")));
+static ftype Wf10b __attribute__((weakref ("Wf10c")));
+static ftype Wf10c __attribute__((weakref ("Wf10d")));
+static ftype Wf10d __attribute__((weakref ("wf10")));
+extern ftype wf10;
+
+extern ftype wf11;
+static ftype Wf11d __attribute__((weakref ("wf11")));
+static ftype Wf11c __attribute__((weakref ("Wf11d")));
+static ftype Wf11b __attribute__((weakref ("Wf11c")));
+static ftype Wf11a __attribute__((weakref ("Wf11b")));
+
+static ftype Wf12 __attribute__((weakref ("wf12")));
+extern ftype wf12 __attribute__((weak));
+
+static ftype Wf13 __attribute__((weakref ("wf13")));
+extern ftype wf13 __attribute__((weak));
+
+static ftype Wf14a __attribute__((weakref ("wf14")));
+static ftype Wf14b __attribute__((weakref ("wf14")));
+extern ftype wf14 __attribute__((weak));
+
+#ifndef __APPLE__
+#define chk(p) do { if (!p) abort (); } while (0)
+#else
+#define chk(p) /* */
+#endif
+
+int main () {
+  chk (!pv1a);
+  chk (pv2a);
+  chk (pv3a);
+  chk (pv4a);
+  chk (pv4);
+  chk (pv5a);
+  chk (pv5);
+  chk (!pv6a);
+  chk (fv7 ());
+  chk (fv7a ());
+  chk (fv8 ());
+  chk (fv8a ());
+  chk (!pv9a);
+  chk (!&Wv10a);
+  chk (!&Wv11a);
+  chk (!&Wv12);
+  chk (!&wv12);
+  chk (!&wv13);
+  chk (!&Wv14a);
+
+  chk (!pf1a);
+  chk (!pf1c);
+  chk (pf2a);
+  chk (pf3a);
+  chk (pf4a);
+  chk (pf4);
+  chk (pf5a);
+  chk (pf5);
+  chk (!pf6a);
+  chk (ff7 ());
+  chk (ff7a ());
+  chk (ff8 ());
+  chk (ff8a ());
+  chk (!pf9a);
+  chk (!&Wf10a);
+  chk (!&Wf11a);
+  chk (!&Wf12);
+  chk (!&wf12);
+  chk (!&wf13);
+  chk (!&Wf14a);
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1a.c
new file mode 100644
index 000000000..5ce1e4e72
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1a.c
@@ -0,0 +1,8 @@
+int uv4;
+int uv5;
+int uv7;
+int uv8;
+void uf4 (void) {}
+void uf5 (void) {}
+void uf7 (void) {}
+void uf8 (void) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1b.c
new file mode 100644
index 000000000..c2c43898c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-1b.c
@@ -0,0 +1,20 @@
+/* On Darwin, you have to have a definition of the function to link,
+   even if later on it won't be present in some dylib.  (That is,
+   you have to link with the latest version of the dylib.)  */
+void wf1(void) { }
+void wf6(void) { }
+void wf9(void) { }
+void wf10(void) { }
+void wf11(void) { }
+void wf12(void) { }
+void wf13(void) { }
+void wf14(void) { }
+
+int wv1;
+int wv6;
+int wv9;
+int wv10;
+int wv11;
+int wv12;
+int wv13;
+int wv14;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-2.c
new file mode 100644
index 000000000..75cc0779c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/attr-weakref-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+
+typedef int vtype;
+
+extern vtype wv1;
+extern vtype Wv1a __attribute__((weakref ("wv1"))); /* { dg-error "weakref 'Wv1a' must have static linkage" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/autopar.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/autopar.exp
new file mode 100644
index 000000000..d19e51f7f
--- /dev/null
+++ b/gcc-4.4.3/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
+# <http://www.gnu.org/licenses/>.
+
+# 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-4.4.3/gcc/testsuite/gcc.dg/autopar/parallelization-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/parallelization-1.c
new file mode 100644
index 000000000..ee62ff666
--- /dev/null
+++ b/gcc-4.4.3/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-final_cleanup" } */
+
+void abort (void);
+
+void parloop (int N)
+{
+  int i;
+  int x[10000000];
+
+  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(10000000);
+
+  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 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/pr39500-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/pr39500-1.c
new file mode 100644
index 000000000..161f31da6
--- /dev/null
+++ b/gcc-4.4.3/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[1000];
+
+  for (i = 0; i < 100; i++)
+    x[i] = x[i+100];
+
+  for (i = 0; i < 100; i++)
+    {
+      if (x[i] != x[i+100])
+       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-4.4.3/gcc/testsuite/gcc.dg/autopar/pr39500-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/pr39500-2.c
new file mode 100644
index 000000000..eabac3f88
--- /dev/null
+++ b/gcc-4.4.3/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-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1.c
new file mode 100644
index 000000000..ac08d3d2e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1.c
@@ -0,0 +1,58 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#define DIFF 242
+
+unsigned int ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned int uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* 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 ();
+}
+
+int main (void)
+{ 
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1char.c
new file mode 100644
index 000000000..228e97995
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1char.c
@@ -0,0 +1,53 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1short.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1short.c
new file mode 100644
index 000000000..45d96fdc9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-1short.c
@@ -0,0 +1,53 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2.c
new file mode 100644
index 000000000..684094d63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#define DIFF 240
+
+int b[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* 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 ();
+}
+
+int main (void)
+{ 
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 3 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 3 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2char.c
new file mode 100644
index 000000000..78e5b13ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2char.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2short.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2short.c
new file mode 100644
index 000000000..cef179b7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-2short.c
@@ -0,0 +1,52 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-3.c
new file mode 100644
index 000000000..97501c615
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-3.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+
+unsigned int ub[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned int uc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* 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;
+}
+
+int main (void)
+{ 
+  main1 (N, 240);
+  main1 (N-1, 210);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 1 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 1 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-6.c
new file mode 100644
index 000000000..b3a28a965
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-6.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define N 16
+#define DIFF 242
+
+__attribute__ ((noinline))
+int main1 (float x, float max_result)
+{
+  int i;
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  float diff = 2;
+  float max = x;
+  float min = 10;
+
+  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 != 0)
+    abort ();
+
+  return 0;
+}
+
+int main (void)
+{ 
+  main1 (100 ,100);
+  main1 (0, 15);
+  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" 0 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "FAILED: it is not a part of reduction" 3 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-7.c
new file mode 100644
index 000000000..90bbc9806
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-7.c
@@ -0,0 +1,82 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdlib.h>
+
+#define N 32
+
+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 const 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 const 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 const 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,
+  };
+
+  
+  testmin (A, 10, 1);
+  testmin (B, 0x7f, 0x70);
+  testmin (C, 0x7f, 0x09);
+
+  testmax (A, 0, 0x7f);
+  testmax (B, 0, 0x8f);
+  testmax (C, 0, 0xff);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-8.c
new file mode 100644
index 000000000..4801dc782
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-8.c
@@ -0,0 +1,80 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdlib.h>
+
+#define N 32
+
+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 const 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 const 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 const 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,
+  };
+
+  testmin (A, 0, 0);
+  testmin (B, 0, 0x80);
+  testmin (C, 0, 0x80);
+
+  testmax (A, 0, 0x7f);
+  testmax (B, 0, 0x7f);
+  testmax (C, 0, 0x77);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-9.c
new file mode 100644
index 000000000..68ed1de61
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/autopar/reduc-9.c
@@ -0,0 +1,80 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-parallelize-loops=4 -fdump-tree-parloops-details -fdump-tree-final_cleanup" } */
+
+#include <stdlib.h>
+
+#define N 32
+
+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 const 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 const 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 const 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,
+  };
+
+  testmin (A, 10, 1);
+  testmin (B, 0x7fff, 0x7000);
+  testmin (C, 0x7fff, 0x0009);
+
+  testmax (A, 0, 0x7fff);
+  testmax (B, 0, 0x800f);
+  testmax (C, 0, 0xffff);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Detected reduction" 2 "parloops" } } */
+/* { dg-final { scan-tree-dump-times "SUCCESS: may be parallelized" 2 "parloops" } } */
+/* { dg-final { cleanup-tree-dump "parloops" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bconstp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bconstp-1.c
new file mode 100644
index 000000000..36831a5d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bconstp-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+
+/* This test checks that builtin_constant_p can be used safely in
+   initializers for static data.  The macro X() defined below should
+   be an acceptable initializer expression no matter how complex its
+   argument is.  */
+
+extern int a;
+extern int b;
+
+extern int foo(void);
+extern int bar(void);
+
+#define X(exp) (__builtin_constant_p(exp) ? (exp) : -1)
+
+const short tests[] = {
+  X(0),
+  X(a),
+  X(0 && a),
+  X(a && b),
+  X(foo()),
+  X(0 && foo()),
+  X(a && foo()),
+  X(foo() && bar())
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-attrib.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-attrib.c
new file mode 100644
index 000000000..da4eb08d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-attrib.c
@@ -0,0 +1,40 @@
+/* bf-ms-attrib.c */
+/* Adapted from Donn Terry <donnte@microsoft.com> testcase
+   posted to GCC-patches
+   http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */ 
+
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* } } */
+
+/* We don't want the default "pedantic-errors" in this case, since we're
+   testing nonstandard stuff to begin with. */
+/* { dg-options "-ansi" } */
+
+extern void abort(void);
+
+struct one_gcc {
+  int d;
+  unsigned char a;
+  unsigned short b:7;
+  char c;	
+} __attribute__((__gcc_struct__)) ;
+
+
+struct one_ms {
+  int d;
+  unsigned char a;
+  unsigned short b:7;
+  char c;	
+} __attribute__((__ms_struct__));
+
+
+main() 
+  {
+    /* As long as the sizes are as expected, we know attributes are working.
+       bf-ms-layout.c makes sure the right thing happens when the attribute
+       is on. */
+    if (sizeof(struct one_ms) != 12)
+	abort();
+    if (sizeof(struct one_gcc) != 8)
+	abort();
+    return 0;
+  }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-layout-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-layout-2.c
new file mode 100644
index 000000000..0bd472bc1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-layout-2.c
@@ -0,0 +1,236 @@
+/* bf-ms-layout.c */
+
+/* Test for MS bitfield layout */
+/* Adapted from Donn Terry <donnte@microsoft.com> testcase
+   posted to GCC-patches
+   http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */
+
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */
+/* { dg-options "-D_TEST_MS_LAYOUT" } */
+/* This test uses the attribute instead of the command line option.  */
+
+#include <stddef.h>
+#include <string.h>
+
+extern void abort();
+
+#pragma pack(8)
+
+#ifdef __GNUC__
+#define ATTR __attribute__ ((ms_struct))
+#endif
+
+struct one {
+  int d;
+  unsigned char a;
+  unsigned short b:7;
+  char c;
+} ATTR;
+
+struct two {
+  int d;
+  unsigned char a;
+  unsigned int b:7;
+  char c;
+} ATTR;
+
+struct three {
+  short d;
+  unsigned short a:3;
+  unsigned short b:9;
+  unsigned char c:7;
+} ATTR;
+
+
+/* Bitfields of size 0 have some truly odd behaviors. */
+
+struct four {
+  unsigned short a:3;
+  unsigned short b:9;
+  unsigned int :0;  /* forces struct alignment to int */
+  unsigned char c:7;
+} ATTR;
+
+struct five {
+  char a;
+  int :0;        /* ignored; prior field is not a bitfield. */
+  char b;
+  char c;
+} ATTR;
+
+struct six {
+  char a :8;
+  int :0;	/* not ignored; prior field IS a bitfield, causes
+		   struct alignment as well. */
+  char b;
+  char c;
+} ATTR;
+
+struct seven {
+  char a:8;
+  char :0;
+  int  :0;	/* Ignored; prior field is zero size bitfield. */
+  char b;
+  char c;
+} ATTR;
+
+struct eight { /* ms size 4 */
+  short b:3;
+  char  c;
+} ATTR;
+
+#ifdef _MSC_VER
+#define LONGLONG __int64
+#else
+#define LONGLONG long long
+#endif
+
+union nine {   /* ms size 8 */
+  LONGLONG a:3;
+  char  c;
+} ATTR;
+
+struct ten {   /* ms size 16 */
+  LONGLONG a:3;
+  LONGLONG b:3;
+  char  c;
+} ATTR;
+
+
+#define val(s,f) (s.f)
+
+#define check_struct(_X) \
+{ \
+  if (sizeof (struct _X) != exp_sizeof_##_X )	\
+    abort();					\
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+     abort();					\
+}
+
+#define check_union(_X) \
+{ \
+  if (sizeof (union _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+     abort();					\
+}
+
+#define check_struct_size(_X) \
+{ \
+  if (sizeof (struct _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+}
+
+#define check_struct_off(_X) \
+{ \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+    abort();                                    \
+}
+
+#define check_union_size(_X) \
+{ \
+  if (sizeof (union _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+}
+
+#define check_union_off(_X) \
+{ \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+    abort();                                    \
+}
+
+int main(){
+
+  unsigned char filler[16];
+  struct one test_one;
+  struct two test_two;
+  struct three test_three;
+  struct four test_four;
+  struct five test_five;
+  struct six test_six;
+  struct seven test_seven;
+  struct eight test_eight;
+  union nine test_nine;
+  struct ten test_ten;
+
+#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER)
+  size_t exp_sizeof_one = 12;
+  size_t exp_sizeof_two = 16;
+  size_t exp_sizeof_three =6;
+  size_t exp_sizeof_four = 8;
+  size_t exp_sizeof_five = 3;
+  size_t exp_sizeof_six = 8;
+  size_t exp_sizeof_seven = 3;
+  size_t exp_sizeof_eight = 4;
+  size_t exp_sizeof_nine = 8;
+  size_t exp_sizeof_ten = 16;
+
+  unsigned char exp_one_c = 8;
+  unsigned char exp_two_c  = 12;
+  unsigned char exp_three_c = 4;
+  unsigned char exp_four_c = 4;
+  char exp_five_c = 2;
+  char exp_six_c = 5;
+  char exp_seven_c = 2;
+  char exp_eight_c = 2;
+  char exp_nine_c = 0;
+  char exp_ten_c = 8;
+
+#else /* testing -mno-ms-bitfields */
+
+  size_t exp_sizeof_one = 8;
+  size_t exp_sizeof_two = 8;
+  size_t exp_sizeof_three = 6;
+  size_t exp_sizeof_four = 6;
+  size_t exp_sizeof_five = 6;
+  size_t exp_sizeof_six = 6;
+  size_t exp_sizeof_seven = 6;
+  size_t exp_sizeof_eight = 2;
+  size_t exp_sizeof_nine = 8;
+  size_t exp_sizeof_ten = 8;
+
+  unsigned short exp_one_c = 6;
+  unsigned int exp_two_c  = 6;
+  unsigned char exp_three_c = 64;
+  unsigned char exp_four_c = 4;
+  char exp_five_c = 5;
+  char exp_six_c = 5;
+  char exp_seven_c = 5;
+  char exp_eight_c = 1;
+  char exp_nine_c = 0;
+  char exp_ten_c = 1;
+
+#endif
+
+  unsigned char i;
+  for ( i = 0; i < 16; i++ )
+    filler[i] = i;
+
+  check_struct_off (one);
+  check_struct_off (two);
+  check_struct_off (three);
+  check_struct_off (four);
+  check_struct_off (five);
+  check_struct_off (six);
+  check_struct_off (seven);
+  check_struct_off (eight);
+  check_union_off (nine);
+  check_struct_off (ten);
+
+  check_struct_size (one);
+  check_struct_size (two);
+  check_struct_size (three);
+  check_struct_size (four);
+  check_struct_size (five);
+  check_struct_size (six);
+  check_struct_size (seven);
+  check_struct_size (eight);
+  check_union_size (nine);
+  check_struct_size (ten);
+
+  return 0;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-layout.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-layout.c
new file mode 100644
index 000000000..3acd1e4a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-ms-layout.c
@@ -0,0 +1,231 @@
+/* bf-ms-layout.c */
+
+/* Test for MS bitfield layout */
+/* Adapted from Donn Terry <donnte@microsoft.com> testcase
+   posted to GCC-patches
+   http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */
+
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */
+/* { dg-options "-mms-bitfields -D_TEST_MS_LAYOUT" } */
+
+#include <stddef.h>
+#include <string.h>
+
+extern void abort();
+
+#pragma pack(8)
+
+struct one {
+  int d;
+  unsigned char a;
+  unsigned short b:7;
+  char c;
+} ;
+
+struct two {
+  int d;
+  unsigned char a;
+  unsigned int b:7;
+  char c;
+} ;
+
+struct three {
+  short d;
+  unsigned short a:3;
+  unsigned short b:9;
+  unsigned char c:7;
+} ;
+
+
+/* Bitfields of size 0 have some truly odd behaviors. */
+
+struct four {
+  unsigned short a:3;
+  unsigned short b:9;
+  unsigned int :0;  /* forces struct alignment to int */
+  unsigned char c:7;
+} ;
+
+struct five {
+  char a;
+  int :0;        /* ignored; prior field is not a bitfield. */
+  char b;
+  char c;
+} ;
+
+struct six {
+  char a :8;
+  int :0;	/* not ignored; prior field IS a bitfield, causes
+		   struct alignment as well. */
+  char b;
+  char c;
+} ;
+
+struct seven {
+  char a:8;
+  char :0;
+  int  :0;	/* Ignored; prior field is zero size bitfield. */
+  char b;
+  char c;
+} ;
+
+struct eight { /* ms size 4 */
+  short b:3;
+  char  c;
+} ;
+
+#ifdef _MSC_VER
+#define LONGLONG __int64
+#else
+#define LONGLONG long long
+#endif
+
+union nine {   /* ms size 8 */
+  LONGLONG a:3;
+  char  c;
+} ;
+
+struct ten {   /* ms size 16 */
+  LONGLONG a:3;
+  LONGLONG b:3;
+  char  c;
+} ;
+
+
+#define val(s,f) (s.f)
+
+#define check_struct(_X) \
+{ \
+  if (sizeof (struct _X) != exp_sizeof_##_X )	\
+    abort();					\
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+     abort();					\
+}
+
+#define check_union(_X) \
+{ \
+  if (sizeof (union _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+     abort();					\
+}
+
+#define check_struct_size(_X) \
+{ \
+  if (sizeof (struct _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+}
+
+#define check_struct_off(_X) \
+{ \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+    abort();                                    \
+}
+
+#define check_union_size(_X) \
+{ \
+  if (sizeof (union _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+}
+
+#define check_union_off(_X) \
+{ \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+    abort();                                    \
+}
+
+int main(){
+
+  unsigned char filler[16];
+  struct one test_one;
+  struct two test_two;
+  struct three test_three;
+  struct four test_four;
+  struct five test_five;
+  struct six test_six;
+  struct seven test_seven;
+  struct eight test_eight;
+  union nine test_nine;
+  struct ten test_ten;
+
+#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER)
+  size_t exp_sizeof_one = 12;
+  size_t exp_sizeof_two = 16;
+  size_t exp_sizeof_three =6;
+  size_t exp_sizeof_four = 8;
+  size_t exp_sizeof_five = 3;
+  size_t exp_sizeof_six = 8;
+  size_t exp_sizeof_seven = 3;
+  size_t exp_sizeof_eight = 4;
+  size_t exp_sizeof_nine = 8;
+  size_t exp_sizeof_ten = 16;
+
+  unsigned char exp_one_c = 8;
+  unsigned char exp_two_c  = 12;
+  unsigned char exp_three_c = 4;
+  unsigned char exp_four_c = 4;
+  char exp_five_c = 2;
+  char exp_six_c = 5;
+  char exp_seven_c = 2;
+  char exp_eight_c = 2;
+  char exp_nine_c = 0;
+  char exp_ten_c = 8;
+
+#else /* testing -mno-ms-bitfields */
+
+  size_t exp_sizeof_one = 8;
+  size_t exp_sizeof_two = 8;
+  size_t exp_sizeof_three = 6;
+  size_t exp_sizeof_four = 6;
+  size_t exp_sizeof_five = 6;
+  size_t exp_sizeof_six = 6;
+  size_t exp_sizeof_seven = 6;
+  size_t exp_sizeof_eight = 2;
+  size_t exp_sizeof_nine = 8;
+  size_t exp_sizeof_ten = 8;
+
+  unsigned short exp_one_c = 6;
+  unsigned int exp_two_c  = 6;
+  unsigned char exp_three_c = 64;
+  unsigned char exp_four_c = 4;
+  char exp_five_c = 5;
+  char exp_six_c = 5;
+  char exp_seven_c = 5;
+  char exp_eight_c = 1;
+  char exp_nine_c = 0;
+  char exp_ten_c = 1;
+
+#endif
+
+  unsigned char i;
+  for ( i = 0; i < 16; i++ )
+    filler[i] = i;
+
+  check_struct_off (one);
+  check_struct_off (two);
+  check_struct_off (three);
+  check_struct_off (four);
+  check_struct_off (five);
+  check_struct_off (six);
+  check_struct_off (seven);
+  check_struct_off (eight);
+  check_union_off (nine);
+  check_struct_off (ten);
+
+  check_struct_size (one);
+  check_struct_size (two);
+  check_struct_size (three);
+  check_struct_size (four);
+  check_struct_size (five);
+  check_struct_size (six);
+  check_struct_size (seven);
+  check_struct_size (eight);
+  check_union_size (nine);
+  check_struct_size (ten);
+
+  return 0;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-no-ms-layout.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-no-ms-layout.c
new file mode 100644
index 000000000..7e5532182
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-no-ms-layout.c
@@ -0,0 +1,231 @@
+/* bf-no-ms-layout.c */
+
+/* Test for gcc bitfield layout, with -mno-ms-bitfields */
+/* Adapted from Donn Terry <donnte@microsoft.com> testcase
+   posted to GCC-patches
+   http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */
+
+/* { dg-do run { target *-*-interix* *-*-mingw* *-*-cygwin* i?86-*-darwin } } */
+/* { dg-options "-mno-ms-bitfields" } */
+
+#include <stddef.h>
+#include <string.h>
+
+extern void abort();
+
+#pragma pack(8)
+
+struct one {
+  int d;
+  unsigned char a;
+  unsigned short b:7;
+  char c;
+};
+
+struct two {
+  int d;
+  unsigned char a;
+  unsigned int b:7;
+  char c;
+};
+
+struct three {
+  short d;
+  unsigned short a:3;
+  unsigned short b:9;
+  unsigned char c:7;
+};
+
+
+/* Bitfields of size 0 have some truly odd behaviors. */
+
+struct four {
+  unsigned short a:3;
+  unsigned short b:9;
+  unsigned int :0;  /* forces struct alignment to int */
+  unsigned char c:7;
+};
+
+struct five {
+  char a;
+  int :0;        /* ignored; prior field is not a bitfield. */
+  char b;
+  char c;
+};
+
+struct six {
+  char a :8;
+  int :0;	/* not ignored; prior field IS a bitfield, causes
+		   struct alignment as well. */
+  char b;
+  char c;
+} ;
+
+struct seven {
+  char a:8;
+  char :0;
+  int  :0;	/* Ignored; prior field is zero size bitfield. */
+  char b;
+  char c;
+};
+
+struct eight { /* ms size 4 */
+  short b:3;
+  char  c;
+};
+
+#ifdef _MSC_VER
+#define LONGLONG __int64
+#else
+#define LONGLONG long long
+#endif
+
+union nine {   /* ms size 8 */
+  LONGLONG a:3;
+  char  c;
+};
+
+struct ten {   /* ms size 16 */
+  LONGLONG a:3;
+  LONGLONG b:3;
+  char  c;
+};
+
+
+#define val(s,f) (s.f)
+
+#define check_struct(_X) \
+{ \
+  if (sizeof (struct _X) != exp_sizeof_##_X )	\
+    abort();					\
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+     abort();					\
+}
+
+#define check_union(_X) \
+{ \
+  if (sizeof (union _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+     abort();					\
+}
+
+#define check_struct_size(_X) \
+{ \
+  if (sizeof (struct _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+}
+
+#define check_struct_off(_X) \
+{ \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+    abort();                                    \
+}
+
+#define check_union_size(_X) \
+{ \
+  if (sizeof (union _X) != exp_sizeof_##_X )	\
+    abort();                                    \
+}
+
+#define check_union_off(_X) \
+{ \
+  memcpy(&test_##_X, filler, sizeof(test_##_X));\
+  if (val(test_##_X,c) != exp_##_X##_c) 	\
+    abort();                                    \
+}
+
+int main(){
+
+  unsigned char filler[16];
+  struct one test_one;
+  struct two test_two;
+  struct three test_three;
+  struct four test_four;
+  struct five test_five;
+  struct six test_six;
+  struct seven test_seven;
+  struct eight test_eight;
+  union nine test_nine;
+  struct ten test_ten;
+
+#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER)
+  size_t exp_sizeof_one = 12;
+  size_t exp_sizeof_two = 16;
+  size_t exp_sizeof_three =6;
+  size_t exp_sizeof_four = 8;
+  size_t exp_sizeof_five = 3;
+  size_t exp_sizeof_six = 8;
+  size_t exp_sizeof_seven = 3;
+  size_t exp_sizeof_eight = 4;
+  size_t exp_sizeof_nine = 8;
+  size_t exp_sizeof_ten = 16;
+
+  unsigned char exp_one_c = 8;
+  unsigned char exp_two_c  = 12;
+  unsigned char exp_three_c = 4;
+  unsigned char exp_four_c = 4;
+  char exp_five_c = 2;
+  char exp_six_c = 5;
+  char exp_seven_c = 2;
+  char exp_eight_c = 2;
+  char exp_nine_c = 0;
+  char exp_ten_c = 8;
+
+#else /* testing -mno-ms-bitfields */
+
+  size_t exp_sizeof_one = 8;
+  size_t exp_sizeof_two = 8;
+  size_t exp_sizeof_three = 6;
+  size_t exp_sizeof_four = 6;
+  size_t exp_sizeof_five = 6;
+  size_t exp_sizeof_six = 6;
+  size_t exp_sizeof_seven = 6;
+  size_t exp_sizeof_eight = 2;
+  size_t exp_sizeof_nine = 8;
+  size_t exp_sizeof_ten = 8;
+
+  unsigned short exp_one_c = 6;
+  unsigned int exp_two_c  = 6;
+  unsigned char exp_three_c = 64;
+  unsigned char exp_four_c = 4;
+  char exp_five_c = 5;
+  char exp_six_c = 5;
+  char exp_seven_c = 5;
+  char exp_eight_c = 1;
+  char exp_nine_c = 0;
+  char exp_ten_c = 1;
+
+#endif
+
+  unsigned char i;
+  for ( i = 0; i < 16; i++ )
+    filler[i] = i;
+
+  check_struct_off (one);
+  check_struct_off (two);
+  check_struct_off (three);
+  check_struct_off (four);
+  check_struct_off (five);
+  check_struct_off (six);
+  check_struct_off (seven);
+  check_struct_off (eight);
+  check_union_off (nine);
+  check_struct_off (ten);
+
+  check_struct_size (one);
+  check_struct_size (two);
+  check_struct_size (three);
+  check_struct_size (four);
+  check_struct_size (five);
+  check_struct_size (six);
+  check_struct_size (seven);
+  check_struct_size (eight);
+  check_union_size (nine);
+  check_struct_size (ten);
+
+  return 0;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-spl1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-spl1.c
new file mode 100644
index 000000000..b28130dac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bf-spl1.c
@@ -0,0 +1,59 @@
+/* { dg-do run { target m68k-*-* fido-*-* sparc-*-* } } */
+/* { dg-options { -O2 } } */
+
+extern void abort (void);
+
+typedef float SFtype __attribute__ ((mode (SF)));
+typedef float DFtype __attribute__ ((mode (DF)));
+
+typedef int HItype __attribute__ ((mode (HI)));
+typedef int SItype __attribute__ ((mode (SI)));
+typedef int DItype __attribute__ ((mode (DI)));
+
+typedef unsigned int UHItype __attribute__ ((mode (HI)));
+typedef unsigned int USItype __attribute__ ((mode (SI)));
+typedef unsigned int UDItype __attribute__ ((mode (DI)));
+
+typedef UDItype fractype;
+typedef USItype halffractype;
+typedef DFtype FLO_type;
+typedef DItype intfrac;
+
+
+typedef union
+{
+  long long foo;
+  FLO_type value;
+  struct
+    {
+      fractype fraction:52 __attribute__ ((packed));
+      unsigned int exp:11 __attribute__ ((packed));
+      unsigned int sign:1 __attribute__ ((packed));
+    }
+  bits;
+} FLO_union_type;
+
+void foo (long long a);
+long long x; 
+
+void
+pack_d ()
+{
+  FLO_union_type dst = { 0x0123456789abcdefLL };
+
+  x = dst.bits.fraction;
+}
+
+main ()
+{
+  pack_d ();
+  foo (x);
+  return 0;
+}
+
+void
+foo (long long a)
+{
+  if (a != 0x0123456789abcLL)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-1.c
new file mode 100644
index 000000000..b7cc5fd0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-1.c
@@ -0,0 +1,312 @@
+/* Test for binary integer constants.  */
+
+/* Derived from: c99-intconst-1.c, bye Joseph Myers <jsm28@cam.ac.uk>.  */
+/* Origin: Joerg Wunsch <j.gnu@uriah.heep.sax.de>.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+#include <limits.h>
+
+/* Assertion that constant C is of type T.  */
+#define ASSERT_CONST_TYPE(C, T)			\
+	do {					\
+	  typedef T type;			\
+	  typedef type **typepp;		\
+	  typedef __typeof__((C)) ctype;	\
+	  typedef ctype **ctypepp;		\
+	  typepp x = 0;				\
+	  ctypepp y = 0;			\
+	  x = y;				\
+	  y = x;				\
+	} while (0)
+
+/* (T *) if E is zero, (void *) otherwise.  */
+#define type_if_not(T, E) __typeof__(0 ? (T *)0 : (void *)(E))
+
+/* (T *) if E is nonzero, (void *) otherwise.  */
+#define type_if(T, E) type_if_not(T, !(E))
+
+/* Combine pointer types, all but one (void *).  */
+#define type_comb2(T1, T2) __typeof__(0 ? (T1)0 : (T2)0)
+#define type_comb3(T1, T2, T3) type_comb2(T1, type_comb2(T2, T3))
+#define type_comb4(T1, T2, T3, T4)				\
+	type_comb2(T1, type_comb2(T2, type_comb2(T3, T4)))
+#define type_comb6(T1, T2, T3, T4, T5, T6)				   \
+	type_comb2(T1,							   \
+		   type_comb2(T2,					   \
+			      type_comb2(T3,				   \
+					 type_comb2(T4,			   \
+						    type_comb2(T5, T6)))))
+
+/* (T1 *) if E1, otherwise (T2 *) if E2.  */
+#define first_of2p(T1, E1, T2, E2) type_comb2(type_if(T1, (E1)),	   \
+					     type_if(T2, (!(E1) && (E2))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3.  */
+#define first_of3p(T1, E1, T2, E2, T3, E3)			\
+	type_comb3(type_if(T1, (E1)),				\
+		   type_if(T2, (!(E1) && (E2))),		\
+		   type_if(T3, (!(E1) && !(E2) && (E3))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3, otherwise
+   (T4 *) if E4.  */
+#define first_of4p(T1, E1, T2, E2, T3, E3, T4, E4)			\
+	type_comb4(type_if(T1, (E1)),					\
+		   type_if(T2, (!(E1) && (E2))),			\
+		   type_if(T3, (!(E1) && !(E2) && (E3))),		\
+		   type_if(T4, (!(E1) && !(E2) && !(E3) && (E4))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3, otherwise
+   (T4 *) if E4, otherwise (T5 *) if E5, otherwise (T6 *) if E6.  */
+#define first_of6p(T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6)	    \
+	type_comb6(type_if(T1, (E1)),					    \
+		   type_if(T2, (!(E1) && (E2))),			    \
+		   type_if(T3, (!(E1) && !(E2) && (E3))),		    \
+		   type_if(T4, (!(E1) && !(E2) && !(E3) && (E4))),	    \
+		   type_if(T5, (!(E1) && !(E2) && !(E3) && !(E4) && (E5))), \
+		   type_if(T6, (!(E1) && !(E2) && !(E3)			    \
+				&& !(E4) && !(E5) && (E6))))
+
+/* Likewise, but return the original type rather than a pointer type.  */
+#define first_of2(T1, E1, T2, E2)			\
+	__typeof__(*((first_of2p(T1, (E1), T2, (E2)))0))
+#define first_of3(T1, E1, T2, E2, T3, E3)				\
+	__typeof__(*((first_of3p(T1, (E1), T2, (E2), T3, (E3)))0))
+#define first_of4(T1, E1, T2, E2, T3, E3, T4, E4)			    \
+	__typeof__(*((first_of4p(T1, (E1), T2, (E2), T3, (E3), T4, (E4)))0))
+#define first_of6(T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6)	\
+	__typeof__(*((first_of6p(T1, (E1), T2, (E2), T3, (E3),		\
+				 T4, (E4), T5, (E5), T6, (E6)))0))
+
+/* Types of constants according to the C99 rules.  */
+#define C99_UNSUF_TYPE(C)					\
+	first_of6(int, (C) <= INT_MAX,				\
+		  unsigned int, (C) <= UINT_MAX,		\
+		  long int, (C) <= LONG_MAX,			\
+		  unsigned long int, (C) <= ULONG_MAX,		\
+		  long long int, (C) <= LLONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFu_TYPE(C)					\
+	first_of3(unsigned int, (C) <= UINT_MAX,		\
+		  unsigned long int, (C) <= ULONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFl_TYPE(C)					\
+	first_of4(long int, (C) <= LONG_MAX,			\
+		  unsigned long int, (C) <= ULONG_MAX,		\
+		  long long int, (C) <= LLONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFul_TYPE(C)					\
+	first_of2(unsigned long int, (C) <= ULONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFll_TYPE(C)					\
+	first_of2(long long int, (C) <= LLONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+
+/* Checks that constants have correct type.  */
+#define CHECK_UNSUF_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C99_UNSUF_TYPE((C)))
+#define CHECK_SUFu_TYPE(C) ASSERT_CONST_TYPE((C), C99_SUFu_TYPE((C)))
+#define CHECK_SUFl_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C99_SUFl_TYPE((C)))
+#define CHECK_SUFul_TYPE(C) ASSERT_CONST_TYPE((C), C99_SUFul_TYPE((C)))
+#define CHECK_SUFll_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C99_SUFll_TYPE((C)))
+#define CHECK_SUFull_TYPE(C) ASSERT_CONST_TYPE((C), unsigned long long int)
+
+/* Check an octal or hexadecimal value, with all suffixes.  */
+#define CHECK_CONST(C)                  	\
+	CHECK_UNSUF_TYPE(C);                    \
+	CHECK_SUFu_TYPE(C##u);			\
+	CHECK_SUFu_TYPE(C##U);			\
+	CHECK_SUFl_TYPE(C##l);                  \
+	CHECK_SUFl_TYPE(C##L);                  \
+	CHECK_SUFul_TYPE(C##ul);		\
+	CHECK_SUFul_TYPE(C##uL);		\
+	CHECK_SUFul_TYPE(C##Ul);		\
+	CHECK_SUFul_TYPE(C##UL);		\
+	CHECK_SUFll_TYPE(C##ll);		\
+	CHECK_SUFll_TYPE(C##LL);		\
+	CHECK_SUFull_TYPE(C##ull);		\
+	CHECK_SUFull_TYPE(C##uLL);		\
+	CHECK_SUFull_TYPE(C##Ull);		\
+	CHECK_SUFull_TYPE(C##ULL);
+
+#define CHECK_BIN_CONST(C)			\
+	CHECK_CONST(0b##C);                     \
+	CHECK_CONST(0B##C);
+
+/* True iff "long long" is at least B bits.  This presumes that (B-2)/3 is at
+   most 63.  */
+#define LLONG_AT_LEAST(B)			\
+	(LLONG_MAX >> ((B)-2)/3 >> ((B)-2)/3	\
+	 >> ((B)-2 - ((B)-2)/3 - ((B)-2)/3))
+
+#define LLONG_HAS_BITS(B) (LLONG_AT_LEAST((B)) && !LLONG_AT_LEAST((B) + 1))
+
+#define FOO 0b1101
+#if !FOO
+# error "preprocessor does not accept binary constants"
+#endif
+
+void
+foo (void)
+{
+  /* Check all 2^n and 2^n - 1 up to 2^72 - 1.  */
+  CHECK_BIN_CONST(1);
+  CHECK_BIN_CONST(10);
+  CHECK_BIN_CONST(11);
+  CHECK_BIN_CONST(100);
+  CHECK_BIN_CONST(111);
+  CHECK_BIN_CONST(1000);
+  CHECK_BIN_CONST(1111);
+  CHECK_BIN_CONST(10000);
+  CHECK_BIN_CONST(11111);
+  CHECK_BIN_CONST(100000);
+  CHECK_BIN_CONST(111111);
+  CHECK_BIN_CONST(1000000);
+  CHECK_BIN_CONST(1111111);
+  CHECK_BIN_CONST(10000000);
+  CHECK_BIN_CONST(11111111);
+  CHECK_BIN_CONST(100000000);
+  CHECK_BIN_CONST(111111111);
+  CHECK_BIN_CONST(1000000000);
+  CHECK_BIN_CONST(1111111111);
+  CHECK_BIN_CONST(10000000000);
+  CHECK_BIN_CONST(11111111111);
+  CHECK_BIN_CONST(100000000000);
+  CHECK_BIN_CONST(111111111111);
+  CHECK_BIN_CONST(1000000000000);
+  CHECK_BIN_CONST(1111111111111);
+  CHECK_BIN_CONST(10000000000000);
+  CHECK_BIN_CONST(11111111111111);
+  CHECK_BIN_CONST(100000000000000);
+  CHECK_BIN_CONST(111111111111111);
+  CHECK_BIN_CONST(1000000000000000);
+  CHECK_BIN_CONST(1111111111111111);
+  CHECK_BIN_CONST(10000000000000000);
+  CHECK_BIN_CONST(11111111111111111);
+  CHECK_BIN_CONST(100000000000000000);
+  CHECK_BIN_CONST(111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111111111111);
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111111111111111);
+#if LLONG_AT_LEAST(65)
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(66)
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(67)
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(68)
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(69)
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(70)
+  CHECK_BIN_CONST(1000000000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(1111111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(71)
+  CHECK_BIN_CONST(10000000000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(11111111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+#if LLONG_AT_LEAST(72)
+  CHECK_BIN_CONST(100000000000000000000000000000000000000000000000000000000000000000000000);
+  CHECK_BIN_CONST(111111111111111111111111111111111111111111111111111111111111111111111111);
+#endif
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-2.c
new file mode 100644
index 000000000..40d763646
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-2.c
@@ -0,0 +1,16 @@
+/* Test for binary integer constants: -pedantic warnings.  */
+
+/* Origin: Joerg Wunsch <j.gnu@uriah.heep.sax.de>.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic" } */
+
+#define FOO 0b1101
+
+int
+foo (void)
+{
+#if FOO /* { dg-warning "binary constants are a GCC extension" } */
+  return 23;
+#endif
+  return 0b1101; /* { dg-warning "binary constants are a GCC extension" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-3.c
new file mode 100644
index 000000000..984477dca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-3.c
@@ -0,0 +1,16 @@
+/* Test for binary integer constants: -pedantic-errors.  */
+
+/* Origin: Joerg Wunsch <j.gnu@uriah.heep.sax.de>.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#define FOO 0b1101
+
+int
+foo (void)
+{
+#if FOO /* { dg-error "binary constants are a GCC extension" } */
+  return 23;
+#endif
+  return 0b1101; /* { dg-error "binary constants are a GCC extension" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-4.c
new file mode 100644
index 000000000..32c9d65a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/binary-constants-4.c
@@ -0,0 +1,18 @@
+/* Test for binary integer constants: random errors.  */
+
+/* Origin: Joerg Wunsch <j.gnu@uriah.heep.sax.de>.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void
+foo(void)
+{
+  double d;
+  int i;
+
+  d = 0b1101;
+  d = 0b1101p1; /* { dg-error "invalid suffix \"p1\" on integer constant" } */
+  d = 0x1101p1;
+  i = 0b3011;   /* { dg-error "invalid suffix \"b3011\" on integer constant" } */
+  i = 0b113;    /* { dg-error "invalid digit \"3\" in binary constant" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-1.c
new file mode 100644
index 000000000..fa835f229
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-1.c
@@ -0,0 +1,31 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.
+
+   Tests various diagnostics about a bit-field's type and width.
+
+   Source: Neil Booth, 26 Jan 2002.
+*/
+
+/* { dg-options -pedantic } */
+
+enum foo {e1 = 0, e2, e3, e4, e5};
+
+int x;
+typedef unsigned int ui;
+
+struct bf1
+{
+  unsigned int a: 3.5;		/* { dg-error "integer constant" } */
+  unsigned int b: x;		/* { dg-error "integer constant" } */
+  unsigned int c: -1;		/* { dg-error "negative width" } */
+  unsigned int d: 0;		/* { dg-error "zero width" } */
+  unsigned int : 0;		/* { dg-bogus "zero width" } */
+  unsigned int : 5;
+  double e: 1;			/* { dg-error "invalid type" } */
+  float f: 1;			/* { dg-error "invalid type" } */
+  unsigned long g: 5;		/* { dg-warning "GCC extension|ISO C" } */
+  ui h: 5;
+  enum foo i: 2;		/* { dg-warning "narrower" } */
+    /* { dg-warning "GCC extension|ISO C" "extension" { target *-*-* } 27 } */
+  enum foo j: 3;		/* { dg-warning "GCC extension|ISO C" } */
+  unsigned int k: 256;		/* { dg-error "exceeds its type" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-10.c
new file mode 100644
index 000000000..ce7223149
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-10.c
@@ -0,0 +1,8 @@
+/* Test for rejection of sizeof on bit-fields.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct { int a : 1; } x;
+
+int r = sizeof (x.a); /* { dg-error "'sizeof' applied to a bit-field" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-11.c
new file mode 100644
index 000000000..c7fe6a510
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-11.c
@@ -0,0 +1,8 @@
+/* Test for rejection of __alignof on bit-fields.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct { int a : 1; } x;
+
+int r = __alignof (x.a); /* { dg-error "'__alignof' applied to a bit-field" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-12.c
new file mode 100644
index 000000000..1270d9b34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-12.c
@@ -0,0 +1,12 @@
+/* Test for rejection of taking address of bit-fields.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+#include <stddef.h>
+
+struct s { int a : 1; } x, *y;
+
+int a = offsetof (struct s, a); /* { dg-error "attempt to take address of bit-field structure member 'a'" } */
+void *b = &x.a; /* { dg-error "cannot take address of bit-field 'a'" } */
+void *c = &y->a; /* { dg-error "cannot take address of bit-field 'a'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-13.c
new file mode 100644
index 000000000..fcb381c86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-13.c
@@ -0,0 +1,14 @@
+/* Test invalid bit-field types: bug 18498.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int
+main(void)
+{
+  struct X {
+    int s[20] : 1; /* { dg-error "bit-field 's' has invalid type" } */
+    int *p : 2; /* { dg-error "bit-field 'p' has invalid type" } */
+    int (*f)(float) : 3; /* { dg-error "bit-field 'f' has invalid type" } */
+  } x;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-14.c
new file mode 100644
index 000000000..de1971cd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-14.c
@@ -0,0 +1,11 @@
+/* Test for non-integer bit-field widths.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+enum e { E, F };
+struct s {
+  int a : (void *)4; /* { dg-error "bit-field 'a' width not an integer constant" } */
+  int b : (enum e)F;
+  int c : (_Bool)1;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-15.c
new file mode 100644
index 000000000..968290f06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-15.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* Remove pedantic.  Allow the GCC extension to use char for bitfields.  */
+/* { dg-options "" } */
+/* { dg-options "-mno-ms-bitfields" { target i?86-*-netware } } */
+
+struct t
+{
+  char a:4;
+  char b:8;
+  char c:4;
+} __attribute__ ((packed)); /* { dg-message "note: Offset of packed bit-field 'b' has changed in GCC 4.4" "" { target pcc_bitfield_type_matters } } */
+
+int assrt[sizeof (struct t) == 2 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-16.c
new file mode 100644
index 000000000..0a89bdab1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-16.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-Wno-packed-bitfield-compat" } */
+/* { dg-options "-Wno-packed-bitfield-compat -mno-ms-bitfields" { target i?86-*-netware } } */
+
+struct t
+{
+  char a:4;
+  char b:8;
+  char c:4;
+} __attribute__ ((packed));
+
+int assrt[sizeof (struct t) == 2 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-17.c
new file mode 100644
index 000000000..a0ad1ffee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-17.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+/* { dg-options "-mno-ms-bitfields" { target i?86-*-netware } } */
+
+struct t
+{
+  char a:4;
+  char b:8 __attribute__ ((packed));
+  char c:4;
+}; /* { dg-message "note: Offset of packed bit-field 'b' has changed in GCC 4.4" "" { target pcc_bitfield_type_matters } } */
+
+int assrt[sizeof (struct t) == 2 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-18.c
new file mode 100644
index 000000000..cb24c65d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-18.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-Wno-packed-bitfield-compat" } */
+/* { dg-options "-Wno-packed-bitfield-compat -mno-ms-bitfields" { target i?86-*-netware } } */
+
+struct t
+{
+  char a:4;
+  char b:8 __attribute__ ((packed));
+  char c:4;
+};
+
+int assrt[sizeof (struct t) == 2 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-19.c
new file mode 100644
index 000000000..072e93c2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-19.c
@@ -0,0 +1,11 @@
+/* Test for bit-field widths not integer constant expressions but
+   folding to integer constants: PR 42439.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void
+f (void)
+{
+  const int m = 1;
+  ((void)(sizeof(struct { int i:!!m; })));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-2.c
new file mode 100644
index 000000000..b61fec608
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-2.c
@@ -0,0 +1,23 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.
+
+   Tests we warn about overly-large assignments to bitfields.
+
+   Source: Neil Booth, 28 Jan 2002.
+*/
+
+struct bf
+{
+  unsigned int a: 2;
+  int b: 2;
+};
+
+struct bf p = {4, 0};		/* { dg-warning "truncated" "" } */
+struct bf q = {0, 2};		/* { dg-warning "overflow" "" } */
+struct bf r = {3, -2};		/* { dg-bogus "(truncated|overflow)" } */
+
+void foo ()
+{
+  p.a = 4, p.b = 0;		/* { dg-warning "truncated" "" } */
+  q.a = 0, q.b = 2;		/* { dg-warning "overflow" "" } */
+  r.a = 3, r.b = -2;		/* { dg-bogus "(truncated|overflow)" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-3.c
new file mode 100644
index 000000000..5207bedb8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-3.c
@@ -0,0 +1,67 @@
+/* Test for bitfield alignment in structs and unions.  */
+/* { dg-do run { target pcc_bitfield_type_matters } }  */
+/* { dg-options "-O2" }  */
+
+extern void abort (void);
+extern void exit (int);
+
+typedef long la __attribute__((aligned (8)));
+
+struct A
+{
+  char a;
+  union UA
+  {
+    char x;
+    la y : 6;
+  } b;
+  char c;
+} a;
+
+struct B
+{
+  char a;
+  union UB
+  {
+    char x;
+    long y : 6 __attribute__((aligned (8)));
+  } b;
+  char c;
+} b;
+
+struct C
+{
+  char a;
+  struct UC
+  {
+    la y : 6;
+  } b;
+  char c;
+} c;
+
+struct D
+{
+  char a;
+  struct UD
+  {
+    long y : 6 __attribute__((aligned (8)));
+  } b;
+  char c;
+} d;
+
+int main (void)
+{
+  if (sizeof (a) != sizeof (b))
+    abort ();
+  if (sizeof (a) != sizeof (c))
+    abort ();
+  if (sizeof (a) != sizeof (d))
+    abort ();
+  if ((&a.c - &a.a) != (&b.c - &b.a))
+    abort ();
+  if ((&a.c - &a.a) != (&c.c - &c.a))
+    abort ();
+  if ((&a.c - &a.a) != (&d.c - &d.a))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-4.c
new file mode 100644
index 000000000..e642bec5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-4.c
@@ -0,0 +1,42 @@
+/* { dg-do run { target { pcc_bitfield_type_matters || default_packed } } } */
+/* { dg-options "" } */
+
+/* Check bitfields and non-bitfields are aligned & sized similarly.
+
+   Copyright (C) 2002 Free Software Foundation Inc
+   Contributed by Nathan Sidwell <nathan@codesourcery.com>
+*/
+
+#include <limits.h>
+#include <stdio.h>
+
+static int fail;
+
+#define CHECK1(N, T) do { \
+  typedef struct Field_##N { char c; T f; } Field_##N; \
+  typedef struct BitField_##N { char c; T f : sizeof (T) * CHAR_BIT; } BitField_##N; \
+  if (sizeof (Field_##N) != sizeof (BitField_##N)) { \
+    fail = 1; printf ("sizeof %s failed\n", #T); \
+  } \
+  if (__alignof__ (Field_##N) != __alignof__ (BitField_##N)) { \
+    fail = 1; printf ("__alignof__ %s failed\n", #T); \
+  } \
+} while (0)
+
+#define CHECK(N, T) do { \
+  CHECK1(N, T); \
+  CHECK1 (s##N, signed T); \
+  CHECK1 (u##N, unsigned T); \
+} while (0)
+ 
+int main ()
+{
+  
+  CHECK (c, char);
+  CHECK (s, short);
+  CHECK (i, int);
+  CHECK (l, long);
+  CHECK (ll, long long);
+  
+  return fail;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-5.c
new file mode 100644
index 000000000..835bbce32
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-5.c
@@ -0,0 +1,12 @@
+/* { dg-options "" } */
+#include <limits.h>
+
+struct s
+{
+  int i1 : sizeof (int) * CHAR_BIT;
+  int i2 : sizeof (int) * CHAR_BIT;
+  int i3 : sizeof (int) * CHAR_BIT;
+  int i4 : sizeof (int) * CHAR_BIT;
+};
+
+int f[sizeof (struct s) != sizeof (int) * 4 ? -1 : 1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-6.c
new file mode 100644
index 000000000..a9a7f4099
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-6.c
@@ -0,0 +1,16 @@
+/* { dg-options "" } */
+#include <limits.h>
+
+struct s
+{
+  int i1 : sizeof (int) * CHAR_BIT;
+  int i2 : sizeof (int) * CHAR_BIT;
+  int i3 : sizeof (int) * CHAR_BIT;
+  int i4 : sizeof (int) * CHAR_BIT;
+  int i5 : sizeof (int) * CHAR_BIT;
+  int i6 : sizeof (int) * CHAR_BIT;
+  int i7 : sizeof (int) * CHAR_BIT;
+  int i8 : sizeof (int) * CHAR_BIT;
+};
+
+int f[sizeof (struct s) != sizeof (int) * 8 ? -1 : 1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-7.c
new file mode 100644
index 000000000..fdaa93f26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-7.c
@@ -0,0 +1,8 @@
+/* Test for rejection of typeof on bit-fields.  PR c/10333.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-fshow-column" } */
+
+struct { int a:1; } x;
+
+typeof (x.a) z; /* { dg-error "9:applied to a bit-field" "typeof" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-8.c
new file mode 100644
index 000000000..937fb64f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-8.c
@@ -0,0 +1,7 @@
+/* Test that too wide bit-fields are hard errors.  PR c/3347.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk>, from PR c/3347 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct { int i : 1999; } x; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "width" "bit-field too wide" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-9.c
new file mode 100644
index 000000000..d6ae0ac31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/bitfld-9.c
@@ -0,0 +1,119 @@
+/* Test -funsigned-bitfields works.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do run } */
+/* { dg-options "-funsigned-bitfields -fsigned-char" } */
+
+typedef char c;
+typedef signed char sc;
+typedef unsigned char uc;
+typedef short s;
+typedef signed short ss;
+typedef unsigned short us;
+typedef n;
+typedef int i;
+typedef signed int si;
+typedef unsigned int ui;
+typedef long l;
+typedef signed long sl;
+typedef unsigned long ul;
+typedef long long ll;
+typedef signed long long sll;
+typedef unsigned long long ull;
+
+typedef c ct;
+typedef sc sct;
+typedef uc uct;
+typedef s st;
+typedef ss sst;
+typedef us ust;
+typedef n nt;
+typedef i it;
+typedef si sit;
+typedef ui uit;
+typedef l lt;
+typedef sl slt;
+typedef ul ult;
+typedef ll llt;
+typedef sll sllt;
+typedef ull ullt;
+
+struct foo {
+  char char0 : 1;
+  c char1 : 1;
+  ct char2 : 1;
+  signed char schar0 : 1;
+  sc schar1 : 1;
+  sct schar2 : 1;
+  unsigned char uchar0 : 1;
+  uc uchar1 : 1;
+  uct uchar2 : 1;
+  short short0 : 1;
+  s short1 : 1;
+  st short2 : 1;
+  signed short sshort0 : 1;
+  ss sshort1 : 1;
+  sst sshort2 : 1;
+  unsigned short ushort0 : 1;
+  us ushort1 : 1;
+  ust ushort2 : 1;
+  __attribute__((dummy)) int0 : 1; /* { dg-warning "attribute directive ignored" } */
+  n int1 : 1;
+  nt int2 : 1;
+  int int3 : 1;
+  i int4 : 1;
+  it int5 : 1;
+  signed int sint0 : 1;
+  si sint1 : 1;
+  sit sint2 : 1;
+  unsigned int uint0 : 1;
+  ui uint1 : 1;
+  uit uint2 : 1;
+  long long0 : 1;
+  l long1 : 1;
+  lt long2 : 1;
+  signed long slong0 : 1;
+  sl slong1 : 1;
+  slt slong2 : 1;
+  unsigned long ulong0 : 1;
+  ul ulong1 : 1;
+  ult ulong2 : 1;
+  long long llong0 : 1;
+  ll llong1 : 1;
+  llt llong2 : 1;
+  signed long long sllong0 : 1;
+  sll sllong1 : 1;
+  sllt sllong2 : 1;
+  unsigned long long ullong0 : 1;
+  ull ullong1 : 1;
+  ullt ullong2 : 1;
+};
+
+struct foo x;
+
+extern void abort (void);
+extern void exit (int);
+extern void *memset (void *, int, __SIZE_TYPE__);
+
+int
+main (void)
+{
+  memset (&x, (unsigned char)-1, sizeof(x));
+  if (x.char0 != 1 || x.char1 != 1 || x.char2 != 1
+      || x.schar0 != -1 || x.schar1 != -1 || x.schar2 != -1
+      || x.uchar0 != 1 || x.uchar1 != 1 || x.uchar2 != 1
+      || x.short0 != 1 || x.short1 != 1 || x.short2 != 1
+      || x.sshort0 != -1 || x.sshort1 != -1 || x.sshort2 != -1
+      || x.ushort0 != 1 || x.ushort1 != 1 || x.ushort2 != 1
+      || x.int0 != 1 || x.int1 != 1 || x.int2 != 1
+      || x.int3 != 1 || x.int4 != 1 || x.int5 != 1
+      || x.sint0 != -1 || x.sint1 != -1 || x.sint2 != -1
+      || x.uint0 != 1 || x.uint1 != 1 || x.uint2 != 1
+      || x.long0 != 1 || x.long1 != 1 || x.long2 != 1
+      || x.slong0 != -1 || x.slong1 != -1 || x.slong2 != -1
+      || x.ulong0 != 1 || x.ulong1 != 1 || x.ulong2 != 1
+      || x.llong0 != 1 || x.llong1 != 1 || x.llong2 != 1
+      || x.sllong0 != -1 || x.sllong1 != -1 || x.sllong2 != -1
+      || x.ullong0 != 1 || x.ullong1 != 1 || x.ullong2 != 1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/boolcomplex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/boolcomplex-1.c
new file mode 100644
index 000000000..c34da04d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/boolcomplex-1.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+_Bool b = --0i == 0; /* { dg-error "lvalue required as decrement operand" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply1.c
new file mode 100644
index 000000000..38b384e7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply1.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.4.3/gcc/testsuite/gcc.dg/builtin-apply2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply2.c
new file mode 100644
index 000000000..bc49a6458
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply2.c
@@ -0,0 +1,32 @@
+/* { dg-do run } */
+/* { dg-skip-if "Variadic funcs have all args on stack. Normal funcs have args in registers." { "avr-*-*" } { "*" } { "" } } */
+
+/* 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).  */
+
+   
+
+#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-4.4.3/gcc/testsuite/gcc.dg/builtin-apply3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply3.c
new file mode 100644
index 000000000..1335d0902
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply3.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.4.3/gcc/testsuite/gcc.dg/builtin-apply4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply4.c
new file mode 100644
index 000000000..859b508f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-apply4.c
@@ -0,0 +1,31 @@
+/* PR tree-optimization/20076 */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mno-mmx" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { 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.4.3/gcc/testsuite/gcc.dg/builtin-bswap-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-1.c
new file mode 100644
index 000000000..6b4a80553
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target stdint_types } */
+/* { dg-options "" } */
+/* { dg-final { scan-assembler-not "__builtin_" } } */
+
+#include <stdint.h>
+
+uint32_t foo (uint32_t a)
+{
+  int b;
+
+  b = __builtin_bswap32 (a);
+
+  return b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-2.c
new file mode 100644
index 000000000..745fed9d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-2.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-require-effective-target stdint_types } */
+/* { dg-options "" } */
+#include <stdint.h>
+
+extern void abort (void);
+
+int main (void)
+{
+  uint32_t a = 4;
+  uint32_t b;
+
+  b = __builtin_bswap32 (a);
+  a = __builtin_bswap32 (b);
+
+  if (b == 4 || a != 4)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-3.c
new file mode 100644
index 000000000..031817e78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-3.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-require-effective-target stdint_types } */
+/* { dg-options "" } */
+#include <stdint.h>
+
+extern void abort (void);
+
+int main (void)
+{
+  uint32_t a = 0x80000000;
+  uint32_t b;
+
+  b = __builtin_bswap32 (a);
+  a = __builtin_bswap32 (b);
+
+  if (b != 0x80 || a != 0x80000000)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-4.c
new file mode 100644
index 000000000..03e190ad7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-4.c
@@ -0,0 +1,60 @@
+/* { dg-do run } */
+/* { dg-require-effective-target stdint_types } */
+/* { dg-options "-Wall" } */
+
+#include <stdint.h>
+
+#define MAKE_FUN(suffix, type)						\
+  type my_bswap##suffix(type x) {					\
+    type result = 0;							\
+    int shift;								\
+    for (shift = 0; shift < 8 * sizeof (type); shift += 8)	\
+      {									\
+	result <<= 8;							\
+	result |= (x >> shift) & 0xff;					\
+      }									\
+    return result;							\
+  }									\
+
+MAKE_FUN(32, uint32_t);
+MAKE_FUN(64, uint64_t);
+
+extern void abort (void);
+
+#define NUMS32					\
+  {						\
+    0x00000000UL,				\
+    0x11223344UL,				\
+    0xffffffffUL,				\
+  }
+
+#define NUMS64					\
+  {						\
+    0x0000000000000000ULL,			\
+    0x1122334455667788ULL,			\
+    0xffffffffffffffffULL,			\
+  }
+
+uint32_t uint32_ts[] =
+  NUMS32;
+
+uint64_t uint64_ts[] =
+  NUMS64;
+
+#define N(table) (sizeof (table) / sizeof (table[0]))
+
+int
+main (void)
+{
+  int i;
+
+  for (i = 0; i < N(uint32_ts); i++)
+    if (__builtin_bswap32 (uint32_ts[i]) != my_bswap32 (uint32_ts[i]))
+      abort ();
+
+  for (i = 0; i < N(uint64_ts); i++)
+    if (__builtin_bswap64 (uint64_ts[i]) != my_bswap64 (uint64_ts[i]))
+      abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-5.c
new file mode 100644
index 000000000..ccac96633
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-bswap-5.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+int
+main (void)
+{
+  /* Test constant folding.  */
+  extern void link_error (void);
+
+  if (__builtin_bswap32(0xaabbccdd) != 0xddccbbaa)
+    link_error ();
+
+  if (__builtin_bswap64(0x1122334455667788ULL) != 0x8877665544332211ULL)
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-choose-expr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-choose-expr-2.c
new file mode 100644
index 000000000..d986b405f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-choose-expr-2.c
@@ -0,0 +1,12 @@
+/* Test diagnostic for invalid use of __builtin_choose_expr.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int a, b, c, d;
+
+void
+f (void)
+{
+  a = __builtin_choose_expr (b, c, d); /* { dg-error "first argument to '__builtin_choose_expr' not a constant" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-choose-expr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-choose-expr.c
new file mode 100644
index 000000000..045dc6c41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-choose-expr.c
@@ -0,0 +1,88 @@
+/* { dg-do run } */
+/* { dg-options "-O1 -Wall" } */
+
+#define choose __builtin_choose_expr
+
+/* Check the type of __builtin_choose_expr between E1 and E2, both
+   ways round and with both 0 and 1 as the condition.  */
+#define ASSERT_COND_TYPE(E1, E2)				\
+        do {							\
+          typedef __typeof(E1) T1;				\
+          typedef __typeof(E2) T2;				\
+          typedef T1 **T1pp;					\
+          typedef T2 **T2pp;					\
+          typedef __typeof(choose (1, (E1), (E2))) T1a;		\
+          typedef __typeof(choose (0, (E2), (E1))) T1b;		\
+          typedef __typeof(choose (1, (E2), (E1))) T2a;		\
+          typedef __typeof(choose (0, (E1), (E2))) T2b;		\
+          typedef T1a **T1app;					\
+          typedef T1b **T1bpp;					\
+          typedef T2a **T2app;					\
+          typedef T2b **T2bpp;					\
+          T1pp t1 = 0;						\
+          T2pp t2 = 0;						\
+          T1app t1a = 0;					\
+          T1bpp t1b = 0;					\
+          T2app t2a = 0;					\
+          T2bpp t2b = 0;					\
+          t1 = t1a;						\
+          t1 = t1b;						\
+          t2 = t2a;						\
+          t2 = t2b;						\
+        } while (0)
+
+
+extern void abort ();
+extern void exit ();
+
+void bad ()
+{
+  abort ();
+}
+
+void good ()
+{
+  exit (0);
+}
+
+int main (void)
+{
+  signed char sc1, sc2;
+  void *v1;
+  int i, j;
+  double dd;
+  float f;
+  typedef void (*fpt)(void);
+  fpt triple;
+  struct S { int x, y; } pour, some, sugar;
+  union u { int p; } united, nations;
+
+  if (__builtin_choose_expr (0, 12, 0)
+      || !__builtin_choose_expr (45, 5, 0)
+      || !__builtin_choose_expr (45, 3, 0))
+    abort ();
+
+  ASSERT_COND_TYPE (sc1, sc2);
+  ASSERT_COND_TYPE (v1, sc1);
+  ASSERT_COND_TYPE (i, j);
+  ASSERT_COND_TYPE (dd, main);
+  ASSERT_COND_TYPE ((float)dd, i);
+  ASSERT_COND_TYPE (4, f);
+  ASSERT_COND_TYPE (triple, some);
+  ASSERT_COND_TYPE (united, nations);
+  ASSERT_COND_TYPE (nations, main);
+
+  pour.y = 69;
+  __builtin_choose_expr (0, bad (), sugar) = pour;
+  if (sugar.y != 69)
+    abort ();
+
+  __builtin_choose_expr (sizeof (int), f, bad ()) = 3.5F;
+
+  if (f != 3.5F)
+    abort ();
+
+  __builtin_choose_expr (1, good, bad)();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-constant_p-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-constant_p-1.c
new file mode 100644
index 000000000..b0b34f4a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-constant_p-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+int main()
+{
+  if (__builtin_constant_p ()) /* { dg-error "not enough" } */
+    return 0;
+  if (__builtin_constant_p (5, 6)) /* { dg-error "too many" } */
+    return 1;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-inf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-inf-1.c
new file mode 100644
index 000000000..d96a5b6b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-inf-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+
+float fi = __builtin_inff();
+double di = __builtin_inf();
+long double li = __builtin_infl();
+
+float fh = __builtin_huge_valf();
+double dh = __builtin_huge_val();
+long double lh = __builtin_huge_vall();
+
+/* { dg-error "does not support infinity" "INF unsupported" { target vax-*-* spu-*-* } 3 } */
+/* { dg-error "does not support infinity" "INF unsupported" { target vax-*-* } 4 } */
+/* { dg-error "does not support infinity" "INF unsupported" { target vax-*-* } 5 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-1.c
new file mode 100644
index 000000000..404b7117f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-1.c
@@ -0,0 +1,436 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void abort (void);
+extern void exit (int);
+extern void *malloc (size_t);
+extern void *calloc (size_t, size_t);
+extern void *alloca (size_t);
+extern void *memcpy (void *, const void *, size_t);
+extern void *memset (void *, int, size_t);
+extern char *strcpy (char *, const char *);
+
+struct A
+{
+  char a[10];
+  int b;
+  char c[10];
+} y, w[4];
+
+extern char exta[];
+extern char extb[30];
+extern struct A zerol[0];
+
+void
+__attribute__ ((noinline))
+test1 (void *q, int x)
+{
+  struct A a;
+  void *p = &a.a[3], *r;
+  char var[x + 10];
+  if (x < 0)
+    r = &a.a[9];
+  else
+    r = &a.c[1];
+  if (__builtin_object_size (p, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
+    abort ();
+  if (__builtin_object_size (&a.c[9], 0)
+      != sizeof (a) - __builtin_offsetof (struct A, c) - 9)
+    abort ();
+  if (__builtin_object_size (q, 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (r, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 9)
+    abort ();
+  if (x < 6)
+    r = &w[2].a[1];
+  else
+    r = &a.a[6];
+  if (__builtin_object_size (&y, 0)
+      != sizeof (y))
+    abort ();
+  if (__builtin_object_size (w, 0)
+      != sizeof (w))
+    abort ();
+  if (__builtin_object_size (&y.b, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, b))
+    abort ();
+  if (__builtin_object_size (r, 0)
+      != 2 * sizeof (w[0]) - __builtin_offsetof (struct A, a) - 1)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 16);
+  if (__builtin_object_size (r, 0) != 2 * 16)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 14);
+  if (__builtin_object_size (r, 0) != 30)
+    abort ();
+  if (x < 30)
+    r = malloc (sizeof (a));
+  else
+    r = &a.a[3];
+  if (__builtin_object_size (r, 0) != sizeof (a))
+    abort ();
+  r = memcpy (r, "a", 2);
+  if (__builtin_object_size (r, 0) != sizeof (a))
+    abort ();
+  r = memcpy (r + 2, "b", 2) + 2;
+  if (__builtin_object_size (r, 0) != sizeof (a) - 4)
+    abort ();
+  r = &a.a[4];
+  r = memset (r, 'a', 2);
+  if (__builtin_object_size (r, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 4)
+    abort ();
+  r = memset (r + 2, 'b', 2) + 2;
+  if (__builtin_object_size (r, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 8)
+    abort ();
+  r = &a.a[1];
+  r = strcpy (r, "ab");
+  if (__builtin_object_size (r, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 1)
+    abort ();
+  r = strcpy (r + 2, "cd") + 2;
+  if (__builtin_object_size (r, 0)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 5)
+    abort ();
+  if (__builtin_object_size (exta, 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (exta + 10, 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&exta[5], 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (extb, 0) != sizeof (extb))
+    abort ();
+  if (__builtin_object_size (extb + 10, 0) != sizeof (extb) - 10)
+    abort ();
+  if (__builtin_object_size (&extb[5], 0) != sizeof (extb) - 5)
+    abort ();
+  if (__builtin_object_size (var, 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (var + 10, 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&var[5], 0) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (zerol, 0) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol, 0) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0], 0) != 0)
+    abort ();
+  if (__builtin_object_size (zerol[0].a, 0) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].a[0], 0) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].b, 0) != 0)
+    abort ();
+  if (__builtin_object_size ("abcdefg", 0) != sizeof ("abcdefg"))
+    abort ();
+  if (__builtin_object_size ("abcd\0efg", 0) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg", 0) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[0], 0) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[4], 0) != sizeof ("abcd\0efg") - 4)
+    abort ();
+  if (__builtin_object_size ("abcd\0efg" + 5, 0) != sizeof ("abcd\0efg") - 5)
+    abort ();
+  if (__builtin_object_size (L"abcdefg", 0) != sizeof (L"abcdefg"))
+    abort ();
+  r = (char *) L"abcd\0efg";
+  if (__builtin_object_size (r + 2, 0) != sizeof (L"abcd\0efg") - 2)
+    abort ();
+}
+
+size_t l1 = 1;
+
+void
+__attribute__ ((noinline))
+test2 (void)
+{
+  struct B { char buf1[10]; char buf2[10]; } a;
+  char *r, buf3[20];
+  int i;
+
+  if (sizeof (a) != 20)
+    return;
+
+  r = buf3;
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[1];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 0) != 20)
+    abort ();
+  r = &buf3[20];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[7];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 0) != 15)
+    abort ();
+  r += 8;
+  if (__builtin_object_size (r, 0) != 7)
+    abort ();
+  if (__builtin_object_size (r + 6, 0) != 1)
+    abort ();
+  r = &buf3[18];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[9];
+      else if (i == l1)
+	r = &a.buf2[9];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[4];
+    }
+  if (__builtin_object_size (r + 12, 0) != 4)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test3 (void)
+{
+  char buf4[10];
+  struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
+	     _Complex double f; } x;
+  double y;
+  _Complex double z;
+  double *dp;
+
+  if (__builtin_object_size (buf4, 0) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4, 0) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[0], 0) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[1], 0) != sizeof (buf4) - 1)
+    abort ();
+  if (__builtin_object_size (&x, 0) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a, 0) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0], 0) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a, 0) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[0], 0) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[3], 0) != sizeof (x) - 3)
+    abort ();
+  if (__builtin_object_size (&x.a[0].b, 0)
+      != sizeof (x) - __builtin_offsetof (struct A, b))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c, 0)
+      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[0], 0)
+      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[3], 0)
+      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b))
+    abort ();
+  if (__builtin_object_size (&x.b.a, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b))
+    abort ();
+  if (__builtin_object_size (&x.b.a[0], 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b))
+    abort ();
+  if (__builtin_object_size (&x.b.a[3], 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b.b, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, b))
+    abort ();
+  if (__builtin_object_size (&x.b.c, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[0], 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[3], 0)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.c, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, c))
+    abort ();
+  if (__builtin_object_size (&x.c[0], 0)
+      != sizeof (x) - __builtin_offsetof (struct B, c))
+    abort ();
+  if (__builtin_object_size (&x.c[1], 0)
+      != sizeof (x) - __builtin_offsetof (struct B, c) - 1)
+    abort ();
+  if (__builtin_object_size (&x.d, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, d))
+    abort ();
+  if (__builtin_object_size (&x.e, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, e))
+    abort ();
+  if (__builtin_object_size (&x.f, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, f))
+    abort ();
+  dp = &__real__ x.f;
+  if (__builtin_object_size (dp, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, f))
+    abort ();
+  dp = &__imag__ x.f;
+  if (__builtin_object_size (dp, 0)
+      != sizeof (x) - __builtin_offsetof (struct B, f)
+	 - sizeof (x.f) / 2)
+    abort ();
+  dp = &y;
+  if (__builtin_object_size (dp, 0) != sizeof (y))
+    abort ();
+  if (__builtin_object_size (&z, 0) != sizeof (z))
+    abort ();
+  dp = &__real__ z;
+  if (__builtin_object_size (dp, 0) != sizeof (z))
+    abort ();
+  dp = &__imag__ z;
+  if (__builtin_object_size (dp, 0) != sizeof (z) / 2)
+    abort ();
+}
+
+struct S { unsigned int a; };
+
+char *
+__attribute__ ((noinline))
+test4 (char *x, int y)
+{
+  register int i;
+  struct A *p;
+
+  for (i = 0; i < y; i++)
+    {
+      p = (struct A *) x;
+      x = (char *) &p[1];
+      if (__builtin_object_size (p, 0) != (size_t) -1)
+	abort ();
+    }
+  return x;
+}
+
+void
+__attribute__ ((noinline))
+test5 (size_t x)
+{
+  char buf[64];
+  char *p = &buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  /* My understanding of ISO C99 6.5.6 is that a conforming
+     program will not end up with p equal to &buf[0]
+     through &buf[7], i.e. calling this function with say
+     UINTPTR_MAX / 4 results in undefined behaviour.
+     If that's true, then the maximum number of remaining
+     bytes from p until end of the object is 56, otherwise
+     it would be 64 (or conservative (size_t) -1 == unknown).  */
+  if (__builtin_object_size (p, 0) != sizeof (buf) - 8)
+    abort ();
+  memset (p, ' ', sizeof (buf) - 8 - 4 * 4);
+}
+
+void
+__attribute__ ((noinline))
+test6 (size_t x)
+{
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &t.buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 0) != sizeof (t) - 8)
+    abort ();
+  memset (p, ' ', sizeof (t) - 8 - 4 * 4);
+}
+
+void
+__attribute__ ((noinline))
+test7 (void)
+{
+  char buf[64];
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &buf[64], *q = &t.buf[64];
+
+  if (__builtin_object_size (p + 64, 0) != 0)
+    abort ();
+  if (__builtin_object_size (q + 63, 0) != sizeof (t) - 64 - 63)
+    abort ();
+  if (__builtin_object_size (q + 64, 0) != sizeof (t) - 64 - 64)
+    abort ();
+  if (__builtin_object_size (q + 256, 0) != 0)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test8 (void)
+{
+  struct T { char buf[10]; char buf2[10]; } t;
+  char *p = &t.buf2[-4];
+  char *q = &t.buf2[0];
+  if (__builtin_object_size (p, 0) != sizeof (t) - 10 + 4)
+    abort ();
+  if (__builtin_object_size (q, 0) != sizeof (t) - 10)
+    abort ();
+  /* GCC only handles additions, not subtractions.  */
+  q = q - 8;
+  if (__builtin_object_size (q, 0) != (size_t) -1
+      && __builtin_object_size (q, 0) != sizeof (t) - 10 + 8)
+    abort ();
+  p = &t.buf[-4];
+  if (__builtin_object_size (p, 0) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct S s[10];
+  __asm ("" : "=r" (l1) : "0" (l1));
+  test1 (main, 6);
+  test2 ();
+  test3 ();
+  test4 ((char *) s, 10);
+  test5 (4);
+  test6 (4);
+  test7 ();
+  test8 ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-2.c
new file mode 100644
index 000000000..4071c2516
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-2.c
@@ -0,0 +1,393 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void abort (void);
+extern void exit (int);
+extern void *malloc (size_t);
+extern void *calloc (size_t, size_t);
+extern void *alloca (size_t);
+extern void *memcpy (void *, const void *, size_t);
+extern void *memset (void *, int, size_t);
+extern char *strcpy (char *, const char *);
+
+struct A
+{
+  char a[10];
+  int b;
+  char c[10];
+} y, w[4];
+
+extern char exta[];
+extern char extb[30];
+extern struct A extc[];
+struct A zerol[0];
+
+void
+__attribute__ ((noinline))
+test1 (void *q, int x)
+{
+  struct A a;
+  void *p = &a.a[3], *r;
+  char var[x + 10];
+  struct A vara[x + 10];
+  if (x < 0)
+    r = &a.a[9];
+  else
+    r = &a.c[1];
+  if (__builtin_object_size (p, 1) != sizeof (a.a) - 3)
+    abort ();
+  if (__builtin_object_size (&a.c[9], 1)
+      != sizeof (a.c) - 9)
+    abort ();
+  if (__builtin_object_size (q, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (r, 1) != sizeof (a.c) - 1)
+    abort ();
+  if (x < 6)
+    r = &w[2].a[1];
+  else
+    r = &a.a[6];
+  if (__builtin_object_size (&y, 1) != sizeof (y))
+    abort ();
+  if (__builtin_object_size (w, 1) != sizeof (w))
+    abort ();
+  if (__builtin_object_size (&y.b, 1) != sizeof (a.b))
+    abort ();
+  if (__builtin_object_size (r, 1) != sizeof (a.a) - 1)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 16);
+  if (__builtin_object_size (r, 1) != 2 * 16)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 14);
+  if (__builtin_object_size (r, 1) != 30)
+    abort ();
+  if (x < 30)
+    r = malloc (sizeof (a));
+  else
+    r = &a.a[3];
+  if (__builtin_object_size (r, 1) != sizeof (a))
+    abort ();
+  r = memcpy (r, "a", 2);
+  if (__builtin_object_size (r, 1) != sizeof (a))
+    abort ();
+  r = memcpy (r + 2, "b", 2) + 2;
+  if (__builtin_object_size (r, 1) != sizeof (a) - 4)
+    abort ();
+  r = &a.a[4];
+  r = memset (r, 'a', 2);
+  if (__builtin_object_size (r, 1) != sizeof (a.a) - 4)
+    abort ();
+  r = memset (r + 2, 'b', 2) + 2;
+  if (__builtin_object_size (r, 1) != sizeof (a.a) - 8)
+    abort ();
+  r = &a.a[1];
+  r = strcpy (r, "ab");
+  if (__builtin_object_size (r, 1) != sizeof (a.a) - 1)
+    abort ();
+  r = strcpy (r + 2, "cd") + 2;
+  if (__builtin_object_size (r, 1) != sizeof (a.a) - 5)
+    abort ();
+  if (__builtin_object_size (exta, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (exta + 10, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&exta[5], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (extb, 1) != sizeof (extb))
+    abort ();
+  if (__builtin_object_size (extb + 10, 1) != sizeof (extb) - 10)
+    abort ();
+  if (__builtin_object_size (&extb[5], 1) != sizeof (extb) - 5)
+    abort ();
+  if (__builtin_object_size (extc, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (extc + 10, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&extc[5], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&extc->a, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&(extc + 10)->b, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&extc[5].c[3], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (var, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (var + 10, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&var[5], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (vara, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (vara + 10, 1) != (size_t) -1)
+    abort ();    
+  if (__builtin_object_size (&vara[5], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&vara[0].a, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&vara[10].a[0], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&vara[5].a[4], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&vara[5].b, 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (&vara[7].c[7], 1) != (size_t) -1)
+    abort ();
+  if (__builtin_object_size (zerol, 1) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol, 1) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0], 1) != 0)
+    abort ();
+  if (__builtin_object_size (zerol[0].a, 1) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].a[0], 1) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].b, 1) != 0)
+    abort ();
+  if (__builtin_object_size ("abcdefg", 1) != sizeof ("abcdefg"))
+    abort ();
+  if (__builtin_object_size ("abcd\0efg", 1) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg", 1) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[0], 1) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[4], 1) != sizeof ("abcd\0efg") - 4)
+    abort ();
+  if (__builtin_object_size ("abcd\0efg" + 5, 1) != sizeof ("abcd\0efg") - 5)
+    abort ();
+  if (__builtin_object_size (L"abcdefg", 1) != sizeof (L"abcdefg"))
+    abort ();
+  r = (char *) L"abcd\0efg";
+  if (__builtin_object_size (r + 2, 1) != sizeof (L"abcd\0efg") - 2)
+    abort ();
+}
+
+size_t l1 = 1;
+
+void
+__attribute__ ((noinline))
+test2 (void)
+{
+  struct B { char buf1[10]; char buf2[10]; } a;
+  char *r, buf3[20];
+  int i;
+
+  if (sizeof (a) != 20)
+    return;
+
+  r = buf3;
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[1];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 1) != sizeof (buf3))
+    abort ();
+  r = &buf3[20];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[7];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 1) != sizeof (buf3) - 5)
+    abort ();
+  r += 8;
+  if (__builtin_object_size (r, 1) != sizeof (buf3) - 13)
+    abort ();
+  if (__builtin_object_size (r + 6, 1) != sizeof (buf3) - 19)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test3 (void)
+{
+  char buf4[10];
+  struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
+	     _Complex double f; } x;
+  double y;
+  _Complex double z;
+  double *dp;
+
+  if (__builtin_object_size (buf4, 1) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4, 1) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[0], 1) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[1], 1) != sizeof (buf4) - 1)
+    abort ();
+  if (__builtin_object_size (&x, 1) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a, 1) != sizeof (x.a))
+    abort ();
+  if (__builtin_object_size (&x.a[0], 1) != sizeof (x.a))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a, 1) != sizeof (x.a[0].a))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[0], 1) != sizeof (x.a[0].a))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[3], 1) != sizeof (x.a[0].a) - 3)
+    abort ();
+  if (__builtin_object_size (&x.a[0].b, 1) != sizeof (x.a[0].b))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c, 1) != sizeof (x.a[1].c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[0], 1) != sizeof (x.a[1].c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[3], 1) != sizeof (x.a[1].c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b, 1) != sizeof (x.b))
+    abort ();
+  if (__builtin_object_size (&x.b.a, 1) != sizeof (x.b.a))
+    abort ();
+  if (__builtin_object_size (&x.b.a[0], 1) != sizeof (x.b.a))
+    abort ();
+  if (__builtin_object_size (&x.b.a[3], 1) != sizeof (x.b.a) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b.b, 1) != sizeof (x.b.b))
+    abort ();
+  if (__builtin_object_size (&x.b.c, 1) != sizeof (x.b.c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[0], 1) != sizeof (x.b.c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[3], 1) != sizeof (x.b.c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.c, 1) != sizeof (x.c))
+    abort ();
+  if (__builtin_object_size (&x.c[0], 1) != sizeof (x.c))
+    abort ();
+  if (__builtin_object_size (&x.c[1], 1) != sizeof (x.c) - 1)
+    abort ();
+  if (__builtin_object_size (&x.d, 1) != sizeof (x.d))
+    abort ();
+  if (__builtin_object_size (&x.e, 1) != sizeof (x.e))
+    abort ();
+  if (__builtin_object_size (&x.f, 1) != sizeof (x.f))
+    abort ();
+  dp = &__real__ x.f;
+  if (__builtin_object_size (dp, 1) != sizeof (x.f) / 2)
+    abort ();
+  dp = &__imag__ x.f;
+  if (__builtin_object_size (dp, 1) != sizeof (x.f) / 2)
+    abort ();
+  dp = &y;
+  if (__builtin_object_size (dp, 1) != sizeof (y))
+    abort ();
+  if (__builtin_object_size (&z, 1) != sizeof (z))
+      abort ();
+  dp = &__real__ z;
+  if (__builtin_object_size (dp, 1) != sizeof (z) / 2)
+    abort ();
+  dp = &__imag__ z;
+  if (__builtin_object_size (dp, 1) != sizeof (z) / 2)
+    abort ();
+}
+
+struct S { unsigned int a; };
+
+char *
+__attribute__ ((noinline))
+test4 (char *x, int y)
+{
+  register int i;
+  struct A *p;
+
+  for (i = 0; i < y; i++)
+    {
+      p = (struct A *) x;
+      x = (char *) &p[1];
+      if (__builtin_object_size (p, 1) != (size_t) -1)
+	abort ();
+    }
+  return x;
+}
+
+void
+__attribute__ ((noinline))
+test5 (size_t x)
+{
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &t.buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 1) != sizeof (t.buf) - 8)
+    abort ();
+  memset (p, ' ', sizeof (t.buf) - 8 - 4 * 4);
+}
+
+void
+__attribute__ ((noinline))
+test6 (void)
+{
+  char buf[64];
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &buf[64], *q = &t.buf[64];
+
+  if (__builtin_object_size (p + 64, 1) != 0)
+    abort ();
+  if (__builtin_object_size (q + 0, 1) != 0)
+    abort ();
+  if (__builtin_object_size (q + 64, 1) != 0)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test7 (void)
+{
+  struct T { char buf[10]; char buf2[10]; } t;
+  char *p = &t.buf2[-4];
+  char *q = &t.buf2[0];
+  if (__builtin_object_size (p, 1) != 0)
+    abort ();
+  if (__builtin_object_size (q, 1) != sizeof (t.buf2))
+    abort ();
+  q = &t.buf[10];
+  if (__builtin_object_size (q, 1) != 0)
+    abort ();
+  q = &t.buf[11];
+  if (__builtin_object_size (q, 1) != 0)
+    abort ();
+  p = &t.buf[-4];
+  if (__builtin_object_size (p, 1) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct S s[10];
+  __asm ("" : "=r" (l1) : "0" (l1));
+  test1 (main, 6);
+  test2 ();
+  test3 ();
+  test4 ((char *) s, 10);
+  test5 (4);
+  test6 ();
+  test7 ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-3.c
new file mode 100644
index 000000000..572ecda04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-3.c
@@ -0,0 +1,446 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void abort (void);
+extern void exit (int);
+extern void *malloc (size_t);
+extern void *calloc (size_t, size_t);
+extern void *alloca (size_t);
+extern void *memcpy (void *, const void *, size_t);
+extern void *memset (void *, int, size_t);
+extern char *strcpy (char *, const char *);
+
+struct A
+{
+  char a[10];
+  int b;
+  char c[10];
+} y, w[4];
+
+extern char exta[];
+extern char extb[30];
+extern struct A zerol[0];
+
+void
+__attribute__ ((noinline))
+test1 (void *q, int x)
+{
+  struct A a;
+  void *p = &a.a[3], *r;
+  char var[x + 10];
+  if (x < 0)
+    r = &a.a[9];
+  else
+    r = &a.c[1];
+  if (__builtin_object_size (p, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
+    abort ();
+  if (__builtin_object_size (&a.c[9], 2)
+      != sizeof (a) - __builtin_offsetof (struct A, c) - 9)
+    abort ();
+  if (__builtin_object_size (q, 2) != 0)
+    abort ();
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, c) - 1)
+    abort ();
+  if (x < 6)
+    r = &w[2].a[1];
+  else
+    r = &a.a[6];
+  if (__builtin_object_size (&y, 2)
+      != sizeof (y))
+    abort ();
+  if (__builtin_object_size (w, 2)
+      != sizeof (w))
+    abort ();
+  if (__builtin_object_size (&y.b, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, b))
+    abort ();
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 6)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 16);
+  if (__builtin_object_size (r, 2) != 30)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 14);
+  if (__builtin_object_size (r, 2) != 2 * 14)
+    abort ();
+  if (x < 30)
+    r = malloc (sizeof (a));
+  else
+    r = &a.a[3];
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
+    abort ();
+  r = memcpy (r, "a", 2);
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
+    abort ();
+  r = memcpy (r + 2, "b", 2) + 2;
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 3 - 4)
+    abort ();
+  r = &a.a[4];
+  r = memset (r, 'a', 2);
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 4)
+    abort ();
+  r = memset (r + 2, 'b', 2) + 2;
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 8)
+    abort ();
+  r = &a.a[1];
+  r = strcpy (r, "ab");
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 1)
+    abort ();
+  r = strcpy (r + 2, "cd") + 2;
+  if (__builtin_object_size (r, 2)
+      != sizeof (a) - __builtin_offsetof (struct A, a) - 5)
+    abort ();
+  if (__builtin_object_size (exta, 2) != 0)
+    abort ();
+  if (__builtin_object_size (exta + 10, 2) != 0)
+    abort ();
+  if (__builtin_object_size (&exta[5], 2) != 0)
+    abort ();
+  if (__builtin_object_size (extb, 2) != sizeof (extb))
+    abort ();
+  if (__builtin_object_size (extb + 10, 2) != sizeof (extb) - 10)
+    abort ();
+  if (__builtin_object_size (&extb[5], 2) != sizeof (extb) - 5)
+    abort ();
+  if (__builtin_object_size (var, 2) != 0)
+    abort ();
+  if (__builtin_object_size (var + 10, 2) != 0)
+    abort ();
+  if (__builtin_object_size (&var[5], 2) != 0)
+    abort ();
+  if (__builtin_object_size (zerol, 2) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol, 2) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0], 2) != 0)
+    abort ();
+  if (__builtin_object_size (zerol[0].a, 2) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].a[0], 2) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].b, 2) != 0)
+    abort ();
+  if (__builtin_object_size ("abcdefg", 2) != sizeof ("abcdefg"))
+    abort ();
+  if (__builtin_object_size ("abcd\0efg", 2) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg", 2) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[0], 2) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[4], 2) != sizeof ("abcd\0efg") - 4)
+    abort ();
+  if (__builtin_object_size ("abcd\0efg" + 5, 2) != sizeof ("abcd\0efg") - 5)
+    abort ();
+  if (__builtin_object_size (L"abcdefg", 2) != sizeof (L"abcdefg"))
+    abort ();
+  r = (char *) L"abcd\0efg";
+  if (__builtin_object_size (r + 2, 2) != sizeof (L"abcd\0efg") - 2)
+    abort ();
+}
+
+size_t l1 = 1;
+
+void
+__attribute__ ((noinline))
+test2 (void)
+{
+  struct B { char buf1[10]; char buf2[10]; } a;
+  char *r, buf3[20];
+  int i;
+
+  if (sizeof (a) != 20)
+    return;
+
+  r = buf3;
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[1];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 2) != 3)
+    abort ();
+  r = &buf3[20];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[7];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 2) != 0)
+    abort ();
+  r = &buf3[2];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[1];
+      else if (i == l1)
+	r = &a.buf1[2];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[4];
+    }
+  if (__builtin_object_size (r, 2) != 15)
+    abort ();
+  r += 8;
+  if (__builtin_object_size (r, 2) != 7)
+    abort ();
+  if (__builtin_object_size (r + 6, 2) != 1)
+    abort ();
+  r = &buf3[18];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[9];
+      else if (i == l1)
+	r = &a.buf2[9];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[4];
+    }
+  if (__builtin_object_size (r + 12, 2) != 0)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test3 (void)
+{
+  char buf4[10];
+  struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
+	     _Complex double f; } x;
+  double y;
+  _Complex double z;
+  double *dp;
+
+  if (__builtin_object_size (buf4, 2) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4, 2) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[0], 2) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[1], 2) != sizeof (buf4) - 1)
+    abort ();
+  if (__builtin_object_size (&x, 2) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a, 2) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0], 2) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a, 2) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[0], 2) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[3], 2) != sizeof (x) - 3)
+    abort ();
+  if (__builtin_object_size (&x.a[0].b, 2)
+      != sizeof (x) - __builtin_offsetof (struct A, b))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c, 2)
+      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[0], 2)
+      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[3], 2)
+      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b))
+    abort ();
+  if (__builtin_object_size (&x.b.a, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b))
+    abort ();
+  if (__builtin_object_size (&x.b.a[0], 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b))
+    abort ();
+  if (__builtin_object_size (&x.b.a[3], 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b.b, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, b))
+    abort ();
+  if (__builtin_object_size (&x.b.c, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[0], 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[3], 2)
+      != sizeof (x) - __builtin_offsetof (struct B, b)
+	 - __builtin_offsetof (struct A, c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.c, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, c))
+    abort ();
+  if (__builtin_object_size (&x.c[0], 2)
+      != sizeof (x) - __builtin_offsetof (struct B, c))
+    abort ();
+  if (__builtin_object_size (&x.c[1], 2)
+      != sizeof (x) - __builtin_offsetof (struct B, c) - 1)
+    abort ();
+  if (__builtin_object_size (&x.d, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, d))
+    abort ();
+  if (__builtin_object_size (&x.e, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, e))
+    abort ();
+  if (__builtin_object_size (&x.f, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, f))
+    abort ();
+  dp = &__real__ x.f;
+  if (__builtin_object_size (dp, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, f))
+    abort ();
+  dp = &__imag__ x.f;
+  if (__builtin_object_size (dp, 2)
+      != sizeof (x) - __builtin_offsetof (struct B, f)
+	 - sizeof (x.f) / 2)
+    abort ();
+  dp = &y;
+  if (__builtin_object_size (dp, 2) != sizeof (y))
+    abort ();
+  if (__builtin_object_size (&z, 2) != sizeof (z))
+    abort ();
+  dp = &__real__ z;
+  if (__builtin_object_size (dp, 2) != sizeof (z))
+    abort ();
+  dp = &__imag__ z;
+  if (__builtin_object_size (dp, 2) != sizeof (z) / 2)
+    abort ();
+}
+
+struct S { unsigned int a; };
+
+char *
+__attribute__ ((noinline))
+test4 (char *x, int y)
+{
+  register int i;
+  struct A *p;
+
+  for (i = 0; i < y; i++)
+    {
+      p = (struct A *) x;
+      x = (char *) &p[1];
+      if (__builtin_object_size (p, 2) != 0)
+	abort ();
+    }
+  return x;
+}
+
+void
+__attribute__ ((noinline))
+test5 (size_t x)
+{
+  char buf[64];
+  char *p = &buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 2) != 0)
+    abort ();
+  memset (p, ' ', sizeof (buf) - 8 - 4 * 4);
+}
+
+void
+__attribute__ ((noinline))
+test6 (size_t x)
+{
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &t.buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 2) != 0)
+    abort ();
+  memset (p, ' ', sizeof (t) - 8 - 4 * 4);
+}
+
+void
+__attribute__ ((noinline))
+test7 (void)
+{
+  char buf[64];
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &buf[64], *q = &t.buf[64];
+
+  if (__builtin_object_size (p + 64, 2) != 0)
+    abort ();
+  if (__builtin_object_size (q + 63, 2) != sizeof (t) - 64 - 63)
+    abort ();
+  if (__builtin_object_size (q + 64, 2) != sizeof (t) - 64 - 64)
+    abort ();
+  if (__builtin_object_size (q + 256, 2) != 0)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test8 (void)
+{
+  struct T { char buf[10]; char buf2[10]; } t;
+  char *p = &t.buf2[-4];
+  char *q = &t.buf2[0];
+  if (__builtin_object_size (p, 2) != sizeof (t) - 10 + 4)
+    abort ();
+  if (__builtin_object_size (q, 2) != sizeof (t) - 10)
+    abort ();
+  /* GCC only handles additions, not subtractions.  */
+  q = q - 8;
+  if (__builtin_object_size (q, 2) != 0
+      && __builtin_object_size (q, 2) != sizeof (t) - 10 + 8)
+    abort ();
+  p = &t.buf[-4];
+  if (__builtin_object_size (p, 2) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct S s[10];
+  __asm ("" : "=r" (l1) : "0" (l1));
+  test1 (main, 6);
+  test2 ();
+  test3 ();
+  test4 ((char *) s, 10);
+  test5 (4);
+  test6 (4);
+  test7 ();
+  test8 ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-4.c
new file mode 100644
index 000000000..453c2d019
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-4.c
@@ -0,0 +1,407 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void abort (void);
+extern void exit (int);
+extern void *malloc (size_t);
+extern void *calloc (size_t, size_t);
+extern void *alloca (size_t);
+extern void *memcpy (void *, const void *, size_t);
+extern void *memset (void *, int, size_t);
+extern char *strcpy (char *, const char *);
+
+struct A
+{
+  char a[10];
+  int b;
+  char c[10];
+} y, w[4];
+
+extern char exta[];
+extern char extb[30];
+extern struct A extc[];
+struct A zerol[0];
+
+void
+__attribute__ ((noinline))
+test1 (void *q, int x)
+{
+  struct A a;
+  void *p = &a.a[3], *r;
+  char var[x + 10];
+  struct A vara[x + 10];
+  if (x < 0)
+    r = &a.a[9];
+  else
+    r = &a.c[1];
+  if (__builtin_object_size (p, 3) != sizeof (a.a) - 3)
+    abort ();
+  if (__builtin_object_size (&a.c[9], 3)
+      != sizeof (a.c) - 9)
+    abort ();
+  if (__builtin_object_size (q, 3) != 0)
+    abort ();
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 9)
+    abort ();
+  if (x < 6)
+    r = &w[2].a[1];
+  else
+    r = &a.a[6];
+  if (__builtin_object_size (&y, 3) != sizeof (y))
+    abort ();
+  if (__builtin_object_size (w, 3) != sizeof (w))
+    abort ();
+  if (__builtin_object_size (&y.b, 3) != sizeof (a.b))
+    abort ();
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 6)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 16);
+  if (__builtin_object_size (r, 3) != 30)
+    abort ();
+  if (x < 20)
+    r = malloc (30);
+  else
+    r = calloc (2, 14);
+  if (__builtin_object_size (r, 3) != 2 * 14)
+    abort ();
+  if (x < 30)
+    r = malloc (sizeof (a));
+  else
+    r = &a.a[3];
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 3)
+    abort ();
+  r = memcpy (r, "a", 2);
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 3)
+    abort ();
+  r = memcpy (r + 2, "b", 2) + 2;
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 3 - 4)
+    abort ();
+  r = &a.a[4];
+  r = memset (r, 'a', 2);
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 4)
+    abort ();
+  r = memset (r + 2, 'b', 2) + 2;
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 8)
+    abort ();
+  r = &a.a[1];
+  r = strcpy (r, "ab");
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 1)
+    abort ();
+  r = strcpy (r + 2, "cd") + 2;
+  if (__builtin_object_size (r, 3) != sizeof (a.a) - 5)
+    abort ();
+  if (__builtin_object_size (exta, 3) != 0)
+    abort ();
+  if (__builtin_object_size (exta + 10, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&exta[5], 3) != 0)
+    abort ();
+  if (__builtin_object_size (extb, 3) != sizeof (extb))
+    abort ();
+  if (__builtin_object_size (extb + 10, 3) != sizeof (extb) - 10)
+    abort ();
+  if (__builtin_object_size (&extb[5], 3) != sizeof (extb) - 5)
+    abort ();
+  if (__builtin_object_size (extc, 3) != 0)
+    abort ();
+  if (__builtin_object_size (extc + 10, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&extc[5], 3) != 0)
+    abort ();
+  if (__builtin_object_size (&extc->a, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&(extc + 10)->b, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&extc[5].c[3], 3) != 0)
+    abort ();
+  if (__builtin_object_size (var, 3) != 0)
+    abort ();
+  if (__builtin_object_size (var + 10, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&var[5], 3) != 0)
+    abort ();
+  if (__builtin_object_size (vara, 3) != 0)
+    abort ();
+  if (__builtin_object_size (vara + 10, 3) != 0)
+    abort ();    
+  if (__builtin_object_size (&vara[5], 3) != 0)
+    abort ();
+  if (__builtin_object_size (&vara[0].a, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&vara[10].a[0], 3) != 0)
+    abort ();
+  if (__builtin_object_size (&vara[5].a[4], 3) != 0)
+    abort ();
+  if (__builtin_object_size (&vara[5].b, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&vara[7].c[7], 3) != 0)
+    abort ();
+  if (__builtin_object_size (zerol, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0], 3) != 0)
+    abort ();
+  if (__builtin_object_size (zerol[0].a, 3) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].a[0], 3) != 0)
+    abort ();
+  if (__builtin_object_size (&zerol[0].b, 3) != 0)
+    abort ();
+  if (__builtin_object_size ("abcdefg", 3) != sizeof ("abcdefg"))
+    abort ();
+  if (__builtin_object_size ("abcd\0efg", 3) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg", 3) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[0], 3) != sizeof ("abcd\0efg"))
+    abort ();
+  if (__builtin_object_size (&"abcd\0efg"[4], 3) != sizeof ("abcd\0efg") - 4)
+    abort ();
+  if (__builtin_object_size ("abcd\0efg" + 5, 3) != sizeof ("abcd\0efg") - 5)
+    abort ();
+  if (__builtin_object_size (L"abcdefg", 3) != sizeof (L"abcdefg"))
+    abort ();
+  r = (char *) L"abcd\0efg";
+  if (__builtin_object_size (r + 2, 3) != sizeof (L"abcd\0efg") - 2)
+    abort ();
+}
+
+size_t l1 = 1;
+
+void
+__attribute__ ((noinline))
+test2 (void)
+{
+  struct B { char buf1[10]; char buf2[10]; } a;
+  char *r, buf3[20];
+  int i;
+
+  if (sizeof (a) != 20)
+    return;
+
+  r = buf3;
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[1];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 3) != sizeof (a.buf1) - 9)
+    abort ();
+  r = &buf3[20];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[7];
+      else if (i == l1)
+	r = &a.buf2[7];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[9];
+    }
+  if (__builtin_object_size (r, 3) != 0)
+    abort ();
+  r = &buf3[1];
+  for (i = 0; i < 4; ++i)
+    {
+      if (i == l1 - 1)
+	r = &a.buf1[6];
+      else if (i == l1)
+	r = &a.buf2[4];
+      else if (i == l1 + 1)
+	r = &buf3[5];
+      else if (i == l1 + 2)
+	r = &a.buf1[2];
+    }
+  if (__builtin_object_size (r, 3) != sizeof (a.buf1) - 6)
+    abort ();
+  r += 2;
+  if (__builtin_object_size (r, 3) != sizeof (a.buf1) - 6 - 2)
+    abort ();
+  if (__builtin_object_size (r + 1, 3) != sizeof (a.buf1) - 6 - 3)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test3 (void)
+{
+  char buf4[10];
+  struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
+	     _Complex double f; } x;
+  double y;
+  _Complex double z;
+  double *dp;
+
+  if (__builtin_object_size (buf4, 3) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4, 3) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[0], 3) != sizeof (buf4))
+    abort ();
+  if (__builtin_object_size (&buf4[1], 3) != sizeof (buf4) - 1)
+    abort ();
+  if (__builtin_object_size (&x, 3) != sizeof (x))
+    abort ();
+  if (__builtin_object_size (&x.a, 3) != sizeof (x.a))
+    abort ();
+  if (__builtin_object_size (&x.a[0], 3) != sizeof (x.a))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a, 3) != sizeof (x.a[0].a))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[0], 3) != sizeof (x.a[0].a))
+    abort ();
+  if (__builtin_object_size (&x.a[0].a[3], 3) != sizeof (x.a[0].a) - 3)
+    abort ();
+  if (__builtin_object_size (&x.a[0].b, 3) != sizeof (x.a[0].b))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c, 3) != sizeof (x.a[1].c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[0], 3) != sizeof (x.a[1].c))
+    abort ();
+  if (__builtin_object_size (&x.a[1].c[3], 3) != sizeof (x.a[1].c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b, 3) != sizeof (x.b))
+    abort ();
+  if (__builtin_object_size (&x.b.a, 3) != sizeof (x.b.a))
+    abort ();
+  if (__builtin_object_size (&x.b.a[0], 3) != sizeof (x.b.a))
+    abort ();
+  if (__builtin_object_size (&x.b.a[3], 3) != sizeof (x.b.a) - 3)
+    abort ();
+  if (__builtin_object_size (&x.b.b, 3) != sizeof (x.b.b))
+    abort ();
+  if (__builtin_object_size (&x.b.c, 3) != sizeof (x.b.c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[0], 3) != sizeof (x.b.c))
+    abort ();
+  if (__builtin_object_size (&x.b.c[3], 3) != sizeof (x.b.c) - 3)
+    abort ();
+  if (__builtin_object_size (&x.c, 3) != sizeof (x.c))
+    abort ();
+  if (__builtin_object_size (&x.c[0], 3) != sizeof (x.c))
+    abort ();
+  if (__builtin_object_size (&x.c[1], 3) != sizeof (x.c) - 1)
+    abort ();
+  if (__builtin_object_size (&x.d, 3) != sizeof (x.d))
+    abort ();
+  if (__builtin_object_size (&x.e, 3) != sizeof (x.e))
+    abort ();
+  if (__builtin_object_size (&x.f, 3) != sizeof (x.f))
+    abort ();
+  dp = &__real__ x.f;
+  if (__builtin_object_size (dp, 3) != sizeof (x.f) / 2)
+    abort ();
+  dp = &__imag__ x.f;
+  if (__builtin_object_size (dp, 3) != sizeof (x.f) / 2)
+    abort ();
+  dp = &y;
+  if (__builtin_object_size (dp, 3) != sizeof (y))
+    abort ();
+  if (__builtin_object_size (&z, 3) != sizeof (z))
+      abort ();
+  dp = &__real__ z;
+  if (__builtin_object_size (dp, 3) != sizeof (z) / 2)
+    abort ();
+  dp = &__imag__ z;
+  if (__builtin_object_size (dp, 3) != sizeof (z) / 2)
+    abort ();
+}
+
+struct S { unsigned int a; };
+
+char *
+__attribute__ ((noinline))
+test4 (char *x, int y)
+{
+  register int i;
+  struct A *p;
+
+  for (i = 0; i < y; i++)
+    {
+      p = (struct A *) x;
+      x = (char *) &p[1];
+      if (__builtin_object_size (p, 3) != 0)
+	abort ();
+    }
+  return x;
+}
+
+void
+__attribute__ ((noinline))
+test5 (size_t x)
+{
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &t.buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 3) != 0)
+    abort ();
+  memset (p, ' ', sizeof (t.buf) - 8 - 4 * 4);
+}
+
+void
+__attribute__ ((noinline))
+test6 (void)
+{
+  char buf[64];
+  struct T { char buf[64]; char buf2[64]; } t;
+  char *p = &buf[64], *q = &t.buf[64];
+
+  if (__builtin_object_size (p + 64, 3) != 0)
+    abort ();
+  if (__builtin_object_size (q + 0, 3) != 0)
+    abort ();
+  if (__builtin_object_size (q + 64, 3) != 0)
+    abort ();
+}
+
+void
+__attribute__ ((noinline))
+test7 (void)
+{
+  struct T { char buf[10]; char buf2[10]; } t;
+  char *p = &t.buf2[-4];
+  char *q = &t.buf2[0];
+  if (__builtin_object_size (p, 3) != 0)
+    abort ();
+  if (__builtin_object_size (q, 3) != sizeof (t.buf2))
+    abort ();
+  q = &t.buf[10];
+  if (__builtin_object_size (q, 3) != 0)
+    abort ();
+  q = &t.buf[11];
+  if (__builtin_object_size (q, 3) != 0)
+    abort ();
+  p = &t.buf[-4];
+  if (__builtin_object_size (p, 3) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  struct S s[10];
+  __asm ("" : "=r" (l1) : "0" (l1));
+  test1 (main, 6);
+  test2 ();
+  test3 ();
+  test4 ((char *) s, 10);
+  test5 (4);
+  test6 ();
+  test7 ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-5.c
new file mode 100644
index 000000000..4cb580ebc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-object-size-5.c
@@ -0,0 +1,56 @@
+/* { dg-do compile { target i?86-*-linux* x86_64-*-linux* } } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void abort (void);
+extern char buf[0x40000000];
+
+void
+test1 (size_t x)
+{
+  char *p = &buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 0) != sizeof (buf) - 8)
+    abort ();
+}
+
+void
+test2 (size_t x)
+{
+  char *p = &buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 1) != sizeof (buf) - 8)
+    abort ();
+}
+
+void
+test3 (size_t x)
+{
+  char *p = &buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 2) != 0)
+    abort ();
+}
+
+void
+test4 (size_t x)
+{
+  char *p = &buf[8];
+  size_t i;
+
+  for (i = 0; i < x; ++i)
+    p = p + 4;
+  if (__builtin_object_size (p, 3) != 0)
+    abort ();
+}
+
+/* { dg-final { scan-assembler-not "abort" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-prefetch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-prefetch-1.c
new file mode 100644
index 000000000..11beb4e1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-prefetch-1.c
@@ -0,0 +1,45 @@
+/* Test that __builtin_prefetch does no harm.
+
+   Prefetch using some invalid rw and locality values.  These must be
+   compile-time constants.  */
+
+/* { dg-do run } */
+
+extern void exit (int);
+
+enum locality { none, low, moderate, high, bogus };
+enum rw { read, write };
+
+int arr[10];
+
+void
+good (int *p)
+{
+  __builtin_prefetch (p, 0, 0);
+  __builtin_prefetch (p, 0, 1);
+  __builtin_prefetch (p, 0, 2);
+  __builtin_prefetch (p, 0, 3);
+  __builtin_prefetch (p, 1, 0);
+  __builtin_prefetch (p, 1, 1);
+  __builtin_prefetch (p, 1, 2);
+  __builtin_prefetch (p, 1, 3);
+}
+
+void
+bad (int *p)
+{
+  __builtin_prefetch (p, -1, 0);  /* { dg-warning "invalid second argument to '__builtin_prefetch'; using zero" } */
+  __builtin_prefetch (p, 2, 0);   /* { dg-warning "invalid second argument to '__builtin_prefetch'; using zero" } */
+  __builtin_prefetch (p, bogus, 0);   /* { dg-warning "invalid second argument to '__builtin_prefetch'; using zero" } */
+  __builtin_prefetch (p, 0, -1);  /* { dg-warning "invalid third argument to '__builtin_prefetch'; using zero" } */
+  __builtin_prefetch (p, 0, 4);   /* { dg-warning "invalid third argument to '__builtin_prefetch'; using zero" } */
+  __builtin_prefetch (p, 0, bogus);   /* { dg-warning "invalid third argument to '__builtin_prefetch'; using zero" } */
+}
+
+int
+main ()
+{
+  good (arr);
+  bad (arr);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-protos-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-protos-1.c
new file mode 100644
index 000000000..85f96cff0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-protos-1.c
@@ -0,0 +1,68 @@
+/* { dg-do compile } */
+/* { dg-options -Wtraditional-conversion } */
+
+int
+test_s (signed int x)
+{
+  return __builtin_abs (x)	/* { dg-bogus "as unsigned due to prototype" } */
+    + __builtin_clz (x)		/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_ctz (x)		/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_ffs (x)		/* { dg-bogus "as unsigned due to prototype" } */
+    + __builtin_parity (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_popcount (x);	/* { dg-warning "as unsigned due to prototype" } */
+}
+
+int
+test_u (unsigned int x)
+{
+  return __builtin_abs (x)	/* { dg-warning "as signed due to prototype" } */
+    + __builtin_clz (x)		/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_ctz (x)		/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_ffs (x)		/* { dg-warning "as signed due to prototype" } */
+    + __builtin_parity (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_popcount (x);	/* { dg-bogus "as signed due to prototype" } */
+}
+
+int
+test_sl (signed long x)
+{
+  return __builtin_labs (x)	/* { dg-bogus "as unsigned due to prototype" } */
+    + __builtin_clzl (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_ctzl (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_ffsl (x)	/* { dg-bogus "as unsigned due to prototype" } */
+    + __builtin_parityl (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_popcountl (x);	/* { dg-warning "as unsigned due to prototype" } */
+}
+
+int
+test_ul (unsigned long x)
+{
+  return __builtin_labs (x)	/* { dg-warning "as signed due to prototype" } */
+    + __builtin_clzl (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_ctzl (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_ffsl (x)	/* { dg-warning "as signed due to prototype" } */
+    + __builtin_parityl (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_popcountl (x);	/* { dg-bogus "as signed due to prototype" } */
+}
+
+int
+test_sll (signed long long x)
+{
+  return __builtin_llabs (x)	/* { dg-bogus "as unsigned due to prototype" } */
+    + __builtin_clzll (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_ctzll (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_ffsll (x)	/* { dg-bogus "as unsigned due to prototype" } */
+    + __builtin_parityll (x)	/* { dg-warning "as unsigned due to prototype" } */
+    + __builtin_popcountll (x);	/* { dg-warning "as unsigned due to prototype" } */
+}
+
+int
+test_ull (unsigned long long x)
+{
+  return __builtin_llabs (x)	/* { dg-warning "as signed due to prototype" } */
+    + __builtin_clzll (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_ctzll (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_ffsll (x)	/* { dg-warning "as signed due to prototype" } */
+    + __builtin_parityll (x)	/* { dg-bogus "as signed due to prototype" } */
+    + __builtin_popcountll (x);	/* { dg-bogus "as signed due to prototype" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-redefine.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-redefine.c
new file mode 100644
index 000000000..f94d3f3d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-redefine.c
@@ -0,0 +1,79 @@
+/* Test -Wno-builtin-macro-redefined warnings.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wno-builtin-macro-redefined -U__DATE__ -D__TIME__=X" } */
+
+/* Check date, time, and datestamp built-ins warnings may be suppressed.  */
+
+#if defined(__DATE__)
+#error "__DATE__ is defined, but should not be (-U command line error)"
+/* { dg-bogus "__DATE__ is defined" "" { target *-*-* } 9 } */
+#endif
+
+#if __TIME__ != X
+#error "__TIME__ is not defined as expected (-D command line error)"
+/* { dg-bogus "__TIME__ is not defined" "" { target *-*-* } 14 } */
+#endif
+
+#if !defined(__TIMESTAMP__)
+#error "__TIMESTAMP__ is not defined (built-in macro expectation error)"
+/* { dg-bogus "__TIMESTAMP__ is not defined" "" { target *-*-* } 19 } */
+#endif
+
+
+#undef __TIME__              /* Undefine while defined.  */
+#undef __TIME__              /* Undefine while already undefined.  */
+
+#define __TIME__ "X"         /* Define while undefined.  */
+#define __TIME__ "X"         /* Re-define while defined.  */
+
+#define __TIME__ "Y"         /* { dg-warning "\"__TIME__\" redefined" } */
+/* { dg-warning "previous definition" "" { target *-*-* } 28 } */
+
+#undef __TIME__              /* Undefine while defined.  */
+
+
+#undef __DATE__              /* Undefine while already undefined.  */
+
+#define __DATE__ "X"         /* Define while undefined.  */
+#define __DATE__ "X"         /* Re-define while defined.  */
+
+#define __DATE__ "Y"         /* { dg-warning "\"__DATE__\" redefined" } */
+/* { dg-warning "previous definition" "" { target *-*-* } 39 } */
+
+#undef __DATE__              /* Undefine while defined.  */
+
+
+#define __TIMESTAMP__ "X"    /* Define while already defined.  */
+#define __TIMESTAMP__ "X"    /* Re-define while defined.  */
+
+#define __TIMESTAMP__ "Y"    /* { dg-warning "\"__TIMESTAMP__\" redefined" } */
+/* { dg-warning "previous definition" "" { target *-*-* } 48 } */
+
+#undef __TIMESTAMP__         /* Undefine while defined.  */
+
+
+/* Check other built-ins with warnings that may be suppressed.  */
+
+#if !defined(__FILE__) || !defined(__BASE_FILE__)
+#error "Expected built-in is not defined (built-in macro expectation error)"
+/* { dg-bogus "Expected built-in is not defined" "" { target *-*-* } 59 } */
+#endif
+
+#define __FILE__ "X"         /* Define while already defined.  */
+#define __BASE_FILE__ "X"    /* Define while already defined.  */
+
+
+/* Check selected built-ins not affected by warning suppression. */
+
+#if !defined(__LINE__) || !defined(__INCLUDE_LEVEL__) || !defined(__COUNTER__)
+#error "Expected built-in is not defined (built-in macro expectation error)"
+/* { dg-bogus "Expected built-in is not defined" "" { target *-*-* } 70 } */
+#endif
+
+#define __LINE__ 0           /* { dg-warning "\"__LINE__\" redef" } */
+#define __INCLUDE_LEVEL__ 0  /* { dg-warning "\"__INCLUDE_LEVEL__\" redef" } */
+#define __COUNTER__ 0        /* { dg-warning "\"__COUNTER__\" redef" } */
+
+
+int unused;  /* Silence `ISO C forbids an empty translation unit' warning.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-return-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-return-1.c
new file mode 100644
index 000000000..68fd0556b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-return-1.c
@@ -0,0 +1,34 @@
+/* PR middle-end/11151 */
+/* Originator: Andrew Church <gcczilla@achurch.org> */
+/* { dg-do run } */
+/* { dg-xfail-run-if "PR36571 untyped return is char register" { "avr-*-*" } { "*" } { "" } } */
+/* 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.4.3/gcc/testsuite/gcc.dg/builtin-stringop-chk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-stringop-chk-1.c
new file mode 100644
index 000000000..f401d39c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-stringop-chk-1.c
@@ -0,0 +1,114 @@
+/* Test whether buffer overflow warnings for __*_chk builtins
+   are emitted properly.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu99" } */
+/* { dg-options "-mstructure-size-boundary=8 -O2 -std=gnu99" { target arm-*-* } } */
+
+extern void abort (void);
+
+#include "../gcc.c-torture/execute/builtins/chk.h"
+#include <stdarg.h>
+
+volatile void *vx;
+char buf1[20];
+int x;
+
+void
+test (int arg, ...)
+{
+  char buf2[20];
+  va_list ap;
+  char *p = &buf1[10], *q;
+
+  memcpy (&buf2[19], "ab", 1);
+  memcpy (&buf2[19], "ab", 2); /* { dg-warning "will always overflow" "memcpy" } */
+  vx = mempcpy (&buf2[19], "ab", 1);
+  vx = mempcpy (&buf2[19], "ab", 2); /* { dg-warning "will always overflow" "mempcpy" } */
+  memmove (&buf2[18], &buf1[10], 2);
+  memmove (&buf2[18], &buf1[10], 3); /* { dg-warning "will always overflow" "memmove" } */
+  memset (&buf2[16], 'a', 4);
+  memset (&buf2[15], 'b', 6); /* { dg-warning "will always overflow" "memset" } */
+  strcpy (&buf2[18], "a");
+  strcpy (&buf2[18], "ab"); /* { dg-warning "will always overflow" "strcpy" } */
+  vx = stpcpy (&buf2[18], "a");
+  vx = stpcpy (&buf2[18], "ab"); /* { dg-warning "will always overflow" "stpcpy" } */
+  strncpy (&buf2[18], "a", 2);
+  strncpy (&buf2[18], "a", 3); /* { dg-warning "will always overflow" "strncpy" } */
+  strncpy (&buf2[18], "abc", 2);
+  strncpy (&buf2[18], "abc", 3); /* { dg-warning "will always overflow" "strncpy" } */
+  memset (buf2, '\0', sizeof (buf2));
+  strcat (&buf2[18], "a");
+  memset (buf2, '\0', sizeof (buf2));
+  strcat (&buf2[18], "ab"); /* { dg-warning "will always overflow" "strcat" } */
+  sprintf (&buf2[18], "%s", buf1);
+  sprintf (&buf2[18], "%s", "a");
+  sprintf (&buf2[18], "%s", "ab"); /* { dg-warning "will always overflow" "sprintf" } */
+  sprintf (&buf2[18], "a");
+  sprintf (&buf2[18], "ab"); /* { dg-warning "will always overflow" "sprintf" } */
+  snprintf (&buf2[18], 2, "%d", x);
+  /* N argument to snprintf is the size of the buffer.
+     Although this particular call wouldn't overflow buf2,
+     incorrect buffer size was passed to it and therefore
+     we want a warning and runtime failure.  */
+  snprintf (&buf2[18], 3, "%d", x); /* { dg-warning "will always overflow" "snprintf" } */
+  va_start (ap, arg);
+  vsprintf (&buf2[18], "a", ap);
+  va_end (ap);
+  va_start (ap, arg);
+  vsprintf (&buf2[18], "ab", ap); /* { dg-warning "will always overflow" "vsprintf" } */
+  va_end (ap);
+  va_start (ap, arg);
+  vsnprintf (&buf2[18], 2, "%s", ap);
+  va_end (ap);
+  va_start (ap, arg);
+  /* See snprintf above.  */
+  vsnprintf (&buf2[18], 3, "%s", ap); /* { dg-warning "will always overflow" "vsnprintf" } */
+  va_end (ap);
+
+  p = p + 10;
+  memset (p, 'd', 0);
+  q = strcpy (p, ""); /* { dg-warning "will always overflow" "strcpy" } */
+
+  /* This invokes undefined behaviour, since we are past the end of buf1.  */
+  p = p + 10;
+  memset (p, 'd', 1); /* { dg-warning "will always overflow" "memset" } */
+
+  memset (q, 'd', 0);
+  memset (q, 'd', 1); /* { dg-warning "will always overflow" "memset" } */
+  q = q - 10;
+  memset (q, 'd', 10);
+}
+
+char *str = "ABCDEFG";
+typedef struct { char b[16]; } H;
+
+/* Some brown paper bag bugs found in real applications.
+   This test is here merely for amusement.  */
+
+void
+test2 (const H h)
+{
+  char c;
+  strncpy (&c, str, 3); /* { dg-warning "will always overflow" "strncpy" } */
+
+  struct { char b[4]; } x;
+  sprintf (x.b, "%s", "ABCD"); /* { dg-warning "will always overflow" "sprintf" } */
+
+  unsigned int i;
+  memcpy (&i, &h, sizeof (h)); /* { dg-warning "will always overflow" "memcpy" } */
+
+  unsigned char buf[21];
+  memset (buf + 16, 0, 8); /* { dg-warning "will always overflow" "memset" } */
+
+  typedef struct { int i, j, k, l; } S;
+  S *s[3];
+  memset (s, 0, sizeof (S) * 3); /* { dg-warning "will always overflow" "memset" } */
+
+  struct T { char a[8]; char b[4]; char c[10]; } t;
+  stpcpy (t.c,"Testing..."); /* { dg-warning "will always overflow" "stpcpy" } */
+
+  char b1[7];
+  char b2[4];
+  memset (b1, 0, sizeof (b1));
+  memset (b2, 0, sizeof (b1)); /* { dg-warning "will always overflow" "memset" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-stringop-chk-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-stringop-chk-2.c
new file mode 100644
index 000000000..adccd0f44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-stringop-chk-2.c
@@ -0,0 +1,137 @@
+/* This file was miscompiled by an earlier version of the object size
+   checking patch.  Object size in one of the memcpy calls was
+   incorrectly determined to be 0 while it should be (size_t) -1
+   (== unknown).  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+#include "../gcc.c-torture/execute/builtins/chk.h"
+   
+void *bar (int);
+extern void *malloc (__SIZE_TYPE__);
+
+struct A
+{
+  int i, j, k;
+};
+
+/* Here all object sizes are not known at compile time.  There
+   should be no warning, nor any checker functions called.  */
+
+void
+foo (const struct A *x, int y, const unsigned char *z)
+{
+  unsigned int b;
+  unsigned char *c = 0;
+
+  b = (x->i & 0xff) == 1 ? 3 : 4;
+  if (y)
+    c = bar (x->j * x->k);
+
+  const unsigned char *d = z;
+  unsigned char *e = c;
+  unsigned char *f = c + x->j * x->k;
+  int g = 0;
+
+  while (e < f)
+    {
+      unsigned int h = *d++;
+
+      if (h & 128)
+	{
+	  h = h - 128;
+	  g = e + h * b > f;
+	  if (g)
+	    h = (f - e) / b;
+	  if (b < 4)
+	    do
+	      {
+		memcpy (e, d, 3);
+		e += 3;
+	      }
+	    while (--h);
+	  else
+	    do
+	      {
+		memcpy (e, d, 4);
+		e += 4;
+	      }
+	    while (--h);
+	  d += b;
+	}
+      else
+	{
+	  h *= b;
+	  g = e + h > f;
+	  if (g)
+	    h = f - e;
+	  memcpy (e, d, h);
+	  e += h;
+	  d += h;
+	}
+    }
+}
+
+/* The same routine, slightly modified:
+   1) c has known size at compile time
+   2) e += h was changed into e += 16.
+      GCC could actually through VRP determine that
+      in e += h is (h >= 0 && h <= 127), thus know
+      it is pointer addition and not subtraction and
+      know e's __builtin_object_size (e, 0) is at 512,
+      but we are not there yet.  */
+
+unsigned char *
+baz (const struct A *x, const unsigned char *z)
+{
+  unsigned int b;
+  unsigned char *c = 0;
+
+  b = (x->i & 0xff) == 1 ? 3 : 4;
+  c = malloc (512);
+
+  const unsigned char *d = z;
+  unsigned char *e = c;
+  unsigned char *f = c + x->j * x->k;
+  int g = 0;
+
+  while (e < f)
+    {
+      unsigned int h = *d++;
+
+      if (h & 128)
+	{
+	  h = h - 128;
+	  g = e + h * b > f;
+	  if (g)
+	    h = (f - e) / b;
+	  if (b < 4)
+	    do
+	      {
+		memcpy (e, d, 3);
+		e += 3;
+	      }
+	    while (--h);
+	  else
+	    do
+	      {
+		memcpy (e, d, 513); /* { dg-warning "will always overflow" "memcpy" } */
+		e += 4;
+	      }
+	    while (--h);
+	  d += b;
+	}
+      else
+	{
+	  h *= b;
+	  g = e + h > f;
+	  if (g)
+	    h = f - e;
+	  memcpy (e, d, h);
+	  /* e += h; */
+	  e += 16;
+	  d += h;
+	}
+    }
+  return c;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-strncat-chk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-strncat-chk-1.c
new file mode 100644
index 000000000..80d7b9d6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-strncat-chk-1.c
@@ -0,0 +1,38 @@
+/* Test whether buffer overflow warnings for __strncat_chk builtin
+   are emitted properly.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu99" } */
+
+extern void abort (void);
+
+#include "../gcc.c-torture/execute/builtins/chk.h"
+
+char buf1[20];
+char *q;
+
+void
+test (int arg, ...)
+{
+  char *p = &buf1[10];
+
+  *p = 0;
+  strncat (p, "abcdefg", 9);
+  *p = 0;
+  strncat (p, "abcdefghi", 9);
+  *p = 0;
+  strncat (p, "abcdefghij", 9);
+  *p = 0;
+  strncat (p, "abcdefghi", 10);
+  *p = 0;
+  strncat (p, "abcdefghij", 10); /* { dg-warning "will always overflow" } */
+  *p = 0;
+  strncat (p, "abcdefgh", 11);
+  *p = 0;
+  strncat (p, "abcdefghijkl", 11); /* { dg-warning "will always overflow" } */
+  *p = 0;
+  strncat (p, q, 9);
+  *p = 0;
+  strncat (p, q, 10); /* { dg-warning "might overflow" } */
+  *p = 0;
+  strncat (p, q, 11); /* { dg-warning "might overflow" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-strstr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-strstr.c
new file mode 100644
index 000000000..b8201f416
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtin-strstr.c
@@ -0,0 +1,8 @@
+/* The strstr call is expanded to just "s", which should not result in a
+   warning about discarding qualifiers in an assignment.  */
+/* { dg-do compile } */
+extern char * strstr (const char *s1, const char * s2);
+void foo(const char *s){
+  char * cp;
+  cp = strstr(s, "");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-1.c
new file mode 100644
index 000000000..5dab9fe0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-1.c
@@ -0,0 +1,212 @@
+/* Copyright (C) 2002, 2003  Free Software Foundation.
+
+   Verify that all the __builtin_ math functions are recognized
+   by the compiler.
+
+   Written by Roger Sayle, 11th July 2002.  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+/* { dg-final { scan-assembler-not "__builtin_" } } */
+
+/* These helper macros ensure we also check the float and long double
+   cases.  */
+
+/* Test FP functions taking void.  */
+#define FPTEST0(FN) \
+double test_##FN(void) { return __builtin_##FN(); } \
+float test_##FN##f(void) { return __builtin_##FN##f(); } \
+long double test_##FN##l(void) { return __builtin_##FN##l(); } 
+
+/* Test FP functions taking one FP argument.  */
+#define FPTEST1(FN) \
+double test_##FN(double x) { return __builtin_##FN(x); } \
+float test_##FN##f(float x) { return __builtin_##FN##f(x); } \
+long double test_##FN##l(long double x) { return __builtin_##FN##l(x); } 
+
+/* Test FP functions taking one argument of a supplied type.  */
+#define FPTEST1ARG(FN, TYPE) \
+double test_##FN(TYPE x) { return __builtin_##FN(x); } \
+float test_##FN##f(TYPE x) { return __builtin_##FN##f(x); } \
+long double test_##FN##l(TYPE x) { return __builtin_##FN##l(x); } 
+
+/* Test FP functions taking two arguments, the first argument is of a
+   supplied type.  */
+#define FPTEST2ARG1(FN, TYPE) \
+double test_##FN(TYPE x, double y) { return __builtin_##FN(x, y); } \
+float test_##FN##f(TYPE x, float y) { return __builtin_##FN##f(x, y); } \
+long double test_##FN##l(TYPE x, long double y) { return __builtin_##FN##l(x, y); } 
+
+/* Test FP functions taking two arguments, the second argument is of a
+   supplied type.  */
+#define FPTEST2ARG2(FN, TYPE) \
+double test_##FN(double x, TYPE y) { return __builtin_##FN(x, y); } \
+float test_##FN##f(float x, TYPE y) { return __builtin_##FN##f(x, y); } \
+long double test_##FN##l(long double x, TYPE y) { return __builtin_##FN##l(x, y); } 
+
+/* Test FP functions taking two arguments, the second argument is of a
+   supplied type.  The function is named reentrant style, meaning "_r"
+   appears after the possible f/l suffix.  */
+#define FPTEST2ARG2_REENT(FN, TYPE) \
+double test_##FN##_r(double x, TYPE y) { return __builtin_##FN##_r(x, y); } \
+float test_##FN##f_r(float x, TYPE y) { return __builtin_##FN##f_r(x, y); } \
+long double test_##FN##l_r(long double x, TYPE y) { return __builtin_##FN##l_r(x, y); } 
+
+/* Test FP functions taking two arguments, the second argument is a
+   FP pointer.  */
+#define FPTEST2FPP2(FN) \
+double test_##FN(double x, double *y) { return __builtin_##FN(x, y); } \
+float test_##FN##f(float x, float *y) { return __builtin_##FN##f(x, y); } \
+long double test_##FN##l(long double x, long double *y) { return __builtin_##FN##l(x, y); } 
+
+/* Test FP functions taking one FP argument and a supplied return
+   type.  */
+#define FPTEST1RET(FN, TYPE) \
+TYPE test_##FN(double x) { return __builtin_##FN(x); } \
+TYPE test_##FN##f(float x) { return __builtin_##FN##f(x); } \
+TYPE test_##FN##l(long double x) { return __builtin_##FN##l(x); } 
+
+/* Test FP functions taking two FP arguments.  */
+#define FPTEST2(FN) \
+double test_##FN(double x, double y) { return __builtin_##FN(x, y); } \
+float test_##FN##f(float x, float y) { return __builtin_##FN##f(x, y); } \
+long double test_##FN##l(long double x, long double y) { return __builtin_##FN##l(x, y); } 
+
+/* Test FP functions taking three FP arguments.  */
+#define FPTEST3(FN) \
+double test_##FN(double x, double y, double z) { return __builtin_##FN(x, y, z); } \
+float test_##FN##f(float x, float y, float z) { return __builtin_##FN##f(x, y, z); } \
+long double test_##FN##l(long double x, long double y, long double z) { return __builtin_##FN##l(x, y, z); } 
+
+/* Test FP functions taking three arguments, two FP and the third is
+   of a supplied type.  */
+#define FPTEST3ARG3(FN, TYPE) \
+double test_##FN(double x, double y, TYPE z) { return __builtin_##FN(x, y, z); } \
+float test_##FN##f(float x, float y, TYPE z) { return __builtin_##FN##f(x, y, z); } \
+long double test_##FN##l(long double x, long double y, TYPE z) { return __builtin_##FN##l(x, y, z); } 
+
+/* Test FP functions taking three FP arguments.  The second and third
+   are FP pointers.  The return type is void.  */
+#define FPTEST3FPP23VOID(FN) \
+double test_##FN(double x, double *y, double *z) { __builtin_##FN(x, y, z); return *y * *z; } \
+float test_##FN##f(float x, float *y, float *z) { __builtin_##FN##f(x, y, z); return *y * *z; } \
+long double test_##FN##l(long double x, long double *y, long double *z) { __builtin_##FN##l(x, y, z); return *y * *z; } 
+
+/* Test Complex functions taking one Complex argument.  */
+#define CPTEST1(FN) \
+_Complex double test_##FN(_Complex double x) { return __builtin_##FN(x); } \
+_Complex float test_##FN##f(_Complex float x) { return __builtin_##FN##f(x); } \
+_Complex long double test_##FN##l(_Complex long double x) { return __builtin_##FN##l(x); } 
+
+/* Test Complex functions taking one Complex argument and returning an FP type.  */
+#define CPTEST1RETFP(FN) \
+double test_##FN(_Complex double x) { return __builtin_##FN(x); } \
+float test_##FN##f(_Complex float x) { return __builtin_##FN##f(x); } \
+long double test_##FN##l(_Complex long double x) { return __builtin_##FN##l(x); } 
+
+/* Test Complex functions taking two Complex arguments.  */
+#define CPTEST2(FN) \
+_Complex double test_##FN(_Complex double x, _Complex double y) { return __builtin_##FN(x,y); } \
+_Complex float test_##FN##f(_Complex float x, _Complex float y) { return __builtin_##FN##f(x,y); } \
+_Complex long double test_##FN##l(_Complex long double x, _Complex long double y) { return __builtin_##FN##l(x,y); } 
+
+
+/* Keep this list sorted alphabetically by function name.  */
+FPTEST1     (acos)
+FPTEST1     (acosh)
+FPTEST1     (asin)
+FPTEST1     (asinh)
+FPTEST1     (atan)
+FPTEST2     (atan2)
+FPTEST1     (atanh)
+FPTEST1     (cbrt)
+FPTEST1     (ceil)
+FPTEST2     (copysign)
+FPTEST1     (cos)
+FPTEST1     (cosh)
+FPTEST2     (drem)
+FPTEST1     (erf)
+FPTEST1     (erfc)
+FPTEST1     (exp)
+FPTEST1     (exp10)
+FPTEST1     (exp2)
+FPTEST1     (expm1)
+FPTEST1     (fabs)
+FPTEST2     (fdim)
+FPTEST1     (floor)
+FPTEST3     (fma)
+FPTEST2     (fmax)
+FPTEST2     (fmin)
+FPTEST2     (fmod)
+FPTEST2ARG2 (frexp, int *)
+FPTEST1     (gamma)
+FPTEST2ARG2_REENT (gamma, int *) /* gamma_r */
+FPTEST0     (huge_val)
+FPTEST2     (hypot)
+FPTEST1     (ilogb)
+FPTEST0     (inf)  /* { dg-warning "target format does not support infinity" "inf" {target spu-*-*} } */
+FPTEST1     (j0)
+FPTEST1     (j1)
+FPTEST2ARG1 (jn, int)
+FPTEST2ARG2 (ldexp, int)
+FPTEST1     (lgamma)
+FPTEST2ARG2_REENT (lgamma, int *) /* lgamma_r */
+FPTEST1RET  (llrint, long long)
+FPTEST1RET  (llround, long long)
+FPTEST1     (log)
+FPTEST1     (log10)
+FPTEST1     (log1p)
+FPTEST1     (log2)
+FPTEST1     (logb)
+FPTEST1RET  (lrint, long)
+FPTEST1RET  (lround, long)
+FPTEST2FPP2 (modf)
+FPTEST1     (nearbyint)
+FPTEST2     (nextafter)
+FPTEST2     (nexttoward)
+FPTEST2     (pow)
+FPTEST1     (pow10)
+FPTEST2     (remainder)
+FPTEST3ARG3 (remquo, int *)
+FPTEST1     (rint)
+FPTEST1     (round)
+FPTEST2     (scalb)
+FPTEST2ARG2 (scalbln, int)
+FPTEST2ARG2 (scalbn, int)
+FPTEST1RET  (signbit, int)
+FPTEST1     (significand)
+FPTEST1     (sin)
+FPTEST3FPP23VOID (sincos)
+FPTEST1     (sinh)
+FPTEST1     (sqrt)
+FPTEST1     (tan)
+FPTEST1     (tanh)
+FPTEST1     (tgamma)
+FPTEST1     (trunc)
+FPTEST1     (y0)
+FPTEST1     (y1)
+FPTEST2ARG1 (yn, int)
+
+/* Keep this list sorted alphabetically by function name.  */
+CPTEST1RETFP (cabs)
+CPTEST1      (cacos)
+CPTEST1      (cacosh)
+CPTEST1RETFP (carg)
+CPTEST1      (casin)
+CPTEST1      (casinh)
+CPTEST1      (catan)
+CPTEST1      (catanh)
+CPTEST1      (ccos)
+CPTEST1      (ccosh)
+CPTEST1      (cexp)
+CPTEST1RETFP (cimag)
+CPTEST1      (clog)
+CPTEST1      (conj)
+CPTEST2      (cpow)
+CPTEST1      (cproj)
+CPTEST1RETFP (creal)
+CPTEST1      (csin)
+CPTEST1      (csinh)
+CPTEST1      (csqrt)
+CPTEST1      (ctan)
+CPTEST1      (ctanh)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-10.c
new file mode 100644
index 000000000..1b141fda2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-10.c
@@ -0,0 +1,55 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 2nd April 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void link_error(void);
+
+extern double exp(double);
+extern double log(double);
+extern double sqrt(double);
+extern double pow(double,double);
+extern double fabs(double);
+
+void test(double x)
+{
+  if (sqrt(pow(x,4.0)) != x*x)
+    link_error ();
+
+  if (pow(sqrt(x),4.0) != x*x)
+    link_error ();
+
+  if (pow(pow(x,4.0),0.25) != x)
+    /* XFAIL.  PR41098.  */;
+}
+
+void test2(double x, double y, double z)
+{
+  if (sqrt(pow(x,y)) != pow(fabs(x),y*0.5))
+    link_error ();
+
+  if (log(pow(x,y)) != y*log(x))
+    link_error ();
+
+  if (pow(exp(x),y) != exp(x*y))
+    link_error ();
+
+  if (pow(sqrt(x),y) != pow(x,y*0.5))
+    link_error ();
+
+  if (pow(pow(fabs(x),y),z) != pow(fabs(x),y*z))
+    link_error ();
+}
+
+int main()
+{
+  test (2.0);
+  test2 (2.0, 3.0, 4.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-11.c
new file mode 100644
index 000000000..ba0d2dbf0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-11.c
@@ -0,0 +1,53 @@
+/* Copyright (C) 2003,2007 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 5th April 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void link_error(void);
+
+extern double exp(double);
+extern double sqrt(double);
+extern double cbrt(double);
+extern double pow(double,double);
+
+void test(double x, double y, double z)
+{
+  if (sqrt(x)*sqrt(x) != x)
+    link_error ();
+
+  if (sqrt(x)*sqrt(y) != sqrt(x*y))
+    link_error ();
+
+  if (exp(x)*exp(y) != exp(x+y))
+    link_error ();
+
+  if (pow(x,y)*pow(z,y) != pow(z*x,y))
+    link_error ();
+
+  if (pow(x,y)*pow(x,z) != pow(x,y+z))
+    link_error ();
+
+  if (x/exp(y) != x*exp(-y))
+    link_error ();
+
+  if (x/pow(y,z) != x*pow(y,-z))
+    link_error ();
+
+  if (x/sqrt(y/z) != x*sqrt(z/y))
+    link_error ();
+
+  if (x/cbrt(y/z) != x*cbrt(z/y))
+    link_error ();
+}
+
+int main()
+{
+  test (2.0, 3.0, 4.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-12.c
new file mode 100644
index 000000000..61a80edf7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-12.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that all the malloc-like __builtin_ allocation functions are
+   recognized by the compiler.
+
+   Written by Roger Sayle, 12th April 2003.  */
+
+/* { dg-do compile } */
+/* { dg-options "-ansi" } */
+/* { dg-final { scan-assembler-not "__builtin_" } } */
+
+typedef __SIZE_TYPE__ size_t;
+
+void *test1(size_t n)
+{
+  return __builtin_malloc(n);
+}
+
+void *test2(size_t n, size_t s)
+{
+  return __builtin_calloc(n,s);
+}
+
+char *test3(const char *ptr)
+{
+  return __builtin_strdup(ptr);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-13.c
new file mode 100644
index 000000000..149407b54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-13.c
@@ -0,0 +1,62 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that the malloc-like __builtin_ allocation functions are
+   correctly aliased by the compiler.
+
+   Written by Roger Sayle, 12th April 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-ansi" } */
+
+typedef __SIZE_TYPE__ size_t;
+
+extern void abort (void);
+extern void *malloc (size_t);
+extern void *calloc (size_t,size_t);
+
+extern void link_error (void);
+
+static int x;
+
+void test1(void)
+{
+  int *ptr1, *ptr2;
+
+  ptr1 = &x;
+  ptr2 = (int*) malloc (sizeof (int));
+
+  *ptr1 = 12;
+  *ptr2 = 8;
+
+  if (*ptr1 != 12)
+    link_error();
+}
+
+void test2(void)
+{
+  int *ptr1, *ptr2;
+
+  ptr1 = &x;
+  ptr2 = (int*) calloc (1, sizeof (int));
+
+  *ptr1 = 12;
+  *ptr2 = 8;
+
+  if (*ptr1 != 12)
+    link_error ();
+}
+
+int main()
+{
+  test1 ();
+  test2 ();
+  return 0;
+}
+
+#ifndef __OPTIMIZE__
+void link_error (void)
+{
+  abort ();
+}
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-14.c
new file mode 100644
index 000000000..e025391a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-14.c
@@ -0,0 +1,26 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 9th April 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error(void);
+
+extern double pow(double,double);
+
+
+int main()
+{
+  if (pow (2.0, 3.0) != 8.0)
+    link_error ();
+
+  if (pow (2.0, -3.0) != 0.125)
+    link_error ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-15.c
new file mode 100644
index 000000000..6d94c7edc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-15.c
@@ -0,0 +1,17 @@
+/* Derived from PR optimization/10764  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double log(double x);
+
+double ndtri(double y0)
+{
+  double x;
+
+  x = log(y0);
+  x = log(x);
+
+  return x;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-16.c
new file mode 100644
index 000000000..e7ffe9350
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-16.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that all the __builtin_cabs? functions are recognized
+   by the compiler.  Complex numbers are not supported with the
+   gcc.dg default "-pedantic-errors" option, so the dg-options
+   overrides this.
+
+   Written by Roger Sayle, 1st June 2003.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -ansi" } */
+/* { dg-final { scan-assembler-not "__builtin_" } } */
+
+double test(__complex__ double x)
+{
+  return __builtin_cabs (x);
+}
+
+float testf(__complex__ float x)
+{
+  return __builtin_cabsf (x);
+}
+
+long double testl(__complex__ long double x)
+{
+  return __builtin_cabsl (x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-17.c
new file mode 100644
index 000000000..a9e21fba8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-17.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 25th May 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void link_error(void);
+
+extern double exp(double);
+extern double atan(double);
+
+int main()
+{
+  if (exp (1.0) < 2.71 || exp (1.0) > 2.72)
+    link_error ();
+  if (exp (2.0) < 7.38 || exp (2.0) > 7.39)
+    link_error ();
+  if (exp (-2.0) < 0.13 || exp (-2.0) > 0.14)
+    link_error ();
+  if (atan (1.0) < 0.78 || atan (1.0) > 0.79)
+    link_error ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-18.c
new file mode 100644
index 000000000..9afaca23a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-18.c
@@ -0,0 +1,65 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that built-in cabs, cabsf and cabsl functions don't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 1st June 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "builtins-config.h"
+
+extern void link_error(void);
+
+extern float cabsf (float _Complex);
+extern double cabs (double _Complex);
+extern long double cabsl (long double _Complex);
+
+int
+main (void)
+{
+  /* For each type, test both runtime and compile time (constant folding)
+     optimization.  */
+  float _Complex fc = 3.0F + 4.0iF;
+  double _Complex dc = 3.0 + 4.0i;
+  long double _Complex ldc = 3.0L + 4.0iL;
+
+#ifdef HAVE_C99_RUNTIME
+  /* Test floats.  */
+  if (cabsf (fc) != 5.0F)
+    link_error ();
+  if (__builtin_cabsf (fc) != 5.0F)
+    link_error ();
+  if (cabsf (3.0F + 4.0iF) != 5.0F)
+    link_error ();
+  if (__builtin_cabsf (3.0F + 4.0iF) != 5.0F)
+    link_error ();
+#endif
+
+  /* Test doubles.  */
+  if (cabs (dc) != 5.0)
+    link_error ();
+  if (__builtin_cabs (dc) != 5.0)
+    link_error ();
+  if (cabs (3.0 + 4.0i) != 5.0)
+    link_error ();
+  if (__builtin_cabs (3.0 + 4.0i) != 5.0)
+    link_error ();
+
+#ifdef HAVE_C99_RUNTIME
+  /* Test long doubles.  */
+  if (cabsl (ldc) != 5.0L)
+    link_error ();
+  if (__builtin_cabsl (ldc) != 5.0L)
+    link_error ();
+  if (cabsl (3.0L + 4.0iL) != 5.0L)
+    link_error ();
+  if (__builtin_cabsl (3.0L + 4.0iL) != 5.0L)
+    link_error ();
+#endif
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-19.c
new file mode 100644
index 000000000..f0583a978
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-19.c
@@ -0,0 +1,44 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Check that cabs of a non-complex argument is converted into fabs.
+
+   Written by Roger Sayle, 1st June 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double cabs (__complex__ double);
+float cabsf (__complex__ float);
+long double cabsl (__complex__ long double);
+double fabs (double);
+float fabsf (float);
+long double fabsl (long double);
+
+void link_error (void);
+
+void test (double x)
+{
+  if (cabs (x) != fabs (x))
+    link_error ();
+}
+
+void testf (float x)
+{
+  if (cabsf (x) != fabsf (x))
+    link_error ();
+}
+
+void testl (long double x)
+{
+  if (cabsl (x) != fabsl (x))
+    link_error ();
+}
+
+int main ()
+{
+  test (1.0);
+  testf (1.0f);
+  testl (1.0l);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-2.c
new file mode 100644
index 000000000..b1f31c84a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-2.c
@@ -0,0 +1,227 @@
+/* Copyright (C) 2002  Free Software Foundation.
+
+   Verify that built-in math function constant folding doesn't
+   cause any problems for the compiler.
+
+   Written by Roger Sayle, 16th August 2002.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double atan (double);
+extern float atanf (float);
+extern long double atanl (long double);
+extern double exp (double);
+extern float expf (float);
+extern long double expl (long double);
+extern double fabs (double);
+extern float fabsf (float);
+extern long double fabsl (long double);
+extern double log (double);
+extern float logf (float);
+extern long double logl (long double);
+extern double pow (double, double);
+extern float powf (float, float);
+extern long double powl (long double, long double);
+extern double sqrt (double);
+extern float sqrtf (float);
+extern long double sqrtl (long double);
+extern double tan (double);
+extern float tanf (float);
+extern long double tanl (long double);
+
+double test1(double x)
+{
+  return log(exp(x));
+}
+
+double test2(double x)
+{
+  return exp(log(x));
+}
+
+double test3(double x)
+{
+  return sqrt(exp(x));
+}
+
+double test4(double x)
+{
+  return log(sqrt(x));
+}
+
+double test5(double x, double y)
+{
+  return sqrt(x)*sqrt(y);
+}
+
+double test6(double x, double y)
+{
+  return exp(x)*exp(y);
+}
+
+double test7(double x, double y)
+{
+  return x/exp(y);
+}
+
+double test8(double x)
+{
+  return fabs(sqrt(x));
+}
+
+double test9(double x)
+{
+  return fabs(exp(x));
+}
+
+double test10(double x)
+{
+  return tan(atan(x));
+}
+
+double test11(double x)
+{
+  return fabs(fabs(x));
+}
+
+double test12(double x)
+{
+  return fabs(atan(x));
+}
+
+double test13(double x)
+{
+  return fabs(pow(2.0,x));
+}
+
+float test1f(float x)
+{
+  return logf(expf(x));
+}
+
+float test2f(float x)
+{
+  return expf(logf(x));
+}
+
+float test3f(float x)
+{
+  return sqrtf(expf(x));
+}
+
+float test4f(float x)
+{
+  return logf(sqrtf(x));
+}
+
+float test5f(float x, float y)
+{
+  return sqrtf(x)*sqrtf(y);
+}
+
+float test6f(float x, float y)
+{
+  return expf(x)*expf(y);
+}
+
+float test7f(float x, float y)
+{
+  return x/expf(y);
+}
+
+float test8f(float x)
+{
+  return fabsf(sqrtf(x));
+}
+
+float test9f(float x)
+{
+  return fabsf(expf(x));
+}
+
+float test10f(float x)
+{
+  return tanf(atanf(x));
+}
+
+float test11f(float x)
+{
+  return fabsf(fabsf(x));
+}
+
+float test12f(float x)
+{
+  return fabsf(atanf(x));
+}
+
+float test13f(float x)
+{
+  return fabsf(powf(2.0f,x));
+}
+
+long double test1l(long double x)
+{
+  return logl(expl(x));
+}
+
+long double test2l(long double x)
+{
+  return expl(logl(x));
+}
+
+long double test3l(long double x)
+{
+  return sqrtl(expl(x));
+}
+
+long double test4l(long double x)
+{
+  return logl(sqrtl(x));
+}
+
+long double test5l(long double x, long double y)
+{
+  return sqrtl(x)*sqrtl(y);
+}
+
+long double test6l(long double x, long double y)
+{
+  return expl(x)*expl(y);
+}
+
+long double test7l(long double x, long double y)
+{
+  return x/expl(y);
+}
+
+long double test8l(long double x)
+{
+  return fabsl(sqrtl(x));
+}
+
+long double test9l(long double x)
+{
+  return fabsl(expl(x));
+}
+
+long double test10l(long double x)
+{
+  return tanl(atanl(x));
+}
+
+long double test11l(long double x)
+{
+  return fabsl(fabsl(x));
+}
+
+long double test12l(long double x)
+{
+  return fabsl(atanl(x));
+}
+
+long double test13l(long double x)
+{
+  return fabsl(powl(2.0l,x));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-20.c
new file mode 100644
index 000000000..43aa71b27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-20.c
@@ -0,0 +1,749 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that built-in math function constant folding doesn't break
+   anything and produces the expected results.
+
+   Written by Roger Sayle, 8th June 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "builtins-config.h"
+
+extern double cos (double);
+extern double sin (double);
+extern double tan (double);
+extern double fabs (double);
+extern double atan2 (double, double);
+extern double copysign (double, double);
+extern double fmin (double, double);
+extern double fmax (double, double);
+extern double hypot (double, double);
+extern double pure (double) __attribute__ ((__pure__));
+extern double carg (__complex__ double);
+extern __complex__ double ccos (__complex__ double);
+extern __complex__ double ctan (__complex__ double);
+extern float cosf (float);
+extern float sinf (float);
+extern float tanf (float);
+extern float fabsf (float);
+extern float atan2f (float, float);
+extern float copysignf (float, float);
+extern float fminf (float, float);
+extern float fmaxf (float, float);
+extern float hypotf (float, float);
+extern float puref (float) __attribute__ ((__pure__));
+extern float cargf (__complex__ float);
+extern __complex__ float ccosf (__complex__ float);
+extern __complex__ float ctanf (__complex__ float);
+extern long double cosl (long double);
+extern long double sinl (long double);
+extern long double tanl (long double);
+extern long double fabsl (long double);
+extern long double atan2l (long double, long double);
+extern long double copysignl (long double, long double);
+extern long double fminl (long double, long double);
+extern long double fmaxl (long double, long double);
+extern long double hypotl (long double, long double);
+extern long double purel (long double) __attribute__ ((__pure__));
+extern long double cargl (__complex__ long double);
+extern __complex__ long double ccosl (__complex__ long double);
+extern __complex__ long double ctanl (__complex__ long double);
+
+extern void link_error(void);
+
+void test1(double x)
+{
+  if (cos(x) != cos(-x))
+    link_error ();
+
+  if (cos(x) != cos(fabs(x)))
+    link_error ();
+
+  if (cos(x) != cos(-fabs(x)))
+    link_error ();
+
+  if (cos(tan(x)) != cos(tan(-fabs(x))))
+    link_error ();
+
+  if (sin(x)/cos(x) != tan(x))
+    link_error ();
+
+  if (cos(x)/sin(x) != 1.0/tan(x))
+    link_error ();
+
+  if (tan(x)*cos(x) != sin(x))
+    link_error ();
+
+  if (cos(x)*tan(x) != sin(x))
+    link_error ();
+
+  if (sin(x)/tan(x) != cos(x))
+    link_error ();
+
+  if (tan(x)/sin(x) != 1.0/cos(x))
+    link_error ();
+}
+
+void test2(double x, double y)
+{
+  if (-tan(x-y) != tan(y-x))
+    link_error ();
+
+  if (-sin(x-y) != sin(y-x))
+    link_error ();
+
+  if (cos(-x*y) != cos(x*y))
+    link_error ();
+
+  if (cos(x*-y) != cos(x*y))
+    link_error ();
+
+  if (cos(-x/y) != cos(x/y))
+    link_error ();
+
+  if (cos(x/-y) != cos(x/y))
+    link_error ();
+
+  if (cos(-fabs(tan(x/-y))) != cos(tan(x/y)))
+    link_error ();
+
+  if (cos(y<10 ? -x : y) != cos(y<10 ? x : y))
+    link_error ();
+
+  if (cos(y<10 ? x : -y) != cos(y<10 ? x : y))
+    link_error ();
+
+  if (cos(y<10 ? -fabs(x) : tan(x<20 ? -x : -fabs(y)))
+      != cos(y<10 ? x : tan(x<20 ? x : y)))
+    link_error ();
+
+  if (cos((y*=3, -x)) != cos((y*=3,x)))
+    link_error ();
+
+  if (cos((y*=2, -fabs(tan(x/-y)))) != cos((y*=2,tan(x/y))))
+    link_error ();
+
+  if (cos(copysign(x,y)) != cos(x))
+    link_error ();
+
+  if (cos(copysign(-fabs(x),y*=2)) != cos((y*=2,x)))
+    link_error ();
+
+  if (hypot (x, 0) != fabs(x))
+    link_error ();
+
+  if (hypot (0, x) != fabs(x))
+    link_error ();
+
+  if (hypot (x, x) != fabs(x) * __builtin_sqrt(2))
+    link_error ();
+
+  if (hypot (-x, y) != hypot (x, y))
+    link_error ();
+
+  if (hypot (x, -y) != hypot (x, y))
+    link_error ();
+
+  if (hypot (-x, -y) != hypot (x, y))
+    link_error ();
+
+  if (hypot (fabs(x), y) != hypot (x, y))
+    link_error ();
+
+  if (hypot (x, fabs(y)) != hypot (x, y))
+    link_error ();
+
+  if (hypot (fabs(x), fabs(y)) != hypot (x, y))
+    link_error ();
+
+  if (hypot (-fabs(-x), -fabs(fabs(fabs(-y)))) != hypot (x, y))
+    link_error ();
+
+  if (hypot (-x, 0) != fabs(x))
+    link_error ();
+
+  if (hypot (-x, x) != fabs(x) * __builtin_sqrt(2))
+    link_error ();
+
+  if (hypot (pure(x), -pure(x)) != fabs(pure(x)) * __builtin_sqrt(2))
+    link_error ();
+
+  if (hypot (tan(-x), tan(-fabs(y))) != hypot (tan(x), tan(y)))
+    link_error ();
+
+  if (fmin (fmax(x,y),y) != y)
+    link_error ();
+
+  if (fmin (fmax(y,x),y) != y)
+    link_error ();
+
+  if (fmin (x,fmax(x,y)) != x)
+    link_error ();
+  
+  if (fmin (x,fmax(y,x)) != x)
+    link_error ();
+  
+  if (fmax (fmin(x,y),y) != y)
+    link_error ();
+
+  if (fmax (fmin(y,x),y) != y)
+    link_error ();
+
+  if (fmax (x,fmin(x,y)) != x)
+    link_error ();
+  
+  if (fmax (x,fmin(y,x)) != x)
+    link_error ();
+
+  if ((__complex__ double) x != -(__complex__ double) (-x))
+    link_error ();
+
+  if (x*1i != -(-x*1i))
+    link_error ();
+
+  if (x+(x-y)*1i != -(-x+(y-x)*1i))
+    link_error ();
+
+  if (x+(x-y)*1i != -(-x-(x-y)*1i))
+    link_error ();
+
+  if (ccos(tan(x)+sin(y)*1i) != ccos(-tan(-x)+-sin(-y)*1i))
+    link_error ();
+
+  if (ccos(tan(x)+sin(x-y)*1i) != ccos(-tan(-x)-sin(y-x)*1i))
+    link_error ();
+
+  if (-5+x*1i != -~(5+x*1i))
+    link_error ();
+
+  if (tan(x)+tan(y)*1i != -~(tan(-x)+tan(y)*1i))
+    link_error ();
+}
+
+void test3(__complex__ double x, __complex__ double y, int i)
+{
+  if (carg(x) != atan2(__imag__ x, __real__ x))
+    link_error ();
+
+  if (ccos(x) != ccos(-x))
+    link_error();
+
+  if (ccos(ctan(x)) != ccos(ctan(-x)))
+    link_error();
+
+  if (ctan(x-y) != -ctan(y-x))
+    link_error();
+
+  if (ccos(x/y) != ccos(-x/y))
+    link_error();
+
+  if (ccos(x/y) != ccos(x/-y))
+    link_error();
+
+  if (ccos(x/ctan(y)) != ccos(-x/ctan(-y)))
+    link_error();
+
+  if (ccos(x*y) != ccos(-x*y))
+    link_error();
+
+  if (ccos(x*y) != ccos(x*-y))
+    link_error();
+
+  if (ccos(ctan(x)*y) != ccos(ctan(-x)*-y))
+    link_error();
+
+  if (ccos(ctan(x/y)) != ccos(-ctan(x/-y)))
+    link_error();
+
+  if (ccos(i ? x : y) != ccos(i ? -x : y))
+    link_error();
+
+  if (ccos(i ? x : y) != ccos(i ? x : -y))
+    link_error();
+
+  if (ccos(i ? x : ctan(y/x)) != ccos(i ? -x : -ctan(-y/x)))
+    link_error();
+
+  if (~x != -~-x)
+    link_error();
+
+  if (ccos(~x) != ccos(-~-x))
+    link_error();
+
+  if (ctan(~(x-y)) != -ctan(~(y-x)))
+    link_error();
+
+  if (ctan(~(x/y)) != -ctan(~(x/-y)))
+    link_error();
+}
+
+void test1f(float x)
+{
+  if (cosf(x) != cosf(-x))
+    link_error ();
+
+  if (cosf(x) != cosf(fabsf(x)))
+    link_error ();
+
+  if (cosf(x) != cosf(-fabsf(x)))
+    link_error ();
+
+  if (cosf(tanf(x)) != cosf(tanf(-fabsf(x))))
+    link_error ();
+
+#ifdef HAVE_C99_RUNTIME
+  if (sinf(x)/cosf(x) != tanf(x))
+    link_error ();
+
+  if (cosf(x)/sinf(x) != 1.0f/tanf(x))
+    link_error ();
+
+  if (tanf(x)*cosf(x) != sinf(x))
+    link_error ();
+
+  if (cosf(x)*tanf(x) != sinf(x))
+    link_error ();
+
+  if (sinf(x)/tanf(x) != cosf(x))
+    link_error ();
+
+  if (tanf(x)/sinf(x) != 1.0f/cosf(x))
+    link_error ();
+#endif
+}
+
+void test2f(float x, float y)
+{
+  if (-tanf(x-y) != tanf(y-x))
+    link_error ();
+
+  if (-sinf(x-y) != sinf(y-x))
+    link_error ();
+
+  if (cosf(-x*y) != cosf(x*y))
+    link_error ();
+
+  if (cosf(x*-y) != cosf(x*y))
+    link_error ();
+
+  if (cosf(-x/y) != cosf(x/y))
+    link_error ();
+
+  if (cosf(x/-y) != cosf(x/y))
+    link_error ();
+
+  if (cosf(-fabsf(tanf(x/-y))) != cosf(tanf(x/y)))
+    link_error ();
+
+  if (cosf(y<10 ? -x : y) != cosf(y<10 ? x : y))
+    link_error ();
+
+  if (cosf(y<10 ? x : -y) != cosf(y<10 ? x : y))
+    link_error ();
+
+  if (cosf(y<10 ? -fabsf(x) : tanf(x<20 ? -x : -fabsf(y)))
+      != cosf(y<10 ? x : tanf(x<20 ? x : y)))
+    link_error ();
+
+  if (cosf((y*=3, -x)) != cosf((y*=3,x)))
+    link_error ();
+
+  if (cosf((y*=2, -fabsf(tanf(x/-y)))) != cosf((y*=2,tanf(x/y))))
+    link_error ();
+
+  if (cosf(copysignf(x,y)) != cosf(x))
+    link_error ();
+
+  if (cosf(copysignf(-fabsf(x),y*=2)) != cosf((y*=2,x)))
+    link_error ();
+
+  if (hypotf (x, 0) != fabsf(x))
+    link_error ();
+
+  if (hypotf (0, x) != fabsf(x))
+    link_error ();
+
+  if (hypotf (x, x) != fabsf(x) * __builtin_sqrtf(2))
+    link_error ();
+
+  if (hypotf (-x, y) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (x, -y) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (-x, -y) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (fabsf(x), y) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (x, fabsf(y)) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (fabsf(x), fabsf(y)) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (-fabsf(-x), -fabsf(fabsf(fabsf(-y)))) != hypotf (x, y))
+    link_error ();
+
+  if (hypotf (-x, 0) != fabsf(x))
+    link_error ();
+
+  if (hypotf (-x, x) != fabsf(x) * __builtin_sqrtf(2))
+    link_error ();
+
+  if (hypotf (puref(x), -puref(x)) != fabsf(puref(x)) * __builtin_sqrtf(2))
+    link_error ();
+
+  if (hypotf (tanf(-x), tanf(-fabsf(y))) != hypotf (tanf(x), tanf(y)))
+    link_error ();
+
+  if (fminf (fmaxf(x,y),y) != y)
+    link_error ();
+
+  if (fminf (fmaxf(y,x),y) != y)
+    link_error ();
+
+  if (fminf (x,fmaxf(x,y)) != x)
+    link_error ();
+  
+  if (fminf (x,fmaxf(y,x)) != x)
+    link_error ();
+  
+  if (fmaxf (fminf(x,y),y) != y)
+    link_error ();
+
+  if (fmaxf (fminf(y,x),y) != y)
+    link_error ();
+
+  if (fmaxf (x,fminf(x,y)) != x)
+    link_error ();
+  
+  if (fmaxf (x,fminf(y,x)) != x)
+    link_error ();
+
+  if ((__complex__ float) x != -(__complex__ float) (-x))
+    link_error ();
+
+  if (x+(x-y)*1i != -(-x+(y-x)*1i))
+    link_error ();
+
+  if (x+(x-y)*1i != -(-x-(x-y)*1i))
+    link_error ();
+
+  if (ccosf(tanf(x)+sinf(y)*1i) != ccosf(-tanf(-x)+-sinf(-y)*1i))
+    link_error ();
+
+  if (ccosf(tanf(x)+sinf(x-y)*1i) != ccosf(-tanf(-x)-sinf(y-x)*1i))
+    link_error ();
+
+  if (-5+x*1i != -~(5+x*1i))
+    link_error ();
+
+  if (tanf(x)+tanf(y)*1i != -~(tanf(-x)+tanf(y)*1i))
+    link_error ();
+}
+
+void test3f(__complex__ float x, __complex__ float y, int i)
+{
+  if (ccosf(x) != ccosf(-x))
+    link_error();
+
+  if (ccosf(ctanf(x)) != ccosf(ctanf(-x)))
+    link_error();
+
+  if (ctanf(x-y) != -ctanf(y-x))
+    link_error();
+
+  if (ccosf(x/y) != ccosf(-x/y))
+    link_error();
+
+  if (ccosf(x/y) != ccosf(x/-y))
+    link_error();
+
+  if (ccosf(x/ctanf(y)) != ccosf(-x/ctanf(-y)))
+    link_error();
+
+  if (ccosf(x*y) != ccosf(-x*y))
+    link_error();
+
+  if (ccosf(x*y) != ccosf(x*-y))
+    link_error();
+
+  if (ccosf(ctanf(x)*y) != ccosf(ctanf(-x)*-y))
+    link_error();
+
+  if (ccosf(ctanf(x/y)) != ccosf(-ctanf(x/-y)))
+    link_error();
+
+  if (ccosf(i ? x : y) != ccosf(i ? -x : y))
+    link_error();
+
+  if (ccosf(i ? x : y) != ccosf(i ? x : -y))
+    link_error();
+
+  if (ccosf(i ? x : ctanf(y/x)) != ccosf(i ? -x : -ctanf(-y/x)))
+    link_error();
+
+  if (~x != -~-x)
+    link_error();
+
+  if (ccosf(~x) != ccosf(-~-x))
+    link_error();
+
+  if (ctanf(~(x-y)) != -ctanf(~(y-x)))
+    link_error();
+
+  if (ctanf(~(x/y)) != -ctanf(~(x/-y)))
+    link_error();
+
+#ifdef HAVE_C99_RUNTIME
+  if (cargf(x) != atan2f(__imag__ x, __real__ x))
+    link_error ();
+#endif
+}
+
+void test1l(long double x)
+{
+  if (cosl(x) != cosl(-x))
+    link_error ();
+
+  if (cosl(x) != cosl(fabsl(x)))
+    link_error ();
+
+  if (cosl(x) != cosl(-fabsl(x)))
+    link_error ();
+
+  if (cosl(tanl(x)) != cosl(tanl(-fabsl(x))))
+    link_error ();
+
+#ifdef HAVE_C99_RUNTIME
+  if (sinl(x)/cosl(x) != tanl(x))
+    link_error ();
+
+  if (cosl(x)/sinl(x) != 1.0l/tanl(x))
+    link_error ();
+
+  if (tanl(x)*cosl(x) != sinl(x))
+    link_error ();
+
+  if (cosl(x)*tanl(x) != sinl(x))
+    link_error ();
+
+  if (sinl(x)/tanl(x) != cosl(x))
+    link_error ();
+
+  if (tanl(x)/sinl(x) != 1.0l/cosl(x))
+    link_error ();
+#endif
+}
+
+void test2l(long double x, long double y)
+{
+  if (-tanl(x-y) != tanl(y-x))
+    link_error ();
+
+  if (-sinl(x-y) != sinl(y-x))
+    link_error ();
+
+  if (cosl(-x*y) != cosl(x*y))
+    link_error ();
+
+  if (cosl(x*-y) != cosl(x*y))
+    link_error ();
+
+  if (cosl(-x/y) != cosl(x/y))
+    link_error ();
+
+  if (cosl(x/-y) != cosl(x/y))
+    link_error ();
+
+  if (cosl(-fabsl(tanl(x/-y))) != cosl(tanl(x/y)))
+    link_error ();
+
+  if (cosl(y<10 ? -x : y) != cosl(y<10 ? x : y))
+    link_error ();
+
+  if (cosl(y<10 ? x : -y) != cosl(y<10 ? x : y))
+    link_error ();
+
+  if (cosl(y<10 ? -fabsl(x) : tanl(x<20 ? -x : -fabsl(y)))
+      != cosl(y<10 ? x : tanl(x<20 ? x : y)))
+    link_error ();
+
+  if (cosl((y*=3, -x)) != cosl((y*=3,x)))
+    link_error ();
+
+  if (cosl((y*=2, -fabsl(tanl(x/-y)))) != cosl((y*=2,tanl(x/y))))
+    link_error ();
+
+  if (cosl(copysignl(x,y)) != cosl(x))
+    link_error ();
+
+  if (cosl(copysignl(-fabsl(x),y*=2)) != cosl((y*=2,x)))
+    link_error ();
+
+  if (hypotl (x, 0) != fabsl(x))
+    link_error ();
+
+  if (hypotl (0, x) != fabsl(x))
+    link_error ();
+
+  if (hypotl (x, x) != fabsl(x) * __builtin_sqrtl(2))
+    link_error ();
+
+  if (hypotl (-x, y) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (x, -y) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (-x, -y) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (fabsl(x), y) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (x, fabsl(y)) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (fabsl(x), fabsl(y)) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (-fabsl(-x), -fabsl(fabsl(fabsl(-y)))) != hypotl (x, y))
+    link_error ();
+
+  if (hypotl (-x, 0) != fabsl(x))
+    link_error ();
+
+  if (hypotl (-x, x) != fabsl(x) * __builtin_sqrtl(2))
+    link_error ();
+
+  if (hypotl (purel(x), -purel(x)) != fabsl(purel(x)) * __builtin_sqrtl(2))
+    link_error ();
+
+  if (hypotl (tanl(-x), tanl(-fabsl(y))) != hypotl (tanl(x), tanl(y)))
+    link_error ();
+
+  if (fminl (fmaxl(x,y),y) != y)
+    link_error ();
+
+  if (fminl (fmaxl(y,x),y) != y)
+    link_error ();
+
+  if (fminl (x,fmaxl(x,y)) != x)
+    link_error ();
+  
+  if (fminl (x,fmaxl(y,x)) != x)
+    link_error ();
+  
+  if (fmaxl (fminl(x,y),y) != y)
+    link_error ();
+
+  if (fmaxl (fminl(y,x),y) != y)
+    link_error ();
+
+  if (fmaxl (x,fminl(x,y)) != x)
+    link_error ();
+  
+  if (fmaxl (x,fminl(y,x)) != x)
+    link_error ();
+
+  if ((__complex__ long double) x != -(__complex__ long double) (-x))
+    link_error ();
+
+  if (x+(x-y)*1i != -(-x+(y-x)*1i))
+    link_error ();
+
+  if (x+(x-y)*1i != -(-x-(x-y)*1i))
+    link_error ();
+
+  if (ccosl(tanl(x)+sinl(y)*1i) != ccosl(-tanl(-x)+-sinl(-y)*1i))
+    link_error ();
+
+  if (ccosl(tanl(x)+sinl(x-y)*1i) != ccosl(-tanl(-x)-sinl(y-x)*1i))
+    link_error ();
+
+  if (-5+x*1i != -~(5+x*1i))
+    link_error ();
+
+  if (tanl(x)+tanl(y)*1i != -~(tanl(-x)+tanl(y)*1i))
+    link_error ();
+}
+
+void test3l(__complex__ long double x, __complex__ long double y, int i)
+{
+  if (ccosl(x) != ccosl(-x))
+    link_error();
+
+  if (ccosl(ctanl(x)) != ccosl(ctanl(-x)))
+    link_error();
+
+  if (ctanl(x-y) != -ctanl(y-x))
+    link_error();
+
+  if (ccosl(x/y) != ccosl(-x/y))
+    link_error();
+
+  if (ccosl(x/y) != ccosl(x/-y))
+    link_error();
+
+  if (ccosl(x/ctanl(y)) != ccosl(-x/ctanl(-y)))
+    link_error();
+
+  if (ccosl(x*y) != ccosl(-x*y))
+    link_error();
+
+  if (ccosl(x*y) != ccosl(x*-y))
+    link_error();
+
+  if (ccosl(ctanl(x)*y) != ccosl(ctanl(-x)*-y))
+    link_error();
+
+  if (ccosl(ctanl(x/y)) != ccosl(-ctanl(x/-y)))
+    link_error();
+
+  if (ccosl(i ? x : y) != ccosl(i ? -x : y))
+    link_error();
+
+  if (ccosl(i ? x : y) != ccosl(i ? x : -y))
+    link_error();
+
+  if (ccosl(i ? x : ctanl(y/x)) != ccosl(i ? -x : -ctanl(-y/x)))
+    link_error();
+
+  if (~x != -~-x)
+    link_error();
+
+  if (ccosl(~x) != ccosl(-~-x))
+    link_error();
+
+  if (ctanl(~(x-y)) != -ctanl(~(y-x)))
+    link_error();
+
+  if (ctanl(~(x/y)) != -ctanl(~(x/-y)))
+    link_error();
+
+#ifdef HAVE_C99_RUNTIME
+  if (cargl(x) != atan2l(__imag__ x, __real__ x))
+    link_error ();
+#endif
+}
+
+int main()
+{
+  test1 (1.0);
+  test2 (1.0, 2.0);
+
+  test1f (1.0f);
+  test2f (1.0f, 2.0f);
+
+  test1l (1.0l);
+  test2l (1.0l, 2.0l);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-21.c
new file mode 100644
index 000000000..60b127fe6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-21.c
@@ -0,0 +1,65 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that built-in math function constant folding doesn't
+   cause any problems for the compiler.
+
+   Written by Roger Sayle, 7th June 2003.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double fabs (double);
+extern float fabsf (float);
+extern long double fabsl (long double);
+extern double sqrt (double);
+extern float sqrtf (float);
+extern long double sqrtl (long double);
+extern double exp (double);
+extern float expf (float);
+extern long double expl (long double);
+
+double test1(double x)
+{
+  return fabs(x*x);
+}
+
+double test2(double x)
+{
+  return fabs(sqrt(x)+2.0);
+}
+
+double test3(double x)
+{
+  return fabs(3.0*exp(x));
+}
+
+float test1f(float x)
+{
+  return fabsf(x*x);
+}
+
+float test2f(float x)
+{
+  return fabsf(sqrtf(x)+2.0f);
+}
+
+float test3f(float x)
+{
+  return fabsf(3.0f*expf(x));
+}
+
+long double test1l(long double x)
+{
+  return fabsl(x*x);
+}
+
+long double test2l(long double x)
+{
+  return fabsl(sqrtl(x)+2.0l);
+}
+
+long double test3l(long double x)
+{
+  return fabsl(3.0l*expl(x));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-22.c
new file mode 100644
index 000000000..916890b40
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-22.c
@@ -0,0 +1,12 @@
+/* Related to PR optimization/10764  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double exp(double x);
+
+double foo(double x)
+{
+  return exp(exp(x));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-23.c
new file mode 100644
index 000000000..f463e17e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-23.c
@@ -0,0 +1,12 @@
+/* Related to PR optimization/10764  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double atan(double x);
+
+double foo(double x)
+{
+  return atan(atan(x));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-24.c
new file mode 100644
index 000000000..41ec1889f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-24.c
@@ -0,0 +1,35 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that the RTL expansion of floating point exponentiation by
+   a constant integer doesn't break anything and produces the expected
+   results.
+
+   Written by Roger Sayle, 20th June 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double pow(double,double);
+extern void abort(void);
+
+double foo (double x)
+{
+  return pow (x, 6);
+}
+
+double bar (double x)
+{
+  return pow (x, -4);
+}
+
+int main()
+{
+  if (foo (2.0) != 64.0)
+    abort ();
+
+  if (bar (2.0) != 0.0625)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-26.c
new file mode 100644
index 000000000..c4d03cd7d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-26.c
@@ -0,0 +1,105 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 28th June 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void link_error(void);
+
+extern double trunc(double);
+extern double floor(double);
+extern double ceil(double);
+
+extern float truncf(float);
+extern float floorf(float);
+extern float ceilf(float);
+
+extern long double truncl(long double);
+extern long double floorl(long double);
+extern long double ceill(long double);
+
+void test(double x)
+{
+  if (trunc (trunc (x)) != trunc (x))
+    link_error ();
+  if (trunc (floor (x)) != floor (x))
+    link_error ();
+  if (trunc (ceil (x)) != ceil (x))
+    link_error ();
+
+  if (floor (trunc (x)) != trunc (x))
+    link_error ();
+  if (floor (floor (x)) != floor (x))
+    link_error ();
+  if (floor (ceil (x)) != ceil (x))
+    link_error ();
+
+  if (ceil (trunc (x)) != trunc (x))
+    link_error ();
+  if (ceil (floor (x)) != floor (x))
+    link_error ();
+  if (ceil (ceil (x)) != ceil (x))
+    link_error ();
+}
+
+void testf(float x)
+{
+  if (truncf (truncf (x)) != truncf (x))
+    link_error ();
+  if (truncf (floorf (x)) != floorf (x))
+    link_error ();
+  if (truncf (ceilf (x)) != ceilf (x))
+    link_error ();
+
+  if (floorf (truncf (x)) != truncf (x))
+    link_error ();
+  if (floorf (floorf (x)) != floorf (x))
+    link_error ();
+  if (floorf (ceilf (x)) != ceilf (x))
+    link_error ();
+
+  if (ceilf (truncf (x)) != truncf (x))
+    link_error ();
+  if (ceilf (floorf (x)) != floorf (x))
+    link_error ();
+  if (ceilf (ceilf (x)) != ceilf (x))
+    link_error ();
+}
+
+void testl(long double x)
+{
+  if (truncl (truncl (x)) != truncl (x))
+    link_error ();
+  if (truncl (floorl (x)) != floorl (x))
+    link_error ();
+  if (truncl (ceill (x)) != ceill (x))
+    link_error ();
+
+  if (floorl (truncl (x)) != truncl (x))
+    link_error ();
+  if (floorl (floorl (x)) != floorl (x))
+    link_error ();
+  if (floorl (ceill (x)) != ceill (x))
+    link_error ();
+
+  if (ceill (truncl (x)) != truncl (x))
+    link_error ();
+  if (ceill (floorl (x)) != floorl (x))
+    link_error ();
+  if (ceill (ceill (x)) != ceill (x))
+    link_error ();
+}
+
+
+int main()
+{
+  test (3.2);
+  testf (3.2f);
+  testl (3.2l);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-27.c
new file mode 100644
index 000000000..69d8f9944
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-27.c
@@ -0,0 +1,47 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Roger Sayle, 29th July 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void link_error(void);
+
+extern double pow(double,double);
+
+void test(double x)
+{
+  if (pow(x,2.0) != x*x)
+    link_error ();
+
+  if (x*pow(x,2.0) != pow(x,3.0))
+    link_error ();
+
+  if (pow(x,2.0)*x != pow(x,3.0))
+    link_error ();
+
+  if (pow(x,3.0) != x*x*x)
+    link_error ();
+
+  if (pow(x,2.0)*x != x*x*x)
+    link_error ();
+
+  if (x*pow(x,2.0) != x*x*x)
+    link_error ();
+
+  if (pow(x,3.0)/x != pow(x,2.0))
+    link_error ();
+
+  if (pow(x,3.0)/x != x*x)
+    link_error ();
+}
+
+int main()
+{
+  test (2.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-28.c
new file mode 100644
index 000000000..bd76d6b97
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-28.c
@@ -0,0 +1,27 @@
+/* Test that creal and cimag built-in functions do not return lvalues.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern float crealf (float _Complex);
+extern double creal (double _Complex);
+extern long double creall (long double _Complex);
+
+extern float cimagf (float _Complex);
+extern double cimag (double _Complex);
+extern long double cimagl (long double _Complex);
+
+float _Complex fc;
+double _Complex dc;
+long double _Complex ldc;
+
+void
+foo (void)
+{
+  crealf (fc) = 0; /* { dg-error "lvalue" "crealf not lvalue" } */
+  cimagf (fc) = 0; /* { dg-error "lvalue" "cimagf not lvalue" } */
+  creal (dc) = 0; /* { dg-error "lvalue" "creal not lvalue" } */
+  cimag (dc) = 0; /* { dg-error "lvalue" "cimag not lvalue" } */
+  creall (ldc) = 0; /* { dg-error "lvalue" "creall not lvalue" } */
+  cimagl (ldc) = 0; /* { dg-error "lvalue" "cimagl not lvalue" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-30.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-30.c
new file mode 100644
index 000000000..65a78fefe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-30.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wshadow" } */
+
+extern double strtod (const char *, char **);
+#define UNUSED __attribute__ ((unused))
+
+/* A built-in function may be overridden by an old-style definition
+   specifying too few arguments... */
+double cos ()  /* { dg-warning "shadows a built-in" } */
+{
+  /* { dg-warning "number of arguments doesn't match built-in prototype" "built-in" { target *-*-* } 10 } */
+  return strtod ("nan", 0);
+}
+
+/* the right number, but the wrong type, arguments... */
+double sin (foo)  /* { dg-warning "shadows a built-in" } */
+     int foo UNUSED;
+{  /* { dg-warning "argument 'foo' doesn't match built-in prototype" } */
+  return strtod ("nan", 0);
+}
+
+/* or too many arguments.  */
+long double cosl (foo, bar)  /* { dg-warning "shadows a built-in" } */
+     const char *foo UNUSED;
+     int bar UNUSED;
+{  /* { dg-warning "number of arguments doesn't match built-in prototype" } */
+  /* { dg-warning "argument 'foo' doesn't match built-in prototype" "foo" { target *-*-* } 26 } */
+  return strtod ("nan", 0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-31.c
new file mode 100644
index 000000000..6e1bda0b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-31.c
@@ -0,0 +1,36 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that constant folding of signbit, signbitf and signbitl math
+   functions doesn't break anything and produces the expected results.
+
+   Written by Roger Sayle, 28th January 2004.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error(void);
+
+extern int signbit(double);
+extern int signbitf(float);
+extern int signbitl(long double);
+
+int main()
+{
+  if (signbit (1.0) != 0)
+    link_error ();
+  if (signbit (-2.0) == 0)
+    link_error ();
+
+  if (signbitf (1.0f) != 0)
+    link_error ();
+  if (signbitf (-2.0f) == 0)
+    link_error ();
+
+  if (signbitl (1.0l) != 0)
+    link_error ();
+  if (signbitl (-2.0f) == 0)
+    link_error ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-32.c
new file mode 100644
index 000000000..3d2a36190
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-32.c
@@ -0,0 +1,58 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that constant folding of signbit, signbitf and signbitl math
+   functions doesn't break anything and produces the expected results.
+
+   Written by Roger Sayle, 28th January 2004.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort(void);
+
+extern int signbit(double);
+extern int signbitf(float);
+extern int signbitl(long double);
+
+int test (double x)
+{
+  return signbit(x);
+}
+
+int testf (float x)
+{
+  return signbitf(x);
+}
+
+int testl (long double x)
+{
+  return signbitl(x);
+}
+
+
+int main()
+{
+  if (test (0.0) != 0)
+    abort ();
+  if (test (1.0) != 0)
+    abort ();
+  if (test (-2.0) == 0)
+    abort ();
+
+  if (testf (0.0f) != 0)
+    abort ();
+  if (testf (1.0f) != 0)
+    abort ();
+  if (testf (-2.0f) == 0)
+    abort ();
+
+  if (testl (0.0l) != 0)
+    abort ();
+  if (testl (1.0l) != 0)
+    abort ();
+  if (testl (-2.0l) == 0)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-33.c
new file mode 100644
index 000000000..11393e300
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-33.c
@@ -0,0 +1,65 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that log10, log10f, log10l, log2, log2f and log2l
+   built-in functions compile.
+
+   Written by Uros Bizjak, 11th February 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double log10(double);
+extern double log2(double);
+extern double log1p(double);
+extern float log10f(float);
+extern float log2f(float);
+extern float log1pf(float);
+extern long double log10l(long double);
+extern long double log2l(long double);
+extern long double log1pl(long double);
+
+
+double test1(double x)
+{
+  return log10(x);
+}
+
+double test2(double x)
+{
+  return log2(x);
+}
+
+double test3(double x)
+{
+  return log1p(x);
+}
+
+float test1f(float x)
+{
+  return log10f(x);
+}
+
+float test2f(float x)
+{
+  return log2f(x);
+}
+
+float test3f(float x)
+{
+  return log1pf(x);
+}
+
+long double test1l(long double x)
+{
+  return log10l(x);
+}
+
+long double test2l(long double x)
+{
+  return log2l(x);
+}
+
+long double test3l(long double x)
+{
+  return log1pl(x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-34.c
new file mode 100644
index 000000000..ee8d7513f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-34.c
@@ -0,0 +1,155 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that exp10, exp10f, exp10l, exp2, exp2f, exp2l, pow10, pow10f,
+   pow10l, expm1, expm1f and expm1l built-in functions compile.
+
+   Written by Uros Bizjak, 13th February 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double exp10(double);
+extern double exp2(double);
+extern double pow10(double);
+extern double expm1(double);
+extern double ldexp(double, int);
+extern double scalb(double, double);
+extern double scalbn(double, int);
+extern double scalbln(double, long);
+extern float exp10f(float);
+extern float exp2f(float);
+extern float pow10f(float);
+extern float expm1f(float);
+extern float ldexpf(float, int);
+extern float scalbf(float, float);
+extern float scalbnf(float, int);
+extern float scalblnf(float, long);
+extern long double exp10l(long double);
+extern long double exp2l(long double);
+extern long double pow10l(long double);
+extern long double expm1l(long double);
+extern long double ldexpl(long double, int);
+extern long double scalbl(long double, long double);
+extern long double scalbnl(long double, int);
+extern long double scalblnl(long double, long);
+
+
+double test1(double x)
+{
+  return exp10(x);
+}
+
+double test2(double x)
+{
+  return exp2(x);
+}
+
+double test3(double x)
+{
+  return pow10(x);
+}
+
+double test4(double x)
+{
+  return expm1(x);
+}
+
+double test5(double x, int exp)
+{
+  return ldexp(x, exp);
+}
+
+double test6(double x, double exp)
+{
+  return scalb(x, exp);
+}
+
+double test7(double x, int exp)
+{
+  return scalbn(x, exp);
+}
+
+double test8(double x, long exp)
+{
+  return scalbln(x, exp);
+}
+
+float test1f(float x)
+{
+  return exp10f(x);
+}
+
+float test2f(float x)
+{
+  return exp2f(x);
+}
+
+float test3f(float x)
+{
+  return pow10f(x);
+}
+
+float test4f(float x)
+{
+  return expm1f(x);
+}
+
+float test5f(float x, int exp)
+{
+  return ldexpf(x, exp);
+}
+
+float test6f(float x, float exp)
+{
+  return scalbf(x, exp);
+}
+
+float test7f(float x, int exp)
+{
+  return scalbnf(x, exp);
+}
+
+float test8f(float x, long exp)
+{
+  return scalblnf(x, exp);
+}
+
+long double test1l(long double x)
+{
+  return exp10l(x);
+}
+
+long double test2l(long double x)
+{
+  return exp2l(x);
+}
+
+long double test3l(long double x)
+{
+  return pow10l(x);
+}
+
+long double test4l(long double x)
+{
+  return expm1l(x);
+}
+
+long double test5l(long double x, int exp)
+{
+  return ldexpl(x, exp);
+}
+
+long double test6l(long double x, long double exp)
+{
+  return scalbl(x, exp);
+}
+
+long double test7l(long double x, int exp)
+{
+  return scalbnl(x, exp);
+}
+
+long double test8l(long double x, long exp)
+{
+  return scalblnl(x, exp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-35.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-35.c
new file mode 100644
index 000000000..f898707e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-35.c
@@ -0,0 +1,6 @@
+/* Test that nan functions are not built-in in C90 mode.  Bug 14635.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+
+int nan, nanf, nanl, nans, nansf, nansl;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-36.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-36.c
new file mode 100644
index 000000000..dc7119884
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-36.c
@@ -0,0 +1,79 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check sin, sinf, sinl, cos, cosf and cosl built-in functions
+   eventually compile to sincos, sincosf and sincosl.
+
+   Written by Uros Bizjak, 5th April 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double sin(double);
+extern float sinf(float);
+extern long double sinl(long double);
+
+extern double cos(double);
+extern float cosf(float);
+extern long double cosl(long double);
+
+
+double test1(double x)
+{
+	double y1, y2;
+
+	y1 = sin(x);
+	y2 = cos(x);
+
+	return y1 - y2;
+}
+
+float test1f(float x)
+{
+	float y1, y2;
+
+	y1 = sinf(x);
+	y2 = cosf(x);
+
+	return y1 - y2;
+}
+
+long double test1l(long double x)
+{
+	long double y1, y2;
+
+	y1 = sinl(x);
+	y2 = cosl(x);
+
+	return y1 - y2;
+}
+
+double test2(double x)
+{
+	return sin(x);
+}
+
+float test2f(float x)
+{
+	return sinf(x);
+}
+
+long double test2l(long double x)
+{
+	return sinl(x);
+}
+
+double test3(double x)
+{
+	return cos(x);
+}
+
+float test3f(float x)
+{
+	return cosf(x);
+}
+
+long double test3l(long double x)
+{
+	return cosl(x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-37.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-37.c
new file mode 100644
index 000000000..e366a6ac5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-37.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check tan, tanf and tanl built-in functions.
+
+   Written by Uros Bizjak, 7th April 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double tan(double);
+extern float tanf(float);
+extern long double tanl(long double);
+
+
+double test1(double x)
+{
+  return tan(x);
+}
+
+float test1f(float x)
+{
+  return tanf(x);
+}
+
+long double test1l(long double x)
+{
+  return tanl(x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-38.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-38.c
new file mode 100644
index 000000000..210516bb7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-38.c
@@ -0,0 +1,48 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that logb, logbf, logbl, ilogb, ilogbf and ilogbl
+   built-in functions compile.
+
+   Written by Uros Bizjak, 14th April 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double logb(double);
+extern float logbf(float);
+extern long double logbl(long double);
+extern int ilogb(double);
+extern int ilogbf(float);
+extern int ilogbl(long double);
+
+
+double test1(double x)
+{
+  return logb(x);
+}
+
+float test1f(float x)
+{
+  return logbf(x);
+}
+
+long double test1l(long double x)
+{
+  return logbl(x);
+}
+
+int test2(double x)
+{
+  return ilogb(x);
+}
+
+int test2f(float x)
+{
+  return ilogbf(x);
+}
+
+int test2l(long double x)
+{
+  return ilogbl(x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-39.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-39.c
new file mode 100644
index 000000000..6359be2b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-39.c
@@ -0,0 +1,48 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that asin, asinf, asinl, acos, acosf
+   and acosl built-in functions compile.
+
+   Written by Uros Bizjak, 20th April 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double asin(double);
+extern double acos(double);
+extern float asinf(float);
+extern float acosf(float);
+extern long double asinl(long double);
+extern long double acosl(long double);
+
+
+double test1(double x)
+{
+  return asin(x);
+}
+
+double test2(double x)
+{
+  return acos(x);
+}
+
+float test1f(float x)
+{
+  return asinf(x);
+}
+
+float test2f(float x)
+{
+  return acosf(x);
+}
+
+long double test1l(long double x)
+{
+  return asinl(x);
+}
+
+long double test2l(long double x)
+{
+  return acosl(x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-40.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-40.c
new file mode 100644
index 000000000..982175a3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-40.c
@@ -0,0 +1,68 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that fmod, fmodf, fmodl, drem, dremf, dreml,
+   remainder, remainderf and remainderl
+   built-in functions compile.
+
+   Written by Uros Bizjak, 5th May 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern double fmod(double, double);
+extern float fmodf(float, float);
+extern long double fmodl(long double, long double);
+
+extern double remainder(double, double);
+extern float remainderf(float, float);
+extern long double remainderl(long double, long double);
+
+extern double drem(double, double);
+extern float dremf(float, float);
+extern long double dreml(long double, long double);
+
+
+double test1(double x, double y)
+{
+  return fmod(x, y);
+}
+
+float test1f(float x, float y)
+{
+  return fmodf(x, y);
+}
+
+long double test1l(long double x, long double y)
+{
+  return fmodl(x, y);
+}
+
+double test2(double x, double y)
+{
+  return remainder(x, y);
+}
+
+float test2f(float x, float y)
+{
+  return remainderf(x, y);
+}
+
+long double test2l(long double x, long double y)
+{
+  return remainderl(x, y);
+}
+
+double test3(double x, double y)
+{
+  return drem(x, y);
+}
+
+float test3f(float x, float y)
+{
+  return dremf(x, y);
+}
+
+long double test3l(long double x, long double y)
+{
+  return dreml(x, y);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-41.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-41.c
new file mode 100644
index 000000000..5b96551fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-41.c
@@ -0,0 +1,57 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that constant folding of copysign, copysignf and copysignl math
+   functions doesn't break anything and produces the expected results.
+
+   Written by Roger Sayle, 6th June 2004.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error(void);
+
+extern double copysign(double, double);
+extern float copysignf(float, float);
+extern long double copysignl(long double, long double);
+
+int main()
+{
+  if (copysign (2.0, 1.0) != 2.0)
+    link_error ();
+  if (copysign (2.0, -1.0) != -2.0)
+    link_error ();
+  if (copysign (-2.0, 1.0) != 2.0)
+    link_error ();
+  if (copysign (-2.0, -1.0) != -2.0)
+    link_error ();
+
+  if (copysign (2.0, 1.0) != 2.0)
+    link_error ();
+  if (copysign (2.0, -1.0) != -2.0)
+    link_error ();
+  if (copysign (-2.0, 1.0) != 2.0)
+    link_error ();
+  if (copysign (-2.0, -1.0) != -2.0)
+    link_error ();
+
+  if (copysignf (2.0f, 1.0f) != 2.0f)
+    link_error ();
+  if (copysignf (2.0f, -1.0f) != -2.0f)
+    link_error ();
+  if (copysignf (-2.0f, 1.0f) != 2.0f)
+    link_error ();
+  if (copysignf (-2.0f, -1.0f) != -2.0f)
+    link_error ();
+
+  if (copysignl (2.0l, 1.0l) != 2.0l)
+    link_error ();
+  if (copysignl (2.0l, -1.0l) != -2.0l)
+    link_error ();
+  if (copysignl (-2.0l, 1.0l) != 2.0l)
+    link_error ();
+  if (copysignl (-2.0l, -1.0l) != -2.0l)
+    link_error ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-43.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-43.c
new file mode 100644
index 000000000..85d96b6cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-43.c
@@ -0,0 +1,59 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-trapping-math -fno-finite-math-only -fdump-tree-gimple -fdump-tree-optimized" } */
+  
+extern void f(int);
+extern void link_error ();
+
+extern float x;
+extern double y;
+extern long double z;
+
+int
+main ()
+{
+  double nan = __builtin_nan ("");
+#ifndef __SPU__
+  /* The SPU single-precision floating point format does not support NANs.  */
+  float nanf = __builtin_nanf ("");
+#endif
+  long double nanl = __builtin_nanl ("");
+
+  if (!__builtin_isnan (nan))
+    link_error ();
+#ifndef __SPU__
+  if (!__builtin_isnan (nanf))
+    link_error ();
+  if (!__builtin_isnanf (nanf))
+    link_error ();
+#endif
+  if (!__builtin_isnan (nanl))
+    link_error ();
+  if (!__builtin_isnanl (nanl))
+    link_error ();
+
+  if (__builtin_isnan (4.0))
+    link_error ();
+  if (__builtin_isnan (4.0))
+    link_error ();
+  if (__builtin_isnanf (4.0))
+    link_error ();
+  if (__builtin_isnan (4.0))
+    link_error ();
+  if (__builtin_isnanl (4.0))
+    link_error ();
+
+  f (__builtin_isnan (x));
+  f (__builtin_isnan (y));
+  f (__builtin_isnanf (y));
+  f (__builtin_isnan (z));
+  f (__builtin_isnanl (z));
+}
+
+
+/* Check that all instances of __builtin_isnan were folded.  */
+/* { dg-final { scan-tree-dump-times "isnan" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+
+/* Check that all instances of link_error were subject to DCE.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-44.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-44.c
new file mode 100644
index 000000000..9e19d774d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-44.c
@@ -0,0 +1,62 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-trapping-math -fno-finite-math-only -fdump-tree-optimized" } */
+  
+extern void f(int);
+extern void link_error ();
+
+extern float x;
+extern double y;
+extern long double z;
+
+int
+main ()
+{
+  double pinf = __builtin_inf ();
+#ifndef __SPU__
+  /* The SPU single-precision floating point format does not support Inf.  */
+  float pinff = __builtin_inff ();
+#endif
+  long double pinfl = __builtin_infl ();
+
+  if (__builtin_isinf (pinf) != 1)
+    link_error ();
+#ifndef __SPU__
+  if (__builtin_isinf (pinff) != 1)
+    link_error ();
+  if (__builtin_isinff (pinff) != 1)
+    link_error ();
+#endif
+  if (__builtin_isinf (pinfl) != 1)
+    link_error ();
+  if (__builtin_isinfl (pinfl) != 1)
+    link_error ();
+
+  if (__builtin_isinf (-pinf) != -1)
+    link_error ();
+#ifndef __SPU__
+  if (__builtin_isinf (-pinff) != -1)
+    link_error ();
+  if (__builtin_isinff (-pinff) != -1)
+    link_error ();
+#endif
+  if (__builtin_isinf (-pinfl) != -1)
+    link_error ();
+  if (__builtin_isinfl (-pinfl) != -1)
+    link_error ();
+
+  if (__builtin_isinf (4.0))
+    link_error ();
+  if (__builtin_isinf (4.0))
+    link_error ();
+  if (__builtin_isinff (4.0))
+    link_error ();
+  if (__builtin_isinf (4.0))
+    link_error ();
+  if (__builtin_isinfl (4.0))
+    link_error ();
+}
+
+
+/* Check that all instances of link_error were subject to DCE.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-45.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-45.c
new file mode 100644
index 000000000..15ec33af6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-45.c
@@ -0,0 +1,57 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-trapping-math -fno-finite-math-only -fdump-tree-optimized" } */
+  
+extern void f(int);
+extern void link_error ();
+
+extern float x;
+extern double y;
+extern long double z;
+
+int
+main ()
+{
+  double nan = __builtin_nan ("");
+#ifndef __SPU__
+  /* The SPU single-precision floating point format does not support NANs.  */
+  float nanf = __builtin_nanf ("");
+#endif
+  long double nanl = __builtin_nanl ("");
+
+  double pinf = __builtin_inf ();
+#ifndef __SPU__
+  /* The SPU single-precision floating point format does not support Inf.  */
+  float pinff = __builtin_inff ();
+#endif
+  long double pinfl = __builtin_infl ();
+
+  if (__builtin_finite (pinf))
+    link_error ();
+#ifndef __SPU__
+  if (__builtin_finitef (pinff))
+    link_error ();
+#endif
+  if (__builtin_finitel (pinfl))
+    link_error ();
+
+  if (__builtin_finite (nan))
+    link_error ();
+#ifndef __SPU__
+  if (__builtin_finitef (nanf))
+    link_error ();
+#endif
+  if (__builtin_finitel (nanl))
+    link_error ();
+
+  if (!__builtin_finite (4.0))
+    link_error ();
+  if (!__builtin_finitef (4.0))
+    link_error ();
+  if (!__builtin_finitel (4.0))
+    link_error ();
+}
+
+
+/* Check that all instances of link_error were subject to DCE.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-46.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-46.c
new file mode 100644
index 000000000..3a955a569
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-46.c
@@ -0,0 +1,142 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that rint, rintf, rintl, lrint, lrintf, lrintl,
+   llrint, llrintf, llrintl, floor, floorf, floorl,
+   ceil, ceilf, ceill, trunc, truncf, truncl,
+   nearbyint, nearbyintf and nearbyintl
+   built-in functions compile.
+
+   Written by Uros Bizjak, 25th Aug 2004.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double rint(double);
+extern long int lrint(double);
+extern long long int llrint(double);
+extern double floor(double);
+extern double ceil(double);
+extern double trunc(double);
+extern double nearbyint(double);
+
+extern float rintf(float);
+extern long int lrintf(float);
+extern long long int llrintf(float);
+extern float floorf(float);
+extern float ceilf(float);
+extern float truncf(float);
+extern float nearbyintf(float);
+
+extern long double rintl(long double);
+extern long int lrintl(long double);
+extern long long int llrintl(long double);
+extern long double floorl(long double);
+extern long double ceill(long double);
+extern long double truncl(long double);
+extern long double nearbyintl(long double);
+
+
+double test1(double x)
+{
+  return rint(x);
+}
+
+long int test11(double x)
+{
+  return lrint(x);
+}
+
+long long int test12(double x)
+{
+  return llrint(x);
+}
+
+double test2(double x)
+{
+  return floor(x);
+}
+
+double test3(double x)
+{
+  return ceil(x);
+}
+
+double test4(double x)
+{
+  return trunc(x);
+}
+
+double test5(double x)
+{
+  return nearbyint(x);
+}
+
+float test1f(float x)
+{
+  return rintf(x);
+}
+
+long int test11f(float x)
+{
+  return lrintf(x);
+}
+
+long long int test12f(float x)
+{
+  return llrintf(x);
+}
+
+float test2f(float x)
+{
+  return floorf(x);
+}
+
+float test3f(float x)
+{
+  return ceilf(x);
+}
+
+float test4f(float x)
+{
+  return truncf(x);
+}
+
+float test5f(float x)
+{
+  return nearbyintf(x);
+}
+
+long double test1l(long double x)
+{
+  return rintl(x);
+}
+
+long int test11l(long double x)
+{
+  return lrintl(x);
+}
+
+long long int test12l(long double x)
+{
+  return llrintl(x);
+}
+
+long double test2l(long double x)
+{
+  return floorl(x);
+}
+
+long double test3l(long double x)
+{
+  return ceill(x);
+}
+
+long double test4l(long double x)
+{
+  return truncl(x);
+}
+
+long double test5l(long double x)
+{
+  return nearbyintl(x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-47.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-47.c
new file mode 100644
index 000000000..b25ee1b99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-47.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-options "-ffast-math -fdump-tree-gimple" } */
+
+extern double sqrt (double);
+extern double pow (double, double);
+extern void abort (void);
+
+int main ()
+{
+  double x = -1.0;
+  if (sqrt (pow (x, 2)) != 1.0)
+    abort();
+  if (sqrt (x*x) != 1.0)
+    abort();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "sqrt" 0 "gimple" } } */
+/* { dg-final { scan-tree-dump-times "pow" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-48.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-48.c
new file mode 100644
index 000000000..43710b868
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-48.c
@@ -0,0 +1,181 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern double fabs(double);
+extern float fabsf(float);
+extern void abort(void);
+
+
+double test1(double x)
+{
+  return (-x)*(-x);
+}
+
+float test1f(float x)
+{
+  return (-x)*(-x);
+}
+
+double test2(double x)
+{
+  return fabs(x)*fabs(x);
+}
+
+float test2f(float x)
+{
+  return fabsf(x)*fabsf(x);
+}
+
+double test3(double x, double y)
+{
+  return (x*-y)*(x*-y);
+}
+
+float test3f(float x, float y)
+{
+  return (x*-y)*(x*-y);
+}
+
+double test4(double x, double y)
+{
+  return (x/-y)*(x/-y);
+}
+
+float test4f(float x, float y)
+{
+  return (x/-y)*(x/-y);
+}
+
+int main()
+{
+  if (test1(1.0) != 1.0)
+    abort();
+  if (test1(2.0) != 4.0)
+    abort();
+  if (test1(0.0) != 0.0)
+    abort();
+  if (test1(-1.0) != 1.0)
+    abort();
+  if (test1(-2.0) != 4.0)
+    abort();
+
+  if (test1f(1.0f) != 1.0f)
+    abort();
+  if (test1f(2.0f) != 4.0f)
+    abort();
+  if (test1f(0.0f) != 0.0f)
+    abort();
+  if (test1f(-1.0f) != 1.0f)
+    abort();
+  if (test1f(-2.0f) != 4.0f)
+    abort();
+
+  if (test2(1.0) != 1.0)
+    abort();
+  if (test2(2.0) != 4.0)
+    abort();
+  if (test2(0.0) != 0.0)
+    abort();
+  if (test2(-1.0) != 1.0)
+    abort();
+  if (test2(-2.0) != 4.0)
+    abort();
+
+  if (test2f(1.0f) != 1.0f)
+    abort();
+  if (test2f(2.0f) != 4.0f)
+    abort();
+  if (test2f(0.0f) != 0.0f)
+    abort();
+  if (test2f(-1.0f) != 1.0f)
+    abort();
+  if (test2f(-2.0f) != 4.0f)
+    abort();
+
+  if (test3(1.0,1.0) != 1.0)
+    abort();
+  if (test3(1.0,-1.0) != 1.0)
+    abort();
+  if (test3(1.0,2.0) != 4.0)
+    abort();
+  if (test3(1.0,-2.0) != 4.0)
+    abort();
+  if (test3(2.0,1.0) != 4.0)
+    abort();
+  if (test3(2.0,-1.0) != 4.0)
+    abort();
+  if (test3(2.0,2.0) != 16.0)
+    abort();
+  if (test3(2.0,-2.0) != 16.0)
+    abort();
+  if (test3(-2.0,1.0) != 4.0)
+    abort();
+  if (test3(-2.0,-1.0) != 4.0)
+    abort();
+  if (test3(-2.0,2.0) != 16.0)
+    abort();
+  if (test3(-2.0,-2.0) != 16.0)
+    abort();
+
+  if (test3f(1.0f,1.0f) != 1.0f)
+    abort();
+  if (test3f(1.0f,-1.0f) != 1.0f)
+    abort();
+  if (test3f(1.0f,2.0f) != 4.0f)
+    abort();
+  if (test3f(1.0f,-2.0f) != 4.0f)
+    abort();
+  if (test3f(2.0f,1.0f) != 4.0f)
+    abort();
+  if (test3f(2.0f,-1.0f) != 4.0f)
+    abort();
+  if (test3f(2.0f,2.0f) != 16.0f)
+    abort();
+  if (test3f(2.0f,-2.0f) != 16.0f)
+    abort();
+  if (test3f(-2.0f,1.0f) != 4.0f)
+    abort();
+  if (test3f(-2.0f,-1.0f) != 4.0f)
+    abort();
+  if (test3f(-2.0f,2.0f) != 16.0f)
+    abort();
+  if (test3f(-2.0f,-2.0f) != 16.0f)
+    abort();
+
+  if (test4(1.0,1.0) != 1.0)
+    abort();
+  if (test4(1.0,-1.0) != 1.0)
+    abort();
+  if (test4(-1.0,1.0) != 1.0)
+    abort();
+  if (test4(-1.0,-1.0) != 1.0)
+    abort();
+  if (test4(6.0,3.0) != 4.0)
+    abort();
+  if (test4(6.0,-3.0) != 4.0)
+    abort();
+  if (test4(-6.0,3.0) != 4.0)
+    abort();
+  if (test4(-6.0,-3.0) != 4.0)
+    abort();
+
+  if (test4f(1.0f,1.0f) != 1.0f)
+    abort();
+  if (test4f(1.0f,-1.0f) != 1.0f)
+    abort();
+  if (test4f(-1.0f,1.0f) != 1.0f)
+    abort();
+  if (test4f(-1.0f,-1.0f) != 1.0f)
+    abort();
+  if (test4f(6.0f,3.0f) != 4.0f)
+    abort();
+  if (test4f(6.0f,-3.0f) != 4.0f)
+    abort();
+  if (test4f(-6.0f,3.0f) != 4.0f)
+    abort();
+  if (test4f(-6.0f,-3.0f) != 4.0f)
+    abort();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-49.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-49.c
new file mode 100644
index 000000000..fdeaad467
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-49.c
@@ -0,0 +1,181 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern double fabs(double);
+extern float fabsf(float);
+extern void abort(void);
+
+
+double test1(double x)
+{
+  return fabs(-x);
+}
+
+float test1f(float x)
+{
+  return fabsf(-x);
+}
+
+double test2(double x)
+{
+  return fabs(fabs(x));
+}
+
+float test2f(float x)
+{
+  return fabsf(fabsf(x));
+}
+
+double test3(double x, double y)
+{
+  return fabs(x*-y);
+}
+
+float test3f(float x, float y)
+{
+  return fabsf(x*-y);
+}
+
+double test4(double x, double y)
+{
+  return fabs(x/-y);
+}
+
+float test4f(float x, float y)
+{
+  return fabsf(x/-y);
+}
+
+int main()
+{
+  if (test1(1.0) != 1.0)
+    abort();
+  if (test1(2.0) != 2.0)
+    abort();
+  if (test1(0.0) != 0.0)
+    abort();
+  if (test1(-1.0) != 1.0)
+    abort();
+  if (test1(-2.0) != 2.0)
+    abort();
+
+  if (test1f(1.0f) != 1.0f)
+    abort();
+  if (test1f(2.0f) != 2.0f)
+    abort();
+  if (test1f(0.0f) != 0.0f)
+    abort();
+  if (test1f(-1.0f) != 1.0f)
+    abort();
+  if (test1f(-2.0f) != 2.0f)
+    abort();
+
+  if (test2(1.0) != 1.0)
+    abort();
+  if (test2(2.0) != 2.0)
+    abort();
+  if (test2(0.0) != 0.0)
+    abort();
+  if (test2(-1.0) != 1.0)
+    abort();
+  if (test2(-2.0) != 2.0)
+    abort();
+
+  if (test2f(1.0f) != 1.0f)
+    abort();
+  if (test2f(2.0f) != 2.0f)
+    abort();
+  if (test2f(0.0f) != 0.0f)
+    abort();
+  if (test2f(-1.0f) != 1.0f)
+    abort();
+  if (test2f(-2.0f) != 2.0f)
+    abort();
+
+  if (test3(1.0,1.0) != 1.0)
+    abort();
+  if (test3(1.0,-1.0) != 1.0)
+    abort();
+  if (test3(1.0,2.0) != 2.0)
+    abort();
+  if (test3(1.0,-2.0) != 2.0)
+    abort();
+  if (test3(2.0,1.0) != 2.0)
+    abort();
+  if (test3(2.0,-1.0) != 2.0)
+    abort();
+  if (test3(2.0,2.0) != 4.0)
+    abort();
+  if (test3(2.0,-2.0) != 4.0)
+    abort();
+  if (test3(-2.0,1.0) != 2.0)
+    abort();
+  if (test3(-2.0,-1.0) != 2.0)
+    abort();
+  if (test3(-2.0,2.0) != 4.0)
+    abort();
+  if (test3(-2.0,-2.0) != 4.0)
+    abort();
+
+  if (test3f(1.0f,1.0f) != 1.0f)
+    abort();
+  if (test3f(1.0f,-1.0f) != 1.0f)
+    abort();
+  if (test3f(1.0f,2.0f) != 2.0f)
+    abort();
+  if (test3f(1.0f,-2.0f) != 2.0f)
+    abort();
+  if (test3f(2.0f,1.0f) != 2.0f)
+    abort();
+  if (test3f(2.0f,-1.0f) != 2.0f)
+    abort();
+  if (test3f(2.0f,2.0f) != 4.0f)
+    abort();
+  if (test3f(2.0f,-2.0f) != 4.0f)
+    abort();
+  if (test3f(-2.0f,1.0f) != 2.0f)
+    abort();
+  if (test3f(-2.0f,-1.0f) != 2.0f)
+    abort();
+  if (test3f(-2.0f,2.0f) != 4.0f)
+    abort();
+  if (test3f(-2.0f,-2.0f) != 4.0f)
+    abort();
+
+  if (test4(1.0,1.0) != 1.0)
+    abort();
+  if (test4(1.0,-1.0) != 1.0)
+    abort();
+  if (test4(-1.0,1.0) != 1.0)
+    abort();
+  if (test4(-1.0,-1.0) != 1.0)
+    abort();
+  if (test4(6.0,3.0) != 2.0)
+    abort();
+  if (test4(6.0,-3.0) != 2.0)
+    abort();
+  if (test4(-6.0,3.0) != 2.0)
+    abort();
+  if (test4(-6.0,-3.0) != 2.0)
+    abort();
+
+  if (test4f(1.0f,1.0f) != 1.0f)
+    abort();
+  if (test4f(1.0f,-1.0f) != 1.0f)
+    abort();
+  if (test4f(-1.0f,1.0f) != 1.0f)
+    abort();
+  if (test4f(-1.0f,-1.0f) != 1.0f)
+    abort();
+  if (test4f(6.0f,3.0f) != 2.0f)
+    abort();
+  if (test4f(6.0f,-3.0f) != 2.0f)
+    abort();
+  if (test4f(-6.0f,3.0f) != 2.0f)
+    abort();
+  if (test4f(-6.0f,-3.0f) != 2.0f)
+    abort();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-50.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-50.c
new file mode 100644
index 000000000..2d32d1ed9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-50.c
@@ -0,0 +1,159 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern double copysign(double,double);
+extern float copysignf(float,float);
+extern double fabs(double);
+extern float fabsf(float);
+extern void abort(void);
+
+
+double test1(double x, double y)
+{
+  return copysign(-x,y);
+}
+
+float test1f(float x, float y)
+{
+  return copysignf(-x,y);
+}
+
+double test2(double x, double y)
+{
+  return copysign(fabs(x),y);
+}
+
+float test2f(float x, float y)
+{
+  return copysignf(fabsf(x),y);
+}
+
+double test3(double x, double y, double z)
+{
+  return copysign(x*-y,z);
+}
+
+float test3f(float x, float y, float z)
+{
+  return copysignf(x*-y,z);
+}
+
+double test4(double x, double y, double z)
+{
+  return copysign(x/-y,z);
+}
+
+float test4f(float x, float y, float z)
+{
+  return copysignf(x/-y,z);
+}
+
+int main()
+{
+  if (test1(3.0,2.0) != 3.0)
+    abort();
+  if (test1(3.0,-2.0) != -3.0)
+    abort();
+  if (test1(-3.0,2.0) != 3.0)
+    abort();
+  if (test1(-3.0,-2.0) != -3.0)
+    abort();
+
+  if (test1f(3.0f,2.0f) != 3.0f)
+    abort();
+  if (test1f(3.0f,-2.0f) != -3.0f)
+    abort();
+  if (test1f(-3.0f,2.0f) != 3.0f)
+    abort();
+  if (test1f(-3.0f,-2.0f) != -3.0f)
+    abort();
+
+  if (test2(3.0,2.0) != 3.0)
+    abort();
+  if (test2(3.0,-2.0) != -3.0)
+    abort();
+  if (test2(-3.0,2.0) != 3.0)
+    abort();
+  if (test2(-3.0,-2.0) != -3.0)
+    abort();
+
+  if (test2f(3.0f,2.0f) != 3.0f)
+    abort();
+  if (test2f(3.0f,-2.0f) != -3.0f)
+    abort();
+  if (test2f(-3.0f,2.0f) != 3.0f)
+    abort();
+  if (test2f(-3.0f,-2.0f) != -3.0f)
+    abort();
+
+  if (test3(2.0,3.0,4.0) != 6.0)
+    abort();
+  if (test3(2.0,3.0,-4.0) != -6.0)
+    abort();
+  if (test3(2.0,-3.0,4.0) != 6.0)
+    abort();
+  if (test3(2.0,-3.0,-4.0) != -6.0)
+    abort();
+  if (test3(-2.0,3.0,4.0) != 6.0)
+    abort();
+  if (test3(-2.0,3.0,-4.0) != -6.0)
+    abort();
+  if (test3(-2.0,-3.0,4.0) != 6.0)
+    abort();
+  if (test3(-2.0,-3.0,-4.0) != -6.0)
+    abort();
+
+  if (test3f(2.0f,3.0f,4.0f) != 6.0f)
+    abort();
+  if (test3f(2.0f,3.0f,-4.0f) != -6.0f)
+    abort();
+  if (test3f(2.0f,-3.0f,4.0f) != 6.0f)
+    abort();
+  if (test3f(2.0f,-3.0f,-4.0f) != -6.0f)
+    abort();
+  if (test3f(-2.0f,3.0f,4.0f) != 6.0f)
+    abort();
+  if (test3f(-2.0f,3.0f,-4.0f) != -6.0f)
+    abort();
+  if (test3f(-2.0f,-3.0f,4.0f) != 6.0f)
+    abort();
+  if (test3f(-2.0f,-3.0f,-4.0f) != -6.0f)
+    abort();
+
+  if (test4(8.0,2.0,3.0) != 4.0)
+    abort();
+  if (test4(8.0,2.0,-3.0) != -4.0)
+    abort();
+  if (test4(8.0,-2.0,3.0) != 4.0)
+    abort();
+  if (test4(8.0,-2.0,-3.0) != -4.0)
+    abort();
+  if (test4(-8.0,2.0,3.0) != 4.0)
+    abort();
+  if (test4(-8.0,2.0,-3.0) != -4.0)
+    abort();
+  if (test4(-8.0,-2.0,3.0) != 4.0)
+    abort();
+  if (test4(-8.0,-2.0,-3.0) != -4.0)
+    abort();
+
+  if (test4f(8.0f,2.0f,3.0f) != 4.0f)
+    abort();
+  if (test4f(8.0f,2.0f,-3.0f) != -4.0f)
+    abort();
+  if (test4f(8.0f,-2.0f,3.0f) != 4.0f)
+    abort();
+  if (test4f(8.0f,-2.0f,-3.0f) != -4.0f)
+    abort();
+  if (test4f(-8.0f,2.0f,3.0f) != 4.0f)
+    abort();
+  if (test4f(-8.0f,2.0f,-3.0f) != -4.0f)
+    abort();
+  if (test4f(-8.0f,-2.0f,3.0f) != 4.0f)
+    abort();
+  if (test4f(-8.0f,-2.0f,-3.0f) != -4.0f)
+    abort();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-51.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-51.c
new file mode 100644
index 000000000..fdfc9bec7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-51.c
@@ -0,0 +1,157 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double pow(double, double);
+extern double fabs(double);
+extern void abort(void);
+
+double test2_1(double x)
+{
+  return pow(x,2.0);
+}
+
+double test2_2(double x)
+{
+  return pow(-x,2.0);
+}
+
+double test2_3(double x)
+{
+  return pow(fabs(x),2.0);
+}
+
+double test3_1(double x)
+{
+  return pow(x,3.0);
+}
+
+double test3_2(double x)
+{
+  return pow(-x,3.0);
+}
+
+double test3_3(double x)
+{
+  return pow(fabs(x),3.0);
+}
+
+double test6_1(double x)
+{
+  return pow(x,6.0);
+}
+
+double test6_2(double x)
+{
+  return pow(-x,6.0);
+}
+
+double test6_3(double x)
+{
+  return pow(fabs(x),6.0);
+}
+
+
+int main()
+{
+  if (test2_1(1.0) != 1.0)
+    abort();
+  if (test2_1(2.0) != 4.0)
+    abort();
+  if (test2_1(0.0) != 0.0)
+    abort();
+  if (test2_1(-1.0) != 1.0)
+    abort();
+  if (test2_1(-2.0) != 4.0)
+    abort();
+
+  if (test2_2(1.0) != 1.0)
+    abort();
+  if (test2_2(2.0) != 4.0)
+    abort();
+  if (test2_2(0.0) != 0.0)
+    abort();
+  if (test2_2(-1.0) != 1.0)
+    abort();
+  if (test2_2(-2.0) != 4.0)
+    abort();
+
+  if (test2_3(1.0) != 1.0)
+    abort();
+  if (test2_3(2.0) != 4.0)
+    abort();
+  if (test2_3(0.0) != 0.0)
+    abort();
+  if (test2_3(-1.0) != 1.0)
+    abort();
+  if (test2_3(2.0) != 4.0)
+    abort();
+
+  if (test3_1(1.0) != 1.0)
+    abort();
+  if (test3_1(2.0) != 8.0)
+    abort();
+  if (test3_1(0.0) != 0.0)
+    abort();
+  if (test3_1(-1.0) != -1.0)
+    abort();
+  if (test3_1(-2.0) != -8.0)
+    abort();
+
+  if (test3_2(1.0) != -1.0)
+    abort();
+  if (test3_2(2.0) != -8.0)
+    abort();
+  if (test3_2(0.0) != -0.0)
+    abort();
+  if (test3_2(-1.0) != 1.0)
+    abort();
+  if (test3_2(-2.0) != 8.0)
+    abort();
+
+  if (test3_3(1.0) != 1.0)
+    abort();
+  if (test3_3(2.0) != 8.0)
+    abort();
+  if (test3_3(0.0) != 0.0)
+    abort();
+  if (test3_3(-1.0) != 1.0)
+    abort();
+  if (test3_3(-2.0) != 8.0)
+    abort();
+
+  if (test6_1(1.0) != 1.0)
+    abort();
+  if (test6_1(2.0) != 64.0)
+    abort();
+  if (test6_1(0.0) != 0.0)
+    abort();
+  if (test6_1(-1.0) != 1.0)
+    abort();
+  if (test6_1(-2.0) != 64.0)
+    abort();
+
+  if (test6_2(1.0) != 1.0)
+    abort();
+  if (test6_2(2.0) != 64.0)
+    abort();
+  if (test6_2(0.0) != 0.0)
+    abort();
+  if (test6_2(-1.0) != 1.0)
+    abort();
+  if (test6_2(-2.0) != 64.0)
+    abort();
+
+  if (test6_3(1.0) != 1.0)
+    abort();
+  if (test6_3(2.0) != 64.0)
+    abort();
+  if (test6_3(0.0) != 0.0)
+    abort();
+  if (test6_3(-1.0) != 1.0)
+    abort();
+  if (test6_3(-2.0) != 64.0)
+    abort();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-52.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-52.c
new file mode 100644
index 000000000..684fd661d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-52.c
@@ -0,0 +1,23 @@
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+
+extern void link_error(void);
+
+void test(double x, int n)
+{
+  if (__builtin_powi(x,-1.0) != 1.0/x)
+    link_error ();
+  if (__builtin_powi(x,0.0) != 1.0)
+    link_error ();
+  if (__builtin_powi(x,1.0) != x)
+    link_error ();
+  if (__builtin_powi(1.0,n) != 1.0)
+    link_error ();
+}
+
+int main()
+{
+  test(7.3, 2);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-53.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-53.c
new file mode 100644
index 000000000..9a50bf5ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-53.c
@@ -0,0 +1,122 @@
+/* Copyright (C) 2005 Free Software Foundation.
+
+   Check that (long)floor, (long)floorf, (long)floorl,
+   (long long)floor, (long long)floorf, (long long)floorl,
+   (long)ceil, (long)ceilf, (long)ceill,
+   (long long)ceil, (long long)ceilf, (long long)ceill
+   built-in functions compile.
+
+   Written by Uros Bizjak, 5th April 2005.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "builtins-config.h"
+
+extern double floor(double);
+extern double ceil(double);
+extern double trunc(double);
+
+extern float floorf(float);
+extern float ceilf(float);
+extern float truncf(float);
+
+extern long double floorl(long double);
+extern long double ceill(long double);
+extern long double truncl(long double);
+
+
+long int test1(double x)
+{
+  return floor(x);
+}
+
+long long int test2(double x)
+{
+  return floor(x);
+}
+
+long int test3(double x)
+{
+  return ceil(x);
+}
+
+long long int test4(double x)
+{
+  return ceil(x);
+}
+
+long int test5(double x)
+{
+  return trunc(x);
+}
+
+long long int test6(double x)
+{
+  return trunc(x);
+}
+
+#ifdef HAVE_C99_RUNTIME
+long int test1f(float x)
+{
+  return floorf(x);
+}
+
+long long int test2f(float x)
+{
+  return floorf(x);
+}
+
+long int test3f(float x)
+{
+  return ceilf(x);
+}
+
+long long int test4f(float x)
+{
+  return ceilf(x);
+}
+#endif
+
+long int test5f(float x)
+{
+  return truncf(x);
+}
+
+long long int test6f(float x)
+{
+  return truncf(x);
+}
+
+#ifdef HAVE_C99_RUNTIME
+long int test1l(long double x)
+{
+  return floorl(x);
+}
+
+long long int test2l(long double x)
+{
+  return floorl(x);
+}
+
+long int test3l(long double x)
+{
+  return ceill(x);
+}
+
+long long int test4l(long double x)
+{
+  return ceill(x);
+}
+#endif
+
+long int test5l(long double x)
+{
+  return truncl(x);
+}
+
+long long int test6l(long double x)
+{
+  return truncl(x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-54.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-54.c
new file mode 100644
index 000000000..2713a3b1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-54.c
@@ -0,0 +1,146 @@
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double fabs(double);
+float fabsf(float);
+long double fabsl(long double);
+double cabs(__complex__ double);
+float cabsf(__complex__ float);
+long double cabsl(__complex__ long double);
+
+void link_error (void);
+
+void test(__complex__ double x, double a, double b)
+{
+  if (cabs(x) != cabs(-x))
+    link_error();
+
+  if (cabs(x) != cabs(~x))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (a+a*1i))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (a*1i+a))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (-a+a*-1i))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (-a+-a*1i))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (-a-a*1i))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (a*-1i-a))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (-a*1i-a))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (a*-1i+-a))
+    link_error();
+
+  if (fabs(a) * __builtin_sqrt(2) != cabs (-a*1i+-a))
+    link_error();
+
+  if (fabs(a*b) * __builtin_sqrt(2) != cabs (a*b-(-b*a*1i)))
+    link_error();
+
+  if (fabs(a*b) * __builtin_sqrt(2) != cabs (a*b*1i-a*-b))
+    link_error();
+}
+
+void testf(__complex__ float x, float a, float b)
+{
+  if (cabsf(x) != cabsf(-x))
+    link_error();
+
+  if (cabsf(x) != cabsf(~x))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (a+a*1i))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (a*1i+a))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (-a+a*-1i))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (-a+-a*1i))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (-a-a*1i))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (a*-1i-a))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (-a*1i-a))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (a*-1i+-a))
+    link_error();
+
+  if (fabsf(a) * __builtin_sqrtf(2) != cabsf (-a*1i+-a))
+    link_error();
+
+  if (fabsf(a*b) * __builtin_sqrtf(2) != cabsf (a*b-(-b*a*1i)))
+    link_error();
+
+  if (fabsf(a*b) * __builtin_sqrtf(2) != cabsf (a*b*1i-a*-b))
+    link_error();
+}
+
+void testl(__complex__ long double x, long double a, long double b)
+{
+  if (cabsl(x) != cabsl(-x))
+    link_error();
+
+  if (cabsl(x) != cabsl(~x))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (a+a*1i))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (a*1i+a))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (-a+a*-1i))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (-a+-a*1i))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (-a-a*1i))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (a*-1i-a))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (-a*1i-a))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (a*-1i+-a))
+    link_error();
+
+  if (fabsl(a) * __builtin_sqrtl(2) != cabsl (-a*1i+-a))
+    link_error();
+
+  if (fabsl(a*b) * __builtin_sqrtl(2) != cabsl (a*b-(-b*a*1i)))
+    link_error();
+
+  if (fabsl(a*b) * __builtin_sqrtl(2) != cabsl (a*b*1i-a*-b))
+    link_error();
+}
+
+int main()
+{
+  test(0, 0, 0);
+  testf(0, 0, 0);
+  testl(0, 0, 0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-55.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-55.c
new file mode 100644
index 000000000..0db7976a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-55.c
@@ -0,0 +1,86 @@
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "builtins-config.h"
+
+void link_error (void);
+
+extern long lround(double);
+extern long lrint(double);
+
+extern long long llround(double);
+extern long long llrint(double);
+
+extern long lroundf(float);
+extern long lrintf(float);
+
+extern long long llroundf(float);
+extern long long llrintf(float);
+
+extern long lroundl(long double);
+extern long lrintl(long double);
+
+extern long long llroundl(long double);
+extern long long llrintl(long double);
+
+
+void test(double x)
+{
+#ifdef HAVE_C99_RUNTIME
+  if (sizeof(long) != sizeof(long long))
+    return;
+
+  if (__builtin_lceil(x) != __builtin_llceil(x))
+    link_error();
+  if (__builtin_lfloor(x) != __builtin_llfloor(x))
+    link_error();
+  if (lround(x) != llround(x))
+    link_error();
+  if (lrint(x) != llrint(x))
+    link_error();
+#endif
+}
+
+void testf(float x)
+{
+#ifdef HAVE_C99_RUNTIME
+  if (sizeof(long) != sizeof(long long))
+    return;
+
+  if (__builtin_lceilf(x) != __builtin_llceilf(x))
+    link_error();
+  if (__builtin_lfloorf(x) != __builtin_llfloorf(x))
+    link_error();
+  if (lroundf(x) != llroundf(x))
+    link_error();
+  if (lrintf(x) != llrintf(x))
+    link_error();
+#endif
+}
+
+void testl(long double x)
+{
+#ifdef HAVE_C99_RUNTIME
+  if (sizeof(long) != sizeof(long long))
+    return;
+
+  if (__builtin_lceill(x) != __builtin_llceill(x))
+    link_error();
+  if (__builtin_lfloorl(x) != __builtin_llfloorl(x))
+    link_error();
+  if (lroundl(x) != llroundl(x))
+    link_error();
+  if (lrintl(x) != llrintl(x))
+    link_error();
+#endif
+}
+
+int main()
+{
+  test(0.0);
+  testf(0.0);
+  testl(0.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-57.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-57.c
new file mode 100644
index 000000000..361826cb0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-57.c
@@ -0,0 +1,25 @@
+/* { dg-do link } */
+/* { dg-options "-std=c99 -ffinite-math-only" } */
+
+#include "builtins-config.h"
+
+extern void link_error (void);
+
+extern double floor (double);
+extern double trunc (double);
+extern double fabs (double);
+
+void test (double x)
+{
+#ifdef HAVE_C99_RUNTIME
+  if (floor (fabs (x)) != trunc (fabs (x)))
+    link_error ();
+#endif
+  if (__builtin_lfloor (fabs (x)) != (long)fabs (x))
+    link_error ();
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-58.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-58.c
new file mode 100644
index 000000000..cf5a9c2f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-58.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math -std=c99" } */
+
+#include "builtins-config.h"
+
+#ifdef HAVE_C99_RUNTIME
+double test1 (double x)
+{
+  return __builtin_pow (x, 1./3.);
+}
+
+double test2 (double x)
+{
+  return __builtin_pow (x, 4./3.);
+}
+
+double test3a (double x)
+{
+  return __builtin_pow (x, 5./3.);
+}
+
+double test3b (double x)
+{
+  return __builtin_pow (x, -5./3.);
+}
+
+double test4 (double x)
+{
+  return __builtin_pow (x, 7./3.);
+}
+#endif
+
+/* { dg-final { scan-assembler-not "pow" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-59.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-59.c
new file mode 100644
index 000000000..b940d39ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-59.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+/* { dg-require-effective-target c99_runtime } */
+
+double test (double x)
+{
+  double s, c;
+  __builtin_sincos (x, &s, &c);
+  return s + c;
+}
+
+/* { dg-final { scan-tree-dump "__builtin_cexpi" "gimple" } } */
+/* { dg-final { scan-tree-dump-not "sincos" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-6.c
new file mode 100644
index 000000000..2ebb0b2d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-6.c
@@ -0,0 +1,80 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that constant folding comparisons against built-in math functions
+   don't cause any problems for the compiler, and produce expected results.
+
+   Written by Roger Sayle, 15th March 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+#include <float.h>
+
+extern void abort (void);
+extern double sqrt (double);
+
+int test1(double x)
+{
+  return sqrt(x) < -9.0;
+}
+
+int test2(double x)
+{
+  return sqrt(x) > -9.0;
+}
+
+int test3(double x)
+{
+  return sqrt(x) < 9.0;
+}
+
+int test4(double x)
+{
+  return sqrt(x) > 9.0;
+}
+
+int test5(double x)
+{
+  return sqrt(x) < DBL_MAX;
+}
+
+int test6(double x)
+{
+  return sqrt(x) > DBL_MAX;
+}
+
+int main()
+{
+  double x;
+
+  x = 80.0;
+  if (test1 (x))
+    abort ();
+  if (! test2 (x))
+    abort ();
+  if (! test3 (x))
+    abort ();
+  if (test4 (x))
+    abort ();
+  if (! test5 (x))
+    abort ();
+  if (test6 (x))
+    abort ();
+
+  x = 100.0;
+  if (test1 (x))
+    abort ();
+  if (! test2 (x))
+    abort ();
+  if (test3 (x))
+    abort ();
+  if (! test4 (x))
+    abort ();
+  if (! test5 (x))
+    abort ();
+  if (test6 (x))
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-60.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-60.c
new file mode 100644
index 000000000..b57679f36
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-60.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+double test1 (double x)
+{
+  return __real __builtin_cexpi (x);
+}
+
+double test2 (double x)
+{
+  return __imag __builtin_cexpi (x);
+}
+
+/* { dg-final { scan-tree-dump "cos" "gimple" } } */
+/* { dg-final { scan-tree-dump "sin" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-61.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-61.c
new file mode 100644
index 000000000..dff163ff1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-61.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math -fdump-tree-optimized" } */
+/* { dg-require-effective-target c99_runtime } */
+
+double test1 (double x)
+{
+  return __real __builtin_cexp(x * (__extension__ 1.0iF));
+}
+
+double test2(double x)
+{
+  return __imag __builtin_cexp((__extension__ 1.0iF) * x);
+}
+
+double test3(double x)
+{
+  _Complex c = __builtin_cexp(x * (__extension__ 1.0iF));
+  return __imag c + __real c;
+}
+
+double test4(double x, double y)
+{
+  _Complex c = __builtin_cexp(x);
+  x = __builtin_exp (x);
+  return x - __real c;
+}
+
+/* { dg-final { scan-tree-dump "cexpi" "optimized" } } */
+/* { dg-final { scan-tree-dump "sin" "optimized" } } */
+/* { dg-final { scan-tree-dump "cos" "optimized" } } */
+/* { dg-final { scan-tree-dump "return 0.0" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-62.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-62.c
new file mode 100644
index 000000000..db6269693
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-62.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffinite-math-only -fdump-tree-optimized" } */
+/* { dg-require-effective-target c99_runtime } */
+
+double test1 (double x)
+{
+  double s, c;
+  s = __builtin_sin (x);
+  c = __builtin_cos (x);
+  return s + c;
+}
+
+double test2 (double x)
+{
+  double s, c;
+  x = x * 2;
+  s = __builtin_sin (x);
+  c = __builtin_cos (x);
+  return s + c;
+}
+
+double test3 (double x, int b)
+{
+  double s, c;
+  if (b)
+    x = x * 2;
+  s = __builtin_sin (x);
+  c = __builtin_cos (x);
+  return s + c;
+}
+
+double test4 (double x)
+{
+  double s;
+  x = x * 2;
+  s = __builtin_sin (x);
+  return s;
+}
+
+/* { dg-final { scan-tree-dump-times "cexpi" 3 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-63.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-63.c
new file mode 100644
index 000000000..8fcbc68e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-63.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2007 Free Software Foundation.
+
+   Check that isinf, isinff and isinfl built-in functions compile.
+
+   Written by Uros Bizjak, 31st January 2007.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern int isinf(double);
+extern int isinff(float);
+extern int isinfl(long double);
+
+int test1(double x)
+{
+  return isinf(x);
+}
+
+int test1f(float x)
+{
+  return isinff(x);
+}
+
+int test1l(long double x)
+{
+  return isinfl(x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-64.c
new file mode 100644
index 000000000..6e84633d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-64.c
@@ -0,0 +1,8 @@
+/* { dg-do run } */
+
+int main ()
+{
+  char *mem = __builtin_alloca (40);
+  __builtin___clear_cache (mem, mem + 40);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-66.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-66.c
new file mode 100644
index 000000000..87bea3f42
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-66.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+
+enum { E0 = 0, E1 = 1, E2 = 2 } e;
+
+int
+foo (void)
+{
+  return __builtin_popcount ((int) e);
+}
+
+/* { dg-final { scan-assembler-not "__builtin_popcount" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-7.c
new file mode 100644
index 000000000..13e708e29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-7.c
@@ -0,0 +1,55 @@
+/* Copyright (C) 2003  Free Software Foundation.
+
+   Verify that built-in math function constant folding of constant
+   arguments is correctly performed by the by the compiler.
+
+   Written by Roger Sayle, 30th March 2003.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double pow (double, double);
+extern float powf (float, float);
+extern long double powl (long double, long double);
+extern double tan (double);
+extern float tanf (float);
+extern long double tanl (long double);
+extern double atan (double);
+extern float atanf (float);
+extern long double atanl (long double);
+
+extern void link_error(void);
+
+void test(double x)
+{
+  if (pow (x, 1.0) != x)
+    link_error ();
+  if (tan (atan (x)) != x)
+    link_error ();
+}
+
+void testf(float x)
+{
+  if (powf (x, 1.0f) != x)
+    link_error ();
+  if (tanf (atanf (x)) != x)
+    link_error ();
+}
+
+void testl(long double x)
+{
+  if (powl (x, 1.0l) != x)
+    link_error ();
+  if (tanl (atanl (x)) != x)
+    link_error ();
+}
+
+int main()
+{
+  test (2.0);
+  testf (2.0f);
+  testl (2.0l);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-8.c
new file mode 100644
index 000000000..95c17e72f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-8.c
@@ -0,0 +1,42 @@
+/* Copyright (C) 2003, 2006  Free Software Foundation.
+
+   Verify that built-in math function constant folding of functions
+   with one constant argument is correctly performed by the compiler.
+
+   Written by Roger Sayle, 30th March 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void abort(void);
+extern double pow(double, double);
+extern double sqrt(double);
+extern double cbrt(double);
+
+void test(double x)
+{
+  if (pow(x,-1.0) != 1.0/x)
+    abort ();
+
+  if (pow(x,2.0) != x*x)
+    abort ();
+
+  if (pow(x,-2.0) != 1.0/(x*x))
+    abort ();
+
+  if (pow(x,0.5) != sqrt(x))
+    abort ();
+
+#ifdef HAVE_C99_RUNTIME
+  if (pow(x,1.0/3.0) != cbrt(x))
+    abort ();
+#endif
+}
+
+int main()
+{
+  test (1.0);
+  test (2.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-9.c
new file mode 100644
index 000000000..108e0d2f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-9.c
@@ -0,0 +1,103 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Check that constant folding of built-in math functions doesn't
+   break anything.
+
+   Written by Roger Sayle, 2nd April 2003.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern double log(double);
+extern double exp(double);
+extern double sqrt(double);
+extern double pow(double,double);
+
+extern float logf(float);
+extern float expf(float);
+extern float sqrtf(float);
+extern float powf(float,float);
+
+extern long double logl(long double);
+extern long double expl(long double);
+extern long double sqrtl(long double);
+extern long double powl(long double,long double);
+
+
+double test1(double x, double y)
+{
+  return log(pow(x,y));
+}
+
+double test2(double x, double y)
+{
+  return sqrt(pow(x,y));
+}
+
+double test3(double x, double y)
+{
+  return pow(exp(x),y);
+}
+
+double test4(double x, double y)
+{
+  return pow(sqrt(x),y);
+}
+
+double test5(double x, double y, double z)
+{
+  return pow(pow(x,y),z);
+}
+
+
+float test1f(float x, float y)
+{
+  return logf(powf(x,y));
+}
+
+float test2f(float x, float y)
+{
+  return sqrtf(powf(x,y));
+}
+
+float test3f(float x, float y)
+{
+  return powf(expf(x),y);
+}
+
+float test4f(float x, float y)
+{
+  return powf(sqrtf(x),y);
+}
+
+float test5f(float x, float y, float z)
+{
+  return powf(powf(x,y),z);
+}
+
+
+long double test1l(long double x, long double y)
+{
+  return logl(powl(x,y));
+}
+
+long double test2l(long double x, long double y)
+{
+  return sqrtl(powl(x,y));
+}
+
+long double test3l(long double x, long double y)
+{
+  return powl(expl(x),y);
+}
+
+long double test4l(long double x, long double y)
+{
+  return powl(sqrtl(x),y);
+}
+
+long double test5l(long double x, long double y, long double z)
+{
+  return powl(powl(x,y),z);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-config.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-config.h
new file mode 100644
index 000000000..eacc09dcf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-config.h
@@ -0,0 +1,61 @@
+/* Copyright (C) 2003, 2004, 2005, 2006, 2009 Free Software Foundation.
+
+   Define macros useful in tests for bulitin functions.  */
+
+/* Define HAVE_C99_RUNTIME if the entire C99 runtime is available on
+   the target system.  The value of HAVE_C99_RUNTIME should be the
+   same as the value of TARGET_C99_FUNCTIONS in the GCC machine
+   description.  (Perhaps GCC should predefine a special macro
+   indicating whether or not TARGET_C99_FUNCTIONS is set, but it does
+   not presently do that.)  */
+
+#if defined(__hppa) && defined(__hpux)
+/* PA HP-UX doesn't have the entire C99 runtime.  */
+#elif defined(__sgi)
+/* Irix6 doesn't have the entire C99 runtime.  */
+#elif defined(__AVR__)
+/* AVR doesn't have the entire C99 runtime.  */
+#elif defined(__FreeBSD__)
+/* FreeBSD up to at least version 8 lacks support for cexp and friends.  */
+#elif defined(__netware__)
+/* NetWare doesn't have the entire C99 runtime.  */
+#elif defined(__vxworks)
+/* VxWorks doesn't have a full C99 time.  (cabs is missing, for example.)  */
+#elif defined(_WIN32) && !defined(__CYGWIN__)
+/* Windows doesn't have the entire C99 runtime.  */
+#elif (defined(__APPLE__) && defined(__ppc__) \
+       && ! defined (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__))
+/* MacOS versions before 10.3 don't have many C99 functions.  
+   But, if you're including this file, you probably want to test the
+   newer behaviour, so: */
+#error forgot to set -mmacosx-version-min.
+#elif (defined(__APPLE__) && defined(__ppc__) \
+       && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1030)
+/* MacOS versions before 10.3 don't have many C99 functions.  */
+#else
+/* Newlib has the "f" variants of the math functions, but not the "l"
+   variants.  TARGET_C99_FUNCTIONS is only defined if all C99
+   functions are present.  Therefore, on systems using newlib, tests
+   of builtins will fail the "l" variants, and we should therefore not
+   define HAVE_C99_RUNTIME.  Including <sys/types.h> gives us a way of
+   seeing if _NEWLIB_VERSION is defined.  Including <math.h> would work
+   too, but the GLIBC math inlines cause us to generate inferior code,
+   which causes the test to fail, so it is not safe.  Including <limits.h>
+   also fails because the include search paths are ordered such that GCC's
+   version will be found before the newlib version.  Similarly, uClibc
+   lacks the C99 functions.  */
+#include <sys/types.h>
+#if defined(_NEWLIB_VERSION) || defined(__UCLIBC__)
+#elif defined(__sun) && __STDC_VERSION__ - 0 < 199901L
+/* If you're including this file, you probably want to test the newer
+   behaviour, so ensure the right flags were used for each test: */
+#error forgot to set -std=c99.
+#elif defined(__sun) && ! defined (_STDC_C99)
+/* Solaris up to 9 doesn't have the entire C99 runtime.
+   Solaris 10 defines _STDC_C99 if __STDC_VERSION__ is >= 199901L.
+   This macro is defined in <sys/feature_tests.h> which is included by
+   various system headers, in this case <sys/types.h> above.  */
+#else
+#define HAVE_C99_RUNTIME
+#endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-error.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-error.c
new file mode 100644
index 000000000..0f41700ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/builtins-error.c
@@ -0,0 +1,65 @@
+/* { dg-do compile } */
+
+struct X { int x; };
+
+int test1(struct X x)
+{
+  if (x.x ==  1) return __builtin_fpclassify(1,2,3,4,5,x); /* { dg-error "non-floating-point argument" } */
+  if (x.x ==  2) return __builtin_isfinite(x); /* { dg-error "non-floating-point argument" } */
+  if (x.x ==  3) return __builtin_isinf_sign(x); /* { dg-error "non-floating-point argument" } */
+  if (x.x ==  4) return __builtin_isinf(x); /* { dg-error "non-floating-point argument" } */
+  if (x.x ==  5) return __builtin_isnan(x); /* { dg-error "non-floating-point argument" } */
+  if (x.x ==  6) return __builtin_isnormal(x); /* { dg-error "non-floating-point argument" } */
+  if (x.x ==  7) return __builtin_isgreater(x, x); /* { dg-error "non-floating-point arguments" } */
+  if (x.x ==  8) return __builtin_isgreaterequal(x, x); /* { dg-error "non-floating-point arguments" } */
+  if (x.x ==  9) return __builtin_isless(x, x); /* { dg-error "non-floating-point arguments" } */
+  if (x.x == 10) return __builtin_islessequal(x, x); /* { dg-error "non-floating-point arguments" } */
+  if (x.x == 11) return __builtin_islessgreater(x, x); /* { dg-error "non-floating-point arguments" } */
+  if (x.x == 12) return __builtin_isunordered(x, x); /* { dg-error "non-floating-point arguments" } */
+
+  return 0;
+}
+
+int test2(double x)
+{
+  if (x ==  1) return __builtin_fpclassify(1,2,3,4,5); /* { dg-error "not enough arguments" } */
+  if (x ==  2) return __builtin_isfinite(); /* { dg-error "not enough arguments" } */
+  if (x ==  3) return __builtin_isinf_sign(); /* { dg-error "not enough arguments" } */
+  if (x ==  4) return __builtin_isinf(); /* { dg-error "not enough arguments" } */
+  if (x ==  5) return __builtin_isnan(); /* { dg-error "not enough arguments" } */
+  if (x ==  6) return __builtin_isnormal(); /* { dg-error "not enough arguments" } */
+  if (x ==  7) return __builtin_isgreater(x); /* { dg-error "not enough arguments" } */
+  if (x ==  8) return __builtin_isgreaterequal(x); /* { dg-error "not enough arguments" } */
+  if (x ==  9) return __builtin_isless(x); /* { dg-error "not enough arguments" } */
+  if (x == 10) return __builtin_islessequal(x); /* { dg-error "not enough arguments" } */
+  if (x == 11) return __builtin_islessgreater(x); /* { dg-error "not enough arguments" } */
+  if (x == 12) return __builtin_isunordered(x); /* { dg-error "not enough arguments" } */
+  return 0;
+}
+
+int test3(double x)
+{
+  if (x ==  1) return __builtin_fpclassify(1,2,3,4,5,x,x); /* { dg-error "too many arguments" } */
+  if (x ==  2) return __builtin_isfinite(x, x); /* { dg-error "too many arguments" } */
+  if (x ==  3) return __builtin_isinf_sign(x, x); /* { dg-error "too many arguments" } */
+  if (x ==  4) return __builtin_isinf(x, x); /* { dg-error "too many arguments" } */
+  if (x ==  5) return __builtin_isnan(x, x); /* { dg-error "too many arguments" } */
+  if (x ==  6) return __builtin_isnormal(x, x); /* { dg-error "too many arguments" } */
+  if (x ==  7) return __builtin_isgreater(x, x, x); /* { dg-error "too many arguments" } */
+  if (x ==  8) return __builtin_isgreaterequal(x, x, x); /* { dg-error "too many arguments" } */
+  if (x ==  9) return __builtin_isless(x, x, x); /* { dg-error "too many arguments" } */
+  if (x == 10) return __builtin_islessequal(x, x, x); /* { dg-error "too many arguments" } */
+  if (x == 11) return __builtin_islessgreater(x, x, x); /* { dg-error "too many arguments" } */
+  if (x == 12) return __builtin_isunordered(x, x, x); /* { dg-error "too many arguments" } */
+  return 0;
+}
+
+int test4(int i, double x)
+{
+  if (x ==  1) return __builtin_fpclassify(i,2,3,4,5,x); /* { dg-error "non-const integer argument" } */
+  if (x ==  2) return __builtin_fpclassify(1,i,3,4,5,x); /* { dg-error "non-const integer argument" } */
+  if (x ==  3) return __builtin_fpclassify(1,2,i,4,5,x); /* { dg-error "non-const integer argument" } */
+  if (x ==  4) return __builtin_fpclassify(1,2,3,i,5,x); /* { dg-error "non-const integer argument" } */
+  if (x ==  5) return __builtin_fpclassify(1,2,3,4,i,x); /* { dg-error "non-const integer argument" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-1.c
new file mode 100644
index 000000000..69655c835
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-1.c
@@ -0,0 +1,21 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { char c[1]; };
+
+extern struct s foo (void);
+
+void
+bar (void)
+{
+  char *t;
+  (foo ()).c[0]; /* { dg-bogus "warning" "warning in place of error" } */
+  t = (foo ()).c; /* { dg-bogus "warning" "warning in place of error" } */
+  (foo ()).c + 1; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "non-lvalue" "array not decaying to lvalue" { target *-*-* } 14 }
+   { dg-error "non-lvalue|incompatible" "array not decaying to lvalue" { target *-*-* } 15 }
+   { dg-error "non-lvalue|invalid" "array not decaying to lvalue" { target *-*-* } 16 }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-2.c
new file mode 100644
index 000000000..9f261e05e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-2.c
@@ -0,0 +1,20 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { char c[17]; };
+
+struct s x;
+
+extern struct s foo (void);
+
+#define ASSERT(v, a)	char v[((a) ? 1 : -1)]
+
+ASSERT (p, sizeof (x.c) == 17);
+ASSERT (q, sizeof (0, x.c) == sizeof (char *));
+ASSERT (r, sizeof ((foo ()).c) == 17);
+/* The non-lvalue array does not decay to a pointer, so the comma expression
+   has (non-lvalue) array type.
+*/
+ASSERT (s, sizeof (0, (foo ()).c) == 17); /* { dg-bogus "array" "bad non-lvalue array handling" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-3.c
new file mode 100644
index 000000000..192a05f62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-3.c
@@ -0,0 +1,34 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.
+   Test various ways of producing non-lvalue arrays.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { char c[1]; };
+struct s a, b, c;
+int d;
+
+void
+bar (void)
+{
+  char *t;
+  (d ? b : c).c[0]; /* { dg-bogus "warning" "warning in place of error" } */
+  (d, b).c[0]; /* { dg-bogus "warning" "warning in place of error" } */
+  (a = b).c[0]; /* { dg-bogus "warning" "warning in place of error" } */
+  t = (d ? b : c).c; /* { dg-bogus "warning" "warning in place of error" } */
+  t = (d, b).c; /* { dg-bogus "warning" "warning in place of error" } */
+  t = (a = b).c; /* { dg-bogus "warning" "warning in place of error" } */
+  (d ? b : c).c + 1; /* { dg-bogus "warning" "warning in place of error" } */
+  (d, b).c + 1; /* { dg-bogus "warning" "warning in place of error" } */
+  (a = b).c + 1; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "non-lvalue" "array not decaying to lvalue" { target *-*-* } 15 }
+   { dg-error "non-lvalue" "array not decaying to lvalue" { target *-*-* } 16 }
+   { dg-error "non-lvalue" "array not decaying to lvalue" { target *-*-* } 17 }
+   { dg-error "non-lvalue|incompatible" "array not decaying to lvalue" { target *-*-* } 18 }
+   { dg-error "non-lvalue|incompatible" "array not decaying to lvalue" { target *-*-* } 19 }
+   { dg-error "non-lvalue|incompatible" "array not decaying to lvalue" { target *-*-* } 20 }
+   { dg-error "non-lvalue|invalid" "array not decaying to lvalue" { target *-*-* } 21 }
+   { dg-error "non-lvalue|invalid" "array not decaying to lvalue" { target *-*-* } 22 }
+   { dg-error "non-lvalue|invalid" "array not decaying to lvalue" { target *-*-* } 23 }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-4.c
new file mode 100644
index 000000000..1f9cb1455
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-4.c
@@ -0,0 +1,26 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.
+   Test various ways of producing non-lvalue arrays.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { char c[17]; };
+
+struct s x;
+
+struct s a, b, c;
+int d;
+
+#define ASSERT(v, a)	char v[((a) ? 1 : -1)]
+
+ASSERT (p, sizeof (x.c) == 17);
+ASSERT (q, sizeof (0, x.c) == sizeof (char *));
+ASSERT (r0, sizeof ((d ? b : c).c) == 17);
+ASSERT (r1, sizeof ((d, b).c) == 17);
+ASSERT (r2, sizeof ((a = b).c) == 17);
+/* The non-lvalue array does not decay to a pointer, so the comma expression
+   has (non-lvalue) array type.
+*/
+ASSERT (s0, sizeof (0, (d ? b : c).c) == 17); /* { dg-bogus "array" "bad non-lvalue array handling" } */
+ASSERT (s0, sizeof (0, (d, b).c) == 17); /* { dg-bogus "array" "bad non-lvalue array handling" } */
+ASSERT (s0, sizeof (0, (a = b).c) == 17); /* { dg-bogus "array" "bad non-lvalue array handling" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-5.c
new file mode 100644
index 000000000..c218a4dae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-5.c
@@ -0,0 +1,26 @@
+/* Test for non-lvalue arrays: test that the unary '&' operator is not
+   allowed on them, for both C90 and C99.  */
+
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { char c[1]; };
+
+extern struct s foo (void);
+struct s a, b, c;
+int d;
+
+void
+bar (void)
+{
+  &((foo ()).c); /* { dg-bogus "warning" "warning in place of error" } */
+  &((d ? b : c).c); /* { dg-bogus "warning" "warning in place of error" } */
+  &((d, b).c); /* { dg-bogus "warning" "warning in place of error" } */
+  &((a = b).c); /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "lvalue" "bad address-of" { target *-*-* } 17 }
+   { dg-error "lvalue" "bad address-of" { target *-*-* } 18 }
+   { dg-error "lvalue" "bad address-of" { target *-*-* } 19 }
+   { dg-error "lvalue" "bad address-of" { target *-*-* } 20 }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-6.c
new file mode 100644
index 000000000..f42ef52bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-6.c
@@ -0,0 +1,16 @@
+/* PR c/12446 */
+/* Origin: Keith Thompson <kst@cts.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+
+struct s { char c[1]; };
+
+extern struct s foo(void);
+
+void bar(void)
+{
+  char *ptr = foo().c; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "non-lvalue" "array not decaying to lvalue" { target *-*-* } 14 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-7.c
new file mode 100644
index 000000000..ee8da4c70
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-lval-7.c
@@ -0,0 +1,23 @@
+/* Test for non-lvalue arrays: test that C90 does not allow them in
+   conditional expressions, while in C99 they decay and are
+   allowed.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { char c[1]; };
+struct s a, b, c;
+int d;
+int e;
+
+void
+bar (void)
+{
+  /* In C90, the non-lvalue arrays do not decay to pointers, and
+     6.3.15 does not permit conditional expressions between arrays.
+     In C99, they decay to pointers.  */
+  (e ? (d ? b : c).c : (e ? b : c).c); /* { dg-bogus "warning" "warning in place of error" } */
+}
+
+/* { dg-error "array" "bad conditional" { target *-*-* } 20 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-quals-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-quals-2.c
new file mode 100644
index 000000000..7cb68c846
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-quals-2.c
@@ -0,0 +1,3 @@
+extern const char *const a[];
+extern const char *const a[];
+extern const char *const a[];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-quals.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-quals.c
new file mode 100644
index 000000000..228e79f65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-array-quals.c
@@ -0,0 +1,3 @@
+extern int (*const a)[];
+extern int (*const a)[10];
+extern int (*const a)[];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-arraydecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-arraydecl-1.c
new file mode 100644
index 000000000..2b7eadbf6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-arraydecl-1.c
@@ -0,0 +1,30 @@
+/* Test for C99 forms of array declarator: rejected in C90.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+/* Use of [*] (possibly with type qualifiers) in an array declarator with
+   function prototype scope is a C99 feature.  GCC does not yet implement
+   it correctly, so gives a warning about this. so we can't yet test here
+   that we get just one error and no warnings.  */
+
+void foo0 (int a, int b[*]); /* { dg-error "ISO C90" "\[*\] not in C90" } */
+void foo1 (int, int [*]); /* { dg-error "ISO C90" "\[*\] not in C90" } */
+
+
+/* Use of static and type qualifiers (not allowed with abstract declarators)
+   is a C99 feature.  */
+
+void bar0 (int a[const]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "ISO C90" "\[quals\] not in C90" { target *-*-* } 18 } */
+void bar1 (int a[const 2]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "ISO C90" "\[quals expr\] not in C90" { target *-*-* } 20 } */
+void bar2 (int a[static 2]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "ISO C90" "\[static expr\] not in C90" { target *-*-* } 22 } */
+void bar3 (int a[static const 2]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "ISO C90" "\[static quals expr\] not in C90" { target *-*-* } 24 } */
+void bar4 (int a[const static 2]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "ISO C90" "\[quals static expr\] not in C90" { target *-*-* } 26 } */
+
+/* Because [*] isn't properly implemented and so warns, we don't test here
+   for [const *] yet.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-complex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-complex-1.c
new file mode 100644
index 000000000..b65fc6873
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-complex-1.c
@@ -0,0 +1,7 @@
+/* Test for _Complex: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+_Complex double foo; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "C" "_Complex not in C90" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-complit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-complit-1.c
new file mode 100644
index 000000000..4cd910fa8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-complit-1.c
@@ -0,0 +1,20 @@
+/* Test for compound literals: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct s { int a; int b; };
+union u { int c; int d; };
+
+void
+foo (void)
+{
+  (int) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "compound literal" "scalar" { target *-*-* } 12 } */
+  (struct s) { 1, 2 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "compound literal" "struct" { target *-*-* } 14 } */
+  (union u) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "compound literal" "union" { target *-*-* } 16 } */
+  (int [1]) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "compound literal" "array" { target *-*-* } 18 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-1.c
new file mode 100644
index 000000000..96d19ee81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-1.c
@@ -0,0 +1,23 @@
+/* Test for constraints on constant expressions.  In C90 it is clear that
+   certain constructs are not permitted in unevaluated parts of an
+   expression (except in sizeof); in C99 it might fall within implementation
+   latitude.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>; inspired by
+   http://deja.com/getdoc.xp?AN=524271595&fmt=text by Peter Seebach.
+*/
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+extern int bar (void);
+
+void
+foo (void)
+{
+  int i;
+  static int j = (1 ? 0 : (i = 2)); /* { dg-error "initial" "assignment" { xfail *-*-* } } */
+  static int k = (1 ? 0 : ++i); /* { dg-error "initial" "increment" { xfail *-*-* } } */
+  static int l = (1 ? 0 : --i); /* { dg-error "initial" "decrement" { xfail *-*-* } } */
+  static int m = (1 ? 0 : bar ()); /* { dg-error "initial" "function call" { xfail *-*-* } } */
+  static int n = (1 ? 0 : (2, 3)); /* { dg-error "initial" "comma" { xfail *-*-* } } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-2.c
new file mode 100644
index 000000000..eafc56433
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-2.c
@@ -0,0 +1,45 @@
+/* Test for constant expressions: details of what is a null pointer
+   constant.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990" } */
+/* Note: not using -pedantic since the -std option alone should be enough
+   to give the correct behavior to conforming programs.  If -pedantic is
+   needed to make (say) (0, 0) not be a constant expression, this is a
+   bug.
+*/
+
+int *a;
+int b;
+long *c;
+
+#if defined(_LP64)
+#define ZERO 0L
+#elif defined(_WIN64)
+#define ZERO 0LL
+#else
+#define ZERO 0
+#endif
+
+/* Assertion that n is a null pointer constant: so the conditional expression
+   has type 'int *' instead of 'void *'.
+*/
+#define ASSERT_NPC(n)	(b = *(1 ? a : (n)))
+/* Assertion that n is not a null pointer constant: so the conditional
+   expressions has type 'void *' instead of 'int *'.
+*/
+#define ASSERT_NOT_NPC(n)	(c = (1 ? a : (n)))
+
+void
+foo (void)
+{
+  ASSERT_NPC (0);
+  ASSERT_NPC ((void *)0);
+  ASSERT_NOT_NPC ((void *)(void *)0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((void *)(char *)0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((void *)(0, ZERO)); /* { dg-bogus "incompatible" "bogus null pointer constant" } */
+  ASSERT_NOT_NPC ((void *)(&"Foobar"[0] - &"Foobar"[0])); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  /* This last one is a null pointer constant in C99 only.  */
+  ASSERT_NOT_NPC ((void *)(1 ? 0 : (0, 0))); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-3.c
new file mode 100644
index 000000000..0fda68e82
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-3.c
@@ -0,0 +1,46 @@
+/* Test for constant expressions: broken optimization with const variables.  */
+/* Reference: ISO 9989:1990 6.5.15 */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -O2" } */
+/* Note: not using -pedantic since the -std option alone should be enough
+   to give the correct behavior to conforming programs.  */
+
+static const int ZERO = 0;
+static const double DZERO = 0;
+
+int *a;
+int b;
+long *c;
+
+/* Assertion that n is a constant zero: so the conditional expression
+   has type 'int *' instead of 'void *'.
+*/
+#define ASSERT_NPC(n)	(b = *(1 ? a : (n)))
+/* Assertion that n is not a constant zero: so the conditional
+   expressions has type 'void *' instead of 'int *'.
+*/
+#define ASSERT_NOT_NPC(n)	(c = (1 ? a : (void *)(__SIZE_TYPE__)(n)))
+
+void
+foo (void)
+{
+  ASSERT_NPC (0);
+  ASSERT_NOT_NPC (ZERO);
+  ASSERT_NPC (0 + 0);
+  ASSERT_NOT_NPC (ZERO + 0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC (ZERO + ZERO); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NPC (+0);
+  ASSERT_NOT_NPC (+ZERO); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NPC (-0);
+  ASSERT_NOT_NPC (-ZERO); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NPC ((char) 0);
+  ASSERT_NOT_NPC ((char) ZERO);
+  ASSERT_NPC ((int) 0);
+  ASSERT_NOT_NPC ((int) ZERO);
+  ASSERT_NPC ((int) 0.0);
+  ASSERT_NOT_NPC ((int) DZERO);
+  ASSERT_NOT_NPC ((int) +0.0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((int) (0.0+0.0)); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((int) (double)0.0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-4.c
new file mode 100644
index 000000000..6a449870e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-4.c
@@ -0,0 +1,11 @@
+/* Test for constant expressions: const variable with value 0 is not a
+   null pointer constant so the conditional expression should have
+   type void * and the assignment is OK.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -O2" } */
+int *p;
+long *q;
+static void *const n = 0;
+int j;
+void f(void) { q = j ? p : n; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-5.c
new file mode 100644
index 000000000..0a5af8124
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-const-expr-5.c
@@ -0,0 +1,39 @@
+/* Test null pointer constants: typedefs for void should be OK but not
+   qualified void.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors -fshow-column" } */
+
+typedef void V;
+int *p;
+long *q;
+int j;
+void (*fp)(void);
+
+void
+f (void)
+{
+  /* (V *)0 is a null pointer constant, so the assignment should be
+     diagnosed.  */
+  q = (j ? p : (V *)0); /* { dg-error "3:assignment from incompatible pointer type" } */
+  q = (j ? p : (void *)0); /* { dg-error "3:assignment from incompatible pointer type" } */
+  /* And this conversion should be valid.  */
+  (void (*)(void))(V *)0;
+  (void (*)(void))(void *)0;
+  /* Pointers to qualified void are not valid null pointer
+     constants.  */
+  fp = (const void *)0; /* { dg-error "3:ISO C forbids assignment between function pointer and 'void \\*'" } */
+  fp = (void *)0;
+  fp = (V *)0;
+  fp = 0;
+  fp == 0;
+  0 == fp;
+  fp == (void *)0;
+  (void *)0 == fp;
+  fp == (V *)0;
+  (V *)0 == fp;
+  fp == (V *)1; /* { dg-error "6:ISO C forbids comparison of 'void \\*' with function pointer" } */
+  (V *)1 == fp; /* { dg-error "10:ISO C forbids comparison of 'void \\*' with function pointer" } */
+  fp == (const void *)0; /* { dg-error "6:ISO C forbids comparison of 'void \\*' with function pointer" } */
+  (const void *)0 == fp; /* { dg-error "19:ISO C forbids comparison of 'void \\*' with function pointer" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-digraph-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-digraph-1.c
new file mode 100644
index 000000000..9396d1367
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-digraph-1.c
@@ -0,0 +1,24 @@
+/* Test for recognition of digraphs: should be recognized in C94 and C99
+   mode, but not in C90 mode.  Also check correct stringizing.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+#define str(x) xstr(x)
+#define xstr(x) #x
+#define foo(p, q) str(p %:%: q)
+
+extern void abort (void);
+extern int strcmp (const char *, const char *);
+
+int
+main (void)
+{
+  const char *t = foo (1, 2);
+  const char *u = str (<:);
+  if (strcmp (t, "1 %:%: 2") || strcmp (u, "<:"))
+    abort ();
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-dupqual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-dupqual-1.c
new file mode 100644
index 000000000..14838c736
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-dupqual-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+typedef const int CI;
+const const int c1;		/* { dg-error "duplicate" } */
+const CI c2;			/* { dg-error "duplicate" } */
+const CI *c3;			/* { dg-error "duplicate" } */
+
+typedef volatile int VI;
+volatile volatile int v1;	/* { dg-error "duplicate" } */
+volatile VI v2;			/* { dg-error "duplicate" } */
+volatile VI *v3;		/* { dg-error "duplicate" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-enum-comma-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-enum-comma-1.c
new file mode 100644
index 000000000..2029c92f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-enum-comma-1.c
@@ -0,0 +1,7 @@
+/* Test for commas at end of enums: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+enum foo { bar, };  /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "comma at end" "enum comma error" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-flex-array-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-flex-array-1.c
new file mode 100644
index 000000000..1eead199e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-flex-array-1.c
@@ -0,0 +1,7 @@
+/* Test for flexible array members.  Test for rejection in C90 mode.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct flex { int a; int b[]; }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "ISO C90" "flexible array members not in C90" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-flex-array-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-flex-array-2.c
new file mode 100644
index 000000000..425ce8464
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-flex-array-2.c
@@ -0,0 +1,15 @@
+/* [] does not indicate a flexible array member unless it is the field
+   itself being declared as an incomplete array type rather than a
+   pointer or other type derived from such a type.  PR 36432.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+void
+f (void)
+{
+  int a[3];
+  int (*p)[];
+  struct { int (*p)[]; } s;
+  p = &a;
+  s.p = &a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-float-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-float-1.c
new file mode 100644
index 000000000..39a585bcd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-float-1.c
@@ -0,0 +1,133 @@
+/* Test for <float.h> C90 macros.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+/* This test checks that the C90 macros (but not the C99 ones) are defined;
+   it does not check the correctness of their values.  */
+
+#include <float.h>
+
+#ifndef FLT_ROUNDS
+#error "FLT_ROUNDS undefined"
+#endif
+
+#ifndef FLT_RADIX
+#error "FLT_RADIX undefined"
+#endif
+
+#ifndef FLT_MANT_DIG
+#error "FLT_MANT_DIG undefined"
+#endif
+
+#ifndef FLT_DIG
+#error "FLT_DIG undefined"
+#endif
+
+#ifndef FLT_MIN_EXP
+#error "FLT_MIN_EXP undefined"
+#endif
+
+#ifndef FLT_MIN_10_EXP
+#error "FLT_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT_MAX_EXP
+#error "FLT_MAX_EXP undefined"
+#endif
+
+#ifndef FLT_MAX_10_EXP
+#error "FLT_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT_MAX
+#error "FLT_MAX undefined"
+#endif
+
+#ifndef FLT_EPSILON
+#error "FLT_EPSILON undefined"
+#endif
+
+#ifndef FLT_MIN
+#error "FLT_MIN undefined"
+#endif
+
+#ifndef DBL_MANT_DIG
+#error "DBL_MANT_DIG undefined"
+#endif
+
+#ifndef DBL_DIG
+#error "DBL_DIG undefined"
+#endif
+
+#ifndef DBL_MIN_EXP
+#error "DBL_MIN_EXP undefined"
+#endif
+
+#ifndef DBL_MIN_10_EXP
+#error "DBL_MIN_10_EXP undefined"
+#endif
+
+#ifndef DBL_MAX_EXP
+#error "DBL_MAX_EXP undefined"
+#endif
+
+#ifndef DBL_MAX_10_EXP
+#error "DBL_MAX_10_EXP undefined"
+#endif
+
+#ifndef DBL_MAX
+#error "DBL_MAX undefined"
+#endif
+
+#ifndef DBL_EPSILON
+#error "DBL_EPSILON undefined"
+#endif
+
+#ifndef DBL_MIN
+#error "DBL_MIN undefined"
+#endif
+
+#ifndef LDBL_MANT_DIG
+#error "LDBL_MANT_DIG undefined"
+#endif
+
+#ifndef LDBL_DIG
+#error "LDBL_DIG undefined"
+#endif
+
+#ifndef LDBL_MIN_EXP
+#error "LDBL_MIN_EXP undefined"
+#endif
+
+#ifndef LDBL_MIN_10_EXP
+#error "LDBL_MIN_10_EXP undefined"
+#endif
+
+#ifndef LDBL_MAX_EXP
+#error "LDBL_MAX_EXP undefined"
+#endif
+
+#ifndef LDBL_MAX_10_EXP
+#error "LDBL_MAX_10_EXP undefined"
+#endif
+
+#ifndef LDBL_MAX
+#error "LDBL_MAX undefined"
+#endif
+
+#ifndef LDBL_EPSILON
+#error "LDBL_EPSILON undefined"
+#endif
+
+#ifndef LDBL_MIN
+#error "LDBL_MIN undefined"
+#endif
+
+#ifdef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD defined"
+#endif
+
+#ifdef DECIMAL_DIG
+#error "DECIMAL_DIG defined"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-fordecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-fordecl-1.c
new file mode 100644
index 000000000..4aa3c5830
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-fordecl-1.c
@@ -0,0 +1,14 @@
+/* Test for C99 declarations in for loops - rejection in C90 mode.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  int j = 0;
+  for (int i = 1; i <= 10; i++) /* { dg-bogus "warning" "warning in place of error" } */
+    j += i;
+  /* { dg-error "'for' loop initial declarations are only allowed in C99 mode" "declaration in for loop" { target *-*-* } 10 } */
+  /* { dg-message "note: use option -std=c99 or -std=gnu99 to compile your code" "note" { target *-*-* } 10 }} */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-hexfloat-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-hexfloat-1.c
new file mode 100644
index 000000000..2dd90a1e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-hexfloat-1.c
@@ -0,0 +1,11 @@
+/* Test for hex floating point constants: in C99 only.  Compiler test.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+double d = 0x1.2p2; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "hexadecimal floating" "hex float error" { target *-*-* } 6 } */
+double d1 = 0x1p2; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "hexadecimal floating" "hex float error" { target *-*-* } 8 } */
+double d2 = 0x1...p2; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "too many decimal points" "bad hex float" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-hexfloat-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-hexfloat-2.c
new file mode 100644
index 000000000..259471c8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-hexfloat-2.c
@@ -0,0 +1,24 @@
+/* Test for hex floating point constants: in C99 only.  Preprocessor test.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+#define f (
+#define l )
+#define str(x) #x
+#define xstr(x) str(x)
+
+/* C90: "0x1p+( 0x1p+)"; C99: "0x1p+f 0x1p+l" */
+const char *s = xstr(0x1p+f 0x1p+l);
+
+extern void abort (void);
+extern int strcmp (const char *, const char *);
+
+int
+main (void)
+{
+  if (strcmp (s, "0x1p+( 0x1p+)"))
+    abort ();
+  else
+    return 0; /* Correct C90 behavior.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-1.c
new file mode 100644
index 000000000..ee05a82f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-1.c
@@ -0,0 +1,8 @@
+/* Test for idempotent type qualifiers: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+typedef const int cint;
+const cint foo; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "duplicate" "duplicate type qualifier error" { target *-*-* } 7 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-2.c
new file mode 100644
index 000000000..c9bb6f7e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-2.c
@@ -0,0 +1,7 @@
+/* Test for idempotent type qualifiers: in C99 only.  Test "const const".  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+const const int foo; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "duplicate" "duplicate type qualifier error" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-3.c
new file mode 100644
index 000000000..9976a0888
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-idem-qual-3.c
@@ -0,0 +1,11 @@
+/* Test for idempotent type qualifiers: in C99 only.  Test duplicate
+   type qualifiers with array element types.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+typedef const int cia[2];
+const cia a; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "duplicate" "duplicate type qualifier error" { target *-*-* } 8 } */
+const cia b[2]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "duplicate" "duplicate type qualifier error" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-decl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-decl-1.c
new file mode 100644
index 000000000..4e4431e6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-decl-1.c
@@ -0,0 +1,22 @@
+/* Test for implicit function declaration: in C90 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  bar ();
+}
+
+/* C90 subclause 7.1.7 says we can implicitly declare strcmp; C99 removes
+   implict declarations.
+*/
+int
+bar (const char *a, const char *b)
+{
+  /* This fails for GCC CVS 20000709, but is not marked XFAIL since
+     GCC 2.95.2 passes.
+  */
+  return strcmp (a, b); /* { dg-bogus "implicit" "implicit declaration warning for strcmp" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-int-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-int-1.c
new file mode 100644
index 000000000..cd995c296
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-int-1.c
@@ -0,0 +1,8 @@
+/* Test for implicit int: in C90 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+extern foo;
+
+bar (void) { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-int-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-int-2.c
new file mode 100644
index 000000000..884c9d92e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-impl-int-2.c
@@ -0,0 +1,8 @@
+/* Test for implicit int: in C90 only.  Function parameters in old-style
+   function definition.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+void foo (a) { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-init-1.c
new file mode 100644
index 000000000..68308d3e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-init-1.c
@@ -0,0 +1,25 @@
+/* Test for C99 designated initializers */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct A {
+  int B;
+  short C[2];
+};
+int a[10] = { 10, [4] = 15 };			/* { dg-error "ISO (C89|C90) forbids specifying subobject to initialize" } */
+struct A b = { .B = 2 };			/* { dg-error "ISO (C89|C90) forbids specifying subobject to initialize" } */
+struct A c[] = { [3].C[1] = 1 };		/* { dg-error "ISO (C89|C90) forbids specifying subobject to initialize" } */
+struct A d[] = { [4 ... 6].C[0 ... 1] = 2 };	/* { dg-error "(forbids specifying range of elements to initialize)|(ISO (C89|C90) forbids specifying subobject to initialize)" } */
+int e[] = { [2] 2 };				/* { dg-error "use of designated initializer without" } */
+struct A f = { C: { 0, 1 } };			/* { dg-error "use of designated initializer with " } */
+int g;
+
+void foo (int *);
+
+void bar (void)
+{
+  int x[] = { g++, 2 };				/* { dg-error "is not computable at load time" } */
+
+  foo (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-intconst-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-intconst-1.c
new file mode 100644
index 000000000..de7371c06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-intconst-1.c
@@ -0,0 +1,763 @@
+/* Test for integer constant types.  */
+
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+#include <limits.h>
+
+/* Assertion that constant C is of type T.  */
+#define ASSERT_CONST_TYPE(C, T)			\
+	do {					\
+	  typedef T type;			\
+	  typedef type **typepp;		\
+	  typedef __typeof__((C)) ctype;	\
+	  typedef ctype **ctypepp;		\
+	  typepp x = 0;				\
+	  ctypepp y = 0;			\
+	  x = y;				\
+	  y = x;				\
+	} while (0)
+
+/* (T *) if E is zero, (void *) otherwise.  */
+#define type_if_not(T, E) __typeof__(0 ? (T *)0 : (void *)(E))
+
+/* (T *) if E is nonzero, (void *) otherwise.  */
+#define type_if(T, E) type_if_not(T, !(E))
+
+/* Combine pointer types, all but one (void *).  */
+#define type_comb2(T1, T2) __typeof__(0 ? (T1)0 : (T2)0)
+#define type_comb3(T1, T2, T3) type_comb2(T1, type_comb2(T2, T3))
+#define type_comb4(T1, T2, T3, T4)				\
+	type_comb2(T1, type_comb2(T2, type_comb2(T3, T4)))
+
+/* (T1 *) if E1, otherwise (T2 *) if E2.  */
+#define first_of2p(T1, E1, T2, E2) type_comb2(type_if(T1, (E1)),	   \
+					     type_if(T2, (!(E1) && (E2))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3.  */
+#define first_of3p(T1, E1, T2, E2, T3, E3)			\
+	type_comb3(type_if(T1, (E1)),				\
+		   type_if(T2, (!(E1) && (E2))),		\
+		   type_if(T3, (!(E1) && !(E2) && (E3))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3, otherwise
+   (T4 *) if E4.  */
+#define first_of4p(T1, E1, T2, E2, T3, E3, T4, E4)			\
+	type_comb4(type_if(T1, (E1)),					\
+		   type_if(T2, (!(E1) && (E2))),			\
+		   type_if(T3, (!(E1) && !(E2) && (E3))),		\
+		   type_if(T4, (!(E1) && !(E2) && !(E3) && (E4))))
+
+/* Likewise, but return the original type rather than a pointer type.  */
+#define first_of2(T1, E1, T2, E2)			\
+	__typeof__(*((first_of2p(T1, (E1), T2, (E2)))0))
+#define first_of3(T1, E1, T2, E2, T3, E3)				\
+	__typeof__(*((first_of3p(T1, (E1), T2, (E2), T3, (E3)))0))
+#define first_of4(T1, E1, T2, E2, T3, E3, T4, E4)			    \
+	__typeof__(*((first_of4p(T1, (E1), T2, (E2), T3, (E3), T4, (E4)))0))
+
+/* Types of constants according to the C90 rules.  */
+#define C90_UNSUF_DEC_TYPE(C)				\
+	first_of3(int, (C) <= INT_MAX,			\
+		  long int, (C) <= LONG_MAX,		\
+		  unsigned long int, (C) <= ULONG_MAX)
+#define C90_UNSUF_OCTHEX_TYPE(C)			\
+	first_of4(int, (C) <= INT_MAX,			\
+		  unsigned int, (C) <= UINT_MAX,	\
+		  long int, (C) <= LONG_MAX,		\
+		  unsigned long int, (C) <= ULONG_MAX)
+#define C90_SUFu_TYPE(C)				\
+	first_of2(unsigned int, (C) <= UINT_MAX,	\
+		  unsigned long int, (C) <= ULONG_MAX)
+#define C90_SUFl_TYPE(C)				\
+	first_of2(long int, (C) <= LONG_MAX,		\
+		  unsigned long int, (C) <= ULONG_MAX)
+
+/* Checks that constants have correct type.  */
+#define CHECK_UNSUF_DEC_TYPE(C) ASSERT_CONST_TYPE((C), C90_UNSUF_DEC_TYPE((C)))
+#define CHECK_UNSUF_OCTHEX_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C90_UNSUF_OCTHEX_TYPE((C)))
+#define CHECK_SUFu_TYPE(C) ASSERT_CONST_TYPE((C), C90_SUFu_TYPE((C)))
+#define CHECK_SUFl_TYPE(C) ASSERT_CONST_TYPE((C), C90_SUFl_TYPE((C)))
+#define CHECK_SUFul_TYPE(C) ASSERT_CONST_TYPE((C), unsigned long int)
+
+/* Check a decimal value, with all suffixes.  */
+#define CHECK_DEC_CONST(C)			\
+	CHECK_UNSUF_DEC_TYPE(C);		\
+	CHECK_SUFu_TYPE(C##u);			\
+	CHECK_SUFu_TYPE(C##U);			\
+	CHECK_SUFl_TYPE(C##l);			\
+	CHECK_SUFl_TYPE(C##L);			\
+	CHECK_SUFul_TYPE(C##ul);		\
+	CHECK_SUFul_TYPE(C##uL);		\
+	CHECK_SUFul_TYPE(C##Ul);		\
+	CHECK_SUFul_TYPE(C##UL);
+
+/* Check an octal or hexadecimal value, with all suffixes.  */
+#define CHECK_OCTHEX_CONST(C)			\
+	CHECK_UNSUF_OCTHEX_TYPE(C);		\
+	CHECK_SUFu_TYPE(C##u);			\
+	CHECK_SUFu_TYPE(C##U);			\
+	CHECK_SUFl_TYPE(C##l);			\
+	CHECK_SUFl_TYPE(C##L);			\
+	CHECK_SUFul_TYPE(C##ul);		\
+	CHECK_SUFul_TYPE(C##uL);		\
+	CHECK_SUFul_TYPE(C##Ul);		\
+	CHECK_SUFul_TYPE(C##UL);
+
+#define CHECK_OCT_CONST(C) CHECK_OCTHEX_CONST(C)
+#define CHECK_HEX_CONST(C)			\
+	CHECK_OCTHEX_CONST(0x##C);		\
+	CHECK_OCTHEX_CONST(0X##C);
+
+/* True iff "long" is at least B bits.  This presumes that (B-2)/3 is at
+   most 31.  */
+#define LONG_AT_LEAST(B)						\
+	(LONG_MAX >> ((B)-2)/3 >> ((B)-2)/3 >> ((B)-2 - ((B)-2)/3 - ((B)-2)/3))
+
+#define LONG_HAS_BITS(B) (LONG_AT_LEAST((B)) && !LONG_AT_LEAST((B) + 1))
+
+/* Decimal values that are large enough to be unsigned.  Allow for up to
+   64 bits in long.  */
+#if LONG_HAS_BITS(32)
+#define LARGE_UNSIGNED_DECIMAL 2147483648
+#endif
+#if LONG_HAS_BITS(33)
+#define LARGE_UNSIGNED_DECIMAL 4294967296
+#endif
+#if LONG_HAS_BITS(34)
+#define LARGE_UNSIGNED_DECIMAL 8589934592
+#endif
+#if LONG_HAS_BITS(35)
+#define LARGE_UNSIGNED_DECIMAL 17179869184
+#endif
+#if LONG_HAS_BITS(36)
+#define LARGE_UNSIGNED_DECIMAL 34359738368
+#endif
+#if LONG_HAS_BITS(37)
+#define LARGE_UNSIGNED_DECIMAL 68719476736
+#endif
+#if LONG_HAS_BITS(38)
+#define LARGE_UNSIGNED_DECIMAL 137438953472
+#endif
+#if LONG_HAS_BITS(39)
+#define LARGE_UNSIGNED_DECIMAL 274877906944
+#endif
+#if LONG_HAS_BITS(40)
+#define LARGE_UNSIGNED_DECIMAL 549755813888
+#endif
+#if LONG_HAS_BITS(41)
+#define LARGE_UNSIGNED_DECIMAL 1099511627776
+#endif
+#if LONG_HAS_BITS(42)
+#define LARGE_UNSIGNED_DECIMAL 2199023255552
+#endif
+#if LONG_HAS_BITS(43)
+#define LARGE_UNSIGNED_DECIMAL 4398046511104
+#endif
+#if LONG_HAS_BITS(44)
+#define LARGE_UNSIGNED_DECIMAL 8796093022208
+#endif
+#if LONG_HAS_BITS(45)
+#define LARGE_UNSIGNED_DECIMAL 17592186044416
+#endif
+#if LONG_HAS_BITS(46)
+#define LARGE_UNSIGNED_DECIMAL 35184372088832
+#endif
+#if LONG_HAS_BITS(47)
+#define LARGE_UNSIGNED_DECIMAL 70368744177664
+#endif
+#if LONG_HAS_BITS(48)
+#define LARGE_UNSIGNED_DECIMAL 140737488355328
+#endif
+#if LONG_HAS_BITS(49)
+#define LARGE_UNSIGNED_DECIMAL 281474976710656
+#endif
+#if LONG_HAS_BITS(50)
+#define LARGE_UNSIGNED_DECIMAL 562949953421312
+#endif
+#if LONG_HAS_BITS(51)
+#define LARGE_UNSIGNED_DECIMAL 1125899906842624
+#endif
+#if LONG_HAS_BITS(52)
+#define LARGE_UNSIGNED_DECIMAL 2251799813685248
+#endif
+#if LONG_HAS_BITS(53)
+#define LARGE_UNSIGNED_DECIMAL 4503599627370496
+#endif
+#if LONG_HAS_BITS(54)
+#define LARGE_UNSIGNED_DECIMAL 9007199254740992
+#endif
+#if LONG_HAS_BITS(55)
+#define LARGE_UNSIGNED_DECIMAL 18014398509481984
+#endif
+#if LONG_HAS_BITS(56)
+#define LARGE_UNSIGNED_DECIMAL 36028797018963968
+#endif
+#if LONG_HAS_BITS(57)
+#define LARGE_UNSIGNED_DECIMAL 72057594037927936
+#endif
+#if LONG_HAS_BITS(58)
+#define LARGE_UNSIGNED_DECIMAL 144115188075855872
+#endif
+#if LONG_HAS_BITS(59)
+#define LARGE_UNSIGNED_DECIMAL 288230376151711744
+#endif
+#if LONG_HAS_BITS(60)
+#define LARGE_UNSIGNED_DECIMAL 576460752303423488
+#endif
+#if LONG_HAS_BITS(61)
+#define LARGE_UNSIGNED_DECIMAL 1152921504606846976
+#endif
+#if LONG_HAS_BITS(62)
+#define LARGE_UNSIGNED_DECIMAL 2305843009213693952
+#endif
+#if LONG_HAS_BITS(63)
+#define LARGE_UNSIGNED_DECIMAL 4611686018427387904
+#endif
+#if LONG_HAS_BITS(64)
+#define LARGE_UNSIGNED_DECIMAL 9223372036854775808
+#endif
+#if LONG_AT_LEAST(65)
+#error "extend this test to allow for long larger than 64 bits"
+#endif
+
+#define cat(x, y) x ## y
+#define xcat(x, y) cat(x, y)
+
+#define LARGE_UNSIGNED_DECIMALl xcat(LARGE_UNSIGNED_DECIMAL, l)
+#define LARGE_UNSIGNED_DECIMALL xcat(LARGE_UNSIGNED_DECIMAL, L)
+#define LARGE_UNSIGNED_DECIMALu xcat(LARGE_UNSIGNED_DECIMAL, u)
+#define LARGE_UNSIGNED_DECIMALU xcat(LARGE_UNSIGNED_DECIMAL, U)
+#define LARGE_UNSIGNED_DECIMALul xcat(LARGE_UNSIGNED_DECIMAL, ul)
+#define LARGE_UNSIGNED_DECIMALuL xcat(LARGE_UNSIGNED_DECIMAL, uL)
+#define LARGE_UNSIGNED_DECIMALUl xcat(LARGE_UNSIGNED_DECIMAL, Ul)
+#define LARGE_UNSIGNED_DECIMALUL xcat(LARGE_UNSIGNED_DECIMAL, UL)
+
+void
+foo (void)
+{
+  /* Decimal.  */
+  /* Check all 2^n and 2^n - 1 up to 2^63 - 1.  Check values that would be
+     unsigned separately since they generate a warning.  */
+  CHECK_DEC_CONST(1);
+  CHECK_DEC_CONST(2);
+  CHECK_DEC_CONST(3);
+  CHECK_DEC_CONST(4);
+  CHECK_DEC_CONST(7);
+  CHECK_DEC_CONST(8);
+  CHECK_DEC_CONST(15);
+  CHECK_DEC_CONST(16);
+  CHECK_DEC_CONST(31);
+  CHECK_DEC_CONST(32);
+  CHECK_DEC_CONST(63);
+  CHECK_DEC_CONST(64);
+  CHECK_DEC_CONST(127);
+  CHECK_DEC_CONST(128);
+  CHECK_DEC_CONST(255);
+  CHECK_DEC_CONST(256);
+  CHECK_DEC_CONST(511);
+  CHECK_DEC_CONST(512);
+  CHECK_DEC_CONST(1023);
+  CHECK_DEC_CONST(1024);
+  CHECK_DEC_CONST(2047);
+  CHECK_DEC_CONST(2048);
+  CHECK_DEC_CONST(4095);
+  CHECK_DEC_CONST(4096);
+  CHECK_DEC_CONST(8191);
+  CHECK_DEC_CONST(8192);
+  CHECK_DEC_CONST(16383);
+  CHECK_DEC_CONST(16384);
+  CHECK_DEC_CONST(32767);
+  CHECK_DEC_CONST(32768);
+  CHECK_DEC_CONST(65535);
+  CHECK_DEC_CONST(65536);
+  CHECK_DEC_CONST(131071);
+  CHECK_DEC_CONST(131072);
+  CHECK_DEC_CONST(262143);
+  CHECK_DEC_CONST(262144);
+  CHECK_DEC_CONST(524287);
+  CHECK_DEC_CONST(524288);
+  CHECK_DEC_CONST(1048575);
+  CHECK_DEC_CONST(1048576);
+  CHECK_DEC_CONST(2097151);
+  CHECK_DEC_CONST(2097152);
+  CHECK_DEC_CONST(4194303);
+  CHECK_DEC_CONST(4194304);
+  CHECK_DEC_CONST(8388607);
+  CHECK_DEC_CONST(8388608);
+  CHECK_DEC_CONST(16777215);
+  CHECK_DEC_CONST(16777216);
+  CHECK_DEC_CONST(33554431);
+  CHECK_DEC_CONST(33554432);
+  CHECK_DEC_CONST(67108863);
+  CHECK_DEC_CONST(67108864);
+  CHECK_DEC_CONST(134217727);
+  CHECK_DEC_CONST(134217728);
+  CHECK_DEC_CONST(268435455);
+  CHECK_DEC_CONST(268435456);
+  CHECK_DEC_CONST(536870911);
+  CHECK_DEC_CONST(536870912);
+  CHECK_DEC_CONST(1073741823);
+  CHECK_DEC_CONST(1073741824);
+  CHECK_DEC_CONST(2147483647);
+#if LONG_AT_LEAST(33)
+  CHECK_DEC_CONST(2147483648);
+  CHECK_DEC_CONST(4294967295);
+#endif
+#if LONG_AT_LEAST(34)
+  CHECK_DEC_CONST(4294967296);
+  CHECK_DEC_CONST(8589934591);
+#endif
+#if LONG_AT_LEAST(35)
+  CHECK_DEC_CONST(8589934592);
+  CHECK_DEC_CONST(17179869183);
+#endif
+#if LONG_AT_LEAST(36)
+  CHECK_DEC_CONST(17179869184);
+  CHECK_DEC_CONST(34359738367);
+#endif
+#if LONG_AT_LEAST(37)
+  CHECK_DEC_CONST(34359738368);
+  CHECK_DEC_CONST(68719476735);
+#endif
+#if LONG_AT_LEAST(38)
+  CHECK_DEC_CONST(68719476736);
+  CHECK_DEC_CONST(137438953471);
+#endif
+#if LONG_AT_LEAST(39)
+  CHECK_DEC_CONST(137438953472);
+  CHECK_DEC_CONST(274877906943);
+#endif
+#if LONG_AT_LEAST(40)
+  CHECK_DEC_CONST(274877906944);
+  CHECK_DEC_CONST(549755813887);
+#endif
+#if LONG_AT_LEAST(41)
+  CHECK_DEC_CONST(549755813888);
+  CHECK_DEC_CONST(1099511627775);
+#endif
+#if LONG_AT_LEAST(42)
+  CHECK_DEC_CONST(1099511627776);
+  CHECK_DEC_CONST(2199023255551);
+#endif
+#if LONG_AT_LEAST(43)
+  CHECK_DEC_CONST(2199023255552);
+  CHECK_DEC_CONST(4398046511103);
+#endif
+#if LONG_AT_LEAST(44)
+  CHECK_DEC_CONST(4398046511104);
+  CHECK_DEC_CONST(8796093022207);
+#endif
+#if LONG_AT_LEAST(45)
+  CHECK_DEC_CONST(8796093022208);
+  CHECK_DEC_CONST(17592186044415);
+#endif
+#if LONG_AT_LEAST(46)
+  CHECK_DEC_CONST(17592186044416);
+  CHECK_DEC_CONST(35184372088831);
+#endif
+#if LONG_AT_LEAST(47)
+  CHECK_DEC_CONST(35184372088832);
+  CHECK_DEC_CONST(70368744177663);
+#endif
+#if LONG_AT_LEAST(48)
+  CHECK_DEC_CONST(70368744177664);
+  CHECK_DEC_CONST(140737488355327);
+#endif
+#if LONG_AT_LEAST(49)
+  CHECK_DEC_CONST(140737488355328);
+  CHECK_DEC_CONST(281474976710655);
+#endif
+#if LONG_AT_LEAST(50)
+  CHECK_DEC_CONST(281474976710656);
+  CHECK_DEC_CONST(562949953421311);
+#endif
+#if LONG_AT_LEAST(51)
+  CHECK_DEC_CONST(562949953421312);
+  CHECK_DEC_CONST(1125899906842623);
+#endif
+#if LONG_AT_LEAST(52)
+  CHECK_DEC_CONST(1125899906842624);
+  CHECK_DEC_CONST(2251799813685247);
+#endif
+#if LONG_AT_LEAST(53)
+  CHECK_DEC_CONST(2251799813685248);
+  CHECK_DEC_CONST(4503599627370495);
+#endif
+#if LONG_AT_LEAST(54)
+  CHECK_DEC_CONST(4503599627370496);
+  CHECK_DEC_CONST(9007199254740991);
+#endif
+#if LONG_AT_LEAST(55)
+  CHECK_DEC_CONST(9007199254740992);
+  CHECK_DEC_CONST(18014398509481983);
+#endif
+#if LONG_AT_LEAST(56)
+  CHECK_DEC_CONST(18014398509481984);
+  CHECK_DEC_CONST(36028797018963967);
+#endif
+#if LONG_AT_LEAST(57)
+  CHECK_DEC_CONST(36028797018963968);
+  CHECK_DEC_CONST(72057594037927935);
+#endif
+#if LONG_AT_LEAST(58)
+  CHECK_DEC_CONST(72057594037927936);
+  CHECK_DEC_CONST(144115188075855871);
+#endif
+#if LONG_AT_LEAST(59)
+  CHECK_DEC_CONST(144115188075855872);
+  CHECK_DEC_CONST(288230376151711743);
+#endif
+#if LONG_AT_LEAST(60)
+  CHECK_DEC_CONST(288230376151711744);
+  CHECK_DEC_CONST(576460752303423487);
+#endif
+#if LONG_AT_LEAST(61)
+  CHECK_DEC_CONST(576460752303423488);
+  CHECK_DEC_CONST(1152921504606846975);
+#endif
+#if LONG_AT_LEAST(62)
+  CHECK_DEC_CONST(1152921504606846976);
+  CHECK_DEC_CONST(2305843009213693951);
+#endif
+#if LONG_AT_LEAST(63)
+  CHECK_DEC_CONST(2305843009213693952);
+  CHECK_DEC_CONST(4611686018427387903);
+#endif
+#if LONG_AT_LEAST(64)
+  CHECK_DEC_CONST(4611686018427387904);
+  CHECK_DEC_CONST(9223372036854775807);
+#endif
+  /* Separate checks for values that are unsigned.  */
+  CHECK_UNSUF_DEC_TYPE(LARGE_UNSIGNED_DECIMAL); /* { dg-warning "unsigned" "unsigned decimal no suffix" } */
+  CHECK_SUFl_TYPE(LARGE_UNSIGNED_DECIMALl); /* { dg-warning "unsigned" "unsigned decimal long suffix" } */
+  CHECK_SUFl_TYPE(LARGE_UNSIGNED_DECIMALL); /* { dg-warning "unsigned" "unsigned decimal long suffix" } */
+  CHECK_SUFu_TYPE(LARGE_UNSIGNED_DECIMALu);
+  CHECK_SUFu_TYPE(LARGE_UNSIGNED_DECIMALU);
+  CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALul);
+  CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALuL);
+  CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALUl);
+  CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALUL);
+  /* Octal and hexadecimal.  */
+  /* Check all 2^n and 2^n - 1 up to 2^64 - 1.  */
+  CHECK_OCT_CONST(0);
+  CHECK_HEX_CONST(0);
+  CHECK_OCT_CONST(01);
+  CHECK_HEX_CONST(1);
+  CHECK_OCT_CONST(02);
+  CHECK_HEX_CONST(2);
+  CHECK_OCT_CONST(03);
+  CHECK_HEX_CONST(3);
+  CHECK_OCT_CONST(04);
+  CHECK_HEX_CONST(4);
+  CHECK_OCT_CONST(07);
+  CHECK_HEX_CONST(7);
+  CHECK_OCT_CONST(010);
+  CHECK_HEX_CONST(8);
+  CHECK_OCT_CONST(017);
+  CHECK_HEX_CONST(f);
+  CHECK_OCT_CONST(020);
+  CHECK_HEX_CONST(10);
+  CHECK_OCT_CONST(037);
+  CHECK_HEX_CONST(1f);
+  CHECK_OCT_CONST(040);
+  CHECK_HEX_CONST(20);
+  CHECK_OCT_CONST(077);
+  CHECK_HEX_CONST(3f);
+  CHECK_OCT_CONST(0100);
+  CHECK_HEX_CONST(40);
+  CHECK_OCT_CONST(0177);
+  CHECK_HEX_CONST(7f);
+  CHECK_OCT_CONST(0200);
+  CHECK_HEX_CONST(80);
+  CHECK_OCT_CONST(0377);
+  CHECK_HEX_CONST(ff);
+  CHECK_OCT_CONST(0400);
+  CHECK_HEX_CONST(100);
+  CHECK_OCT_CONST(0777);
+  CHECK_HEX_CONST(1ff);
+  CHECK_OCT_CONST(01000);
+  CHECK_HEX_CONST(200);
+  CHECK_OCT_CONST(01777);
+  CHECK_HEX_CONST(3ff);
+  CHECK_OCT_CONST(02000);
+  CHECK_HEX_CONST(400);
+  CHECK_OCT_CONST(03777);
+  CHECK_HEX_CONST(7ff);
+  CHECK_OCT_CONST(04000);
+  CHECK_HEX_CONST(800);
+  CHECK_OCT_CONST(07777);
+  CHECK_HEX_CONST(fff);
+  CHECK_OCT_CONST(010000);
+  CHECK_HEX_CONST(1000);
+  CHECK_OCT_CONST(017777);
+  CHECK_HEX_CONST(1fff);
+  CHECK_OCT_CONST(020000);
+  CHECK_HEX_CONST(2000);
+  CHECK_OCT_CONST(037777);
+  CHECK_HEX_CONST(3fff);
+  CHECK_OCT_CONST(040000);
+  CHECK_HEX_CONST(4000);
+  CHECK_OCT_CONST(077777);
+  CHECK_HEX_CONST(7fff);
+  CHECK_OCT_CONST(0100000);
+  CHECK_HEX_CONST(8000);
+  CHECK_OCT_CONST(0177777);
+  CHECK_HEX_CONST(ffff);
+  CHECK_OCT_CONST(0200000);
+  CHECK_HEX_CONST(10000);
+  CHECK_OCT_CONST(0377777);
+  CHECK_HEX_CONST(1ffff);
+  CHECK_OCT_CONST(0400000);
+  CHECK_HEX_CONST(20000);
+  CHECK_OCT_CONST(0777777);
+  CHECK_HEX_CONST(3ffff);
+  CHECK_OCT_CONST(01000000);
+  CHECK_HEX_CONST(40000);
+  CHECK_OCT_CONST(01777777);
+  CHECK_HEX_CONST(7ffff);
+  CHECK_OCT_CONST(02000000);
+  CHECK_HEX_CONST(80000);
+  CHECK_OCT_CONST(03777777);
+  CHECK_HEX_CONST(fffff);
+  CHECK_OCT_CONST(04000000);
+  CHECK_HEX_CONST(100000);
+  CHECK_OCT_CONST(07777777);
+  CHECK_HEX_CONST(1fffff);
+  CHECK_OCT_CONST(010000000);
+  CHECK_HEX_CONST(200000);
+  CHECK_OCT_CONST(017777777);
+  CHECK_HEX_CONST(3fffff);
+  CHECK_OCT_CONST(020000000);
+  CHECK_HEX_CONST(400000);
+  CHECK_OCT_CONST(037777777);
+  CHECK_HEX_CONST(7fffff);
+  CHECK_OCT_CONST(040000000);
+  CHECK_HEX_CONST(800000);
+  CHECK_OCT_CONST(077777777);
+  CHECK_HEX_CONST(ffffff);
+  CHECK_OCT_CONST(0100000000);
+  CHECK_HEX_CONST(1000000);
+  CHECK_OCT_CONST(0177777777);
+  CHECK_HEX_CONST(1ffffff);
+  CHECK_OCT_CONST(0200000000);
+  CHECK_HEX_CONST(2000000);
+  CHECK_OCT_CONST(0377777777);
+  CHECK_HEX_CONST(3ffffff);
+  CHECK_OCT_CONST(0400000000);
+  CHECK_HEX_CONST(4000000);
+  CHECK_OCT_CONST(0777777777);
+  CHECK_HEX_CONST(7ffffff);
+  CHECK_OCT_CONST(01000000000);
+  CHECK_HEX_CONST(8000000);
+  CHECK_OCT_CONST(01777777777);
+  CHECK_HEX_CONST(fffffff);
+  CHECK_OCT_CONST(02000000000);
+  CHECK_HEX_CONST(10000000);
+  CHECK_OCT_CONST(03777777777);
+  CHECK_HEX_CONST(1fffffff);
+  CHECK_OCT_CONST(04000000000);
+  CHECK_HEX_CONST(20000000);
+  CHECK_OCT_CONST(07777777777);
+  CHECK_HEX_CONST(3fffffff);
+  CHECK_OCT_CONST(010000000000);
+  CHECK_HEX_CONST(40000000);
+  CHECK_OCT_CONST(017777777777);
+  CHECK_HEX_CONST(7fffffff);
+  CHECK_OCT_CONST(020000000000);
+  CHECK_HEX_CONST(80000000);
+  CHECK_OCT_CONST(037777777777);
+  CHECK_HEX_CONST(ffffffff);
+#if LONG_AT_LEAST(33)
+  CHECK_OCT_CONST(040000000000);
+  CHECK_HEX_CONST(100000000);
+  CHECK_OCT_CONST(077777777777);
+  CHECK_HEX_CONST(1ffffffff);
+#endif
+#if LONG_AT_LEAST(34)
+  CHECK_OCT_CONST(0100000000000);
+  CHECK_HEX_CONST(200000000);
+  CHECK_OCT_CONST(0177777777777);
+  CHECK_HEX_CONST(3ffffffff);
+#endif
+#if LONG_AT_LEAST(35)
+  CHECK_OCT_CONST(0200000000000);
+  CHECK_HEX_CONST(400000000);
+  CHECK_OCT_CONST(0377777777777);
+  CHECK_HEX_CONST(7ffffffff);
+#endif
+#if LONG_AT_LEAST(36)
+  CHECK_OCT_CONST(0400000000000);
+  CHECK_HEX_CONST(800000000);
+  CHECK_OCT_CONST(0777777777777);
+  CHECK_HEX_CONST(fffffffff);
+#endif
+#if LONG_AT_LEAST(37)
+  CHECK_OCT_CONST(01000000000000);
+  CHECK_HEX_CONST(1000000000);
+  CHECK_OCT_CONST(01777777777777);
+  CHECK_HEX_CONST(1fffffffff);
+#endif
+#if LONG_AT_LEAST(38)
+  CHECK_OCT_CONST(02000000000000);
+  CHECK_HEX_CONST(2000000000);
+  CHECK_OCT_CONST(03777777777777);
+  CHECK_HEX_CONST(3fffffffff);
+#endif
+#if LONG_AT_LEAST(39)
+  CHECK_OCT_CONST(04000000000000);
+  CHECK_HEX_CONST(4000000000);
+  CHECK_OCT_CONST(07777777777777);
+  CHECK_HEX_CONST(7fffffffff);
+#endif
+#if LONG_AT_LEAST(40)
+  CHECK_OCT_CONST(010000000000000);
+  CHECK_HEX_CONST(8000000000);
+  CHECK_OCT_CONST(017777777777777);
+  CHECK_HEX_CONST(ffffffffff);
+#endif
+#if LONG_AT_LEAST(41)
+  CHECK_OCT_CONST(020000000000000);
+  CHECK_HEX_CONST(10000000000);
+  CHECK_OCT_CONST(037777777777777);
+  CHECK_HEX_CONST(1ffffffffff);
+#endif
+#if LONG_AT_LEAST(42)
+  CHECK_OCT_CONST(040000000000000);
+  CHECK_HEX_CONST(20000000000);
+  CHECK_OCT_CONST(077777777777777);
+  CHECK_HEX_CONST(3ffffffffff);
+#endif
+#if LONG_AT_LEAST(43)
+  CHECK_OCT_CONST(0100000000000000);
+  CHECK_HEX_CONST(40000000000);
+  CHECK_OCT_CONST(0177777777777777);
+  CHECK_HEX_CONST(7ffffffffff);
+#endif
+#if LONG_AT_LEAST(44)
+  CHECK_OCT_CONST(0200000000000000);
+  CHECK_HEX_CONST(80000000000);
+  CHECK_OCT_CONST(0377777777777777);
+  CHECK_HEX_CONST(fffffffffff);
+#endif
+#if LONG_AT_LEAST(45)
+  CHECK_OCT_CONST(0400000000000000);
+  CHECK_HEX_CONST(100000000000);
+  CHECK_OCT_CONST(0777777777777777);
+  CHECK_HEX_CONST(1fffffffffff);
+#endif
+#if LONG_AT_LEAST(46)
+  CHECK_OCT_CONST(01000000000000000);
+  CHECK_HEX_CONST(200000000000);
+  CHECK_OCT_CONST(01777777777777777);
+  CHECK_HEX_CONST(3fffffffffff);
+#endif
+#if LONG_AT_LEAST(47)
+  CHECK_OCT_CONST(02000000000000000);
+  CHECK_HEX_CONST(400000000000);
+  CHECK_OCT_CONST(03777777777777777);
+  CHECK_HEX_CONST(7fffffffffff);
+#endif
+#if LONG_AT_LEAST(48)
+  CHECK_OCT_CONST(04000000000000000);
+  CHECK_HEX_CONST(800000000000);
+  CHECK_OCT_CONST(07777777777777777);
+  CHECK_HEX_CONST(ffffffffffff);
+#endif
+#if LONG_AT_LEAST(49)
+  CHECK_OCT_CONST(010000000000000000);
+  CHECK_HEX_CONST(1000000000000);
+  CHECK_OCT_CONST(017777777777777777);
+  CHECK_HEX_CONST(1ffffffffffff);
+#endif
+#if LONG_AT_LEAST(50)
+  CHECK_OCT_CONST(020000000000000000);
+  CHECK_HEX_CONST(2000000000000);
+  CHECK_OCT_CONST(037777777777777777);
+  CHECK_HEX_CONST(3ffffffffffff);
+#endif
+#if LONG_AT_LEAST(51)
+  CHECK_OCT_CONST(040000000000000000);
+  CHECK_HEX_CONST(4000000000000);
+  CHECK_OCT_CONST(077777777777777777);
+  CHECK_HEX_CONST(7ffffffffffff);
+#endif
+#if LONG_AT_LEAST(52)
+  CHECK_OCT_CONST(0100000000000000000);
+  CHECK_HEX_CONST(8000000000000);
+  CHECK_OCT_CONST(0177777777777777777);
+  CHECK_HEX_CONST(fffffffffffff);
+#endif
+#if LONG_AT_LEAST(53)
+  CHECK_OCT_CONST(0200000000000000000);
+  CHECK_HEX_CONST(10000000000000);
+  CHECK_OCT_CONST(0377777777777777777);
+  CHECK_HEX_CONST(1fffffffffffff);
+#endif
+#if LONG_AT_LEAST(54)
+  CHECK_OCT_CONST(0400000000000000000);
+  CHECK_HEX_CONST(20000000000000);
+  CHECK_OCT_CONST(0777777777777777777);
+  CHECK_HEX_CONST(3fffffffffffff);
+#endif
+#if LONG_AT_LEAST(55)
+  CHECK_OCT_CONST(01000000000000000000);
+  CHECK_HEX_CONST(40000000000000);
+  CHECK_OCT_CONST(01777777777777777777);
+  CHECK_HEX_CONST(7fffffffffffff);
+#endif
+#if LONG_AT_LEAST(56)
+  CHECK_OCT_CONST(02000000000000000000);
+  CHECK_HEX_CONST(80000000000000);
+  CHECK_OCT_CONST(03777777777777777777);
+  CHECK_HEX_CONST(ffffffffffffff);
+#endif
+#if LONG_AT_LEAST(57)
+  CHECK_OCT_CONST(04000000000000000000);
+  CHECK_HEX_CONST(100000000000000);
+  CHECK_OCT_CONST(07777777777777777777);
+  CHECK_HEX_CONST(1ffffffffffffff);
+#endif
+#if LONG_AT_LEAST(58)
+  CHECK_OCT_CONST(010000000000000000000);
+  CHECK_HEX_CONST(200000000000000);
+  CHECK_OCT_CONST(017777777777777777777);
+  CHECK_HEX_CONST(3ffffffffffffff);
+#endif
+#if LONG_AT_LEAST(59)
+  CHECK_OCT_CONST(020000000000000000000);
+  CHECK_HEX_CONST(400000000000000);
+  CHECK_OCT_CONST(037777777777777777777);
+  CHECK_HEX_CONST(7ffffffffffffff);
+#endif
+#if LONG_AT_LEAST(60)
+  CHECK_OCT_CONST(040000000000000000000);
+  CHECK_HEX_CONST(800000000000000);
+  CHECK_OCT_CONST(077777777777777777777);
+  CHECK_HEX_CONST(fffffffffffffff);
+#endif
+#if LONG_AT_LEAST(61)
+  CHECK_OCT_CONST(0100000000000000000000);
+  CHECK_HEX_CONST(1000000000000000);
+  CHECK_OCT_CONST(0177777777777777777777);
+  CHECK_HEX_CONST(1fffffffffffffff);
+#endif
+#if LONG_AT_LEAST(62)
+  CHECK_OCT_CONST(0200000000000000000000);
+  CHECK_HEX_CONST(2000000000000000);
+  CHECK_OCT_CONST(0377777777777777777777);
+  CHECK_HEX_CONST(3fffffffffffffff);
+#endif
+#if LONG_AT_LEAST(63)
+  CHECK_OCT_CONST(0400000000000000000000);
+  CHECK_HEX_CONST(4000000000000000);
+  CHECK_OCT_CONST(0777777777777777777777);
+  CHECK_HEX_CONST(7fffffffffffffff);
+#endif
+#if LONG_AT_LEAST(64)
+  CHECK_OCT_CONST(01000000000000000000000);
+  CHECK_HEX_CONST(8000000000000000);
+  CHECK_OCT_CONST(01777777777777777777777);
+  CHECK_HEX_CONST(ffffffffffffffff);
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-intprom-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-intprom-1.c
new file mode 100644
index 000000000..78e4b39ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-intprom-1.c
@@ -0,0 +1,47 @@
+/* Test for integer promotion rules: C90 subset of types.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+#include <limits.h>
+
+#define CHECK(T1, T2, TC)			\
+  do {						\
+    T1 a = 0;					\
+    T2 b = 0;					\
+    TC *c = 0;					\
+    __typeof__(a+b) *d = 0;			\
+    c = d;					\
+    d = c;					\
+  } while (0)
+
+void
+f (void)
+{
+  /* One type is unsigned long.  */
+  CHECK(unsigned long, unsigned long, unsigned long);
+  CHECK(unsigned int, unsigned long, unsigned long);
+  CHECK(unsigned long, unsigned int, unsigned long);
+  CHECK(int, unsigned long, unsigned long);
+  CHECK(long, unsigned long, unsigned long);
+  CHECK(unsigned long, int, unsigned long);
+  CHECK(unsigned long, long, unsigned long);
+  /* long and unsigned int.  */
+#if LONG_MAX >= UINT_MAX
+  CHECK(unsigned int, long, long);
+  CHECK(long, unsigned int, long);
+#else
+  CHECK(unsigned int, long, unsigned long);
+  CHECK(long, unsigned int, unsigned long);
+#endif
+  /* One type is long.  */
+  CHECK(long, long, long);
+  CHECK(int, long, long);
+  CHECK(long, int, long);
+  /* One type is unsigned int.  */
+  CHECK(unsigned int, unsigned int, unsigned int);
+  CHECK(int, unsigned int, unsigned int);
+  CHECK(unsigned int, int, unsigned int);
+  /* Otherwise int.  */
+  CHECK(int, int, int);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-longlong-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-longlong-1.c
new file mode 100644
index 000000000..e91e39e80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-longlong-1.c
@@ -0,0 +1,7 @@
+/* Test for long long: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+long long foo; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "long long" "long long not in C90" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-mixdecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-mixdecl-1.c
new file mode 100644
index 000000000..b07ab2674
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-mixdecl-1.c
@@ -0,0 +1,13 @@
+/* Test for C99 mixed declarations and code: not in C90.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  int i;
+  i = 0;
+  int j; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "mix|parse" "mixed declarations and code not in C90" { target *-*-* } 11 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-restrict-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-restrict-1.c
new file mode 100644
index 000000000..482083151
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-restrict-1.c
@@ -0,0 +1,7 @@
+/* Test for restrict: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+char *restrict foo; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parse error|syntax error|expected|no type" "restrict not in C90" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-return-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-return-1.c
new file mode 100644
index 000000000..59e9a920b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-return-1.c
@@ -0,0 +1,17 @@
+/* Test for constraints on return statements.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+int
+foo (void)
+{
+  return;
+}
+
+void
+bar (void)
+{
+  return 1; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "with a value" "return constraint violation" { target *-*-* } 15 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-scope-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-scope-1.c
new file mode 100644
index 000000000..ad36b7063
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-scope-1.c
@@ -0,0 +1,34 @@
+/* Test for new block scopes in C99.  Inspired by C99 Rationale (N897).  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+struct foo {
+  char a;
+};
+
+extern void abort (void);
+extern void exit (int);
+
+int
+sfoo (void)
+{
+  if (sizeof (struct foo { int a; double b; char *c; void *d; }))
+    (void) 0;
+  return sizeof (struct foo);
+}
+
+int
+main (void)
+{
+  int t, u;
+  t = sfoo ();
+  u = sizeof (struct foo);
+  /* With C90 scoping rules the new declaration of struct foo is in scope
+     above; with C99 it is local to the if.
+  */
+  if (t == u)
+    abort (); /* C99 rules apply.  */
+  else
+    exit (0); /* C90 rules apply.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-static-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-static-1.c
new file mode 100644
index 000000000..cc6f320c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-static-1.c
@@ -0,0 +1,22 @@
+/* It is a constraint violation for a static function to be declared
+   but not defined if it is used except in a sizeof expression.  The
+   use of the function simply being unevaluated is not enough.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=iso9899:1990 -pedantic-errors" } */
+
+/* Constraint violation (trivial case, where function is used).  */
+static void f0(void); /* { dg-error "used but never defined" } */
+void g0(void) { f0(); }
+
+/* Constraint violation.  */
+static void f1(void); /* { dg-error "used but never defined" } */
+void g1(void) { if (0) { f1(); } }
+
+/* Constraint violation.  */
+static int f2(void); /* { dg-error "used but never defined" } */
+void g2(void) { 0 ? f2() : 0; }
+
+/* OK.  */
+static int f3(void);
+void g3(void) { sizeof(f3()); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-typespec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-typespec-1.c
new file mode 100644
index 000000000..e32111b63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-typespec-1.c
@@ -0,0 +1,522 @@
+/* Test for valid and invalid combinations of type specifiers in C90.
+   Similar to typespec-1.c but with -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+typedef char type;
+extern *x0;
+void *x1;
+char *x2;
+short *x3;
+int *x4;
+long *x5;
+float *x6;
+double *x7;
+signed *x8;
+unsigned *x9;
+type *x10;
+void void *x11; /* { dg-error "" "void void" } */
+void char *x12; /* { dg-error "" "void char" } */
+void short *x13; /* { dg-error "" "void short" } */
+void int *x14; /* { dg-error "" "void int" } */
+void long *x15; /* { dg-error "" "void long" } */
+void float *x16; /* { dg-error "" "void float" } */
+void double *x17; /* { dg-error "" "void double" } */
+void signed *x18; /* { dg-error "" "void signed" } */
+void unsigned *x19; /* { dg-error "" "void unsigned" } */
+char void *x20; /* { dg-error "" "char void" } */
+char char *x21; /* { dg-error "" "char char" } */
+char short *x22; /* { dg-error "" "char short" } */
+char int *x23; /* { dg-error "" "char int" } */
+char long *x24; /* { dg-error "" "char long" } */
+char float *x25; /* { dg-error "" "char float" } */
+char double *x26; /* { dg-error "" "char double" } */
+char signed *x27;
+char unsigned *x28;
+short void *x29; /* { dg-error "" "short void" } */
+short char *x30; /* { dg-error "" "short char" } */
+short short *x31; /* { dg-error "" "short short" } */
+short int *x32;
+short long *x33; /* { dg-error "" "short long" } */
+short float *x34; /* { dg-error "" "short float" } */
+short double *x35; /* { dg-error "" "short double" } */
+short signed *x36;
+short unsigned *x37;
+int void *x38; /* { dg-error "" "int void" } */
+int char *x39; /* { dg-error "" "int char" } */
+int short *x40;
+int int *x41; /* { dg-error "" "int int" } */
+int long *x42;
+int float *x43; /* { dg-error "" "int float" } */
+int double *x44; /* { dg-error "" "int double" } */
+int signed *x45;
+int unsigned *x46;
+long void *x47; /* { dg-error "" "long void" } */
+long char *x48; /* { dg-error "" "long char" } */
+long short *x49; /* { dg-error "" "long short" } */
+long int *x50;
+long long *x51; /* { dg-error "" "long long" } */
+long float *x52; /* { dg-error "" "long float" } */
+long double *x53;
+long signed *x54;
+long unsigned *x55;
+float void *x56; /* { dg-error "" "float void" } */
+float char *x57; /* { dg-error "" "float char" } */
+float short *x58; /* { dg-error "" "float short" } */
+float int *x59; /* { dg-error "" "float int" } */
+float long *x60; /* { dg-error "" "float long" } */
+float float *x61; /* { dg-error "" "float float" } */
+float double *x62; /* { dg-error "" "float double" } */
+float signed *x63; /* { dg-error "" "float signed" } */
+float unsigned *x64; /* { dg-error "" "float unsigned" } */
+double void *x65; /* { dg-error "" "double void" } */
+double char *x66; /* { dg-error "" "double char" } */
+double short *x67; /* { dg-error "" "double short" } */
+double int *x68; /* { dg-error "" "double int" } */
+double long *x69;
+double float *x70; /* { dg-error "" "double float" } */
+double double *x71; /* { dg-error "" "double double" } */
+double signed *x72; /* { dg-error "" "double signed" } */
+double unsigned *x73; /* { dg-error "" "double unsigned" } */
+signed void *x74; /* { dg-error "" "signed void" } */
+signed char *x75;
+signed short *x76;
+signed int *x77;
+signed long *x78;
+signed float *x79; /* { dg-error "" "signed float" } */
+signed double *x80; /* { dg-error "" "signed double" } */
+signed signed *x81; /* { dg-error "" "signed signed" } */
+signed unsigned *x82; /* { dg-error "" "signed unsigned" } */
+unsigned void *x83; /* { dg-error "" "unsigned void" } */
+unsigned char *x84;
+unsigned short *x85;
+unsigned int *x86;
+unsigned long *x87;
+unsigned float *x88; /* { dg-error "" "unsigned float" } */
+unsigned double *x89; /* { dg-error "" "unsigned double" } */
+unsigned signed *x90; /* { dg-error "" "unsigned signed" } */
+unsigned unsigned *x91; /* { dg-error "" "unsigned unsigned" } */
+type void *x92; /* { dg-error "" "type void" } */
+type char *x93; /* { dg-error "" "type char" } */
+type short *x94; /* { dg-error "" "type short" } */
+type int *x95; /* { dg-error "" "type int" } */
+type long *x96; /* { dg-error "" "type long" } */
+type float *x97; /* { dg-error "" "type float" } */
+type double *x98; /* { dg-error "" "type double" } */
+type signed *x99; /* { dg-error "" "type signed" } */
+type unsigned *x100; /* { dg-error "" "type unsigned" } */
+char signed void *x101; /* { dg-error "" "char signed void" } */
+char signed char *x102; /* { dg-error "" "char signed char" } */
+char signed short *x103; /* { dg-error "" "char signed short" } */
+char signed int *x104; /* { dg-error "" "char signed int" } */
+char signed long *x105; /* { dg-error "" "char signed long" } */
+char signed float *x106; /* { dg-error "" "char signed float" } */
+char signed double *x107; /* { dg-error "" "char signed double" } */
+char signed signed *x108; /* { dg-error "" "char signed signed" } */
+char signed unsigned *x109; /* { dg-error "" "char signed unsigned" } */
+char unsigned void *x110; /* { dg-error "" "char unsigned void" } */
+char unsigned char *x111; /* { dg-error "" "char unsigned char" } */
+char unsigned short *x112; /* { dg-error "" "char unsigned short" } */
+char unsigned int *x113; /* { dg-error "" "char unsigned int" } */
+char unsigned long *x114; /* { dg-error "" "char unsigned long" } */
+char unsigned float *x115; /* { dg-error "" "char unsigned float" } */
+char unsigned double *x116; /* { dg-error "" "char unsigned double" } */
+char unsigned signed *x117; /* { dg-error "" "char unsigned signed" } */
+char unsigned unsigned *x118; /* { dg-error "" "char unsigned unsigned" } */
+short int void *x119; /* { dg-error "" "short int void" } */
+short int char *x120; /* { dg-error "" "short int char" } */
+short int short *x121; /* { dg-error "" "short int short" } */
+short int int *x122; /* { dg-error "" "short int int" } */
+short int long *x123; /* { dg-error "" "short int long" } */
+short int float *x124; /* { dg-error "" "short int float" } */
+short int double *x125; /* { dg-error "" "short int double" } */
+short int signed *x126;
+short int unsigned *x127;
+short signed void *x128; /* { dg-error "" "short signed void" } */
+short signed char *x129; /* { dg-error "" "short signed char" } */
+short signed short *x130; /* { dg-error "" "short signed short" } */
+short signed int *x131;
+short signed long *x132; /* { dg-error "" "short signed long" } */
+short signed float *x133; /* { dg-error "" "short signed float" } */
+short signed double *x134; /* { dg-error "" "short signed double" } */
+short signed signed *x135; /* { dg-error "" "short signed signed" } */
+short signed unsigned *x136; /* { dg-error "" "short signed unsigned" } */
+short unsigned void *x137; /* { dg-error "" "short unsigned void" } */
+short unsigned char *x138; /* { dg-error "" "short unsigned char" } */
+short unsigned short *x139; /* { dg-error "" "short unsigned short" } */
+short unsigned int *x140;
+short unsigned long *x141; /* { dg-error "" "short unsigned long" } */
+short unsigned float *x142; /* { dg-error "" "short unsigned float" } */
+short unsigned double *x143; /* { dg-error "" "short unsigned double" } */
+short unsigned signed *x144; /* { dg-error "" "short unsigned signed" } */
+short unsigned unsigned *x145; /* { dg-error "" "short unsigned unsigned" } */
+int short void *x146; /* { dg-error "" "int short void" } */
+int short char *x147; /* { dg-error "" "int short char" } */
+int short short *x148; /* { dg-error "" "int short short" } */
+int short int *x149; /* { dg-error "" "int short int" } */
+int short long *x150; /* { dg-error "" "int short long" } */
+int short float *x151; /* { dg-error "" "int short float" } */
+int short double *x152; /* { dg-error "" "int short double" } */
+int short signed *x153;
+int short unsigned *x154;
+int long void *x155; /* { dg-error "" "int long void" } */
+int long char *x156; /* { dg-error "" "int long char" } */
+int long short *x157; /* { dg-error "" "int long short" } */
+int long int *x158; /* { dg-error "" "int long int" } */
+int long long *x159; /* { dg-error "" "int long long" } */
+int long float *x160; /* { dg-error "" "int long float" } */
+int long double *x161; /* { dg-error "" "int long double" } */
+int long signed *x162;
+int long unsigned *x163;
+int signed void *x164; /* { dg-error "" "int signed void" } */
+int signed char *x165; /* { dg-error "" "int signed char" } */
+int signed short *x166;
+int signed int *x167; /* { dg-error "" "int signed int" } */
+int signed long *x168;
+int signed float *x169; /* { dg-error "" "int signed float" } */
+int signed double *x170; /* { dg-error "" "int signed double" } */
+int signed signed *x171; /* { dg-error "" "int signed signed" } */
+int signed unsigned *x172; /* { dg-error "" "int signed unsigned" } */
+int unsigned void *x173; /* { dg-error "" "int unsigned void" } */
+int unsigned char *x174; /* { dg-error "" "int unsigned char" } */
+int unsigned short *x175;
+int unsigned int *x176; /* { dg-error "" "int unsigned int" } */
+int unsigned long *x177;
+int unsigned float *x178; /* { dg-error "" "int unsigned float" } */
+int unsigned double *x179; /* { dg-error "" "int unsigned double" } */
+int unsigned signed *x180; /* { dg-error "" "int unsigned signed" } */
+int unsigned unsigned *x181; /* { dg-error "" "int unsigned unsigned" } */
+long int void *x182; /* { dg-error "" "long int void" } */
+long int char *x183; /* { dg-error "" "long int char" } */
+long int short *x184; /* { dg-error "" "long int short" } */
+long int int *x185; /* { dg-error "" "long int int" } */
+long int long *x186; /* { dg-error "" "long int long" } */
+long int float *x187; /* { dg-error "" "long int float" } */
+long int double *x188; /* { dg-error "" "long int double" } */
+long int signed *x189;
+long int unsigned *x190;
+long double void *x191; /* { dg-error "" "long double void" } */
+long double char *x192; /* { dg-error "" "long double char" } */
+long double short *x193; /* { dg-error "" "long double short" } */
+long double int *x194; /* { dg-error "" "long double int" } */
+long double long *x195; /* { dg-error "" "long double long" } */
+long double float *x196; /* { dg-error "" "long double float" } */
+long double double *x197; /* { dg-error "" "long double double" } */
+long double signed *x198; /* { dg-error "" "long double signed" } */
+long double unsigned *x199; /* { dg-error "" "long double unsigned" } */
+long signed void *x200; /* { dg-error "" "long signed void" } */
+long signed char *x201; /* { dg-error "" "long signed char" } */
+long signed short *x202; /* { dg-error "" "long signed short" } */
+long signed int *x203;
+long signed long *x204; /* { dg-error "" "long signed long" } */
+long signed float *x205; /* { dg-error "" "long signed float" } */
+long signed double *x206; /* { dg-error "" "long signed double" } */
+long signed signed *x207; /* { dg-error "" "long signed signed" } */
+long signed unsigned *x208; /* { dg-error "" "long signed unsigned" } */
+long unsigned void *x209; /* { dg-error "" "long unsigned void" } */
+long unsigned char *x210; /* { dg-error "" "long unsigned char" } */
+long unsigned short *x211; /* { dg-error "" "long unsigned short" } */
+long unsigned int *x212;
+long unsigned long *x213; /* { dg-error "" "long unsigned long" } */
+long unsigned float *x214; /* { dg-error "" "long unsigned float" } */
+long unsigned double *x215; /* { dg-error "" "long unsigned double" } */
+long unsigned signed *x216; /* { dg-error "" "long unsigned signed" } */
+long unsigned unsigned *x217; /* { dg-error "" "long unsigned unsigned" } */
+double long void *x218; /* { dg-error "" "double long void" } */
+double long char *x219; /* { dg-error "" "double long char" } */
+double long short *x220; /* { dg-error "" "double long short" } */
+double long int *x221; /* { dg-error "" "double long int" } */
+double long long *x222; /* { dg-error "" "double long long" } */
+double long float *x223; /* { dg-error "" "double long float" } */
+double long double *x224; /* { dg-error "" "double long double" } */
+double long signed *x225; /* { dg-error "" "double long signed" } */
+double long unsigned *x226; /* { dg-error "" "double long unsigned" } */
+signed char void *x227; /* { dg-error "" "signed char void" } */
+signed char char *x228; /* { dg-error "" "signed char char" } */
+signed char short *x229; /* { dg-error "" "signed char short" } */
+signed char int *x230; /* { dg-error "" "signed char int" } */
+signed char long *x231; /* { dg-error "" "signed char long" } */
+signed char float *x232; /* { dg-error "" "signed char float" } */
+signed char double *x233; /* { dg-error "" "signed char double" } */
+signed char signed *x234; /* { dg-error "" "signed char signed" } */
+signed char unsigned *x235; /* { dg-error "" "signed char unsigned" } */
+signed short void *x236; /* { dg-error "" "signed short void" } */
+signed short char *x237; /* { dg-error "" "signed short char" } */
+signed short short *x238; /* { dg-error "" "signed short short" } */
+signed short int *x239;
+signed short long *x240; /* { dg-error "" "signed short long" } */
+signed short float *x241; /* { dg-error "" "signed short float" } */
+signed short double *x242; /* { dg-error "" "signed short double" } */
+signed short signed *x243; /* { dg-error "" "signed short signed" } */
+signed short unsigned *x244; /* { dg-error "" "signed short unsigned" } */
+signed int void *x245; /* { dg-error "" "signed int void" } */
+signed int char *x246; /* { dg-error "" "signed int char" } */
+signed int short *x247;
+signed int int *x248; /* { dg-error "" "signed int int" } */
+signed int long *x249;
+signed int float *x250; /* { dg-error "" "signed int float" } */
+signed int double *x251; /* { dg-error "" "signed int double" } */
+signed int signed *x252; /* { dg-error "" "signed int signed" } */
+signed int unsigned *x253; /* { dg-error "" "signed int unsigned" } */
+signed long void *x254; /* { dg-error "" "signed long void" } */
+signed long char *x255; /* { dg-error "" "signed long char" } */
+signed long short *x256; /* { dg-error "" "signed long short" } */
+signed long int *x257;
+signed long long *x258; /* { dg-error "" "signed long long" } */
+signed long float *x259; /* { dg-error "" "signed long float" } */
+signed long double *x260; /* { dg-error "" "signed long double" } */
+signed long signed *x261; /* { dg-error "" "signed long signed" } */
+signed long unsigned *x262; /* { dg-error "" "signed long unsigned" } */
+unsigned char void *x263; /* { dg-error "" "unsigned char void" } */
+unsigned char char *x264; /* { dg-error "" "unsigned char char" } */
+unsigned char short *x265; /* { dg-error "" "unsigned char short" } */
+unsigned char int *x266; /* { dg-error "" "unsigned char int" } */
+unsigned char long *x267; /* { dg-error "" "unsigned char long" } */
+unsigned char float *x268; /* { dg-error "" "unsigned char float" } */
+unsigned char double *x269; /* { dg-error "" "unsigned char double" } */
+unsigned char signed *x270; /* { dg-error "" "unsigned char signed" } */
+unsigned char unsigned *x271; /* { dg-error "" "unsigned char unsigned" } */
+unsigned short void *x272; /* { dg-error "" "unsigned short void" } */
+unsigned short char *x273; /* { dg-error "" "unsigned short char" } */
+unsigned short short *x274; /* { dg-error "" "unsigned short short" } */
+unsigned short int *x275;
+unsigned short long *x276; /* { dg-error "" "unsigned short long" } */
+unsigned short float *x277; /* { dg-error "" "unsigned short float" } */
+unsigned short double *x278; /* { dg-error "" "unsigned short double" } */
+unsigned short signed *x279; /* { dg-error "" "unsigned short signed" } */
+unsigned short unsigned *x280; /* { dg-error "" "unsigned short unsigned" } */
+unsigned int void *x281; /* { dg-error "" "unsigned int void" } */
+unsigned int char *x282; /* { dg-error "" "unsigned int char" } */
+unsigned int short *x283;
+unsigned int int *x284; /* { dg-error "" "unsigned int int" } */
+unsigned int long *x285;
+unsigned int float *x286; /* { dg-error "" "unsigned int float" } */
+unsigned int double *x287; /* { dg-error "" "unsigned int double" } */
+unsigned int signed *x288; /* { dg-error "" "unsigned int signed" } */
+unsigned int unsigned *x289; /* { dg-error "" "unsigned int unsigned" } */
+unsigned long void *x290; /* { dg-error "" "unsigned long void" } */
+unsigned long char *x291; /* { dg-error "" "unsigned long char" } */
+unsigned long short *x292; /* { dg-error "" "unsigned long short" } */
+unsigned long int *x293;
+unsigned long long *x294; /* { dg-error "" "unsigned long long" } */
+unsigned long float *x295; /* { dg-error "" "unsigned long float" } */
+unsigned long double *x296; /* { dg-error "" "unsigned long double" } */
+unsigned long signed *x297; /* { dg-error "" "unsigned long signed" } */
+unsigned long unsigned *x298; /* { dg-error "" "unsigned long unsigned" } */
+short int signed void *x299; /* { dg-error "" "short int signed void" } */
+short int signed char *x300; /* { dg-error "" "short int signed char" } */
+short int signed short *x301; /* { dg-error "" "short int signed short" } */
+short int signed int *x302; /* { dg-error "" "short int signed int" } */
+short int signed long *x303; /* { dg-error "" "short int signed long" } */
+short int signed float *x304; /* { dg-error "" "short int signed float" } */
+short int signed double *x305; /* { dg-error "" "short int signed double" } */
+short int signed signed *x306; /* { dg-error "" "short int signed signed" } */
+short int signed unsigned *x307; /* { dg-error "" "short int signed unsigned" } */
+short int unsigned void *x308; /* { dg-error "" "short int unsigned void" } */
+short int unsigned char *x309; /* { dg-error "" "short int unsigned char" } */
+short int unsigned short *x310; /* { dg-error "" "short int unsigned short" } */
+short int unsigned int *x311; /* { dg-error "" "short int unsigned int" } */
+short int unsigned long *x312; /* { dg-error "" "short int unsigned long" } */
+short int unsigned float *x313; /* { dg-error "" "short int unsigned float" } */
+short int unsigned double *x314; /* { dg-error "" "short int unsigned double" } */
+short int unsigned signed *x315; /* { dg-error "" "short int unsigned signed" } */
+short int unsigned unsigned *x316; /* { dg-error "" "short int unsigned unsigned" } */
+short signed int void *x317; /* { dg-error "" "short signed int void" } */
+short signed int char *x318; /* { dg-error "" "short signed int char" } */
+short signed int short *x319; /* { dg-error "" "short signed int short" } */
+short signed int int *x320; /* { dg-error "" "short signed int int" } */
+short signed int long *x321; /* { dg-error "" "short signed int long" } */
+short signed int float *x322; /* { dg-error "" "short signed int float" } */
+short signed int double *x323; /* { dg-error "" "short signed int double" } */
+short signed int signed *x324; /* { dg-error "" "short signed int signed" } */
+short signed int unsigned *x325; /* { dg-error "" "short signed int unsigned" } */
+short unsigned int void *x326; /* { dg-error "" "short unsigned int void" } */
+short unsigned int char *x327; /* { dg-error "" "short unsigned int char" } */
+short unsigned int short *x328; /* { dg-error "" "short unsigned int short" } */
+short unsigned int int *x329; /* { dg-error "" "short unsigned int int" } */
+short unsigned int long *x330; /* { dg-error "" "short unsigned int long" } */
+short unsigned int float *x331; /* { dg-error "" "short unsigned int float" } */
+short unsigned int double *x332; /* { dg-error "" "short unsigned int double" } */
+short unsigned int signed *x333; /* { dg-error "" "short unsigned int signed" } */
+short unsigned int unsigned *x334; /* { dg-error "" "short unsigned int unsigned" } */
+int short signed void *x335; /* { dg-error "" "int short signed void" } */
+int short signed char *x336; /* { dg-error "" "int short signed char" } */
+int short signed short *x337; /* { dg-error "" "int short signed short" } */
+int short signed int *x338; /* { dg-error "" "int short signed int" } */
+int short signed long *x339; /* { dg-error "" "int short signed long" } */
+int short signed float *x340; /* { dg-error "" "int short signed float" } */
+int short signed double *x341; /* { dg-error "" "int short signed double" } */
+int short signed signed *x342; /* { dg-error "" "int short signed signed" } */
+int short signed unsigned *x343; /* { dg-error "" "int short signed unsigned" } */
+int short unsigned void *x344; /* { dg-error "" "int short unsigned void" } */
+int short unsigned char *x345; /* { dg-error "" "int short unsigned char" } */
+int short unsigned short *x346; /* { dg-error "" "int short unsigned short" } */
+int short unsigned int *x347; /* { dg-error "" "int short unsigned int" } */
+int short unsigned long *x348; /* { dg-error "" "int short unsigned long" } */
+int short unsigned float *x349; /* { dg-error "" "int short unsigned float" } */
+int short unsigned double *x350; /* { dg-error "" "int short unsigned double" } */
+int short unsigned signed *x351; /* { dg-error "" "int short unsigned signed" } */
+int short unsigned unsigned *x352; /* { dg-error "" "int short unsigned unsigned" } */
+int long signed void *x353; /* { dg-error "" "int long signed void" } */
+int long signed char *x354; /* { dg-error "" "int long signed char" } */
+int long signed short *x355; /* { dg-error "" "int long signed short" } */
+int long signed int *x356; /* { dg-error "" "int long signed int" } */
+int long signed long *x357; /* { dg-error "" "int long signed long" } */
+int long signed float *x358; /* { dg-error "" "int long signed float" } */
+int long signed double *x359; /* { dg-error "" "int long signed double" } */
+int long signed signed *x360; /* { dg-error "" "int long signed signed" } */
+int long signed unsigned *x361; /* { dg-error "" "int long signed unsigned" } */
+int long unsigned void *x362; /* { dg-error "" "int long unsigned void" } */
+int long unsigned char *x363; /* { dg-error "" "int long unsigned char" } */
+int long unsigned short *x364; /* { dg-error "" "int long unsigned short" } */
+int long unsigned int *x365; /* { dg-error "" "int long unsigned int" } */
+int long unsigned long *x366; /* { dg-error "" "int long unsigned long" } */
+int long unsigned float *x367; /* { dg-error "" "int long unsigned float" } */
+int long unsigned double *x368; /* { dg-error "" "int long unsigned double" } */
+int long unsigned signed *x369; /* { dg-error "" "int long unsigned signed" } */
+int long unsigned unsigned *x370; /* { dg-error "" "int long unsigned unsigned" } */
+int signed short void *x371; /* { dg-error "" "int signed short void" } */
+int signed short char *x372; /* { dg-error "" "int signed short char" } */
+int signed short short *x373; /* { dg-error "" "int signed short short" } */
+int signed short int *x374; /* { dg-error "" "int signed short int" } */
+int signed short long *x375; /* { dg-error "" "int signed short long" } */
+int signed short float *x376; /* { dg-error "" "int signed short float" } */
+int signed short double *x377; /* { dg-error "" "int signed short double" } */
+int signed short signed *x378; /* { dg-error "" "int signed short signed" } */
+int signed short unsigned *x379; /* { dg-error "" "int signed short unsigned" } */
+int signed long void *x380; /* { dg-error "" "int signed long void" } */
+int signed long char *x381; /* { dg-error "" "int signed long char" } */
+int signed long short *x382; /* { dg-error "" "int signed long short" } */
+int signed long int *x383; /* { dg-error "" "int signed long int" } */
+int signed long long *x384; /* { dg-error "" "int signed long long" } */
+int signed long float *x385; /* { dg-error "" "int signed long float" } */
+int signed long double *x386; /* { dg-error "" "int signed long double" } */
+int signed long signed *x387; /* { dg-error "" "int signed long signed" } */
+int signed long unsigned *x388; /* { dg-error "" "int signed long unsigned" } */
+int unsigned short void *x389; /* { dg-error "" "int unsigned short void" } */
+int unsigned short char *x390; /* { dg-error "" "int unsigned short char" } */
+int unsigned short short *x391; /* { dg-error "" "int unsigned short short" } */
+int unsigned short int *x392; /* { dg-error "" "int unsigned short int" } */
+int unsigned short long *x393; /* { dg-error "" "int unsigned short long" } */
+int unsigned short float *x394; /* { dg-error "" "int unsigned short float" } */
+int unsigned short double *x395; /* { dg-error "" "int unsigned short double" } */
+int unsigned short signed *x396; /* { dg-error "" "int unsigned short signed" } */
+int unsigned short unsigned *x397; /* { dg-error "" "int unsigned short unsigned" } */
+int unsigned long void *x398; /* { dg-error "" "int unsigned long void" } */
+int unsigned long char *x399; /* { dg-error "" "int unsigned long char" } */
+int unsigned long short *x400; /* { dg-error "" "int unsigned long short" } */
+int unsigned long int *x401; /* { dg-error "" "int unsigned long int" } */
+int unsigned long long *x402; /* { dg-error "" "int unsigned long long" } */
+int unsigned long float *x403; /* { dg-error "" "int unsigned long float" } */
+int unsigned long double *x404; /* { dg-error "" "int unsigned long double" } */
+int unsigned long signed *x405; /* { dg-error "" "int unsigned long signed" } */
+int unsigned long unsigned *x406; /* { dg-error "" "int unsigned long unsigned" } */
+long int signed void *x407; /* { dg-error "" "long int signed void" } */
+long int signed char *x408; /* { dg-error "" "long int signed char" } */
+long int signed short *x409; /* { dg-error "" "long int signed short" } */
+long int signed int *x410; /* { dg-error "" "long int signed int" } */
+long int signed long *x411; /* { dg-error "" "long int signed long" } */
+long int signed float *x412; /* { dg-error "" "long int signed float" } */
+long int signed double *x413; /* { dg-error "" "long int signed double" } */
+long int signed signed *x414; /* { dg-error "" "long int signed signed" } */
+long int signed unsigned *x415; /* { dg-error "" "long int signed unsigned" } */
+long int unsigned void *x416; /* { dg-error "" "long int unsigned void" } */
+long int unsigned char *x417; /* { dg-error "" "long int unsigned char" } */
+long int unsigned short *x418; /* { dg-error "" "long int unsigned short" } */
+long int unsigned int *x419; /* { dg-error "" "long int unsigned int" } */
+long int unsigned long *x420; /* { dg-error "" "long int unsigned long" } */
+long int unsigned float *x421; /* { dg-error "" "long int unsigned float" } */
+long int unsigned double *x422; /* { dg-error "" "long int unsigned double" } */
+long int unsigned signed *x423; /* { dg-error "" "long int unsigned signed" } */
+long int unsigned unsigned *x424; /* { dg-error "" "long int unsigned unsigned" } */
+long signed int void *x425; /* { dg-error "" "long signed int void" } */
+long signed int char *x426; /* { dg-error "" "long signed int char" } */
+long signed int short *x427; /* { dg-error "" "long signed int short" } */
+long signed int int *x428; /* { dg-error "" "long signed int int" } */
+long signed int long *x429; /* { dg-error "" "long signed int long" } */
+long signed int float *x430; /* { dg-error "" "long signed int float" } */
+long signed int double *x431; /* { dg-error "" "long signed int double" } */
+long signed int signed *x432; /* { dg-error "" "long signed int signed" } */
+long signed int unsigned *x433; /* { dg-error "" "long signed int unsigned" } */
+long unsigned int void *x434; /* { dg-error "" "long unsigned int void" } */
+long unsigned int char *x435; /* { dg-error "" "long unsigned int char" } */
+long unsigned int short *x436; /* { dg-error "" "long unsigned int short" } */
+long unsigned int int *x437; /* { dg-error "" "long unsigned int int" } */
+long unsigned int long *x438; /* { dg-error "" "long unsigned int long" } */
+long unsigned int float *x439; /* { dg-error "" "long unsigned int float" } */
+long unsigned int double *x440; /* { dg-error "" "long unsigned int double" } */
+long unsigned int signed *x441; /* { dg-error "" "long unsigned int signed" } */
+long unsigned int unsigned *x442; /* { dg-error "" "long unsigned int unsigned" } */
+signed short int void *x443; /* { dg-error "" "signed short int void" } */
+signed short int char *x444; /* { dg-error "" "signed short int char" } */
+signed short int short *x445; /* { dg-error "" "signed short int short" } */
+signed short int int *x446; /* { dg-error "" "signed short int int" } */
+signed short int long *x447; /* { dg-error "" "signed short int long" } */
+signed short int float *x448; /* { dg-error "" "signed short int float" } */
+signed short int double *x449; /* { dg-error "" "signed short int double" } */
+signed short int signed *x450; /* { dg-error "" "signed short int signed" } */
+signed short int unsigned *x451; /* { dg-error "" "signed short int unsigned" } */
+signed int short void *x452; /* { dg-error "" "signed int short void" } */
+signed int short char *x453; /* { dg-error "" "signed int short char" } */
+signed int short short *x454; /* { dg-error "" "signed int short short" } */
+signed int short int *x455; /* { dg-error "" "signed int short int" } */
+signed int short long *x456; /* { dg-error "" "signed int short long" } */
+signed int short float *x457; /* { dg-error "" "signed int short float" } */
+signed int short double *x458; /* { dg-error "" "signed int short double" } */
+signed int short signed *x459; /* { dg-error "" "signed int short signed" } */
+signed int short unsigned *x460; /* { dg-error "" "signed int short unsigned" } */
+signed int long void *x461; /* { dg-error "" "signed int long void" } */
+signed int long char *x462; /* { dg-error "" "signed int long char" } */
+signed int long short *x463; /* { dg-error "" "signed int long short" } */
+signed int long int *x464; /* { dg-error "" "signed int long int" } */
+signed int long long *x465; /* { dg-error "" "signed int long long" } */
+signed int long float *x466; /* { dg-error "" "signed int long float" } */
+signed int long double *x467; /* { dg-error "" "signed int long double" } */
+signed int long signed *x468; /* { dg-error "" "signed int long signed" } */
+signed int long unsigned *x469; /* { dg-error "" "signed int long unsigned" } */
+signed long int void *x470; /* { dg-error "" "signed long int void" } */
+signed long int char *x471; /* { dg-error "" "signed long int char" } */
+signed long int short *x472; /* { dg-error "" "signed long int short" } */
+signed long int int *x473; /* { dg-error "" "signed long int int" } */
+signed long int long *x474; /* { dg-error "" "signed long int long" } */
+signed long int float *x475; /* { dg-error "" "signed long int float" } */
+signed long int double *x476; /* { dg-error "" "signed long int double" } */
+signed long int signed *x477; /* { dg-error "" "signed long int signed" } */
+signed long int unsigned *x478; /* { dg-error "" "signed long int unsigned" } */
+unsigned short int void *x479; /* { dg-error "" "unsigned short int void" } */
+unsigned short int char *x480; /* { dg-error "" "unsigned short int char" } */
+unsigned short int short *x481; /* { dg-error "" "unsigned short int short" } */
+unsigned short int int *x482; /* { dg-error "" "unsigned short int int" } */
+unsigned short int long *x483; /* { dg-error "" "unsigned short int long" } */
+unsigned short int float *x484; /* { dg-error "" "unsigned short int float" } */
+unsigned short int double *x485; /* { dg-error "" "unsigned short int double" } */
+unsigned short int signed *x486; /* { dg-error "" "unsigned short int signed" } */
+unsigned short int unsigned *x487; /* { dg-error "" "unsigned short int unsigned" } */
+unsigned int short void *x488; /* { dg-error "" "unsigned int short void" } */
+unsigned int short char *x489; /* { dg-error "" "unsigned int short char" } */
+unsigned int short short *x490; /* { dg-error "" "unsigned int short short" } */
+unsigned int short int *x491; /* { dg-error "" "unsigned int short int" } */
+unsigned int short long *x492; /* { dg-error "" "unsigned int short long" } */
+unsigned int short float *x493; /* { dg-error "" "unsigned int short float" } */
+unsigned int short double *x494; /* { dg-error "" "unsigned int short double" } */
+unsigned int short signed *x495; /* { dg-error "" "unsigned int short signed" } */
+unsigned int short unsigned *x496; /* { dg-error "" "unsigned int short unsigned" } */
+unsigned int long void *x497; /* { dg-error "" "unsigned int long void" } */
+unsigned int long char *x498; /* { dg-error "" "unsigned int long char" } */
+unsigned int long short *x499; /* { dg-error "" "unsigned int long short" } */
+unsigned int long int *x500; /* { dg-error "" "unsigned int long int" } */
+unsigned int long long *x501; /* { dg-error "" "unsigned int long long" } */
+unsigned int long float *x502; /* { dg-error "" "unsigned int long float" } */
+unsigned int long double *x503; /* { dg-error "" "unsigned int long double" } */
+unsigned int long signed *x504; /* { dg-error "" "unsigned int long signed" } */
+unsigned int long unsigned *x505; /* { dg-error "" "unsigned int long unsigned" } */
+unsigned long int void *x506; /* { dg-error "" "unsigned long int void" } */
+unsigned long int char *x507; /* { dg-error "" "unsigned long int char" } */
+unsigned long int short *x508; /* { dg-error "" "unsigned long int short" } */
+unsigned long int int *x509; /* { dg-error "" "unsigned long int int" } */
+unsigned long int long *x510; /* { dg-error "" "unsigned long int long" } */
+unsigned long int float *x511; /* { dg-error "" "unsigned long int float" } */
+unsigned long int double *x512; /* { dg-error "" "unsigned long int double" } */
+unsigned long int signed *x513; /* { dg-error "" "unsigned long int signed" } */
+unsigned long int unsigned *x514; /* { dg-error "" "unsigned long int unsigned" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-vla-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-vla-1.c
new file mode 100644
index 000000000..2d9b5f10b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c90-vla-1.c
@@ -0,0 +1,12 @@
+/* Origin: PR 3467 */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+void
+tdef (int n)
+{
+  typedef int A[n];	/* { dg-error "forbids variable length array" } */
+  A a;
+  A *p;
+  p = &a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c94-digraph-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c94-digraph-1.c
new file mode 100644
index 000000000..55d77146b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c94-digraph-1.c
@@ -0,0 +1,24 @@
+/* Test for recognition of digraphs: should be recognized in C94 and C99
+   mode, but not in C90 mode.  Also check correct stringizing.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:199409 -pedantic-errors" } */
+
+#define str(x) xstr(x)
+#define xstr(x) #x
+#define foo(p, q) str(p %:%: q)
+
+extern void abort (void);
+extern int strcmp (const char *, const char *);
+
+int
+main (void)
+{
+  const char *t = foo (1, 2);
+  const char *u = str (<:);
+  if (strcmp (t, "12") || strcmp (u, "<:"))
+    abort ();
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-1.c
new file mode 100644
index 000000000..c0fccc813
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-1.c
@@ -0,0 +1,17 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char c[1]; };
+
+extern struct s foo (void);
+
+void
+bar (void)
+{
+  char *t;
+  (foo ()).c[0]; /* { dg-bogus "non-lvalue" "array not decaying to lvalue" } */
+  t = (foo ()).c; /* { dg-bogus "non-lvalue" "array not decaying to lvalue" } */
+  (foo ()).c + 1; /* { dg-bogus "non-lvalue" "array not decaying to lvalue" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-2.c
new file mode 100644
index 000000000..894ff957a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-2.c
@@ -0,0 +1,18 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char c[17]; };
+
+struct s x;
+
+extern struct s foo (void);
+
+#define ASSERT(v, a)	char v[((a) ? 1 : -1)]
+
+ASSERT (p, sizeof (x.c) == 17);
+ASSERT (q, sizeof (0, x.c) == sizeof (char *));
+ASSERT (r, sizeof ((foo ()).c) == 17);
+/* The non-lvalue array decays to a pointer in C99.  */
+ASSERT (s, sizeof (0, (foo ()).c) == sizeof (char *)); /* { dg-bogus "array" "bad non-lvalue array handling" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-3.c
new file mode 100644
index 000000000..a12a9600b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-3.c
@@ -0,0 +1,24 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.
+   Test various ways of producing non-lvalue arrays.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char c[1]; };
+struct s a, b, c;
+int d;
+
+void
+bar (void)
+{
+  char *t;
+  (d ? b : c).c[0];
+  (d, b).c[0];
+  (a = b).c[0];
+  t = (d ? b : c).c;
+  t = (d, b).c;
+  t = (a = b).c;
+  (d ? b : c).c + 1;
+  (d, b).c + 1;
+  (a = b).c + 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-4.c
new file mode 100644
index 000000000..259ce9214
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-4.c
@@ -0,0 +1,24 @@
+/* Test for non-lvalue arrays decaying to pointers: in C99 only.
+   Test various ways of producing non-lvalue arrays.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char c[17]; };
+
+struct s x;
+
+struct s a, b, c;
+int d;
+
+#define ASSERT(v, a)	char v[((a) ? 1 : -1)]
+
+ASSERT (p, sizeof (x.c) == 17);
+ASSERT (q, sizeof (0, x.c) == sizeof (char *));
+ASSERT (r0, sizeof ((d ? b : c).c) == 17);
+ASSERT (r1, sizeof ((d, b).c) == 17);
+ASSERT (r2, sizeof ((a = b).c) == 17);
+/* The non-lvalue array decays to a pointer in C99.  */
+ASSERT (s0, sizeof (0, (d ? b : c).c) == sizeof (char *)); /* { dg-bogus "array" "bad non-lvalue array handling" } */
+ASSERT (s0, sizeof (0, (d, b).c) == sizeof (char *)); /* { dg-bogus "array" "bad non-lvalue array handling" } */
+ASSERT (s0, sizeof (0, (a = b).c) == sizeof (char *)); /* { dg-bogus "array" "bad non-lvalue array handling" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-5.c
new file mode 100644
index 000000000..57e806d97
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-5.c
@@ -0,0 +1,26 @@
+/* Test for non-lvalue arrays: test that the unary '&' operator is not
+   allowed on them, for both C90 and C99.  */
+
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char c[1]; };
+
+extern struct s foo (void);
+struct s a, b, c;
+int d;
+
+void
+bar (void)
+{
+  &((foo ()).c); /* { dg-bogus "warning" "warning in place of error" } */
+  &((d ? b : c).c); /* { dg-bogus "warning" "warning in place of error" } */
+  &((d, b).c); /* { dg-bogus "warning" "warning in place of error" } */
+  &((a = b).c); /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "lvalue" "bad address-of" { target *-*-* } 17 }
+   { dg-error "lvalue" "bad address-of" { target *-*-* } 18 }
+   { dg-error "lvalue" "bad address-of" { target *-*-* } 19 }
+   { dg-error "lvalue" "bad address-of" { target *-*-* } 20 }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-6.c
new file mode 100644
index 000000000..426b3c75c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-6.c
@@ -0,0 +1,15 @@
+/* PR c/12446 */
+/* Origin: Keith Thompson <kst@cts.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+
+struct s { char c[1]; };
+
+extern struct s foo(void);
+
+void bar(void)
+{
+  char *ptr = foo().c; /* { dg-bogus "non-lvalue" "array not decaying to lvalue" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-7.c
new file mode 100644
index 000000000..3d70ed07b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-lval-7.c
@@ -0,0 +1,21 @@
+/* Test for non-lvalue arrays: test that C90 does not allow them in
+   conditional expressions, while in C99 they decay and are
+   allowed.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char c[1]; };
+struct s a, b, c;
+int d;
+int e;
+
+void
+bar (void)
+{
+  /* In C90, the non-lvalue arrays do not decay to pointers, and
+     6.3.15 does not permit conditional expressions between arrays.
+     In C99, they decay to pointers.  */
+  (e ? (d ? b : c).c : (e ? b : c).c);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-nonobj-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-nonobj-1.c
new file mode 100644
index 000000000..45fc74c4c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-array-nonobj-1.c
@@ -0,0 +1,27 @@
+/* Test for arrays of incomplete and function types: a constraint violation
+   in C99 only, though undefined (DR#047) before.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef void func (void);
+struct s;
+
+extern int a[][]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "array" "\[\]\[\] var" { target *-*-* } 11 } */
+
+void f (int [][]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "array" "\[\]\[\] arg" { target *-*-* } 14 } */
+
+extern struct s b[]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "array" "struct \[\] var" { target *-*-* } 17 } */
+
+void g (struct s []); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "array" "struct \[\] arg" { target *-*-* } 20 } */
+
+extern func c[]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "array" "func \[\] var" { target *-*-* } 23 } */
+
+void h (func []); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "array" "func \[\] arg" { target *-*-* } 26 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-1.c
new file mode 100644
index 000000000..2036d82fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-1.c
@@ -0,0 +1,111 @@
+/* Test for C99 forms of array declarator.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* Because GCC doesn't yet implement it, we don't yet test for [*] here.  */
+
+/* Test each of: [quals], [quals expr], [static expr], [static quals expr],
+   [quals static expr].  Not yet: [quals *].  */
+
+void f00 (int a[const]);
+void f01 (int [const]);
+
+void
+f02 (int a[const])
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 17 } */
+  int *const *c = &a;
+}
+void
+f03 (a)
+     int a[const];
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 25 } */
+  int *const *c = &a;
+}
+
+void f10 (int a[const 2]);
+void f11 (int [const 2]);
+
+void
+f12 (int a[const 2])
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 36 } */
+  int *const *c = &a;
+}
+void
+f13 (a)
+     int a[const 2];
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 44 } */
+  int *const *c = &a;
+}
+
+void f20 (int a[static 2]);
+void f21 (int [static 2]);
+
+void
+f22 (int a[static 2])
+{
+  int **b = &a;
+  int *const *c = &a;
+}
+void
+f23 (a)
+     int a[static 2];
+{
+  int **b = &a;
+  int *const *c = &a;
+}
+
+void f30 (int a[static const 2]);
+void f31 (int [static const 2]);
+
+void
+f32 (int a[static const 2])
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 72 } */
+  int *const *c = &a;
+}
+void
+f33 (a)
+     int a[static const 2];
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 80 } */
+  int *const *c = &a;
+}
+
+void f40 (int a[const static 2]);
+void f41 (int [const static 2]);
+
+void
+f42 (int a[const static 2])
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 91 } */
+  int *const *c = &a;
+}
+void
+f43 (a)
+     int a[const static 2];
+{
+  int **b = &a; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "discards" "discards quals" { target *-*-* } 99 } */
+  int *const *c = &a;
+}
+
+/* Test rejection of static and type qualifiers in non-parameter contexts.  */
+int x[const 2]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "non-parameter" "quals in non-parm array" { target *-*-* } 105 } */
+int y[static 2]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "non-parameter" "static in non-parm array" { target *-*-* } 107 } */
+void g (int a[static 2][3]);
+void h (int a[2][static 3]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "non-parameter" "static in non-final parm array" { target *-*-* } 110 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-2.c
new file mode 100644
index 000000000..22d6e97be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-2.c
@@ -0,0 +1,16 @@
+/* Test for C99 array declarators: expression must be an
+   assignment-expression.  PR 11943.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  int a[2, 3]; /* { dg-error "parse|syntax|expected" "bad array declarator" } */
+  void b(int x[2, 3]); /* { dg-error "parse|syntax|expected" "bad array declarator" } */
+  void c(int [2, 3]); /* { dg-error "parse|syntax|expected" "bad array declarator" } */
+  void d(int *x[restrict 2, 3]); /* { dg-error "parse|syntax|expected" "bad array declarator" } */
+  void e(int *x[static restrict 2, 3]); /* { dg-error "parse|syntax|expected" "bad array declarator" } */
+  void f(int *x[restrict static 2, 3]); /* { dg-error "parse|syntax|expected" "bad array declarator" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-3.c
new file mode 100644
index 000000000..2ab927d6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-arraydecl-3.c
@@ -0,0 +1,20 @@
+/* Test for C99 forms of array declarator.  Test restrict qualifiers
+   properly applied to type of parameter.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+f0 (int a[restrict])
+{
+  int **b = &a; /* { dg-error "discards qualifiers" } */
+  int *restrict *c = &a;
+}
+
+void
+f1 (a)
+     int a[restrict];
+{
+  int **b = &a; /* { dg-error "discards qualifiers" } */
+  int *restrict *c = &a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-1.c
new file mode 100644
index 000000000..7ec99a76b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-1.c
@@ -0,0 +1,248 @@
+/* Test for _Bool and <stdbool.h> in C99.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* _Bool must be a builtin type.  */
+
+_Bool foo;
+
+#include <stdbool.h>
+
+/* Three macros must be integer constant expressions suitable for use
+   in #if.
+*/
+
+#if !defined(true) || (true != 1)
+#error "bad stdbool true" /* { dg-bogus "#error" "bad stdbool.h" } */
+#endif
+
+#if !defined(false) || (false != 0)
+#error "bad stdbool false" /* { dg-bogus "#error" "bad stdbool.h" } */
+#endif
+
+#if !defined(__bool_true_false_are_defined) || (__bool_true_false_are_defined != 1)
+#error "bad stdbool __bool_true_false_are_defined" /* { dg-bogus "#error" "bad stdbool.h" } */
+#endif
+
+int a = true;
+int b = false;
+int c = __bool_true_false_are_defined;
+
+struct foo
+{
+  _Bool a : 1;
+} sf;
+
+#define str(x) xstr(x)
+#define xstr(x) #x
+
+
+extern void abort (void);
+extern void exit (int);
+extern int strcmp (const char *, const char *);
+
+int
+main (void)
+{
+  /* The macro `bool' must expand to _Bool.  */
+  const char *t = str (bool);
+  _Bool u, v;
+  if (strcmp (t, "_Bool"))
+    abort ();
+  if (a != 1 || b != 0 || c != 1)
+    abort ();
+  /* Casts to _Bool have a specified behavior.  */
+  if ((int)(_Bool)2 != 1)
+    abort ();
+  if ((int)(_Bool)0.2 != 1)
+    abort ();
+  /* Pointers may be assigned to _Bool.  */
+  if ((u = t) != 1)
+    abort ();
+  /* _Bool may be used to subscript arrays.  */
+  u = 0;
+  if (t[u] != '_')
+    abort ();
+  if (u[t] != '_')
+    abort ();
+  u = 1;
+  if (t[u] != 'B')
+    abort ();
+  if (u[t] != 'B')
+    abort ();
+  /* Test increment and decrement operators.  */
+  u = 0;
+  if (u++ != 0)
+    abort ();
+  if (u != 1)
+    abort ();
+  if (u++ != 1)
+    abort ();
+  if (u != 1)
+    abort ();
+  u = 0;
+  if (++u != 1)
+    abort ();
+  if (u != 1)
+    abort ();
+  if (++u != 1)
+    abort ();
+  if (u != 1)
+    abort ();
+  u = 0;
+  if (u-- != 0)
+    abort ();
+  if (u != 1)
+    abort ();
+  if (u-- != 1)
+    abort ();
+  if (u != 0)
+    abort ();
+  u = 0;
+  if (--u != 1)
+    abort ();
+  if (u != 1)
+    abort ();
+  if (--u != 0)
+    abort ();
+  if (u != 0)
+    abort ();
+  /* Test unary + - ~ !.  */
+  u = 0;
+  if (+u != 0)
+    abort ();
+  if (-u != 0)
+    abort ();
+  u = 1;
+  if (+u != 1)
+    abort ();
+  if (-u != -1)
+    abort ();
+  u = 2;
+  if (+u != 1)
+    abort ();
+  if (-u != -1)
+    abort ();
+  u = 0;
+  if (~u != ~(int)0)
+    abort ();
+  u = 1;
+  if (~u != ~(int)1)
+    abort ();
+  u = 0;
+  if (!u != 1)
+    abort ();
+  u = 1;
+  if (!u != 0)
+    abort ();
+  /* Test arithmetic * / % + - (which all apply promotions).  */
+  u = 0;
+  if (u + 2 != 2)
+    abort ();
+  u = 1;
+  if (u * 4 != 4)
+    abort ();
+  if (u % 3 != 1)
+    abort ();
+  if (u / 1 != 1)
+    abort ();
+  if (4 / u != 4)
+    abort ();
+  if (u - 7 != -6)
+    abort ();
+  /* Test bitwise shift << >>.  */
+  u = 1;
+  if (u << 1 != 2)
+    abort ();
+  if (u >> 1 != 0)
+    abort ();
+  /* Test relational and equality operators < > <= >= == !=.  */
+  u = 0;
+  v = 0;
+  if (u < v || u > v || !(u <= v) || !(u >= v) || !(u == v) || u != v)
+    abort ();
+  u = 0;
+  v = 1;
+  if (!(u < v) || u > v || !(u <= v) || u >= v || u == v || !(u != v))
+    abort ();
+  /* Test bitwise operators & ^ |.  */
+  u = 1;
+  if ((u | 2) != 3)
+    abort ();
+  if ((u ^ 3) != 2)
+    abort ();
+  if ((u & 1) != 1)
+    abort ();
+  if ((u & 0) != 0)
+    abort ();
+  /* Test logical && ||.  */
+  u = 0;
+  v = 1;
+  if (!(u || v))
+    abort ();
+  if (!(v || u))
+    abort ();
+  if (u && v)
+    abort ();
+  if (v && u)
+    abort ();
+  u = 1;
+  v = 1;
+  if (!(u && v))
+    abort ();
+  /* Test conditional ? :.  */
+  u = 0;
+  if ((u ? 4 : 7) != 7)
+    abort ();
+  u = 1;
+  v = 0;
+  if ((1 ? u : v) != 1)
+    abort ();
+  if ((1 ? 4 : u) != 4)
+    abort ();
+  /* Test assignment operators = *= /= %= += -= <<= >>= &= ^= |=.  */
+  if ((u = 2) != 1)
+    abort ();
+  if (u != 1)
+    abort ();
+  if ((u *= -1) != 1)
+    abort ();
+  if (u != 1)
+    abort ();
+  if ((u /= 2) != 0)
+    abort ();
+  if ((u += 3) != 1)
+    abort ();
+  if ((u -= 1) != 0)
+    abort ();
+  u = 1;
+  if ((u <<= 4) != 1)
+    abort ();
+  if ((u >>= 1) != 0)
+    abort ();
+  u = 1;
+  if ((u &= 0) != 0)
+    abort ();
+  if ((u |= 2) != 1)
+    abort ();
+  if ((u ^= 3) != 1)
+    abort ();
+  /* Test comma expressions.  */
+  u = 1;
+  if ((4, u) != 1)
+    abort ();
+  /* Test bitfields.  */
+  {
+    int i;
+    for (i = 0; i < sizeof (struct foo); i++)
+      *((unsigned char *)&sf + i) = (unsigned char) -1;
+    sf.a = 1;
+    if (sf.a != 1)
+      abort ();
+    sf.a = 0;
+    if (sf.a != 0)
+      abort ();
+  }
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-2.c
new file mode 100644
index 000000000..5a577a428
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-2.c
@@ -0,0 +1,14 @@
+/* Test for _Bool bit-fields.  After TC2, the width of a _Bool
+   bit-field must not extend the width (number of sign and value bits)
+   of _Bool, which is implementation-defined but is 1 unless the
+   implementation defines representations for values greater than 1 in
+   type _Bool and allows for _Bool objects to have such types, which
+   GCC does not.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct foo
+{
+  _Bool b : 2; /* { dg-error "width" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-3.c
new file mode 100644
index 000000000..f93547ac0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-bool-3.c
@@ -0,0 +1,33 @@
+/* Test for _Bool bit-fields.  They have the semantics of _Bool, at
+   least for now (DR#335 Spring 2007 discussion).  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+struct foo
+{
+  _Bool a : 1;
+} sf;
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int i;
+  for (i = 0; i < sizeof (struct foo); i++)
+    *((unsigned char *)&sf + i) = (unsigned char) -1;
+  sf.a = 2;
+  if (sf.a != 1)
+    abort ();
+  sf.a = 0;
+  if (sf.a != 0)
+    abort ();
+  sf.a = 0.2;
+  if (sf.a != 1)
+    abort ();
+  sf.a = &sf;
+  if (sf.a != 1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complex-1.c
new file mode 100644
index 000000000..2e1ba7df5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complex-1.c
@@ -0,0 +1,33 @@
+/* Test for _Complex: in C99 only.  A few basic tests.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* Test _Complex allowed on floating types.  */
+
+float _Complex a;
+_Complex float b;
+double _Complex c;
+_Complex double d;
+long double _Complex e;
+_Complex long double f;
+
+/* Plain `_Complex' for complex double is a GNU extension.  */
+_Complex g; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "plain" "plain _Complex" { target *-*-* } 16 } */
+
+/* Complex integer types are GNU extensions.  */
+_Complex int h; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "complex integer" "_Complex int" { target *-*-* } 20 } */
+_Complex long i; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "complex integer" "_Complex long" { target *-*-* } 22 } */
+
+/* Use of ~ for complex conjugation is a GNU extension, but a constraint
+   violation (6.5.3.3p1) in C99.
+*/
+_Complex double
+foo (_Complex double z)
+{
+  return ~z; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "complex conj" "~ for conjugation" { target *-*-* } 31 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complex-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complex-2.c
new file mode 100644
index 000000000..078e92ae9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complex-2.c
@@ -0,0 +1,22 @@
+/* Test for _Complex: in C99 only.  Test for increment and decrement.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* Use of ++ and -- on complex types (both prefix and postfix) is a
+   C99 constraint violation (6.5.2.4p1, 6.5.3.1p1).
+*/
+
+_Complex double
+foo (_Complex double z)
+{
+  z++; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "complex" "postinc" { target *-*-* } 13 } */
+  ++z; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "complex" "preinc" { target *-*-* } 15 } */
+  z--; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "complex" "postdec" { target *-*-* } 17 } */
+  --z; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "complex" "predec" { target *-*-* } 19 } */
+  return z;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complit-1.c
new file mode 100644
index 000000000..94e15db6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complit-1.c
@@ -0,0 +1,112 @@
+/* Test for compound literals: in C99 only.  Test for valid uses.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct s { int a; int b; };
+union u { int c; int d; };
+
+int *i0a = &(int) { 0 };
+int *i0b = &(int) { 0 };
+int *i1a = &(int) { 1 };
+int *i1b = &(int) { 1 };
+const int *i0c = &(const int) { 0 };
+
+struct s *s0 = &(struct s) { 1, 2 };
+struct s *s1 = &(struct s) { 1, 2 };
+const struct s *s2 = &(const struct s) { 1, 2 };
+
+union u *u0 = &(union u) { 3 };
+union u *u1 = &(union u) { 3 };
+const union u *u2 = &(const union u) { 3 };
+
+int *a0 = (int []) { 1, 2, 3 };
+const int *a1 = (const int []) { 1, 2, 3 };
+
+char *p = (char []){ "foo" };
+
+int
+main (void)
+{
+  if (i0a == i0b || i0a == i0c || i0b == i0c)
+    abort ();
+  if (i1a == i1b)
+    abort ();
+  if (*i0a != 0 || *i0b != 0 || *i1a != 1 || *i1b != 1 || *i0c != 0)
+    abort ();
+  *i0a = 1;
+  *i1a = 0;
+  if (*i0a != 1 || *i0b != 0 || *i1a != 0 || *i1b != 1 || *i0c != 0)
+    abort ();
+  if (s0 == s1 || s1 == s2 || s2 == s0)
+    abort ();
+  if (s0->a != 1 || s0->b != 2 || s1->a != 1 || s1->b != 2
+      || s2->a != 1 || s2->b != 2)
+    abort ();
+  s0->a = 2;
+  s1->b = 1;
+  if (s0->a != 2 || s0->b != 2 || s1->a != 1 || s1->b != 1
+      || s2->a != 1 || s2->b != 2)
+    abort ();
+  if (u0 == u1 || u1 == u2 || u2 == u0)
+    abort ();
+  if (u0->c != 3 || u1->c != 3 || u2->c != 3)
+    abort ();
+  u0->d = 2;
+  if (u0->d != 2 || u1->c != 3 || u2->c != 3)
+    abort ();
+  if (a0 == a1)
+    abort ();
+  if (a0[0] != 1 || a0[1] != 2 || a0[2] != 3
+      || a1[0] != 1 || a1[1] != 2 || a1[2] != 3)
+    abort ();
+  a0[0] = 3;
+  if (a0[0] != 3 || a0[1] != 2 || a0[2] != 3
+      || a1[0] != 1 || a1[1] != 2 || a1[2] != 3)
+    abort ();
+  if (p[0] != 'f' || p[1] != 'o' || p[2] != 'o' || p[3] != 0)
+    abort ();
+  p[0] = 'g';
+  if (p[0] != 'g' || p[1] != 'o' || p[2] != 'o' || p[3] != 0)
+    abort ();
+  if (sizeof((int []) { 1, 2 ,3 }) != 3 * sizeof(int))
+    abort ();
+  if (sizeof((int []) { [3] = 4 }) != 4 * sizeof(int))
+    abort ();
+  struct s *y;
+  for (int i = 0; i < 3; i++) {
+    struct s *x = &(struct s) { 1, i };
+    if (x->a != 1 || x->b != i)
+      abort ();
+    x->a++;
+    x->b--;
+    if (x->a != 2 || x->b != i - 1)
+      abort ();
+    if (i && y != x)
+      abort ();
+    y = x;
+  }
+  int *z;
+  for (int i = 0; i < 4; i++) {
+    int *x = (int []){ 0, i, i + 2, i - 3 };
+    if (x[0] != 0 || x[1] != i || x[2] != i + 2 || x[3] != i - 3)
+      abort ();
+    x[0] = x[1];
+    x[1] *= x[2];
+    x[2] -= x[3];
+    x[3] += 7;
+    if (x[0] != i || x[1] != i * (i + 2) || x[2] != 5 || x[3] != i + 4)
+      abort ();
+    if (i && z != x)
+      abort ();
+    z = x;
+  }
+  (int) { 0 } = 1;
+  (struct s) { 0, 1 }.a = 3;
+  (union u) { 3 }.c = 4;
+  (int []){ 1, 2 }[0] = 0;
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complit-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complit-2.c
new file mode 100644
index 000000000..faf44b237
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-complit-2.c
@@ -0,0 +1,68 @@
+/* Test for compound literals: in C99 only.  Test for invalid uses.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { int a; int b; };
+union u { int c; int d; };
+
+struct si;
+union ui;
+
+void
+foo (int a)
+{
+  /* The type name must not be incomplete (apart from arrays of unknown
+     size), or a function type, or a VLA type.  */
+  (void) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "void type" { target *-*-* } 17 } */
+  &(struct si) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "incomplete struct type" { target *-*-* } 19 } */
+  &(union ui) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "incomplete union type" { target *-*-* } 21 } */
+  (void (void)) { 0 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "function type" { target *-*-* } 23 } */
+  (int [a]) { 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init|variable" "VLA type" { target *-*-* } 25 } */
+  /* Initializers must not attempt to initialize outside the object
+     declared.  */
+  (int [1]) { [1] = 2 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "value outside array" { target *-*-* } 29 } */
+  (int [1]) { [-1] = 2 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "value outside array" { target *-*-* } 31 } */
+  (int [1]) { 0, 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "value outside array" { target *-*-* } 33 } */
+}
+
+int z;
+
+/* Outside a function, initializers must be constant.  */
+struct s *s0 = &(struct s) { 0, z }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "init" "non-const" { target *-*-* } 40 } */
+int sz = sizeof((struct s) { 0, z }); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "init" "non-const" { target *-*-* } 42 } */
+
+/* Compound literals aren't themselves constant expressions.  */
+int x = (int) { 0 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "init" "non-const" { target *-*-* } 46 } */
+
+/* Nor are they suitable structure or union initializers
+   outside a function.  */
+struct s s1 = (struct s) { 0, 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "init" "struct bad init" { target *-*-* } 51 } */
+union u u1 = (union u) { 0 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "init" "union bad init" { target *-*-* } 53 } */
+
+/* They aren't suitable for array initializers, either inside or outside
+   a function.  */
+int y[2] = (int [2]) { 0, 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "init" "array bad init" { target *-*-* } 58 } */
+
+void
+bar (void)
+{
+  struct s s2 = (struct s) { 0, 1 };
+  union u u2 = (union u) { 0 };
+  int z[2] = (int [2]) { 0, 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "init" "array bad init" { target *-*-* } 66 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-condexpr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-condexpr-1.c
new file mode 100644
index 000000000..69d425080
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-condexpr-1.c
@@ -0,0 +1,70 @@
+/* Test for types of conditional expressions.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* Notes:
+
+   (a) The rules are the same in both C standard versions, but C99 also
+   gives us the "restrict" qualifier to play with.
+
+   (b) Within the C standard, the value of a conditional expression can't
+   have qualified type - but nor can this be detected.  Because of GCC's
+   extended lvalues, the value may in GCC have qualified type if the
+   arguments do.  So don't use the following macro with arguments of
+   qualified type.
+
+*/
+
+/* Assertion that the type of a conditional expression between E1 and E2
+   is T.  Checks the expression both ways round.  */
+#define ASSERT_COND_TYPE(E1, E2, T)			\
+	do {						\
+	  typedef T type;				\
+	  typedef type **typepp;			\
+	  typedef __typeof(0 ? (E1) : (E2)) ctype;	\
+	  typedef __typeof(0 ? (E2) : (E1)) ctype2;	\
+	  typedef ctype **ctypepp;			\
+	  typedef ctype2 **ctype2pp;			\
+	  typepp x = 0;					\
+	  ctypepp y = 0;				\
+	  ctype2pp z = 0;				\
+	  x = y;					\
+	  x = z;					\
+	} while (0)
+
+void
+foo (void)
+{
+  const void *c_vp;
+  void *vp;
+  const int *c_ip;
+  volatile int *v_ip;
+  int *ip;
+  const char *c_cp;
+  int *restrict *r_ipp;
+  typedef void (*fpt)(void);
+  fpt fp;
+  signed char sc;
+  struct s { int p; } st;
+  union u { int p; } un;
+  /* Arithmetic type.  */
+  ASSERT_COND_TYPE (sc, sc, int);
+  /* Structure and union.  */
+  ASSERT_COND_TYPE (st, st, struct s);
+  ASSERT_COND_TYPE (un, un, union u);
+  /* Void.  */
+  ASSERT_COND_TYPE ((void)0, (void)1, void);
+  /* Pointers: examples from 6.5.15 paragraph 8.  */
+  ASSERT_COND_TYPE (c_vp, c_ip, const void *);
+  ASSERT_COND_TYPE (v_ip, 0, volatile int *);
+  ASSERT_COND_TYPE (c_ip, v_ip, const volatile int *);
+  ASSERT_COND_TYPE (vp, c_cp, const void *);
+  ASSERT_COND_TYPE (ip, c_ip, const int *);
+  ASSERT_COND_TYPE (vp, ip, void *);
+  /* Null pointer constants.  */
+  ASSERT_COND_TYPE (v_ip, (void *)0, volatile int *);
+  ASSERT_COND_TYPE (r_ipp, (void *)0, int *restrict *);
+  ASSERT_COND_TYPE (fp, 0, fpt);
+  ASSERT_COND_TYPE (fp, (void *)0, fpt);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-1.c
new file mode 100644
index 000000000..c3082ee38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-1.c
@@ -0,0 +1,16 @@
+/* Test for constraints on constant expressions.  In C90 it is clear that
+   certain constructs are not permitted in unevaluated parts of an
+   expression (except in sizeof); in C99 it might fall within implementation
+   latitude; and if the operands are suitable, diagnostics should not be
+   issued.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>; inspired by
+   http://deja.com/getdoc.xp?AN=524271595&fmt=text by Peter Seebach.
+*/
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* The comma operator is in a subexpression that is not evaluated, so OK
+   by C99.  In C90 a diagnostic is required since it is not in a sizeof.
+*/
+int i = (1 ? 0 : (2, 3));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-2.c
new file mode 100644
index 000000000..638f43d92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-2.c
@@ -0,0 +1,45 @@
+/* Test for constant expressions: details of what is a null pointer
+   constant.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999" } */
+/* Note: not using -pedantic since the -std option alone should be enough
+   to give the correct behavior to conforming programs.  If -pedantic is
+   needed to make (say) (0, 0) not be a constant expression, this is a
+   bug.
+*/
+
+int *a;
+int b;
+long *c;
+
+#if defined(_LP64)
+#define ZERO 0L
+#elif defined(_WIN64)
+#define ZERO 0LL
+#else
+#define ZERO 0
+#endif
+
+/* Assertion that n is a null pointer constant: so the conditional expression
+   has type 'int *' instead of 'void *'.
+*/
+#define ASSERT_NPC(n)	(b = *(1 ? a : (n)))
+/* Assertion that n is not a null pointer constant: so the conditional
+   expressions has type 'void *' instead of 'int *'.
+*/
+#define ASSERT_NOT_NPC(n)	(c = (1 ? a : (n)))
+
+void
+foo (void)
+{
+  ASSERT_NPC (0);
+  ASSERT_NPC ((void *)0);
+  ASSERT_NOT_NPC ((void *)(void *)0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((void *)(char *)0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((void *)(0, ZERO)); /* { dg-bogus "incompatible" "bogus null pointer constant" } */
+  ASSERT_NOT_NPC ((void *)(&"Foobar"[0] - &"Foobar"[0])); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  /* This last one is a null pointer constant in C99 only.  */
+  ASSERT_NPC ((void *)(1 ? 0 : (0, 0)));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-3.c
new file mode 100644
index 000000000..f23060333
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-3.c
@@ -0,0 +1,45 @@
+/* Test for constant expressions: broken optimization with const variables.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -O2" } */
+/* Note: not using -pedantic since the -std option alone should be enough
+   to give the correct behavior to conforming programs.  */
+
+static const int ZERO = 0;
+static const double DZERO = 0;
+
+int *a;
+int b;
+long *c;
+
+/* Assertion that n is a constant zero: so the conditional expression
+   has type 'int *' instead of 'void *'.
+*/
+#define ASSERT_NPC(n)	(b = *(1 ? a : (n)))
+/* Assertion that n is not a constant zero: so the conditional
+   expressions has type 'void *' instead of 'int *'.
+*/
+#define ASSERT_NOT_NPC(n)	(c = (1 ? a : (void *)(__SIZE_TYPE__)(n)))
+
+void
+foo (void)
+{
+  ASSERT_NPC (0);
+  ASSERT_NOT_NPC (ZERO);
+  ASSERT_NPC (0 + 0);
+  ASSERT_NOT_NPC (ZERO + 0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC (ZERO + ZERO); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NPC (+0);
+  ASSERT_NOT_NPC (+ZERO); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NPC (-0);
+  ASSERT_NOT_NPC (-ZERO); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NPC ((char) 0);
+  ASSERT_NOT_NPC ((char) ZERO);
+  ASSERT_NPC ((int) 0);
+  ASSERT_NOT_NPC ((int) ZERO);
+  ASSERT_NPC ((int) 0.0);
+  ASSERT_NOT_NPC ((int) DZERO);
+  ASSERT_NOT_NPC ((int) +0.0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((int) (0.0+0.0)); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+  ASSERT_NOT_NPC ((int) (double)0.0); /* { dg-bogus "incompatible" "bogus null pointer constant" { xfail *-*-* } } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-4.c
new file mode 100644
index 000000000..f6beaf77a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-4.c
@@ -0,0 +1,11 @@
+/* Test for constant expressions: const variable with value 0 is not a
+   null pointer constant so the conditional expression should have
+   type void * and the assignment is OK.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -O2" } */
+int *p;
+long *q;
+static void *const n = 0;
+int j;
+void f(void) { q = j ? p : n; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-5.c
new file mode 100644
index 000000000..3bfa7f6fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-const-expr-5.c
@@ -0,0 +1,39 @@
+/* Test null pointer constants: typedefs for void should be OK but not
+   qualified void.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef void V;
+int *p;
+long *q;
+int j;
+void (*fp)(void);
+
+void
+f (void)
+{
+  /* (V *)0 is a null pointer constant, so the assignment should be
+     diagnosed.  */
+  q = (j ? p : (V *)0); /* { dg-error "assignment from incompatible pointer type" } */
+  q = (j ? p : (void *)0); /* { dg-error "assignment from incompatible pointer type" } */
+  /* And this conversion should be valid.  */
+  (void (*)(void))(V *)0;
+  (void (*)(void))(void *)0;
+  /* Pointers to qualified void are not valid null pointer
+     constants.  */
+  fp = (const void *)0; /* { dg-error "ISO C forbids assignment between function pointer and 'void \\*'" } */
+  fp = (void *)0;
+  fp = (V *)0;
+  fp = 0;
+  fp == 0;
+  0 == fp;
+  fp == (void *)0;
+  (void *)0 == fp;
+  fp == (V *)0;
+  (V *)0 == fp;
+  fp == (V *)1; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */
+  (V *)1 == fp; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */
+  fp == (const void *)0; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */
+  (const void *)0 == fp; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-digraph-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-digraph-1.c
new file mode 100644
index 000000000..318aa70bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-digraph-1.c
@@ -0,0 +1,24 @@
+/* Test for recognition of digraphs: should be recognized in C94 and C99
+   mode, but not in C90 mode.  Also check correct stringizing.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#define str(x) xstr(x)
+#define xstr(x) #x
+#define foo(p, q) str(p %:%: q)
+
+extern void abort (void);
+extern int strcmp (const char *, const char *);
+
+int
+main (void)
+{
+  const char *t = foo (1, 2);
+  const char *u = str (<:);
+  if (strcmp (t, "12") || strcmp (u, "<:"))
+    abort ();
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-dupqual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-dupqual-1.c
new file mode 100644
index 000000000..2e6d7e1bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-dupqual-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef const int CI;
+const const int c1;		/* { dg-bogus "duplicate" } */
+const CI c2;			/* { dg-bogus "duplicate" } */
+const CI *c3;			/* { dg-bogus "duplicate" } */
+
+typedef volatile int VI;
+volatile volatile int v1;	/* { dg-bogus "duplicate" } */
+volatile VI v2;			/* { dg-bogus "duplicate" } */
+volatile VI *v3;		/* { dg-bogus "duplicate" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-enum-comma-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-enum-comma-1.c
new file mode 100644
index 000000000..1b676a229
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-enum-comma-1.c
@@ -0,0 +1,6 @@
+/* Test for commas at end of enums: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+enum foo { bar, };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-1.c
new file mode 100644
index 000000000..b14397ad2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-1.c
@@ -0,0 +1,8 @@
+/* Test for invalid uses of flexible array members.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s1 { int x[]; }; /* { dg-error "empty struct" "empty" } */
+struct s2 { int :1; int x[]; }; /* { dg-error "empty struct" "empty" } */
+struct s3 { int x[]; int y; }; /* { dg-error "not at end" "not at end" } */
+struct s4 { int x; int y[]; };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-2.c
new file mode 100644
index 000000000..496f4f985
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-2.c
@@ -0,0 +1,14 @@
+/* PR c/5623 */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct blah {
+   int   number;
+   char  array[];
+};
+
+void foo(void)
+{
+   struct blah b;
+   b.array = "hi";  /* { dg-error "invalid use of flexible array member" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-3.c
new file mode 100644
index 000000000..e8647f6ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-3.c
@@ -0,0 +1,47 @@
+/* Test for flexible array members.  Test for where structures with
+   such members may not occur.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct flex { int a; int b[]; };
+union rf1 { struct flex a; int b; };
+union rf2 { int a; struct flex b; };
+union rf3 { int a; union rf1 b; };
+union rf4 { union rf2 a; int b; };
+
+/* The above structure and unions may not be members of structures or
+   elements of arrays (6.7.2.1#2).  */
+
+struct t0 { struct flex a; }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "struct in struct" { target *-*-* } 16 } */
+struct t1 { union rf1 a; }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "union in struct" { target *-*-* } 18 } */
+struct t2 { union rf2 a; }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "union in struct" { target *-*-* } 20 } */
+struct t3 { union rf3 a; }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "recursive union in struct" { target *-*-* } 22 } */
+struct t4 { union rf4 a; }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "recursive union in struct" { target *-*-* } 24 } */
+
+void f0 (struct flex[]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "struct in array" { target *-*-* } 27 } */
+void f1 (union rf1[]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "union in array" { target *-*-* } 29 } */
+void f2 (union rf2[]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "union in array" { target *-*-* } 31 } */
+void f3 (union rf3[]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "recursive union in array" { target *-*-* } 33 } */
+void f4 (union rf4[]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "recursive union in array" { target *-*-* } 35 } */
+
+struct flex a0[1]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "struct in array" { target *-*-* } 38 } */
+union rf1 a1[1]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "union in array" { target *-*-* } 40 } */
+union rf2 a2[1]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "union in array" { target *-*-* } 42 } */
+union rf3 a3[1]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "recursive union in array" { target *-*-* } 44 } */
+union rf4 a4[1]; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "invalid use of structure" "recursive union in array" { target *-*-* } 46 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-5.c
new file mode 100644
index 000000000..385b0cb95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-5.c
@@ -0,0 +1,6 @@
+/* Test for flexible array members: not permitted in unions.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+union u { int a; char b[]; }; /* { dg-error "flexible array member in union" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-6.c
new file mode 100644
index 000000000..468c4b3cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-flex-array-6.c
@@ -0,0 +1,15 @@
+/* [] does not indicate a flexible array member unless it is the field
+   itself being declared as an incomplete array type rather than a
+   pointer or other type derived from such a type.  PR 36432.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+f (void)
+{
+  int a[3];
+  int (*p)[];
+  struct { int (*p)[]; } s;
+  p = &a;
+  s.p = &a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-float-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-float-1.c
new file mode 100644
index 000000000..07fb9ee8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-float-1.c
@@ -0,0 +1,133 @@
+/* Test for <float.h> C99 macros.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* This test checks that the C99 macros are defined;
+   it does not check the correctness of their values.  */
+
+#include <float.h>
+
+#ifndef FLT_ROUNDS
+#error "FLT_ROUNDS undefined"
+#endif
+
+#ifndef FLT_RADIX
+#error "FLT_RADIX undefined"
+#endif
+
+#ifndef FLT_MANT_DIG
+#error "FLT_MANT_DIG undefined"
+#endif
+
+#ifndef FLT_DIG
+#error "FLT_DIG undefined"
+#endif
+
+#ifndef FLT_MIN_EXP
+#error "FLT_MIN_EXP undefined"
+#endif
+
+#ifndef FLT_MIN_10_EXP
+#error "FLT_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT_MAX_EXP
+#error "FLT_MAX_EXP undefined"
+#endif
+
+#ifndef FLT_MAX_10_EXP
+#error "FLT_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT_MAX
+#error "FLT_MAX undefined"
+#endif
+
+#ifndef FLT_EPSILON
+#error "FLT_EPSILON undefined"
+#endif
+
+#ifndef FLT_MIN
+#error "FLT_MIN undefined"
+#endif
+
+#ifndef DBL_MANT_DIG
+#error "DBL_MANT_DIG undefined"
+#endif
+
+#ifndef DBL_DIG
+#error "DBL_DIG undefined"
+#endif
+
+#ifndef DBL_MIN_EXP
+#error "DBL_MIN_EXP undefined"
+#endif
+
+#ifndef DBL_MIN_10_EXP
+#error "DBL_MIN_10_EXP undefined"
+#endif
+
+#ifndef DBL_MAX_EXP
+#error "DBL_MAX_EXP undefined"
+#endif
+
+#ifndef DBL_MAX_10_EXP
+#error "DBL_MAX_10_EXP undefined"
+#endif
+
+#ifndef DBL_MAX
+#error "DBL_MAX undefined"
+#endif
+
+#ifndef DBL_EPSILON
+#error "DBL_EPSILON undefined"
+#endif
+
+#ifndef DBL_MIN
+#error "DBL_MIN undefined"
+#endif
+
+#ifndef LDBL_MANT_DIG
+#error "LDBL_MANT_DIG undefined"
+#endif
+
+#ifndef LDBL_DIG
+#error "LDBL_DIG undefined"
+#endif
+
+#ifndef LDBL_MIN_EXP
+#error "LDBL_MIN_EXP undefined"
+#endif
+
+#ifndef LDBL_MIN_10_EXP
+#error "LDBL_MIN_10_EXP undefined"
+#endif
+
+#ifndef LDBL_MAX_EXP
+#error "LDBL_MAX_EXP undefined"
+#endif
+
+#ifndef LDBL_MAX_10_EXP
+#error "LDBL_MAX_10_EXP undefined"
+#endif
+
+#ifndef LDBL_MAX
+#error "LDBL_MAX undefined"
+#endif
+
+#ifndef LDBL_EPSILON
+#error "LDBL_EPSILON undefined"
+#endif
+
+#ifndef LDBL_MIN
+#error "LDBL_MIN undefined"
+#endif
+
+#ifndef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD undefined"
+#endif
+
+#ifndef DECIMAL_DIG
+#error "DECIMAL_DIG undefined"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-1.c
new file mode 100644
index 000000000..faaab1e95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-1.c
@@ -0,0 +1,35 @@
+/* Test for C99 declarations in for loops.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int j = 0;
+  int i = -1;
+  for (int i = 1; i <= 10; i++)
+    j += i;
+  if (j != 55)
+    abort ();
+  if (i != -1)
+    abort ();
+  j = 0;
+  for (auto int i = 1; i <= 10; i++)
+    j += i;
+  if (j != 55)
+    abort ();
+  if (i != -1)
+    abort ();
+  j = 0;
+  for (register int i = 1; i <= 10; i++)
+    j += i;
+  if (j != 55)
+    abort ();
+  if (i != -1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-2.c
new file mode 100644
index 000000000..0ef11f612
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-2.c
@@ -0,0 +1,28 @@
+/* Test for C99 declarations in for loops.  Test constraints.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  /* See comments in check_for_loop_decls (c-decl.c) for the presumptions
+     behind these tests.  */
+  int j = 0;
+  for (int i = 1, bar (void); i <= 10; i++) /* { dg-bogus "warning" "warning in place of error" } */
+    j += i;
+  /* { dg-error "bar" "function in for loop" { target *-*-* } 12 } */
+  for (static int i = 1; i <= 10; i++) /* { dg-bogus "warning" "warning in place of error" } */
+    j += i;
+  /* { dg-error "static" "static in for loop" { target *-*-* } 15 } */
+  for (extern int i; j <= 500; j++) /* { dg-bogus "warning" "warning in place of error" } */
+    j += 5;
+  /* { dg-error "extern" "extern in for loop" { target *-*-* } 18 } */
+  for (enum { FOO } i = FOO; i < 10; i++) /* { dg-bogus "warning" "warning in place of error" } */
+    j += i;
+  /* { dg-error "FOO" "enum value in for loop" { target *-*-* } 21 } */
+  for (enum BAR { FOO } i = FOO; i < 10; i++) /* { dg-bogus "warning" "warning in place of error" } */
+    j += i;
+  /* { dg-error "FOO" "enum value in for loop" { target *-*-* } 24 } */
+  /* { dg-error "BAR" "enum tag in for loop" { target *-*-* } 24 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-3.c
new file mode 100644
index 000000000..ff814ad57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-fordecl-3.c
@@ -0,0 +1,15 @@
+/* Test for C99 declarations in for loops.  Test constraints: struct
+   and union tags can't be declared there (affirmed in response to
+   DR#277).  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  for (struct s { int p; } *p = 0; ;) /* { dg-error "'struct s' declared in 'for' loop initial declaration" } */
+    ;
+  for (union u { int p; } *p = 0; ;) /* { dg-error "'union u' declared in 'for' loop initial declaration" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-1.c
new file mode 100644
index 000000000..43fb03217
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-1.c
@@ -0,0 +1,17 @@
+/* Test for C99 __func__.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern void abort (void);
+extern int strcmp (const char *, const char *);
+extern void exit (int);
+
+int
+main (void)
+{
+  if (strcmp (__func__, "main") || sizeof (__func__) != 5)
+    abort ();
+  else
+    exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-2.c
new file mode 100644
index 000000000..f3eaaa1fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-2.c
@@ -0,0 +1,10 @@
+/* Test for C99 __func__: not a string constant.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  __func__ "foo"; /* { dg-error "parse error|syntax error|expected" "before string constant" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-3.c
new file mode 100644
index 000000000..f8a06a0e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-3.c
@@ -0,0 +1,16 @@
+/* Test for C99 __func__: not merging with string literals.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  if ("main" == __func__)
+    abort ();
+  else
+    exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-4.c
new file mode 100644
index 000000000..10ec19566
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-func-4.c
@@ -0,0 +1,10 @@
+/* Test for C99 __func__: of type const char [].  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  char *p = __func__; /* { dg-error "discards" "__func__ pointer to const" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-hexfloat-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-hexfloat-1.c
new file mode 100644
index 000000000..f4c147bcc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-hexfloat-1.c
@@ -0,0 +1,6 @@
+/* Test for hex floating point constants: in C99 only.  Compiler test.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+double d = 0x1.2p2; /* { dg-bogus "radix 16" "bogus C99 hex float error" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-hexfloat-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-hexfloat-2.c
new file mode 100644
index 000000000..3ca15c3c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-hexfloat-2.c
@@ -0,0 +1,24 @@
+/* Test for hex floating point constants: in C99 only.  Preprocessor test.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#define f (
+#define l )
+#define str(x) #x
+#define xstr(x) str(x)
+
+/* C90: "0x1p+( 0x1p+)"; C99: "0x1p+f 0x1p+l" */
+const char *s = xstr(0x1p+f 0x1p+l);
+
+extern void abort (void);
+extern int strcmp (const char *, const char *);
+
+int
+main (void)
+{
+  if (strcmp (s, "0x1p+f 0x1p+l"))
+    abort ();
+  else
+    return 0; /* Correct C99 behavior.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-1.c
new file mode 100644
index 000000000..c541d075c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-1.c
@@ -0,0 +1,7 @@
+/* Test for idempotent type qualifiers: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef const int cint;
+const cint foo; /* { dg-bogus "duplicate" "duplicate type qualifier error" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-2.c
new file mode 100644
index 000000000..dd9f932b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-2.c
@@ -0,0 +1,6 @@
+/* Test for idempotent type qualifiers: in C99 only.  Test "const const".  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+const const int foo; /* { dg-bogus "duplicate" "duplicate type qualifier error" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-3.c
new file mode 100644
index 000000000..0f34f8321
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-idem-qual-3.c
@@ -0,0 +1,9 @@
+/* Test for idempotent type qualifiers: in C99 only.  Test duplicate
+   type qualifiers with array element types.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef const int cia[2];
+const cia a; /* { dg-bogus "duplicate" "duplicate type qualifier warning" } */
+const cia b[2]; /* { dg-bogus "duplicate" "duplicate type qualifier warning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-decl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-decl-1.c
new file mode 100644
index 000000000..6602bc71d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-decl-1.c
@@ -0,0 +1,21 @@
+/* Test for implicit function declaration: in C90 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  bar (); /* { dg-bogus "warning" "warning in place of error" } */
+ /* { dg-error "implicit" "C99 implicit declaration error" { target *-*-* } 9 } */
+}
+
+/* C90 subclause 7.1.7 says we can implicitly declare strcmp; C99 removes
+   implict declarations.
+*/
+int
+bar (const char *a, const char *b)
+{
+  return strcmp (a, b); /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "implicit" "C99 implicit declaration error" { target *-*-* } 19 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-int-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-int-1.c
new file mode 100644
index 000000000..dcc25203a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-int-1.c
@@ -0,0 +1,9 @@
+/* Test for implicit int: in C90 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern foo; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "type defaults" "C99 implicit int error" { target *-*-* } 6 } */
+bar (void) { } /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "return type defaults" "C99 implicit int error" { target *-*-* } 8 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-int-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-int-2.c
new file mode 100644
index 000000000..e9e974767
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-impl-int-2.c
@@ -0,0 +1,9 @@
+/* Test for implicit int: in C90 only.  Function parameters in old-style
+   function definition.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void foo (a) { } /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "defaults" "C99 implicit int parameter error" { target *-*-* } 8 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-1.c
new file mode 100644
index 000000000..95803c241
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-1.c
@@ -0,0 +1,78 @@
+/* Test for C99 designated initializers */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef __SIZE_TYPE__ size_t;
+typedef __WCHAR_TYPE__ wchar_t;
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+
+int a[10] = { 10, 0, 12, 13, 14, 0, 0, 17, 0, 0 };
+int b[10] = { 10, [4] = 15, [2] = 12, [4] = 14, [7] = 17 };
+int c[10] = { 10, [4] = 15, [2] = 12, [3] = 13, 14, [7] = 17 };
+struct A {
+  int B;
+  short C[2];
+};
+struct A d[] = { { 0, { 1, 2 } }, { 0, { 0, 0 } }, { 10, { 11, 12 } } };
+struct A e[] = { 0, 1, 2, [2] = 10, 11, 12 };
+struct A f[] = { 0, 1, 2, [2].C = 11, 12, 13 };
+struct A g[] = { 0, 1, 2, [2].C[1] = 12, 13, 14 };
+struct A h[] = { 0, 1, 2, [2] = { .C[1] = 12 }, 13, 14 };
+struct A i[] = { 0, 1, 2, [2] = { .C = { [1] = 12 } }, 13, 14 };
+union D {
+  int E;
+  double F;
+  struct A G;
+};
+union D j[] = { [4] = 1, [4].F = 1.0, [1].G.C[1] = 4 };
+struct H {
+  char I[6];
+  int J;
+} k[] = { { { "foo" }, 1 }, [0].I[0] = 'b' };
+struct K {
+  wchar_t L[6];
+  int M;
+} l[] = { { { L"foo" }, 1 }, [0].L[2] = L'x', [0].L[4] = L'y' };
+struct H m[] = { { { "foo" }, 1 }, [0] = { .I[0] = 'b' } };
+struct H n[] = { { { "foo" }, 1 }, [0].I = { "a" }, [0].J = 2 };
+int o = { 22 };
+
+int main (void)
+{
+  if (b[3])
+    abort ();
+  b[3] = 13;
+  if (memcmp (a, b, sizeof (a)) || memcmp (a, c, sizeof (a)))
+    abort ();
+  if (memcmp (d, e, sizeof (d)) || sizeof (d) != sizeof (e))
+    abort ();
+  if (f[2].B != 0 || g[2].B != 0 || g[2].C[0] != 0)
+    abort ();
+  if (memcmp (g, h, sizeof (g)) || memcmp (g, i, sizeof (g)))
+    abort ();
+  f[2].B = 10;
+  g[2].B = 10;
+  g[2].C[0] = 11;
+  if (memcmp (d, f, sizeof (d)) || memcmp (d, g, sizeof (d)))
+    abort ();
+  if (f[3].B != 13 || g[3].B != 13 || g[3].C[0] != 14)
+    abort ();
+  if (j[0].E || j[1].G.B || j[1].G.C[0] || j[1].G.C[1] != 4)
+    abort ();
+  if (j[2].E || j[3].E || j[4].F != 1.0)
+    abort ();
+  if (memcmp (k[0].I, "boo\0\0", 6) || k[0].J != 1)
+    abort ();
+  if (memcmp (l[0].L, L"fox\0y", 6 * sizeof(wchar_t)) || l[0].M != 1)
+    abort ();
+  if (memcmp (m[0].I, "b\0\0\0\0", 6) || m[0].J)
+    abort ();
+  if (memcmp (n[0].I, "a\0\0\0\0", 6) || n[0].J != 2)
+    abort ();
+  if (o != 22)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-2.c
new file mode 100644
index 000000000..d3a331ff3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-2.c
@@ -0,0 +1,30 @@
+/* Test for C99 designated initializer warnings and errors */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -Wall -pedantic-errors" } */
+
+typedef struct {
+  int B;
+  short C[2];
+} A;
+A a = { [2] = 1 };			/* { dg-error "(array index in non-array)|(near initialization)" } */
+int b[] = { .B = 1 };			/* { dg-error "(field name not in record)|(near initialization)" } */
+A c[] = { [0].D = 1 };			/* { dg-error "unknown field" } */
+int d;
+int e = { d++ };			/* { dg-error "(is not constant)|(near initialization)" } */
+A f[2] = { [0].C[0] = 1, [2] = { 2, { 1, 2 } } };/* { dg-error "(array index in initializer exceeds array bounds)|(near initialization)" } */
+int g[4] = { [1] = 1, 2, [6] = 5 };	/* { dg-error "(array index in initializer exceeds array bounds)|(near initialization)" } */
+int h[] = { [0 ... 3] = 5 };		/* { dg-error "forbids specifying range of elements" } */
+int i[] = { [2] 4 };			/* { dg-error "use of designated initializer without" } */
+A j = { B: 2 };				/* { dg-error "use of designated initializer with " } */
+
+void foo (int *, A *);
+
+void bar (void)
+{
+  int a[] = { d++, [0] = 1 };		/* { dg-warning "(initialized field with side-effects overwritten)|(near initialization)" } */
+  A b = { 1, { d++, 2 }, .C[0] = 3 };/* { dg-warning "(initialized field with side-effects overwritten)|(near initialization)" } */
+  A c = { d++, { 2, 3 }, .B = 4 };	/* { dg-warning "(initialized field with side-effects overwritten)|(near initialization)" } */
+
+  foo (a, d ? &b : &c);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-3.c
new file mode 100644
index 000000000..9aca19acc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-3.c
@@ -0,0 +1,8 @@
+/* Test for designated initializers: array designators must be of
+   integer type.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+int a[] = { [(void *)0] = 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "integer type|near init" "pointer designator"  { target *-*-* } 7 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-4.c
new file mode 100644
index 000000000..707355785
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-init-4.c
@@ -0,0 +1,8 @@
+/* Test for nested initialization of a compound literal: must not be
+   checked against outer array bounds.  Bug 19435.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s { char *p; };
+struct s a[1] = { { .p = ((char []){ 1, 2 }) } };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-intconst-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-intconst-1.c
new file mode 100644
index 000000000..629b0bcac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-intconst-1.c
@@ -0,0 +1,639 @@
+/* Test for integer constant types.  */
+
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#include <limits.h>
+
+/* Assertion that constant C is of type T.  */
+#define ASSERT_CONST_TYPE(C, T)			\
+	do {					\
+	  typedef T type;			\
+	  typedef type **typepp;		\
+	  typedef __typeof__((C)) ctype;	\
+	  typedef ctype **ctypepp;		\
+	  typepp x = 0;				\
+	  ctypepp y = 0;			\
+	  x = y;				\
+	  y = x;				\
+	} while (0)
+
+/* (T *) if E is zero, (void *) otherwise.  */
+#define type_if_not(T, E) __typeof__(0 ? (T *)0 : (void *)(E))
+
+/* (T *) if E is nonzero, (void *) otherwise.  */
+#define type_if(T, E) type_if_not(T, !(E))
+
+/* Combine pointer types, all but one (void *).  */
+#define type_comb2(T1, T2) __typeof__(0 ? (T1)0 : (T2)0)
+#define type_comb3(T1, T2, T3) type_comb2(T1, type_comb2(T2, T3))
+#define type_comb4(T1, T2, T3, T4)				\
+	type_comb2(T1, type_comb2(T2, type_comb2(T3, T4)))
+#define type_comb6(T1, T2, T3, T4, T5, T6)				   \
+	type_comb2(T1,							   \
+		   type_comb2(T2,					   \
+			      type_comb2(T3,				   \
+					 type_comb2(T4,			   \
+						    type_comb2(T5, T6)))))
+
+/* (T1 *) if E1, otherwise (T2 *) if E2.  */
+#define first_of2p(T1, E1, T2, E2) type_comb2(type_if(T1, (E1)),	   \
+					     type_if(T2, (!(E1) && (E2))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3.  */
+#define first_of3p(T1, E1, T2, E2, T3, E3)			\
+	type_comb3(type_if(T1, (E1)),				\
+		   type_if(T2, (!(E1) && (E2))),		\
+		   type_if(T3, (!(E1) && !(E2) && (E3))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3, otherwise
+   (T4 *) if E4.  */
+#define first_of4p(T1, E1, T2, E2, T3, E3, T4, E4)			\
+	type_comb4(type_if(T1, (E1)),					\
+		   type_if(T2, (!(E1) && (E2))),			\
+		   type_if(T3, (!(E1) && !(E2) && (E3))),		\
+		   type_if(T4, (!(E1) && !(E2) && !(E3) && (E4))))
+/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3, otherwise
+   (T4 *) if E4, otherwise (T5 *) if E5, otherwise (T6 *) if E6.  */
+#define first_of6p(T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6)	    \
+	type_comb6(type_if(T1, (E1)),					    \
+		   type_if(T2, (!(E1) && (E2))),			    \
+		   type_if(T3, (!(E1) && !(E2) && (E3))),		    \
+		   type_if(T4, (!(E1) && !(E2) && !(E3) && (E4))),	    \
+		   type_if(T5, (!(E1) && !(E2) && !(E3) && !(E4) && (E5))), \
+		   type_if(T6, (!(E1) && !(E2) && !(E3)			    \
+				&& !(E4) && !(E5) && (E6))))
+
+/* Likewise, but return the original type rather than a pointer type.  */
+#define first_of2(T1, E1, T2, E2)			\
+	__typeof__(*((first_of2p(T1, (E1), T2, (E2)))0))
+#define first_of3(T1, E1, T2, E2, T3, E3)				\
+	__typeof__(*((first_of3p(T1, (E1), T2, (E2), T3, (E3)))0))
+#define first_of4(T1, E1, T2, E2, T3, E3, T4, E4)			    \
+	__typeof__(*((first_of4p(T1, (E1), T2, (E2), T3, (E3), T4, (E4)))0))
+#define first_of6(T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6)	\
+	__typeof__(*((first_of6p(T1, (E1), T2, (E2), T3, (E3),		\
+				 T4, (E4), T5, (E5), T6, (E6)))0))
+
+/* Types of constants according to the C99 rules.  */
+#define C99_UNSUF_DEC_TYPE(C)				\
+	first_of3(int, (C) <= INT_MAX,			\
+		  long int, (C) <= LONG_MAX,		\
+		  long long int, (C) <= LLONG_MAX)
+#define C99_UNSUF_OCTHEX_TYPE(C)				\
+	first_of6(int, (C) <= INT_MAX,				\
+		  unsigned int, (C) <= UINT_MAX,		\
+		  long int, (C) <= LONG_MAX,			\
+		  unsigned long int, (C) <= ULONG_MAX,		\
+		  long long int, (C) <= LLONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFu_TYPE(C)					\
+	first_of3(unsigned int, (C) <= UINT_MAX,		\
+		  unsigned long int, (C) <= ULONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFl_DEC_TYPE(C)				\
+	first_of2(long int, (C) <= LONG_MAX,		\
+		  long long int, (C) <= LLONG_MAX)
+#define C99_SUFl_OCTHEX_TYPE(C)					\
+	first_of4(long int, (C) <= LONG_MAX,			\
+		  unsigned long int, (C) <= ULONG_MAX,		\
+		  long long int, (C) <= LLONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFul_TYPE(C)					\
+	first_of2(unsigned long int, (C) <= ULONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+#define C99_SUFll_OCTHEX_TYPE(C)				\
+	first_of2(long long int, (C) <= LLONG_MAX,		\
+		  unsigned long long int, (C) <= ULLONG_MAX)
+
+/* Checks that constants have correct type.  */
+#define CHECK_UNSUF_DEC_TYPE(C) ASSERT_CONST_TYPE((C), C99_UNSUF_DEC_TYPE((C)))
+#define CHECK_UNSUF_OCTHEX_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C99_UNSUF_OCTHEX_TYPE((C)))
+#define CHECK_SUFu_TYPE(C) ASSERT_CONST_TYPE((C), C99_SUFu_TYPE((C)))
+#define CHECK_SUFl_DEC_TYPE(C) ASSERT_CONST_TYPE((C), C99_SUFl_DEC_TYPE((C)))
+#define CHECK_SUFl_OCTHEX_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C99_SUFl_OCTHEX_TYPE((C)))
+#define CHECK_SUFul_TYPE(C) ASSERT_CONST_TYPE((C), C99_SUFul_TYPE((C)))
+#define CHECK_SUFll_DEC_TYPE(C) ASSERT_CONST_TYPE((C), long long int)
+#define CHECK_SUFll_OCTHEX_TYPE(C)				\
+	ASSERT_CONST_TYPE((C), C99_SUFll_OCTHEX_TYPE((C)))
+#define CHECK_SUFull_TYPE(C) ASSERT_CONST_TYPE((C), unsigned long long int)
+
+/* Check a decimal value, with all suffixes.  */
+#define CHECK_DEC_CONST(C)			\
+	CHECK_UNSUF_DEC_TYPE(C);		\
+	CHECK_SUFu_TYPE(C##u);			\
+	CHECK_SUFu_TYPE(C##U);			\
+	CHECK_SUFl_DEC_TYPE(C##l);		\
+	CHECK_SUFl_DEC_TYPE(C##L);		\
+	CHECK_SUFul_TYPE(C##ul);		\
+	CHECK_SUFul_TYPE(C##uL);		\
+	CHECK_SUFul_TYPE(C##Ul);		\
+	CHECK_SUFul_TYPE(C##UL);		\
+	CHECK_SUFll_DEC_TYPE(C##ll);		\
+	CHECK_SUFll_DEC_TYPE(C##LL);		\
+	CHECK_SUFull_TYPE(C##ull);		\
+	CHECK_SUFull_TYPE(C##uLL);		\
+	CHECK_SUFull_TYPE(C##Ull);		\
+	CHECK_SUFull_TYPE(C##ULL);
+
+/* Check an octal or hexadecimal value, with all suffixes.  */
+#define CHECK_OCTHEX_CONST(C)			\
+	CHECK_UNSUF_OCTHEX_TYPE(C);		\
+	CHECK_SUFu_TYPE(C##u);			\
+	CHECK_SUFu_TYPE(C##U);			\
+	CHECK_SUFl_OCTHEX_TYPE(C##l);		\
+	CHECK_SUFl_OCTHEX_TYPE(C##L);		\
+	CHECK_SUFul_TYPE(C##ul);		\
+	CHECK_SUFul_TYPE(C##uL);		\
+	CHECK_SUFul_TYPE(C##Ul);		\
+	CHECK_SUFul_TYPE(C##UL);		\
+	CHECK_SUFll_OCTHEX_TYPE(C##ll);		\
+	CHECK_SUFll_OCTHEX_TYPE(C##LL);		\
+	CHECK_SUFull_TYPE(C##ull);		\
+	CHECK_SUFull_TYPE(C##uLL);		\
+	CHECK_SUFull_TYPE(C##Ull);		\
+	CHECK_SUFull_TYPE(C##ULL);
+
+#define CHECK_OCT_CONST(C) CHECK_OCTHEX_CONST(C)
+#define CHECK_HEX_CONST(C)			\
+	CHECK_OCTHEX_CONST(0x##C);		\
+	CHECK_OCTHEX_CONST(0X##C);
+
+/* True iff "long long" is at least B bits.  This presumes that (B-2)/3 is at
+   most 63.  */
+#define LLONG_AT_LEAST(B)			\
+	(LLONG_MAX >> ((B)-2)/3 >> ((B)-2)/3	\
+	 >> ((B)-2 - ((B)-2)/3 - ((B)-2)/3))
+
+#define LLONG_HAS_BITS(B) (LLONG_AT_LEAST((B)) && !LLONG_AT_LEAST((B) + 1))
+
+void
+foo (void)
+{
+  /* Decimal.  */
+  /* Check all 2^n and 2^n - 1 up to 2^71 - 1.  */
+  CHECK_DEC_CONST(1);
+  CHECK_DEC_CONST(2);
+  CHECK_DEC_CONST(3);
+  CHECK_DEC_CONST(4);
+  CHECK_DEC_CONST(7);
+  CHECK_DEC_CONST(8);
+  CHECK_DEC_CONST(15);
+  CHECK_DEC_CONST(16);
+  CHECK_DEC_CONST(31);
+  CHECK_DEC_CONST(32);
+  CHECK_DEC_CONST(63);
+  CHECK_DEC_CONST(64);
+  CHECK_DEC_CONST(127);
+  CHECK_DEC_CONST(128);
+  CHECK_DEC_CONST(255);
+  CHECK_DEC_CONST(256);
+  CHECK_DEC_CONST(511);
+  CHECK_DEC_CONST(512);
+  CHECK_DEC_CONST(1023);
+  CHECK_DEC_CONST(1024);
+  CHECK_DEC_CONST(2047);
+  CHECK_DEC_CONST(2048);
+  CHECK_DEC_CONST(4095);
+  CHECK_DEC_CONST(4096);
+  CHECK_DEC_CONST(8191);
+  CHECK_DEC_CONST(8192);
+  CHECK_DEC_CONST(16383);
+  CHECK_DEC_CONST(16384);
+  CHECK_DEC_CONST(32767);
+  CHECK_DEC_CONST(32768);
+  CHECK_DEC_CONST(65535);
+  CHECK_DEC_CONST(65536);
+  CHECK_DEC_CONST(131071);
+  CHECK_DEC_CONST(131072);
+  CHECK_DEC_CONST(262143);
+  CHECK_DEC_CONST(262144);
+  CHECK_DEC_CONST(524287);
+  CHECK_DEC_CONST(524288);
+  CHECK_DEC_CONST(1048575);
+  CHECK_DEC_CONST(1048576);
+  CHECK_DEC_CONST(2097151);
+  CHECK_DEC_CONST(2097152);
+  CHECK_DEC_CONST(4194303);
+  CHECK_DEC_CONST(4194304);
+  CHECK_DEC_CONST(8388607);
+  CHECK_DEC_CONST(8388608);
+  CHECK_DEC_CONST(16777215);
+  CHECK_DEC_CONST(16777216);
+  CHECK_DEC_CONST(33554431);
+  CHECK_DEC_CONST(33554432);
+  CHECK_DEC_CONST(67108863);
+  CHECK_DEC_CONST(67108864);
+  CHECK_DEC_CONST(134217727);
+  CHECK_DEC_CONST(134217728);
+  CHECK_DEC_CONST(268435455);
+  CHECK_DEC_CONST(268435456);
+  CHECK_DEC_CONST(536870911);
+  CHECK_DEC_CONST(536870912);
+  CHECK_DEC_CONST(1073741823);
+  CHECK_DEC_CONST(1073741824);
+  CHECK_DEC_CONST(2147483647);
+  CHECK_DEC_CONST(2147483648);
+  CHECK_DEC_CONST(4294967295);
+  CHECK_DEC_CONST(4294967296);
+  CHECK_DEC_CONST(8589934591);
+  CHECK_DEC_CONST(8589934592);
+  CHECK_DEC_CONST(17179869183);
+  CHECK_DEC_CONST(17179869184);
+  CHECK_DEC_CONST(34359738367);
+  CHECK_DEC_CONST(34359738368);
+  CHECK_DEC_CONST(68719476735);
+  CHECK_DEC_CONST(68719476736);
+  CHECK_DEC_CONST(137438953471);
+  CHECK_DEC_CONST(137438953472);
+  CHECK_DEC_CONST(274877906943);
+  CHECK_DEC_CONST(274877906944);
+  CHECK_DEC_CONST(549755813887);
+  CHECK_DEC_CONST(549755813888);
+  CHECK_DEC_CONST(1099511627775);
+  CHECK_DEC_CONST(1099511627776);
+  CHECK_DEC_CONST(2199023255551);
+  CHECK_DEC_CONST(2199023255552);
+  CHECK_DEC_CONST(4398046511103);
+  CHECK_DEC_CONST(4398046511104);
+  CHECK_DEC_CONST(8796093022207);
+  CHECK_DEC_CONST(8796093022208);
+  CHECK_DEC_CONST(17592186044415);
+  CHECK_DEC_CONST(17592186044416);
+  CHECK_DEC_CONST(35184372088831);
+  CHECK_DEC_CONST(35184372088832);
+  CHECK_DEC_CONST(70368744177663);
+  CHECK_DEC_CONST(70368744177664);
+  CHECK_DEC_CONST(140737488355327);
+  CHECK_DEC_CONST(140737488355328);
+  CHECK_DEC_CONST(281474976710655);
+  CHECK_DEC_CONST(281474976710656);
+  CHECK_DEC_CONST(562949953421311);
+  CHECK_DEC_CONST(562949953421312);
+  CHECK_DEC_CONST(1125899906842623);
+  CHECK_DEC_CONST(1125899906842624);
+  CHECK_DEC_CONST(2251799813685247);
+  CHECK_DEC_CONST(2251799813685248);
+  CHECK_DEC_CONST(4503599627370495);
+  CHECK_DEC_CONST(4503599627370496);
+  CHECK_DEC_CONST(9007199254740991);
+  CHECK_DEC_CONST(9007199254740992);
+  CHECK_DEC_CONST(18014398509481983);
+  CHECK_DEC_CONST(18014398509481984);
+  CHECK_DEC_CONST(36028797018963967);
+  CHECK_DEC_CONST(36028797018963968);
+  CHECK_DEC_CONST(72057594037927935);
+  CHECK_DEC_CONST(72057594037927936);
+  CHECK_DEC_CONST(144115188075855871);
+  CHECK_DEC_CONST(144115188075855872);
+  CHECK_DEC_CONST(288230376151711743);
+  CHECK_DEC_CONST(288230376151711744);
+  CHECK_DEC_CONST(576460752303423487);
+  CHECK_DEC_CONST(576460752303423488);
+  CHECK_DEC_CONST(1152921504606846975);
+  CHECK_DEC_CONST(1152921504606846976);
+  CHECK_DEC_CONST(2305843009213693951);
+  CHECK_DEC_CONST(2305843009213693952);
+  CHECK_DEC_CONST(4611686018427387903);
+  CHECK_DEC_CONST(4611686018427387904);
+  CHECK_DEC_CONST(9223372036854775807);
+#if LLONG_AT_LEAST(65)
+  CHECK_DEC_CONST(9223372036854775808);
+  CHECK_DEC_CONST(18446744073709551615);
+#endif
+#if LLONG_AT_LEAST(66)
+  CHECK_DEC_CONST(18446744073709551616);
+  CHECK_DEC_CONST(36893488147419103231);
+#endif
+#if LLONG_AT_LEAST(67)
+  CHECK_DEC_CONST(36893488147419103232);
+  CHECK_DEC_CONST(73786976294838206463);
+#endif
+#if LLONG_AT_LEAST(68)
+  CHECK_DEC_CONST(73786976294838206464);
+  CHECK_DEC_CONST(147573952589676412927);
+#endif
+#if LLONG_AT_LEAST(69)
+  CHECK_DEC_CONST(147573952589676412928);
+  CHECK_DEC_CONST(295147905179352825855);
+#endif
+#if LLONG_AT_LEAST(70)
+  CHECK_DEC_CONST(295147905179352825856);
+  CHECK_DEC_CONST(590295810358705651711);
+#endif
+#if LLONG_AT_LEAST(71)
+  CHECK_DEC_CONST(590295810358705651712);
+  CHECK_DEC_CONST(1180591620717411303423);
+#endif
+#if LLONG_AT_LEAST(72)
+  CHECK_DEC_CONST(1180591620717411303424);
+  CHECK_DEC_CONST(2361183241434822606847);
+#endif
+  /* Octal and hexadecimal.  */
+  /* Check all 2^n and 2^n - 1 up to 2^72 - 1.  */
+  CHECK_OCT_CONST(0);
+  CHECK_HEX_CONST(0);
+  CHECK_OCT_CONST(01);
+  CHECK_HEX_CONST(1);
+  CHECK_OCT_CONST(02);
+  CHECK_HEX_CONST(2);
+  CHECK_OCT_CONST(03);
+  CHECK_HEX_CONST(3);
+  CHECK_OCT_CONST(04);
+  CHECK_HEX_CONST(4);
+  CHECK_OCT_CONST(07);
+  CHECK_HEX_CONST(7);
+  CHECK_OCT_CONST(010);
+  CHECK_HEX_CONST(8);
+  CHECK_OCT_CONST(017);
+  CHECK_HEX_CONST(f);
+  CHECK_OCT_CONST(020);
+  CHECK_HEX_CONST(10);
+  CHECK_OCT_CONST(037);
+  CHECK_HEX_CONST(1f);
+  CHECK_OCT_CONST(040);
+  CHECK_HEX_CONST(20);
+  CHECK_OCT_CONST(077);
+  CHECK_HEX_CONST(3f);
+  CHECK_OCT_CONST(0100);
+  CHECK_HEX_CONST(40);
+  CHECK_OCT_CONST(0177);
+  CHECK_HEX_CONST(7f);
+  CHECK_OCT_CONST(0200);
+  CHECK_HEX_CONST(80);
+  CHECK_OCT_CONST(0377);
+  CHECK_HEX_CONST(ff);
+  CHECK_OCT_CONST(0400);
+  CHECK_HEX_CONST(100);
+  CHECK_OCT_CONST(0777);
+  CHECK_HEX_CONST(1ff);
+  CHECK_OCT_CONST(01000);
+  CHECK_HEX_CONST(200);
+  CHECK_OCT_CONST(01777);
+  CHECK_HEX_CONST(3ff);
+  CHECK_OCT_CONST(02000);
+  CHECK_HEX_CONST(400);
+  CHECK_OCT_CONST(03777);
+  CHECK_HEX_CONST(7ff);
+  CHECK_OCT_CONST(04000);
+  CHECK_HEX_CONST(800);
+  CHECK_OCT_CONST(07777);
+  CHECK_HEX_CONST(fff);
+  CHECK_OCT_CONST(010000);
+  CHECK_HEX_CONST(1000);
+  CHECK_OCT_CONST(017777);
+  CHECK_HEX_CONST(1fff);
+  CHECK_OCT_CONST(020000);
+  CHECK_HEX_CONST(2000);
+  CHECK_OCT_CONST(037777);
+  CHECK_HEX_CONST(3fff);
+  CHECK_OCT_CONST(040000);
+  CHECK_HEX_CONST(4000);
+  CHECK_OCT_CONST(077777);
+  CHECK_HEX_CONST(7fff);
+  CHECK_OCT_CONST(0100000);
+  CHECK_HEX_CONST(8000);
+  CHECK_OCT_CONST(0177777);
+  CHECK_HEX_CONST(ffff);
+  CHECK_OCT_CONST(0200000);
+  CHECK_HEX_CONST(10000);
+  CHECK_OCT_CONST(0377777);
+  CHECK_HEX_CONST(1ffff);
+  CHECK_OCT_CONST(0400000);
+  CHECK_HEX_CONST(20000);
+  CHECK_OCT_CONST(0777777);
+  CHECK_HEX_CONST(3ffff);
+  CHECK_OCT_CONST(01000000);
+  CHECK_HEX_CONST(40000);
+  CHECK_OCT_CONST(01777777);
+  CHECK_HEX_CONST(7ffff);
+  CHECK_OCT_CONST(02000000);
+  CHECK_HEX_CONST(80000);
+  CHECK_OCT_CONST(03777777);
+  CHECK_HEX_CONST(fffff);
+  CHECK_OCT_CONST(04000000);
+  CHECK_HEX_CONST(100000);
+  CHECK_OCT_CONST(07777777);
+  CHECK_HEX_CONST(1fffff);
+  CHECK_OCT_CONST(010000000);
+  CHECK_HEX_CONST(200000);
+  CHECK_OCT_CONST(017777777);
+  CHECK_HEX_CONST(3fffff);
+  CHECK_OCT_CONST(020000000);
+  CHECK_HEX_CONST(400000);
+  CHECK_OCT_CONST(037777777);
+  CHECK_HEX_CONST(7fffff);
+  CHECK_OCT_CONST(040000000);
+  CHECK_HEX_CONST(800000);
+  CHECK_OCT_CONST(077777777);
+  CHECK_HEX_CONST(ffffff);
+  CHECK_OCT_CONST(0100000000);
+  CHECK_HEX_CONST(1000000);
+  CHECK_OCT_CONST(0177777777);
+  CHECK_HEX_CONST(1ffffff);
+  CHECK_OCT_CONST(0200000000);
+  CHECK_HEX_CONST(2000000);
+  CHECK_OCT_CONST(0377777777);
+  CHECK_HEX_CONST(3ffffff);
+  CHECK_OCT_CONST(0400000000);
+  CHECK_HEX_CONST(4000000);
+  CHECK_OCT_CONST(0777777777);
+  CHECK_HEX_CONST(7ffffff);
+  CHECK_OCT_CONST(01000000000);
+  CHECK_HEX_CONST(8000000);
+  CHECK_OCT_CONST(01777777777);
+  CHECK_HEX_CONST(fffffff);
+  CHECK_OCT_CONST(02000000000);
+  CHECK_HEX_CONST(10000000);
+  CHECK_OCT_CONST(03777777777);
+  CHECK_HEX_CONST(1fffffff);
+  CHECK_OCT_CONST(04000000000);
+  CHECK_HEX_CONST(20000000);
+  CHECK_OCT_CONST(07777777777);
+  CHECK_HEX_CONST(3fffffff);
+  CHECK_OCT_CONST(010000000000);
+  CHECK_HEX_CONST(40000000);
+  CHECK_OCT_CONST(017777777777);
+  CHECK_HEX_CONST(7fffffff);
+  CHECK_OCT_CONST(020000000000);
+  CHECK_HEX_CONST(80000000);
+  CHECK_OCT_CONST(037777777777);
+  CHECK_HEX_CONST(ffffffff);
+  CHECK_OCT_CONST(040000000000);
+  CHECK_HEX_CONST(100000000);
+  CHECK_OCT_CONST(077777777777);
+  CHECK_HEX_CONST(1ffffffff);
+  CHECK_OCT_CONST(0100000000000);
+  CHECK_HEX_CONST(200000000);
+  CHECK_OCT_CONST(0177777777777);
+  CHECK_HEX_CONST(3ffffffff);
+  CHECK_OCT_CONST(0200000000000);
+  CHECK_HEX_CONST(400000000);
+  CHECK_OCT_CONST(0377777777777);
+  CHECK_HEX_CONST(7ffffffff);
+  CHECK_OCT_CONST(0400000000000);
+  CHECK_HEX_CONST(800000000);
+  CHECK_OCT_CONST(0777777777777);
+  CHECK_HEX_CONST(fffffffff);
+  CHECK_OCT_CONST(01000000000000);
+  CHECK_HEX_CONST(1000000000);
+  CHECK_OCT_CONST(01777777777777);
+  CHECK_HEX_CONST(1fffffffff);
+  CHECK_OCT_CONST(02000000000000);
+  CHECK_HEX_CONST(2000000000);
+  CHECK_OCT_CONST(03777777777777);
+  CHECK_HEX_CONST(3fffffffff);
+  CHECK_OCT_CONST(04000000000000);
+  CHECK_HEX_CONST(4000000000);
+  CHECK_OCT_CONST(07777777777777);
+  CHECK_HEX_CONST(7fffffffff);
+  CHECK_OCT_CONST(010000000000000);
+  CHECK_HEX_CONST(8000000000);
+  CHECK_OCT_CONST(017777777777777);
+  CHECK_HEX_CONST(ffffffffff);
+  CHECK_OCT_CONST(020000000000000);
+  CHECK_HEX_CONST(10000000000);
+  CHECK_OCT_CONST(037777777777777);
+  CHECK_HEX_CONST(1ffffffffff);
+  CHECK_OCT_CONST(040000000000000);
+  CHECK_HEX_CONST(20000000000);
+  CHECK_OCT_CONST(077777777777777);
+  CHECK_HEX_CONST(3ffffffffff);
+  CHECK_OCT_CONST(0100000000000000);
+  CHECK_HEX_CONST(40000000000);
+  CHECK_OCT_CONST(0177777777777777);
+  CHECK_HEX_CONST(7ffffffffff);
+  CHECK_OCT_CONST(0200000000000000);
+  CHECK_HEX_CONST(80000000000);
+  CHECK_OCT_CONST(0377777777777777);
+  CHECK_HEX_CONST(fffffffffff);
+  CHECK_OCT_CONST(0400000000000000);
+  CHECK_HEX_CONST(100000000000);
+  CHECK_OCT_CONST(0777777777777777);
+  CHECK_HEX_CONST(1fffffffffff);
+  CHECK_OCT_CONST(01000000000000000);
+  CHECK_HEX_CONST(200000000000);
+  CHECK_OCT_CONST(01777777777777777);
+  CHECK_HEX_CONST(3fffffffffff);
+  CHECK_OCT_CONST(02000000000000000);
+  CHECK_HEX_CONST(400000000000);
+  CHECK_OCT_CONST(03777777777777777);
+  CHECK_HEX_CONST(7fffffffffff);
+  CHECK_OCT_CONST(04000000000000000);
+  CHECK_HEX_CONST(800000000000);
+  CHECK_OCT_CONST(07777777777777777);
+  CHECK_HEX_CONST(ffffffffffff);
+  CHECK_OCT_CONST(010000000000000000);
+  CHECK_HEX_CONST(1000000000000);
+  CHECK_OCT_CONST(017777777777777777);
+  CHECK_HEX_CONST(1ffffffffffff);
+  CHECK_OCT_CONST(020000000000000000);
+  CHECK_HEX_CONST(2000000000000);
+  CHECK_OCT_CONST(037777777777777777);
+  CHECK_HEX_CONST(3ffffffffffff);
+  CHECK_OCT_CONST(040000000000000000);
+  CHECK_HEX_CONST(4000000000000);
+  CHECK_OCT_CONST(077777777777777777);
+  CHECK_HEX_CONST(7ffffffffffff);
+  CHECK_OCT_CONST(0100000000000000000);
+  CHECK_HEX_CONST(8000000000000);
+  CHECK_OCT_CONST(0177777777777777777);
+  CHECK_HEX_CONST(fffffffffffff);
+  CHECK_OCT_CONST(0200000000000000000);
+  CHECK_HEX_CONST(10000000000000);
+  CHECK_OCT_CONST(0377777777777777777);
+  CHECK_HEX_CONST(1fffffffffffff);
+  CHECK_OCT_CONST(0400000000000000000);
+  CHECK_HEX_CONST(20000000000000);
+  CHECK_OCT_CONST(0777777777777777777);
+  CHECK_HEX_CONST(3fffffffffffff);
+  CHECK_OCT_CONST(01000000000000000000);
+  CHECK_HEX_CONST(40000000000000);
+  CHECK_OCT_CONST(01777777777777777777);
+  CHECK_HEX_CONST(7fffffffffffff);
+  CHECK_OCT_CONST(02000000000000000000);
+  CHECK_HEX_CONST(80000000000000);
+  CHECK_OCT_CONST(03777777777777777777);
+  CHECK_HEX_CONST(ffffffffffffff);
+  CHECK_OCT_CONST(04000000000000000000);
+  CHECK_HEX_CONST(100000000000000);
+  CHECK_OCT_CONST(07777777777777777777);
+  CHECK_HEX_CONST(1ffffffffffffff);
+  CHECK_OCT_CONST(010000000000000000000);
+  CHECK_HEX_CONST(200000000000000);
+  CHECK_OCT_CONST(017777777777777777777);
+  CHECK_HEX_CONST(3ffffffffffffff);
+  CHECK_OCT_CONST(020000000000000000000);
+  CHECK_HEX_CONST(400000000000000);
+  CHECK_OCT_CONST(037777777777777777777);
+  CHECK_HEX_CONST(7ffffffffffffff);
+  CHECK_OCT_CONST(040000000000000000000);
+  CHECK_HEX_CONST(800000000000000);
+  CHECK_OCT_CONST(077777777777777777777);
+  CHECK_HEX_CONST(fffffffffffffff);
+  CHECK_OCT_CONST(0100000000000000000000);
+  CHECK_HEX_CONST(1000000000000000);
+  CHECK_OCT_CONST(0177777777777777777777);
+  CHECK_HEX_CONST(1fffffffffffffff);
+  CHECK_OCT_CONST(0200000000000000000000);
+  CHECK_HEX_CONST(2000000000000000);
+  CHECK_OCT_CONST(0377777777777777777777);
+  CHECK_HEX_CONST(3fffffffffffffff);
+  CHECK_OCT_CONST(0400000000000000000000);
+  CHECK_HEX_CONST(4000000000000000);
+  CHECK_OCT_CONST(0777777777777777777777);
+  CHECK_HEX_CONST(7fffffffffffffff);
+  CHECK_OCT_CONST(01000000000000000000000);
+  CHECK_HEX_CONST(8000000000000000);
+  CHECK_OCT_CONST(01777777777777777777777);
+  CHECK_HEX_CONST(ffffffffffffffff);
+#if LLONG_AT_LEAST(65)
+  CHECK_OCT_CONST(02000000000000000000000);
+  CHECK_HEX_CONST(10000000000000000);
+  CHECK_OCT_CONST(03777777777777777777777);
+  CHECK_HEX_CONST(1ffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(66)
+  CHECK_OCT_CONST(04000000000000000000000);
+  CHECK_HEX_CONST(20000000000000000);
+  CHECK_OCT_CONST(07777777777777777777777);
+  CHECK_HEX_CONST(3ffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(67)
+  CHECK_OCT_CONST(010000000000000000000000);
+  CHECK_HEX_CONST(40000000000000000);
+  CHECK_OCT_CONST(017777777777777777777777);
+  CHECK_HEX_CONST(7ffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(68)
+  CHECK_OCT_CONST(020000000000000000000000);
+  CHECK_HEX_CONST(80000000000000000);
+  CHECK_OCT_CONST(037777777777777777777777);
+  CHECK_HEX_CONST(fffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(69)
+  CHECK_OCT_CONST(040000000000000000000000);
+  CHECK_HEX_CONST(100000000000000000);
+  CHECK_OCT_CONST(077777777777777777777777);
+  CHECK_HEX_CONST(1fffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(70)
+  CHECK_OCT_CONST(0100000000000000000000000);
+  CHECK_HEX_CONST(200000000000000000);
+  CHECK_OCT_CONST(0177777777777777777777777);
+  CHECK_HEX_CONST(3fffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(71)
+  CHECK_OCT_CONST(0200000000000000000000000);
+  CHECK_HEX_CONST(400000000000000000);
+  CHECK_OCT_CONST(0377777777777777777777777);
+  CHECK_HEX_CONST(7fffffffffffffffff);
+#endif
+#if LLONG_AT_LEAST(72)
+  CHECK_OCT_CONST(0400000000000000000000000);
+  CHECK_HEX_CONST(800000000000000000);
+  CHECK_OCT_CONST(0777777777777777777777777);
+  CHECK_HEX_CONST(ffffffffffffffffff);
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-intprom-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-intprom-1.c
new file mode 100644
index 000000000..0d7a33ee8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-intprom-1.c
@@ -0,0 +1,77 @@
+/* Test for integer promotion rules: extended to long long by C99.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#include <limits.h>
+
+#define CHECK(T1, T2, TC)			\
+  do {						\
+    T1 a = 0;					\
+    T2 b = 0;					\
+    TC *c = 0;					\
+    __typeof__(a+b) *d = 0;			\
+    c = d;					\
+    d = c;					\
+  } while (0)
+
+void
+f (void)
+{
+  /* Same type.  */
+  CHECK(int, int, int);
+  CHECK(unsigned int, unsigned int, unsigned int);
+  CHECK(long, long, long);
+  CHECK(unsigned long, unsigned long, unsigned long);
+  CHECK(long long, long long, long long);
+  CHECK(unsigned long long, unsigned long long, unsigned long long);
+  /* Both signed.  */
+  CHECK(int, long, long);
+  CHECK(int, long long, long long);
+  CHECK(long, int, long);
+  CHECK(long, long long, long long);
+  CHECK(long long, int, long long);
+  CHECK(long long, long, long long);
+  /* Both unsigned.  */
+  CHECK(unsigned int, unsigned long, unsigned long);
+  CHECK(unsigned int, unsigned long long, unsigned long long);
+  CHECK(unsigned long, unsigned int, unsigned long);
+  CHECK(unsigned long, unsigned long long, unsigned long long);
+  CHECK(unsigned long long, unsigned int, unsigned long long);
+  CHECK(unsigned long long, unsigned long, unsigned long long);
+  /* Unsigned of greater or equal rank.  */
+  CHECK(int, unsigned int, unsigned int);
+  CHECK(int, unsigned long, unsigned long);
+  CHECK(int, unsigned long long, unsigned long long);
+  CHECK(unsigned int, int, unsigned int);
+  CHECK(long, unsigned long, unsigned long);
+  CHECK(long, unsigned long long, unsigned long long);
+  CHECK(unsigned long, int, unsigned long);
+  CHECK(unsigned long, long, unsigned long);
+  CHECK(long long, unsigned long long, unsigned long long);
+  CHECK(unsigned long long, int, unsigned long long);
+  CHECK(unsigned long long, long, unsigned long long);
+  CHECK(unsigned long long, long long, unsigned long long);
+  /* Signed of greater rank.  */
+#if LONG_MAX >= UINT_MAX
+  CHECK(unsigned int, long, long);
+  CHECK(long, unsigned int, long);
+#else
+  CHECK(unsigned int, long, unsigned long);
+  CHECK(long, unsigned int, unsigned long);
+#endif
+#if LLONG_MAX >= UINT_MAX
+  CHECK(unsigned int, long long, long long);
+  CHECK(long long, unsigned int, long long);
+#else
+  CHECK(unsigned int, long long, unsigned long long);
+  CHECK(long long, unsigned int, unsigned long long);
+#endif
+#if LLONG_MAX >= ULONG_MAX
+  CHECK(unsigned long, long long, long long);
+  CHECK(long long, unsigned long, long long);
+#else
+  CHECK(unsigned long, long long, unsigned long long);
+  CHECK(long long, unsigned long, unsigned long long);
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-longlong-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-longlong-1.c
new file mode 100644
index 000000000..92d5e0e80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-longlong-1.c
@@ -0,0 +1,6 @@
+/* Test for long long: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+long long foo; /* { dg-bogus "long long" "bogus long long error" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-main-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-main-1.c
new file mode 100644
index 000000000..fdef9fd36
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-main-1.c
@@ -0,0 +1,9 @@
+/* Test for implicit return 0 from main in C99.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors -Wreturn-type -O -fhosted" } */
+
+int
+main (void)
+{
+} /* { dg-bogus "control reaches end" "missing implicit return" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-double-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-double-1.c
new file mode 100644
index 000000000..6441a59fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-double-1.c
@@ -0,0 +1,22 @@
+/* { dg-do run { target *-*-solaris2.1[0-9]* } } */
+/* { dg-options "-std=c99 -O" } */
+
+#include <math.h>
+#include "c99-math.h"
+
+int main(void)
+{
+  volatile double nan = NAN;
+  volatile double inf = INFINITY;
+  volatile double huge = HUGE_VAL;
+  volatile double norm1 = __DBL_MIN__;
+  volatile double norm2 = 1;
+  volatile double norm3 = __DBL_MAX__;
+  volatile double sub = __DBL_MIN__ / 2;
+  volatile double zero = 0.0;
+
+  C99_MATH_TESTS (nan, inf, huge, norm1, norm2, norm3, sub, zero, /*neg=*/0)
+  C99_MATH_TESTS (-nan, -inf, -huge, -norm1, -norm2, -norm3, -sub, -zero, /*neg=*/1)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-float-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-float-1.c
new file mode 100644
index 000000000..36a739602
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-float-1.c
@@ -0,0 +1,22 @@
+/* { dg-do run { target *-*-solaris2.1[0-9]* } } */
+/* { dg-options "-std=c99 -O" } */
+
+#include <math.h>
+#include "c99-math.h"
+
+int main(void)
+{
+  volatile float nan = NAN;
+  volatile float inf = INFINITY;
+  volatile float huge = HUGE_VALF;
+  volatile float norm1 = __FLT_MIN__;
+  volatile float norm2 = 1;
+  volatile float norm3 = __FLT_MAX__;
+  volatile float sub = __FLT_MIN__ / 2;
+  volatile float zero = 0.0f;
+
+  C99_MATH_TESTS (nan, inf, huge, norm1, norm2, norm3, sub, zero, /*neg=*/0)
+  C99_MATH_TESTS (-nan, -inf, -huge, -norm1, -norm2, -norm3, -sub, -zero, /*neg=*/1)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-long-double-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-long-double-1.c
new file mode 100644
index 000000000..d8146c28a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math-long-double-1.c
@@ -0,0 +1,22 @@
+/* { dg-do run { target *-*-solaris2.1[0-9]* } } */
+/* { dg-options "-std=c99 -O" } */
+
+#include <math.h>
+#include "c99-math.h"
+
+int main(void)
+{
+  volatile long double nan = NAN;
+  volatile long double inf = INFINITY;
+  volatile long double huge = HUGE_VALL;
+  volatile long double norm1 = __LDBL_MIN__;
+  volatile long double norm2 = 1;
+  volatile long double norm3 = __LDBL_MAX__;
+  volatile long double sub = __LDBL_MIN__ / 2;
+  volatile long double zero = 0.0l;
+
+  C99_MATH_TESTS (nan, inf, huge, norm1, norm2, norm3, sub, zero, /*neg=*/0)
+  C99_MATH_TESTS (-nan, -inf, -huge, -norm1, -norm2, -norm3, -sub, -zero, /*neg=*/1)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math.h
new file mode 100644
index 000000000..81f2e6ddb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-math.h
@@ -0,0 +1,236 @@
+#include <math.h>
+#include <fenv.h>
+
+extern void abort(void);
+
+#define C99_MATH_TESTS(nan, inf, huge, norm1, norm2, norm3, sub, zero, neg) \
+{							\
+  if (feclearexcept (FE_ALL_EXCEPT) != 0)		\
+    abort();						\
+							\
+							\
+  if (fpclassify (nan) != FP_NAN)			\
+    abort ();						\
+							\
+  if (fpclassify (inf) != FP_INFINITE)			\
+    abort ();						\
+							\
+  if (fpclassify (huge) != FP_INFINITE)			\
+    abort ();						\
+							\
+  if (fpclassify (norm1) != FP_NORMAL)			\
+    abort ();						\
+							\
+  if (fpclassify (norm2) != FP_NORMAL)			\
+    abort ();						\
+							\
+  if (fpclassify (norm3) != FP_NORMAL)			\
+    abort ();						\
+							\
+  if (fpclassify (sub) != FP_SUBNORMAL)			\
+    abort ();						\
+							\
+  if (fpclassify (zero) != FP_ZERO)			\
+    abort ();						\
+							\
+							\
+  if (!isnan (nan))					\
+    abort ();						\
+							\
+  if (isnan (inf))					\
+    abort ();						\
+							\
+  if (isnan (huge))					\
+    abort ();						\
+							\
+  if (isnan (norm1))					\
+    abort ();						\
+							\
+  if (isnan (norm2))					\
+    abort ();						\
+							\
+  if (isnan (norm3))					\
+    abort ();						\
+							\
+  if (isnan (sub))					\
+    abort ();						\
+							\
+  if (isnan (zero))					\
+    abort ();						\
+							\
+							\
+  if (isinf (nan))					\
+    abort ();						\
+							\
+  if (!isinf (inf))					\
+    abort ();						\
+							\
+  if (!isinf (huge))					\
+    abort ();						\
+							\
+  if (isinf (norm1))					\
+    abort ();						\
+							\
+  if (isinf (norm2))					\
+    abort ();						\
+							\
+  if (isinf (norm3))					\
+    abort ();						\
+							\
+  if (isinf (sub))					\
+    abort ();						\
+							\
+  if (isinf (zero))					\
+    abort ();						\
+							\
+							\
+  if (isfinite (nan))					\
+    abort ();						\
+							\
+  if (isfinite (inf))					\
+    abort ();						\
+							\
+  if (isfinite (huge))					\
+    abort ();						\
+							\
+  if (!isfinite (norm1))				\
+    abort ();						\
+							\
+  if (!isfinite (norm2))				\
+    abort ();						\
+							\
+  if (!isfinite (norm3))				\
+    abort ();						\
+							\
+  if (!isfinite (sub))					\
+    abort ();						\
+							\
+  if (!isfinite (zero))					\
+    abort ();						\
+							\
+							\
+  if (isnormal (nan))					\
+    abort ();						\
+							\
+  if (isnormal (inf))					\
+    abort ();						\
+							\
+  if (isnormal (huge))					\
+    abort ();						\
+							\
+  if (!isnormal (norm1))				\
+    abort ();						\
+							\
+  if (!isnormal (norm2))				\
+    abort ();						\
+							\
+  if (!isnormal (norm3))				\
+    abort ();						\
+							\
+  if (isnormal (sub))					\
+    abort ();						\
+							\
+  if (isnormal (zero))					\
+    abort ();						\
+							\
+							\
+  if (!!signbit (nan) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (inf) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (huge) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (norm1) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (norm2) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (norm3) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (sub) != neg)				\
+    abort ();						\
+							\
+  if (!!signbit (zero) != neg)				\
+    abort ();						\
+							\
+							\
+  if (neg)						\
+  {							\
+    if (!isless ((inf), (norm1)))			\
+      abort ();						\
+							\
+    if (!isless ((inf), (norm2)))			\
+      abort ();						\
+							\
+    if (!isless ((inf), (norm3)))			\
+      abort ();						\
+							\
+    if (!islessequal ((inf), (huge)))			\
+      abort ();						\
+							\
+    if (!isgreater ((norm1), (inf)))			\
+      abort ();						\
+							\
+    if (!isgreater ((norm2), (inf)))			\
+      abort ();						\
+							\
+    if (!isgreater ((norm3), (inf)))			\
+      abort ();						\
+							\
+    if (!isgreaterequal ((huge), (inf)))		\
+      abort ();						\
+  }							\
+  else							\
+  {							\
+    if (!isgreater ((inf), (norm1)))			\
+      abort ();						\
+							\
+    if (!isgreater ((inf), (norm2)))			\
+      abort ();						\
+							\
+    if (!isgreater ((inf), (norm3)))			\
+      abort ();						\
+							\
+    if (!isgreaterequal ((inf), (huge)))		\
+      abort ();						\
+							\
+    if (!isless ((norm1), (inf)))			\
+      abort ();						\
+							\
+    if (!isless ((norm2), (inf)))			\
+      abort ();						\
+							\
+    if (!isless ((norm3), (inf)))			\
+      abort ();						\
+							\
+    if (!islessequal ((huge), (inf)))			\
+      abort ();						\
+  }							\
+							\
+  if (!islessgreater ((inf), (norm1)))			\
+    abort ();						\
+							\
+  if (!islessgreater ((inf), (norm2)))			\
+    abort ();						\
+							\
+  if (!islessgreater ((inf), (norm3)))			\
+    abort ();						\
+							\
+  if (!isunordered ((nan), (norm1)))			\
+    abort ();						\
+							\
+  if (!isunordered ((nan), (norm2)))			\
+    abort ();						\
+							\
+  if (!isunordered ((nan), (norm3)))			\
+    abort ();						\
+							\
+							\
+  if (fetestexcept (FE_ALL_EXCEPT) != 0)		\
+    abort();						\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-mixdecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-mixdecl-1.c
new file mode 100644
index 000000000..cfedad44c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-mixdecl-1.c
@@ -0,0 +1,25 @@
+/* Test for C99 mixed declarations and code.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int i = 0;
+  if (i != 0)
+    abort ();
+  i++;
+  if (i != 1)
+    abort ();
+  int j = i;
+  if (j != 1)
+    abort ();
+  struct foo { int i0; } k = { 4 };
+  if (k.i0 != 4)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-restrict-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-restrict-1.c
new file mode 100644
index 000000000..30ddd96bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-restrict-1.c
@@ -0,0 +1,19 @@
+/* Test for restrict: in C99 only.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+char *restrict foo;
+
+/* The following are constraint violations and should be rejected.  */
+
+int restrict bar; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "restrict" "restrict constraint violation" { target *-*-* } 10 } */
+
+typedef void (*fp) (void);
+
+fp restrict baz; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "restrict" "restrict constraint violation" { target *-*-* } 15 } */
+
+void quux (int restrict a[3]); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "restrict" "restrict constraint violation" { target *-*-* } 18 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-restrict-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-restrict-2.c
new file mode 100644
index 000000000..2adc5f2b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-restrict-2.c
@@ -0,0 +1,12 @@
+/* Test for restrict: in C99 only.  Test handling of arrays of restricted
+   pointers.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef int *ipa[2];
+
+int *restrict x[2];
+restrict ipa y;
+
+void f(int *restrict a[2], restrict ipa b, int *restrict c[restrict]);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-return-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-return-1.c
new file mode 100644
index 000000000..017cf89a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-return-1.c
@@ -0,0 +1,18 @@
+/* Test for constraints on return statements.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+int
+foo (void)
+{
+  return; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "with no value" "return constraint violation" { target *-*-* } 9 } */
+}
+
+void
+bar (void)
+{
+  return 1; /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "with a value" "return constraint violation" { target *-*-* } 16 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-scope-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-scope-1.c
new file mode 100644
index 000000000..48ea3b088
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-scope-1.c
@@ -0,0 +1,34 @@
+/* Test for new block scopes in C99.  Inspired by C99 Rationale (N897).  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct foo {
+  char a;
+};
+
+extern void abort (void);
+extern void exit (int);
+
+int
+sfoo (void)
+{
+  if (sizeof (struct foo { int a; double b; char *c; void *d; }))
+    (void) 0;
+  return sizeof (struct foo);
+}
+
+int
+main (void)
+{
+  int t, u;
+  t = sfoo ();
+  u = sizeof (struct foo);
+  /* With C90 scoping rules the new declaration of struct foo is in scope
+     above; with C99 it is local to the if.
+  */
+  if (t == u)
+    exit (0); /* C99 rules apply.  */
+  else
+    abort (); /* C90 rules apply.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-scope-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-scope-2.c
new file mode 100644
index 000000000..86ac272a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-scope-2.c
@@ -0,0 +1,71 @@
+/* Test for new block scopes in C99.  Test for each new scope.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do run } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  struct foo { int i0; };
+  int a, b, c, d;
+  a = sizeof (struct foo);
+  if (b = sizeof (struct foo { int i0; int i1; }))
+    c = sizeof (struct foo { int i0; int i1; int i2; });
+  if (!(a <= b && b <= c))
+    abort ();
+  if ((b = sizeof (struct foo { int i0; int i1; })), 0)
+    c = sizeof (struct foo { int i0; int i1; int i2; });
+  else
+    d = sizeof (struct foo { int i0; int i1; int i2; int i3; });
+  if (!(a <= b && b <= d))
+    abort ();
+  switch (b = sizeof (struct foo { int i0; int i1; }))
+    default:
+      c = sizeof (struct foo { int i0; int i1; int i2; });
+  if (!(a <= b && b <= c))
+    abort ();
+  do
+    c = sizeof (struct foo { int i0; int i1; int i2; });
+  while ((b = sizeof (struct foo { int i0; int i1; })), 0);
+  if (!(a <= b && b <= c))
+    abort ();
+  d = 1;
+  while ((b = sizeof (struct foo { int i0; int i1; })), d)
+    (c = sizeof (struct foo { int i0; int i1; int i2; })), d--;
+  if (!(a <= b && b <= c))
+    abort ();
+  d = 1;
+  for ((b = sizeof (struct foo { int i0; int i1; })); d; d--)
+    c = sizeof (struct foo { int i0; int i1; int i2; });
+  if (!(a <= b && b <= c))
+    abort ();
+  d = 1;
+  for ((b = sizeof (struct foo { int i0; int i1; })); d; d--)
+    c = sizeof (struct foo);
+  if (!(a <= b && b == c))
+    abort ();
+  d = 1;
+  for (; (b = sizeof (struct foo { int i0; int i1; })), d; d--)
+    c = sizeof (struct foo { int i0; int i1; int i2; });
+  if (!(a <= b && b <= c))
+    abort ();
+  d = 1;
+  for (; (b = sizeof (struct foo { int i0; int i1; })), d; d--)
+    c = sizeof (struct foo);
+  if (!(a <= b && b == c))
+    abort ();
+  d = 1;
+  for (; d; (b = sizeof (struct foo { int i0; int i1; })), d--)
+    c = sizeof (struct foo { int i0; int i1; int i2; });
+  if (!(a <= b && b <= c))
+    abort ();
+  d = 1;
+  for (; d; (b = sizeof (struct foo { int i0; int i1; })), d--)
+    c = sizeof (struct foo);
+  if (!(a <= b && b == c))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-static-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-static-1.c
new file mode 100644
index 000000000..3c817c624
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-static-1.c
@@ -0,0 +1,35 @@
+/* It is a constraint violation for a static function to be declared
+   but not defined if it is used except in a sizeof expression whose
+   result is an integer constant.  The use of the function simply
+   being unevaluated is not enough.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=iso9899:1999 -pedantic-errors" } */
+
+/* Constraint violation (trivial case, where function is used).  */
+static void f0(void); /* { dg-error "used but never defined" } */
+void g0(void) { f0(); }
+
+/* Constraint violation.  */
+static void f1(void); /* { dg-error "used but never defined" } */
+void g1(void) { if (0) { f1(); } }
+
+/* Constraint violation.  */
+static int f2(void); /* { dg-error "used but never defined" } */
+void g2(void) { 0 ? f2() : 0; }
+
+/* OK.  */
+static int f3(void);
+void g3(void) { sizeof(f3()); }
+
+/* OK (VM type, not VLA).  */
+static int f4(void);
+void g4(void) { sizeof(int (*)[f4()]); }
+
+/* Constraint violation (VLA).  */
+static int f5(void); /* { dg-error "used but never defined" "VLA" { xfail *-*-* } } */
+void g5(void) { sizeof(int [0 ? f5() : 1]); }
+
+/* OK (non-constant sizeof inside constant sizeof).  */
+static int f6(void);
+void g6(void) { sizeof(sizeof(int [f6()])); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-1.c
new file mode 100644
index 000000000..e93d3bcf0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-1.c
@@ -0,0 +1,151 @@
+/* Test for handling of tags (6.7.2.3).  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+foo (void)
+{
+  /* Forward declarations of structs and unions are OK; those of enums are
+     not.  */
+  {
+    struct s0;
+    struct s1 *x0;
+    union u0;
+    union u1 *x1;
+    enum e0; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "forward" "enum forward 1" { target *-*-* } 16 } */
+    enum e1 *x2; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "forward" "enum forward 2" { target *-*-* } 18 } */
+    /* GCC used to fail to diagnose a use of an enum inside its definition.  */
+    enum e2 { E2A = sizeof (enum e2 *) }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "forward" "enum forward 3" { target *-*-* } 21 } */
+  }
+  /* A specific type shall have its content defined at most once.  But we
+     may redeclare the tag in different scopes.  */
+  {
+    struct s0 { int i; };
+    {
+      struct s0 { long l; };
+    }
+    {
+      union s0 { long l; };
+    }
+    struct s0 { int i; }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "rede" "struct redef" { target *-*-* } 34 } */
+    union u0 { int i; };
+    {
+      union u0 { long l; };
+    }
+    {
+      struct u0 { long l; };
+    }
+    union u0 { int i; }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "rede" "union redef" { target *-*-* } 43 } */
+    enum e0 { E0A };
+    {
+      enum e0 { E0B };
+    }
+    {
+      struct e0 { long l; };
+    }
+    enum e0 { E0B }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "rede" "enum redef" { target *-*-* } 52 } */
+  }
+  /* Structure, union and enumerated types have a single namespace of tags.  */
+  {
+    struct s0;
+    struct s1;
+    struct s2 { int i; };
+    struct s2;
+    struct s3 { int i; };
+    struct s2 sv;
+    union u0;
+    union u2 { int i; };
+    union u2;
+    union u2 uv;
+    enum e0 { E0A };
+    enum e1 { E1A };
+    /* None of the following are allowed; some were not detected by GCC.  */
+    union s0; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 70 } */
+    union s1 { int i; }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 72 } */
+    union s2; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 74 } */
+    union s3 { int i; }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 76 } */
+    enum u0 { U0A }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 78 } */
+    enum u2 { U2A }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 80 } */
+    struct e0; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 82 } */
+    struct e1 { int i; }; /* { dg-bogus "warning" "warning in place of error" } */
+    /* { dg-error "wrong" "wrong tag type" { target *-*-* } 84 } */
+  }
+  /* Explicit shadowing in inner scopes is OK, but references to the tag
+     that don't explicitly shadow it must (whether in declarations or
+     expressions) use the correct one of struct/union/enum.  */
+  {
+    struct s0;
+    struct s1;
+    struct s2 { int i; };
+    struct s2;
+    struct s3 { int i; };
+    struct s2 sv;
+    union u0;
+    union u2 { int i; };
+    union u2;
+    union u2 uv;
+    enum e0 { E0A };
+    enum e1 { E1A };
+    {
+      union s0;
+      union s1;
+      union s2;
+      union s3;
+      struct u0;
+      struct u2;
+      struct e0;
+      union e1;
+    }
+    {
+      union s0 *x0; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 114 } */
+      int x1[sizeof (union s1 *)]; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 116 } */
+      struct t;
+      union s2 *x2;
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 119 } */
+      int x3[sizeof (union s3 *)]; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 121 } */
+      struct u;
+      enum u0 *y0; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong|forward" "wrong tag type" { target *-*-* } 124 } */
+      int y1[sizeof (enum u2 *)]; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong|forward" "wrong tag type" { target *-*-* } 126 } */
+      struct v;
+      struct e0 *z0; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 129 } */
+      int z1[sizeof (struct e1 *)]; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 131 } */
+      struct w;
+    }
+    /* When explicitly shadowed to be a tag of a different type, references
+       to the new type of tag must be accepted and those to the old type
+       rejected.  */
+    {
+      union s0;
+      union s0 *x0;
+      union s1;
+      struct s1 *x1; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 142 } */
+      union s2;
+      union s2 *x2;
+      union s3;
+      struct s3 *x3; /* { dg-bogus "warning" "warning in place of error" } */
+      /* { dg-error "wrong" "wrong tag type" { target *-*-* } 147 } */
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-2.c
new file mode 100644
index 000000000..22cf90e27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-2.c
@@ -0,0 +1,16 @@
+/* Test for handling of tags.  A struct defined in an inner scope does
+   not match one declared in an outer scope.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct s;
+struct t { struct s *p; } x;
+
+void
+f (void)
+{
+  /* This is a different struct s from the outer one.  */
+  struct s { int a; } y;
+  x.p = &y; /* { dg-error "incompatible" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-3.c
new file mode 100644
index 000000000..7406e7d64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tag-3.c
@@ -0,0 +1,59 @@
+/* Test for handling of tags.  "const struct foo;" and similar does
+   not redeclare an existing tag.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* Plain "struct s;" always declares a tag: the same as one declared
+   in that scope, or shadowing one from an outer scope.  */
+struct s0;
+struct s0 { int a; };
+struct s0;
+void f (void) { struct s0; }
+
+/* A declaration with a qualifier or storage class specifier declares
+   the tag if no other declaration of it is visible.  */
+const union u0; /* { dg-warning "useless type qualifier in empty declaration" } */
+union u0 { long b; };
+
+extern struct s1; /* { dg-warning "useless storage class specifier in empty declaration" } */
+
+/* But if a declaration of the tag is visible, whether at the same
+   scope or an outer scope, the declaration specifies the same type as
+   the previous declaration and does not redeclare the tag (C99
+   6.7.2.3#8).  Thus, as it does not declare a declarator, a tag or
+   the members of an enumeration, it is a constraint violation.  */
+
+struct s2 { char x; };
+const struct s2; /* { dg-error "empty declaration with type qualifier does not redeclare tag" } */
+
+union u1;
+extern union u1; /* { dg-error "empty declaration with storage class specifier does not redeclare tag" } */
+
+union u2 { long b; };
+void g(void) { const union u2; } /* { dg-error "empty declaration with type qualifier does not redeclare tag" } */
+
+/* And it does not redeclare the tag either if the outer tag is the
+   wrong kind of tag.  This also yields an error for the reference to
+   the wrong kind of tag in addition to the pedwarn for the empty
+   declaration.  */
+
+union u3 { float v; };
+void h(void) { const struct u3; } /* { dg-error "'u3' defined as wrong kind of tag" } */
+/* { dg-error "empty declaration with type qualifier does not redeclare tag" "wrong tag empty" { target *-*-* } 42 } */
+
+/* However, such useless specifiers are OK if the contents of the tag
+   are being defined, or shadowed in an inner scope with the contents
+   included in the shadowing.  */
+
+struct s3;
+const struct s3 { int a; }; /* { dg-warning "useless type qualifier in empty declaration" } */
+
+union u4;
+extern union u4 { int z; }; /* { dg-warning "useless storage class specifier in empty declaration" } */
+
+enum e0 { E0 };
+void i(void) { const enum e0 { E1 }; } /* { dg-warning "useless type qualifier in empty declaration" } */
+
+union u5 { int p; };
+void j(void) { extern struct u5 { int q; }; } /* { dg-warning "useless storage class specifier in empty declaration" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-1.c
new file mode 100644
index 000000000..c7d848c7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-1.c
@@ -0,0 +1,248 @@
+/* Test for <tgmath.h> in C99. */
+/* Origin: Matt Austern <austern@apple.com>
+/* { dg-do preprocess { target c99_runtime } } */
+/* { dg-options "-std=iso9899:1999" } */
+/* { dg-add-options c99_runtime } */
+
+/* Test that tgmath defines the macros it's supposed to. */
+#include <tgmath.h>
+
+#ifndef acos
+#error acos undefined
+#endif
+
+#ifndef asin
+#error asin undefined
+#endif
+
+#ifndef atan
+#error atan undefined
+#endif
+
+#ifndef acosh
+#error acosh undefined
+#endif
+
+#ifndef asinh
+#error asinh undefined
+#endif
+
+#ifndef atanh
+#error atanh undefined
+#endif
+
+#ifndef cos
+#error cos undefined
+#endif
+
+#ifndef sin
+#error sin undefined
+#endif
+
+#ifndef tan
+#error tan undefined
+#endif
+
+#ifndef cosh
+#error cosh undefined
+#endif
+
+#ifndef sinh
+#error sinh undefined
+#endif
+
+#ifndef tanh
+#error tanh undefined
+#endif
+
+#ifndef exp
+#error exp undefined
+#endif
+
+#ifndef log
+#error log undefined
+#endif
+
+#ifndef pow
+#error pow undefined
+#endif
+
+#ifndef sqrt
+#error sqrt undefined
+#endif
+
+#ifndef fabs
+#error fabs undefined
+#endif
+
+#ifndef atan2
+#error atan2 undefined
+#endif
+
+#ifndef cbrt
+#error cbrt undefined
+#endif
+
+#ifndef ceil
+#error ceil undefined
+#endif
+
+#ifndef copysign
+#error copysign undefined
+#endif
+
+#ifndef erf
+#error erf undefined
+#endif
+
+#ifndef erfc
+#error erfc undefined
+#endif
+
+#ifndef exp2
+#error exp2 undefined
+#endif
+
+#ifndef expm1
+#error expm1 undefined
+#endif
+
+#ifndef fdim
+#error fdim undefined
+#endif
+
+#ifndef floor
+#error floor undefined
+#endif
+
+#ifndef fma
+#error fma undefined
+#endif
+
+#ifndef fmax
+#error fmax undefined
+#endif
+
+#ifndef fmin
+#error fmin undefined
+#endif
+
+#ifndef fmod
+#error fmod undefined
+#endif
+
+#ifndef frexp
+#error frexp undefined
+#endif
+
+#ifndef hypot
+#error hypot undefined
+#endif
+
+#ifndef ilogb
+#error ilogb undefined
+#endif
+
+#ifndef ldexp
+#error ldexp undefined
+#endif
+
+#ifndef lgamma
+#error lgamma undefined
+#endif
+
+#ifndef llrint
+#error llrint undefined
+#endif
+
+#ifndef llround
+#error llround undefined
+#endif
+
+#ifndef log10
+#error log10 undefined
+#endif
+
+#ifndef log1p
+#error log1p undefined
+#endif
+
+#ifndef log2
+#error log2 undefined
+#endif
+
+#ifndef logb
+#error logb undefined
+#endif
+
+#ifndef lrint
+#error lrint undefined
+#endif
+
+#ifndef lround
+#error lround undefined
+#endif
+
+#ifndef nearbyint
+#error nearbyint undefined
+#endif
+
+#ifndef nextafter
+#error nextafter undefined
+#endif
+
+#ifndef nexttoward
+#error nexttoward undefined
+#endif
+
+#ifndef remainder
+#error remainder undefined
+#endif
+
+#ifndef remquo
+#error remquo undefined
+#endif
+
+#ifndef rint
+#error rint undefined
+#endif
+
+#ifndef round
+#error round undefined
+#endif
+
+#ifndef scalbn
+#error scalbn undefined
+#endif
+
+#ifndef scalbln
+#error scalbln undefined
+#endif
+
+#ifndef tgamma
+#error tgamma undefined
+#endif
+
+#ifndef trunc
+#error trunc undefined
+#endif
+
+#ifndef carg
+#error carg undefined
+#endif
+
+#ifndef cimag
+#error cimag undefined
+#endif
+
+#ifndef conj
+#error conj undefined
+#endif
+
+#ifndef cproj
+#error cproj undefined
+#endif
+
+#ifndef creal
+#error creal undefined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-2.c
new file mode 100644
index 000000000..d4f1f87cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-2.c
@@ -0,0 +1,15 @@
+/* Test for <tgmath.h> in C99. */
+/* Origin: Matt Austern <austern@apple.com>
+/* { dg-do compile { target c99_runtime } } */
+/* { dg-options "-std=iso9899:1999" } */
+/* { dg-add-options c99_runtime } */
+
+/* Test that invoking type-generic sin on a float invokes sinf. */
+#include <tgmath.h>
+
+float foo(float x)
+{
+  return sin(x);
+}
+
+/* { dg-final { scan-assembler "sinf" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-3.c
new file mode 100644
index 000000000..3e9830427
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-3.c
@@ -0,0 +1,15 @@
+/* Test for <tgmath.h> in C99. */
+/* Origin: Matt Austern <austern@apple.com>
+/* { dg-do compile { target c99_runtime } } */
+/* { dg-options "-std=iso9899:1999" } */
+/* { dg-add-options c99_runtime } */
+
+/* Test that invoking type-generic exp on a complex invokes cexp. */
+#include <tgmath.h>
+
+complex double foo(complex double x)
+{
+  return exp(x);
+}
+
+/* { dg-final { scan-assembler "cexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-4.c
new file mode 100644
index 000000000..d8dc043c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-tgmath-4.c
@@ -0,0 +1,15 @@
+/* Test for <tgmath.h> in C99. */
+/* Origin: Matt Austern <austern@apple.com>
+/* { dg-do compile { target c99_runtime } } */
+/* { dg-options "-std=iso9899:1999" } */
+/* { dg-add-options c99_runtime } */
+
+/* Test that invoking type-generic pow on complex float invokes cpowf. */
+#include <tgmath.h>
+
+complex double foo(complex float x, float y)
+{
+  return pow(x, y);
+}
+
+/* { dg-final { scan-assembler "cpowf" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-typespec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-typespec-1.c
new file mode 100644
index 000000000..a72335e4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-typespec-1.c
@@ -0,0 +1,1164 @@
+/* Test for valid and invalid combinations of type specifiers in C99.
+   Similar to typespec-1.c but with -pedantic-errors.
+   Includes _Complex, but not _Imaginary (expected to be removed in TC2).  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+typedef char type;
+void *x0;
+char *x1;
+short *x2;
+int *x3;
+long *x4;
+float *x5;
+double *x6;
+signed *x7;
+unsigned *x8;
+_Bool *x9;
+_Complex *x10; /* { dg-error "" "_Complex" } */
+type *x11;
+void void *x12; /* { dg-error "" "void void" } */
+void char *x13; /* { dg-error "" "void char" } */
+void short *x14; /* { dg-error "" "void short" } */
+void int *x15; /* { dg-error "" "void int" } */
+void long *x16; /* { dg-error "" "void long" } */
+void float *x17; /* { dg-error "" "void float" } */
+void double *x18; /* { dg-error "" "void double" } */
+void signed *x19; /* { dg-error "" "void signed" } */
+void unsigned *x20; /* { dg-error "" "void unsigned" } */
+void _Bool *x21; /* { dg-error "" "void _Bool" } */
+void _Complex *x22; /* { dg-error "" "void _Complex" } */
+char void *x23; /* { dg-error "" "char void" } */
+char char *x24; /* { dg-error "" "char char" } */
+char short *x25; /* { dg-error "" "char short" } */
+char int *x26; /* { dg-error "" "char int" } */
+char long *x27; /* { dg-error "" "char long" } */
+char float *x28; /* { dg-error "" "char float" } */
+char double *x29; /* { dg-error "" "char double" } */
+char signed *x30;
+char unsigned *x31;
+char _Bool *x32; /* { dg-error "" "char _Bool" } */
+char _Complex *x33; /* { dg-error "" "char _Complex" } */
+short void *x34; /* { dg-error "" "short void" } */
+short char *x35; /* { dg-error "" "short char" } */
+short short *x36; /* { dg-error "" "short short" } */
+short int *x37;
+short long *x38; /* { dg-error "" "short long" } */
+short float *x39; /* { dg-error "" "short float" } */
+short double *x40; /* { dg-error "" "short double" } */
+short signed *x41;
+short unsigned *x42;
+short _Bool *x43; /* { dg-error "" "short _Bool" } */
+short _Complex *x44; /* { dg-error "" "short _Complex" } */
+int void *x45; /* { dg-error "" "int void" } */
+int char *x46; /* { dg-error "" "int char" } */
+int short *x47;
+int int *x48; /* { dg-error "" "int int" } */
+int long *x49;
+int float *x50; /* { dg-error "" "int float" } */
+int double *x51; /* { dg-error "" "int double" } */
+int signed *x52;
+int unsigned *x53;
+int _Bool *x54; /* { dg-error "" "int _Bool" } */
+int _Complex *x55; /* { dg-error "" "int _Complex" } */
+long void *x56; /* { dg-error "" "long void" } */
+long char *x57; /* { dg-error "" "long char" } */
+long short *x58; /* { dg-error "" "long short" } */
+long int *x59;
+long long *x60;
+long float *x61; /* { dg-error "" "long float" } */
+long double *x62;
+long signed *x63;
+long unsigned *x64;
+long _Bool *x65; /* { dg-error "" "long _Bool" } */
+long _Complex *x66; /* { dg-error "" "long _Complex" } */
+float void *x67; /* { dg-error "" "float void" } */
+float char *x68; /* { dg-error "" "float char" } */
+float short *x69; /* { dg-error "" "float short" } */
+float int *x70; /* { dg-error "" "float int" } */
+float long *x71; /* { dg-error "" "float long" } */
+float float *x72; /* { dg-error "" "float float" } */
+float double *x73; /* { dg-error "" "float double" } */
+float signed *x74; /* { dg-error "" "float signed" } */
+float unsigned *x75; /* { dg-error "" "float unsigned" } */
+float _Bool *x76; /* { dg-error "" "float _Bool" } */
+float _Complex *x77;
+double void *x78; /* { dg-error "" "double void" } */
+double char *x79; /* { dg-error "" "double char" } */
+double short *x80; /* { dg-error "" "double short" } */
+double int *x81; /* { dg-error "" "double int" } */
+double long *x82;
+double float *x83; /* { dg-error "" "double float" } */
+double double *x84; /* { dg-error "" "double double" } */
+double signed *x85; /* { dg-error "" "double signed" } */
+double unsigned *x86; /* { dg-error "" "double unsigned" } */
+double _Bool *x87; /* { dg-error "" "double _Bool" } */
+double _Complex *x88;
+signed void *x89; /* { dg-error "" "signed void" } */
+signed char *x90;
+signed short *x91;
+signed int *x92;
+signed long *x93;
+signed float *x94; /* { dg-error "" "signed float" } */
+signed double *x95; /* { dg-error "" "signed double" } */
+signed signed *x96; /* { dg-error "" "signed signed" } */
+signed unsigned *x97; /* { dg-error "" "signed unsigned" } */
+signed _Bool *x98; /* { dg-error "" "signed _Bool" } */
+signed _Complex *x99; /* { dg-error "" "signed _Complex" } */
+unsigned void *x100; /* { dg-error "" "unsigned void" } */
+unsigned char *x101;
+unsigned short *x102;
+unsigned int *x103;
+unsigned long *x104;
+unsigned float *x105; /* { dg-error "" "unsigned float" } */
+unsigned double *x106; /* { dg-error "" "unsigned double" } */
+unsigned signed *x107; /* { dg-error "" "unsigned signed" } */
+unsigned unsigned *x108; /* { dg-error "" "unsigned unsigned" } */
+unsigned _Bool *x109; /* { dg-error "" "unsigned _Bool" } */
+unsigned _Complex *x110; /* { dg-error "" "unsigned _Complex" } */
+_Bool void *x111; /* { dg-error "" "_Bool void" } */
+_Bool char *x112; /* { dg-error "" "_Bool char" } */
+_Bool short *x113; /* { dg-error "" "_Bool short" } */
+_Bool int *x114; /* { dg-error "" "_Bool int" } */
+_Bool long *x115; /* { dg-error "" "_Bool long" } */
+_Bool float *x116; /* { dg-error "" "_Bool float" } */
+_Bool double *x117; /* { dg-error "" "_Bool double" } */
+_Bool signed *x118; /* { dg-error "" "_Bool signed" } */
+_Bool unsigned *x119; /* { dg-error "" "_Bool unsigned" } */
+_Bool _Bool *x120; /* { dg-error "" "_Bool _Bool" } */
+_Bool _Complex *x121; /* { dg-error "" "_Bool _Complex" } */
+_Complex void *x122; /* { dg-error "" "_Complex void" } */
+_Complex char *x123; /* { dg-error "" "_Complex char" } */
+_Complex short *x124; /* { dg-error "" "_Complex short" } */
+_Complex int *x125; /* { dg-error "" "_Complex int" } */
+_Complex long *x126; /* { dg-error "" "_Complex long" } */
+_Complex float *x127;
+_Complex double *x128;
+_Complex signed *x129; /* { dg-error "" "_Complex signed" } */
+_Complex unsigned *x130; /* { dg-error "" "_Complex unsigned" } */
+_Complex _Bool *x131; /* { dg-error "" "_Complex _Bool" } */
+_Complex _Complex *x132; /* { dg-error "" "_Complex _Complex" } */
+type void *x133; /* { dg-error "" "type void" } */
+type char *x134; /* { dg-error "" "type char" } */
+type short *x135; /* { dg-error "" "type short" } */
+type int *x136; /* { dg-error "" "type int" } */
+type long *x137; /* { dg-error "" "type long" } */
+type float *x138; /* { dg-error "" "type float" } */
+type double *x139; /* { dg-error "" "type double" } */
+type signed *x140; /* { dg-error "" "type signed" } */
+type unsigned *x141; /* { dg-error "" "type unsigned" } */
+type _Bool *x142; /* { dg-error "" "type _Bool" } */
+type _Complex *x143; /* { dg-error "" "type _Complex" } */
+char signed void *x144; /* { dg-error "" "char signed void" } */
+char signed char *x145; /* { dg-error "" "char signed char" } */
+char signed short *x146; /* { dg-error "" "char signed short" } */
+char signed int *x147; /* { dg-error "" "char signed int" } */
+char signed long *x148; /* { dg-error "" "char signed long" } */
+char signed float *x149; /* { dg-error "" "char signed float" } */
+char signed double *x150; /* { dg-error "" "char signed double" } */
+char signed signed *x151; /* { dg-error "" "char signed signed" } */
+char signed unsigned *x152; /* { dg-error "" "char signed unsigned" } */
+char signed _Bool *x153; /* { dg-error "" "char signed _Bool" } */
+char signed _Complex *x154; /* { dg-error "" "char signed _Complex" } */
+char unsigned void *x155; /* { dg-error "" "char unsigned void" } */
+char unsigned char *x156; /* { dg-error "" "char unsigned char" } */
+char unsigned short *x157; /* { dg-error "" "char unsigned short" } */
+char unsigned int *x158; /* { dg-error "" "char unsigned int" } */
+char unsigned long *x159; /* { dg-error "" "char unsigned long" } */
+char unsigned float *x160; /* { dg-error "" "char unsigned float" } */
+char unsigned double *x161; /* { dg-error "" "char unsigned double" } */
+char unsigned signed *x162; /* { dg-error "" "char unsigned signed" } */
+char unsigned unsigned *x163; /* { dg-error "" "char unsigned unsigned" } */
+char unsigned _Bool *x164; /* { dg-error "" "char unsigned _Bool" } */
+char unsigned _Complex *x165; /* { dg-error "" "char unsigned _Complex" } */
+short int void *x166; /* { dg-error "" "short int void" } */
+short int char *x167; /* { dg-error "" "short int char" } */
+short int short *x168; /* { dg-error "" "short int short" } */
+short int int *x169; /* { dg-error "" "short int int" } */
+short int long *x170; /* { dg-error "" "short int long" } */
+short int float *x171; /* { dg-error "" "short int float" } */
+short int double *x172; /* { dg-error "" "short int double" } */
+short int signed *x173;
+short int unsigned *x174;
+short int _Bool *x175; /* { dg-error "" "short int _Bool" } */
+short int _Complex *x176; /* { dg-error "" "short int _Complex" } */
+short signed void *x177; /* { dg-error "" "short signed void" } */
+short signed char *x178; /* { dg-error "" "short signed char" } */
+short signed short *x179; /* { dg-error "" "short signed short" } */
+short signed int *x180;
+short signed long *x181; /* { dg-error "" "short signed long" } */
+short signed float *x182; /* { dg-error "" "short signed float" } */
+short signed double *x183; /* { dg-error "" "short signed double" } */
+short signed signed *x184; /* { dg-error "" "short signed signed" } */
+short signed unsigned *x185; /* { dg-error "" "short signed unsigned" } */
+short signed _Bool *x186; /* { dg-error "" "short signed _Bool" } */
+short signed _Complex *x187; /* { dg-error "" "short signed _Complex" } */
+short unsigned void *x188; /* { dg-error "" "short unsigned void" } */
+short unsigned char *x189; /* { dg-error "" "short unsigned char" } */
+short unsigned short *x190; /* { dg-error "" "short unsigned short" } */
+short unsigned int *x191;
+short unsigned long *x192; /* { dg-error "" "short unsigned long" } */
+short unsigned float *x193; /* { dg-error "" "short unsigned float" } */
+short unsigned double *x194; /* { dg-error "" "short unsigned double" } */
+short unsigned signed *x195; /* { dg-error "" "short unsigned signed" } */
+short unsigned unsigned *x196; /* { dg-error "" "short unsigned unsigned" } */
+short unsigned _Bool *x197; /* { dg-error "" "short unsigned _Bool" } */
+short unsigned _Complex *x198; /* { dg-error "" "short unsigned _Complex" } */
+int short void *x199; /* { dg-error "" "int short void" } */
+int short char *x200; /* { dg-error "" "int short char" } */
+int short short *x201; /* { dg-error "" "int short short" } */
+int short int *x202; /* { dg-error "" "int short int" } */
+int short long *x203; /* { dg-error "" "int short long" } */
+int short float *x204; /* { dg-error "" "int short float" } */
+int short double *x205; /* { dg-error "" "int short double" } */
+int short signed *x206;
+int short unsigned *x207;
+int short _Bool *x208; /* { dg-error "" "int short _Bool" } */
+int short _Complex *x209; /* { dg-error "" "int short _Complex" } */
+int long void *x210; /* { dg-error "" "int long void" } */
+int long char *x211; /* { dg-error "" "int long char" } */
+int long short *x212; /* { dg-error "" "int long short" } */
+int long int *x213; /* { dg-error "" "int long int" } */
+int long long *x214;
+int long float *x215; /* { dg-error "" "int long float" } */
+int long double *x216; /* { dg-error "" "int long double" } */
+int long signed *x217;
+int long unsigned *x218;
+int long _Bool *x219; /* { dg-error "" "int long _Bool" } */
+int long _Complex *x220; /* { dg-error "" "int long _Complex" } */
+int signed void *x221; /* { dg-error "" "int signed void" } */
+int signed char *x222; /* { dg-error "" "int signed char" } */
+int signed short *x223;
+int signed int *x224; /* { dg-error "" "int signed int" } */
+int signed long *x225;
+int signed float *x226; /* { dg-error "" "int signed float" } */
+int signed double *x227; /* { dg-error "" "int signed double" } */
+int signed signed *x228; /* { dg-error "" "int signed signed" } */
+int signed unsigned *x229; /* { dg-error "" "int signed unsigned" } */
+int signed _Bool *x230; /* { dg-error "" "int signed _Bool" } */
+int signed _Complex *x231; /* { dg-error "" "int signed _Complex" } */
+int unsigned void *x232; /* { dg-error "" "int unsigned void" } */
+int unsigned char *x233; /* { dg-error "" "int unsigned char" } */
+int unsigned short *x234;
+int unsigned int *x235; /* { dg-error "" "int unsigned int" } */
+int unsigned long *x236;
+int unsigned float *x237; /* { dg-error "" "int unsigned float" } */
+int unsigned double *x238; /* { dg-error "" "int unsigned double" } */
+int unsigned signed *x239; /* { dg-error "" "int unsigned signed" } */
+int unsigned unsigned *x240; /* { dg-error "" "int unsigned unsigned" } */
+int unsigned _Bool *x241; /* { dg-error "" "int unsigned _Bool" } */
+int unsigned _Complex *x242; /* { dg-error "" "int unsigned _Complex" } */
+long int void *x243; /* { dg-error "" "long int void" } */
+long int char *x244; /* { dg-error "" "long int char" } */
+long int short *x245; /* { dg-error "" "long int short" } */
+long int int *x246; /* { dg-error "" "long int int" } */
+long int long *x247;
+long int float *x248; /* { dg-error "" "long int float" } */
+long int double *x249; /* { dg-error "" "long int double" } */
+long int signed *x250;
+long int unsigned *x251;
+long int _Bool *x252; /* { dg-error "" "long int _Bool" } */
+long int _Complex *x253; /* { dg-error "" "long int _Complex" } */
+long long void *x254; /* { dg-error "" "long long void" } */
+long long char *x255; /* { dg-error "" "long long char" } */
+long long short *x256; /* { dg-error "" "long long short" } */
+long long int *x257;
+long long long *x258; /* { dg-error "" "long long long" } */
+long long float *x259; /* { dg-error "" "long long float" } */
+long long double *x260; /* { dg-error "" "long long double" } */
+long long signed *x261;
+long long unsigned *x262;
+long long _Bool *x263; /* { dg-error "" "long long _Bool" } */
+long long _Complex *x264; /* { dg-error "" "long long _Complex" } */
+long double void *x265; /* { dg-error "" "long double void" } */
+long double char *x266; /* { dg-error "" "long double char" } */
+long double short *x267; /* { dg-error "" "long double short" } */
+long double int *x268; /* { dg-error "" "long double int" } */
+long double long *x269; /* { dg-error "" "long double long" } */
+long double float *x270; /* { dg-error "" "long double float" } */
+long double double *x271; /* { dg-error "" "long double double" } */
+long double signed *x272; /* { dg-error "" "long double signed" } */
+long double unsigned *x273; /* { dg-error "" "long double unsigned" } */
+long double _Bool *x274; /* { dg-error "" "long double _Bool" } */
+long double _Complex *x275;
+long signed void *x276; /* { dg-error "" "long signed void" } */
+long signed char *x277; /* { dg-error "" "long signed char" } */
+long signed short *x278; /* { dg-error "" "long signed short" } */
+long signed int *x279;
+long signed long *x280;
+long signed float *x281; /* { dg-error "" "long signed float" } */
+long signed double *x282; /* { dg-error "" "long signed double" } */
+long signed signed *x283; /* { dg-error "" "long signed signed" } */
+long signed unsigned *x284; /* { dg-error "" "long signed unsigned" } */
+long signed _Bool *x285; /* { dg-error "" "long signed _Bool" } */
+long signed _Complex *x286; /* { dg-error "" "long signed _Complex" } */
+long unsigned void *x287; /* { dg-error "" "long unsigned void" } */
+long unsigned char *x288; /* { dg-error "" "long unsigned char" } */
+long unsigned short *x289; /* { dg-error "" "long unsigned short" } */
+long unsigned int *x290;
+long unsigned long *x291;
+long unsigned float *x292; /* { dg-error "" "long unsigned float" } */
+long unsigned double *x293; /* { dg-error "" "long unsigned double" } */
+long unsigned signed *x294; /* { dg-error "" "long unsigned signed" } */
+long unsigned unsigned *x295; /* { dg-error "" "long unsigned unsigned" } */
+long unsigned _Bool *x296; /* { dg-error "" "long unsigned _Bool" } */
+long unsigned _Complex *x297; /* { dg-error "" "long unsigned _Complex" } */
+long _Complex void *x298; /* { dg-error "" "long _Complex void" } */
+long _Complex char *x299; /* { dg-error "" "long _Complex char" } */
+long _Complex short *x300; /* { dg-error "" "long _Complex short" } */
+long _Complex int *x301; /* { dg-error "" "long _Complex int" } */
+long _Complex long *x302; /* { dg-error "" "long _Complex long" } */
+long _Complex float *x303; /* { dg-error "" "long _Complex float" } */
+long _Complex double *x304;
+long _Complex signed *x305; /* { dg-error "" "long _Complex signed" } */
+long _Complex unsigned *x306; /* { dg-error "" "long _Complex unsigned" } */
+long _Complex _Bool *x307; /* { dg-error "" "long _Complex _Bool" } */
+long _Complex _Complex *x308; /* { dg-error "" "long _Complex _Complex" } */
+float _Complex void *x309; /* { dg-error "" "float _Complex void" } */
+float _Complex char *x310; /* { dg-error "" "float _Complex char" } */
+float _Complex short *x311; /* { dg-error "" "float _Complex short" } */
+float _Complex int *x312; /* { dg-error "" "float _Complex int" } */
+float _Complex long *x313; /* { dg-error "" "float _Complex long" } */
+float _Complex float *x314; /* { dg-error "" "float _Complex float" } */
+float _Complex double *x315; /* { dg-error "" "float _Complex double" } */
+float _Complex signed *x316; /* { dg-error "" "float _Complex signed" } */
+float _Complex unsigned *x317; /* { dg-error "" "float _Complex unsigned" } */
+float _Complex _Bool *x318; /* { dg-error "" "float _Complex _Bool" } */
+float _Complex _Complex *x319; /* { dg-error "" "float _Complex _Complex" } */
+double long void *x320; /* { dg-error "" "double long void" } */
+double long char *x321; /* { dg-error "" "double long char" } */
+double long short *x322; /* { dg-error "" "double long short" } */
+double long int *x323; /* { dg-error "" "double long int" } */
+double long long *x324; /* { dg-error "" "double long long" } */
+double long float *x325; /* { dg-error "" "double long float" } */
+double long double *x326; /* { dg-error "" "double long double" } */
+double long signed *x327; /* { dg-error "" "double long signed" } */
+double long unsigned *x328; /* { dg-error "" "double long unsigned" } */
+double long _Bool *x329; /* { dg-error "" "double long _Bool" } */
+double long _Complex *x330;
+double _Complex void *x331; /* { dg-error "" "double _Complex void" } */
+double _Complex char *x332; /* { dg-error "" "double _Complex char" } */
+double _Complex short *x333; /* { dg-error "" "double _Complex short" } */
+double _Complex int *x334; /* { dg-error "" "double _Complex int" } */
+double _Complex long *x335;
+double _Complex float *x336; /* { dg-error "" "double _Complex float" } */
+double _Complex double *x337; /* { dg-error "" "double _Complex double" } */
+double _Complex signed *x338; /* { dg-error "" "double _Complex signed" } */
+double _Complex unsigned *x339; /* { dg-error "" "double _Complex unsigned" } */
+double _Complex _Bool *x340; /* { dg-error "" "double _Complex _Bool" } */
+double _Complex _Complex *x341; /* { dg-error "" "double _Complex _Complex" } */
+signed char void *x342; /* { dg-error "" "signed char void" } */
+signed char char *x343; /* { dg-error "" "signed char char" } */
+signed char short *x344; /* { dg-error "" "signed char short" } */
+signed char int *x345; /* { dg-error "" "signed char int" } */
+signed char long *x346; /* { dg-error "" "signed char long" } */
+signed char float *x347; /* { dg-error "" "signed char float" } */
+signed char double *x348; /* { dg-error "" "signed char double" } */
+signed char signed *x349; /* { dg-error "" "signed char signed" } */
+signed char unsigned *x350; /* { dg-error "" "signed char unsigned" } */
+signed char _Bool *x351; /* { dg-error "" "signed char _Bool" } */
+signed char _Complex *x352; /* { dg-error "" "signed char _Complex" } */
+signed short void *x353; /* { dg-error "" "signed short void" } */
+signed short char *x354; /* { dg-error "" "signed short char" } */
+signed short short *x355; /* { dg-error "" "signed short short" } */
+signed short int *x356;
+signed short long *x357; /* { dg-error "" "signed short long" } */
+signed short float *x358; /* { dg-error "" "signed short float" } */
+signed short double *x359; /* { dg-error "" "signed short double" } */
+signed short signed *x360; /* { dg-error "" "signed short signed" } */
+signed short unsigned *x361; /* { dg-error "" "signed short unsigned" } */
+signed short _Bool *x362; /* { dg-error "" "signed short _Bool" } */
+signed short _Complex *x363; /* { dg-error "" "signed short _Complex" } */
+signed int void *x364; /* { dg-error "" "signed int void" } */
+signed int char *x365; /* { dg-error "" "signed int char" } */
+signed int short *x366;
+signed int int *x367; /* { dg-error "" "signed int int" } */
+signed int long *x368;
+signed int float *x369; /* { dg-error "" "signed int float" } */
+signed int double *x370; /* { dg-error "" "signed int double" } */
+signed int signed *x371; /* { dg-error "" "signed int signed" } */
+signed int unsigned *x372; /* { dg-error "" "signed int unsigned" } */
+signed int _Bool *x373; /* { dg-error "" "signed int _Bool" } */
+signed int _Complex *x374; /* { dg-error "" "signed int _Complex" } */
+signed long void *x375; /* { dg-error "" "signed long void" } */
+signed long char *x376; /* { dg-error "" "signed long char" } */
+signed long short *x377; /* { dg-error "" "signed long short" } */
+signed long int *x378;
+signed long long *x379;
+signed long float *x380; /* { dg-error "" "signed long float" } */
+signed long double *x381; /* { dg-error "" "signed long double" } */
+signed long signed *x382; /* { dg-error "" "signed long signed" } */
+signed long unsigned *x383; /* { dg-error "" "signed long unsigned" } */
+signed long _Bool *x384; /* { dg-error "" "signed long _Bool" } */
+signed long _Complex *x385; /* { dg-error "" "signed long _Complex" } */
+unsigned char void *x386; /* { dg-error "" "unsigned char void" } */
+unsigned char char *x387; /* { dg-error "" "unsigned char char" } */
+unsigned char short *x388; /* { dg-error "" "unsigned char short" } */
+unsigned char int *x389; /* { dg-error "" "unsigned char int" } */
+unsigned char long *x390; /* { dg-error "" "unsigned char long" } */
+unsigned char float *x391; /* { dg-error "" "unsigned char float" } */
+unsigned char double *x392; /* { dg-error "" "unsigned char double" } */
+unsigned char signed *x393; /* { dg-error "" "unsigned char signed" } */
+unsigned char unsigned *x394; /* { dg-error "" "unsigned char unsigned" } */
+unsigned char _Bool *x395; /* { dg-error "" "unsigned char _Bool" } */
+unsigned char _Complex *x396; /* { dg-error "" "unsigned char _Complex" } */
+unsigned short void *x397; /* { dg-error "" "unsigned short void" } */
+unsigned short char *x398; /* { dg-error "" "unsigned short char" } */
+unsigned short short *x399; /* { dg-error "" "unsigned short short" } */
+unsigned short int *x400;
+unsigned short long *x401; /* { dg-error "" "unsigned short long" } */
+unsigned short float *x402; /* { dg-error "" "unsigned short float" } */
+unsigned short double *x403; /* { dg-error "" "unsigned short double" } */
+unsigned short signed *x404; /* { dg-error "" "unsigned short signed" } */
+unsigned short unsigned *x405; /* { dg-error "" "unsigned short unsigned" } */
+unsigned short _Bool *x406; /* { dg-error "" "unsigned short _Bool" } */
+unsigned short _Complex *x407; /* { dg-error "" "unsigned short _Complex" } */
+unsigned int void *x408; /* { dg-error "" "unsigned int void" } */
+unsigned int char *x409; /* { dg-error "" "unsigned int char" } */
+unsigned int short *x410;
+unsigned int int *x411; /* { dg-error "" "unsigned int int" } */
+unsigned int long *x412;
+unsigned int float *x413; /* { dg-error "" "unsigned int float" } */
+unsigned int double *x414; /* { dg-error "" "unsigned int double" } */
+unsigned int signed *x415; /* { dg-error "" "unsigned int signed" } */
+unsigned int unsigned *x416; /* { dg-error "" "unsigned int unsigned" } */
+unsigned int _Bool *x417; /* { dg-error "" "unsigned int _Bool" } */
+unsigned int _Complex *x418; /* { dg-error "" "unsigned int _Complex" } */
+unsigned long void *x419; /* { dg-error "" "unsigned long void" } */
+unsigned long char *x420; /* { dg-error "" "unsigned long char" } */
+unsigned long short *x421; /* { dg-error "" "unsigned long short" } */
+unsigned long int *x422;
+unsigned long long *x423;
+unsigned long float *x424; /* { dg-error "" "unsigned long float" } */
+unsigned long double *x425; /* { dg-error "" "unsigned long double" } */
+unsigned long signed *x426; /* { dg-error "" "unsigned long signed" } */
+unsigned long unsigned *x427; /* { dg-error "" "unsigned long unsigned" } */
+unsigned long _Bool *x428; /* { dg-error "" "unsigned long _Bool" } */
+unsigned long _Complex *x429; /* { dg-error "" "unsigned long _Complex" } */
+_Complex long void *x430; /* { dg-error "" "_Complex long void" } */
+_Complex long char *x431; /* { dg-error "" "_Complex long char" } */
+_Complex long short *x432; /* { dg-error "" "_Complex long short" } */
+_Complex long int *x433; /* { dg-error "" "_Complex long int" } */
+_Complex long long *x434; /* { dg-error "" "_Complex long long" } */
+_Complex long float *x435; /* { dg-error "" "_Complex long float" } */
+_Complex long double *x436;
+_Complex long signed *x437; /* { dg-error "" "_Complex long signed" } */
+_Complex long unsigned *x438; /* { dg-error "" "_Complex long unsigned" } */
+_Complex long _Bool *x439; /* { dg-error "" "_Complex long _Bool" } */
+_Complex long _Complex *x440; /* { dg-error "" "_Complex long _Complex" } */
+_Complex float void *x441; /* { dg-error "" "_Complex float void" } */
+_Complex float char *x442; /* { dg-error "" "_Complex float char" } */
+_Complex float short *x443; /* { dg-error "" "_Complex float short" } */
+_Complex float int *x444; /* { dg-error "" "_Complex float int" } */
+_Complex float long *x445; /* { dg-error "" "_Complex float long" } */
+_Complex float float *x446; /* { dg-error "" "_Complex float float" } */
+_Complex float double *x447; /* { dg-error "" "_Complex float double" } */
+_Complex float signed *x448; /* { dg-error "" "_Complex float signed" } */
+_Complex float unsigned *x449; /* { dg-error "" "_Complex float unsigned" } */
+_Complex float _Bool *x450; /* { dg-error "" "_Complex float _Bool" } */
+_Complex float _Complex *x451; /* { dg-error "" "_Complex float _Complex" } */
+_Complex double void *x452; /* { dg-error "" "_Complex double void" } */
+_Complex double char *x453; /* { dg-error "" "_Complex double char" } */
+_Complex double short *x454; /* { dg-error "" "_Complex double short" } */
+_Complex double int *x455; /* { dg-error "" "_Complex double int" } */
+_Complex double long *x456;
+_Complex double float *x457; /* { dg-error "" "_Complex double float" } */
+_Complex double double *x458; /* { dg-error "" "_Complex double double" } */
+_Complex double signed *x459; /* { dg-error "" "_Complex double signed" } */
+_Complex double unsigned *x460; /* { dg-error "" "_Complex double unsigned" } */
+_Complex double _Bool *x461; /* { dg-error "" "_Complex double _Bool" } */
+_Complex double _Complex *x462; /* { dg-error "" "_Complex double _Complex" } */
+short int signed void *x463; /* { dg-error "" "short int signed void" } */
+short int signed char *x464; /* { dg-error "" "short int signed char" } */
+short int signed short *x465; /* { dg-error "" "short int signed short" } */
+short int signed int *x466; /* { dg-error "" "short int signed int" } */
+short int signed long *x467; /* { dg-error "" "short int signed long" } */
+short int signed float *x468; /* { dg-error "" "short int signed float" } */
+short int signed double *x469; /* { dg-error "" "short int signed double" } */
+short int signed signed *x470; /* { dg-error "" "short int signed signed" } */
+short int signed unsigned *x471; /* { dg-error "" "short int signed unsigned" } */
+short int signed _Bool *x472; /* { dg-error "" "short int signed _Bool" } */
+short int signed _Complex *x473; /* { dg-error "" "short int signed _Complex" } */
+short int unsigned void *x474; /* { dg-error "" "short int unsigned void" } */
+short int unsigned char *x475; /* { dg-error "" "short int unsigned char" } */
+short int unsigned short *x476; /* { dg-error "" "short int unsigned short" } */
+short int unsigned int *x477; /* { dg-error "" "short int unsigned int" } */
+short int unsigned long *x478; /* { dg-error "" "short int unsigned long" } */
+short int unsigned float *x479; /* { dg-error "" "short int unsigned float" } */
+short int unsigned double *x480; /* { dg-error "" "short int unsigned double" } */
+short int unsigned signed *x481; /* { dg-error "" "short int unsigned signed" } */
+short int unsigned unsigned *x482; /* { dg-error "" "short int unsigned unsigned" } */
+short int unsigned _Bool *x483; /* { dg-error "" "short int unsigned _Bool" } */
+short int unsigned _Complex *x484; /* { dg-error "" "short int unsigned _Complex" } */
+short signed int void *x485; /* { dg-error "" "short signed int void" } */
+short signed int char *x486; /* { dg-error "" "short signed int char" } */
+short signed int short *x487; /* { dg-error "" "short signed int short" } */
+short signed int int *x488; /* { dg-error "" "short signed int int" } */
+short signed int long *x489; /* { dg-error "" "short signed int long" } */
+short signed int float *x490; /* { dg-error "" "short signed int float" } */
+short signed int double *x491; /* { dg-error "" "short signed int double" } */
+short signed int signed *x492; /* { dg-error "" "short signed int signed" } */
+short signed int unsigned *x493; /* { dg-error "" "short signed int unsigned" } */
+short signed int _Bool *x494; /* { dg-error "" "short signed int _Bool" } */
+short signed int _Complex *x495; /* { dg-error "" "short signed int _Complex" } */
+short unsigned int void *x496; /* { dg-error "" "short unsigned int void" } */
+short unsigned int char *x497; /* { dg-error "" "short unsigned int char" } */
+short unsigned int short *x498; /* { dg-error "" "short unsigned int short" } */
+short unsigned int int *x499; /* { dg-error "" "short unsigned int int" } */
+short unsigned int long *x500; /* { dg-error "" "short unsigned int long" } */
+short unsigned int float *x501; /* { dg-error "" "short unsigned int float" } */
+short unsigned int double *x502; /* { dg-error "" "short unsigned int double" } */
+short unsigned int signed *x503; /* { dg-error "" "short unsigned int signed" } */
+short unsigned int unsigned *x504; /* { dg-error "" "short unsigned int unsigned" } */
+short unsigned int _Bool *x505; /* { dg-error "" "short unsigned int _Bool" } */
+short unsigned int _Complex *x506; /* { dg-error "" "short unsigned int _Complex" } */
+int short signed void *x507; /* { dg-error "" "int short signed void" } */
+int short signed char *x508; /* { dg-error "" "int short signed char" } */
+int short signed short *x509; /* { dg-error "" "int short signed short" } */
+int short signed int *x510; /* { dg-error "" "int short signed int" } */
+int short signed long *x511; /* { dg-error "" "int short signed long" } */
+int short signed float *x512; /* { dg-error "" "int short signed float" } */
+int short signed double *x513; /* { dg-error "" "int short signed double" } */
+int short signed signed *x514; /* { dg-error "" "int short signed signed" } */
+int short signed unsigned *x515; /* { dg-error "" "int short signed unsigned" } */
+int short signed _Bool *x516; /* { dg-error "" "int short signed _Bool" } */
+int short signed _Complex *x517; /* { dg-error "" "int short signed _Complex" } */
+int short unsigned void *x518; /* { dg-error "" "int short unsigned void" } */
+int short unsigned char *x519; /* { dg-error "" "int short unsigned char" } */
+int short unsigned short *x520; /* { dg-error "" "int short unsigned short" } */
+int short unsigned int *x521; /* { dg-error "" "int short unsigned int" } */
+int short unsigned long *x522; /* { dg-error "" "int short unsigned long" } */
+int short unsigned float *x523; /* { dg-error "" "int short unsigned float" } */
+int short unsigned double *x524; /* { dg-error "" "int short unsigned double" } */
+int short unsigned signed *x525; /* { dg-error "" "int short unsigned signed" } */
+int short unsigned unsigned *x526; /* { dg-error "" "int short unsigned unsigned" } */
+int short unsigned _Bool *x527; /* { dg-error "" "int short unsigned _Bool" } */
+int short unsigned _Complex *x528; /* { dg-error "" "int short unsigned _Complex" } */
+int long long void *x529; /* { dg-error "" "int long long void" } */
+int long long char *x530; /* { dg-error "" "int long long char" } */
+int long long short *x531; /* { dg-error "" "int long long short" } */
+int long long int *x532; /* { dg-error "" "int long long int" } */
+int long long long *x533; /* { dg-error "" "int long long long" } */
+int long long float *x534; /* { dg-error "" "int long long float" } */
+int long long double *x535; /* { dg-error "" "int long long double" } */
+int long long signed *x536;
+int long long unsigned *x537;
+int long long _Bool *x538; /* { dg-error "" "int long long _Bool" } */
+int long long _Complex *x539; /* { dg-error "" "int long long _Complex" } */
+int long signed void *x540; /* { dg-error "" "int long signed void" } */
+int long signed char *x541; /* { dg-error "" "int long signed char" } */
+int long signed short *x542; /* { dg-error "" "int long signed short" } */
+int long signed int *x543; /* { dg-error "" "int long signed int" } */
+int long signed long *x544;
+int long signed float *x545; /* { dg-error "" "int long signed float" } */
+int long signed double *x546; /* { dg-error "" "int long signed double" } */
+int long signed signed *x547; /* { dg-error "" "int long signed signed" } */
+int long signed unsigned *x548; /* { dg-error "" "int long signed unsigned" } */
+int long signed _Bool *x549; /* { dg-error "" "int long signed _Bool" } */
+int long signed _Complex *x550; /* { dg-error "" "int long signed _Complex" } */
+int long unsigned void *x551; /* { dg-error "" "int long unsigned void" } */
+int long unsigned char *x552; /* { dg-error "" "int long unsigned char" } */
+int long unsigned short *x553; /* { dg-error "" "int long unsigned short" } */
+int long unsigned int *x554; /* { dg-error "" "int long unsigned int" } */
+int long unsigned long *x555;
+int long unsigned float *x556; /* { dg-error "" "int long unsigned float" } */
+int long unsigned double *x557; /* { dg-error "" "int long unsigned double" } */
+int long unsigned signed *x558; /* { dg-error "" "int long unsigned signed" } */
+int long unsigned unsigned *x559; /* { dg-error "" "int long unsigned unsigned" } */
+int long unsigned _Bool *x560; /* { dg-error "" "int long unsigned _Bool" } */
+int long unsigned _Complex *x561; /* { dg-error "" "int long unsigned _Complex" } */
+int signed short void *x562; /* { dg-error "" "int signed short void" } */
+int signed short char *x563; /* { dg-error "" "int signed short char" } */
+int signed short short *x564; /* { dg-error "" "int signed short short" } */
+int signed short int *x565; /* { dg-error "" "int signed short int" } */
+int signed short long *x566; /* { dg-error "" "int signed short long" } */
+int signed short float *x567; /* { dg-error "" "int signed short float" } */
+int signed short double *x568; /* { dg-error "" "int signed short double" } */
+int signed short signed *x569; /* { dg-error "" "int signed short signed" } */
+int signed short unsigned *x570; /* { dg-error "" "int signed short unsigned" } */
+int signed short _Bool *x571; /* { dg-error "" "int signed short _Bool" } */
+int signed short _Complex *x572; /* { dg-error "" "int signed short _Complex" } */
+int signed long void *x573; /* { dg-error "" "int signed long void" } */
+int signed long char *x574; /* { dg-error "" "int signed long char" } */
+int signed long short *x575; /* { dg-error "" "int signed long short" } */
+int signed long int *x576; /* { dg-error "" "int signed long int" } */
+int signed long long *x577;
+int signed long float *x578; /* { dg-error "" "int signed long float" } */
+int signed long double *x579; /* { dg-error "" "int signed long double" } */
+int signed long signed *x580; /* { dg-error "" "int signed long signed" } */
+int signed long unsigned *x581; /* { dg-error "" "int signed long unsigned" } */
+int signed long _Bool *x582; /* { dg-error "" "int signed long _Bool" } */
+int signed long _Complex *x583; /* { dg-error "" "int signed long _Complex" } */
+int unsigned short void *x584; /* { dg-error "" "int unsigned short void" } */
+int unsigned short char *x585; /* { dg-error "" "int unsigned short char" } */
+int unsigned short short *x586; /* { dg-error "" "int unsigned short short" } */
+int unsigned short int *x587; /* { dg-error "" "int unsigned short int" } */
+int unsigned short long *x588; /* { dg-error "" "int unsigned short long" } */
+int unsigned short float *x589; /* { dg-error "" "int unsigned short float" } */
+int unsigned short double *x590; /* { dg-error "" "int unsigned short double" } */
+int unsigned short signed *x591; /* { dg-error "" "int unsigned short signed" } */
+int unsigned short unsigned *x592; /* { dg-error "" "int unsigned short unsigned" } */
+int unsigned short _Bool *x593; /* { dg-error "" "int unsigned short _Bool" } */
+int unsigned short _Complex *x594; /* { dg-error "" "int unsigned short _Complex" } */
+int unsigned long void *x595; /* { dg-error "" "int unsigned long void" } */
+int unsigned long char *x596; /* { dg-error "" "int unsigned long char" } */
+int unsigned long short *x597; /* { dg-error "" "int unsigned long short" } */
+int unsigned long int *x598; /* { dg-error "" "int unsigned long int" } */
+int unsigned long long *x599;
+int unsigned long float *x600; /* { dg-error "" "int unsigned long float" } */
+int unsigned long double *x601; /* { dg-error "" "int unsigned long double" } */
+int unsigned long signed *x602; /* { dg-error "" "int unsigned long signed" } */
+int unsigned long unsigned *x603; /* { dg-error "" "int unsigned long unsigned" } */
+int unsigned long _Bool *x604; /* { dg-error "" "int unsigned long _Bool" } */
+int unsigned long _Complex *x605; /* { dg-error "" "int unsigned long _Complex" } */
+long int long void *x606; /* { dg-error "" "long int long void" } */
+long int long char *x607; /* { dg-error "" "long int long char" } */
+long int long short *x608; /* { dg-error "" "long int long short" } */
+long int long int *x609; /* { dg-error "" "long int long int" } */
+long int long long *x610; /* { dg-error "" "long int long long" } */
+long int long float *x611; /* { dg-error "" "long int long float" } */
+long int long double *x612; /* { dg-error "" "long int long double" } */
+long int long signed *x613;
+long int long unsigned *x614;
+long int long _Bool *x615; /* { dg-error "" "long int long _Bool" } */
+long int long _Complex *x616; /* { dg-error "" "long int long _Complex" } */
+long int signed void *x617; /* { dg-error "" "long int signed void" } */
+long int signed char *x618; /* { dg-error "" "long int signed char" } */
+long int signed short *x619; /* { dg-error "" "long int signed short" } */
+long int signed int *x620; /* { dg-error "" "long int signed int" } */
+long int signed long *x621;
+long int signed float *x622; /* { dg-error "" "long int signed float" } */
+long int signed double *x623; /* { dg-error "" "long int signed double" } */
+long int signed signed *x624; /* { dg-error "" "long int signed signed" } */
+long int signed unsigned *x625; /* { dg-error "" "long int signed unsigned" } */
+long int signed _Bool *x626; /* { dg-error "" "long int signed _Bool" } */
+long int signed _Complex *x627; /* { dg-error "" "long int signed _Complex" } */
+long int unsigned void *x628; /* { dg-error "" "long int unsigned void" } */
+long int unsigned char *x629; /* { dg-error "" "long int unsigned char" } */
+long int unsigned short *x630; /* { dg-error "" "long int unsigned short" } */
+long int unsigned int *x631; /* { dg-error "" "long int unsigned int" } */
+long int unsigned long *x632;
+long int unsigned float *x633; /* { dg-error "" "long int unsigned float" } */
+long int unsigned double *x634; /* { dg-error "" "long int unsigned double" } */
+long int unsigned signed *x635; /* { dg-error "" "long int unsigned signed" } */
+long int unsigned unsigned *x636; /* { dg-error "" "long int unsigned unsigned" } */
+long int unsigned _Bool *x637; /* { dg-error "" "long int unsigned _Bool" } */
+long int unsigned _Complex *x638; /* { dg-error "" "long int unsigned _Complex" } */
+long long int void *x639; /* { dg-error "" "long long int void" } */
+long long int char *x640; /* { dg-error "" "long long int char" } */
+long long int short *x641; /* { dg-error "" "long long int short" } */
+long long int int *x642; /* { dg-error "" "long long int int" } */
+long long int long *x643; /* { dg-error "" "long long int long" } */
+long long int float *x644; /* { dg-error "" "long long int float" } */
+long long int double *x645; /* { dg-error "" "long long int double" } */
+long long int signed *x646;
+long long int unsigned *x647;
+long long int _Bool *x648; /* { dg-error "" "long long int _Bool" } */
+long long int _Complex *x649; /* { dg-error "" "long long int _Complex" } */
+long long signed void *x650; /* { dg-error "" "long long signed void" } */
+long long signed char *x651; /* { dg-error "" "long long signed char" } */
+long long signed short *x652; /* { dg-error "" "long long signed short" } */
+long long signed int *x653;
+long long signed long *x654; /* { dg-error "" "long long signed long" } */
+long long signed float *x655; /* { dg-error "" "long long signed float" } */
+long long signed double *x656; /* { dg-error "" "long long signed double" } */
+long long signed signed *x657; /* { dg-error "" "long long signed signed" } */
+long long signed unsigned *x658; /* { dg-error "" "long long signed unsigned" } */
+long long signed _Bool *x659; /* { dg-error "" "long long signed _Bool" } */
+long long signed _Complex *x660; /* { dg-error "" "long long signed _Complex" } */
+long long unsigned void *x661; /* { dg-error "" "long long unsigned void" } */
+long long unsigned char *x662; /* { dg-error "" "long long unsigned char" } */
+long long unsigned short *x663; /* { dg-error "" "long long unsigned short" } */
+long long unsigned int *x664;
+long long unsigned long *x665; /* { dg-error "" "long long unsigned long" } */
+long long unsigned float *x666; /* { dg-error "" "long long unsigned float" } */
+long long unsigned double *x667; /* { dg-error "" "long long unsigned double" } */
+long long unsigned signed *x668; /* { dg-error "" "long long unsigned signed" } */
+long long unsigned unsigned *x669; /* { dg-error "" "long long unsigned unsigned" } */
+long long unsigned _Bool *x670; /* { dg-error "" "long long unsigned _Bool" } */
+long long unsigned _Complex *x671; /* { dg-error "" "long long unsigned _Complex" } */
+long double _Complex void *x672; /* { dg-error "" "long double _Complex void" } */
+long double _Complex char *x673; /* { dg-error "" "long double _Complex char" } */
+long double _Complex short *x674; /* { dg-error "" "long double _Complex short" } */
+long double _Complex int *x675; /* { dg-error "" "long double _Complex int" } */
+long double _Complex long *x676; /* { dg-error "" "long double _Complex long" } */
+long double _Complex float *x677; /* { dg-error "" "long double _Complex float" } */
+long double _Complex double *x678; /* { dg-error "" "long double _Complex double" } */
+long double _Complex signed *x679; /* { dg-error "" "long double _Complex signed" } */
+long double _Complex unsigned *x680; /* { dg-error "" "long double _Complex unsigned" } */
+long double _Complex _Bool *x681; /* { dg-error "" "long double _Complex _Bool" } */
+long double _Complex _Complex *x682; /* { dg-error "" "long double _Complex _Complex" } */
+long signed int void *x683; /* { dg-error "" "long signed int void" } */
+long signed int char *x684; /* { dg-error "" "long signed int char" } */
+long signed int short *x685; /* { dg-error "" "long signed int short" } */
+long signed int int *x686; /* { dg-error "" "long signed int int" } */
+long signed int long *x687;
+long signed int float *x688; /* { dg-error "" "long signed int float" } */
+long signed int double *x689; /* { dg-error "" "long signed int double" } */
+long signed int signed *x690; /* { dg-error "" "long signed int signed" } */
+long signed int unsigned *x691; /* { dg-error "" "long signed int unsigned" } */
+long signed int _Bool *x692; /* { dg-error "" "long signed int _Bool" } */
+long signed int _Complex *x693; /* { dg-error "" "long signed int _Complex" } */
+long signed long void *x694; /* { dg-error "" "long signed long void" } */
+long signed long char *x695; /* { dg-error "" "long signed long char" } */
+long signed long short *x696; /* { dg-error "" "long signed long short" } */
+long signed long int *x697;
+long signed long long *x698; /* { dg-error "" "long signed long long" } */
+long signed long float *x699; /* { dg-error "" "long signed long float" } */
+long signed long double *x700; /* { dg-error "" "long signed long double" } */
+long signed long signed *x701; /* { dg-error "" "long signed long signed" } */
+long signed long unsigned *x702; /* { dg-error "" "long signed long unsigned" } */
+long signed long _Bool *x703; /* { dg-error "" "long signed long _Bool" } */
+long signed long _Complex *x704; /* { dg-error "" "long signed long _Complex" } */
+long unsigned int void *x705; /* { dg-error "" "long unsigned int void" } */
+long unsigned int char *x706; /* { dg-error "" "long unsigned int char" } */
+long unsigned int short *x707; /* { dg-error "" "long unsigned int short" } */
+long unsigned int int *x708; /* { dg-error "" "long unsigned int int" } */
+long unsigned int long *x709;
+long unsigned int float *x710; /* { dg-error "" "long unsigned int float" } */
+long unsigned int double *x711; /* { dg-error "" "long unsigned int double" } */
+long unsigned int signed *x712; /* { dg-error "" "long unsigned int signed" } */
+long unsigned int unsigned *x713; /* { dg-error "" "long unsigned int unsigned" } */
+long unsigned int _Bool *x714; /* { dg-error "" "long unsigned int _Bool" } */
+long unsigned int _Complex *x715; /* { dg-error "" "long unsigned int _Complex" } */
+long unsigned long void *x716; /* { dg-error "" "long unsigned long void" } */
+long unsigned long char *x717; /* { dg-error "" "long unsigned long char" } */
+long unsigned long short *x718; /* { dg-error "" "long unsigned long short" } */
+long unsigned long int *x719;
+long unsigned long long *x720; /* { dg-error "" "long unsigned long long" } */
+long unsigned long float *x721; /* { dg-error "" "long unsigned long float" } */
+long unsigned long double *x722; /* { dg-error "" "long unsigned long double" } */
+long unsigned long signed *x723; /* { dg-error "" "long unsigned long signed" } */
+long unsigned long unsigned *x724; /* { dg-error "" "long unsigned long unsigned" } */
+long unsigned long _Bool *x725; /* { dg-error "" "long unsigned long _Bool" } */
+long unsigned long _Complex *x726; /* { dg-error "" "long unsigned long _Complex" } */
+long _Complex double void *x727; /* { dg-error "" "long _Complex double void" } */
+long _Complex double char *x728; /* { dg-error "" "long _Complex double char" } */
+long _Complex double short *x729; /* { dg-error "" "long _Complex double short" } */
+long _Complex double int *x730; /* { dg-error "" "long _Complex double int" } */
+long _Complex double long *x731; /* { dg-error "" "long _Complex double long" } */
+long _Complex double float *x732; /* { dg-error "" "long _Complex double float" } */
+long _Complex double double *x733; /* { dg-error "" "long _Complex double double" } */
+long _Complex double signed *x734; /* { dg-error "" "long _Complex double signed" } */
+long _Complex double unsigned *x735; /* { dg-error "" "long _Complex double unsigned" } */
+long _Complex double _Bool *x736; /* { dg-error "" "long _Complex double _Bool" } */
+long _Complex double _Complex *x737; /* { dg-error "" "long _Complex double _Complex" } */
+double long _Complex void *x738; /* { dg-error "" "double long _Complex void" } */
+double long _Complex char *x739; /* { dg-error "" "double long _Complex char" } */
+double long _Complex short *x740; /* { dg-error "" "double long _Complex short" } */
+double long _Complex int *x741; /* { dg-error "" "double long _Complex int" } */
+double long _Complex long *x742; /* { dg-error "" "double long _Complex long" } */
+double long _Complex float *x743; /* { dg-error "" "double long _Complex float" } */
+double long _Complex double *x744; /* { dg-error "" "double long _Complex double" } */
+double long _Complex signed *x745; /* { dg-error "" "double long _Complex signed" } */
+double long _Complex unsigned *x746; /* { dg-error "" "double long _Complex unsigned" } */
+double long _Complex _Bool *x747; /* { dg-error "" "double long _Complex _Bool" } */
+double long _Complex _Complex *x748; /* { dg-error "" "double long _Complex _Complex" } */
+double _Complex long void *x749; /* { dg-error "" "double _Complex long void" } */
+double _Complex long char *x750; /* { dg-error "" "double _Complex long char" } */
+double _Complex long short *x751; /* { dg-error "" "double _Complex long short" } */
+double _Complex long int *x752; /* { dg-error "" "double _Complex long int" } */
+double _Complex long long *x753; /* { dg-error "" "double _Complex long long" } */
+double _Complex long float *x754; /* { dg-error "" "double _Complex long float" } */
+double _Complex long double *x755; /* { dg-error "" "double _Complex long double" } */
+double _Complex long signed *x756; /* { dg-error "" "double _Complex long signed" } */
+double _Complex long unsigned *x757; /* { dg-error "" "double _Complex long unsigned" } */
+double _Complex long _Bool *x758; /* { dg-error "" "double _Complex long _Bool" } */
+double _Complex long _Complex *x759; /* { dg-error "" "double _Complex long _Complex" } */
+signed short int void *x760; /* { dg-error "" "signed short int void" } */
+signed short int char *x761; /* { dg-error "" "signed short int char" } */
+signed short int short *x762; /* { dg-error "" "signed short int short" } */
+signed short int int *x763; /* { dg-error "" "signed short int int" } */
+signed short int long *x764; /* { dg-error "" "signed short int long" } */
+signed short int float *x765; /* { dg-error "" "signed short int float" } */
+signed short int double *x766; /* { dg-error "" "signed short int double" } */
+signed short int signed *x767; /* { dg-error "" "signed short int signed" } */
+signed short int unsigned *x768; /* { dg-error "" "signed short int unsigned" } */
+signed short int _Bool *x769; /* { dg-error "" "signed short int _Bool" } */
+signed short int _Complex *x770; /* { dg-error "" "signed short int _Complex" } */
+signed int short void *x771; /* { dg-error "" "signed int short void" } */
+signed int short char *x772; /* { dg-error "" "signed int short char" } */
+signed int short short *x773; /* { dg-error "" "signed int short short" } */
+signed int short int *x774; /* { dg-error "" "signed int short int" } */
+signed int short long *x775; /* { dg-error "" "signed int short long" } */
+signed int short float *x776; /* { dg-error "" "signed int short float" } */
+signed int short double *x777; /* { dg-error "" "signed int short double" } */
+signed int short signed *x778; /* { dg-error "" "signed int short signed" } */
+signed int short unsigned *x779; /* { dg-error "" "signed int short unsigned" } */
+signed int short _Bool *x780; /* { dg-error "" "signed int short _Bool" } */
+signed int short _Complex *x781; /* { dg-error "" "signed int short _Complex" } */
+signed int long void *x782; /* { dg-error "" "signed int long void" } */
+signed int long char *x783; /* { dg-error "" "signed int long char" } */
+signed int long short *x784; /* { dg-error "" "signed int long short" } */
+signed int long int *x785; /* { dg-error "" "signed int long int" } */
+signed int long long *x786;
+signed int long float *x787; /* { dg-error "" "signed int long float" } */
+signed int long double *x788; /* { dg-error "" "signed int long double" } */
+signed int long signed *x789; /* { dg-error "" "signed int long signed" } */
+signed int long unsigned *x790; /* { dg-error "" "signed int long unsigned" } */
+signed int long _Bool *x791; /* { dg-error "" "signed int long _Bool" } */
+signed int long _Complex *x792; /* { dg-error "" "signed int long _Complex" } */
+signed long int void *x793; /* { dg-error "" "signed long int void" } */
+signed long int char *x794; /* { dg-error "" "signed long int char" } */
+signed long int short *x795; /* { dg-error "" "signed long int short" } */
+signed long int int *x796; /* { dg-error "" "signed long int int" } */
+signed long int long *x797;
+signed long int float *x798; /* { dg-error "" "signed long int float" } */
+signed long int double *x799; /* { dg-error "" "signed long int double" } */
+signed long int signed *x800; /* { dg-error "" "signed long int signed" } */
+signed long int unsigned *x801; /* { dg-error "" "signed long int unsigned" } */
+signed long int _Bool *x802; /* { dg-error "" "signed long int _Bool" } */
+signed long int _Complex *x803; /* { dg-error "" "signed long int _Complex" } */
+signed long long void *x804; /* { dg-error "" "signed long long void" } */
+signed long long char *x805; /* { dg-error "" "signed long long char" } */
+signed long long short *x806; /* { dg-error "" "signed long long short" } */
+signed long long int *x807;
+signed long long long *x808; /* { dg-error "" "signed long long long" } */
+signed long long float *x809; /* { dg-error "" "signed long long float" } */
+signed long long double *x810; /* { dg-error "" "signed long long double" } */
+signed long long signed *x811; /* { dg-error "" "signed long long signed" } */
+signed long long unsigned *x812; /* { dg-error "" "signed long long unsigned" } */
+signed long long _Bool *x813; /* { dg-error "" "signed long long _Bool" } */
+signed long long _Complex *x814; /* { dg-error "" "signed long long _Complex" } */
+unsigned short int void *x815; /* { dg-error "" "unsigned short int void" } */
+unsigned short int char *x816; /* { dg-error "" "unsigned short int char" } */
+unsigned short int short *x817; /* { dg-error "" "unsigned short int short" } */
+unsigned short int int *x818; /* { dg-error "" "unsigned short int int" } */
+unsigned short int long *x819; /* { dg-error "" "unsigned short int long" } */
+unsigned short int float *x820; /* { dg-error "" "unsigned short int float" } */
+unsigned short int double *x821; /* { dg-error "" "unsigned short int double" } */
+unsigned short int signed *x822; /* { dg-error "" "unsigned short int signed" } */
+unsigned short int unsigned *x823; /* { dg-error "" "unsigned short int unsigned" } */
+unsigned short int _Bool *x824; /* { dg-error "" "unsigned short int _Bool" } */
+unsigned short int _Complex *x825; /* { dg-error "" "unsigned short int _Complex" } */
+unsigned int short void *x826; /* { dg-error "" "unsigned int short void" } */
+unsigned int short char *x827; /* { dg-error "" "unsigned int short char" } */
+unsigned int short short *x828; /* { dg-error "" "unsigned int short short" } */
+unsigned int short int *x829; /* { dg-error "" "unsigned int short int" } */
+unsigned int short long *x830; /* { dg-error "" "unsigned int short long" } */
+unsigned int short float *x831; /* { dg-error "" "unsigned int short float" } */
+unsigned int short double *x832; /* { dg-error "" "unsigned int short double" } */
+unsigned int short signed *x833; /* { dg-error "" "unsigned int short signed" } */
+unsigned int short unsigned *x834; /* { dg-error "" "unsigned int short unsigned" } */
+unsigned int short _Bool *x835; /* { dg-error "" "unsigned int short _Bool" } */
+unsigned int short _Complex *x836; /* { dg-error "" "unsigned int short _Complex" } */
+unsigned int long void *x837; /* { dg-error "" "unsigned int long void" } */
+unsigned int long char *x838; /* { dg-error "" "unsigned int long char" } */
+unsigned int long short *x839; /* { dg-error "" "unsigned int long short" } */
+unsigned int long int *x840; /* { dg-error "" "unsigned int long int" } */
+unsigned int long long *x841;
+unsigned int long float *x842; /* { dg-error "" "unsigned int long float" } */
+unsigned int long double *x843; /* { dg-error "" "unsigned int long double" } */
+unsigned int long signed *x844; /* { dg-error "" "unsigned int long signed" } */
+unsigned int long unsigned *x845; /* { dg-error "" "unsigned int long unsigned" } */
+unsigned int long _Bool *x846; /* { dg-error "" "unsigned int long _Bool" } */
+unsigned int long _Complex *x847; /* { dg-error "" "unsigned int long _Complex" } */
+unsigned long int void *x848; /* { dg-error "" "unsigned long int void" } */
+unsigned long int char *x849; /* { dg-error "" "unsigned long int char" } */
+unsigned long int short *x850; /* { dg-error "" "unsigned long int short" } */
+unsigned long int int *x851; /* { dg-error "" "unsigned long int int" } */
+unsigned long int long *x852;
+unsigned long int float *x853; /* { dg-error "" "unsigned long int float" } */
+unsigned long int double *x854; /* { dg-error "" "unsigned long int double" } */
+unsigned long int signed *x855; /* { dg-error "" "unsigned long int signed" } */
+unsigned long int unsigned *x856; /* { dg-error "" "unsigned long int unsigned" } */
+unsigned long int _Bool *x857; /* { dg-error "" "unsigned long int _Bool" } */
+unsigned long int _Complex *x858; /* { dg-error "" "unsigned long int _Complex" } */
+unsigned long long void *x859; /* { dg-error "" "unsigned long long void" } */
+unsigned long long char *x860; /* { dg-error "" "unsigned long long char" } */
+unsigned long long short *x861; /* { dg-error "" "unsigned long long short" } */
+unsigned long long int *x862;
+unsigned long long long *x863; /* { dg-error "" "unsigned long long long" } */
+unsigned long long float *x864; /* { dg-error "" "unsigned long long float" } */
+unsigned long long double *x865; /* { dg-error "" "unsigned long long double" } */
+unsigned long long signed *x866; /* { dg-error "" "unsigned long long signed" } */
+unsigned long long unsigned *x867; /* { dg-error "" "unsigned long long unsigned" } */
+unsigned long long _Bool *x868; /* { dg-error "" "unsigned long long _Bool" } */
+unsigned long long _Complex *x869; /* { dg-error "" "unsigned long long _Complex" } */
+_Complex long double void *x870; /* { dg-error "" "_Complex long double void" } */
+_Complex long double char *x871; /* { dg-error "" "_Complex long double char" } */
+_Complex long double short *x872; /* { dg-error "" "_Complex long double short" } */
+_Complex long double int *x873; /* { dg-error "" "_Complex long double int" } */
+_Complex long double long *x874; /* { dg-error "" "_Complex long double long" } */
+_Complex long double float *x875; /* { dg-error "" "_Complex long double float" } */
+_Complex long double double *x876; /* { dg-error "" "_Complex long double double" } */
+_Complex long double signed *x877; /* { dg-error "" "_Complex long double signed" } */
+_Complex long double unsigned *x878; /* { dg-error "" "_Complex long double unsigned" } */
+_Complex long double _Bool *x879; /* { dg-error "" "_Complex long double _Bool" } */
+_Complex long double _Complex *x880; /* { dg-error "" "_Complex long double _Complex" } */
+_Complex double long void *x881; /* { dg-error "" "_Complex double long void" } */
+_Complex double long char *x882; /* { dg-error "" "_Complex double long char" } */
+_Complex double long short *x883; /* { dg-error "" "_Complex double long short" } */
+_Complex double long int *x884; /* { dg-error "" "_Complex double long int" } */
+_Complex double long long *x885; /* { dg-error "" "_Complex double long long" } */
+_Complex double long float *x886; /* { dg-error "" "_Complex double long float" } */
+_Complex double long double *x887; /* { dg-error "" "_Complex double long double" } */
+_Complex double long signed *x888; /* { dg-error "" "_Complex double long signed" } */
+_Complex double long unsigned *x889; /* { dg-error "" "_Complex double long unsigned" } */
+_Complex double long _Bool *x890; /* { dg-error "" "_Complex double long _Bool" } */
+_Complex double long _Complex *x891; /* { dg-error "" "_Complex double long _Complex" } */
+int long long signed void *x892; /* { dg-error "" "int long long signed void" } */
+int long long signed char *x893; /* { dg-error "" "int long long signed char" } */
+int long long signed short *x894; /* { dg-error "" "int long long signed short" } */
+int long long signed int *x895; /* { dg-error "" "int long long signed int" } */
+int long long signed long *x896; /* { dg-error "" "int long long signed long" } */
+int long long signed float *x897; /* { dg-error "" "int long long signed float" } */
+int long long signed double *x898; /* { dg-error "" "int long long signed double" } */
+int long long signed signed *x899; /* { dg-error "" "int long long signed signed" } */
+int long long signed unsigned *x900; /* { dg-error "" "int long long signed unsigned" } */
+int long long signed _Bool *x901; /* { dg-error "" "int long long signed _Bool" } */
+int long long signed _Complex *x902; /* { dg-error "" "int long long signed _Complex" } */
+int long long unsigned void *x903; /* { dg-error "" "int long long unsigned void" } */
+int long long unsigned char *x904; /* { dg-error "" "int long long unsigned char" } */
+int long long unsigned short *x905; /* { dg-error "" "int long long unsigned short" } */
+int long long unsigned int *x906; /* { dg-error "" "int long long unsigned int" } */
+int long long unsigned long *x907; /* { dg-error "" "int long long unsigned long" } */
+int long long unsigned float *x908; /* { dg-error "" "int long long unsigned float" } */
+int long long unsigned double *x909; /* { dg-error "" "int long long unsigned double" } */
+int long long unsigned signed *x910; /* { dg-error "" "int long long unsigned signed" } */
+int long long unsigned unsigned *x911; /* { dg-error "" "int long long unsigned unsigned" } */
+int long long unsigned _Bool *x912; /* { dg-error "" "int long long unsigned _Bool" } */
+int long long unsigned _Complex *x913; /* { dg-error "" "int long long unsigned _Complex" } */
+int long signed long void *x914; /* { dg-error "" "int long signed long void" } */
+int long signed long char *x915; /* { dg-error "" "int long signed long char" } */
+int long signed long short *x916; /* { dg-error "" "int long signed long short" } */
+int long signed long int *x917; /* { dg-error "" "int long signed long int" } */
+int long signed long long *x918; /* { dg-error "" "int long signed long long" } */
+int long signed long float *x919; /* { dg-error "" "int long signed long float" } */
+int long signed long double *x920; /* { dg-error "" "int long signed long double" } */
+int long signed long signed *x921; /* { dg-error "" "int long signed long signed" } */
+int long signed long unsigned *x922; /* { dg-error "" "int long signed long unsigned" } */
+int long signed long _Bool *x923; /* { dg-error "" "int long signed long _Bool" } */
+int long signed long _Complex *x924; /* { dg-error "" "int long signed long _Complex" } */
+int long unsigned long void *x925; /* { dg-error "" "int long unsigned long void" } */
+int long unsigned long char *x926; /* { dg-error "" "int long unsigned long char" } */
+int long unsigned long short *x927; /* { dg-error "" "int long unsigned long short" } */
+int long unsigned long int *x928; /* { dg-error "" "int long unsigned long int" } */
+int long unsigned long long *x929; /* { dg-error "" "int long unsigned long long" } */
+int long unsigned long float *x930; /* { dg-error "" "int long unsigned long float" } */
+int long unsigned long double *x931; /* { dg-error "" "int long unsigned long double" } */
+int long unsigned long signed *x932; /* { dg-error "" "int long unsigned long signed" } */
+int long unsigned long unsigned *x933; /* { dg-error "" "int long unsigned long unsigned" } */
+int long unsigned long _Bool *x934; /* { dg-error "" "int long unsigned long _Bool" } */
+int long unsigned long _Complex *x935; /* { dg-error "" "int long unsigned long _Complex" } */
+int signed long long void *x936; /* { dg-error "" "int signed long long void" } */
+int signed long long char *x937; /* { dg-error "" "int signed long long char" } */
+int signed long long short *x938; /* { dg-error "" "int signed long long short" } */
+int signed long long int *x939; /* { dg-error "" "int signed long long int" } */
+int signed long long long *x940; /* { dg-error "" "int signed long long long" } */
+int signed long long float *x941; /* { dg-error "" "int signed long long float" } */
+int signed long long double *x942; /* { dg-error "" "int signed long long double" } */
+int signed long long signed *x943; /* { dg-error "" "int signed long long signed" } */
+int signed long long unsigned *x944; /* { dg-error "" "int signed long long unsigned" } */
+int signed long long _Bool *x945; /* { dg-error "" "int signed long long _Bool" } */
+int signed long long _Complex *x946; /* { dg-error "" "int signed long long _Complex" } */
+int unsigned long long void *x947; /* { dg-error "" "int unsigned long long void" } */
+int unsigned long long char *x948; /* { dg-error "" "int unsigned long long char" } */
+int unsigned long long short *x949; /* { dg-error "" "int unsigned long long short" } */
+int unsigned long long int *x950; /* { dg-error "" "int unsigned long long int" } */
+int unsigned long long long *x951; /* { dg-error "" "int unsigned long long long" } */
+int unsigned long long float *x952; /* { dg-error "" "int unsigned long long float" } */
+int unsigned long long double *x953; /* { dg-error "" "int unsigned long long double" } */
+int unsigned long long signed *x954; /* { dg-error "" "int unsigned long long signed" } */
+int unsigned long long unsigned *x955; /* { dg-error "" "int unsigned long long unsigned" } */
+int unsigned long long _Bool *x956; /* { dg-error "" "int unsigned long long _Bool" } */
+int unsigned long long _Complex *x957; /* { dg-error "" "int unsigned long long _Complex" } */
+long int long signed void *x958; /* { dg-error "" "long int long signed void" } */
+long int long signed char *x959; /* { dg-error "" "long int long signed char" } */
+long int long signed short *x960; /* { dg-error "" "long int long signed short" } */
+long int long signed int *x961; /* { dg-error "" "long int long signed int" } */
+long int long signed long *x962; /* { dg-error "" "long int long signed long" } */
+long int long signed float *x963; /* { dg-error "" "long int long signed float" } */
+long int long signed double *x964; /* { dg-error "" "long int long signed double" } */
+long int long signed signed *x965; /* { dg-error "" "long int long signed signed" } */
+long int long signed unsigned *x966; /* { dg-error "" "long int long signed unsigned" } */
+long int long signed _Bool *x967; /* { dg-error "" "long int long signed _Bool" } */
+long int long signed _Complex *x968; /* { dg-error "" "long int long signed _Complex" } */
+long int long unsigned void *x969; /* { dg-error "" "long int long unsigned void" } */
+long int long unsigned char *x970; /* { dg-error "" "long int long unsigned char" } */
+long int long unsigned short *x971; /* { dg-error "" "long int long unsigned short" } */
+long int long unsigned int *x972; /* { dg-error "" "long int long unsigned int" } */
+long int long unsigned long *x973; /* { dg-error "" "long int long unsigned long" } */
+long int long unsigned float *x974; /* { dg-error "" "long int long unsigned float" } */
+long int long unsigned double *x975; /* { dg-error "" "long int long unsigned double" } */
+long int long unsigned signed *x976; /* { dg-error "" "long int long unsigned signed" } */
+long int long unsigned unsigned *x977; /* { dg-error "" "long int long unsigned unsigned" } */
+long int long unsigned _Bool *x978; /* { dg-error "" "long int long unsigned _Bool" } */
+long int long unsigned _Complex *x979; /* { dg-error "" "long int long unsigned _Complex" } */
+long int signed long void *x980; /* { dg-error "" "long int signed long void" } */
+long int signed long char *x981; /* { dg-error "" "long int signed long char" } */
+long int signed long short *x982; /* { dg-error "" "long int signed long short" } */
+long int signed long int *x983; /* { dg-error "" "long int signed long int" } */
+long int signed long long *x984; /* { dg-error "" "long int signed long long" } */
+long int signed long float *x985; /* { dg-error "" "long int signed long float" } */
+long int signed long double *x986; /* { dg-error "" "long int signed long double" } */
+long int signed long signed *x987; /* { dg-error "" "long int signed long signed" } */
+long int signed long unsigned *x988; /* { dg-error "" "long int signed long unsigned" } */
+long int signed long _Bool *x989; /* { dg-error "" "long int signed long _Bool" } */
+long int signed long _Complex *x990; /* { dg-error "" "long int signed long _Complex" } */
+long int unsigned long void *x991; /* { dg-error "" "long int unsigned long void" } */
+long int unsigned long char *x992; /* { dg-error "" "long int unsigned long char" } */
+long int unsigned long short *x993; /* { dg-error "" "long int unsigned long short" } */
+long int unsigned long int *x994; /* { dg-error "" "long int unsigned long int" } */
+long int unsigned long long *x995; /* { dg-error "" "long int unsigned long long" } */
+long int unsigned long float *x996; /* { dg-error "" "long int unsigned long float" } */
+long int unsigned long double *x997; /* { dg-error "" "long int unsigned long double" } */
+long int unsigned long signed *x998; /* { dg-error "" "long int unsigned long signed" } */
+long int unsigned long unsigned *x999; /* { dg-error "" "long int unsigned long unsigned" } */
+long int unsigned long _Bool *x1000; /* { dg-error "" "long int unsigned long _Bool" } */
+long int unsigned long _Complex *x1001; /* { dg-error "" "long int unsigned long _Complex" } */
+long long int signed void *x1002; /* { dg-error "" "long long int signed void" } */
+long long int signed char *x1003; /* { dg-error "" "long long int signed char" } */
+long long int signed short *x1004; /* { dg-error "" "long long int signed short" } */
+long long int signed int *x1005; /* { dg-error "" "long long int signed int" } */
+long long int signed long *x1006; /* { dg-error "" "long long int signed long" } */
+long long int signed float *x1007; /* { dg-error "" "long long int signed float" } */
+long long int signed double *x1008; /* { dg-error "" "long long int signed double" } */
+long long int signed signed *x1009; /* { dg-error "" "long long int signed signed" } */
+long long int signed unsigned *x1010; /* { dg-error "" "long long int signed unsigned" } */
+long long int signed _Bool *x1011; /* { dg-error "" "long long int signed _Bool" } */
+long long int signed _Complex *x1012; /* { dg-error "" "long long int signed _Complex" } */
+long long int unsigned void *x1013; /* { dg-error "" "long long int unsigned void" } */
+long long int unsigned char *x1014; /* { dg-error "" "long long int unsigned char" } */
+long long int unsigned short *x1015; /* { dg-error "" "long long int unsigned short" } */
+long long int unsigned int *x1016; /* { dg-error "" "long long int unsigned int" } */
+long long int unsigned long *x1017; /* { dg-error "" "long long int unsigned long" } */
+long long int unsigned float *x1018; /* { dg-error "" "long long int unsigned float" } */
+long long int unsigned double *x1019; /* { dg-error "" "long long int unsigned double" } */
+long long int unsigned signed *x1020; /* { dg-error "" "long long int unsigned signed" } */
+long long int unsigned unsigned *x1021; /* { dg-error "" "long long int unsigned unsigned" } */
+long long int unsigned _Bool *x1022; /* { dg-error "" "long long int unsigned _Bool" } */
+long long int unsigned _Complex *x1023; /* { dg-error "" "long long int unsigned _Complex" } */
+long long signed int void *x1024; /* { dg-error "" "long long signed int void" } */
+long long signed int char *x1025; /* { dg-error "" "long long signed int char" } */
+long long signed int short *x1026; /* { dg-error "" "long long signed int short" } */
+long long signed int int *x1027; /* { dg-error "" "long long signed int int" } */
+long long signed int long *x1028; /* { dg-error "" "long long signed int long" } */
+long long signed int float *x1029; /* { dg-error "" "long long signed int float" } */
+long long signed int double *x1030; /* { dg-error "" "long long signed int double" } */
+long long signed int signed *x1031; /* { dg-error "" "long long signed int signed" } */
+long long signed int unsigned *x1032; /* { dg-error "" "long long signed int unsigned" } */
+long long signed int _Bool *x1033; /* { dg-error "" "long long signed int _Bool" } */
+long long signed int _Complex *x1034; /* { dg-error "" "long long signed int _Complex" } */
+long long unsigned int void *x1035; /* { dg-error "" "long long unsigned int void" } */
+long long unsigned int char *x1036; /* { dg-error "" "long long unsigned int char" } */
+long long unsigned int short *x1037; /* { dg-error "" "long long unsigned int short" } */
+long long unsigned int int *x1038; /* { dg-error "" "long long unsigned int int" } */
+long long unsigned int long *x1039; /* { dg-error "" "long long unsigned int long" } */
+long long unsigned int float *x1040; /* { dg-error "" "long long unsigned int float" } */
+long long unsigned int double *x1041; /* { dg-error "" "long long unsigned int double" } */
+long long unsigned int signed *x1042; /* { dg-error "" "long long unsigned int signed" } */
+long long unsigned int unsigned *x1043; /* { dg-error "" "long long unsigned int unsigned" } */
+long long unsigned int _Bool *x1044; /* { dg-error "" "long long unsigned int _Bool" } */
+long long unsigned int _Complex *x1045; /* { dg-error "" "long long unsigned int _Complex" } */
+long signed int long void *x1046; /* { dg-error "" "long signed int long void" } */
+long signed int long char *x1047; /* { dg-error "" "long signed int long char" } */
+long signed int long short *x1048; /* { dg-error "" "long signed int long short" } */
+long signed int long int *x1049; /* { dg-error "" "long signed int long int" } */
+long signed int long long *x1050; /* { dg-error "" "long signed int long long" } */
+long signed int long float *x1051; /* { dg-error "" "long signed int long float" } */
+long signed int long double *x1052; /* { dg-error "" "long signed int long double" } */
+long signed int long signed *x1053; /* { dg-error "" "long signed int long signed" } */
+long signed int long unsigned *x1054; /* { dg-error "" "long signed int long unsigned" } */
+long signed int long _Bool *x1055; /* { dg-error "" "long signed int long _Bool" } */
+long signed int long _Complex *x1056; /* { dg-error "" "long signed int long _Complex" } */
+long signed long int void *x1057; /* { dg-error "" "long signed long int void" } */
+long signed long int char *x1058; /* { dg-error "" "long signed long int char" } */
+long signed long int short *x1059; /* { dg-error "" "long signed long int short" } */
+long signed long int int *x1060; /* { dg-error "" "long signed long int int" } */
+long signed long int long *x1061; /* { dg-error "" "long signed long int long" } */
+long signed long int float *x1062; /* { dg-error "" "long signed long int float" } */
+long signed long int double *x1063; /* { dg-error "" "long signed long int double" } */
+long signed long int signed *x1064; /* { dg-error "" "long signed long int signed" } */
+long signed long int unsigned *x1065; /* { dg-error "" "long signed long int unsigned" } */
+long signed long int _Bool *x1066; /* { dg-error "" "long signed long int _Bool" } */
+long signed long int _Complex *x1067; /* { dg-error "" "long signed long int _Complex" } */
+long unsigned int long void *x1068; /* { dg-error "" "long unsigned int long void" } */
+long unsigned int long char *x1069; /* { dg-error "" "long unsigned int long char" } */
+long unsigned int long short *x1070; /* { dg-error "" "long unsigned int long short" } */
+long unsigned int long int *x1071; /* { dg-error "" "long unsigned int long int" } */
+long unsigned int long long *x1072; /* { dg-error "" "long unsigned int long long" } */
+long unsigned int long float *x1073; /* { dg-error "" "long unsigned int long float" } */
+long unsigned int long double *x1074; /* { dg-error "" "long unsigned int long double" } */
+long unsigned int long signed *x1075; /* { dg-error "" "long unsigned int long signed" } */
+long unsigned int long unsigned *x1076; /* { dg-error "" "long unsigned int long unsigned" } */
+long unsigned int long _Bool *x1077; /* { dg-error "" "long unsigned int long _Bool" } */
+long unsigned int long _Complex *x1078; /* { dg-error "" "long unsigned int long _Complex" } */
+long unsigned long int void *x1079; /* { dg-error "" "long unsigned long int void" } */
+long unsigned long int char *x1080; /* { dg-error "" "long unsigned long int char" } */
+long unsigned long int short *x1081; /* { dg-error "" "long unsigned long int short" } */
+long unsigned long int int *x1082; /* { dg-error "" "long unsigned long int int" } */
+long unsigned long int long *x1083; /* { dg-error "" "long unsigned long int long" } */
+long unsigned long int float *x1084; /* { dg-error "" "long unsigned long int float" } */
+long unsigned long int double *x1085; /* { dg-error "" "long unsigned long int double" } */
+long unsigned long int signed *x1086; /* { dg-error "" "long unsigned long int signed" } */
+long unsigned long int unsigned *x1087; /* { dg-error "" "long unsigned long int unsigned" } */
+long unsigned long int _Bool *x1088; /* { dg-error "" "long unsigned long int _Bool" } */
+long unsigned long int _Complex *x1089; /* { dg-error "" "long unsigned long int _Complex" } */
+signed int long long void *x1090; /* { dg-error "" "signed int long long void" } */
+signed int long long char *x1091; /* { dg-error "" "signed int long long char" } */
+signed int long long short *x1092; /* { dg-error "" "signed int long long short" } */
+signed int long long int *x1093; /* { dg-error "" "signed int long long int" } */
+signed int long long long *x1094; /* { dg-error "" "signed int long long long" } */
+signed int long long float *x1095; /* { dg-error "" "signed int long long float" } */
+signed int long long double *x1096; /* { dg-error "" "signed int long long double" } */
+signed int long long signed *x1097; /* { dg-error "" "signed int long long signed" } */
+signed int long long unsigned *x1098; /* { dg-error "" "signed int long long unsigned" } */
+signed int long long _Bool *x1099; /* { dg-error "" "signed int long long _Bool" } */
+signed int long long _Complex *x1100; /* { dg-error "" "signed int long long _Complex" } */
+signed long int long void *x1101; /* { dg-error "" "signed long int long void" } */
+signed long int long char *x1102; /* { dg-error "" "signed long int long char" } */
+signed long int long short *x1103; /* { dg-error "" "signed long int long short" } */
+signed long int long int *x1104; /* { dg-error "" "signed long int long int" } */
+signed long int long long *x1105; /* { dg-error "" "signed long int long long" } */
+signed long int long float *x1106; /* { dg-error "" "signed long int long float" } */
+signed long int long double *x1107; /* { dg-error "" "signed long int long double" } */
+signed long int long signed *x1108; /* { dg-error "" "signed long int long signed" } */
+signed long int long unsigned *x1109; /* { dg-error "" "signed long int long unsigned" } */
+signed long int long _Bool *x1110; /* { dg-error "" "signed long int long _Bool" } */
+signed long int long _Complex *x1111; /* { dg-error "" "signed long int long _Complex" } */
+signed long long int void *x1112; /* { dg-error "" "signed long long int void" } */
+signed long long int char *x1113; /* { dg-error "" "signed long long int char" } */
+signed long long int short *x1114; /* { dg-error "" "signed long long int short" } */
+signed long long int int *x1115; /* { dg-error "" "signed long long int int" } */
+signed long long int long *x1116; /* { dg-error "" "signed long long int long" } */
+signed long long int float *x1117; /* { dg-error "" "signed long long int float" } */
+signed long long int double *x1118; /* { dg-error "" "signed long long int double" } */
+signed long long int signed *x1119; /* { dg-error "" "signed long long int signed" } */
+signed long long int unsigned *x1120; /* { dg-error "" "signed long long int unsigned" } */
+signed long long int _Bool *x1121; /* { dg-error "" "signed long long int _Bool" } */
+signed long long int _Complex *x1122; /* { dg-error "" "signed long long int _Complex" } */
+unsigned int long long void *x1123; /* { dg-error "" "unsigned int long long void" } */
+unsigned int long long char *x1124; /* { dg-error "" "unsigned int long long char" } */
+unsigned int long long short *x1125; /* { dg-error "" "unsigned int long long short" } */
+unsigned int long long int *x1126; /* { dg-error "" "unsigned int long long int" } */
+unsigned int long long long *x1127; /* { dg-error "" "unsigned int long long long" } */
+unsigned int long long float *x1128; /* { dg-error "" "unsigned int long long float" } */
+unsigned int long long double *x1129; /* { dg-error "" "unsigned int long long double" } */
+unsigned int long long signed *x1130; /* { dg-error "" "unsigned int long long signed" } */
+unsigned int long long unsigned *x1131; /* { dg-error "" "unsigned int long long unsigned" } */
+unsigned int long long _Bool *x1132; /* { dg-error "" "unsigned int long long _Bool" } */
+unsigned int long long _Complex *x1133; /* { dg-error "" "unsigned int long long _Complex" } */
+unsigned long int long void *x1134; /* { dg-error "" "unsigned long int long void" } */
+unsigned long int long char *x1135; /* { dg-error "" "unsigned long int long char" } */
+unsigned long int long short *x1136; /* { dg-error "" "unsigned long int long short" } */
+unsigned long int long int *x1137; /* { dg-error "" "unsigned long int long int" } */
+unsigned long int long long *x1138; /* { dg-error "" "unsigned long int long long" } */
+unsigned long int long float *x1139; /* { dg-error "" "unsigned long int long float" } */
+unsigned long int long double *x1140; /* { dg-error "" "unsigned long int long double" } */
+unsigned long int long signed *x1141; /* { dg-error "" "unsigned long int long signed" } */
+unsigned long int long unsigned *x1142; /* { dg-error "" "unsigned long int long unsigned" } */
+unsigned long int long _Bool *x1143; /* { dg-error "" "unsigned long int long _Bool" } */
+unsigned long int long _Complex *x1144; /* { dg-error "" "unsigned long int long _Complex" } */
+unsigned long long int void *x1145; /* { dg-error "" "unsigned long long int void" } */
+unsigned long long int char *x1146; /* { dg-error "" "unsigned long long int char" } */
+unsigned long long int short *x1147; /* { dg-error "" "unsigned long long int short" } */
+unsigned long long int int *x1148; /* { dg-error "" "unsigned long long int int" } */
+unsigned long long int long *x1149; /* { dg-error "" "unsigned long long int long" } */
+unsigned long long int float *x1150; /* { dg-error "" "unsigned long long int float" } */
+unsigned long long int double *x1151; /* { dg-error "" "unsigned long long int double" } */
+unsigned long long int signed *x1152; /* { dg-error "" "unsigned long long int signed" } */
+unsigned long long int unsigned *x1153; /* { dg-error "" "unsigned long long int unsigned" } */
+unsigned long long int _Bool *x1154; /* { dg-error "" "unsigned long long int _Bool" } */
+unsigned long long int _Complex *x1155; /* { dg-error "" "unsigned long long int _Complex" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-1.c
new file mode 100644
index 000000000..4a3a0f8e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-1.c
@@ -0,0 +1,12 @@
+/* Origin: PR 3467 */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+tdef (int n)
+{
+  typedef int A[n];	/* { dg-bogus "forbids variable length array" } */
+  A a;
+  A *p;
+  p = &a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-2.c
new file mode 100644
index 000000000..de15c73c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-2.c
@@ -0,0 +1,107 @@
+/* Test composite type of VLA and fixed-size array: should be the
+   fixed-size type.  Bug 22192.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+/* Test that the given expression (of pointer-to-array type) points to
+   the right sort of array.  */
+#define TEST_FIXED_SIZE(a) do { static int x[sizeof(*(a))]; (void)x; } while (0)
+#define TEST_VLA(a) do { (void)sizeof(*(a)); (void)(1 ? (a) : (__typeof__(**(a)) (*)[1])0); (void)(1 ? (a) : (__typeof__(**(a)) (*)[2])0); } while (0)
+#define TEST_INCOMPLETE(a) do { __typeof__(*(a)) x = { 0 }; (void)x; (void)(1 ? a : (__typeof__(**(a)) (*)[1])0); (void)(1 ? a : (__typeof__(**(a)) (*)[2])0); } while (0)
+
+#define TEST_COMP_FIX(a, b) TEST_FIXED_SIZE(i ? a : b)
+#define TEST_COMP_VLA(a, b) TEST_VLA(i ? a : b)
+#define TEST_COMP_INC(a, b) TEST_INCOMPLETE(i ? a : b)
+
+void
+foo (int i, int j)
+{
+  typedef int I;
+  int (*pf)[2];
+  int (*pv)[i];
+  int (*pi)[];
+  I (*pfI)[2];
+  I (*pvI)[i];
+  I (*piI)[];
+  TEST_COMP_FIX(pf, pf);
+  TEST_COMP_FIX(pf, pv);
+  TEST_COMP_FIX(pf, pi);
+  TEST_COMP_FIX(pf, pfI);
+  TEST_COMP_FIX(pf, pvI);
+  TEST_COMP_FIX(pf, piI);
+  TEST_COMP_FIX(pv, pf);
+  TEST_COMP_VLA(pv, pv);
+  TEST_COMP_VLA(pv, pi);
+  TEST_COMP_FIX(pv, pfI);
+  TEST_COMP_VLA(pv, pvI);
+  TEST_COMP_VLA(pv, piI);
+  TEST_COMP_FIX(pi, pf);
+  TEST_COMP_VLA(pi, pv);
+  TEST_COMP_INC(pi, pi);
+  TEST_COMP_FIX(pi, pfI);
+  TEST_COMP_VLA(pi, pvI);
+  TEST_COMP_INC(pi, piI);
+  TEST_COMP_FIX(pfI, pf);
+  TEST_COMP_FIX(pfI, pv);
+  TEST_COMP_FIX(pfI, pi);
+  TEST_COMP_FIX(pfI, pfI);
+  TEST_COMP_FIX(pfI, pvI);
+  TEST_COMP_FIX(pfI, piI);
+  TEST_COMP_FIX(pvI, pf);
+  TEST_COMP_VLA(pvI, pv);
+  TEST_COMP_VLA(pvI, pi);
+  TEST_COMP_FIX(pvI, pfI);
+  TEST_COMP_VLA(pvI, pvI);
+  TEST_COMP_VLA(pvI, piI);
+  TEST_COMP_FIX(piI, pf);
+  TEST_COMP_VLA(piI, pv);
+  TEST_COMP_INC(piI, pi);
+  TEST_COMP_FIX(piI, pfI);
+  TEST_COMP_VLA(piI, pvI);
+  TEST_COMP_INC(piI, piI);
+  typedef int (*Ti)[i];
+  typedef int (*Tj)[j];
+  Ti (*qf)[2];
+  Ti (*qv)[i];
+  Ti (*qi)[];
+  Tj (*rf)[2];
+  Tj (*rv)[j];
+  Tj (*ri)[];
+  TEST_COMP_FIX(qf, qf);
+  TEST_COMP_FIX(qf, qv);
+  TEST_COMP_FIX(qf, qi);
+  TEST_COMP_FIX(qf, rf);
+  TEST_COMP_FIX(qf, rv);
+  TEST_COMP_FIX(qf, ri);
+  TEST_COMP_FIX(qv, qf);
+  TEST_COMP_VLA(qv, qv);
+  TEST_COMP_VLA(qv, qi);
+  TEST_COMP_FIX(qv, rf);
+  TEST_COMP_VLA(qv, rv);
+  TEST_COMP_VLA(qv, ri);
+  TEST_COMP_FIX(qi, qf);
+  TEST_COMP_VLA(qi, qv);
+  TEST_COMP_INC(qi, qi);
+  TEST_COMP_FIX(qi, rf);
+  TEST_COMP_VLA(qi, rv);
+  TEST_COMP_INC(qi, ri);
+  TEST_COMP_FIX(rf, qf);
+  TEST_COMP_FIX(rf, qv);
+  TEST_COMP_FIX(rf, qi);
+  TEST_COMP_FIX(rf, rf);
+  TEST_COMP_FIX(rf, rv);
+  TEST_COMP_FIX(rf, ri);
+  TEST_COMP_FIX(rv, qf);
+  TEST_COMP_VLA(rv, qv);
+  TEST_COMP_VLA(rv, qi);
+  TEST_COMP_FIX(rv, rf);
+  TEST_COMP_VLA(rv, rv);
+  TEST_COMP_VLA(rv, ri);
+  TEST_COMP_FIX(ri, qf);
+  TEST_COMP_VLA(ri, qv);
+  TEST_COMP_INC(ri, qi);
+  TEST_COMP_FIX(ri, rf);
+  TEST_COMP_VLA(ri, rv);
+  TEST_COMP_INC(ri, ri);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-1.c
new file mode 100644
index 000000000..4e984d2b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-1.c
@@ -0,0 +1,305 @@
+/* Test for labels and VM declarations: bug 12913.
+   goto statements must not jump into the scope of VM declarations.
+
+   This tests all combinations of label and goto locations in a given
+   function.
+
+   c99-vla-jump-1.c tests with just that label and goto, VLAs.
+   c99-vla-jump-2.c tests with many other labels and gotos, VLAs.
+   c99-vla-jump-3.c tests with just that label and goto, VM.
+   c99-vla-jump-4.c tests with many other labels and gotos, VM.
+   c99-vla-jump-5.c tests with switch statements.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void fa0 (int n) {  goto a; a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa1 (int n) {  goto a; { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa2 (int n) {  goto a; { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa3 (int n) {  goto a; { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa4 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa5 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa6 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa7 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa8 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa9 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa10 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa11 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa12 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa13 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa14 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa15 (int n) {  goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa16 (int n) { a: goto a; { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa17 (int n) { a:{ int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa18 (int n) { { int b[n];  goto a; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa19 (int n) { { int b[n];  goto a; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa20 (int n) { { int b[n];  goto a; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa21 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa22 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa23 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa24 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa25 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa26 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa27 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa28 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa29 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa30 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa31 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa32 (int n) { { int b[n];  goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa33 (int n) { { int b[n]; a: goto a; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa34 (int n) { a:{ int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa35 (int n) { { int b[n]; a:{ int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa36 (int n) { { int b[n]; { int c[n];  goto a; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa37 (int n) { { int b[n]; { int c[n];  goto a; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa38 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa39 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa40 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa41 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa42 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa43 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa44 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa45 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa46 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa47 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa48 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa49 (int n) { { int b[n]; { int c[n];  goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa50 (int n) { { int b[n]; { int c[n]; a: goto a; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa51 (int n) { a:{ int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa52 (int n) { { int b[n]; a:{ int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa53 (int n) { { int b[n]; { int c[n]; a:0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa54 (int n) { { int b[n]; { int c[n]; 0;}  goto a; a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa55 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa56 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa57 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa58 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa59 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa60 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa61 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa62 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa63 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa64 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa65 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa66 (int n) { { int b[n]; { int c[n]; 0;}  goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa67 (int n) { { int b[n]; { int c[n]; 0;} a: goto a; { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa68 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa69 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa70 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa71 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa72 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa73 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa74 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa75 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa76 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa77 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa78 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa79 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa80 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa81 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa82 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa83 (int n) { { int b[n]; { int c[n]; 0;} { int d[n];  goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa84 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a: goto a; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa85 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa86 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa87 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa88 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa89 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa90 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa91 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa92 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa93 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa94 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa95 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa96 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa97 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa98 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa99 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa100 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;}  goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa101 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a: goto a; ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa102 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa103 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa104 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa105 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa106 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa107 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa108 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa109 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa110 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa111 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa112 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa113 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa114 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa115 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa116 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa117 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n];  goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa118 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a: goto a; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa119 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa120 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa121 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa122 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa123 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa124 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa125 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa126 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa127 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa128 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa129 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa130 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa131 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa132 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa133 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa134 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;};  goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa135 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a: goto a; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa136 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa137 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa138 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa139 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa140 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa141 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa142 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa143 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa144 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa145 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa146 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa147 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa148 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; }
+void fa149 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa150 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa151 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n];  goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa152 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a: goto a; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa153 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa154 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa155 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa156 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa157 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa158 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa159 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa160 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa161 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa162 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa163 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa164 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa165 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; }
+void fa166 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa167 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa168 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n];  goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa169 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a: goto a; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa170 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa171 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa172 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa173 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa174 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa175 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa176 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa177 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa178 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa179 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa180 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa181 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa182 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; }
+void fa183 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa184 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa185 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;};  goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa186 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a: goto a; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa187 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa188 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa189 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa190 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa191 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa192 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa193 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa194 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa195 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa196 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa197 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa198 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa199 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; }
+void fa200 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa201 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa202 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n];  goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa203 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a: goto a; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa204 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa205 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa206 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa207 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa208 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa209 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa210 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa211 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa212 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa213 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa214 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa215 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;};  goto a; ; int i[n]; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa216 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; a:; int i[n]; 0;}; ; int j[n]; 0; }
+void fa217 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; a:0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa218 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; a:; int j[n]; 0; }
+void fa219 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;};  goto a; ; int i[n]; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa220 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a: goto a; ; int i[n]; 0;}; ; int j[n]; 0; }
+void fa221 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; }
+void fa222 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa223 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa224 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa225 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa226 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa227 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa228 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; }
+void fa229 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; }
+void fa230 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa231 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; }
+void fa232 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n];  goto a; 0;}; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa233 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n];  goto a; 0;}; ; int j[n]; 0; }
+void fa234 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; a:0;}; ; int j[n]; 0; }
+void fa235 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; a:; int j[n]; 0; }
+void fa236 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n];  goto a; 0;}; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa237 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a: goto a; 0;}; ; int j[n]; 0; }
+void fa238 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; }
+void fa239 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa240 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa241 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa242 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa243 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa244 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa245 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; }
+void fa246 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa247 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa248 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa249 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa250 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa251 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;};  goto a; ; int j[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa252 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; a:; int j[n]; 0; }
+void fa253 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;};  goto a; ; int j[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa254 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a: goto a; ; int j[n]; 0; }
+void fa255 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; }
+void fa256 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa257 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa258 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa259 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa260 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa261 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa262 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; }
+void fa263 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa264 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa265 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa266 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa267 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa268 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa269 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n];  goto a; 0; }
+void fa270 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n];  goto a; a:0; }
+void fa271 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a: goto a; 0; }
+void fa272 (int n) { a:{ int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  }
+void fa273 (int n) { { int b[n]; a:{ int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa274 (int n) { { int b[n]; { int c[n]; a:0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa275 (int n) { { int b[n]; { int c[n]; 0;} a:{ int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa276 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; a:0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa277 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} a:; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa278 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; a:0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa279 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; a:{ int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  }
+void fa280 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; a:{ int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa281 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; a:0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa282 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; a:{ int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa283 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; a:0;}; ; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa284 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; a:; int i[n]; 0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa285 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; a:0;}; ; int j[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fa286 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; a:; int j[n]; 0; goto a;  }
+void fa287 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; a:0; goto a;  }
+void fa288 (int n) { { int b[n]; { int c[n]; 0;} { int d[n]; 0;} ; int e[n]; 0;}; { int f[n]; { int g[n]; 0;}; { int h[n]; 0;}; ; int i[n]; 0;}; ; int j[n]; 0;a: goto a;  }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-2.c
new file mode 100644
index 000000000..27cecaa60
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-2.c
@@ -0,0 +1,305 @@
+/* Test for labels and VM declarations: bug 12913.
+   goto statements must not jump into the scope of VM declarations.
+
+   This tests all combinations of label and goto locations in a given
+   function.
+
+   c99-vla-jump-1.c tests with just that label and goto, VLAs.
+   c99-vla-jump-2.c tests with many other labels and gotos, VLAs.
+   c99-vla-jump-3.c tests with just that label and goto, VM.
+   c99-vla-jump-4.c tests with many other labels and gotos, VM.
+   c99-vla-jump-5.c tests with switch statements.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void fb0 (int n) { p0A:goto p0A; goto a; a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb1 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb2 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb3 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb4 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb5 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb6 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb7 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb8 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb9 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb10 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb11 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb12 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb13 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb14 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb15 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb16 (int n) { a: goto a; P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb17 (int n) { a:{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb18 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb19 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb20 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb21 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb22 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb23 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb24 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb25 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb26 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb27 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb28 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb29 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb30 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb31 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb32 (int n) { P0A:goto P0A;{ int b[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb33 (int n) { P0A:goto P0A;{ int b[n]; a: goto a; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb34 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb35 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb36 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb37 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb38 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb39 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb40 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb41 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb42 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb43 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb44 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb45 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb46 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb47 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb48 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb49 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb50 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a: goto a; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb51 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb52 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb53 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb54 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb55 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb56 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb57 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb58 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb59 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb60 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb61 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb62 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb63 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb64 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb65 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb66 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb67 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a: goto a; P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb68 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb69 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb70 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb71 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb72 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb73 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb74 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb75 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb76 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb77 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb78 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb79 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb80 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb81 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb82 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb83 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb84 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a: goto a; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb85 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb86 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb87 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb88 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb89 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb90 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb91 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb92 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb93 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb94 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb95 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb96 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb97 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb98 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb99 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb100 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb101 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a: goto a; P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb102 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb103 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb104 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb105 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb106 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb107 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb108 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb109 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb110 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb111 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb112 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb113 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb114 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb115 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb116 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb117 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb118 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a: goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb119 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb120 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb121 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb122 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb123 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb124 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb125 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb126 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb127 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb128 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb129 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb130 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb131 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb132 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb133 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb134 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb135 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a: goto a; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb136 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb137 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb138 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb139 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb140 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb141 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb142 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb143 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb144 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb145 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb146 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb147 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb148 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb149 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb150 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb151 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb152 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a: goto a; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb153 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb154 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb155 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb156 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb157 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb158 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb159 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb160 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb161 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb162 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb163 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb164 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb165 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb166 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb167 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb168 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb169 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a: goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb170 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb171 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb172 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb173 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb174 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb175 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb176 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb177 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb178 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb179 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb180 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb181 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb182 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb183 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb184 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb185 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb186 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a: goto a; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb187 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb188 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb189 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb190 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb191 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb192 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb193 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb194 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb195 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb196 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb197 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb198 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb199 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb200 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb201 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb202 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb203 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a: goto a; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb204 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb205 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb206 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb207 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb208 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb209 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb210 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb211 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb212 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb213 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb214 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb215 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb216 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb217 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb218 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb219 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb220 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a: goto a; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb221 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb222 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb223 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb224 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb225 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb226 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb227 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb228 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb229 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb230 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb231 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb232 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb233 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb234 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb235 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb236 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb237 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a: goto a; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb238 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb239 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb240 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb241 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb242 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb243 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb244 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb245 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb246 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb247 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb248 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb249 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb250 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb251 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb252 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; a:; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb253 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; int j[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb254 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a: goto a; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fb255 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fb256 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb257 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb258 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb259 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb260 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb261 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb262 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fb263 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb264 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb265 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb266 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb267 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb268 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb269 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fb270 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; p03A:goto p03A; goto a; a:0;P03B:goto P03B; }
+void fb271 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a: goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fb272 (int n) { a:{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fb273 (int n) { P0A:goto P0A;{ int b[n]; a:{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb274 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; a:0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb275 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} a:{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb276 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; a:0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb277 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} a:; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb278 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; a:0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb279 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; a:{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fb280 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; a:{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb281 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; a:0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb282 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; a:{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb283 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; a:0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb284 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; a:; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb285 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; a:0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fb286 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; a:; int j[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fb287 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; a:0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fb288 (int n) { P0A:goto P0A;{ int b[n]; P01A:goto P01A;{ int c[n]; P012A:goto P012A;0;} P01B:goto P01B;{ int d[n]; P013A:goto P013A;0;} P01C:goto P01C;; int e[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ int f[n]; P02A:goto P02A;{ int g[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ int h[n]; P025A:goto P025A;0;}; P02C:goto P02C;; int i[n]; P026A:goto P026A;0;}; P0C:goto P0C;; int j[n]; P03A:goto P03A;0;a: goto a; P03B:goto P03B; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-3.c
new file mode 100644
index 000000000..0aff362d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-3.c
@@ -0,0 +1,305 @@
+/* Test for labels and VM declarations: bug 12913.
+   goto statements must not jump into the scope of VM declarations.
+
+   This tests all combinations of label and goto locations in a given
+   function.
+
+   c99-vla-jump-1.c tests with just that label and goto, VLAs.
+   c99-vla-jump-2.c tests with many other labels and gotos, VLAs.
+   c99-vla-jump-3.c tests with just that label and goto, VM.
+   c99-vla-jump-4.c tests with many other labels and gotos, VM.
+   c99-vla-jump-5.c tests with switch statements.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void fc0 (int n) {  goto a; a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc1 (int n) {  goto a; { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc2 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc3 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc4 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc5 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc6 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc7 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc8 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc9 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc10 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc11 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc12 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc13 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc14 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc15 (int n) {  goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc16 (int n) { a: goto a; { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc17 (int n) { a:{ typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc18 (int n) { { typedef int (*b)[n];  goto a; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc19 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc20 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc21 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc22 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc23 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc24 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc25 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc26 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc27 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc28 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc29 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc30 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc31 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc32 (int n) { { typedef int (*b)[n];  goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc33 (int n) { { typedef int (*b)[n]; a: goto a; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc34 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc35 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc36 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc37 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc38 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc39 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc40 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc41 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc42 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc43 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc44 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc45 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc46 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc47 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc48 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc49 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n];  goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc50 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a: goto a; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc51 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc52 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc53 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc54 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc55 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc56 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc57 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc58 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc59 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc60 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc61 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc62 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc63 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc64 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc65 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc66 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;}  goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc67 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a: goto a; { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc68 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc69 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc70 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc71 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc72 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc73 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc74 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc75 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc76 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc77 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc78 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc79 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc80 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc81 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc82 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc83 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n];  goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc84 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a: goto a; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc85 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc86 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc87 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc88 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc89 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc90 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc91 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc92 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc93 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc94 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc95 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc96 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc97 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc98 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc99 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc100 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;}  goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc101 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a: goto a; ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc102 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc103 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc104 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc105 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc106 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc107 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc108 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc109 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc110 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc111 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc112 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc113 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc114 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc115 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc116 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc117 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n];  goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc118 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a: goto a; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc119 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc120 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc121 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc122 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc123 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc124 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc125 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc126 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc127 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc128 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc129 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc130 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc131 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc132 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc133 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc134 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;};  goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc135 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a: goto a; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc136 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc137 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc138 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc139 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc140 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc141 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc142 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc143 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc144 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc145 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc146 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc147 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc148 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc149 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc150 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc151 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n];  goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc152 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a: goto a; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc153 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc154 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc155 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc156 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc157 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc158 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc159 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc160 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc161 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc162 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc163 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc164 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc165 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc166 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc167 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc168 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n];  goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc169 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a: goto a; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc170 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc171 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc172 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc173 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc174 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc175 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc176 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc177 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc178 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc179 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc180 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc181 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc182 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc183 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc184 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc185 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;};  goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc186 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a: goto a; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc187 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc188 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc189 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc190 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc191 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc192 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc193 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc194 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc195 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc196 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc197 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc198 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc199 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc200 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc201 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc202 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n];  goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc203 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a: goto a; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc204 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc205 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc206 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc207 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc208 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc209 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc210 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc211 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc212 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc213 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc214 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc215 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc216 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc217 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc218 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc219 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;};  goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc220 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a: goto a; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; }
+void fc221 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; }
+void fc222 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc223 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc224 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc225 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc226 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc227 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc228 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; }
+void fc229 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; }
+void fc230 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc231 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; }
+void fc232 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc233 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; 0; }
+void fc234 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; a:0;}; ; typedef int (*j)[n]; 0; }
+void fc235 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; a:; typedef int (*j)[n]; 0; }
+void fc236 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n];  goto a; 0;}; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc237 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a: goto a; 0;}; ; typedef int (*j)[n]; 0; }
+void fc238 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; }
+void fc239 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc240 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc241 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc242 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc243 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc244 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc245 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; }
+void fc246 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc247 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc248 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc249 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc250 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc251 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;};  goto a; ; typedef int (*j)[n]; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc252 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; a:; typedef int (*j)[n]; 0; }
+void fc253 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;};  goto a; ; typedef int (*j)[n]; a:0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc254 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a: goto a; ; typedef int (*j)[n]; 0; }
+void fc255 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; }
+void fc256 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc257 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc258 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc259 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc260 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc261 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc262 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; }
+void fc263 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc264 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc265 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc266 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc267 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc268 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n];  goto a; 0; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc269 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n];  goto a; 0; }
+void fc270 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n];  goto a; a:0; }
+void fc271 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a: goto a; 0; }
+void fc272 (int n) { a:{ typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  }
+void fc273 (int n) { { typedef int (*b)[n]; a:{ typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc274 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; a:0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc275 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} a:{ typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc276 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; a:0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc277 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} a:; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc278 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; a:0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc279 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; a:{ typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  }
+void fc280 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; a:{ typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc281 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; a:0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc282 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; a:{ typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc283 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; a:0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc284 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; a:; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc285 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; a:0;}; ; typedef int (*j)[n]; 0; goto a;  } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fc286 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; a:; typedef int (*j)[n]; 0; goto a;  }
+void fc287 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; a:0; goto a;  }
+void fc288 (int n) { { typedef int (*b)[n]; { typedef int (*c)[n]; 0;} { typedef int (*d)[n]; 0;} ; typedef int (*e)[n]; 0;}; { typedef int (*f)[n]; { typedef int (*g)[n]; 0;}; { typedef int (*h)[n]; 0;}; ; typedef int (*i)[n]; 0;}; ; typedef int (*j)[n]; 0;a: goto a;  }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-4.c
new file mode 100644
index 000000000..e77a14209
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-4.c
@@ -0,0 +1,305 @@
+/* Test for labels and VM declarations: bug 12913.
+   goto statements must not jump into the scope of VM declarations.
+
+   This tests all combinations of label and goto locations in a given
+   function.
+
+   c99-vla-jump-1.c tests with just that label and goto, VLAs.
+   c99-vla-jump-2.c tests with many other labels and gotos, VLAs.
+   c99-vla-jump-3.c tests with just that label and goto, VM.
+   c99-vla-jump-4.c tests with many other labels and gotos, VM.
+   c99-vla-jump-5.c tests with switch statements.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void fd0 (int n) { p0A:goto p0A; goto a; a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd1 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd2 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd3 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd4 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd5 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd6 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd7 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd8 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd9 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd10 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd11 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd12 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd13 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd14 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd15 (int n) { p0A:goto p0A; goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd16 (int n) { a: goto a; P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd17 (int n) { a:{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd18 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd19 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd20 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd21 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd22 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd23 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd24 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd25 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd26 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd27 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd28 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd29 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd30 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd31 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd32 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; p01A:goto p01A; goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd33 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a: goto a; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd34 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd35 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd36 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd37 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd38 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd39 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd40 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd41 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd42 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd43 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd44 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd45 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd46 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd47 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd48 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd49 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; p012A:goto p012A; goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd50 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a: goto a; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd51 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd52 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd53 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd54 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd55 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd56 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd57 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd58 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd59 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd60 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd61 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd62 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd63 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd64 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd65 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd66 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} p01B:goto p01B; goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd67 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a: goto a; P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd68 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd69 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd70 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd71 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd72 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd73 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd74 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd75 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd76 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd77 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd78 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd79 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd80 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd81 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd82 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd83 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; p013A:goto p013A; goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd84 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a: goto a; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd85 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd86 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd87 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd88 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd89 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd90 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd91 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd92 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd93 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd94 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd95 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd96 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd97 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd98 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd99 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd100 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} p01C:goto p01C; goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd101 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a: goto a; P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd102 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd103 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd104 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd105 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd106 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd107 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd108 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd109 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd110 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd111 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd112 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd113 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd114 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd115 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd116 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd117 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; p014A:goto p014A; goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd118 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a: goto a; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd119 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd120 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd121 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd122 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd123 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd124 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd125 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd126 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd127 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd128 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd129 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd130 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd131 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd132 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd133 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd134 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; p0B:goto p0B; goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd135 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a: goto a; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd136 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd137 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd138 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd139 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd140 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd141 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd142 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd143 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd144 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd145 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd146 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd147 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd148 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd149 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd150 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd151 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; p02A:goto p02A; goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd152 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a: goto a; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd153 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd154 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd155 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd156 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd157 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd158 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd159 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd160 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd161 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd162 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd163 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd164 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd165 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd166 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd167 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd168 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; p024A:goto p024A; goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd169 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a: goto a; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd170 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd171 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd172 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd173 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd174 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd175 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd176 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd177 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd178 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd179 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd180 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd181 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd182 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd183 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd184 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd185 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; p02B:goto p02B; goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd186 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a: goto a; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd187 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd188 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd189 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd190 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd191 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd192 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd193 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd194 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd195 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd196 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd197 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd198 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd199 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd200 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd201 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd202 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; p025A:goto p025A; goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd203 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a: goto a; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd204 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd205 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd206 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd207 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd208 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd209 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd210 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd211 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd212 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd213 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd214 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd215 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd216 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd217 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd218 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd219 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; p02C:goto p02C; goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd220 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a: goto a; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd221 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd222 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd223 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd224 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd225 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd226 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd227 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd228 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd229 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd230 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd231 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd232 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd233 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd234 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd235 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd236 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; p026A:goto p026A; goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd237 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a: goto a; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd238 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd239 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd240 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd241 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd242 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd243 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd244 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd245 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd246 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd247 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd248 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd249 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd250 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd251 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd252 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; a:; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd253 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; p0C:goto p0C; goto a; P0C:goto P0C;; typedef int (*j)[n]; a:0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd254 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a: goto a; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;P03B:goto P03B; }
+void fd255 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fd256 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd257 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd258 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd259 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd260 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd261 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd262 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fd263 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd264 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd265 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd266 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd267 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd268 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd269 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; p03A:goto p03A; goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fd270 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; p03A:goto p03A; goto a; a:0;P03B:goto P03B; }
+void fd271 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a: goto a; P03A:goto P03A;0;P03B:goto P03B; }
+void fd272 (int n) { a:{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fd273 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; a:{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd274 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; a:0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd275 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} a:{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd276 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; a:0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd277 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} a:; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd278 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; a:0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd279 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; a:{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fd280 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; a:{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd281 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; a:0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd282 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; a:{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd283 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; a:0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd284 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; a:; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd285 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; a:0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; } /* { dg-error "jump into scope of identifier with variably modified type" } */
+void fd286 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; a:; typedef int (*j)[n]; P03A:goto P03A;0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fd287 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; a:0;p03B:goto p03B; goto a; P03B:goto P03B; }
+void fd288 (int n) { P0A:goto P0A;{ typedef int (*b)[n]; P01A:goto P01A;{ typedef int (*c)[n]; P012A:goto P012A;0;} P01B:goto P01B;{ typedef int (*d)[n]; P013A:goto P013A;0;} P01C:goto P01C;; typedef int (*e)[n]; P014A:goto P014A;0;}; P0B:goto P0B;{ typedef int (*f)[n]; P02A:goto P02A;{ typedef int (*g)[n]; P024A:goto P024A;0;}; P02B:goto P02B;{ typedef int (*h)[n]; P025A:goto P025A;0;}; P02C:goto P02C;; typedef int (*i)[n]; P026A:goto P026A;0;}; P0C:goto P0C;; typedef int (*j)[n]; P03A:goto P03A;0;a: goto a; P03B:goto P03B; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-5.c
new file mode 100644
index 000000000..ca3f85f59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/c99-vla-jump-5.c
@@ -0,0 +1,30 @@
+/* Test for labels and VM declarations: bug 12913.
+   switch statements must not jump into the scope of VM declarations.
+
+   c99-vla-jump-1.c tests with just that label and goto, VLAs.
+   c99-vla-jump-2.c tests with many other labels and gotos, VLAs.
+   c99-vla-jump-3.c tests with just that label and goto, VM.
+   c99-vla-jump-4.c tests with many other labels and gotos, VM.
+   c99-vla-jump-5.c tests with switch statements.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+void
+f (int a, int b)
+{
+  switch (a) {
+    int v[b];
+  case 2: /* { dg-error "case label in scope of identifier with variably modified type not containing enclosing switch statement" } */
+  default: /* { dg-error "'default' label in scope of identifier with variably modified type not containing enclosing switch statement" } */
+  switch (a)
+    {
+    case 4:
+      { int z[b]; }
+    default:
+      ;
+      int w[b];
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/call-diag-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/call-diag-1.c
new file mode 100644
index 000000000..884baa0d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/call-diag-1.c
@@ -0,0 +1,9 @@
+/* The warning for calling through a non-compatible type must not
+   disable the normal diagnostics from comparing the argument list
+   against the type of the called expression.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void foo (void);
+void bar (void) { ((long (*)(int))foo) (); } /* { dg-error "too few arguments to function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/case-const-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/case-const-1.c
new file mode 100644
index 000000000..ba39d0961
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/case-const-1.c
@@ -0,0 +1,15 @@
+/* Test for case labels not integer constant expressions but folding
+   to integer constants (used in Linux kernel, PR 39613).  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern int i;
+void
+f (int c)
+{
+  switch (c)
+    {
+    case (1 ? 1 : i):
+      ;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-1.c
new file mode 100644
index 000000000..7b12ad9f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-1.c
@@ -0,0 +1,41 @@
+/* Test diagnostics for bad or doubtful casts.  Test with no special
+   options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+struct s { int a; } sv;
+union u { int a; } uv;
+int i;
+long l;
+char c;
+void *p;
+float fv;
+
+void
+f (void)
+{
+  (int []) p; /* { dg-error "cast specifies array type" } */
+  (int ()) p; /* { dg-error "cast specifies function type" } */
+  (struct s) sv;
+  (union u) uv;
+  (struct s) i; /* { dg-error "conversion to non-scalar type requested" } */
+  (union u) i;
+  (union u) l; /* { dg-error "cast to union type from type not present in union" } */
+  (int) sv; /* { dg-error "aggregate value used where an integer was expected" } */
+  (int) uv; /* { dg-error "aggregate value used where an integer was expected" } */
+  (float) sv; /* { dg-error "aggregate value used where a float was expected" } */
+  (float) uv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Complex double) sv; /* { dg-error "aggregate value used where a complex was expected" } */
+  (_Complex double) uv; /* { dg-error "aggregate value used where a complex was expected" } */
+  (void *) sv; /* { dg-error "cannot convert to a pointer type" } */
+  (void *) uv; /* { dg-error "cannot convert to a pointer type" } */
+  (_Bool) sv; /* { dg-error "used struct type value where scalar is required" } */
+  (_Bool) uv; /* { dg-error "used union type value where scalar is required" } */
+  (void) sv;
+  (const void) uv;
+  (void *) c; /* { dg-warning "cast to pointer from integer of different size" } */
+  (void *) (char) 1;
+  (char) p; /* { dg-warning "cast from pointer to integer of different size" } */
+  (char) (void *) 1; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-2.c
new file mode 100644
index 000000000..f7f58f8a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-2.c
@@ -0,0 +1,41 @@
+/* Test diagnostics for bad or doubtful casts.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+struct s { int a; } sv;
+union u { int a; } uv;
+int i;
+long l;
+char c;
+void *p;
+float fv;
+
+void
+f (void)
+{
+  (int []) p; /* { dg-error "cast specifies array type" } */
+  (int ()) p; /* { dg-error "cast specifies function type" } */
+  (struct s) sv; /* { dg-warning "ISO C forbids casting nonscalar to the same type" } */
+  (union u) uv; /* { dg-warning "ISO C forbids casting nonscalar to the same type" } */
+  (struct s) i; /* { dg-error "conversion to non-scalar type requested" } */
+  (union u) i; /* { dg-warning "ISO C forbids casts to union type" } */
+  (union u) l; /* { dg-error "cast to union type from type not present in union" } */
+  (int) sv; /* { dg-error "aggregate value used where an integer was expected" } */
+  (int) uv; /* { dg-error "aggregate value used where an integer was expected" } */
+  (float) sv; /* { dg-error "aggregate value used where a float was expected" } */
+  (float) uv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Complex double) sv; /* { dg-error "aggregate value used where a complex was expected" } */
+  (_Complex double) uv; /* { dg-error "aggregate value used where a complex was expected" } */
+  (void *) sv; /* { dg-error "cannot convert to a pointer type" } */
+  (void *) uv; /* { dg-error "cannot convert to a pointer type" } */
+  (_Bool) sv; /* { dg-error "used struct type value where scalar is required" } */
+  (_Bool) uv; /* { dg-error "used union type value where scalar is required" } */
+  (void) sv;
+  (const void) uv;
+  (void *) c; /* { dg-warning "cast to pointer from integer of different size" } */
+  (void *) (char) 1;
+  (char) p; /* { dg-warning "cast from pointer to integer of different size" } */
+  (char) (void *) 1; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-3.c
new file mode 100644
index 000000000..40d3c88c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-3.c
@@ -0,0 +1,41 @@
+/* Test diagnostics for bad or doubtful casts.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+struct s { int a; } sv;
+union u { int a; } uv;
+int i;
+long l;
+char c;
+void *p;
+float fv;
+
+void
+f (void)
+{
+  (int []) p; /* { dg-error "cast specifies array type" } */
+  (int ()) p; /* { dg-error "cast specifies function type" } */
+  (struct s) sv; /* { dg-error "ISO C forbids casting nonscalar to the same type" } */
+  (union u) uv; /* { dg-error "ISO C forbids casting nonscalar to the same type" } */
+  (struct s) i; /* { dg-error "conversion to non-scalar type requested" } */
+  (union u) i; /* { dg-error "ISO C forbids casts to union type" } */
+  (union u) l; /* { dg-error "cast to union type from type not present in union" } */
+  (int) sv; /* { dg-error "aggregate value used where an integer was expected" } */
+  (int) uv; /* { dg-error "aggregate value used where an integer was expected" } */
+  (float) sv; /* { dg-error "aggregate value used where a float was expected" } */
+  (float) uv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Complex double) sv; /* { dg-error "aggregate value used where a complex was expected" } */
+  (_Complex double) uv; /* { dg-error "aggregate value used where a complex was expected" } */
+  (void *) sv; /* { dg-error "cannot convert to a pointer type" } */
+  (void *) uv; /* { dg-error "cannot convert to a pointer type" } */
+  (_Bool) sv; /* { dg-error "used struct type value where scalar is required" } */
+  (_Bool) uv; /* { dg-error "used union type value where scalar is required" } */
+  (void) sv;
+  (const void) uv;
+  (void *) c; /* { dg-warning "cast to pointer from integer of different size" } */
+  (void *) (char) 1;
+  (char) p; /* { dg-warning "cast from pointer to integer of different size" } */
+  (char) (void *) 1; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-4.c
new file mode 100644
index 000000000..ebc84c11c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-4.c
@@ -0,0 +1,13 @@
+/* Test warnings when casting from a constant integer to pointer.  
+   Test with -pedantic-errors.  */
+/* Origin: Carlos O'Donell <carlos@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+extern int i;
+char c;
+void
+f (void)
+{
+  c = (char)&i; /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-function-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-function-1.c
new file mode 100644
index 000000000..8ed7d5da4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-function-1.c
@@ -0,0 +1,49 @@
+/* PR c/12085 */
+/* Origin: David Hollenberg <dhollen@mosis.org> */
+
+/* Verify that the compiler doesn't inline a function at
+   a calling point where it is viewed with a different
+   prototype than the actual one.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+int foo1(int);
+int foo2();
+
+typedef struct {
+  double d;
+  int a;
+} str_t;
+
+void bar(void)
+{
+  double d;
+  int i;
+  str_t s;
+
+  d = ((double (*) (int)) foo1) (i);  /* { dg-warning "non-compatible|abort" } */
+  i = ((int (*) (double)) foo1) (d);  /* { dg-warning "non-compatible|abort" } */
+  s = ((str_t (*) (int)) foo1) (i);   /* { dg-warning "non-compatible|abort" } */
+  ((void (*) (int)) foo1) (d);        /* { dg-warning "non-compatible|abort" } */
+  i = ((int (*) (int)) foo1) (i);     /* { dg-bogus "non-compatible|abort" } */
+  (void) foo1 (i);                    /* { dg-bogus "non-compatible|abort" } */
+
+  d = ((double (*) (int)) foo2) (i);  /* { dg-warning "non-compatible|abort" } */
+  i = ((int (*) (double)) foo2) (d);  /* { dg-bogus "non-compatible|abort" } */
+  s = ((str_t (*) (int)) foo2) (i);   /* { dg-warning "non-compatible|abort" } */
+  ((void (*) (int)) foo2) (d);        /* { dg-warning "non-compatible|abort" } */
+  i = ((int (*) (int)) foo2) (i);     /* { dg-bogus "non-compatible|abort" } */
+  (void) foo2 (i);                    /* { dg-bogus "non-compatible|abort" } */
+}
+
+int foo1(int arg)
+{
+  return arg;
+}
+
+int foo2(arg)
+  int arg;
+{
+  return arg;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-lvalue-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-lvalue-1.c
new file mode 100644
index 000000000..4e84804e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-lvalue-1.c
@@ -0,0 +1,13 @@
+/* Test for deprecation of casts as lvalues.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int x;
+
+void
+foo (void)
+{
+  (char) x = 1; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "lvalue" "cast as lvalue" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-lvalue-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-lvalue-2.c
new file mode 100644
index 000000000..d4db4bd6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-lvalue-2.c
@@ -0,0 +1,13 @@
+/* Test for error on casts as lvalues.  Casts to same type.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int x;
+
+void
+foo (void)
+{
+  (int) x = 1; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "lvalue" "cast as lvalue" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-pretty-print-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-pretty-print-1.c
new file mode 100644
index 000000000..b9da56674
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-pretty-print-1.c
@@ -0,0 +1,12 @@
+/* Test pretty-printing of casts.  Should not depend on whether
+   NOP_EXPR or CONVERT_EXPR is used.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+int i;
+void
+f (void)
+{
+  ((unsigned int)i)(); /* { dg-error "called object '\\(unsigned int\\)i' is not a function" } */
+  ((char)i)(); /* { dg-error "called object '\\(char\\)i' is not a function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-qual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-qual-1.c
new file mode 100644
index 000000000..407d138d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-qual-1.c
@@ -0,0 +1,30 @@
+/* Incorrect `cast discards `const'' warnings.  There should be warnings
+   in bad_cast and bad_assign; bad_assign gets the correct warning, but
+   good_cast may get the warning instead of bad_cast.
+   gcc 2.7.2.3 passes, egcs-1.1.2 and egcs-ss-19990428 fail.
+   http://gcc.gnu.org/ml/gcc-bugs/1998-08/msg00645.html */
+/* { dg-do compile } */
+/* { dg-options "-Wcast-qual" } */
+void
+good_cast(const void *bar)
+{
+  (char *const *)bar; /* { dg-bogus "cast discards" "discarding `const' warning" } */
+}
+
+void
+bad_cast(const void *bar)
+{
+  (const char **)bar; /* { dg-warning "cast discards" "discarding `const' warning" } */
+}
+
+void
+good_assign(const void *bar)
+{
+  char *const *foo = bar; /* { dg-bogus "initialization discards" "discarding `const' warning" } */
+}
+
+void
+bad_assign(const void *bar)
+{
+  const char **foo = bar; /* { dg-warning "initialization discards" "discarding `const' warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-qual-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-qual-2.c
new file mode 100644
index 000000000..0be1d6171
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cast-qual-2.c
@@ -0,0 +1,34 @@
+/* Test whether the -Wcast-qual handles cv-qualified functions correctly.  */
+/* { dg-do compile } */
+/* { dg-options "-Wcast-qual" } */
+
+typedef int (intfn_t) (int);
+typedef void (voidfn_t) (void);
+
+typedef const intfn_t *constfn_t;
+typedef volatile voidfn_t *noreturnfn_t;
+
+intfn_t intfn;
+const intfn_t constfn;
+voidfn_t voidfn;
+volatile voidfn_t noreturnfn;
+
+intfn_t *i1 = intfn;
+intfn_t *i2 = (intfn_t *) intfn;
+intfn_t *i3 = constfn;
+intfn_t *i4 = (intfn_t *) constfn; /* { dg-bogus "discards qualifier" } */
+
+constfn_t p1 = intfn; /* { dg-warning "makes qualified function" } */
+constfn_t p2 = (constfn_t) intfn; /* { dg-warning "new qualifier" } */
+constfn_t p3 = constfn;
+constfn_t p4 = (constfn_t) constfn;
+
+voidfn_t *v1 = voidfn;
+voidfn_t *v2 = (voidfn_t *) voidfn;
+voidfn_t *v3 = noreturnfn;
+voidfn_t *v4 = (voidfn_t *) noreturnfn; /* { dg-bogus "discards qualifier" } */
+
+noreturnfn_t n1 = voidfn; /* { dg-warning "makes qualified function" } */
+noreturnfn_t n2 = (noreturnfn_t) voidfn; /* { dg-warning "new qualifier" } */
+noreturnfn_t n3 = noreturnfn;
+noreturnfn_t n4 = (noreturnfn_t) noreturnfn;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cdce1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cdce1.c
new file mode 100644
index 000000000..3a10dd02e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cdce1.c
@@ -0,0 +1,81 @@
+/* { dg-do  run  } */
+/* { dg-skip-if "doubles are floats" { "avr-*-*" "m32c-*-*" } { "*" } { "" } } */
+/* { dg-options "-O2 -fmath-errno -fdump-tree-cdce-details  -lm" } */
+/* { dg-options "-O2 -fmath-errno -fdump-tree-cdce-details" { target *-*-netware* } } */
+/* { dg-final { scan-tree-dump  "cdce1.c:17: note: function call is shrink-wrapped into error conditions\."  "cdce" } } */
+/* { dg-final { cleanup-tree-dump "cdce" } } */
+
+#include <stdlib.h>
+#include <math.h>
+#include <errno.h>
+int total_err_count = 0;
+double foo_opt (int x, double y) __attribute__((noinline));
+double foo_opt (int x, double y)
+{
+  double yy = 0;
+  errno = 0;
+  yy = pow (x, y * y);
+  return 0;
+}
+
+double foo (int x, double y) __attribute__((noinline));
+double foo (int x, double y)
+{
+  double yy = 0;
+  errno = 0;
+  yy = pow (x, y * y);
+  return yy;
+}
+
+int test (double (*fp)(int x, double y))
+{
+  int i,x;
+  
+  x = 127; 
+  for (i = 30; i < 300; i++)
+    {  
+      fp (x, i);
+      if (errno)
+        total_err_count ++;
+    }
+  
+  x = -300; 
+  for (i = 100; i < 300; i++)
+    {  
+      fp (x, i);
+      if (errno)
+        total_err_count ++;
+    }
+
+   x = 65577;
+   for (i = 60; i < 200; i++)
+     {  
+       fp (x, i);
+       if (errno)
+         total_err_count ++;
+     }
+
+   x = 65577 * 127;
+   for (i = 1; i < 100; i++)
+     {  
+       fp (x, i);
+       if (errno)
+         total_err_count ++;
+     }
+
+   return total_err_count;
+}
+
+int main ()
+{
+  int en1, en2;
+  total_err_count = 0;
+  en1 = test (foo_opt);
+  total_err_count = 0;
+  en2 = test (foo);
+  
+  if (en1 != en2)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cdce2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cdce2.c
new file mode 100644
index 000000000..eebebaa23
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cdce2.c
@@ -0,0 +1,56 @@
+/* { dg-do  run  } */
+/* { dg-skip-if "doubles are floats" { "avr-*-*" } { "*" } { "" } } */
+/* { dg-options "-O2 -fmath-errno -fdump-tree-cdce-details  -lm" } */
+/* { dg-options "-O2 -fmath-errno -fdump-tree-cdce-details" { target *-*-netware* } } */
+/* { dg-final { scan-tree-dump  "cdce2.c:17: note: function call is shrink-wrapped into error conditions\." "cdce" } }*/
+/* { dg-final { cleanup-tree-dump "cdce" } } */
+ 
+#include <stdlib.h>
+#include <math.h>
+#include <errno.h>
+int total_err_count = 0;
+double foo_opt (double y) __attribute__((noinline));
+double foo_opt (double y)
+{
+  double yy = 0;
+  errno = 0;
+  yy = log (y);
+  return 0;
+}
+
+double foo (double y) __attribute__((noinline));
+double foo (double y)
+{
+  double yy = 0;
+  errno = 0;
+  yy = log (y);
+  return yy;
+}
+
+int test (double (*fp) (double y))
+{
+  int i,x;
+  for (i = -100; i < 100; i++)
+    {  
+      fp (i);
+      if (errno)
+        total_err_count ++;
+    }
+
+  return total_err_count;
+}
+
+int main ()
+{
+  int en1, en2;
+  double yy;
+  total_err_count = 0;
+  en1 = test (foo_opt);
+  total_err_count = 0;
+  en2 = test (foo);
+
+  if (en1 != en2)
+    abort();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/char-compare.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/char-compare.c
new file mode 100644
index 000000000..f8b2fb968
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/char-compare.c
@@ -0,0 +1,23 @@
+/* PR rtl-optimization/23241 */
+/* Origin: Josh Conner <jconner@apple.com> */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort(void);
+
+struct fbs {
+  unsigned char uc;
+} fbs1 = {255};
+
+void fn(struct fbs *fbs_ptr)
+{
+  if ((fbs_ptr->uc != 255) && (fbs_ptr->uc != 0))
+    abort();
+}
+
+int main(void)
+{
+  fn(&fbs1); 
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm1.c
new file mode 100644
index 000000000..dfd140186
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler ".ascii bar" } }
+   { dg-final { scan-assembler ".ascii foo" } }
+ */
+extern int x, y;
+
+asm (".ascii bar");
+
+int foo (void)
+{
+  __asm__ (".ascii foo");
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm2.c
new file mode 100644
index 000000000..a9a9c011b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm2.c
@@ -0,0 +1,16 @@
+/* Test for execution character set encoding errors.
+   If we ever get a good way to test error recovery
+   the string "foobar" should be translated.  */
+/* { dg-do compile } */
+/* { dg-require-iconv "IBM1047" } */
+asm (not_a_string); /* { dg-error "(parse error|syntax error|expected string literal) before" "not_a_string" } */
+char x[] = "foobar";
+
+void foo (void)
+{
+  char *y;
+  asm (not_a_string2); /* { dg-error "(parse error|syntax error|expected string literal) before" "not_a_string" } */
+
+#define FOO "walrus"
+  y = FOO;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm3.c
new file mode 100644
index 000000000..842bd5cfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm3.c
@@ -0,0 +1,33 @@
+/* Test for complex asm statements. Make sure it compiles
+   then test for some of the asm statements not being translated.  */
+/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && ilp32 } } }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler "std" } }
+   { dg-final { scan-assembler "cld" } }
+   { dg-final { scan-assembler "rep" } }
+   { dg-final { scan-assembler "movsb" } } */
+#define size_t int
+void *
+memmove (void *__dest, __const void *__src, size_t __n)
+{
+  register unsigned long int __d0, __d1, __d2;
+  if (__dest < __src)
+    __asm__ __volatile__
+      ("cld\n\t"
+       "rep\n\t"
+       "movsb"
+       : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
+       : "0" (__n), "1" (__src), "2" (__dest)
+       : "memory");
+  else
+    __asm__ __volatile__
+      ("std\n\t"
+       "rep\n\t"
+       "movsb\n\t"
+       "cld"
+       : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
+       : "0" (__n), "1" (__n - 1 + (const char *) __src),
+         "2" (__n - 1 + (char *) __dest)
+       : "memory");
+  return __dest;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm4.c
new file mode 100644
index 000000000..59c8d59ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm4.c
@@ -0,0 +1,10 @@
+/* Simple asm test.  */
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler "foo" } } */
+extern int bar;
+
+int main (void)
+{
+  asm ("foo %0" : "=r" (bar));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm5.c
new file mode 100644
index 000000000..a4bb01401
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm5.c
@@ -0,0 +1,8 @@
+/* Test for string translation.  */
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler-not "translate" } } */
+void foo (void)
+{
+  asm ("xx" : : "r"("translate") : "cc");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm6.c
new file mode 100644
index 000000000..ae2ec485d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/asm6.c
@@ -0,0 +1,13 @@
+/* Test for string translation.  */
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" } 
+   { dg-final { scan-assembler "foo" } } */
+int main()
+{
+  unsigned long int *ptr;
+  ptr = ((unsigned long int *)
+         ( { void *stack_ptr;
+           __asm__ __volatile__ ( "foo %0" : "=r" (stack_ptr) );
+           (stack_ptr); } ) );
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/attribute1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/attribute1.c
new file mode 100644
index 000000000..799630030
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/attribute1.c
@@ -0,0 +1,10 @@
+/* Test for attribute non-translation.  */
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler "foo" } } */
+int walrus __attribute__ ((section (".foo")));
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/attribute2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/attribute2.c
new file mode 100644
index 000000000..427e94979
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/attribute2.c
@@ -0,0 +1,8 @@
+/* Test to make sure that invalid attributes aren't translated.
+   If error recovery is ever testable then "foobar" should be
+   translated.  */
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+ */
+int foo __attribute__ ((walrus)); /* { dg-warning "walrus" "ignored" } */
+char x[] = "foobar";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/builtin1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/builtin1.c
new file mode 100644
index 000000000..753049c96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/builtin1.c
@@ -0,0 +1,26 @@
+/* isdigit(c) can be optimized to ((unsigned)c) - '0' <= 9, but only if
+   we know the correct value of '0'.  PR 18785.  */
+
+/* { dg-do run } */
+/* { dg-require-iconv "IBM1047" } */
+/* { dg-options "-O2 -fno-inline -fexec-charset=IBM1047" } */
+
+extern int isdigit(int);
+extern void abort(void);
+
+static int str1(void) { return '1'; }
+static int strA(void) { return 'A'; }
+
+int
+main(void)
+{
+  if (!isdigit('1'))
+    abort();
+  if (isdigit('A'))
+    abort();
+  if (!isdigit(str1()))
+    abort();
+  if (isdigit(strA()))
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/builtin2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/builtin2.c
new file mode 100644
index 000000000..bfe9a20e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/builtin2.c
@@ -0,0 +1,32 @@
+/* Ensure that transformations of *printf are performed correctly
+   regardless of -fexec-charset.  See PR 25120.  */
+
+/* { dg-do compile } */
+/* { dg-require-iconv "IBM1047" } */
+/* { dg-options "-O2 -fexec-charset=IBM1047" } */
+/* { dg-final { scan-assembler-not "printf" } } */
+/* { dg-final { scan-assembler-not "fprintf" } } */
+/* { dg-final { scan-assembler-not "sprintf" } } */
+
+#include <stdio.h>
+
+void foo (char *dst, const char *src)
+{
+  printf ("\n");
+  printf ("hello world\n");
+  printf ("%s", "\n");
+  printf ("%s", "hello world\n");
+  printf ("%c", '\n');
+  printf ("%s\n", "hello world");
+  printf ("%s\n", src);
+  
+  fprintf (stdout, "\n");
+  fprintf (stdout, "hello world\n");
+  fprintf (stdout, "%s", "\n");
+  fprintf (stdout, "%s", "hello world\n");
+  fprintf (stdout, "%c", '\n');
+  fprintf (stdout, "%s", src);
+
+  sprintf (dst, "hello world\n");
+  sprintf (dst, "%s", src);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/charset.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/charset.exp
new file mode 100644
index 000000000..7e3a1348e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/charset.exp
@@ -0,0 +1,44 @@
+#   Copyright (C) 2004, 2007 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/>.
+
+# GCC testsuite that uses the 'dg.exp' driver.
+
+# There's a bunch of headers we need.
+if [is_remote host] {
+    foreach header [glob -nocomplain $srcdir/$subdir/*.{h,def} ] {
+        remote_download host $header
+    }
+}
+
+# Load support procs.
+load_lib gcc-dg.exp
+load_lib target-supports.exp
+
+# If a testcase doesn't have special options, use these.
+global DEFAULT_CHARSETCFLAGS
+if ![info exists DEFAULT_CHARSETCFLAGS] then {
+    set DEFAULT_CHARSETCFLAGS "-fexec-charset=IBM1047"
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.{c,S} ]] \
+        "" $DEFAULT_CHARSETCFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/extern.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/extern.c
new file mode 100644
index 000000000..05a0c3e42
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/extern.c
@@ -0,0 +1,11 @@
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler-not "abcdefghijklmnopqrstuvwxyz" } } */
+
+extern char *bar;
+
+extern void foo (void)
+{
+   char str[]="abcdefghijklmnopqrstuvwxyz";
+   bar = str;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/function.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/function.c
new file mode 100644
index 000000000..5aba6511b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/function.c
@@ -0,0 +1,10 @@
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler-not "\"foobar\"" } } */
+
+const char *str;
+
+void foobar (void)
+{
+  str = __FUNCTION__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/string.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/string.c
new file mode 100644
index 000000000..f720773dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/charset/string.c
@@ -0,0 +1,5 @@
+/* Simple character translation test.  */
+/* { dg-do compile }
+   { dg-require-iconv "IBM1047" }
+   { dg-final { scan-assembler-not "string foobar" } } */
+char *foo = "string foobar";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-1.c
new file mode 100644
index 000000000..dd571635b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-1.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+/* Validate expected warnings and errors.  */
+
+#define U	__attribute__((unused))
+#define C(x)	__attribute__((cleanup(x)))
+
+static int f1(void *x U) { return 0; }
+static void f2() { }
+static void f3(void) { }
+static void f4(void *x U) { }
+static void f5(int *x U) { }
+static void f6(double *x U) { } /* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" } */
+static void f7(const int *x U) { }
+static void f8(const int *x U, int y U) { }
+static void f9(int x U) { } /* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" } */
+
+void test(void)
+{
+  int o1 C(f1);
+  int o2 C(f2);
+  int o3 C(f3);		/* { dg-error "too many arguments" } */
+  int o4 C(f4);
+  int o5 C(f5);
+  int o6 C(f6);		/* { dg-warning "incompatible pointer type" } */
+  int o7 C(f7);
+  int o8 C(f8);		/* { dg-error "too few arguments" } */
+  int o9 C(f9);		/* { dg-warning "from pointer without a cast" } */
+  int o10 U C(undef);	/* { dg-error "not a function" } */
+  int o11 U C(o1);	/* { dg-error "not a function" } */
+  int o12 U C("f1");	/* { dg-error "not an identifier" } */
+  static int o13 U C(f1); /* { dg-warning "attribute ignored" } */
+}
+
+int o14 C(f1);		/* { dg-warning "attribute ignored" } */
+void t15(int o U C(f1)) {} /* { dg-warning "attribute ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-10.c
new file mode 100644
index 000000000..11b7403f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-10.c
@@ -0,0 +1,116 @@
+/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */
+/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */
+/* Verify that cleanups work with exception handling through signal frames
+   on alternate stack.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+                   _Unwind_Exception_Class exc_class,
+                   struct _Unwind_Exception *exc_obj,
+                   struct _Unwind_Context *context,
+                   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind ()
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+                   
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+                   
+  abort ();
+}
+
+int count;
+char *null;
+
+static void counter (void *p __attribute__((unused)))
+{
+  ++count;
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  if (count != 2)
+    abort ();
+  exit (0);
+}
+
+static int __attribute__((noinline)) fn5 ()
+{
+  char dummy __attribute__((cleanup (counter)));
+  force_unwind ();
+  return 0;
+}
+
+static void fn4 (int sig, siginfo_t *info, void *ctx)
+{
+  char dummy __attribute__((cleanup (counter)));
+  fn5 ();
+  null = NULL;
+}
+
+static void fn3 ()
+{
+  abort ();
+}
+
+static int __attribute__((noinline)) fn2 ()
+{
+  *null = 0;
+  fn3 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn1 ()
+{
+  stack_t ss;
+  struct sigaction s;
+
+  ss.ss_size = 4 * sysconf (_SC_PAGESIZE);
+  if (ss.ss_size < SIGSTKSZ)
+    ss.ss_size = SIGSTKSZ;
+  ss.ss_sp = malloc (ss.ss_size);
+  if (ss.ss_sp == NULL)
+    exit (1);
+  ss.ss_flags = 0;
+  if (sigaltstack (&ss, NULL) < 0)
+    exit (1);
+
+  sigemptyset (&s.sa_mask);
+  s.sa_sigaction = fn4;
+  s.sa_flags = SA_RESETHAND | SA_ONSTACK;
+  sigaction (SIGSEGV, &s, NULL);
+  sigaction (SIGBUS, &s, NULL);
+  fn2 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn0 ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  fn1 ();
+  null = 0;
+  return 0;
+}
+
+int main()
+{ 
+  fn0 ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-11.c
new file mode 100644
index 000000000..d0c78d577
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-11.c
@@ -0,0 +1,116 @@
+/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */
+/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */
+/* Verify that cleanups work with exception handling through realtime signal
+   frames on alternate stack.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+                   _Unwind_Exception_Class exc_class,
+                   struct _Unwind_Exception *exc_obj,
+                   struct _Unwind_Context *context,
+                   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind ()
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+                   
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+                   
+  abort ();
+}
+
+int count;
+char *null;
+
+static void counter (void *p __attribute__((unused)))
+{
+  ++count;
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  if (count != 2)
+    abort ();
+  exit (0);
+}
+
+static int __attribute__((noinline)) fn5 ()
+{
+  char dummy __attribute__((cleanup (counter)));
+  force_unwind ();
+  return 0;
+}
+
+static void fn4 (int sig, siginfo_t *info, void *ctx)
+{
+  char dummy __attribute__((cleanup (counter)));
+  fn5 ();
+  null = NULL;
+}
+
+static void fn3 ()
+{
+  abort ();
+}
+
+static int __attribute__((noinline)) fn2 ()
+{
+  *null = 0;
+  fn3 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn1 ()
+{
+  stack_t ss;
+  struct sigaction s;
+
+  ss.ss_size = 4 * sysconf (_SC_PAGESIZE);
+  if (ss.ss_size < SIGSTKSZ)
+    ss.ss_size = SIGSTKSZ;
+  ss.ss_sp = malloc (ss.ss_size);
+  if (ss.ss_sp == NULL)
+    exit (1);
+  ss.ss_flags = 0;
+  if (sigaltstack (&ss, NULL) < 0)
+    exit (1);
+
+  sigemptyset (&s.sa_mask);
+  s.sa_sigaction = fn4;
+  s.sa_flags = SA_RESETHAND | SA_ONSTACK | SA_SIGINFO;
+  sigaction (SIGSEGV, &s, NULL);
+  sigaction (SIGBUS, &s, NULL);
+  fn2 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn0 ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  fn1 ();
+  null = 0;
+  return 0;
+}
+
+int main()
+{ 
+  fn0 ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-12.c
new file mode 100644
index 000000000..90de90ac8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-12.c
@@ -0,0 +1,69 @@
+/* PR middle-end/32758 */
+/* HP-UX libunwind.so doesn't provide _UA_END_OF_STACK */
+/* { dg-do run } */
+/* { dg-options "-O2 -fexceptions" } */
+/* { dg-skip-if "" { "ia64-*-hpux11.*" }  { "*" } { "" } } */
+/* Verify unwind info in presence of alloca.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <string.h>
+
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+		   _Unwind_Exception_Class exc_class,
+		   struct _Unwind_Exception *exc_obj,
+		   struct _Unwind_Context *context,
+		   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind (void)
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+
+  abort ();
+}
+
+__attribute__((noinline))
+void foo (void *x __attribute__((unused)))
+{
+  force_unwind ();
+}
+
+__attribute__((noinline))
+int bar (unsigned int x)
+{
+  void *y = __builtin_alloca (x);
+  foo (y);
+  return 1;
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  exit (0);
+}
+
+__attribute__((noinline))
+static void doit ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  bar (1024);
+}
+
+int main ()
+{
+  doit ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-13.c
new file mode 100644
index 000000000..5a0d4c69f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-13.c
@@ -0,0 +1,332 @@
+/* HP-UX libunwind.so doesn't provide _UA_END_OF_STACK */
+/* { dg-do run } */
+/* { dg-options "-fexceptions" } */
+/* { dg-skip-if "" { "ia64-*-hpux11.*" }  { "*" } { "" } } */
+/* Verify DW_OP_* handling in the unwinder.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* #define OP_addr(x) 0x06, ... */
+#define OP_deref 0x06,
+#define SLEB128(x) (x)&0x7f	/* Assume here the value is -0x40 ... 0x3f.  */
+#define ULEB128(x) (x)&0x7f	/* Assume here the value is 0 ... 0x7f.  */
+#define VAL1(x) (x)&0xff
+#if defined (__BIG_ENDIAN__)
+#define VAL2(x) ((x)>>8)&0xff,(x)&0xff
+#define VAL4(x) ((x)>>24)&0xff,((x)>>16)&0xff,((x)>>8)&0xff,(x)&0xff
+#define VAL8(x) ((x)>>56)&0xff,((x)>>48)&0xff,((x)>>40)&0xff,((x)>>32)&0xff,((x)>>24)&0xff,((x)>>16)&0xff,((x)>>8)&0xff,(x)&0xff
+#elif defined(__LITTLE_ENDIAN__) || defined(__x86_64__) || defined(__i386__)
+#define VAL2(x) (x)&0xff,((x)>>8)&0xff
+#define VAL4(x) (x)&0xff,((x)>>8)&0xff,((x)>>16)&0xff,((x)>>24)&0xff
+#define VAL8(x) (x)&0xff,((x)>>8)&0xff,((x)>>16)&0xff,((x)>>24)&0xff,((x)>>32)&0xff,((x)>>40)&0xff,((x)>>48)&0xff,((x)>>56)&0xff
+#endif
+#define OP_const1u(x) 0x08,VAL1(x),
+#define OP_const1s(x) 0x09,VAL1(x),
+#define OP_const2u(x) 0x0a,VAL2(x),
+#define OP_const2s(x) 0x0b,VAL2(x),
+#define OP_const4u(x) 0x0c,VAL4(x),
+#define OP_const4s(x) 0x0d,VAL4(x),
+#define OP_const8u(x) 0x0e,VAL8(x),
+#define OP_const8s(x) 0x0f,VAL8(x),
+#define OP_constu(x) 0x10,ULEB128(x),
+#define OP_consts(x) 0x11,SLEB128(x),
+#define OP_dup 0x12,
+#define OP_drop 0x13,
+#define OP_over 0x14,
+#define OP_pick(x) 0x15,VAL1(x),
+#define OP_swap 0x16,
+#define OP_rot 0x17,
+#define OP_xderef 0x18,
+#define OP_abs 0x19,
+#define OP_and 0x1a,
+#define OP_div 0x1b,
+#define OP_minus 0x1c,
+#define OP_mod 0x1d,
+#define OP_mul 0x1e,
+#define OP_neg 0x1f,
+#define OP_not 0x20,
+#define OP_or 0x21,
+#define OP_plus 0x22,
+#define OP_plus_uconst(x) 0x23,ULEB128(x),
+#define OP_shl 0x24,
+#define OP_shr 0x25,
+#define OP_shra 0x26,
+#define OP_xor 0x27,
+#define OP_bra(x) 0x28,VAL2(x),
+#define OP_eq 0x29,
+#define OP_ge 0x2a,
+#define OP_gt 0x2b,
+#define OP_le 0x2c,
+#define OP_lt 0x2d,
+#define OP_ne 0x2e,
+#define OP_skip(x) 0x2f,VAL2(x),
+#define OP_lit0 0x30,
+#define OP_lit1 0x31,
+#define OP_lit2 0x32,
+#define OP_lit3 0x33,
+#define OP_lit4 0x34,
+#define OP_lit5 0x35,
+#define OP_lit6 0x36,
+#define OP_lit7 0x37,
+#define OP_lit8 0x38,
+#define OP_lit9 0x39,
+#define OP_lit10 0x3a,
+#define OP_lit11 0x3b,
+#define OP_lit12 0x3c,
+#define OP_lit13 0x3d,
+#define OP_lit14 0x3e,
+#define OP_lit15 0x3f,
+#define OP_lit16 0x40,
+#define OP_lit17 0x41,
+#define OP_lit18 0x42,
+#define OP_lit19 0x43,
+#define OP_lit20 0x44,
+#define OP_lit21 0x45,
+#define OP_lit22 0x46,
+#define OP_lit23 0x47,
+#define OP_lit24 0x48,
+#define OP_lit25 0x49,
+#define OP_lit26 0x4a,
+#define OP_lit27 0x4b,
+#define OP_lit28 0x4c,
+#define OP_lit29 0x4d,
+#define OP_lit30 0x4e,
+#define OP_lit31 0x4f,
+#define OP_reg0 0x50,
+#define OP_reg1 0x51,
+#define OP_reg2 0x52,
+#define OP_reg3 0x53,
+#define OP_reg4 0x54,
+#define OP_reg5 0x55,
+#define OP_reg6 0x56,
+#define OP_reg7 0x57,
+#define OP_reg8 0x58,
+#define OP_reg9 0x59,
+#define OP_reg10 0x5a,
+#define OP_reg11 0x5b,
+#define OP_reg12 0x5c,
+#define OP_reg13 0x5d,
+#define OP_reg14 0x5e,
+#define OP_reg15 0x5f,
+#define OP_reg16 0x60,
+#define OP_reg17 0x61,
+#define OP_reg18 0x62,
+#define OP_reg19 0x63,
+#define OP_reg20 0x64,
+#define OP_reg21 0x65,
+#define OP_reg22 0x66,
+#define OP_reg23 0x67,
+#define OP_reg24 0x68,
+#define OP_reg25 0x69,
+#define OP_reg26 0x6a,
+#define OP_reg27 0x6b,
+#define OP_reg28 0x6c,
+#define OP_reg29 0x6d,
+#define OP_reg30 0x6e,
+#define OP_reg31 0x6f,
+#define OP_breg0(x) 0x70,SLEB128(x),
+#define OP_breg1(x) 0x71,SLEB128(x),
+#define OP_breg2(x) 0x72,SLEB128(x),
+#define OP_breg3(x) 0x73,SLEB128(x),
+#define OP_breg4(x) 0x74,SLEB128(x),
+#define OP_breg5(x) 0x75,SLEB128(x),
+#define OP_breg6(x) 0x76,SLEB128(x),
+#define OP_breg7(x) 0x77,SLEB128(x),
+#define OP_breg8(x) 0x78,SLEB128(x),
+#define OP_breg9(x) 0x79,SLEB128(x),
+#define OP_breg10(x) 0x7a,SLEB128(x),
+#define OP_breg11(x) 0x7b,SLEB128(x),
+#define OP_breg12(x) 0x7c,SLEB128(x),
+#define OP_breg13(x) 0x7d,SLEB128(x),
+#define OP_breg14(x) 0x7e,SLEB128(x),
+#define OP_breg15(x) 0x7f,SLEB128(x),
+#define OP_breg16(x) 0x80,SLEB128(x),
+#define OP_breg17(x) 0x81,SLEB128(x),
+#define OP_breg18(x) 0x82,SLEB128(x),
+#define OP_breg19(x) 0x83,SLEB128(x),
+#define OP_breg20(x) 0x84,SLEB128(x),
+#define OP_breg21(x) 0x85,SLEB128(x),
+#define OP_breg22(x) 0x86,SLEB128(x),
+#define OP_breg23(x) 0x87,SLEB128(x),
+#define OP_breg24(x) 0x88,SLEB128(x),
+#define OP_breg25(x) 0x89,SLEB128(x),
+#define OP_breg26(x) 0x8a,SLEB128(x),
+#define OP_breg27(x) 0x8b,SLEB128(x),
+#define OP_breg28(x) 0x8c,SLEB128(x),
+#define OP_breg29(x) 0x8d,SLEB128(x),
+#define OP_breg30(x) 0x8e,SLEB128(x),
+#define OP_breg31(x) 0x8f,SLEB128(x),
+#define OP_regx(x) 0x90,SLEB128(x),
+#define OP_fbreg(x) 0x91,SLEB128(x),
+#define OP_bregx(x,y) 0x92,ULEB128(x),SLEB128(y),
+#define OP_piece(x) 0x93,ULEB128(x),
+#define OP_deref_size(x) 0x94,VAL1(x),
+#define OP_xderef_size(x) 0x95,VAL1(x),
+#define OP_nop 0x96,
+#define OP_nop_termination 0x96
+#define OP_push_object_address 0x97,
+#define OP_call2(x) 0x98,VAL2(x),
+#define OP_call4(x) 0x99,VAL4(x),
+/* #define OP_call_ref(x) 0x9a,... */
+#define OP_form_tls_address(x) 0x9b,
+#define OP_call_frame_cfa 0x9c,
+#define OP_bit_piece(x) 0x9d,ULEB128(x),
+/* #define OP_implicit_value(x...) 0x9e,... */
+#define OP_stack_value 0x9f,
+#define OP_GNU_push_tls_address 0xe0,
+/* #define OP_GNU_encoded_addr(x...) 0xf1, */
+
+#define ASSERT_TOS_NON0 OP_bra(3) OP_skip(-3)
+#define ASSERT_TOS_0 OP_lit0 OP_eq ASSERT_TOS_NON0
+
+/* Initially there is CFA value on the stack, we want to
+   keep it there at the end.  */
+#define CFI_PROGRAM \
+OP_lit0 OP_nop ASSERT_TOS_0						\
+OP_lit1 ASSERT_TOS_NON0							\
+OP_lit1 OP_const1u(1) OP_eq ASSERT_TOS_NON0				\
+OP_lit16 OP_const2u(16) OP_eq ASSERT_TOS_NON0				\
+OP_lit31 OP_const4u(31) OP_ne ASSERT_TOS_0				\
+OP_lit1 OP_neg OP_const1s(-1) OP_eq ASSERT_TOS_NON0			\
+OP_lit16 OP_neg OP_const2s(-16) OP_ne ASSERT_TOS_0			\
+OP_lit31 OP_const4s(-31) OP_neg OP_ne ASSERT_TOS_0			\
+OP_lit7 OP_dup OP_plus_uconst(2) OP_lit9 OP_eq ASSERT_TOS_NON0		\
+  OP_lit7 OP_eq ASSERT_TOS_NON0						\
+OP_lit20 OP_lit1 OP_drop OP_lit20 OP_eq ASSERT_TOS_NON0			\
+OP_lit17 OP_lit19 OP_over OP_lit17 OP_eq ASSERT_TOS_NON0		\
+  OP_lit19 OP_eq ASSERT_TOS_NON0 OP_lit17 OP_eq ASSERT_TOS_NON0		\
+OP_lit1 OP_lit2 OP_lit3 OP_lit4 OP_pick(2) OP_lit2 OP_eq ASSERT_TOS_NON0\
+  OP_lit4 OP_eq ASSERT_TOS_NON0 OP_lit3 OP_eq ASSERT_TOS_NON0		\
+  OP_pick(0) OP_lit2 OP_eq ASSERT_TOS_NON0				\
+  OP_lit2 OP_eq ASSERT_TOS_NON0 OP_lit1 OP_eq ASSERT_TOS_NON0		\
+OP_lit6 OP_lit12 OP_swap OP_lit6 OP_eq ASSERT_TOS_NON0			\
+  OP_lit12 OP_eq ASSERT_TOS_NON0					\
+OP_lit7 OP_lit8 OP_lit9 OP_rot OP_lit8 OP_eq ASSERT_TOS_NON0		\
+  OP_lit7 OP_eq ASSERT_TOS_NON0 OP_lit9 OP_eq ASSERT_TOS_NON0		\
+OP_lit7 OP_abs OP_lit7 OP_eq ASSERT_TOS_NON0				\
+OP_const1s(-123) OP_abs OP_const1u(123) OP_eq ASSERT_TOS_NON0		\
+OP_lit3 OP_lit6 OP_and OP_lit2 OP_eq ASSERT_TOS_NON0			\
+OP_lit3 OP_lit6 OP_or OP_lit7 OP_eq ASSERT_TOS_NON0			\
+OP_lit17 OP_lit2 OP_minus OP_lit15 OP_eq ASSERT_TOS_NON0		\
+/* Divide is signed truncating toward zero.  */				\
+OP_const1s(-6) OP_const1s(-2) OP_div OP_lit3 OP_eq ASSERT_TOS_NON0	\
+OP_const1s(-7) OP_const1s(3) OP_div OP_const1s(-2)			\
+  OP_eq ASSERT_TOS_NON0							\
+/* Modulo is unsigned.  */						\
+OP_const1s(-6) OP_const1s(-4) OP_mod OP_const1s(-6)			\
+  OP_eq ASSERT_TOS_NON0							\
+OP_const1s(-6) OP_lit4 OP_mod OP_lit2 OP_eq ASSERT_TOS_NON0		\
+OP_lit6 OP_const1s(-4) OP_mod OP_lit6 OP_eq ASSERT_TOS_NON0		\
+/* Signed modulo can be implemented using "over over div mul minus".  */\
+OP_const1s(-6) OP_const1s(-4) OP_over OP_over OP_div OP_mul OP_minus	\
+  OP_const1s(-2) OP_eq ASSERT_TOS_NON0					\
+OP_const1s(-7) OP_lit3 OP_over OP_over OP_div OP_mul OP_minus		\
+  OP_const1s(-1) OP_eq ASSERT_TOS_NON0					\
+OP_lit7 OP_const1s(-3) OP_over OP_over OP_div OP_mul OP_minus		\
+  OP_lit1 OP_eq ASSERT_TOS_NON0						\
+OP_lit16 OP_lit31 OP_plus_uconst(1) OP_mul OP_const2u(512)		\
+  OP_eq ASSERT_TOS_NON0							\
+OP_lit5 OP_not OP_lit31 OP_and OP_lit26 OP_eq ASSERT_TOS_NON0		\
+OP_lit12 OP_lit31 OP_plus OP_const1u(43) OP_eq ASSERT_TOS_NON0		\
+OP_const1s(-6) OP_lit2 OP_plus OP_const1s(-4) OP_eq ASSERT_TOS_NON0	\
+OP_const1s(-6) OP_plus_uconst(3) OP_const1s(-3) OP_eq ASSERT_TOS_NON0	\
+OP_lit16 OP_lit4 OP_shl OP_const2u(256) OP_eq ASSERT_TOS_NON0		\
+OP_lit16 OP_lit3 OP_shr OP_lit2 OP_eq ASSERT_TOS_NON0			\
+OP_const1s(-16) OP_lit3 OP_shra OP_const1s(-2) OP_eq ASSERT_TOS_NON0	\
+OP_lit3 OP_lit6 OP_xor OP_lit5 OP_eq ASSERT_TOS_NON0			\
+OP_lit3 OP_lit6 OP_le ASSERT_TOS_NON0					\
+OP_lit3 OP_lit3 OP_le ASSERT_TOS_NON0					\
+OP_lit6 OP_lit3 OP_le ASSERT_TOS_0					\
+OP_lit3 OP_lit6 OP_lt ASSERT_TOS_NON0					\
+OP_lit3 OP_lit3 OP_lt ASSERT_TOS_0					\
+OP_lit6 OP_lit3 OP_lt ASSERT_TOS_0					\
+OP_lit3 OP_lit6 OP_ge ASSERT_TOS_0					\
+OP_lit3 OP_lit3 OP_ge ASSERT_TOS_NON0					\
+OP_lit6 OP_lit3 OP_ge ASSERT_TOS_NON0					\
+OP_lit3 OP_lit6 OP_gt ASSERT_TOS_0					\
+OP_lit3 OP_lit3 OP_gt ASSERT_TOS_0					\
+OP_lit6 OP_lit3 OP_gt ASSERT_TOS_NON0					\
+OP_const1s(-6) OP_lit1 OP_shr OP_lit0 OP_gt ASSERT_TOS_NON0		\
+OP_const1s(-6) OP_lit1 OP_shra OP_lit0 OP_lt ASSERT_TOS_NON0
+
+#define CFI_ESCAPE_VAL_2(VALUES...) #VALUES
+#define CFI_ESCAPE_VAL_1(VALUES...) CFI_ESCAPE_VAL_2(VALUES)
+#define CFI_ESCAPE_VAL(VALUES...) CFI_ESCAPE_VAL_1(VALUES)
+#define CFI_ESCAPE do { } while (0)
+#define CFI_ARCH_PROGRAM OP_nop_termination
+#ifdef __GCC_HAVE_DWARF2_CFI_ASM
+#if defined (__x86_64__)
+#undef CFI_ESCAPE
+#undef CFI_ARCH_PROGRAM
+#define CFI_ARCH_PROGRAM CFI_PROGRAM OP_lit8 OP_minus OP_nop_termination
+unsigned char cfi_arch_program[] = { CFI_ARCH_PROGRAM };
+extern char verify_it[sizeof (cfi_arch_program) - 0x80 < 0x3f80 ? 1 : -1];
+/* DW_CFA_expression %rip, uleb128(l2-l1), l1: program DW_OP_lit8 DW_OP_minus DW_OP_nop l2: */
+#define CFI_ESCAPE \
+  asm volatile (".cfi_escape 0x10, 0x10, (%P0&0x7f)+0x80, %P0>>7, " \
+		CFI_ESCAPE_VAL (CFI_ARCH_PROGRAM) \
+		: : "i" (sizeof (cfi_arch_program)))
+#elif defined (__i386__)
+#undef CFI_ESCAPE
+#undef CFI_ARCH_PROGRAM
+#define CFI_ARCH_PROGRAM CFI_PROGRAM OP_lit4 OP_minus OP_nop_termination
+unsigned char cfi_arch_program[] = { CFI_ARCH_PROGRAM };
+extern char verify_it[sizeof (cfi_arch_program) - 0x80 < 0x3f80 ? 1 : -1];
+/* DW_CFA_expression %eip, uleb128(l2-l1), l1: program DW_OP_lit4 DW_OP_minus DW_OP_nop l2: */
+#define CFI_ESCAPE \
+  asm volatile (".cfi_escape 0x10, 8, (%P0&0x7f)+0x80, %P0>>7, " \
+		CFI_ESCAPE_VAL (CFI_ARCH_PROGRAM) \
+		: : "i" (sizeof (cfi_arch_program)))
+#endif
+#endif
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+		   _Unwind_Exception_Class exc_class,
+		   struct _Unwind_Exception *exc_obj,
+		   struct _Unwind_Context *context,
+		   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind ()
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+
+  abort ();
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  exit (0);
+}
+
+__attribute__((noinline)) static void callme ()
+{
+  CFI_ESCAPE;
+  force_unwind ();
+}
+
+__attribute__((noinline)) static void doit ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  callme ();
+}
+
+int main()
+{ 
+  doit ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-2.c
new file mode 100644
index 000000000..2c798023c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-2.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+/* Verify that cleanup works in the most basic of ways.  */
+
+extern void exit(int);
+extern void abort(void);
+
+static void handler(void *p __attribute__((unused)))
+{
+  exit (0);
+}
+
+static void doit(void)
+{
+  int x __attribute__((cleanup (handler)));
+}
+
+int main()
+{
+  doit ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-3.c
new file mode 100644
index 000000000..b5b01fd59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-3.c
@@ -0,0 +1,45 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+/* Verify that the cleanup handler receives the proper contents
+   of the variable.  */
+
+extern void exit(int);
+extern void abort(void);
+
+static int expected;
+
+static void
+handler(int *p)
+{
+  if (*p != expected)
+    abort ();
+}
+
+static void __attribute__((noinline))
+bar(void)
+{
+}
+
+static void doit(int x, int y)
+{
+  int r __attribute__((cleanup (handler)));
+  if (x < y)
+    {
+      r = 0;
+      return;
+    }
+
+  bar();
+  r = x + y;
+}
+
+int main()
+{
+  expected = 0;
+  doit (1, 2);
+
+  expected = 3;
+  doit (2, 1);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-4.c
new file mode 100644
index 000000000..a5487553d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-4.c
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+/* Verify cleanup execution on non-trivial exit from a block.  */
+
+extern void exit(int);
+extern void abort(void);
+
+static int counter;
+
+static void
+handler(int *p)
+{
+  counter += *p;
+}
+
+static void __attribute__((noinline))
+bar(void)
+{
+}
+
+static void doit(int n, int n2)
+{
+  int i;
+  for (i = 0; i < n; ++i)
+    {
+      int dummy __attribute__((cleanup (handler))) = i;
+      if (i == n2)
+	break;
+      bar();
+    }
+}
+
+int main()
+{
+  doit (10, 6);
+  if (counter != 0 + 1 + 2 + 3 + 4 + 5 + 6)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-5.c
new file mode 100644
index 000000000..c335c1e44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-5.c
@@ -0,0 +1,53 @@
+/* HP-UX libunwind.so doesn't provide _UA_END_OF_STACK */
+/* { dg-do run } */
+/* { dg-options "-fexceptions" } */
+/* { dg-skip-if "" { "ia64-*-hpux11.*" }  { "*" } { "" } } */
+/* Verify that cleanups work with exception handling.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <string.h>
+
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+                   _Unwind_Exception_Class exc_class,
+                   struct _Unwind_Exception *exc_obj,
+                   struct _Unwind_Context *context,
+                   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind ()
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+                   
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+                   
+  abort ();
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  exit (0);
+}
+
+static void doit ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  force_unwind ();
+}
+
+int main()
+{ 
+  doit ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-6.c
new file mode 100644
index 000000000..4e3d53893
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-6.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+/* Verify that a cleanup marked "inline" gets inlined.  */
+
+static inline void xyzzy(void *p __attribute__((unused)))
+{
+}
+
+void doit(void)
+{
+  int x __attribute__((cleanup (xyzzy)));
+}
+
+/* { dg-final { scan-assembler-not "xyzzy" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-7.c
new file mode 100644
index 000000000..eae3d5298
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-7.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+/* Verify that the search for function happens in the proper scope.  */
+
+extern void exit(int);
+extern void abort(void);
+
+int main()
+{
+  auto void xyzzy(void *p __attribute__((unused)))
+  {
+    exit (0);
+  }
+
+  auto void doit ()
+  {
+    int x __attribute__((cleanup (xyzzy)));
+  }
+
+  doit ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-8.c
new file mode 100644
index 000000000..d2335606a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-8.c
@@ -0,0 +1,99 @@
+/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */
+/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */
+/* Verify that cleanups work with exception handling through signal
+   frames.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+                   _Unwind_Exception_Class exc_class,
+                   struct _Unwind_Exception *exc_obj,
+                   struct _Unwind_Context *context,
+                   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind ()
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+                   
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+                   
+  abort ();
+}
+
+int count;
+char *null;
+
+static void counter (void *p __attribute__((unused)))
+{
+  ++count;
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  if (count != 2)
+    abort ();
+  exit (0);
+}
+
+static int __attribute__((noinline)) fn5 ()
+{
+  char dummy __attribute__((cleanup (counter)));
+  force_unwind ();
+  return 0;
+}
+
+static void fn4 (int sig)
+{
+  char dummy __attribute__((cleanup (counter)));
+  fn5 ();
+  null = NULL;
+}
+
+static void fn3 ()
+{
+  abort ();
+}
+
+static int __attribute__((noinline)) fn2 ()
+{
+  *null = 0;
+  fn3 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn1 ()
+{
+  signal (SIGSEGV, fn4);
+  signal (SIGBUS, fn4);
+  fn2 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn0 ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  fn1 ();
+  null = 0;
+  return 0;
+}
+
+int main()
+{ 
+  fn0 ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-9.c
new file mode 100644
index 000000000..b73125ace
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cleanup-9.c
@@ -0,0 +1,103 @@
+/* { dg-do run { target hppa*-*-hpux* *-*-linux* powerpc*-*-darwin* *-*-darwin[912]* } } */
+/* { dg-options "-fexceptions -fnon-call-exceptions -O2" } */
+/* Verify that cleanups work with exception handling through realtime
+   signal frames.  */
+
+#include <unwind.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+
+static _Unwind_Reason_Code
+force_unwind_stop (int version, _Unwind_Action actions,
+                   _Unwind_Exception_Class exc_class,
+                   struct _Unwind_Exception *exc_obj,
+                   struct _Unwind_Context *context,
+                   void *stop_parameter)
+{
+  if (actions & _UA_END_OF_STACK)
+    abort ();
+  return _URC_NO_REASON;
+}
+
+static void force_unwind ()
+{
+  struct _Unwind_Exception *exc = malloc (sizeof (*exc));
+  memset (&exc->exception_class, 0, sizeof (exc->exception_class));
+  exc->exception_cleanup = 0;
+                   
+#ifndef __USING_SJLJ_EXCEPTIONS__
+  _Unwind_ForcedUnwind (exc, force_unwind_stop, 0);
+#else
+  _Unwind_SjLj_ForcedUnwind (exc, force_unwind_stop, 0);
+#endif
+                   
+  abort ();
+}
+
+int count;
+char *null;
+
+static void counter (void *p __attribute__((unused)))
+{
+  ++count;
+}
+
+static void handler (void *p __attribute__((unused)))
+{
+  if (count != 2)
+    abort ();
+  exit (0);
+}
+
+static int __attribute__((noinline)) fn5 ()
+{
+  char dummy __attribute__((cleanup (counter)));
+  force_unwind ();
+  return 0;
+}
+
+static void fn4 (int sig, siginfo_t *info, void *ctx)
+{
+  char dummy __attribute__((cleanup (counter)));
+  fn5 ();
+  null = NULL;
+}
+
+static void fn3 ()
+{
+  abort ();
+}
+
+static int __attribute__((noinline)) fn2 ()
+{
+  *null = 0;
+  fn3 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn1 ()
+{
+  struct sigaction s;
+  sigemptyset (&s.sa_mask);
+  s.sa_sigaction = fn4;
+  s.sa_flags = SA_RESETHAND | SA_SIGINFO;
+  sigaction (SIGSEGV, &s, NULL);
+  sigaction (SIGBUS, &s, NULL);
+  fn2 ();
+  return 0;
+}
+
+static int __attribute__((noinline)) fn0 ()
+{
+  char dummy __attribute__((cleanup (handler)));
+  fn1 ();
+  null = 0;
+  return 0;
+}
+
+int main()
+{ 
+  fn0 ();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-1.c
new file mode 100644
index 000000000..66afac87b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-1.c
@@ -0,0 +1,13 @@
+/* Test diagnostics for addresses of labels and computed gotos.  Test
+   with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (void)
+{
+  void *p = &&a;
+  goto *p;
+ a: ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-2.c
new file mode 100644
index 000000000..85b0049fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-2.c
@@ -0,0 +1,13 @@
+/* Test diagnostics for addresses of labels and computed gotos.  Test
+   with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+void
+f (void)
+{
+  void *p = &&a; /* { dg-warning "taking the address of a label is non-standard" } */
+  goto *p; /* { dg-warning "ISO C forbids 'goto \\*expr;'" } */
+ a: ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-3.c
new file mode 100644
index 000000000..5a3b4d2ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-goto-3.c
@@ -0,0 +1,13 @@
+/* Test diagnostics for addresses of labels and computed gotos.  Test
+   with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+void
+f (void)
+{
+  void *p = &&a; /* { dg-error "taking the address of a label is non-standard" } */
+  goto *p; /* { dg-error "ISO C forbids 'goto \\*expr;'" } */
+ a: ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-return-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-return-1.c
new file mode 100644
index 000000000..82c398355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/comp-return-1.c
@@ -0,0 +1,31 @@
+/* When merging a nonprototype definition of a function with a prior
+   prototype declaration, the composite type of the return types must
+   be formed rather than just copying the function type.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+
+typedef int a[];
+typedef int a5[5];
+typedef int a10[10];
+
+a *f1 ();
+a5 *f1 () { return 0; }
+
+a *f2 (void);
+a5 *f2 () { return 0; }
+
+a *f3 ();
+a5 *f3 (void) { return 0; }
+
+a *f4 (void);
+a5 *f4 (void) { return 0; }
+
+void
+g (void)
+{
+  a10 *x;
+  x = f1 (); /* { dg-error "incompatible" "f1" } */
+  x = f2 (); /* { dg-error "incompatible" "f2" } */
+  x = f3 (); /* { dg-error "incompatible" "f3" } */
+  x = f4 (); /* { dg-error "incompatible" "f4" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare1.c
new file mode 100644
index 000000000..17ba3ee20
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare1.c
@@ -0,0 +1,41 @@
+/* Test for a bogus warning on comparison between signed and unsigned.
+   This was inspired by code in gcc.  This testcase is identical to
+   compare9.c except that we use -fno-short-enums here and expect a
+   warning from case 4.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fno-short-enums -Wsign-compare" } */
+
+int tf = 1;
+
+/* This enumeration has an explicit negative value and is therefore signed.  */
+enum mm1 
+{
+  VOID, SI, DI, MAX = -1
+};
+
+/* This enumeration fits entirely in a signed int, but is unsigned anyway.  */
+enum mm2
+{
+  VOID2, SI2, DI2, MAX2
+};
+
+int f(enum mm1 x)
+{
+  return x == (tf?DI:SI); /* { dg-bogus "signed and unsigned" "case 1" } */
+}
+
+int g(enum mm1 x)
+{
+  return x == (tf?DI:-1); /* { dg-bogus "signed and unsigned" "case 2" } */
+}
+
+int h(enum mm2 x)
+{
+  return x == (tf?DI2:SI2); /* { dg-bogus "signed and unsigned" "case 3" } */
+}
+
+int i(enum mm2 x)
+{
+  return x == (tf?DI2:-1); /* { dg-warning "signed and unsigned" "case 4" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare2.c
new file mode 100644
index 000000000..0625eb9c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare2.c
@@ -0,0 +1,58 @@
+/* Test for a bogus warning on comparison between signed and unsigned.
+   This was inspired by code in gcc. */
+
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare" } */
+
+int tf = 1;
+
+void f(int x, unsigned int y)
+{
+  /* ?: branches are constants.  */
+  x > (tf?64:128); /* { dg-bogus "signed and unsigned" "case 1" } */
+  y > (tf?64:128); /* { dg-bogus "signed and unsigned" "case 2" } */
+
+  /* ?: branches are (recursively) constants.  */
+  x > (tf?64:(tf?128:256)); /* { dg-bogus "signed and unsigned" "case 3" } */
+  y > (tf?64:(tf?128:256)); /* { dg-bogus "signed and unsigned" "case 4" } */
+
+  /* ?: branches are signed constants.  */
+  x > (tf?64:-1); /* { dg-bogus "signed and unsigned" "case 5" } */
+  y > (tf?64:-1); /* { dg-warning "signed and unsigned" "case 6" } */
+
+  /* ?: branches are (recursively) signed constants.  */
+  x > (tf?64:(tf?128:-1)); /* { dg-bogus "signed and unsigned" "case 7" } */
+  y > (tf?64:(tf?128:-1)); /* { dg-warning "signed and unsigned" "case 8" } */
+
+  /* Statement expression.  */
+  x > ({tf; 64;}); /* { dg-bogus "signed and unsigned" "case 9" } */
+  y > ({tf; 64;}); /* { dg-bogus "signed and unsigned" "case 10" } */
+
+  /* Statement expression with recursive ?: .  */
+  x > ({tf; tf?64:(tf?128:256);}); /* { dg-bogus "signed and unsigned" "case 11" } */
+  y > ({tf; tf?64:(tf?128:256);}); /* { dg-bogus "signed and unsigned" "case 12" } */
+
+  /* Statement expression with signed ?:.  */
+  x > ({tf; tf?64:-1;}); /* { dg-bogus "signed and unsigned" "case 13" } */
+  y > ({tf; tf?64:-1;}); /* { dg-warning "signed and unsigned" "case 14" } */
+
+  /* Statement expression with recursive signed ?:.  */
+  x > ({tf; tf?64:(tf?128:-1);}); /* { dg-bogus "signed and unsigned" "case 15" } */
+  y > ({tf; tf?64:(tf?128:-1);}); /* { dg-warning "signed and unsigned" "case 16" } */
+
+  /* ?: branches are constants.  */
+  tf ? x : (tf?64:32); /* { dg-bogus "conditional expression" "case 17" } */
+  tf ? y : (tf?64:32); /* { dg-bogus "conditional expression" "case 18" } */
+
+  /* ?: branches are signed constants.  */
+  tf ? x : (tf?64:-1); /* { dg-bogus "conditional expression" "case 19" } */
+  tf ? y : (tf?64:-1); /* { dg-warning "conditional expression" "case 20" } */
+
+  /* ?: branches are (recursively) constants.  */
+  tf ? x : (tf?64:(tf?128:256)); /* { dg-bogus "conditional expression" "case 21" } */
+  tf ? y : (tf?64:(tf?128:256)); /* { dg-bogus "conditional expression" "case 22" } */
+
+  /* ?: branches are (recursively) signed constants.  */
+  tf ? x : (tf?64:(tf?128:-1)); /* { dg-bogus "conditional expression" "case 23" } */
+  tf ? y : (tf?64:(tf?128:-1)); /* { dg-warning "conditional expression" "case 24" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare3.c
new file mode 100644
index 000000000..eda3faf27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare3.c
@@ -0,0 +1,59 @@
+/* Test for a bogus warning on comparison between signed and unsigned.
+   This was inspired by code in gcc. */
+
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare" } */
+
+int tf = 1;
+
+void f(int x, unsigned int y)
+{
+  /* Test comparing conditional expressions containing truth values.
+     This can occur explicitly, or e.g. when (foo?2:(bar?1:0)) is
+     optimized into (foo?2:(bar!=0)).  */
+  x > (tf?64:(tf!=x)); /* { dg-bogus "signed and unsigned" "case 1" } */
+  y > (tf?64:(tf!=x)); /* { dg-bogus "signed and unsigned" "case 2" } */
+  x > (tf?(tf!=x):64); /* { dg-bogus "signed and unsigned" "case 3" } */
+  y > (tf?(tf!=x):64); /* { dg-bogus "signed and unsigned" "case 4" } */
+
+  x > (tf?64:(tf==x)); /* { dg-bogus "signed and unsigned" "case 5" } */
+  y > (tf?64:(tf==x)); /* { dg-bogus "signed and unsigned" "case 6" } */
+  x > (tf?(tf==x):64); /* { dg-bogus "signed and unsigned" "case 7" } */
+  y > (tf?(tf==x):64); /* { dg-bogus "signed and unsigned" "case 8" } */
+
+  x > (tf?64:(tf>x)); /* { dg-bogus "signed and unsigned" "case 9" } */
+  y > (tf?64:(tf>x)); /* { dg-bogus "signed and unsigned" "case 10" } */
+  x > (tf?(tf>x):64); /* { dg-bogus "signed and unsigned" "case 11" } */
+  y > (tf?(tf>x):64); /* { dg-bogus "signed and unsigned" "case 12" } */
+
+  x < (tf?64:(tf<x)); /* { dg-bogus "signed and unsigned" "case 13" } */
+  y < (tf?64:(tf<x)); /* { dg-bogus "signed and unsigned" "case 14" } */
+  x < (tf?(tf<x):64); /* { dg-bogus "signed and unsigned" "case 15" } */
+  y < (tf?(tf<x):64); /* { dg-bogus "signed and unsigned" "case 16" } */
+
+  x > (tf?64:(tf>=x)); /* { dg-bogus "signed and unsigned" "case 17" } */
+  y > (tf?64:(tf>=x)); /* { dg-bogus "signed and unsigned" "case 18" } */
+  x > (tf?(tf>=x):64); /* { dg-bogus "signed and unsigned" "case 19" } */
+  y > (tf?(tf>=x):64); /* { dg-bogus "signed and unsigned" "case 20" } */
+
+  x > (tf?64:(tf<=x)); /* { dg-bogus "signed and unsigned" "case 21" } */
+  y > (tf?64:(tf<=x)); /* { dg-bogus "signed and unsigned" "case 22" } */
+  x > (tf?(tf<=x):64); /* { dg-bogus "signed and unsigned" "case 23" } */
+  y > (tf?(tf<=x):64); /* { dg-bogus "signed and unsigned" "case 24" } */
+
+  x > (tf?64:(tf&&x)); /* { dg-bogus "signed and unsigned" "case 25" } */
+  y > (tf?64:(tf&&x)); /* { dg-bogus "signed and unsigned" "case 26" } */
+  x > (tf?(tf&&x):64); /* { dg-bogus "signed and unsigned" "case 27" } */
+  y > (tf?(tf&&x):64); /* { dg-bogus "signed and unsigned" "case 28" } */
+
+  x > (tf?64:(tf||x)); /* { dg-bogus "signed and unsigned" "case 29" } */
+  y > (tf?64:(tf||x)); /* { dg-bogus "signed and unsigned" "case 30" } */
+  x > (tf?(tf||x):64); /* { dg-bogus "signed and unsigned" "case 31" } */
+  y > (tf?(tf||x):64); /* { dg-bogus "signed and unsigned" "case 32" } */
+
+  x > (tf?64:(!tf)); /* { dg-bogus "signed and unsigned" "case 33" } */
+  y > (tf?64:(!tf)); /* { dg-bogus "signed and unsigned" "case 34" } */
+  x > (tf?(!tf):64); /* { dg-bogus "signed and unsigned" "case 35" } */
+  y > (tf?(!tf):64); /* { dg-bogus "signed and unsigned" "case 36" } */
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare4.c
new file mode 100644
index 000000000..e5dad4d1e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare4.c
@@ -0,0 +1,49 @@
+/* Test for a bogus warning on comparison between signed and unsigned.
+   Origin: Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 5/13/2001.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fshow-column -Wsign-compare -fstrict-overflow" } */
+
+extern void bar(void);
+
+int foo(int x, int y, unsigned u)
+{
+  /* A COMPOUND_EXPR is non-negative if the last element is known to
+     be non-negative.  */
+  if (u < (bar(), -1)) /*{ dg-warning "9:signed and unsigned" "COMPOUND_EXPR" }*/
+    return x;
+  if (u < (bar(), 10))
+    return x;
+  if ((bar(), 10) < u)
+    return x;
+  if (u < (x ? (bar(),bar(),bar(),bar(),x==y) : 10))
+    return x;
+  if ((x ? 10 : (bar(),bar(),bar(),bar(),x==y)) < u)
+    return x;
+
+  /* Test an ABS_EXPR, which is by definition non-negative when
+     -fstrict-overflow is used.  */
+  if (u < __builtin_abs(x))
+    return x;
+  if (__builtin_abs(x) < u)
+    return x;
+  if (u < (x ? __builtin_abs(x) : 10))
+    return x;
+  if ((x ? 10: __builtin_abs(x)) < u)
+    return x;
+
+  /* A MODIFY_EXPR is non-negative if the new value is known to be
+     non-negative.  */
+  if (u < (x = -1)) /* { dg-warning "9:signed and unsigned" "MODIFY_EXPR" } */
+    return x;
+  if (u < (x = 10))
+    return x;
+  if ((x = 10) < u)
+    return x;
+  if (u < (x = (y ? (x==y) : 10)))
+    return x;
+  if ((x = (y ? 10 : (x==y))) < u)
+    return x;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare5.c
new file mode 100644
index 000000000..f19c575ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare5.c
@@ -0,0 +1,41 @@
+/* Test for a bogus warning on comparison between signed and unsigned.
+   Origin: Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/21/2001.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare" } */
+
+extern void bar(void);
+
+int foo(int x, int y, unsigned u)
+{
+  /* A *_DIV_EXPR is non-negative if both operands are.  */
+
+  if (u < ((x=-22)/33)) /* { dg-warning "signed and unsigned" "DIV_EXPR" } */
+    return x;
+
+  if (u < ((x=22)/33))
+    return x;
+
+  if (u < ((x=22)/(y=33)))
+    return x;
+
+  if (u < (((x&0x10000)?128:64) / ((y&0x10000)?8:4)))
+    return x;
+
+
+  /* A *_MOD_EXPR is non-negative if the first operand is.  */
+
+  if (u < ((x=-22)%33)) /* { dg-warning "signed and unsigned" "MOD_EXPR" } */
+    return x;
+
+  if (u < ((x=22)%-33))
+    return x;
+
+  if (u < ((x==y)%-33))
+    return x;
+
+  if (u < (((x=22)/33)%-33))
+    return x;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare6.c
new file mode 100644
index 000000000..945d28239
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare6.c
@@ -0,0 +1,13 @@
+/* PR c/2098 */
+/* Test for a warning on comparison on out-of-range data.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtype-limits" } */
+
+signed char sc;
+unsigned char uc;
+
+void foo()
+{
+  if (sc == 10000) return; /* { dg-warning "always false" "signed" } */
+  if (uc == 10000) return; /* { dg-warning "always false" "unsigned" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare7.c
new file mode 100644
index 000000000..e2fbc04bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare7.c
@@ -0,0 +1,10 @@
+/* -Wall is not supposed to trigger -Wsign-compare for C.  PR 10604.
+   See also g++.dg/warn/compare1.C.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+int f(unsigned a, int b)
+{
+  return a < b;  /* { dg-bogus "signed and unsigned" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare8.c
new file mode 100644
index 000000000..d723c45a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare8.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare" } */
+
+int
+f(unsigned short a1, unsigned short a2, unsigned int b)
+{
+  return ((a1+a2)|5) > b ? 2 : 3;  /* { dg-bogus "signed and unsigned" } */
+}
+
+int
+g(unsigned short a1, unsigned short a2, unsigned int b)
+{
+  return ((a1+a2)&5) > b ? 2 : 3;  /* { dg-bogus "signed and unsigned" } */
+}
+
+int
+h(unsigned short a1, unsigned short a2, unsigned int b)
+{
+  return ((a1+a2)^5) > b ? 2 : 3;  /* { dg-bogus "signed and unsigned" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compare9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare9.c
new file mode 100644
index 000000000..02150cb1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compare9.c
@@ -0,0 +1,41 @@
+/* Test for a bogus warning on comparison between signed and unsigned.
+   This was inspired by code in gcc.  This testcase is identical to
+   compare1.c except that we use -fshort-enums here and do not expect
+   a warning from case 4.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fshort-enums -Wsign-compare" } */
+
+int tf = 1;
+
+/* This enumeration has an explicit negative value and is therefore signed.  */
+enum mm1 
+{
+  VOID, SI, DI, MAX = -1
+};
+
+/* This enumeration fits entirely in a signed int, but is unsigned anyway.  */
+enum mm2
+{
+  VOID2, SI2, DI2, MAX2
+};
+
+int f(enum mm1 x)
+{
+  return x == (tf?DI:SI); /* { dg-bogus "signed and unsigned" "case 1" } */
+}
+
+int g(enum mm1 x)
+{
+  return x == (tf?DI:-1); /* { dg-bogus "signed and unsigned" "case 2" } */
+}
+
+int h(enum mm2 x)
+{
+  return x == (tf?DI2:SI2); /* { dg-bogus "signed and unsigned" "case 3" } */
+}
+
+int i(enum mm2 x)
+{
+  return x == (tf?DI2:-1); /* { dg-bogus "signed and unsigned" "case 4" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/compat-common.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/compat-common.h
new file mode 100644
index 000000000..40d4e08f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/compat-common.h
@@ -0,0 +1,51 @@
+/*  Several of the binary compatibility tests use these macros to
+    allow debugging the test or tracking down a failure by getting an
+    indication of whether each individual check passed or failed.
+    When DBG is defined, each check is shown by a dot (pass) or 'F'
+    (fail) rather than aborting as soon as a failure is detected.  */
+ 
+#ifdef DBG
+#include <stdio.h>
+#define DEBUG_INIT setbuf (stdout, NULL);
+#define DEBUG_FPUTS(x) fputs (x, stdout)
+#define DEBUG_DOT putc ('.', stdout)
+#define DEBUG_NL putc ('\n', stdout)
+#define DEBUG_FAIL putc ('F', stdout); fails++
+#define DEBUG_CHECK { DEBUG_FAIL; } else { DEBUG_DOT; }
+#define DEBUG_FINI if (fails) DEBUG_FPUTS ("failed\n"); \
+		   else DEBUG_FPUTS ("passed\n");
+#else
+#define DEBUG_INIT
+#define DEBUG_FPUTS(x)
+#define DEBUG_DOT
+#define DEBUG_NL
+#define DEBUG_FAIL abort ()
+#define DEBUG_CHECK abort ();
+#define DEBUG_FINI
+#endif
+
+#ifdef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+#define SKIP_COMPLEX_INT
+#endif
+#endif
+
+#ifndef SKIP_COMPLEX
+#ifdef __GNUC__
+#define CINT(x, y) (x + y * __extension__ 1i)
+#define CDBL(x, y) (x + y * __extension__ 1i)
+#else
+#ifdef __SUNPRO_C
+/* ??? Complex support without <complex.h>.  */
+#else
+#include <complex.h>
+#endif
+#ifndef SKIP_COMPLEX_INT
+#define CINT(x, y) ((_Complex int) (x + y * _Complex_I))
+#endif
+#define CDBL(x, y) (x + y * _Complex_I)
+#endif
+#endif
+
+extern void abort (void);
+extern int fails;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/compat.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/compat.exp
new file mode 100644
index 000000000..1302d5259
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/compat.exp
@@ -0,0 +1,86 @@
+# Copyright (C) 2002, 2003, 2007 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 file was written by Janis Johnson, <janis187@us.ibm.com>
+
+
+# Test interoperability of two compilers that follow the same ABI.
+#
+# Break simple tests into two pieces and see that they work when linked
+# together.  If an alternate compiler is specified then the two main
+# pieces of each test are compiled with different compilers.  The
+# alternate compiler must be installed, and is specified by defining
+# ALT_CC_UNDER_TEST in the environment.
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+global GCC_UNDER_TEST
+global ALT_CC_UNDER_TEST
+global compat_save_gcc_under_test
+global compat_use_alt
+global compat_same_alt
+global compat_have_dfp
+
+# Load procedures from common libraries. 
+load_lib standard.exp
+load_lib gcc.exp
+
+# Load the language-dependent compatibility support procedures.
+load_lib c-compat.exp
+
+# Load the language-independent compabibility support procedures.
+load_lib compat.exp
+
+gcc_init
+
+# Save variables for the C compiler under test, which each test will
+# change a couple of times.  This must be done after calling gcc-init.
+set compat_save_gcc_under_test $GCC_UNDER_TEST
+
+# Define an identifier for use with this suite to avoid name conflicts
+# with other compat tests running at the same time.
+set sid "c_compat"
+
+# Find out whether there is an alternate compiler to test.  If the
+# variable is defined but is set to "same", that means we use the same
+# compiler twice, which is meaningful if the two parts of COMPAT_OPTIONS
+# are different.
+set compat_use_alt 0
+set compat_same_alt 0
+
+if [info exists ALT_CC_UNDER_TEST] then {
+    set compat_use_alt 1
+    if [string match "same" $ALT_CC_UNDER_TEST] then {
+	set compat_same_alt 1
+    }
+}
+
+compat_setup_dfp
+
+# Main loop.
+foreach src [lsort [find $srcdir/$subdir *_main.c]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $src] then {
+	continue
+    }
+
+    compat-execute $src $sid $compat_use_alt
+}
+
+# Restore the original compiler under test.
+compat-use-tst-compiler
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_main.c
new file mode 100644
index 000000000..35c94aaea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_main.c
@@ -0,0 +1,12 @@
+/* Test passing function pointers.  */
+
+extern void fnptr_by_value_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  fnptr_by_value_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_x.c
new file mode 100644
index 000000000..156a417a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_x.c
@@ -0,0 +1,162 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+typedef void (*fpi)(int);
+typedef void (*fpd)(double);
+
+extern void test1a (fpi);
+extern void test1b (fpi, int);
+extern void test1c (double, fpd);
+extern void test2a (fpi, fpd);
+extern void test2b (fpi, fpd, int);
+extern void test2c (fpi, int, fpd);
+extern void test2d (int, fpi, fpd);
+extern void test2e (fpi, fpd, int, double);
+extern void test2f (fpi, int, fpd, double);
+extern void test2g (fpi, int, double, fpd);
+extern void test2h (double, fpd, fpi, int);
+extern void test2i (double, fpd, int, fpi);
+extern void test2j (int, double, fpi, fpd);
+extern void testva (int, ...);
+
+int f1_val;
+double f2_val;
+
+void f1 (int i) { f1_val = i; }
+void f2 (double x) { f2_val = x; }
+
+void
+checki (int x, int v)
+{
+  if (x != v)
+    DEBUG_CHECK
+}
+
+void
+checkd (double x, double v)
+{
+  if (x != v)
+    DEBUG_CHECK
+}
+
+void
+testit (void)
+{
+  DEBUG_FPUTS ("test1a: ");
+  test1a (f1);
+  checki (f1_val, 1);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test1b: ");
+  test1b (f1, 2);
+  checki (f1_val, 2);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test1c: ");
+  test1c (3.0, f2);
+  checkd (f2_val, 3.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2a: ");
+  test2a (f1, f2);
+  checki (f1_val, 10);
+  checkd (f2_val, 10.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2b: ");
+  test2b (f1, f2, 11);
+  checki (f1_val, 11);
+  checkd (f2_val, 11.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2c: ");
+  test2c (f1, 12, f2);
+  checki (f1_val, 12);
+  checkd (f2_val, 12.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2d: ");
+  test2d (13, f1, f2);
+  checki (f1_val, 13);
+  checkd (f2_val, 13.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2e: ");
+  test2e (f1, f2, 14, 15.0);
+  checki (f1_val, 14);
+  checkd (f2_val, 15.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2f: ");
+  test2f (f1, 16, f2, 17.0);
+  checki (f1_val, 16);
+  checkd (f2_val, 17.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2g: ");
+  test2g (f1, 18, 19.0, f2);
+  checki (f1_val, 18);
+  checkd (f2_val, 19.0);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2h: ");
+  test2h (20.0, f2, f1, 21);
+  checkd (f2_val, 20.0);
+  checki (f1_val, 21);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2i: ");
+  test2i (22.0, f2, 23, f1);
+  checkd (f2_val, 22.0);
+  checki (f1_val, 23);
+  DEBUG_NL;
+  DEBUG_FPUTS ("test2j: ");
+  test2j (24, 25.0, f1, f2);
+  checki (f1_val, 24);
+  checkd (f2_val, 25.0);
+  if (test_va)
+    {
+      DEBUG_NL;
+      DEBUG_FPUTS ("testva: ");
+      testva (1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (2, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (3, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (4, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (5, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (6, f1, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (7, f1, f1, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (8, f1, f1, f1, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (9, f1, f1, f1, f1, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (10, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (11, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1);
+      DEBUG_NL;
+      DEBUG_FPUTS ("        ");
+      testva (12, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1, f1);
+    }
+  DEBUG_NL;
+}
+
+void
+fnptr_by_value_1_x ()
+{
+  DEBUG_INIT
+  testit ();
+  DEBUG_FINI
+
+  if (fails != 0)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_y.c
new file mode 100644
index 000000000..1f6917cdc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fnptr-by-value-1_y.c
@@ -0,0 +1,111 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+typedef void (*fpi)(int);
+typedef void (*fpd)(double);
+
+extern int f1_val;
+extern void checki (int, int);
+
+void
+test1a (fpi f)
+{
+  (*f)(1);
+}
+
+void
+test1b (fpi f, int i)
+{
+  (*f)(i);
+}
+
+void
+test1c (double x, fpd f)
+{
+  (*f)(x);
+}
+
+void
+test2a (fpi f1, fpd f2)
+{
+  (*f1)(10);
+  (*f2)(10.0);
+}
+
+void
+test2b (fpi f1, fpd f2, int i)
+{
+  (*f1)(i);
+  (*f2)((double)i);
+}
+
+void
+test2c (fpi f1, int i, fpd f2)
+{
+  (*f1)(i);
+  (*f2)((double)i);
+}
+
+void
+test2d (int i, fpi f1, fpd f2)
+{
+  (*f1)(i);
+  (*f2)((double)i);
+}
+
+void
+test2e (fpi f1, fpd f2, int i, double x)
+{
+  (*f1)(i);
+  (*f2)(x);
+}
+
+void
+test2f (fpi f1, int i, fpd f2, double x)
+{
+  (*f1)(i);
+  (*f2)(x);
+}
+
+void
+test2g (fpi f1, int i, double x, fpd f2)
+{
+  (*f1)(i);
+  (*f2)(x);
+}
+
+void
+test2h (double x, fpd f1, fpi f2, int i)
+{
+  (*f1)(x);
+  (*f2)(i);
+}
+
+void
+test2i (double x, fpd f1, int i, fpi f2)
+{
+  (*f1)(x);
+  (*f2)(i);
+}
+
+void
+test2j (int i, double x, fpi f1, fpd f2)
+{
+  (*f1)(i);
+  (*f2)(x);
+}
+
+void
+testva (int n, ...)
+{
+  int i;
+  va_list ap;
+  va_start (ap, n);
+  for (i = 0; i < n; i++)
+    {
+      fpi fp = va_arg (ap, fpi);
+      (*fp)(i);
+      checki (f1_val, i);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-check.h
new file mode 100644
index 000000000..bd3283b6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-check.h
@@ -0,0 +1,71 @@
+/* Function definitions that are used by multiple tests.  */
+
+#define CHECKS(NAME,TYPEM)					\
+void checkS##NAME##1 (S##NAME##1 x, TYPEM y)			\
+{ if (x.a != y) DEBUG_CHECK }					\
+void checkS##NAME##2 (S##NAME##2 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 ) DEBUG_CHECK }			\
+void checkS##NAME##3 (S##NAME##3 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 )			\
+    DEBUG_CHECK }						\
+void checkS##NAME##4 (S##NAME##4 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3)	\
+    DEBUG_CHECK }						\
+void checkS##NAME##5 (S##NAME##5 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4) DEBUG_CHECK }				\
+void checkS##NAME##6 (S##NAME##6 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5) DEBUG_CHECK }		\
+void checkS##NAME##7 (S##NAME##7 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6)		\
+    DEBUG_CHECK }						\
+void checkS##NAME##8 (S##NAME##8 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7) DEBUG_CHECK }				\
+void checkS##NAME##9 (S##NAME##9 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8) DEBUG_CHECK }		\
+void checkS##NAME##10 (S##NAME##10 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9)		\
+   DEBUG_CHECK }						\
+void checkS##NAME##11 (S##NAME##11 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9			\
+      || x.k != y+10) DEBUG_CHECK }				\
+void checkS##NAME##12 (S##NAME##12 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9			\
+      || x.k != y+10 || x.l != y+11) DEBUG_CHECK }		\
+void checkS##NAME##13 (S##NAME##13 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9			\
+      || x.k != y+10 || x.l != y+11 || x.m != y+12)		\
+    DEBUG_CHECK }						\
+void checkS##NAME##14 (S##NAME##14 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9			\
+      || x.k != y+10 || x.l != y+11 || x.m != y+12		\
+      || x.n != y+13) DEBUG_CHECK }				\
+void checkS##NAME##15 (S##NAME##15 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9			\
+      || x.k != y+10 || x.l != y+11 || x.m != y+12		\
+      || x.n != y+13 || x.o != y+14) DEBUG_CHECK }		\
+void checkS##NAME##16 (S##NAME##16 x, TYPEM y)			\
+{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3	\
+      || x.e != y+4 || x.f != y+5 || x.g != y+6			\
+      || x.h != y+7 || x.i != y+8 || x.j != y+9			\
+      || x.k != y+10 || x.l != y+11 || x.m != y+12		\
+      || x.n != y+13 || x.o != y+14 || x.p != y+15)		\
+    DEBUG_CHECK }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-defs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-defs.h
new file mode 100644
index 000000000..67d63f23b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-defs.h
@@ -0,0 +1,43 @@
+/* Type definitions that are used by multiple tests.  */
+
+#define DEFS(NAME,TYPEM)					\
+typedef struct { TYPEM a; } S##NAME##1;				\
+typedef struct { TYPEM a; TYPEM b; } S##NAME##2;		\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; } S##NAME##3;	\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; }		\
+	       S##NAME##4;					\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; }	\
+	       S##NAME##5;					\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+  		 TYPEM f; } S##NAME##6;				\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; } S##NAME##7;		\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; } S##NAME##8;	\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; }		\
+	       S##NAME##9;					\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; }	\
+	       S##NAME##10;					\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j;	\
+		 TYPEM k; } S##NAME##11;			\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j;	\
+		 TYPEM k; TYPEM l; } S##NAME##12;		\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j;	\
+		 TYPEM k; TYPEM l; TYPEM m; } S##NAME##13;	\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j;	\
+		 TYPEM k; TYPEM l; TYPEM m; TYPEM n; }		\
+	        S##NAME##14;					\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j;	\
+		 TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; }	\
+	       S##NAME##15;					\
+typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e;	\
+		 TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j;	\
+		 TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o;	\
+		 TYPEM p; } S##NAME##16;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-init.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-init.h
new file mode 100644
index 000000000..46a0cef1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-init.h
@@ -0,0 +1,54 @@
+/* Function definitions that are used by multiple tests.  */
+
+#define INITS(NAME,TYPEM)					\
+void initS##NAME##1 (S##NAME##1 *p, TYPEM y)			\
+{ p->a = y; }							\
+void initS##NAME##2 (S##NAME##2 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; }					\
+void initS##NAME##3 (S##NAME##3 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; }				\
+void initS##NAME##4 (S##NAME##4 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; }		\
+void initS##NAME##5 (S##NAME##5 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; }	\
+void initS##NAME##6 (S##NAME##6 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; }							\
+void initS##NAME##7 (S##NAME##7 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; }					\
+void initS##NAME##8 (S##NAME##8 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; }				\
+void initS##NAME##9 (S##NAME##9 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; }		\
+void initS##NAME##10 (S##NAME##10 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; }	\
+void initS##NAME##11 (S##NAME##11 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9;	\
+  p->k = y+10; }						\
+void initS##NAME##12 (S##NAME##12 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9;	\
+  p->k = y+10; p->l = y+11; }					\
+void initS##NAME##13 (S##NAME##13 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9;	\
+  p->k = y+10; p->l = y+11; p->m = y+12; }			\
+void initS##NAME##14 (S##NAME##14 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9;	\
+  p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; }		\
+void initS##NAME##15 (S##NAME##15 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9;	\
+  p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13;		\
+  p->o = y+14; }						\
+void initS##NAME##16 (S##NAME##16 *p, TYPEM y)			\
+{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4;	\
+  p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9;	\
+  p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13;		\
+  p->o = y+14; p->p = y+15; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-x.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-x.h
new file mode 100644
index 000000000..876f1b355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-x.h
@@ -0,0 +1,136 @@
+#define TEST(TYPE,MTYPE)					\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, MTYPE x);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  (MTYPE)1);				\
+  init##TYPE  ( &g2s##TYPE,  (MTYPE)2);				\
+  init##TYPE  ( &g3s##TYPE,  (MTYPE)3);				\
+  init##TYPE  ( &g4s##TYPE,  (MTYPE)4);				\
+  init##TYPE  ( &g5s##TYPE,  (MTYPE)5);				\
+  init##TYPE  ( &g6s##TYPE,  (MTYPE)6);				\
+  init##TYPE  ( &g7s##TYPE,  (MTYPE)7);				\
+  init##TYPE  ( &g8s##TYPE,  (MTYPE)8);				\
+  init##TYPE  ( &g9s##TYPE,  (MTYPE)9);				\
+  init##TYPE  (&g10s##TYPE, (MTYPE)10);				\
+  init##TYPE  (&g11s##TYPE, (MTYPE)11);				\
+  init##TYPE  (&g12s##TYPE, (MTYPE)12);				\
+  init##TYPE  (&g13s##TYPE, (MTYPE)13);				\
+  init##TYPE  (&g14s##TYPE, (MTYPE)14);				\
+  init##TYPE  (&g15s##TYPE, (MTYPE)15);				\
+  init##TYPE  (&g16s##TYPE, (MTYPE)16);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-y.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-y.h
new file mode 100644
index 000000000..49fccdd09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-y.h
@@ -0,0 +1,69 @@
+#define TEST(TYPE,TYPE2)					\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+extern void check##TYPE (TYPE x, TYPE2 y);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  (TYPE2)1);				\
+  check##TYPE (  g2s##TYPE,  (TYPE2)2);				\
+  check##TYPE (  g3s##TYPE,  (TYPE2)3);				\
+  check##TYPE (  g4s##TYPE,  (TYPE2)4);				\
+  check##TYPE (  g5s##TYPE,  (TYPE2)5);				\
+  check##TYPE (  g6s##TYPE,  (TYPE2)6);				\
+  check##TYPE (  g7s##TYPE,  (TYPE2)7);				\
+  check##TYPE (  g8s##TYPE,  (TYPE2)8);				\
+  check##TYPE (  g9s##TYPE,  (TYPE2)9);				\
+  check##TYPE ( g10s##TYPE, (TYPE2)10);				\
+  check##TYPE ( g11s##TYPE, (TYPE2)11);				\
+  check##TYPE ( g12s##TYPE, (TYPE2)12);				\
+  check##TYPE ( g13s##TYPE, (TYPE2)13);				\
+  check##TYPE ( g14s##TYPE, (TYPE2)14);				\
+  check##TYPE ( g15s##TYPE, (TYPE2)15);				\
+  check##TYPE ( g16s##TYPE, (TYPE2)16);				\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, (TYPE2)1);					\
+  check##TYPE (s2, (TYPE2)2);					\
+  check##TYPE (s3, (TYPE2)3);					\
+  check##TYPE (s4, (TYPE2)4);					\
+  check##TYPE (s5, (TYPE2)5);					\
+  check##TYPE (s6, (TYPE2)6);					\
+  check##TYPE (s7, (TYPE2)7);					\
+  check##TYPE (s8, (TYPE2)8);					\
+  check##TYPE (s9, (TYPE2)9);					\
+  check##TYPE (s10, (TYPE2)10);					\
+  check##TYPE (s11, (TYPE2)11);					\
+  check##TYPE (s12, (TYPE2)12);					\
+  check##TYPE (s13, (TYPE2)13);					\
+  check##TYPE (s14, (TYPE2)14);					\
+  check##TYPE (s15, (TYPE2)15);					\
+  check##TYPE (s16, (TYPE2)16);					\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, (TYPE2)i+1);				\
+	}							\
+      va_end (ap);						\
+    }								\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-check.h
new file mode 100644
index 000000000..c00f70547
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-check.h
@@ -0,0 +1,27 @@
+/* Function definitions that are used by multiple tests.  */
+
+void checkSfd (Sfd x, double y)
+{ if (x.f != y || x.d != y+1) DEBUG_CHECK }
+void checkSfl (Sfl x, double y)
+{ if (x.f != y || x.l != y+1) DEBUG_CHECK }
+void checkSdf (Sdf x, double y)
+{ if (x.d != y || x.f != y+1) DEBUG_CHECK }
+void checkSdl (Sdl x, double y)
+{ if (x.d != y || x.l != y+1) DEBUG_CHECK }
+void checkSlf (Slf x, double y)
+{ if (x.l != y || x.f != y+1) DEBUG_CHECK }
+void checkSld (Sld x, double y)
+{ if (x.l != y || x.d != y+1) DEBUG_CHECK }
+
+void checkSfdl (Sfdl x, double y)
+{ if (x.f != y || x.d != y+1 || x.l != y+2) DEBUG_CHECK }
+void checkSfld (Sfld x, double y)
+{ if (x.f != y || x.l != y+1 || x.d != y+2) DEBUG_CHECK }
+void checkSdfl (Sdfl x, double y)
+{ if (x.d != y || x.f != y+1 || x.l != y+2) DEBUG_CHECK }
+void checkSdlf (Sdlf x, double y)
+{ if (x.d != y || x.l != y+1 || x.f != y+2) DEBUG_CHECK }
+void checkSlfd (Slfd x, double y)
+{ if (x.l != y || x.f != y+1 || x.d != y+2) DEBUG_CHECK }
+void checkSldf (Sldf x, double y)
+{ if (x.l != y || x.d != y+1 || x.f != y+2) DEBUG_CHECK }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-defs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-defs.h
new file mode 100644
index 000000000..be387a70a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-defs.h
@@ -0,0 +1,15 @@
+/* Type definitions that are used by multiple tests.  */
+
+typedef struct { float f; double d; } Sfd;
+typedef struct { float f; long double l; } Sfl;
+typedef struct { double d; float f; } Sdf;
+typedef struct { double d; long double l; } Sdl;
+typedef struct { long double l; float f; } Slf;
+typedef struct { long double l; double d; } Sld;
+
+typedef struct { float f; double d; long double l; } Sfdl;
+typedef struct { float f; long double l; double d; } Sfld;
+typedef struct { double d; float f; long double l; } Sdfl;
+typedef struct { double d; long double l; float f; } Sdlf;
+typedef struct { long double l; float f; double d; } Slfd;
+typedef struct { long double l; double d; float f; } Sldf;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-init.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-init.h
new file mode 100644
index 000000000..35fe77e00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/fp2-struct-init.h
@@ -0,0 +1,27 @@
+/* Function definitions that are used by multiple tests.  */
+
+void initSfd (Sfd *p, double y)
+{ p->f = y; p->d = y+1; }
+void initSfl (Sfl *p, double y)
+{ p->f = y; p->l = y+1; }
+void initSdf (Sdf *p, double y)
+{ p->d = y; p->f = y+1; }
+void initSdl (Sdl *p, double y)
+{ p->d = y; p->l = y+1; }
+void initSlf (Slf *p, double y)
+{ p->l = y; p->f = y+1; }
+void initSld (Sld *p, double y)
+{ p->l = y; p->d = y+1; }
+
+void initSfdl (Sfdl *p, double y)
+{ p->f = y; p->d = y+1; p->l = y+2; }
+void initSfld (Sfld *p, double y)
+{ p->f = y; p->l = y+1; p->d = y+2; }
+void initSdfl (Sdfl *p, double y)
+{ p->d = y; p->f = y+1; p->l = y+2; }
+void initSdlf (Sdlf *p, double y)
+{ p->d = y; p->l = y+1; p->f = y+2; }
+void initSlfd (Slfd *p, double y)
+{ p->l = y; p->f = y+1; p->d = y+2; }
+void initSldf (Sldf *p, double y)
+{ p->l = y; p->d = y+1; p->f = y+2; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random.c
new file mode 100644
index 000000000..c4b06db67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random.c
@@ -0,0 +1,265 @@
+/* Copyright (C) 1995, 2004 Free Software Foundation
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301 USA.  */
+
+/*
+ * This is derived from the Berkeley source:
+ *	@(#)random.c	5.5 (Berkeley) 7/6/88
+ * It was reworked for the GNU C Library by Roland McGrath.
+ * Rewritten to use reentrant functions by Ulrich Drepper, 1995.
+ */
+
+/*
+   Copyright (C) 1983 Regents of the University of California.
+   All rights reserved.
+ 
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+   4. Neither the name of the University nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+   
+   THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+   SUCH DAMAGE.*/
+
+#include <limits.h>
+#include <stdlib.h>
+#include "generate-random.h"
+
+
+/* An improved random number generation package.  In addition to the standard
+   rand()/srand() like interface, this package also has a special state info
+   interface.  The initstate() routine is called with a seed, an array of
+   bytes, and a count of how many bytes are being passed in; this array is
+   then initialized to contain information for random number generation with
+   that much state information.  Good sizes for the amount of state
+   information are 32, 64, 128, and 256 bytes.  The state can be switched by
+   calling the setstate() function with the same array as was initialized
+   with initstate().  By default, the package runs with 128 bytes of state
+   information and generates far better random numbers than a linear
+   congruential generator.  If the amount of state information is less than
+   32 bytes, a simple linear congruential R.N.G. is used.  Internally, the
+   state information is treated as an array of longs; the zeroth element of
+   the array is the type of R.N.G. being used (small integer); the remainder
+   of the array is the state information for the R.N.G.  Thus, 32 bytes of
+   state information will give 7 longs worth of state information, which will
+   allow a degree seven polynomial.  (Note: The zeroth word of state
+   information also has some other information stored in it; see setstate
+   for details).  The random number generation technique is a linear feedback
+   shift register approach, employing trinomials (since there are fewer terms
+   to sum up that way).  In this approach, the least significant bit of all
+   the numbers in the state table will act as a linear feedback shift register,
+   and will have period 2^deg - 1 (where deg is the degree of the polynomial
+   being used, assuming that the polynomial is irreducible and primitive).
+   The higher order bits will have longer periods, since their values are
+   also influenced by pseudo-random carries out of the lower bits.  The
+   total period of the generator is approximately deg*(2**deg - 1); thus
+   doubling the amount of state information has a vast influence on the
+   period of the generator.  Note: The deg*(2**deg - 1) is an approximation
+   only good for large deg, when the period of the shift register is the
+   dominant factor.  With deg equal to seven, the period is actually much
+   longer than the 7*(2**7 - 1) predicted by this formula.  */
+
+
+
+/* For each of the currently supported random number generators, we have a
+   break value on the amount of state information (you need at least this many
+   bytes of state info to support this random number generator), a degree for
+   the polynomial (actually a trinomial) that the R.N.G. is based on, and
+   separation between the two lower order coefficients of the trinomial.  */
+
+/* Linear congruential.  */
+#define	TYPE_0		0
+#define	BREAK_0		8
+#define	DEG_0		0
+#define	SEP_0		0
+
+/* x**7 + x**3 + 1.  */
+#define	TYPE_1		1
+#define	BREAK_1		32
+#define	DEG_1		7
+#define	SEP_1		3
+
+/* x**15 + x + 1.  */
+#define	TYPE_2		2
+#define	BREAK_2		64
+#define	DEG_2		15
+#define	SEP_2		1
+
+/* x**31 + x**3 + 1.  */
+#define	TYPE_3		3
+#define	BREAK_3		128
+#define	DEG_3		31
+#define	SEP_3		3
+
+/* x**63 + x + 1.  */
+#define	TYPE_4		4
+#define	BREAK_4		256
+#define	DEG_4		63
+#define	SEP_4		1
+
+
+/* Array versions of the above information to make code run faster.
+   Relies on fact that TYPE_i == i.  */
+
+#define	MAX_TYPES	5	/* Max number of types above.  */
+
+
+/* Initially, everything is set up as if from:
+	initstate(1, randtbl, 128);
+   Note that this initialization takes advantage of the fact that srandom
+   advances the front and rear pointers 10*rand_deg times, and hence the
+   rear pointer which starts at 0 will also end up at zero; thus the zeroth
+   element of the state information, which contains info about the current
+   position of the rear pointer is just
+	(MAX_TYPES * (rptr - state)) + TYPE_3 == TYPE_3.  */
+
+static int randtbl[DEG_3 + 1] =
+  {
+    TYPE_3,
+
+    -1726662223, 379960547, 1735697613, 1040273694, 1313901226,
+    1627687941, -179304937, -2073333483, 1780058412, -1989503057,
+    -615974602, 344556628, 939512070, -1249116260, 1507946756,
+    -812545463, 154635395, 1388815473, -1926676823, 525320961,
+    -1009028674, 968117788, -123449607, 1284210865, 435012392,
+    -2017506339, -911064859, -370259173, 1132637927, 1398500161,
+    -205601318,
+  };
+
+
+static struct generate_random_data unsafe_state =
+  {
+/* FPTR and RPTR are two pointers into the state info, a front and a rear
+   pointer.  These two pointers are always rand_sep places aparts, as they
+   cycle through the state information.  (Yes, this does mean we could get
+   away with just one pointer, but the code for random is more efficient
+   this way).  The pointers are left positioned as they would be from the call:
+	initstate(1, randtbl, 128);
+   (The position of the rear pointer, rptr, is really 0 (as explained above
+   in the initialization of randtbl) because the state table pointer is set
+   to point to randtbl[1] (as explained below).)  */
+
+   &randtbl[SEP_3 + 1],  /* fptr */
+   &randtbl[1],          /* rptr */
+
+/* The following things are the pointer to the state information table,
+   the type of the current generator, the degree of the current polynomial
+   being used, and the separation between the two pointers.
+   Note that for efficiency of random, we remember the first location of
+   the state information, not the zeroth.  Hence it is valid to access
+   state[-1], which is used to store the type of the R.N.G.
+   Also, we remember the last location, since this is more efficient than
+   indexing every time to find the address of the last element to see if
+   the front and rear pointers have wrapped.  */
+
+    &randtbl[1],  /* state */
+
+    TYPE_3,  /* rand_type */
+    DEG_3,   /* rand_deg */
+    SEP_3,   /* rand_sep */
+
+    &randtbl[sizeof (randtbl) / sizeof (randtbl[0])]  /* end_ptr */
+};
+
+/* Initialize the random number generator based on the given seed.  If the
+   type is the trivial no-state-information type, just remember the seed.
+   Otherwise, initializes state[] based on the given "seed" via a linear
+   congruential generator.  Then, the pointers are set to known locations
+   that are exactly rand_sep places apart.  Lastly, it cycles the state
+   information a given number of times to get rid of any initial dependencies
+   introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
+   for default usage relies on values produced by this routine.  */
+void
+generate_srandom (unsigned int x)
+{
+  (void) generate_srandom_r (x, &unsafe_state);
+}
+
+/* Initialize the state information in the given array of N bytes for
+   future random number generation.  Based on the number of bytes we
+   are given, and the break values for the different R.N.G.'s, we choose
+   the best (largest) one we can and set things up for it.  srandom is
+   then called to initialize the state information.  Note that on return
+   from srandom, we set state[-1] to be the type multiplexed with the current
+   value of the rear pointer; this is so successive calls to initstate won't
+   lose this information and will be able to restart with setstate.
+   Note: The first thing we do is save the current state, if any, just like
+   setstate so that it doesn't matter when initstate is called.
+   Returns a pointer to the old state.  */
+char *
+generate_initstate (unsigned int seed, char *arg_state, size_t n)
+{
+  int *ostate;
+
+  ostate = &unsafe_state.state[-1];
+  generate_initstate_r (seed, arg_state, n, &unsafe_state);
+  return (char *) ostate;
+}
+
+/* Restore the state from the given state array.
+   Note: It is important that we also remember the locations of the pointers
+   in the current state information, and restore the locations of the pointers
+   from the old state information.  This is done by multiplexing the pointer
+   location into the zeroth word of the state information. Note that due
+   to the order in which things are done, it is OK to call setstate with the
+   same state as the current state
+   Returns a pointer to the old state information.  */
+char *
+generate_setstate (char *arg_state)
+{
+  int *ostate;
+
+  ostate = &unsafe_state.state[-1];
+  if (generate_setstate_r (arg_state, &unsafe_state) < 0)
+    ostate = NULL;
+  return (char *) ostate;
+}
+
+/* If we are using the trivial TYPE_0 R.N.G., just do the old linear
+   congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
+   same in all the other cases due to all the global variables that have been
+   set up.  The basic operation is to add the number at the rear pointer into
+   the one at the front pointer.  Then both pointers are advanced to the next
+   location cyclically in the table.  The value returned is the sum generated,
+   reduced to 31 bits by throwing away the "least random" low bit.
+   Note: The code takes advantage of the fact that both the front and
+   rear pointers can't wrap on the same call by not testing the rear
+   pointer if the front one has wrapped.  Returns a 31-bit random number.  */
+
+long int
+generate_random (void)
+{
+  int retval;
+  (void) generate_random_r (&unsafe_state, &retval);
+  return retval;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random.h
new file mode 100644
index 000000000..e14f526bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random.h
@@ -0,0 +1,33 @@
+/* Copyright (C) 2004 Free Software Foundation
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301 USA.  */
+
+struct generate_random_data
+  {
+    int *fptr, *rptr, *state;
+    int rand_type, rand_deg, rand_sep;
+    int *end_ptr;
+  };
+
+extern void generate_srandom (unsigned int);
+extern char *generate_initstate (unsigned int, char *, size_t);
+extern char *generate_setstate (char *);
+extern long int generate_random (void);
+extern int generate_random_r (struct generate_random_data *, int *);
+extern int generate_srandom_r (unsigned int, struct generate_random_data *);
+extern int generate_initstate_r (unsigned int, char *, size_t,
+				 struct generate_random_data *);
+extern int generate_setstate_r (char *, struct generate_random_data *);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random_r.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random_r.c
new file mode 100644
index 000000000..6e83f3596
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/generate-random_r.c
@@ -0,0 +1,385 @@
+/* 
+   Copyright (C) 1995, 2004 Free Software Foundation
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301 USA.  */
+
+/*
+   Copyright (C) 1983 Regents of the University of California.
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+   4. Neither the name of the University nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+   
+   THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+   SUCH DAMAGE.*/
+
+/*
+ * This is derived from the Berkeley source:
+ *	@(#)random.c	5.5 (Berkeley) 7/6/88
+ * It was reworked for the GNU C Library by Roland McGrath.
+ * Rewritten to be reentrant by Ulrich Drepper, 1995
+ */
+
+#include <limits.h>
+#include <stdlib.h>
+#include "generate-random.h"
+
+
+/* An improved random number generation package.  In addition to the standard
+   rand()/srand() like interface, this package also has a special state info
+   interface.  The initstate() routine is called with a seed, an array of
+   bytes, and a count of how many bytes are being passed in; this array is
+   then initialized to contain information for random number generation with
+   that much state information.  Good sizes for the amount of state
+   information are 32, 64, 128, and 256 bytes.  The state can be switched by
+   calling the setstate() function with the same array as was initialized
+   with initstate().  By default, the package runs with 128 bytes of state
+   information and generates far better random numbers than a linear
+   congruential generator.  If the amount of state information is less than
+   32 bytes, a simple linear congruential R.N.G. is used.  Internally, the
+   state information is treated as an array of longs; the zeroth element of
+   the array is the type of R.N.G. being used (small integer); the remainder
+   of the array is the state information for the R.N.G.  Thus, 32 bytes of
+   state information will give 7 longs worth of state information, which will
+   allow a degree seven polynomial.  (Note: The zeroth word of state
+   information also has some other information stored in it; see setstate
+   for details).  The random number generation technique is a linear feedback
+   shift register approach, employing trinomials (since there are fewer terms
+   to sum up that way).  In this approach, the least significant bit of all
+   the numbers in the state table will act as a linear feedback shift register,
+   and will have period 2^deg - 1 (where deg is the degree of the polynomial
+   being used, assuming that the polynomial is irreducible and primitive).
+   The higher order bits will have longer periods, since their values are
+   also influenced by pseudo-random carries out of the lower bits.  The
+   total period of the generator is approximately deg*(2**deg - 1); thus
+   doubling the amount of state information has a vast influence on the
+   period of the generator.  Note: The deg*(2**deg - 1) is an approximation
+   only good for large deg, when the period of the shift register is the
+   dominant factor.  With deg equal to seven, the period is actually much
+   longer than the 7*(2**7 - 1) predicted by this formula.  */
+
+
+
+/* For each of the currently supported random number generators, we have a
+   break value on the amount of state information (you need at least this many
+   bytes of state info to support this random number generator), a degree for
+   the polynomial (actually a trinomial) that the R.N.G. is based on, and
+   separation between the two lower order coefficients of the trinomial.  */
+
+/* Linear congruential.  */
+#define	TYPE_0		0
+#define	BREAK_0		8
+#define	DEG_0		0
+#define	SEP_0		0
+
+/* x**7 + x**3 + 1.  */
+#define	TYPE_1		1
+#define	BREAK_1		32
+#define	DEG_1		7
+#define	SEP_1		3
+
+/* x**15 + x + 1.  */
+#define	TYPE_2		2
+#define	BREAK_2		64
+#define	DEG_2		15
+#define	SEP_2		1
+
+/* x**31 + x**3 + 1.  */
+#define	TYPE_3		3
+#define	BREAK_3		128
+#define	DEG_3		31
+#define	SEP_3		3
+
+/* x**63 + x + 1.  */
+#define	TYPE_4		4
+#define	BREAK_4		256
+#define	DEG_4		63
+#define	SEP_4		1
+
+
+/* Array versions of the above information to make code run faster.
+   Relies on fact that TYPE_i == i.  */
+
+#define	MAX_TYPES	5	/* Max number of types above.  */
+
+struct random_poly_info
+{
+  int seps[MAX_TYPES];
+  int degrees[MAX_TYPES];
+};
+
+static const struct random_poly_info random_poly_info =
+{
+  { SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 },
+  { DEG_0, DEG_1, DEG_2, DEG_3, DEG_4 }
+};
+
+
+
+
+/* Initialize the random number generator based on the given seed.  If the
+   type is the trivial no-state-information type, just remember the seed.
+   Otherwise, initializes state[] based on the given "seed" via a linear
+   congruential generator.  Then, the pointers are set to known locations
+   that are exactly rand_sep places apart.  Lastly, it cycles the state
+   information a given number of times to get rid of any initial dependencies
+   introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
+   for default usage relies on values produced by this routine.  */
+int
+generate_srandom_r (unsigned int seed, struct generate_random_data *buf)
+{
+  int type;
+  int *state;
+  long int i;
+  long int word;
+  int *dst;
+  int kc;
+
+  if (buf == NULL)
+    goto fail;
+  type = buf->rand_type;
+  if ((unsigned int) type >= MAX_TYPES)
+    goto fail;
+
+  state = buf->state;
+  /* We must make sure the seed is not 0.  Take arbitrarily 1 in this case.  */
+  if (seed == 0)
+    seed = 1;
+  state[0] = seed;
+  if (type == TYPE_0)
+    goto done;
+
+  dst = state;
+  word = seed;
+  kc = buf->rand_deg;
+  for (i = 1; i < kc; ++i)
+    {
+      /* This does:
+	   state[i] = (16807 * state[i - 1]) % 2147483647;
+	 but avoids overflowing 31 bits.  */
+      long int hi = word / 127773;
+      long int lo = word % 127773;
+      word = 16807 * lo - 2836 * hi;
+      if (word < 0)
+	word += 2147483647;
+      *++dst = word;
+    }
+
+  buf->fptr = &state[buf->rand_sep];
+  buf->rptr = &state[0];
+  kc *= 10;
+  while (--kc >= 0)
+    {
+      int discard;
+      (void) generate_random_r (buf, &discard);
+    }
+
+ done:
+  return 0;
+
+ fail:
+  return -1;
+}
+
+/* Initialize the state information in the given array of N bytes for
+   future random number generation.  Based on the number of bytes we
+   are given, and the break values for the different R.N.G.'s, we choose
+   the best (largest) one we can and set things up for it.  srandom is
+   then called to initialize the state information.  Note that on return
+   from srandom, we set state[-1] to be the type multiplexed with the current
+   value of the rear pointer; this is so successive calls to initstate won't
+   lose this information and will be able to restart with setstate.
+   Note: The first thing we do is save the current state, if any, just like
+   setstate so that it doesn't matter when initstate is called.
+   Returns a pointer to the old state.  */
+int
+generate_initstate_r (unsigned int seed, char *arg_state, size_t n,
+		      struct generate_random_data *buf)
+{
+  int type;
+  int degree;
+  int separation;
+  int *state;
+
+  if (buf == NULL)
+    goto fail;
+
+  if (n >= BREAK_3)
+    type = n < BREAK_4 ? TYPE_3 : TYPE_4;
+  else if (n < BREAK_1)
+    {
+      if (n < BREAK_0)
+	{
+	  goto fail;
+	}
+      type = TYPE_0;
+    }
+  else
+    type = n < BREAK_2 ? TYPE_1 : TYPE_2;
+
+  degree = random_poly_info.degrees[type];
+  separation = random_poly_info.seps[type];
+
+  buf->rand_type = type;
+  buf->rand_sep = separation;
+  buf->rand_deg = degree;
+  state = &((int *) arg_state)[1];	/* First location.  */
+  /* Must set END_PTR before srandom.  */
+  buf->end_ptr = &state[degree];
+
+  buf->state = state;
+
+  generate_srandom_r (seed, buf);
+
+  state[-1] = TYPE_0;
+  if (type != TYPE_0)
+    state[-1] = (buf->rptr - state) * MAX_TYPES + type;
+
+  return 0;
+
+ fail:
+  return -1;
+}
+
+/* Restore the state from the given state array.
+   Note: It is important that we also remember the locations of the pointers
+   in the current state information, and restore the locations of the pointers
+   from the old state information.  This is done by multiplexing the pointer
+   location into the zeroth word of the state information. Note that due
+   to the order in which things are done, it is OK to call setstate with the
+   same state as the current state
+   Returns a pointer to the old state information.  */
+int
+generate_setstate_r (char *arg_state, struct generate_random_data *buf)
+{
+  int *new_state = 1 + (int *) arg_state;
+  int type;
+  int old_type;
+  int *old_state;
+  int degree;
+  int separation;
+
+  if (arg_state == NULL || buf == NULL)
+    goto fail;
+
+  old_type = buf->rand_type;
+  old_state = buf->state;
+  if (old_type == TYPE_0)
+    old_state[-1] = TYPE_0;
+  else
+    old_state[-1] = (MAX_TYPES * (buf->rptr - old_state)) + old_type;
+
+  type = new_state[-1] % MAX_TYPES;
+  if (type < TYPE_0 || type > TYPE_4)
+    goto fail;
+
+  buf->rand_deg = degree = random_poly_info.degrees[type];
+  buf->rand_sep = separation = random_poly_info.seps[type];
+  buf->rand_type = type;
+
+  if (type != TYPE_0)
+    {
+      int rear = new_state[-1] / MAX_TYPES;
+      buf->rptr = &new_state[rear];
+      buf->fptr = &new_state[(rear + separation) % degree];
+    }
+  buf->state = new_state;
+  /* Set end_ptr too.  */
+  buf->end_ptr = &new_state[degree];
+
+  return 0;
+
+ fail:
+  return -1;
+}
+
+/* If we are using the trivial TYPE_0 R.N.G., just do the old linear
+   congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
+   same in all the other cases due to all the global variables that have been
+   set up.  The basic operation is to add the number at the rear pointer into
+   the one at the front pointer.  Then both pointers are advanced to the next
+   location cyclically in the table.  The value returned is the sum generated,
+   reduced to 31 bits by throwing away the "least random" low bit.
+   Note: The code takes advantage of the fact that both the front and
+   rear pointers can't wrap on the same call by not testing the rear
+   pointer if the front one has wrapped.  Returns a 31-bit random number.  */
+
+int
+generate_random_r (struct generate_random_data *buf, int *result)
+{
+  int *state;
+
+  if (buf == NULL || result == NULL)
+    goto fail;
+
+  state = buf->state;
+
+  if (buf->rand_type == TYPE_0)
+    {
+      int val = state[0];
+      val = ((state[0] * 1103515245) + 12345) & 0x7fffffff;
+      state[0] = val;
+      *result = val;
+    }
+  else
+    {
+      int *fptr = buf->fptr;
+      int *rptr = buf->rptr;
+      int *end_ptr = buf->end_ptr;
+      int val;
+
+      val = *fptr += *rptr;
+      /* Chucking least random bit.  */
+      *result = (val >> 1) & 0x7fffffff;
+      ++fptr;
+      if (fptr >= end_ptr)
+	{
+	  fptr = state;
+	  ++rptr;
+	}
+      else
+	{
+	  ++rptr;
+	  if (rptr >= end_ptr)
+	    rptr = state;
+	}
+      buf->fptr = fptr;
+      buf->rptr = rptr;
+    }
+  return 0;
+
+ fail:
+  return -1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-check.h
new file mode 100644
index 000000000..248ffb215
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-check.h
@@ -0,0 +1,37 @@
+/* Function definitions that are used by multiple tests.  */
+
+void checkScd (Scd x, int i)
+{ if (x.c != (char)i || x.d != (double)i+1) DEBUG_CHECK }
+void checkScdc (Scdc x, int i)
+{ if (x.c != (char)i || x.d != (double)i+1 || x.b != (char)i+2) DEBUG_CHECK }
+void checkSd (Sd x, int i)
+{ if (x.d != (double)i) DEBUG_CHECK }
+void checkSdi (Sdi x, int i)
+{ if (x.d != (double)i || x.i != i+1) DEBUG_CHECK }
+void checkScsds (Scsds x, int i)
+{ if (x.c != (char)i || x.sd.d != (double)i+1) DEBUG_CHECK }
+void checkScsdsc (Scsdsc x, int i)
+{ if (x.c != (char)i || x.sd.d != (double)i+1 || x.b != (char)i+2) DEBUG_CHECK }
+void checkScsdis (Scsdis x, int i)
+{ if (x.c != (char)i || x.sdi.d != (double)i+1 || x.sdi.i != i+2) DEBUG_CHECK }
+void checkScsdisc (Scsdisc x, int i)
+{ if (x.c != (char)i || x.sdi.d != (double)i+1 || x.sdi.i != i+2
+    || x.b != (char)i+3) DEBUG_CHECK }
+void checkSsds (Ssds x, int i)
+{ if (x.sd.d != (double)i) DEBUG_CHECK }
+void checkSsdsc (Ssdsc x, int i)
+{ if (x.sd.d != (double)i || x.c != (char)i+1) DEBUG_CHECK }
+void checkScssdss (Scssdss x, int i)
+{ if (x.c != (char)i || x.ssds.sd.d != (double)i+1) DEBUG_CHECK }
+void checkScssdssc (Scssdssc x, int i)
+{ if (x.c != (char)i || x.ssds.sd.d != (double)i+1
+    || x.b != (char)i+2) DEBUG_CHECK }
+
+void checkSfi (Sfi x, int i)
+{ if (x.f != (float)i || x.i != i+1) DEBUG_CHECK }
+void checkSfii (Sfii x, int i)
+{ if (x.f != (float)i || x.i1 != i+1 || x.i2 != i+2) DEBUG_CHECK }
+void checkSfifi (Sfifi x, int i)
+{ if (x.fi.f != (float)i || x.fi.i != i+1) DEBUG_CHECK }
+void checkSfiifii (Sfiifii x, int i)
+{ if (x.fii.f != (float)i || x.fii.i1 != i+1 || x.fii.i2 != i+2) DEBUG_CHECK }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-defs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-defs.h
new file mode 100644
index 000000000..9a313790f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-defs.h
@@ -0,0 +1,19 @@
+/* Type definitions that are used by multiple tests.  */
+
+typedef struct { char c; double d; } Scd;
+typedef struct { char c; double d; char b; } Scdc;
+typedef struct { double d; } Sd;
+typedef struct { double d; int i; } Sdi;
+typedef struct { char c; Sd sd; } Scsds;
+typedef struct { char c; Sd sd; char b; } Scsdsc;
+typedef struct { char c; Sdi sdi; } Scsdis;
+typedef struct { char c; Sdi sdi; char b; } Scsdisc;
+typedef struct { Sd sd; } Ssds;
+typedef struct { Sd sd; char c; } Ssdsc;
+typedef struct { char c; Ssds ssds; } Scssdss;
+typedef struct { char c; Ssds ssds; char b; } Scssdssc;
+
+typedef struct { float f; int i; } Sfi;
+typedef struct { float f; int i1; int i2; } Sfii;
+typedef struct { float f; int i; Sfi fi; } Sfifi;
+typedef struct { float f; int i1; int i2; Sfii fii; } Sfiifii;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-init.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-init.h
new file mode 100644
index 000000000..b11fc2404
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/mixed-struct-init.h
@@ -0,0 +1,35 @@
+/* Function definitions that are used by multiple tests.  */
+
+void initScd (Scd *p, int i)
+{ p->c = (char)i; p->d = (double)i+1; }
+void initScdc (Scdc *p, int i)
+{ p->c = (char)i; p->d = (double)i+1; p->b = (char)i+2; }
+void initSd (Sd *p, int i)
+{ p->d = (double)i; }
+void initSdi (Sdi *p, int i)
+{ p->d = (double)i; p->i = i+1; }
+void initScsds (Scsds *p, int i)
+{ p->c = (char)i; p->sd.d = (double)i+1; }
+void initScsdsc (Scsdsc *p, int i)
+{ p->c = (char)i; p->sd.d = (double)i+1; p->b = (char)i+2; }
+void initScsdis (Scsdis *p, int i)
+{ p->c = (char)i; p->sdi.d = (double)i+1; p->sdi.i = i+2; }
+void initScsdisc (Scsdisc *p, int i)
+{ p->c = (char)i; p->sdi.d = (double)i+1; p->sdi.i = i+2; p->b = (char)i+3; }
+void initSsds (Ssds *p, int i)
+{ p->sd.d = (double)i; }
+void initSsdsc (Ssdsc *p, int i)
+{ p->sd.d = (double)i; p->c = (char)i+1; }
+void initScssdss (Scssdss *p, int i)
+{ p->c = (char)i; p->ssds.sd.d = (double)i+1; }
+void initScssdssc (Scssdssc *p, int i)
+{ p->c = (char)i; p->ssds.sd.d = (double)i+1; p->b = (char)i+2; }
+
+void initSfi (Sfi *x, int i)
+{ x->f = (float)i; x->i = i+1; }
+void initSfii (Sfii *x, int i)
+{ x->f = (float)i; x->i1 = i+1; x->i2 = i+2; }
+void initSfifi (Sfifi *x, int i)
+{ x->fi.f = (float)i; x->fi.i = i+1; }
+void initSfiifii (Sfiifii *x, int i)
+{ x->fii.f = (float)i; x->fii.i1 = i+1; x->fii.i2 = i+2; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_main.c
new file mode 100644
index 000000000..88c3586db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_main.c
@@ -0,0 +1,18 @@
+/* PR target/38736 */
+/* { dg-skip-if "attribute ((aligned))" { ! { i?86-*-* x86_64-*-* } } } */
+/* { dg-require-effective-target avx } */
+
+/* Test compatibility of attribute ((aligned)) with and without -mavx.  */
+
+extern int aligned_x (void);
+extern int aligned_y_avx (void);
+extern void abort (void);
+
+int
+main ()
+{
+  if (aligned_x () != aligned_y_avx ())
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_x.c
new file mode 100644
index 000000000..aeab257aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_x.c
@@ -0,0 +1,15 @@
+/* PR target/38736 */
+/* { dg-options "-O2" } */
+
+struct alignment_test_struct
+{
+  char space[4] __attribute__((__aligned__));
+};
+
+extern int aligned_x (void);
+
+int
+aligned_x (void)
+{
+  return __alignof__(struct alignment_test_struct);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_y.c
new file mode 100644
index 000000000..7e46afa8d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/pr38736_y.c
@@ -0,0 +1,6 @@
+/* PR target/38736 */
+/* { dg-options "-O2 -mavx" } */
+
+#define aligned_x aligned_y_avx
+
+#include "pr38736_x.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_main.c
new file mode 100644
index 000000000..5272a379f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_main.c
@@ -0,0 +1,13 @@
+/* Test passing scalars by value.  This test includes scalar types that
+   are supported by va_arg.  */
+
+extern void scalar_by_value_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_by_value_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_x.c
new file mode 100644
index 000000000..3bfa76644
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_x.c
@@ -0,0 +1,180 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern void							\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16);		\
+extern void testva##NAME (int n, ...);				\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v + INITVAL)						\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+test2_##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+	      TYPE x05, TYPE x06, TYPE x07, TYPE x08)		\
+{								\
+  test##NAME (x01, g02##NAME, x02, g04##NAME,			\
+	      x03, g06##NAME, x04, g08##NAME,			\
+	      x05, g10##NAME, x06, g12##NAME,			\
+	      x07, g14##NAME, x08, g16##NAME);			\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##NAME (g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+	      g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+	      g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+	      g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##NAME (1,						\
+		g01##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (2,						\
+		g01##NAME, g02##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (3,						\
+		g01##NAME, g02##NAME, g03##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (4,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (5,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (6,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (7,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (8,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (9,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (10,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (11,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (12,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (13,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (14,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (15,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME, g15##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (16,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##NAME (g01##NAME, g03##NAME, g05##NAME, g07##NAME,	\
+		g09##NAME, g11##NAME, g13##NAME, g15##NAME);	\
+  DEBUG_NL;							\
+}
+
+T(ui, unsigned int, 51)
+T(si, int, (-55))
+T(ul, unsigned long, 61)
+T(sl, long, (-66))
+T(ull, unsigned long long, 71)
+T(sll, long long, (-77))
+T(d, double, 91.0)
+T(ld, long double, 92.0)
+
+#undef T
+
+void
+scalar_by_value_1_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+T(ui)
+T(si)
+T(ul)
+T(sl)
+T(ull)
+T(sll)
+T(d)
+T(ld)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_y.c
new file mode 100644
index 000000000..73f3de0e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-1_y.c
@@ -0,0 +1,94 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1);					\
+  check##NAME (g02##NAME,  2);					\
+  check##NAME (g03##NAME,  3);					\
+  check##NAME (g04##NAME,  4);					\
+  check##NAME (g05##NAME,  5);					\
+  check##NAME (g06##NAME,  6);					\
+  check##NAME (g07##NAME,  7);					\
+  check##NAME (g08##NAME,  8);					\
+  check##NAME (g09##NAME,  9);					\
+  check##NAME (g10##NAME, 10);					\
+  check##NAME (g11##NAME, 11);					\
+  check##NAME (g12##NAME, 12);					\
+  check##NAME (g13##NAME, 13);					\
+  check##NAME (g14##NAME, 14);					\
+  check##NAME (g15##NAME, 15);					\
+  check##NAME (g16##NAME, 16);					\
+}								\
+								\
+void								\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16)		\
+{								\
+  check##NAME (x01,  1);					\
+  check##NAME (x02,  2);					\
+  check##NAME (x03,  3);					\
+  check##NAME (x04,  4);					\
+  check##NAME (x05,  5);					\
+  check##NAME (x06,  6);					\
+  check##NAME (x07,  7);					\
+  check##NAME (x08,  8);					\
+  check##NAME (x09,  9);					\
+  check##NAME (x10, 10);					\
+  check##NAME (x11, 11);					\
+  check##NAME (x12, 12);					\
+  check##NAME (x13, 13);					\
+  check##NAME (x14, 14);					\
+  check##NAME (x15, 15);					\
+  check##NAME (x16, 16);					\
+}								\
+								\
+void								\
+testva##NAME (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##NAME (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(ui, unsigned int, 51)
+T(si, int, (-55))
+T(ul, unsigned long, 61)
+T(sl, long, (-66))
+T(ull, unsigned long long, 71)
+T(sll, long long, (-77))
+T(d, double, 91.0)
+T(ld, long double, 92.0)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_main.c
new file mode 100644
index 000000000..8426b7894
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_main.c
@@ -0,0 +1,15 @@
+/* Test passing scalars by value.  This test includes scalar types that
+   are not supported by va_arg; since they require casts to pass to a
+   function with a variable argument list, testing them with variable
+   arguments is not interesting.  */
+
+extern void scalar_by_value_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_by_value_2_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_x.c
new file mode 100644
index 000000000..48ea1d997
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_x.c
@@ -0,0 +1,100 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern void							\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16);		\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v + INITVAL)						\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+test2_##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+	      TYPE x05, TYPE x06, TYPE x07, TYPE x08)		\
+{								\
+  test##NAME (x01, g02##NAME, x02, g04##NAME,			\
+	      x03, g06##NAME, x04, g08##NAME,			\
+	      x05, g10##NAME, x06, g12##NAME,			\
+	      x07, g14##NAME, x08, g16##NAME);			\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##NAME (g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+	      g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+	      g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+	      g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##NAME (g01##NAME, g03##NAME, g05##NAME, g07##NAME,	\
+		g09##NAME, g11##NAME, g13##NAME, g15##NAME);	\
+  DEBUG_NL;							\
+}
+
+T(c, char, 21)
+T(uc, unsigned char, 22)
+T(sc, signed char, (-33))
+T(us, unsigned short, 41)
+T(ss, short, (-44))
+T(f, float, 90.0)
+
+#undef T
+
+void
+scalar_by_value_2_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+T(c)
+T(uc)
+T(sc)
+T(us)
+T(ss)
+T(f)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_y.c
new file mode 100644
index 000000000..2eea6135d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-2_y.c
@@ -0,0 +1,69 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1);					\
+  check##NAME (g02##NAME,  2);					\
+  check##NAME (g03##NAME,  3);					\
+  check##NAME (g04##NAME,  4);					\
+  check##NAME (g05##NAME,  5);					\
+  check##NAME (g06##NAME,  6);					\
+  check##NAME (g07##NAME,  7);					\
+  check##NAME (g08##NAME,  8);					\
+  check##NAME (g09##NAME,  9);					\
+  check##NAME (g10##NAME, 10);					\
+  check##NAME (g11##NAME, 11);					\
+  check##NAME (g12##NAME, 12);					\
+  check##NAME (g13##NAME, 13);					\
+  check##NAME (g14##NAME, 14);					\
+  check##NAME (g15##NAME, 15);					\
+  check##NAME (g16##NAME, 16);					\
+}								\
+								\
+void								\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16)		\
+{								\
+  check##NAME (x01,  1);					\
+  check##NAME (x02,  2);					\
+  check##NAME (x03,  3);					\
+  check##NAME (x04,  4);					\
+  check##NAME (x05,  5);					\
+  check##NAME (x06,  6);					\
+  check##NAME (x07,  7);					\
+  check##NAME (x08,  8);					\
+  check##NAME (x09,  9);					\
+  check##NAME (x10, 10);					\
+  check##NAME (x11, 11);					\
+  check##NAME (x12, 12);					\
+  check##NAME (x13, 13);					\
+  check##NAME (x14, 14);					\
+  check##NAME (x15, 15);					\
+  check##NAME (x16, 16);					\
+}
+
+T(c, char, 21)
+T(uc, unsigned char, 22)
+T(sc, signed char, (-33))
+T(us, unsigned short, 41)
+T(ss, short, (-44))
+T(f, float, 90.0)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_main.c
new file mode 100644
index 000000000..307e6ccb6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_main.c
@@ -0,0 +1,14 @@
+/* Test passing scalars by value.  This test includes _Complex types
+   whose real and imaginary parts can be used in variable-length
+   argument lists.  */
+
+extern void scalar_by_value_3_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_by_value_3_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_x.c
new file mode 100644
index 000000000..e63f5fd38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_x.c
@@ -0,0 +1,182 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern void							\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16);		\
+extern void testva##NAME (int n, ...);				\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v + INITVAL)						\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+test2_##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+	      TYPE x05, TYPE x06, TYPE x07, TYPE x08)		\
+{								\
+  test##NAME (x01, g02##NAME, x02, g04##NAME,			\
+	      x03, g06##NAME, x04, g08##NAME,			\
+	      x05, g10##NAME, x06, g12##NAME,			\
+	      x07, g14##NAME, x08, g16##NAME);			\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##NAME (g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+	      g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+	      g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+	      g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##NAME (1,						\
+		g01##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (2,						\
+		g01##NAME, g02##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (3,						\
+		g01##NAME, g02##NAME, g03##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (4,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (5,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (6,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (7,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (8,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (9,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (10,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (11,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (12,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (13,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (14,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (15,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME, g15##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (16,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##NAME (g01##NAME, g03##NAME, g05##NAME, g07##NAME,	\
+		g09##NAME, g11##NAME, g13##NAME, g15##NAME);	\
+  DEBUG_NL;							\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(ci, _Complex int, CINT (2, 3))
+T(cl, _Complex long, CINT (3, 4))
+T(cll, _Complex long long, CINT (5, 6))
+#endif
+T(cd, _Complex double, CDBL (7.0, 8.0))
+T(cld, _Complex long double, CDBL (8.0, 9.0))
+#endif
+
+#undef T
+
+void
+scalar_by_value_3_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(ci)
+T(cl)
+T(cll)
+#endif
+T(cd)
+T(cld)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_y.c
new file mode 100644
index 000000000..d470ef605
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-3_y.c
@@ -0,0 +1,95 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1);					\
+  check##NAME (g02##NAME,  2);					\
+  check##NAME (g03##NAME,  3);					\
+  check##NAME (g04##NAME,  4);					\
+  check##NAME (g05##NAME,  5);					\
+  check##NAME (g06##NAME,  6);					\
+  check##NAME (g07##NAME,  7);					\
+  check##NAME (g08##NAME,  8);					\
+  check##NAME (g09##NAME,  9);					\
+  check##NAME (g10##NAME, 10);					\
+  check##NAME (g11##NAME, 11);					\
+  check##NAME (g12##NAME, 12);					\
+  check##NAME (g13##NAME, 13);					\
+  check##NAME (g14##NAME, 14);					\
+  check##NAME (g15##NAME, 15);					\
+  check##NAME (g16##NAME, 16);					\
+}								\
+								\
+void								\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16)		\
+{								\
+  check##NAME (x01,  1);					\
+  check##NAME (x02,  2);					\
+  check##NAME (x03,  3);					\
+  check##NAME (x04,  4);					\
+  check##NAME (x05,  5);					\
+  check##NAME (x06,  6);					\
+  check##NAME (x07,  7);					\
+  check##NAME (x08,  8);					\
+  check##NAME (x09,  9);					\
+  check##NAME (x10, 10);					\
+  check##NAME (x11, 11);					\
+  check##NAME (x12, 12);					\
+  check##NAME (x13, 13);					\
+  check##NAME (x14, 14);					\
+  check##NAME (x15, 15);					\
+  check##NAME (x16, 16);					\
+}								\
+								\
+void								\
+testva##NAME (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##NAME (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(ci, _Complex int, CINT (2, 3))
+T(cl, _Complex long, CINT (3, 4))
+T(cll, _Complex long long, CINT (5, 6))
+#endif
+T(cd, _Complex double, CDBL (7.0, 8.0))
+T(cld, _Complex long double, CDBL (8.0, 9.0))
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_main.c
new file mode 100644
index 000000000..8164b4428
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_main.c
@@ -0,0 +1,14 @@
+/* Test passing scalars by value.  This test includes _Complex types
+   whose real and imaginary parts cannot be used in variable-length
+   argument lists.  */
+
+extern void scalar_by_value_4_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_by_value_4_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_x.c
new file mode 100644
index 000000000..a4e73c9fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_x.c
@@ -0,0 +1,102 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern void							\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16);		\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v + INITVAL)						\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+test2_##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+	      TYPE x05, TYPE x06, TYPE x07, TYPE x08)		\
+{								\
+  test##NAME (x01, g02##NAME, x02, g04##NAME,			\
+	      x03, g06##NAME, x04, g08##NAME,			\
+	      x05, g10##NAME, x06, g12##NAME,			\
+	      x07, g14##NAME, x08, g16##NAME);			\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##NAME (g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+	      g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+	      g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+	      g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##NAME (g01##NAME, g03##NAME, g05##NAME, g07##NAME,	\
+		g09##NAME, g11##NAME, g13##NAME, g15##NAME);	\
+  DEBUG_NL;							\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(cc, _Complex char, CINT (0, 1))
+T(cs, _Complex short, CINT (1, 2))
+#endif
+T(cf, _Complex float, CDBL (6.0, 7.0))
+#endif
+
+#undef T
+
+void
+scalar_by_value_4_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(cc)
+T(cs)
+#endif
+T(cf)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_y.c
new file mode 100644
index 000000000..e0fa70539
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-4_y.c
@@ -0,0 +1,76 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1);					\
+  check##NAME (g02##NAME,  2);					\
+  check##NAME (g03##NAME,  3);					\
+  check##NAME (g04##NAME,  4);					\
+  check##NAME (g05##NAME,  5);					\
+  check##NAME (g06##NAME,  6);					\
+  check##NAME (g07##NAME,  7);					\
+  check##NAME (g08##NAME,  8);					\
+  check##NAME (g09##NAME,  9);					\
+  check##NAME (g10##NAME, 10);					\
+  check##NAME (g11##NAME, 11);					\
+  check##NAME (g12##NAME, 12);					\
+  check##NAME (g13##NAME, 13);					\
+  check##NAME (g14##NAME, 14);					\
+  check##NAME (g15##NAME, 15);					\
+  check##NAME (g16##NAME, 16);					\
+}								\
+								\
+void								\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16)		\
+{								\
+  check##NAME (x01,  1);					\
+  check##NAME (x02,  2);					\
+  check##NAME (x03,  3);					\
+  check##NAME (x04,  4);					\
+  check##NAME (x05,  5);					\
+  check##NAME (x06,  6);					\
+  check##NAME (x07,  7);					\
+  check##NAME (x08,  8);					\
+  check##NAME (x09,  9);					\
+  check##NAME (x10, 10);					\
+  check##NAME (x11, 11);					\
+  check##NAME (x12, 12);					\
+  check##NAME (x13, 13);					\
+  check##NAME (x14, 14);					\
+  check##NAME (x15, 15);					\
+  check##NAME (x16, 16);					\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(cc, _Complex char, CINT (0, 1))
+T(cs, _Complex short, CINT (1, 2))
+#endif
+T(cf, _Complex float, CDBL (6.0, 7.0))
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5.c
new file mode 100644
index 000000000..1c336d81a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5.c
@@ -0,0 +1,22 @@
+TEST_FUNCS (longlong_i, long long, int,
+	    1234LL, -987)
+TEST_FUNCS (longlong_d, long long, double,
+	    1234LL, -987.0)
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+TEST_FUNCS (complexint_i, _Complex int, int,
+	    1234 + 567i, -987)
+TEST_FUNCS (complexint_d, _Complex int, double,
+	    1234 + 567i, -987.0)
+#endif
+TEST_FUNCS (complexdouble_i, _Complex double, int,
+	    1234.0 + 567.0i, -987)
+TEST_FUNCS (complexdouble_d, _Complex double, double,
+	    1234.0 + 567.0i, -987.0)
+#ifndef SKIP_COMPLEX_INT
+TEST_FUNCS (complexlonglong_i, _Complex long long, int,
+	    1234LL + 567LLi, -987)
+TEST_FUNCS (complexlonglong_d, _Complex long long, double,
+	    1234LL + 567LLi, -987.0)
+#endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_main.c
new file mode 100644
index 000000000..d29597e3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_main.c
@@ -0,0 +1,32 @@
+/* Test that function args can be passed in various positions to both fixed
+   and variable arg functions.  */
+/* { dg-options "-O" } */
+
+extern void exit (int);
+extern void longlong_i_doit (void);
+extern void longlong_d_doit (void);
+extern void complexint_i_doit (void);
+extern void complexint_d_doit (void);
+extern void complexdouble_i_doit (void);
+extern void complexdouble_d_doit (void);
+extern void complexlonglong_i_doit (void);
+extern void complexlonglong_d_doit (void);
+
+int main (void)
+{
+  longlong_i_doit ();
+  longlong_d_doit ();
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+  complexint_i_doit ();
+  complexint_d_doit ();
+#endif
+  complexdouble_i_doit ();
+  complexdouble_d_doit ();
+#ifndef SKIP_COMPLEX_INT
+  complexlonglong_i_doit ();
+  complexlonglong_d_doit ();
+#endif
+#endif
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_x.c
new file mode 100644
index 000000000..5266bdf67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_x.c
@@ -0,0 +1,2 @@
+#include "scalar-by-value-x.h"
+#include "scalar-by-value-5.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_y.c
new file mode 100644
index 000000000..78d985a24
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-5_y.c
@@ -0,0 +1,2 @@
+#include "scalar-by-value-y.h"
+#include "scalar-by-value-5.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6.c
new file mode 100644
index 000000000..af65398f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6.c
@@ -0,0 +1,6 @@
+TEST_FUNCS (longdouble_i, long double, int, d, -987)
+TEST_FUNCS (longdouble_d, long double, double, d, -987.0)
+#ifndef SKIP_COMPLEX
+TEST_FUNCS (complexlongdouble_i, _Complex long double, int, cd, -987)
+TEST_FUNCS (complexlongdouble_d, _Complex long double, double, cd, -987.0)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_main.c
new file mode 100644
index 000000000..f6b3c1d8a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_main.c
@@ -0,0 +1,23 @@
+/* Test that function args can be passed in various positions to both fixed
+   and variable arg functions.  */
+/* { dg-options "-O" } */
+/* { dg-options "-O -mlong-double-128" { target powerpc*-*-* } } */
+
+extern void exit (int);
+extern void longdouble_i_doit (void);
+extern void longdouble_d_doit (void);
+#ifndef SKIP_COMPLEX
+extern void complexlongdouble_i_doit (void);
+extern void complexlongdouble_d_doit (void);
+#endif
+
+int main (void)
+{
+  longdouble_i_doit ();
+  longdouble_d_doit ();
+#ifndef SKIP_COMPLEX
+  complexlongdouble_i_doit ();
+  complexlongdouble_d_doit ();
+#endif
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_x.c
new file mode 100644
index 000000000..27aa48fbe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_x.c
@@ -0,0 +1,8 @@
+#include "scalar-by-value-x.h"
+
+extern long double d;
+#ifndef SKIP_COMPLEX
+extern _Complex long double cd;
+#endif
+
+#include "scalar-by-value-6.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_y.c
new file mode 100644
index 000000000..2e9aed282
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-6_y.c
@@ -0,0 +1,8 @@
+#include "scalar-by-value-y.h"
+
+long double d = 1234.0L + 0x0.abcdp-70L;
+#ifndef SKIP_COMPLEX
+_Complex long double cd = 234.0L + 0x0.abcp-70L + 567.0Li +0x0defp-70Li;
+#endif
+
+#include "scalar-by-value-6.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_main.c
new file mode 100644
index 000000000..7f81d6a37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_main.c
@@ -0,0 +1,15 @@
+/* Test passing scalars by value.  This test includes scalar types that
+   are supported by va_arg.  */
+
+/* { dg-require-compat-dfp "" } */
+
+extern void scalar_by_value_dfp_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_by_value_dfp_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_x.c
new file mode 100644
index 000000000..8f55671c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_x.c
@@ -0,0 +1,170 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern void							\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16);		\
+extern void testva##NAME (int n, ...);				\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v + INITVAL)						\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+test2_##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+	      TYPE x05, TYPE x06, TYPE x07, TYPE x08)		\
+{								\
+  test##NAME (x01, g02##NAME, x02, g04##NAME,			\
+	      x03, g06##NAME, x04, g08##NAME,			\
+	      x05, g10##NAME, x06, g12##NAME,			\
+	      x07, g14##NAME, x08, g16##NAME);			\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##NAME (g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+	      g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+	      g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+	      g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##NAME (1,						\
+		g01##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (2,						\
+		g01##NAME, g02##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (3,						\
+		g01##NAME, g02##NAME, g03##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (4,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (5,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (6,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (7,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (8,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (9,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (10,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (11,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (12,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME);	\
+  DEBUG_NL;							\
+  testva##NAME (13,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME);					\
+  DEBUG_NL;							\
+  testva##NAME (14,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME);				\
+  DEBUG_NL;							\
+  testva##NAME (15,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME, g15##NAME);		\
+  DEBUG_NL;							\
+  testva##NAME (16,						\
+		g01##NAME, g02##NAME, g03##NAME, g04##NAME,	\
+		g05##NAME, g06##NAME, g07##NAME, g08##NAME,	\
+		g09##NAME, g10##NAME, g11##NAME, g12##NAME,	\
+		g13##NAME, g14##NAME, g15##NAME, g16##NAME);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##NAME (g01##NAME, g03##NAME, g05##NAME, g07##NAME,	\
+		g09##NAME, g11##NAME, g13##NAME, g15##NAME);	\
+  DEBUG_NL;							\
+}
+
+T(d32, _Decimal32, 1.2df)
+T(d64, _Decimal64, 12.34dd)
+T(d128, _Decimal128, 123.456dl)
+
+#undef T
+
+void
+scalar_by_value_dfp_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+T(d32)
+T(d64)
+T(d128)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_y.c
new file mode 100644
index 000000000..9b1f49f69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-dfp_y.c
@@ -0,0 +1,89 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1);					\
+  check##NAME (g02##NAME,  2);					\
+  check##NAME (g03##NAME,  3);					\
+  check##NAME (g04##NAME,  4);					\
+  check##NAME (g05##NAME,  5);					\
+  check##NAME (g06##NAME,  6);					\
+  check##NAME (g07##NAME,  7);					\
+  check##NAME (g08##NAME,  8);					\
+  check##NAME (g09##NAME,  9);					\
+  check##NAME (g10##NAME, 10);					\
+  check##NAME (g11##NAME, 11);					\
+  check##NAME (g12##NAME, 12);					\
+  check##NAME (g13##NAME, 13);					\
+  check##NAME (g14##NAME, 14);					\
+  check##NAME (g15##NAME, 15);					\
+  check##NAME (g16##NAME, 16);					\
+}								\
+								\
+void								\
+test##NAME (TYPE x01, TYPE x02, TYPE x03, TYPE x04,		\
+            TYPE x05, TYPE x06, TYPE x07, TYPE x08,		\
+            TYPE x09, TYPE x10, TYPE x11, TYPE x12,		\
+            TYPE x13, TYPE x14, TYPE x15, TYPE x16)		\
+{								\
+  check##NAME (x01,  1);					\
+  check##NAME (x02,  2);					\
+  check##NAME (x03,  3);					\
+  check##NAME (x04,  4);					\
+  check##NAME (x05,  5);					\
+  check##NAME (x06,  6);					\
+  check##NAME (x07,  7);					\
+  check##NAME (x08,  8);					\
+  check##NAME (x09,  9);					\
+  check##NAME (x10, 10);					\
+  check##NAME (x11, 11);					\
+  check##NAME (x12, 12);					\
+  check##NAME (x13, 13);					\
+  check##NAME (x14, 14);					\
+  check##NAME (x15, 15);					\
+  check##NAME (x16, 16);					\
+}								\
+								\
+void								\
+testva##NAME (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##NAME (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(d32, _Decimal32, 1.2df)
+T(d64, _Decimal64, 12.34dd)
+T(d128, _Decimal128, 123.456dl)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-x.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-x.h
new file mode 100644
index 000000000..f0ac216ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-x.h
@@ -0,0 +1,77 @@
+#if DEBUG
+#include <stdio.h>
+#define DBG(x) fputs (x, stdout); fflush (stdout);
+#else
+#define DBG(x)
+#endif
+
+#define TEST_FUNCS(NAME, TYPE, PADT, VAL, VAL2) \
+extern void NAME##_f0 (TYPE a, PADT b);					\
+extern void NAME##_f1 (PADT z0, TYPE a, PADT b);			\
+extern void NAME##_f2 (PADT z0, PADT z1, TYPE a, PADT b);		\
+extern void NAME##_f3 (PADT z0, PADT z1, PADT z2, TYPE a, PADT b);	\
+extern void NAME##_f4 (PADT z0, PADT z1, PADT z2, PADT z3, TYPE a,	\
+		       PADT b);						\
+extern void NAME##_f5 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4,	\
+		       TYPE a, PADT b);					\
+extern void NAME##_f6 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4,	\
+		       PADT z5, TYPE a, PADT b);			\
+extern void NAME##_f7 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4,	\
+		       PADT z5, PADT z6, TYPE a, PADT b);		\
+extern void NAME##_f8 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4,	\
+		       PADT z5, PADT z6, PADT z7, TYPE a, PADT b);	\
+extern void NAME##_f9 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4,	\
+		       PADT z5, PADT z6, PADT z7, PADT z8, TYPE a,	\
+		       PADT b);						\
+extern void NAME##_fv (int n, ...);					\
+									\
+void NAME##_doit (void)							\
+{									\
+  NAME##_f0 (VAL, VAL2);						\
+  DBG (".");								\
+  NAME##_f1 ((PADT) 0, VAL, VAL2);					\
+  DBG (".");								\
+  NAME##_f2 ((PADT) 0, (PADT) 0, VAL, VAL2);				\
+  DBG (".");								\
+  NAME##_f3 ((PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);			\
+  DBG (".");								\
+  NAME##_f4 ((PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);	\
+  DBG (".");								\
+  NAME##_f5 ((PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,		\
+	     VAL, VAL2);						\
+  DBG (".");								\
+  NAME##_f6 ((PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,		\
+	     (PADT) 0, VAL, VAL2);					\
+  DBG (".");								\
+  NAME##_f7 ((PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,		\
+	     (PADT) 0, (PADT) 0, VAL, VAL2);				\
+  DBG (".");								\
+  NAME##_f8 ((PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,		\
+	     (PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);			\
+  DBG (".");								\
+  NAME##_f9 ((PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,		\
+	     (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);	\
+  DBG (".");								\
+  NAME##_fv (0, VAL, VAL2);						\
+  DBG (".");								\
+  NAME##_fv (1, (PADT) 0, VAL, VAL2);					\
+  DBG (".");								\
+  NAME##_fv (2, (PADT) 0, (PADT) 0, VAL, VAL2);				\
+  DBG (".");								\
+  NAME##_fv (3, (PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);		\
+  DBG (".");								\
+  NAME##_fv (4, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);	\
+  DBG (".");								\
+  NAME##_fv (5, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,	\
+	     VAL, VAL2);						\
+  DBG (".");								\
+  NAME##_fv (6, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,	\
+	     (PADT) 0, VAL, VAL2);					\
+  DBG (".");								\
+  NAME##_fv (7, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,	\
+	     (PADT) 0, (PADT) 0, VAL, VAL2);				\
+  DBG (".");								\
+  NAME##_fv (8, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0, (PADT) 0,	\
+	     (PADT) 0, (PADT) 0, (PADT) 0, VAL, VAL2);			\
+  DBG ("\n");								\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-y.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-y.h
new file mode 100644
index 000000000..e181a7e34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-by-value-y.h
@@ -0,0 +1,277 @@
+extern void abort (void);
+
+#ifdef __GNUC__
+#define va_list __builtin_va_list
+#define va_start __builtin_va_start
+#define va_arg __builtin_va_arg
+#define va_end __builtin_va_end
+#else
+#include <stdarg.h>
+#endif
+
+#if USE_MEMCMP
+/* For comparing vectors.  */
+#define TEST_FUNCS(NAME, TYPE, PADT, VAL, VAL2) \
+void NAME##_f0 (TYPE a, PADT b)						\
+{									\
+  if (memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)			\
+    abort ();								\
+}									\
+									\
+void NAME##_f1 (PADT z0, TYPE a, PADT b)				\
+{									\
+  if (z0 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f2 (PADT z0, PADT z1, TYPE a, PADT b)			\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f3 (PADT z0, PADT z1, PADT z2, TYPE a, PADT b)		\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f4 (PADT z0, PADT z1, PADT z2, PADT z3, TYPE a, PADT b)	\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f5 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, TYPE a,	\
+		PADT b)							\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f6 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		TYPE a, PADT b)						\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f7 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		PADT z6, TYPE a, PADT b)				\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || z6 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f8 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		PADT z6, PADT z7, TYPE a, PADT b)			\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || z6 != (PADT) 0							\
+      || z7 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_f9 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		PADT z6, PADT z7, PADT z8, TYPE a, PADT b)		\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || z6 != (PADT) 0							\
+      || z7 != (PADT) 0							\
+      || z8 != (PADT) 0							\
+      || memcmp (&a, &VAL, sizeof (a)) != 0 || b != VAL2)		\
+    abort ();								\
+}									\
+									\
+void NAME##_fv (int n, ...)						\
+{									\
+  va_list ap;								\
+  TYPE x;								\
+  va_start (ap, n);							\
+									\
+  while (n-- != 0)							\
+    if (va_arg (ap, PADT) != (PADT) 0)					\
+      abort ();								\
+									\
+  x = va_arg (ap, TYPE);						\
+  if (memcmp (&x, &VAL, sizeof (x)) != 0 )				\
+    abort ();								\
+									\
+  if (va_arg (ap, PADT) != VAL2)					\
+    abort ();								\
+									\
+  va_end (ap);								\
+}
+
+#else
+
+#define TEST_FUNCS(NAME, TYPE, PADT, VAL, VAL2) \
+void NAME##_f0 (TYPE a, PADT b)						\
+{									\
+  if (a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f1 (PADT z0, TYPE a, PADT b)				\
+{									\
+  if (z0 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f2 (PADT z0, PADT z1, TYPE a, PADT b)			\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f3 (PADT z0, PADT z1, PADT z2, TYPE a, PADT b)		\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f4 (PADT z0, PADT z1, PADT z2, PADT z3, TYPE a, PADT b)	\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f5 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, TYPE a,	\
+		PADT b)							\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f6 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		TYPE a, PADT b)						\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f7 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		PADT z6, TYPE a, PADT b)				\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || z6 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f8 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		PADT z6, PADT z7, TYPE a, PADT b)			\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || z6 != (PADT) 0							\
+      || z7 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_f9 (PADT z0, PADT z1, PADT z2, PADT z3, PADT z4, PADT z5,	\
+		PADT z6, PADT z7, PADT z8, TYPE a, PADT b)		\
+{									\
+  if (z0 != (PADT) 0							\
+      || z1 != (PADT) 0							\
+      || z2 != (PADT) 0							\
+      || z3 != (PADT) 0							\
+      || z4 != (PADT) 0							\
+      || z5 != (PADT) 0							\
+      || z6 != (PADT) 0							\
+      || z7 != (PADT) 0							\
+      || z8 != (PADT) 0							\
+      || a != VAL || b != VAL2)						\
+    abort ();								\
+}									\
+									\
+void NAME##_fv (int n, ...)						\
+{									\
+  va_list ap;								\
+									\
+  va_start (ap, n);							\
+									\
+  while (n-- != 0)							\
+    if (va_arg (ap, PADT) != (PADT) 0)					\
+      abort ();								\
+									\
+  if (va_arg (ap, TYPE) != VAL)						\
+    abort ();								\
+									\
+  if (va_arg (ap, PADT) != VAL2)					\
+    abort ();								\
+									\
+  va_end (ap);								\
+}
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_main.c
new file mode 100644
index 000000000..0a27f5416
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_main.c
@@ -0,0 +1,13 @@
+/* Test function return values.  This test includes scalar types that
+   are supported by va_arg.  */
+
+extern void scalar_return_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_return_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_x.c
new file mode 100644
index 000000000..5556f9510
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_x.c
@@ -0,0 +1,119 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern TYPE test0##NAME (void);					\
+extern TYPE test1##NAME (TYPE);					\
+extern TYPE testva##NAME (int n, ...);				\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v)							\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##NAME ();					\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##NAME (g01##NAME);				\
+  check##NAME (rslt, g01##NAME);				\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#NAME);					\
+      DEBUG_FPUTS (" testva:");					\
+      rslt = testva##NAME (1, g01##NAME);			\
+      check##NAME (rslt, g01##NAME);				\
+      rslt = testva##NAME (5, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME);		\
+      check##NAME (rslt, g05##NAME);				\
+      rslt = testva##NAME (9, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME, g06##NAME,	\
+			   g07##NAME, g08##NAME, g09##NAME);	\
+      check##NAME (rslt, g09##NAME);				\
+      rslt = testva##NAME (16, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME, g06##NAME,	\
+			   g07##NAME, g08##NAME, g09##NAME,	\
+			   g10##NAME, g11##NAME, g12##NAME,	\
+			   g13##NAME, g14##NAME, g15##NAME,	\
+			   g16##NAME);				\
+      check##NAME (rslt, g16##NAME);				\
+    }								\
+  DEBUG_NL;							\
+}
+
+T(ui, unsigned int, 51)
+T(si, int, (-55))
+T(ul, unsigned long, 61)
+T(sl, long, (-66))
+T(ull, unsigned long long, 71)
+T(sll, long long, (-77))
+T(d, double, 91.0)
+T(ld, long double, 92.0)
+
+#undef T
+
+void
+scalar_return_1_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+T(ui)
+T(si)
+T(ul)
+T(sl)
+T(ull)
+T(sll)
+T(d)
+T(ld)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_y.c
new file mode 100644
index 000000000..f913dbbb8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-1_y.c
@@ -0,0 +1,72 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1+INITVAL);				\
+  check##NAME (g02##NAME,  2+INITVAL);				\
+  check##NAME (g03##NAME,  3+INITVAL);				\
+  check##NAME (g04##NAME,  4+INITVAL);				\
+  check##NAME (g05##NAME,  5+INITVAL);				\
+  check##NAME (g06##NAME,  6+INITVAL);				\
+  check##NAME (g07##NAME,  7+INITVAL);				\
+  check##NAME (g08##NAME,  8+INITVAL);				\
+  check##NAME (g09##NAME,  9+INITVAL);				\
+  check##NAME (g10##NAME, 10+INITVAL);				\
+  check##NAME (g11##NAME, 11+INITVAL);				\
+  check##NAME (g12##NAME, 12+INITVAL);				\
+  check##NAME (g13##NAME, 13+INITVAL);				\
+  check##NAME (g14##NAME, 14+INITVAL);				\
+  check##NAME (g15##NAME, 15+INITVAL);				\
+  check##NAME (g16##NAME, 16+INITVAL);				\
+}								\
+								\
+TYPE								\
+test0##NAME (void)						\
+{								\
+  return g01##NAME;						\
+}								\
+								\
+TYPE								\
+test1##NAME (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##NAME (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+    rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(ui, unsigned int, 51)
+T(si, int, (-55))
+T(ul, unsigned long, 61)
+T(sl, long, (-66))
+T(ull, unsigned long long, 71)
+T(sll, long long, (-77))
+T(d, double, 91.0)
+T(ld, long double, 92.0)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_main.c
new file mode 100644
index 000000000..11a5e5044
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_main.c
@@ -0,0 +1,13 @@
+/* Test function return values.   This test includes scalar types that
+   are not supported by va_arg.  */
+
+extern void scalar_return_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_return_2_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_x.c
new file mode 100644
index 000000000..f864d4c96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_x.c
@@ -0,0 +1,86 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern TYPE test0##NAME (void);					\
+extern TYPE test1##NAME (TYPE);					\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v)							\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##NAME ();					\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##NAME (g01##NAME);				\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+}
+
+T(c, char, 21)
+T(uc, unsigned char, 22)
+T(sc, signed char, (-33))
+T(us, unsigned short, 41)
+T(ss, short, (-44))
+T(f, float, 90.0)
+
+#undef T
+
+void
+scalar_return_2_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+T(c)
+T(uc)
+T(sc)
+T(us)
+T(ss)
+T(f)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_y.c
new file mode 100644
index 000000000..485165c71
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-2_y.c
@@ -0,0 +1,63 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1+INITVAL);				\
+  check##NAME (g02##NAME,  2+INITVAL);				\
+  check##NAME (g03##NAME,  3+INITVAL);				\
+  check##NAME (g04##NAME,  4+INITVAL);				\
+  check##NAME (g05##NAME,  5+INITVAL);				\
+  check##NAME (g06##NAME,  6+INITVAL);				\
+  check##NAME (g07##NAME,  7+INITVAL);				\
+  check##NAME (g08##NAME,  8+INITVAL);				\
+  check##NAME (g09##NAME,  9+INITVAL);				\
+  check##NAME (g10##NAME, 10+INITVAL);				\
+  check##NAME (g11##NAME, 11+INITVAL);				\
+  check##NAME (g12##NAME, 12+INITVAL);				\
+  check##NAME (g13##NAME, 13+INITVAL);				\
+  check##NAME (g14##NAME, 14+INITVAL);				\
+  check##NAME (g15##NAME, 15+INITVAL);				\
+  check##NAME (g16##NAME, 16+INITVAL);				\
+}								\
+								\
+TYPE								\
+test0##NAME (void)						\
+{								\
+  return g01##NAME;						\
+}								\
+								\
+TYPE								\
+test1##NAME (TYPE x01)						\
+{								\
+  return x01;							\
+}
+
+T(c, char, 21)
+T(uc, unsigned char, 22)
+T(sc, signed char, (-33))
+T(us, unsigned short, 41)
+T(ss, short, (-44))
+T(f, float, 90.0)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_main.c
new file mode 100644
index 000000000..8f2738be6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_main.c
@@ -0,0 +1,14 @@
+/* Test function return values.  This test includes _Complex types
+   whose real and imaginary parts can be used in variable-length
+   argument lists.  */
+
+extern void scalar_return_3_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_return_3_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_x.c
new file mode 100644
index 000000000..5b33ce880
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_x.c
@@ -0,0 +1,121 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern TYPE test0##NAME (void);					\
+extern TYPE test1##NAME (TYPE);					\
+extern TYPE testva##NAME (int n, ...);				\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v)							\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##NAME ();					\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##NAME (g01##NAME);				\
+  check##NAME (rslt, g01##NAME);				\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#NAME);					\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##NAME (1, g01##NAME);			\
+      check##NAME (rslt, g01##NAME);				\
+      rslt = testva##NAME (5, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME);		\
+      check##NAME (rslt, g05##NAME);				\
+      rslt = testva##NAME (9, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME, g06##NAME,	\
+			   g07##NAME, g08##NAME, g09##NAME);	\
+      check##NAME (rslt, g09##NAME);				\
+      rslt = testva##NAME (16, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME, g06##NAME,	\
+			   g07##NAME, g08##NAME, g09##NAME,	\
+			   g10##NAME, g11##NAME, g12##NAME,	\
+			   g13##NAME, g14##NAME, g15##NAME,	\
+			   g16##NAME);				\
+      check##NAME (rslt, g16##NAME);				\
+  }								\
+  DEBUG_NL;							\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(ci, _Complex int, CINT (2, 3))
+T(cl, _Complex long, CINT (3, 4))
+T(cll, _Complex long long, CINT (4, 5))
+#endif
+T(cd, _Complex double, CDBL (2.0, 3.0))
+T(cld, _Complex long double, CDBL (3.0, 4.0))
+#endif
+
+#undef T
+
+void
+scalar_return_3_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(ci)
+T(cl)
+T(cll)
+#endif
+T(cd)
+T(cld)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_y.c
new file mode 100644
index 000000000..245c4c571
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-3_y.c
@@ -0,0 +1,73 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1+INITVAL);				\
+  check##NAME (g02##NAME,  2+INITVAL);				\
+  check##NAME (g03##NAME,  3+INITVAL);				\
+  check##NAME (g04##NAME,  4+INITVAL);				\
+  check##NAME (g05##NAME,  5+INITVAL);				\
+  check##NAME (g06##NAME,  6+INITVAL);				\
+  check##NAME (g07##NAME,  7+INITVAL);				\
+  check##NAME (g08##NAME,  8+INITVAL);				\
+  check##NAME (g09##NAME,  9+INITVAL);				\
+  check##NAME (g10##NAME, 10+INITVAL);				\
+  check##NAME (g11##NAME, 11+INITVAL);				\
+  check##NAME (g12##NAME, 12+INITVAL);				\
+  check##NAME (g13##NAME, 13+INITVAL);				\
+  check##NAME (g14##NAME, 14+INITVAL);				\
+  check##NAME (g15##NAME, 15+INITVAL);				\
+  check##NAME (g16##NAME, 16+INITVAL);				\
+}								\
+								\
+TYPE								\
+test0##NAME (void)						\
+{								\
+  return g01##NAME;						\
+}								\
+								\
+TYPE								\
+test1##NAME (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##NAME (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+    rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(ci, _Complex int, CINT (2, 3))
+T(cl, _Complex long, CINT (3, 4))
+T(cll, _Complex long long, CINT (4, 5))
+#endif
+T(cd, _Complex double, CDBL (2.0, 3.0))
+T(cld, _Complex long double, CDBL (3.0, 4.0))
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_main.c
new file mode 100644
index 000000000..2bcfa0487
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_main.c
@@ -0,0 +1,14 @@
+/* Test function return values.  This test includes _Complex types
+   whose real and imaginary parts cannot be used in variable-length
+   argument lists.  */
+
+extern void scalar_return_4_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_return_4_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_x.c
new file mode 100644
index 000000000..50305be4d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_x.c
@@ -0,0 +1,70 @@
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME;							\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern TYPE test0##NAME (void);					\
+extern TYPE test1##NAME (TYPE);					\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v)							\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##NAME ();					\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##NAME (g01##NAME);				\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(cc, _Complex char, CINT (0, 1))
+T(cs, _Complex short, CINT (1 + 2))
+#endif
+T(cf, _Complex float, CDBL (1.0, 2.0))
+#endif
+
+#undef T
+
+void
+scalar_return_4_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(cc)
+T(cs)
+#endif
+T(cf)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_y.c
new file mode 100644
index 000000000..3c9685697
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-4_y.c
@@ -0,0 +1,46 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME;						\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1+INITVAL);				\
+}								\
+								\
+TYPE								\
+test0##NAME (void)						\
+{								\
+  return g01##NAME;						\
+}								\
+								\
+TYPE								\
+test1##NAME (TYPE x01)						\
+{								\
+  return x01;							\
+}
+
+#ifndef SKIP_COMPLEX
+#ifndef SKIP_COMPLEX_INT
+T(cc, _Complex char, CINT (0, 1))
+T(cs, _Complex short, CINT (1, 2))
+#endif
+T(cf, _Complex float, CDBL (1.0, 2.0))
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_main.c
new file mode 100644
index 000000000..eeb62869f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_main.c
@@ -0,0 +1,15 @@
+/* Test function return values.  This test includes scalar types that
+   are supported by va_arg.  */
+
+/* { dg-require-compat-dfp "" } */
+
+extern void scalar_return_dfp_x(void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  scalar_return_dfp_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_x.c
new file mode 100644
index 000000000..aee0a9717
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_x.c
@@ -0,0 +1,109 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(NAME, TYPE, INITVAL) 					\
+TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void init##NAME (TYPE *p, TYPE v);			\
+extern void checkg##NAME (void);				\
+extern TYPE test0##NAME (void);					\
+extern TYPE test1##NAME (TYPE);					\
+extern TYPE testva##NAME (int n, ...);				\
+								\
+void								\
+check##NAME (TYPE x, TYPE v)					\
+{								\
+  if (x != v)							\
+    DEBUG_CHECK							\
+}								\
+								\
+void								\
+testit##NAME (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME (&g01##NAME,  1);					\
+  init##NAME (&g02##NAME,  2);					\
+  init##NAME (&g03##NAME,  3);					\
+  init##NAME (&g04##NAME,  4);					\
+  init##NAME (&g05##NAME,  5);					\
+  init##NAME (&g06##NAME,  6);					\
+  init##NAME (&g07##NAME,  7);					\
+  init##NAME (&g08##NAME,  8);					\
+  init##NAME (&g09##NAME,  9);					\
+  init##NAME (&g10##NAME, 10);					\
+  init##NAME (&g11##NAME, 11);					\
+  init##NAME (&g12##NAME, 12);					\
+  init##NAME (&g13##NAME, 13);					\
+  init##NAME (&g14##NAME, 14);					\
+  init##NAME (&g15##NAME, 15);					\
+  init##NAME (&g16##NAME, 16);					\
+  checkg##NAME ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##NAME ();					\
+  check##NAME (rslt, g01##NAME);				\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##NAME (g01##NAME);				\
+  check##NAME (rslt, g01##NAME);				\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#NAME);					\
+      DEBUG_FPUTS (" testva:");					\
+      rslt = testva##NAME (1, g01##NAME);			\
+      check##NAME (rslt, g01##NAME);				\
+      rslt = testva##NAME (5, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME);		\
+      check##NAME (rslt, g05##NAME);				\
+      rslt = testva##NAME (9, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME, g06##NAME,	\
+			   g07##NAME, g08##NAME, g09##NAME);	\
+      check##NAME (rslt, g09##NAME);				\
+      rslt = testva##NAME (16, g01##NAME, g02##NAME, g03##NAME,	\
+			   g04##NAME, g05##NAME, g06##NAME,	\
+			   g07##NAME, g08##NAME, g09##NAME,	\
+			   g10##NAME, g11##NAME, g12##NAME,	\
+			   g13##NAME, g14##NAME, g15##NAME,	\
+			   g16##NAME);				\
+      check##NAME (rslt, g16##NAME);				\
+    }								\
+  DEBUG_NL;							\
+}
+
+T(d32, _Decimal32, 1.2df)
+T(d64, _Decimal64, 12.34dd)
+T(d128, _Decimal128, 123.456dl)
+
+#undef T
+
+void
+scalar_return_dfp_x ()
+{
+DEBUG_INIT
+
+#define T(NAME) testit##NAME ();
+
+T(d32)
+T(d64)
+T(d128)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_y.c
new file mode 100644
index 000000000..5fd9373fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/scalar-return-dfp_y.c
@@ -0,0 +1,67 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#define T(NAME, TYPE, INITVAL)					\
+extern TYPE g01##NAME, g02##NAME, g03##NAME, g04##NAME;		\
+extern TYPE g05##NAME, g06##NAME, g07##NAME, g08##NAME;		\
+extern TYPE g09##NAME, g10##NAME, g11##NAME, g12##NAME;		\
+extern TYPE g13##NAME, g14##NAME, g15##NAME, g16##NAME;		\
+								\
+extern void check##NAME (TYPE x, TYPE v);			\
+								\
+void								\
+init##NAME (TYPE *p, TYPE v)					\
+{								\
+  *p = v + INITVAL;						\
+}								\
+								\
+void								\
+checkg##NAME (void)						\
+{								\
+  check##NAME (g01##NAME,  1+INITVAL);				\
+  check##NAME (g02##NAME,  2+INITVAL);				\
+  check##NAME (g03##NAME,  3+INITVAL);				\
+  check##NAME (g04##NAME,  4+INITVAL);				\
+  check##NAME (g05##NAME,  5+INITVAL);				\
+  check##NAME (g06##NAME,  6+INITVAL);				\
+  check##NAME (g07##NAME,  7+INITVAL);				\
+  check##NAME (g08##NAME,  8+INITVAL);				\
+  check##NAME (g09##NAME,  9+INITVAL);				\
+  check##NAME (g10##NAME, 10+INITVAL);				\
+  check##NAME (g11##NAME, 11+INITVAL);				\
+  check##NAME (g12##NAME, 12+INITVAL);				\
+  check##NAME (g13##NAME, 13+INITVAL);				\
+  check##NAME (g14##NAME, 14+INITVAL);				\
+  check##NAME (g15##NAME, 15+INITVAL);				\
+  check##NAME (g16##NAME, 16+INITVAL);				\
+}								\
+								\
+TYPE								\
+test0##NAME (void)						\
+{								\
+  return g01##NAME;						\
+}								\
+								\
+TYPE								\
+test1##NAME (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##NAME (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+    rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(d32, _Decimal32, 1.2df)
+T(d64, _Decimal64, 12.34dd)
+T(d128, _Decimal128, 123.456dl)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_main.c
new file mode 100644
index 000000000..68e9f8f09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_main.c
@@ -0,0 +1,12 @@
+/* Check that sdata qualification doesn't produce out-of-range relocations
+   and that compilers agree on the way these declarations are handled.  */
+
+extern void sdata_1_x (void);
+extern void exit (int);
+
+int
+main ()
+{
+  sdata_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_x.c
new file mode 100644
index 000000000..fc7b8cef3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_x.c
@@ -0,0 +1,25 @@
+#include "sdata-section.h"
+
+struct s { int x; int y[4]; };
+extern struct s small_struct SDATA_SECTION;
+
+/* Test "load address" operations.  */
+int *xaddr (void) { return &small_struct.x; }
+int *yaddr (int i) { return &small_struct.y[i]; }
+
+void sdata_1_x (void)
+{
+  int i;
+
+  /* Test direct accesses.  */
+  small_struct.x = 5;
+  for (i = 0; i < 4; i++)
+    small_struct.y[i] = i + 42;
+
+  if (*xaddr () != 5)
+    abort ();
+
+  for (i = 0; i < 4; i++)
+    if (*yaddr (i) != i + 42)
+      abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_y.c
new file mode 100644
index 000000000..8bc878a85
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-1_y.c
@@ -0,0 +1,4 @@
+#include "sdata-section.h"
+
+struct s { int x; int y[4]; };
+struct s small_struct SDATA_SECTION;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-section.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-section.h
new file mode 100644
index 000000000..15be84386
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/sdata-section.h
@@ -0,0 +1,7 @@
+#if defined (__mips) && !defined(SKIP_ATTRIBUTE)
+#define SDATA_SECTION __attribute__((__section__(".sdata")))
+#else
+#define SDATA_SECTION
+#endif
+
+extern void abort (void);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-check.h
new file mode 100644
index 000000000..85b334c44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-check.h
@@ -0,0 +1,29 @@
+/* Function definitions that are used by multiple tests.  */
+
+void checkSc (Sc x, int i) { if (x.c != (char)i) DEBUG_CHECK }
+void checkSs (Ss x, int i) { if (x.s != i) DEBUG_CHECK }
+void checkSi (Si x, int i) { if (x.i != i) DEBUG_CHECK }
+void checkSsc (Ssc x, int i)
+{ if (x.s != i || x.c != (char)i+1) DEBUG_CHECK }
+void checkScs (Scs x, int i)
+{ if (x.c != (char)i || x.s != i+1) DEBUG_CHECK }
+void checkSsi (Ssi x, int i)
+{ if (x.s != i || x.i != i+1) DEBUG_CHECK }
+void checkSis (Sis x, int i)
+{ if (x.i != i || x.s != i+1) DEBUG_CHECK }
+void checkSic (Sic x, int i)
+{ if (x.i != i || x.c != (char)i+1) DEBUG_CHECK }
+void checkSci (Sci x, int i)
+{ if (x.c != (char)i || x.i != i+1) DEBUG_CHECK }
+void checkScsi (Scsi x, int i)
+{ if (x.c != (char)i || x.s != i+1 || x.i != i+2) DEBUG_CHECK }
+void checkScis (Scis x, int i)
+{ if (x.c != (char)i || x.i != i+1 || x.s != i+2) DEBUG_CHECK }
+void checkSsci (Ssci x, int i)
+{ if (x.s != i || x.c != (char)i+1 || x.i != i+2) DEBUG_CHECK }
+void checkSsic (Ssic x, int i)
+{ if (x.s != i || x.i != i+1 || x.c != (char)i+2) DEBUG_CHECK }
+void checkSisc (Sisc x, int i)
+{ if (x.i != i || x.s != i+1 || x.c != (char)i+2) DEBUG_CHECK }
+void checkSics (Sics x, int i)
+{ if (x.i != i || x.c != (char)i+1 || x.s != i+2) DEBUG_CHECK }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-defs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-defs.h
new file mode 100644
index 000000000..1a46b26e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-defs.h
@@ -0,0 +1,17 @@
+/* Type definitions that are used by multiple tests.  */
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { char c; short s; } Scs;
+typedef struct { int i; char c; } Sic;
+typedef struct { char c; int i; } Sci;
+typedef struct { short s; int i; } Ssi;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+typedef struct { short s; char c; int i; } Ssci;
+typedef struct { short s; int i; char c; } Ssic;
+typedef struct { int i; short s; char c; } Sisc;
+typedef struct { int i; char c; short s; } Sics;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-init.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-init.h
new file mode 100644
index 000000000..97009b6ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/small-struct-init.h
@@ -0,0 +1,17 @@
+/* Function definitions that are used by multiple tests.  */
+
+void initSc (Sc *p, int i) { p->c = (char)i; }
+void initSs (Ss *p, int i) { p->s = i; }
+void initSi (Si *p, int i) { p->i = i; }
+void initSsc (Ssc *p, int i) { p->s = i; p->c = (char)i+1; }
+void initScs (Scs *p, int i) { p->c = (char)i; p->s = i+1; }
+void initSsi (Ssi *p, int i) { p->s = i; p->i = i+1; }
+void initSis (Sis *p, int i) { p->i = i; p->s = i+1; }
+void initSic (Sic *p, int i) { p->i = i; p->c = (char)i+1; }
+void initSci (Sci *p, int i) { p->c = (char)i; p->i = i+1; }
+void initScsi (Scsi *p, int i) { p->c = (char)i; p->s = i+1; p->i = i+2; }
+void initScis (Scis *p, int i) { p->c = (char)i; p->i = i+1; p->s = i+2; }
+void initSsci (Ssci *p, int i) { p->s = i; p->c = (char)i+1; p->i = i+2; }
+void initSsic (Ssic *p, int i) { p->s = i; p->i = i+1; p->c = (char)i+2; }
+void initSisc (Sisc *p, int i) { p->i = i; p->s = i+1; p->c = (char)i+2; }
+void initSics (Sics *p, int i) { p->i = i; p->c = (char)i+1; p->s = i+2; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1.h
new file mode 100644
index 000000000..d9006c741
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1.h
@@ -0,0 +1,180 @@
+/* Define several variants of a struct for which the alignment differs
+   between powerpc64-linux and powerpc64-aix.  This might be interesting
+   for other targets as well.  */
+
+#define DESC_orig "original"
+struct B1_orig {
+  char c;
+  double d;
+};
+
+struct A2_orig {
+  double d;
+};
+
+struct B2_orig {
+  char c;
+  struct A2_orig a2;
+};
+
+struct A3_orig {
+  double d;
+  int i;
+};
+
+struct B3_orig {
+  char c;
+  struct A3_orig a3;
+};
+
+#ifndef SKIP_ATTRIBUTE
+#define DESC_p_all "packed attribute for all"
+struct B1_p_all {
+  char c;
+  double d;
+} __attribute__ ((packed));
+
+struct A2_p_all {
+  double d;
+} __attribute__ ((packed));
+
+struct B2_p_all {
+  char c;
+  struct A2_p_all a2;
+} __attribute__ ((packed));
+
+struct A3_p_all {
+  double d;
+  int i;
+} __attribute__ ((packed));
+
+struct B3_p_all {
+  char c;
+  struct A3_p_all a3;
+} __attribute__ ((packed));
+
+#define DESC_p_inner "packed attribute for inner"
+struct B1_p_inner {
+  char c;
+  double d;
+};
+
+struct A2_p_inner {
+  double d;
+} __attribute__ ((packed));
+
+struct B2_p_inner {
+  char c;
+  struct A2_p_inner a2;
+};
+
+struct A3_p_inner {
+  double d;
+  int i;
+} __attribute__ ((packed));
+
+struct B3_p_inner {
+  char c;
+  struct A3_p_inner a3;
+};
+
+#define DESC_p_outer "packed attribute for outer"
+struct B1_p_outer {
+  char c;
+  double d;
+} __attribute__ ((packed));
+
+struct A2_p_outer {
+  double d;
+};
+
+struct B2_p_outer {
+  char c;
+  struct A2_p_outer a2;
+} __attribute__ ((packed));
+
+struct A3_p_outer {
+  double d;
+  int i;
+};
+
+struct B3_p_outer {
+  char c;
+  struct A3_p_outer a3;
+} __attribute__ ((packed));
+
+#define DESC_a_max "maximum useful struct alignment for all"
+struct B1_a_max {
+  char c;
+  double d;
+} __attribute__ ((aligned));
+
+struct A2_a_max {
+  double d;
+} __attribute__ ((aligned));
+
+struct B2_a_max {
+  char c;
+  struct A2_a_max a2;
+} __attribute__ ((aligned));
+
+struct A3_a_max {
+  double d;
+  int i;
+} __attribute__ ((aligned));
+
+struct B3_a_max {
+  char c;
+  struct A3_a_max a3;
+} __attribute__ ((aligned));
+
+#define DESC_m_outer_p_inner "maximum alignment for outer, packed inner"
+struct B1_m_outer_p_inner {
+  char c;
+  double d;
+} __attribute__ ((aligned)) __attribute__ ((packed));
+
+struct A2_m_outer_p_inner {
+  double d;
+} __attribute__ ((packed));
+
+struct B2_m_outer_p_inner {
+  char c;
+  struct A2_m_outer_p_inner a2;
+} __attribute__ ((aligned));
+
+struct A3_m_outer_p_inner {
+  double d;
+  int i;
+} __attribute__ ((packed));
+
+struct B3_m_outer_p_inner {
+  char c;
+  struct A3_m_outer_p_inner a3;
+} __attribute__ ((aligned));
+
+#define DESC_m_inner_p_outer "maximum alignment for inner, packed outer"
+struct B1_m_inner_p_outer {
+  char c;
+  double d;
+} __attribute__ ((aligned)) __attribute__ ((packed));
+
+struct A2_m_inner_p_outer {
+  double d;
+} __attribute__ ((aligned));
+
+struct B2_m_inner_p_outer {
+  char c;
+  struct A2_m_inner_p_outer a2;
+} __attribute__ ((packed));
+
+struct A3_m_inner_p_outer {
+  double d;
+  int i;
+} __attribute__ ((aligned));
+
+struct B3_m_inner_p_outer {
+  char c;
+  struct A3_m_inner_p_outer a3;
+} __attribute__ ((packed));
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_main.c
new file mode 100644
index 000000000..0b7f27bea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_main.c
@@ -0,0 +1,13 @@
+/* Test compatibility of structure layout and alignment for structs
+   which contain doubles.  The original structs here are from PR 10645.  */
+
+extern void struct_align_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_align_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_x.c
new file mode 100644
index 000000000..51b2ef442
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_x.c
@@ -0,0 +1,108 @@
+#include "compat-common.h"
+#include "struct-align-1.h"
+
+#define SETUP(NAME,V1,V2,V3)				\
+char v1_##NAME = V1;					\
+double v2_##NAME = V2;					\
+int v3_##NAME = V3;					\
+							\
+struct B1_##NAME b1_##NAME = { V1, V2 };		\
+struct B2_##NAME b2_##NAME = { V1, { V2 } };		\
+struct B3_##NAME b3_##NAME = { V1, { V2, V3 } };	\
+							\
+struct B1_##NAME ab1_##NAME[2] =			\
+  { { V1, V2 }, { V1, V2 } };				\
+struct B2_##NAME ab2_##NAME[2] =			\
+  { { V1, { V2 } }, { V1, { V2 } } };			\
+struct B3_##NAME ab3_##NAME[2] =			\
+  { { V1, { V2, V3 } }, { V1, { V2, V3 } } };		\
+							\
+extern void test_##NAME (void);				\
+extern void checkp1_##NAME (struct B1_##NAME *);	\
+extern void checkp2_##NAME (struct B2_##NAME *);	\
+extern void checkp3_##NAME (struct B3_##NAME *);	\
+extern void checkg1_##NAME (void);			\
+extern void checkg2_##NAME (void);			\
+extern void checkg3_##NAME (void);			\
+							\
+void							\
+pass1_##NAME (struct B1_##NAME s)			\
+{							\
+  checkp1_##NAME (&s);					\
+}							\
+							\
+void							\
+pass2_##NAME (struct B2_##NAME s)			\
+{							\
+  checkp2_##NAME (&s);					\
+}							\
+							\
+void							\
+pass3_##NAME (struct B3_##NAME s)			\
+{							\
+  checkp3_##NAME (&s);					\
+}							\
+							\
+struct B1_##NAME					\
+return1_##NAME (void)					\
+{							\
+  return ab1_##NAME[0];					\
+}							\
+							\
+struct B2_##NAME					\
+return2_##NAME (void)					\
+{							\
+  return ab2_##NAME[0];					\
+}							\
+							\
+struct B3_##NAME					\
+return3_##NAME (void)					\
+{							\
+  return ab3_##NAME[0];					\
+}
+
+#define CHECK(NAME) test_##NAME()
+
+#if __INT_MAX__ > 32767
+SETUP (orig, 49, 1.0, 111111)
+#else
+SETUP (orig, 49, 1.0, 1111)
+#endif
+#ifndef SKIP_ATTRIBUTE
+#if __INT_MAX__ > 32767
+SETUP (p_all, 50, 2.0, 222222)
+SETUP (p_inner, 51, 3.0, 333333)
+SETUP (p_outer, 52, 4.0, 444444)
+SETUP (a_max, 53, 5.0, 555555)
+SETUP (m_outer_p_inner, 54, 6.0, 666666)
+SETUP (m_inner_p_outer, 55, 7.0, 777777)
+#else
+SETUP (p_all, 50, 2.0, 2222)
+SETUP (p_inner, 51, 3.0, 3333)
+SETUP (p_outer, 52, 4.0, 4444)
+SETUP (a_max, 53, 5.0, 5555)
+SETUP (m_outer_p_inner, 54, 6.0, 6666)
+SETUP (m_inner_p_outer, 55, 7.0, 7777)
+#endif
+#endif
+
+void
+struct_align_1_x (void)
+{
+  DEBUG_INIT
+
+  CHECK (orig);
+#ifndef SKIP_ATTRIBUTE
+  CHECK (p_all);
+  CHECK (p_inner);
+  CHECK (p_outer);
+  CHECK (a_max);
+  CHECK (m_outer_p_inner);
+  CHECK (m_inner_p_outer);
+#endif
+
+  DEBUG_FINI
+
+  if (fails != 0)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_y.c
new file mode 100644
index 000000000..c858e10d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-1_y.c
@@ -0,0 +1,90 @@
+#include "compat-common.h"
+#include "struct-align-1.h"
+
+#define TEST(NAME)						\
+extern char v1_##NAME;						\
+extern double v2_##NAME;					\
+extern int v3_##NAME;						\
+								\
+extern struct B1_##NAME b1_##NAME, ab1_##NAME[2];		\
+extern struct B2_##NAME b2_##NAME, ab2_##NAME[2];		\
+extern struct B3_##NAME b3_##NAME, ab3_##NAME[2];		\
+								\
+extern void pass1_##NAME (struct B1_##NAME);			\
+extern void pass2_##NAME (struct B2_##NAME);			\
+extern void pass3_##NAME (struct B3_##NAME);			\
+extern struct B1_##NAME return1_##NAME (void);			\
+extern struct B2_##NAME return2_##NAME (void);			\
+extern struct B3_##NAME return3_##NAME (void);			\
+								\
+void								\
+checkp1_##NAME (struct B1_##NAME *p)				\
+{								\
+  if (p->c != v1_##NAME)					\
+    DEBUG_CHECK;						\
+  if (p->d != v2_##NAME)					\
+    DEBUG_CHECK;						\
+}								\
+								\
+void								\
+checkp2_##NAME (struct B2_##NAME *p)				\
+{								\
+  if (p->c != v1_##NAME)					\
+    DEBUG_CHECK;						\
+  if (p->a2.d != v2_##NAME)					\
+    DEBUG_CHECK;						\
+}								\
+								\
+void								\
+checkp3_##NAME (struct B3_##NAME *p)				\
+{								\
+  if (p->c != v1_##NAME)					\
+    DEBUG_CHECK;						\
+  if (p->a3.d != v2_##NAME)					\
+    DEBUG_CHECK;						\
+  if (p->a3.i != v3_##NAME)					\
+    DEBUG_CHECK;						\
+}								\
+								\
+void								\
+test_##NAME (void)						\
+{								\
+  struct B1_##NAME s1;						\
+  struct B2_##NAME s2;						\
+  struct B3_##NAME s3;						\
+  DEBUG_FPUTS (DESC_##NAME);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  global variable");				\
+  checkp1_##NAME (&b1_##NAME);					\
+  checkp2_##NAME (&b2_##NAME);					\
+  checkp3_##NAME (&b3_##NAME);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  global array");				\
+  checkp1_##NAME (&ab1_##NAME[1]);				\
+  checkp2_##NAME (&ab2_##NAME[1]);				\
+  checkp3_##NAME (&ab3_##NAME[1]);				\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  argument");					\
+  pass1_##NAME (b1_##NAME);					\
+  pass2_##NAME (b2_##NAME);					\
+  pass3_##NAME (b3_##NAME);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  function result");				\
+  s1 = return1_##NAME ();					\
+  checkp1_##NAME (&s1);						\
+  s2 = return2_##NAME ();					\
+  checkp2_##NAME (&s2);						\
+  s3 = return3_##NAME ();					\
+  checkp3_##NAME (&s3);						\
+  DEBUG_NL;							\
+}
+
+TEST (orig)
+#ifndef SKIP_ATTRIBUTE
+TEST (p_all)
+TEST (p_inner)
+TEST (p_outer)
+TEST (a_max)
+TEST (m_outer_p_inner)
+TEST (m_inner_p_outer)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2.h
new file mode 100644
index 000000000..f94fe57e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2.h
@@ -0,0 +1,75 @@
+/* Define several variants of struct epoll_event from the Linux kernel,
+   specifying various attributes that affect alignment and size.
+ 
+   This test was developed for systems for which int is 32 bits and
+   long long is 64 bits; it might need to be disabled for systems where
+   either of those is not true.  */
+
+#define DESC_orig "original"
+struct epoll_event_orig {
+  unsigned int events;
+  unsigned long long data;
+};
+
+#ifndef SKIP_ATTRIBUTE
+#define DESC_structmax "maximum useful struct alignment"
+struct epoll_event_structmax {
+  unsigned int events;
+  unsigned long long data;
+} __attribute__ ((aligned));
+
+
+#define DESC_struct4 "4-byte struct alignment"
+struct epoll_event_struct4 {
+  unsigned int events;
+  unsigned long long data;
+} __attribute__ ((aligned(4)));
+
+#define DESC_struct8 "8-byte struct alignment"
+struct epoll_event_struct8 {
+  unsigned int events;
+  unsigned long long data;
+} __attribute__ ((aligned(8)));
+
+#define DESC_data4 "4-byte alignment for data"
+struct epoll_event_data4 {
+  unsigned int events;
+  unsigned long long data __attribute__ ((aligned(4)));
+};
+
+#define DESC_data8 "8-byte alignment for data"
+struct epoll_event_data8 {
+  unsigned int events;
+  unsigned long long data __attribute__ ((aligned(8)));
+};
+
+#define DESC_p "packed attribute"
+struct epoll_event_p {
+  unsigned int events;
+  unsigned long long data;
+} __attribute__ ((packed));
+
+#define DESC_pstruct4 "packed attribute, 4-byte struct alignment"
+struct epoll_event_pstruct4 {
+  unsigned int events;
+  unsigned long long data;
+} __attribute__ ((packed)) __attribute__ ((aligned(4)));
+
+#define DESC_pstruct8 "packed attribute, 8-byte struct alignment"
+struct epoll_event_pstruct8 {
+  unsigned int events;
+  unsigned long long data;
+} __attribute__ ((packed)) __attribute__ ((aligned(8)));
+
+#define DESC_pdata4 "packed attribute, 4-byte alignment for data"
+struct epoll_event_pdata4 {
+  unsigned int events;
+  unsigned long long data __attribute__ ((aligned(4)));
+} __attribute__ ((packed));
+
+#define DESC_pdata8 "packed attribute, 8-byte alignment for data"
+struct epoll_event_pdata8 {
+  unsigned int events;
+  unsigned long long data __attribute__ ((aligned(8)));
+} __attribute__ ((packed));
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_main.c
new file mode 100644
index 000000000..b1dece1b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_main.c
@@ -0,0 +1,14 @@
+/* Test compatibility of structure layout and alignment for a struct
+   containing an int and a long long, with various combinations of
+   packed and aligned attributes.  The struct is from the Linux kernel.  */
+
+extern void struct_align_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_align_2_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_x.c
new file mode 100644
index 000000000..2a4ae586b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_x.c
@@ -0,0 +1,85 @@
+/* Disable this test for 16-bit targets.  */
+
+#include <limits.h>
+
+#if !(defined __GNUC__) || (INT_MAX > 32767)
+
+#include "compat-common.h"
+#include "struct-align-2.h"
+
+#define SETUP(NAME,V1,V2,V3)					\
+struct outer_##NAME {						\
+  int i;							\
+  struct epoll_event_##NAME ee;					\
+};								\
+								\
+unsigned int v1_##NAME = V1;					\
+unsigned int v2_##NAME = V2;					\
+unsigned long long v3_##NAME = V3;				\
+								\
+struct outer_##NAME s_##NAME[2] =				\
+ { {V1, { V2, V3 } }, { V1, { V2, V3 } } };			\
+								\
+extern void test_##NAME (void);					\
+extern void checkp_##NAME (struct outer_##NAME *);		\
+extern void checkg_##NAME (void);				\
+								\
+void								\
+pass_##NAME (struct outer_##NAME s)				\
+{								\
+  checkp_##NAME (&s);						\
+}								\
+								\
+struct outer_##NAME						\
+return_##NAME (void)						\
+{								\
+  return s_##NAME[0];						\
+}
+
+#define CHECK(NAME)						\
+  test_##NAME()
+
+SETUP (orig,101, 102, 0x0101010101010101ULL)
+#ifndef SKIP_ATTRIBUTE
+SETUP (structmax, 103, 104, 0x1212121212121212ULL)
+SETUP (struct4, 105, 106, 0x2323232323232323ULL)
+SETUP (struct8, 107, 108, 0x3434343434343434ULL)
+SETUP (data4, 109, 110, 0x4545454545454545ULL)
+SETUP (data8, 111, 112, 0x5656565656565656ULL)
+SETUP (p, 113, 114, 0x6767676767676767ULL)
+SETUP (pstruct4, 115, 116, 0x7878787878787878ULL)
+SETUP (pstruct8, 117, 118, 0x8989898989898989ULL)
+SETUP (pdata4, 119, 120, 0x9A9A9A9A9A9A9A9AULL)
+SETUP (pdata8, 121, 122, 0xABABABABABABABABULL)
+#endif
+
+void
+struct_align_2_x (void)
+{
+  DEBUG_INIT
+
+  CHECK (orig);
+#ifndef SKIP_ATTRIBUTE
+  CHECK (structmax);
+  CHECK (struct4);
+  CHECK (struct8);
+  CHECK (data4);
+  CHECK (data8);
+  CHECK (p);
+  CHECK (pstruct4);
+  CHECK (pstruct8);
+  CHECK (pdata4);
+  CHECK (pdata8);
+#endif
+
+  DEBUG_FINI
+
+  if (fails != 0)
+    abort ();
+}
+
+#else
+
+void struct_align_2_x (void) {}
+
+#endif  /* INT_MAX */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_y.c
new file mode 100644
index 000000000..0ca2e40c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-align-2_y.c
@@ -0,0 +1,73 @@
+/* Disable this test for 16-bit targets.  */
+
+#include <limits.h>
+
+#if !(defined __GNUC__) || (INT_MAX > 32767)
+
+#include "compat-common.h"
+#include "struct-align-2.h"
+
+#define TEST(NAME)						\
+struct outer_##NAME {						\
+  int i;							\
+  struct epoll_event_##NAME ee;					\
+};								\
+								\
+extern unsigned int v1_##NAME;					\
+extern unsigned int v2_##NAME;					\
+extern unsigned long long v3_##NAME;				\
+								\
+extern struct outer_##NAME s_##NAME[2];				\
+								\
+extern void pass_##NAME (struct outer_##NAME);			\
+extern struct outer_##NAME return_##NAME (void);		\
+								\
+void								\
+checkp_##NAME (struct outer_##NAME *p)				\
+{								\
+  if (p->i != v1_##NAME)					\
+    DEBUG_CHECK;						\
+  if (p->ee.events != v2_##NAME)				\
+    DEBUG_CHECK;						\
+  if (p->ee.data != v3_##NAME)					\
+    DEBUG_CHECK;						\
+}								\
+								\
+void								\
+test_##NAME (void)						\
+{								\
+  struct outer_##NAME s;					\
+  DEBUG_FPUTS (DESC_##NAME);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  global array");				\
+  checkp_##NAME (&s_##NAME[0]);					\
+  checkp_##NAME (&s_##NAME[1]);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  argument");					\
+  pass_##NAME (s_##NAME[0]);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS ("  function result");				\
+  s = return_##NAME ();						\
+  checkp_##NAME (&s);						\
+  DEBUG_NL;							\
+}
+
+TEST (orig)
+#ifndef SKIP_ATTRIBUTE
+TEST (structmax)
+TEST (struct4)
+TEST (struct8)
+TEST (data4)
+TEST (data8)
+TEST (p)
+TEST (pstruct4)
+TEST (pstruct8)
+TEST (pdata4)
+TEST (pdata8)
+#endif
+
+#else
+
+int i;  /* prevent compiling an empty file */
+
+#endif  /* INT_MAX */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_main.c
new file mode 100644
index 000000000..e41b93c57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are floating
+   point scalars.  */
+
+extern void struct_by_value_10_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_10_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_x.c
new file mode 100644
index 000000000..5954104aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_x.c
@@ -0,0 +1,184 @@
+#include "compat-common.h"
+
+#include "fp2-struct-defs.h"
+#include "fp2-struct-check.h"
+
+#define TEST(TYPE)						\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, double x);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  (double)1);			\
+  init##TYPE  ( &g2s##TYPE,  (double)2);			\
+  init##TYPE  ( &g3s##TYPE,  (double)3);			\
+  init##TYPE  ( &g4s##TYPE,  (double)4);			\
+  init##TYPE  ( &g5s##TYPE,  (double)5);			\
+  init##TYPE  ( &g6s##TYPE,  (double)6);			\
+  init##TYPE  ( &g7s##TYPE,  (double)7);			\
+  init##TYPE  ( &g8s##TYPE,  (double)8);			\
+  init##TYPE  ( &g9s##TYPE,  (double)9);			\
+  init##TYPE  (&g10s##TYPE, (double)10);			\
+  init##TYPE  (&g11s##TYPE, (double)11);			\
+  init##TYPE  (&g12s##TYPE, (double)12);			\
+  init##TYPE  (&g13s##TYPE, (double)13);			\
+  init##TYPE  (&g14s##TYPE, (double)14);			\
+  init##TYPE  (&g15s##TYPE, (double)15);			\
+  init##TYPE  (&g16s##TYPE, (double)16);			\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
+
+TEST(Sfd)
+TEST(Sfl)
+TEST(Sdf)
+TEST(Sdl)
+TEST(Slf)
+TEST(Sld)
+TEST(Sfdl)
+TEST(Sfld)
+TEST(Sdfl)
+TEST(Sdlf)
+TEST(Slfd)
+TEST(Sldf)
+
+#undef T
+
+void
+struct_by_value_10_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Sfd)
+T(Sfl)
+T(Sdf)
+T(Sdl)
+T(Slf)
+T(Sld)
+T(Sfdl)
+T(Sfld)
+T(Sdfl)
+T(Sdlf)
+T(Slfd)
+T(Sldf)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_y.c
new file mode 100644
index 000000000..6c9589d02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-10_y.c
@@ -0,0 +1,95 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp2-struct-defs.h"
+#include "fp2-struct-init.h"
+
+#define TEST(TYPE)						\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+extern void check##TYPE (TYPE x, double y);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  (double)1);			\
+  check##TYPE (  g2s##TYPE,  (double)2);			\
+  check##TYPE (  g3s##TYPE,  (double)3);			\
+  check##TYPE (  g4s##TYPE,  (double)4);			\
+  check##TYPE (  g5s##TYPE,  (double)5);			\
+  check##TYPE (  g6s##TYPE,  (double)6);			\
+  check##TYPE (  g7s##TYPE,  (double)7);			\
+  check##TYPE (  g8s##TYPE,  (double)8);			\
+  check##TYPE (  g9s##TYPE,  (double)9);			\
+  check##TYPE ( g10s##TYPE, (double)10);			\
+  check##TYPE ( g11s##TYPE, (double)11);			\
+  check##TYPE ( g12s##TYPE, (double)12);			\
+  check##TYPE ( g13s##TYPE, (double)13);			\
+  check##TYPE ( g14s##TYPE, (double)14);			\
+  check##TYPE ( g15s##TYPE, (double)15);			\
+  check##TYPE ( g16s##TYPE, (double)16);			\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, (double)1);					\
+  check##TYPE (s2, (double)2);					\
+  check##TYPE (s3, (double)3);					\
+  check##TYPE (s4, (double)4);					\
+  check##TYPE (s5, (double)5);					\
+  check##TYPE (s6, (double)6);					\
+  check##TYPE (s7, (double)7);					\
+  check##TYPE (s8, (double)8);					\
+  check##TYPE (s9, (double)9);					\
+  check##TYPE (s10, (double)10);				\
+  check##TYPE (s11, (double)11);				\
+  check##TYPE (s12, (double)12);				\
+  check##TYPE (s13, (double)13);				\
+  check##TYPE (s14, (double)14);				\
+  check##TYPE (s15, (double)15);				\
+  check##TYPE (s16, (double)16);				\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, (double)i+1);				\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+TEST(Sfd)
+TEST(Sfl)
+TEST(Sdf)
+TEST(Sdl)
+TEST(Slf)
+TEST(Sld)
+TEST(Sfdl)
+TEST(Sfld)
+TEST(Sdfl)
+TEST(Sdlf)
+TEST(Slfd)
+TEST(Sldf)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_main.c
new file mode 100644
index 000000000..400e94c2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex char.  */
+
+extern void struct_by_value_11_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_11_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_x.c
new file mode 100644
index 000000000..cea1ac096
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_x.c
@@ -0,0 +1,63 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cc, _Complex char)
+CHECKS(cc, _Complex char)
+
+TEST(Scc1, _Complex char)
+TEST(Scc2, _Complex char)
+TEST(Scc3, _Complex char)
+TEST(Scc4, _Complex char)
+TEST(Scc5, _Complex char)
+TEST(Scc6, _Complex char)
+TEST(Scc7, _Complex char)
+TEST(Scc8, _Complex char)
+TEST(Scc9, _Complex char)
+TEST(Scc10, _Complex char)
+TEST(Scc11, _Complex char)
+TEST(Scc12, _Complex char)
+TEST(Scc13, _Complex char)
+TEST(Scc14, _Complex char)
+TEST(Scc15, _Complex char)
+TEST(Scc16, _Complex char)
+#endif
+
+#undef T
+
+void
+struct_by_value_11_x ()
+{
+#ifndef SKIP_COMPLEX_INT
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Scc1, _Complex char)
+T(Scc2, _Complex char)
+T(Scc3, _Complex char)
+T(Scc4, _Complex char)
+T(Scc5, _Complex char)
+T(Scc6, _Complex char)
+T(Scc7, _Complex char)
+T(Scc8, _Complex char)
+T(Scc9, _Complex char)
+T(Scc10, _Complex char)
+T(Scc11, _Complex char)
+T(Scc12, _Complex char)
+T(Scc13, _Complex char)
+T(Scc14, _Complex char)
+T(Scc15, _Complex char)
+T(Scc16, _Complex char)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_y.c
new file mode 100644
index 000000000..c4e47fc35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-11_y.c
@@ -0,0 +1,35 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cc,_Complex char)
+INITS(cc, _Complex char)
+
+TEST(Scc1, _Complex char)
+TEST(Scc2, _Complex char)
+TEST(Scc3, _Complex char)
+TEST(Scc4, _Complex char)
+TEST(Scc5, _Complex char)
+TEST(Scc6, _Complex char)
+TEST(Scc7, _Complex char)
+TEST(Scc8, _Complex char)
+TEST(Scc9, _Complex char)
+TEST(Scc10, _Complex char)
+TEST(Scc11, _Complex char)
+TEST(Scc12, _Complex char)
+TEST(Scc13, _Complex char)
+TEST(Scc14, _Complex char)
+TEST(Scc15, _Complex char)
+TEST(Scc16, _Complex char)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_main.c
new file mode 100644
index 000000000..ab4faac09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex short.  */
+
+extern void struct_by_value_12_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_12_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_x.c
new file mode 100644
index 000000000..925ce9270
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_x.c
@@ -0,0 +1,63 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cs, _Complex short)
+CHECKS(cs, _Complex short)
+
+TEST(Scs1, _Complex short)
+TEST(Scs2, _Complex short)
+TEST(Scs3, _Complex short)
+TEST(Scs4, _Complex short)
+TEST(Scs5, _Complex short)
+TEST(Scs6, _Complex short)
+TEST(Scs7, _Complex short)
+TEST(Scs8, _Complex short)
+TEST(Scs9, _Complex short)
+TEST(Scs10, _Complex short)
+TEST(Scs11, _Complex short)
+TEST(Scs12, _Complex short)
+TEST(Scs13, _Complex short)
+TEST(Scs14, _Complex short)
+TEST(Scs15, _Complex short)
+TEST(Scs16, _Complex short)
+#endif
+
+#undef T
+
+void
+struct_by_value_12_x ()
+{
+#ifndef SKIP_COMPLEX_INT
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Scs1, _Complex short)
+T(Scs2, _Complex short)
+T(Scs3, _Complex short)
+T(Scs4, _Complex short)
+T(Scs5, _Complex short)
+T(Scs6, _Complex short)
+T(Scs7, _Complex short)
+T(Scs8, _Complex short)
+T(Scs9, _Complex short)
+T(Scs10, _Complex short)
+T(Scs11, _Complex short)
+T(Scs12, _Complex short)
+T(Scs13, _Complex short)
+T(Scs14, _Complex short)
+T(Scs15, _Complex short)
+T(Scs16, _Complex short)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_y.c
new file mode 100644
index 000000000..2e8e393ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-12_y.c
@@ -0,0 +1,35 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cs,_Complex short)
+INITS(cs, _Complex short)
+
+TEST(Scs1, _Complex short)
+TEST(Scs2, _Complex short)
+TEST(Scs3, _Complex short)
+TEST(Scs4, _Complex short)
+TEST(Scs5, _Complex short)
+TEST(Scs6, _Complex short)
+TEST(Scs7, _Complex short)
+TEST(Scs8, _Complex short)
+TEST(Scs9, _Complex short)
+TEST(Scs10, _Complex short)
+TEST(Scs11, _Complex short)
+TEST(Scs12, _Complex short)
+TEST(Scs13, _Complex short)
+TEST(Scs14, _Complex short)
+TEST(Scs15, _Complex short)
+TEST(Scs16, _Complex short)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_main.c
new file mode 100644
index 000000000..b853bb88e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are type
+   _Complex int.  */
+
+extern void struct_by_value_l3_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_13_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_x.c
new file mode 100644
index 000000000..f27222f2d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_x.c
@@ -0,0 +1,63 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(ci, _Complex int)
+CHECKS(ci, _Complex int)
+
+TEST(Sci1, _Complex int)
+TEST(Sci2, _Complex int)
+TEST(Sci3, _Complex int)
+TEST(Sci4, _Complex int)
+TEST(Sci5, _Complex int)
+TEST(Sci6, _Complex int)
+TEST(Sci7, _Complex int)
+TEST(Sci8, _Complex int)
+TEST(Sci9, _Complex int)
+TEST(Sci10, _Complex int)
+TEST(Sci11, _Complex int)
+TEST(Sci12, _Complex int)
+TEST(Sci13, _Complex int)
+TEST(Sci14, _Complex int)
+TEST(Sci15, _Complex int)
+TEST(Sci16, _Complex int)
+#endif
+
+#undef T
+
+void
+struct_by_value_13_x ()
+{
+#ifndef SKIP_COMPLEX_INT
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sci1, _Complex int)
+T(Sci2, _Complex int)
+T(Sci3, _Complex int)
+T(Sci4, _Complex int)
+T(Sci5, _Complex int)
+T(Sci6, _Complex int)
+T(Sci7, _Complex int)
+T(Sci8, _Complex int)
+T(Sci9, _Complex int)
+T(Sci10, _Complex int)
+T(Sci11, _Complex int)
+T(Sci12, _Complex int)
+T(Sci13, _Complex int)
+T(Sci14, _Complex int)
+T(Sci15, _Complex int)
+T(Sci16, _Complex int)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_y.c
new file mode 100644
index 000000000..7a3657e0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-13_y.c
@@ -0,0 +1,35 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(ci,_Complex int)
+INITS(ci, _Complex int)
+
+TEST(Sci1, _Complex int)
+TEST(Sci2, _Complex int)
+TEST(Sci3, _Complex int)
+TEST(Sci4, _Complex int)
+TEST(Sci5, _Complex int)
+TEST(Sci6, _Complex int)
+TEST(Sci7, _Complex int)
+TEST(Sci8, _Complex int)
+TEST(Sci9, _Complex int)
+TEST(Sci10, _Complex int)
+TEST(Sci11, _Complex int)
+TEST(Sci12, _Complex int)
+TEST(Sci13, _Complex int)
+TEST(Sci14, _Complex int)
+TEST(Sci15, _Complex int)
+TEST(Sci16, _Complex int)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_main.c
new file mode 100644
index 000000000..a332e93b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex long.  */
+
+extern void struct_by_value_14_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_14_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_x.c
new file mode 100644
index 000000000..bb8db7072
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_x.c
@@ -0,0 +1,63 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cl, _Complex long)
+CHECKS(cl, _Complex long)
+
+TEST(Scl1, _Complex long)
+TEST(Scl2, _Complex long)
+TEST(Scl3, _Complex long)
+TEST(Scl4, _Complex long)
+TEST(Scl5, _Complex long)
+TEST(Scl6, _Complex long)
+TEST(Scl7, _Complex long)
+TEST(Scl8, _Complex long)
+TEST(Scl9, _Complex long)
+TEST(Scl10, _Complex long)
+TEST(Scl11, _Complex long)
+TEST(Scl12, _Complex long)
+TEST(Scl13, _Complex long)
+TEST(Scl14, _Complex long)
+TEST(Scl15, _Complex long)
+TEST(Scl16, _Complex long)
+#endif
+
+#undef T
+
+void
+struct_by_value_14_x ()
+{
+#ifndef SKIP_COMPLEX_INT
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Scl1, _Complex long)
+T(Scl2, _Complex long)
+T(Scl3, _Complex long)
+T(Scl4, _Complex long)
+T(Scl5, _Complex long)
+T(Scl6, _Complex long)
+T(Scl7, _Complex long)
+T(Scl8, _Complex long)
+T(Scl9, _Complex long)
+T(Scl10, _Complex long)
+T(Scl11, _Complex long)
+T(Scl12, _Complex long)
+T(Scl13, _Complex long)
+T(Scl14, _Complex long)
+T(Scl15, _Complex long)
+T(Scl16, _Complex long)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_y.c
new file mode 100644
index 000000000..5abd063ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-14_y.c
@@ -0,0 +1,35 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cl,_Complex long)
+INITS(cl, _Complex long)
+
+TEST(Scl1, _Complex long)
+TEST(Scl2, _Complex long)
+TEST(Scl3, _Complex long)
+TEST(Scl4, _Complex long)
+TEST(Scl5, _Complex long)
+TEST(Scl6, _Complex long)
+TEST(Scl7, _Complex long)
+TEST(Scl8, _Complex long)
+TEST(Scl9, _Complex long)
+TEST(Scl10, _Complex long)
+TEST(Scl11, _Complex long)
+TEST(Scl12, _Complex long)
+TEST(Scl13, _Complex long)
+TEST(Scl14, _Complex long)
+TEST(Scl15, _Complex long)
+TEST(Scl16, _Complex long)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_main.c
new file mode 100644
index 000000000..6e5d8e0f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex long long.  */
+
+extern void struct_by_value_15_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_15_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_x.c
new file mode 100644
index 000000000..4409c9668
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_x.c
@@ -0,0 +1,63 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cll, _Complex long long)
+CHECKS(cll, _Complex long long)
+
+TEST(Scll1, _Complex long long)
+TEST(Scll2, _Complex long long)
+TEST(Scll3, _Complex long long)
+TEST(Scll4, _Complex long long)
+TEST(Scll5, _Complex long long)
+TEST(Scll6, _Complex long long)
+TEST(Scll7, _Complex long long)
+TEST(Scll8, _Complex long long)
+TEST(Scll9, _Complex long long)
+TEST(Scll10, _Complex long long)
+TEST(Scll11, _Complex long long)
+TEST(Scll12, _Complex long long)
+TEST(Scll13, _Complex long long)
+TEST(Scll14, _Complex long long)
+TEST(Scll15, _Complex long long)
+TEST(Scll16, _Complex long long)
+#endif
+
+#undef T
+
+void
+struct_by_value_15_x ()
+{
+#ifndef SKIP_COMPLEX_INT
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Scll1, _Complex long long)
+T(Scll2, _Complex long long)
+T(Scll3, _Complex long long)
+T(Scll4, _Complex long long)
+T(Scll5, _Complex long long)
+T(Scll6, _Complex long long)
+T(Scll7, _Complex long long)
+T(Scll8, _Complex long long)
+T(Scll9, _Complex long long)
+T(Scll10, _Complex long long)
+T(Scll11, _Complex long long)
+T(Scll12, _Complex long long)
+T(Scll13, _Complex long long)
+T(Scll14, _Complex long long)
+T(Scll15, _Complex long long)
+T(Scll16, _Complex long long)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_y.c
new file mode 100644
index 000000000..a5fec4fdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-15_y.c
@@ -0,0 +1,35 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX_INT
+DEFS(cll,_Complex long long)
+INITS(cll, _Complex long long)
+
+TEST(Scll1, _Complex long long)
+TEST(Scll2, _Complex long long)
+TEST(Scll3, _Complex long long)
+TEST(Scll4, _Complex long long)
+TEST(Scll5, _Complex long long)
+TEST(Scll6, _Complex long long)
+TEST(Scll7, _Complex long long)
+TEST(Scll8, _Complex long long)
+TEST(Scll9, _Complex long long)
+TEST(Scll10, _Complex long long)
+TEST(Scll11, _Complex long long)
+TEST(Scll12, _Complex long long)
+TEST(Scll13, _Complex long long)
+TEST(Scll14, _Complex long long)
+TEST(Scll15, _Complex long long)
+TEST(Scll16, _Complex long long)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_main.c
new file mode 100644
index 000000000..31447bee6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex float.  */
+
+extern void struct_by_value_16_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_16_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_x.c
new file mode 100644
index 000000000..05e36fe26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_x.c
@@ -0,0 +1,55 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cf, _Complex float)
+CHECKS(cf, _Complex float)
+
+TEST(Scf1, _Complex float)
+TEST(Scf2, _Complex float)
+TEST(Scf3, _Complex float)
+TEST(Scf4, _Complex float)
+TEST(Scf5, _Complex float)
+TEST(Scf6, _Complex float)
+TEST(Scf7, _Complex float)
+TEST(Scf8, _Complex float)
+TEST(Scf9, _Complex float)
+TEST(Scf10, _Complex float)
+TEST(Scf11, _Complex float)
+TEST(Scf12, _Complex float)
+#endif
+
+#undef T
+
+void
+struct_by_value_16_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+#ifndef SKIP_COMPLEX
+T(Scf1, _Complex float)
+T(Scf2, _Complex float)
+T(Scf3, _Complex float)
+T(Scf4, _Complex float)
+T(Scf5, _Complex float)
+T(Scf6, _Complex float)
+T(Scf7, _Complex float)
+T(Scf8, _Complex float)
+T(Scf9, _Complex float)
+T(Scf10, _Complex float)
+T(Scf11, _Complex float)
+T(Scf12, _Complex float)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_y.c
new file mode 100644
index 000000000..ce99a68a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16_y.c
@@ -0,0 +1,31 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cf,_Complex float)
+INITS(cf, _Complex float)
+
+TEST(Scf1, _Complex float)
+TEST(Scf2, _Complex float)
+TEST(Scf3, _Complex float)
+TEST(Scf4, _Complex float)
+TEST(Scf5, _Complex float)
+TEST(Scf6, _Complex float)
+TEST(Scf7, _Complex float)
+TEST(Scf8, _Complex float)
+TEST(Scf9, _Complex float)
+TEST(Scf10, _Complex float)
+TEST(Scf11, _Complex float)
+TEST(Scf12, _Complex float)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_main.c
new file mode 100644
index 000000000..6a71d15b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a

+   variable-length argument lists.  All struct members are of type

+   _Complex float.  */

+

+extern void struct_by_value_16_x (void);

+extern void exit (int);

+int fails;

+

+int

+main ()

+{

+  struct_by_value_16a_x ();

+  exit (0);

+}

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_x.c
new file mode 100644
index 000000000..f563f6ea9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_x.c
@@ -0,0 +1,39 @@
+#include "compat-common.h"

+

+#include "fp-struct-defs.h"

+#include "fp-struct-check.h"

+#include "fp-struct-test-by-value-x.h"

+

+#ifndef SKIP_COMPLEX

+DEFS(cf, _Complex float)

+CHECKS(cf, _Complex float)

+

+TEST(Scf13, _Complex float)

+TEST(Scf14, _Complex float)

+TEST(Scf15, _Complex float)

+TEST(Scf16, _Complex float)

+#endif

+

+#undef T

+

+void

+struct_by_value_16a_x ()

+{

+DEBUG_INIT

+

+#define T(TYPE, MTYPE) testit##TYPE ();

+

+#ifndef SKIP_COMPLEX

+T(Scf13, _Complex float)

+T(Scf14, _Complex float)

+T(Scf15, _Complex float)

+T(Scf16, _Complex float)

+#endif

+

+DEBUG_FINI

+

+if (fails != 0)

+  abort ();

+

+#undef T

+}

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_y.c
new file mode 100644
index 000000000..0575b3c1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-16a_y.c
@@ -0,0 +1,23 @@
+#include <stdarg.h>

+

+#include "compat-common.h"

+

+#ifdef SKIP_VA

+const int test_va = 0;

+#else

+const int test_va = 1;

+#endif

+

+#include "fp-struct-defs.h"

+#include "fp-struct-init.h"

+#include "fp-struct-test-by-value-y.h"

+

+#ifndef SKIP_COMPLEX

+DEFS(cf,_Complex float)

+INITS(cf, _Complex float)

+

+TEST(Scf13, _Complex float)

+TEST(Scf14, _Complex float)

+TEST(Scf15, _Complex float)

+TEST(Scf16, _Complex float)

+#endif

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_main.c
new file mode 100644
index 000000000..3d97146b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex double.  */
+
+extern void struct_by_value_17_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_17_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_x.c
new file mode 100644
index 000000000..8c2704522
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_x.c
@@ -0,0 +1,55 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cd, _Complex double)
+CHECKS(cd, _Complex double)
+
+TEST(Scd1, _Complex double)
+TEST(Scd2, _Complex double)
+TEST(Scd3, _Complex double)
+TEST(Scd4, _Complex double)
+TEST(Scd5, _Complex double)
+TEST(Scd6, _Complex double)
+TEST(Scd7, _Complex double)
+TEST(Scd8, _Complex double)
+TEST(Scd9, _Complex double)
+TEST(Scd10, _Complex double)
+TEST(Scd11, _Complex double)
+TEST(Scd12, _Complex double)
+#endif
+
+#undef T
+
+void
+struct_by_value_17_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+#ifndef SKIP_COMPLEX
+T(Scd1, _Complex double)
+T(Scd2, _Complex double)
+T(Scd3, _Complex double)
+T(Scd4, _Complex double)
+T(Scd5, _Complex double)
+T(Scd6, _Complex double)
+T(Scd7, _Complex double)
+T(Scd8, _Complex double)
+T(Scd9, _Complex double)
+T(Scd10, _Complex double)
+T(Scd11, _Complex double)
+T(Scd12, _Complex double)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_y.c
new file mode 100644
index 000000000..d05ff8407
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17_y.c
@@ -0,0 +1,31 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cd,_Complex double)
+INITS(cd, _Complex double)
+
+TEST(Scd1, _Complex double)
+TEST(Scd2, _Complex double)
+TEST(Scd3, _Complex double)
+TEST(Scd4, _Complex double)
+TEST(Scd5, _Complex double)
+TEST(Scd6, _Complex double)
+TEST(Scd7, _Complex double)
+TEST(Scd8, _Complex double)
+TEST(Scd9, _Complex double)
+TEST(Scd10, _Complex double)
+TEST(Scd11, _Complex double)
+TEST(Scd12, _Complex double)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_main.c
new file mode 100644
index 000000000..1db00215f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex double.  */
+
+extern void struct_by_value_17_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_17a_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_x.c
new file mode 100644
index 000000000..804b5c255
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_x.c
@@ -0,0 +1,39 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cd, _Complex double)
+CHECKS(cd, _Complex double)
+
+TEST(Scd13, _Complex double)
+TEST(Scd14, _Complex double)
+TEST(Scd15, _Complex double)
+TEST(Scd16, _Complex double)
+#endif
+
+#undef T
+
+void
+struct_by_value_17a_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+#ifndef SKIP_COMPLEX
+T(Scd13, _Complex double)
+T(Scd14, _Complex double)
+T(Scd15, _Complex double)
+T(Scd16, _Complex double)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_y.c
new file mode 100644
index 000000000..3119e5448
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-17a_y.c
@@ -0,0 +1,23 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cd,_Complex double)
+INITS(cd, _Complex double)
+
+TEST(Scd13, _Complex double)
+TEST(Scd14, _Complex double)
+TEST(Scd15, _Complex double)
+TEST(Scd16, _Complex double)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_main.c
new file mode 100644
index 000000000..8a4889cc0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are of type
+   _Complex long double.  */
+
+extern void struct_by_value_18_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_18_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_x.c
new file mode 100644
index 000000000..aa10a6e1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_x.c
@@ -0,0 +1,55 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cld, _Complex long double)
+CHECKS(cld, _Complex long double)
+
+TEST(Scld1, _Complex long double)
+TEST(Scld2, _Complex long double)
+TEST(Scld3, _Complex long double)
+TEST(Scld4, _Complex long double)
+TEST(Scld5, _Complex long double)
+TEST(Scld6, _Complex long double)
+TEST(Scld7, _Complex long double)
+TEST(Scld8, _Complex long double)
+TEST(Scld9, _Complex long double)
+TEST(Scld10, _Complex long double)
+TEST(Scld11, _Complex long double)
+TEST(Scld12, _Complex long double)
+#endif
+
+#undef T
+
+void
+struct_by_value_18_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+#ifndef SKIP_COMPLEX
+T(Scld1, _Complex long double)
+T(Scld2, _Complex long double)
+T(Scld3, _Complex long double)
+T(Scld4, _Complex long double)
+T(Scld5, _Complex long double)
+T(Scld6, _Complex long double)
+T(Scld7, _Complex long double)
+T(Scld8, _Complex long double)
+T(Scld9, _Complex long double)
+T(Scld10, _Complex long double)
+T(Scld11, _Complex long double)
+T(Scld12, _Complex long double)
+#endif
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_y.c
new file mode 100644
index 000000000..d98debb6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18_y.c
@@ -0,0 +1,31 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+#ifndef SKIP_COMPLEX
+DEFS(cld,_Complex long double)
+INITS(cld, _Complex long double)
+
+TEST(Scld1, _Complex long double)
+TEST(Scld2, _Complex long double)
+TEST(Scld3, _Complex long double)
+TEST(Scld4, _Complex long double)
+TEST(Scld5, _Complex long double)
+TEST(Scld6, _Complex long double)
+TEST(Scld7, _Complex long double)
+TEST(Scld8, _Complex long double)
+TEST(Scld9, _Complex long double)
+TEST(Scld10, _Complex long double)
+TEST(Scld11, _Complex long double)
+TEST(Scld12, _Complex long double)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_main.c
new file mode 100644
index 000000000..5b9dfd983
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a

+   variable-length argument lists.  All struct members are of type

+   _Complex long double.  */

+

+extern void struct_by_value_18_x (void);

+extern void exit (int);

+int fails;

+

+int

+main ()

+{

+  struct_by_value_18a_x ();

+  exit (0);

+}

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_x.c
new file mode 100644
index 000000000..986c4dded
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_x.c
@@ -0,0 +1,39 @@
+#include "compat-common.h"

+

+#include "fp-struct-defs.h"

+#include "fp-struct-check.h"

+#include "fp-struct-test-by-value-x.h"

+

+#ifndef SKIP_COMPLEX

+DEFS(cld, _Complex long double)

+CHECKS(cld, _Complex long double)

+

+TEST(Scld13, _Complex long double)

+TEST(Scld14, _Complex long double)

+TEST(Scld15, _Complex long double)

+TEST(Scld16, _Complex long double)

+#endif

+

+#undef T

+

+void

+struct_by_value_18a_x ()

+{

+DEBUG_INIT

+

+#define T(TYPE, MTYPE) testit##TYPE ();

+

+#ifndef SKIP_COMPLEX

+T(Scld13, _Complex long double)

+T(Scld14, _Complex long double)

+T(Scld15, _Complex long double)

+T(Scld16, _Complex long double)

+#endif

+

+DEBUG_FINI

+

+if (fails != 0)

+  abort ();

+

+#undef T

+}

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_y.c
new file mode 100644
index 000000000..12ac53418
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-18a_y.c
@@ -0,0 +1,23 @@
+#include <stdarg.h>

+

+#include "compat-common.h"

+

+#ifdef SKIP_VA

+const int test_va = 0;

+#else

+const int test_va = 1;

+#endif

+

+#include "fp-struct-defs.h"

+#include "fp-struct-init.h"

+#include "fp-struct-test-by-value-y.h"

+

+#ifndef SKIP_COMPLEX

+DEFS(cld,_Complex long double)

+INITS(cld, _Complex long double)

+

+TEST(Scld13, _Complex long double)

+TEST(Scld14, _Complex long double)

+TEST(Scld15, _Complex long double)

+TEST(Scld16, _Complex long double)

+#endif

diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_main.c
new file mode 100644
index 000000000..b0eed4c3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_main.c
@@ -0,0 +1,17 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.  Struct members are char, int, double,
+   and other structs containing these types.  This test was written in
+   response to a layout change for such structs for powerpc64-linux,
+   but this test only checks similar structs that are not affected by
+   that break in compatibility. */
+
+extern void struct_by_value_19_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_19_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_x.c
new file mode 100644
index 000000000..4ccedfde3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_x.c
@@ -0,0 +1,178 @@
+#include "compat-common.h"
+
+#define T(TYPE)							\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  1);				\
+  init##TYPE  ( &g2s##TYPE,  2);				\
+  init##TYPE  ( &g3s##TYPE,  3);				\
+  init##TYPE  ( &g4s##TYPE,  4);				\
+  init##TYPE  ( &g5s##TYPE,  5);				\
+  init##TYPE  ( &g6s##TYPE,  6);				\
+  init##TYPE  ( &g7s##TYPE,  7);				\
+  init##TYPE  ( &g8s##TYPE,  8);				\
+  init##TYPE  ( &g9s##TYPE,  9);				\
+  init##TYPE  (&g10s##TYPE, 10);				\
+  init##TYPE  (&g11s##TYPE, 11);				\
+  init##TYPE  (&g12s##TYPE, 12);				\
+  init##TYPE  (&g13s##TYPE, 13);				\
+  init##TYPE  (&g14s##TYPE, 14);				\
+  init##TYPE  (&g15s##TYPE, 15);				\
+  init##TYPE  (&g16s##TYPE, 16);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2:");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+T(Scdc)
+T(Sd)
+T(Sdi)
+T(Scsdsc)
+T(Scsdis)
+T(Scsdisc)
+T(Ssds)
+T(Ssdsc)
+T(Scssdssc)
+
+#undef T
+
+void
+struct_by_value_19_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Scdc)
+T(Sd)
+T(Sdi)
+T(Scsdsc)
+T(Scsdis)
+T(Scsdisc)
+T(Ssds)
+T(Ssdsc)
+T(Scssdssc)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_y.c
new file mode 100644
index 000000000..036c6b618
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-19_y.c
@@ -0,0 +1,104 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "mixed-struct-defs.h"
+
+extern void checkScd (Scd x, int i);
+extern void checkScdc (Scdc x, int i);
+extern void checkSd (Sd x, int i);
+extern void checkSdi (Sdi x, int i);
+extern void checkScsds (Scsds x, int i);
+extern void checkScsdsc (Scsdsc x, int i);
+extern void checkScsdis (Scsdis x, int i);
+extern void checkScsdisc (Scsdisc x, int i);
+extern void checkSsds (Ssds x, int i);
+extern void checkSsdsc (Ssdsc x, int i);
+extern void checkScssdss (Scssdss x, int i);
+extern void checkScssdssc (Scssdssc x, int i);
+
+#include "mixed-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  1);				\
+  check##TYPE (  g2s##TYPE,  2);				\
+  check##TYPE (  g3s##TYPE,  3);				\
+  check##TYPE (  g4s##TYPE,  4);				\
+  check##TYPE (  g5s##TYPE,  5);				\
+  check##TYPE (  g6s##TYPE,  6);				\
+  check##TYPE (  g7s##TYPE,  7);				\
+  check##TYPE (  g8s##TYPE,  8);				\
+  check##TYPE (  g9s##TYPE,  9);				\
+  check##TYPE ( g10s##TYPE, 10);				\
+  check##TYPE ( g11s##TYPE, 11);				\
+  check##TYPE ( g12s##TYPE, 12);				\
+  check##TYPE ( g13s##TYPE, 13);				\
+  check##TYPE ( g14s##TYPE, 14);				\
+  check##TYPE ( g15s##TYPE, 15);				\
+  check##TYPE ( g16s##TYPE, 16);				\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, 1);						\
+  check##TYPE (s2, 2);						\
+  check##TYPE (s3, 3);						\
+  check##TYPE (s4, 4);						\
+  check##TYPE (s5, 5);						\
+  check##TYPE (s6, 6);						\
+  check##TYPE (s7, 7);						\
+  check##TYPE (s8, 8);						\
+  check##TYPE (s9, 9);						\
+  check##TYPE (s10, 10);					\
+  check##TYPE (s11, 11);					\
+  check##TYPE (s12, 12);					\
+  check##TYPE (s13, 13);					\
+  check##TYPE (s14, 14);					\
+  check##TYPE (s15, 15);					\
+  check##TYPE (s16, 16);					\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(Scdc)
+T(Sd)
+T(Sdi)
+T(Scsdsc)
+T(Scsdis)
+T(Scsdisc)
+T(Ssds)
+T(Ssdsc)
+T(Scssdssc)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_main.c
new file mode 100644
index 000000000..d2f9de505
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_main.c
@@ -0,0 +1,12 @@
+/* Test structure passing by value, using a test from gcc.dg.
+   Each struct that is passed contains an array of unsigned char.  */
+
+extern void struct_by_value_1_x (void);
+extern void exit (int);
+
+int
+main ()
+{
+  struct_by_value_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_x.c
new file mode 100644
index 000000000..67ac16d1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_x.c
@@ -0,0 +1,69 @@
+#define T(N)							\
+struct S##N { unsigned char i[N]; };				\
+struct S##N g1s##N, g2s##N, g3s##N;				\
+								\
+extern void init##N (struct S##N *p, int i);			\
+extern void checkg##N (void);					\
+extern void test##N (struct S##N s1,				\
+    struct S##N s2, struct S##N s3);				\
+								\
+void								\
+check##N (struct S##N x, int i)					\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    if (x.i[j] != i + j) abort ();				\
+}								\
+								\
+void								\
+test2_##N (struct S##N s1, struct S##N s2)			\
+{								\
+  test##N (s1, g2s##N, s2);					\
+}								\
+								\
+void								\
+testit##N (void)						\
+{								\
+  init##N (&g1s##N, 64);					\
+  init##N (&g2s##N, 128);					\
+  init##N (&g3s##N, 192);					\
+  checkg##N ();							\
+  test##N (g1s##N, g2s##N, g3s##N);				\
+  test2_##N (g1s##N, g3s##N);					\
+}
+
+extern void abort (void);
+
+#ifndef SKIP_ZERO_ARRAY
+T(0)
+#endif
+T(1) T(2) T(3) T(4) T(5) T(6) T(7)
+T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15)
+T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23)
+T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31)
+T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39)
+T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47)
+T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55)
+T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63)
+
+#undef T
+
+void
+struct_by_value_1_x ()
+{
+#define T(N) testit##N ();
+
+#ifndef SKIP_ZERO_ARRAY
+T(0)
+#endif
+T(1) T(2) T(3) T(4) T(5) T(6) T(7)
+T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15)
+T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23)
+T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31)
+T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39)
+T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47)
+T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55)
+T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63)
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_y.c
new file mode 100644
index 000000000..8370dbac3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-1_y.c
@@ -0,0 +1,43 @@
+#define T(N)							\
+struct S##N { unsigned char i[N]; };				\
+extern struct S##N g1s##N, g2s##N, g3s##N;			\
+								\
+extern void check##N (struct S##N x, int i);			\
+extern void test2_##N (struct S##N s1, struct S##N s2);		\
+								\
+void								\
+init##N (struct S##N *p, int i)					\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    p->i[j] = i + j;						\
+}								\
+								\
+void								\
+checkg##N (void)						\
+{								\
+  check##N (g1s##N, 64);					\
+  check##N (g2s##N, 128);					\
+  check##N (g3s##N, 192);					\
+}								\
+								\
+void								\
+test##N (struct S##N s1, struct S##N s2,			\
+			 struct S##N s3)			\
+{								\
+  check##N (s1, 64);						\
+  check##N (s2, 128);						\
+  check##N (s3, 192);						\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0)
+#endif
+T(1) T(2) T(3) T(4) T(5) T(6) T(7)
+T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15)
+T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23)
+T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31)
+T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39)
+T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47)
+T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55)
+T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_main.c
new file mode 100644
index 000000000..64c8f27ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_main.c
@@ -0,0 +1,16 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.  Tested structs end with double.
+   This test was written in response to a layout change for such
+   structs for powerpc64-linux that breaks compatibility between
+   3.3 and 3.4. */
+
+extern void struct_by_value_20_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_20_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_x.c
new file mode 100644
index 000000000..183e32dc4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_x.c
@@ -0,0 +1,166 @@
+#include "compat-common.h"
+
+#define T(TYPE)							\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  1);				\
+  init##TYPE  ( &g2s##TYPE,  2);				\
+  init##TYPE  ( &g3s##TYPE,  3);				\
+  init##TYPE  ( &g4s##TYPE,  4);				\
+  init##TYPE  ( &g5s##TYPE,  5);				\
+  init##TYPE  ( &g6s##TYPE,  6);				\
+  init##TYPE  ( &g7s##TYPE,  7);				\
+  init##TYPE  ( &g8s##TYPE,  8);				\
+  init##TYPE  ( &g9s##TYPE,  9);				\
+  init##TYPE  (&g10s##TYPE, 10);				\
+  init##TYPE  (&g11s##TYPE, 11);				\
+  init##TYPE  (&g12s##TYPE, 12);				\
+  init##TYPE  (&g13s##TYPE, 13);				\
+  init##TYPE  (&g14s##TYPE, 14);				\
+  init##TYPE  (&g15s##TYPE, 15);				\
+  init##TYPE  (&g16s##TYPE, 16);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2:");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+T(Scd)
+T(Scsds)
+T(Scssdss)
+
+#undef T
+
+void
+struct_by_value_20_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Scd)
+T(Scsds)
+T(Scssdss)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_y.c
new file mode 100644
index 000000000..1a4a6775d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-20_y.c
@@ -0,0 +1,98 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "mixed-struct-defs.h"
+
+extern void checkScd (Scd x, int i);
+extern void checkScdc (Scdc x, int i);
+extern void checkSd (Sd x, int i);
+extern void checkSdi (Sdi x, int i);
+extern void checkScsds (Scsds x, int i);
+extern void checkScsdsc (Scsdsc x, int i);
+extern void checkScsdis (Scsdis x, int i);
+extern void checkScsdisc (Scsdisc x, int i);
+extern void checkSsds (Ssds x, int i);
+extern void checkSsdsc (Ssdsc x, int i);
+extern void checkScssdss (Scssdss x, int i);
+extern void checkScssdssc (Scssdssc x, int i);
+
+#include "mixed-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  1);				\
+  check##TYPE (  g2s##TYPE,  2);				\
+  check##TYPE (  g3s##TYPE,  3);				\
+  check##TYPE (  g4s##TYPE,  4);				\
+  check##TYPE (  g5s##TYPE,  5);				\
+  check##TYPE (  g6s##TYPE,  6);				\
+  check##TYPE (  g7s##TYPE,  7);				\
+  check##TYPE (  g8s##TYPE,  8);				\
+  check##TYPE (  g9s##TYPE,  9);				\
+  check##TYPE ( g10s##TYPE, 10);				\
+  check##TYPE ( g11s##TYPE, 11);				\
+  check##TYPE ( g12s##TYPE, 12);				\
+  check##TYPE ( g13s##TYPE, 13);				\
+  check##TYPE ( g14s##TYPE, 14);				\
+  check##TYPE ( g15s##TYPE, 15);				\
+  check##TYPE ( g16s##TYPE, 16);				\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, 1);						\
+  check##TYPE (s2, 2);						\
+  check##TYPE (s3, 3);						\
+  check##TYPE (s4, 4);						\
+  check##TYPE (s5, 5);						\
+  check##TYPE (s6, 6);						\
+  check##TYPE (s7, 7);						\
+  check##TYPE (s8, 8);						\
+  check##TYPE (s9, 9);						\
+  check##TYPE (s10, 10);					\
+  check##TYPE (s11, 11);					\
+  check##TYPE (s12, 12);					\
+  check##TYPE (s13, 13);					\
+  check##TYPE (s14, 14);					\
+  check##TYPE (s15, 15);					\
+  check##TYPE (s16, 16);					\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(Scd)
+T(Scsds)
+T(Scssdss)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_main.c
new file mode 100644
index 000000000..b722bccd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_main.c
@@ -0,0 +1,13 @@
+/* Test function argument passing.  This was written when correcting
+   a deviation from the ABI on SPARC64 between 3.3 and 3.4.  */
+
+extern void struct_by_value_21_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_21_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_x.c
new file mode 100644
index 000000000..3b01ba86e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_x.c
@@ -0,0 +1,168 @@
+#include "compat-common.h"
+
+#define T(TYPE)							\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  1);				\
+  init##TYPE  ( &g2s##TYPE,  2);				\
+  init##TYPE  ( &g3s##TYPE,  3);				\
+  init##TYPE  ( &g4s##TYPE,  4);				\
+  init##TYPE  ( &g5s##TYPE,  5);				\
+  init##TYPE  ( &g6s##TYPE,  6);				\
+  init##TYPE  ( &g7s##TYPE,  7);				\
+  init##TYPE  ( &g8s##TYPE,  8);				\
+  init##TYPE  ( &g9s##TYPE,  9);				\
+  init##TYPE  (&g10s##TYPE, 10);				\
+  init##TYPE  (&g11s##TYPE, 11);				\
+  init##TYPE  (&g12s##TYPE, 12);				\
+  init##TYPE  (&g13s##TYPE, 13);				\
+  init##TYPE  (&g14s##TYPE, 14);				\
+  init##TYPE  (&g15s##TYPE, 15);				\
+  init##TYPE  (&g16s##TYPE, 16);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2:");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+T(Sfi)
+T(Sfii)
+T(Sfifi)
+T(Sfiifii)
+
+#undef T
+
+void
+struct_by_value_21_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Sfi)
+T(Sfii)
+T(Sfifi)
+T(Sfiifii)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_y.c
new file mode 100644
index 000000000..fc06d9d4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-21_y.c
@@ -0,0 +1,86 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-init.h"
+
+#define T(TYPE)							\
+extern void check##TYPE (TYPE x, int i);			\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  1);				\
+  check##TYPE (  g2s##TYPE,  2);				\
+  check##TYPE (  g3s##TYPE,  3);				\
+  check##TYPE (  g4s##TYPE,  4);				\
+  check##TYPE (  g5s##TYPE,  5);				\
+  check##TYPE (  g6s##TYPE,  6);				\
+  check##TYPE (  g7s##TYPE,  7);				\
+  check##TYPE (  g8s##TYPE,  8);				\
+  check##TYPE (  g9s##TYPE,  9);				\
+  check##TYPE ( g10s##TYPE, 10);				\
+  check##TYPE ( g11s##TYPE, 11);				\
+  check##TYPE ( g12s##TYPE, 12);				\
+  check##TYPE ( g13s##TYPE, 13);				\
+  check##TYPE ( g14s##TYPE, 14);				\
+  check##TYPE ( g15s##TYPE, 15);				\
+  check##TYPE ( g16s##TYPE, 16);				\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, 1);						\
+  check##TYPE (s2, 2);						\
+  check##TYPE (s3, 3);						\
+  check##TYPE (s4, 4);						\
+  check##TYPE (s5, 5);						\
+  check##TYPE (s6, 6);						\
+  check##TYPE (s7, 7);						\
+  check##TYPE (s8, 8);						\
+  check##TYPE (s9, 9);						\
+  check##TYPE (s10, 10);					\
+  check##TYPE (s11, 11);					\
+  check##TYPE (s12, 12);					\
+  check##TYPE (s13, 13);					\
+  check##TYPE (s14, 14);					\
+  check##TYPE (s15, 15);					\
+  check##TYPE (s16, 16);					\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(Sfi)
+T(Sfii)
+T(Sfifi)
+T(Sfiifii)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_main.c
new file mode 100644
index 000000000..1fd2eba1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_main.c
@@ -0,0 +1,20 @@
+/* Test variable sized function argument passing.
+   GCC 3.2 and earlier is incompatible with GCC 3.3+ on x86-64,
+   the latter passes variable sized arguments by reference while
+   the former doesn't.
+   See http://gcc.gnu.org/ml/gcc-patches/2003-01/msg01830.html */
+
+#ifndef SKIP_VLA_IN_STRUCT
+extern void struct_by_value_22_x (void);
+#endif
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+#ifndef SKIP_VLA_IN_STRUCT
+  struct_by_value_22_x ();
+#endif
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_x.c
new file mode 100644
index 000000000..6f1cdc860
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_x.c
@@ -0,0 +1,83 @@
+#ifndef SKIP_VLA_IN_STRUCT
+
+#ifndef T
+#include "compat-common.h"
+#include "mixed-struct-defs.h"
+#include "mixed-struct-init.h"
+
+#define T(NAME, FIELDS, TYPE, FIELDINIT, FIELDTEST)			\
+extern void testva##NAME (int n, ...);					\
+									\
+void									\
+testit##NAME (int n)							\
+{									\
+  struct S { FIELDS TYPE a[n]; } s;					\
+  int i;								\
+  FIELDINIT;								\
+  for (i = 0; i < n; ++i)						\
+    s.a[i] = 12 + n - i;						\
+  testva##NAME (n, s, n, s);						\
+}
+
+#include "struct-by-value-22_x.c"
+
+#undef T
+
+void
+struct_by_value_22_x ()
+{
+  int n;
+DEBUG_INIT
+
+#define T(NAME, FIELDS, TYPE, FIELDINIT, FIELDTEST) testit##NAME (n);
+
+  for (n = 0; n < 16; ++n)
+    {
+#include "struct-by-value-22_x.c"
+      DEBUG_NL;
+    }
+  for (; n < 110; n += 13)
+    {
+#include "struct-by-value-22_x.c"
+      DEBUG_NL;
+    }
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+}
+
+#else
+
+#define S(NAME, FIELDS, FIELDINIT, FIELDTEST)				\
+  T(c##NAME, FIELDS, char, FIELDINIT, FIELDTEST)			\
+  T(s##NAME, FIELDS, short, FIELDINIT, FIELDTEST)			\
+  T(u##NAME, FIELDS, unsigned, FIELDINIT, FIELDTEST)			\
+  T(d##NAME, FIELDS, double, FIELDINIT, FIELDTEST)
+S(E, , do {} while (0), DEBUG_DOT)
+S(n, int n;, s.n = n, if (s.n != n) DEBUG_CHECK)
+#define U(TYPE)								\
+S(TYPE, TYPE s;, init##TYPE (&s.s, n), check##TYPE (s.s, n))
+U(Scd)
+U(Scdc)
+U(Sd)
+U(Sdi)
+U(Scsds)
+U(Scsdsc)
+U(Scsdis)
+U(Scsdisc)
+U(Ssds)
+U(Ssdsc)
+U(Scssdss)
+U(Scssdssc)
+U(Sfi)
+U(Sfii)
+U(Sfifi)
+U(Sfiifii)
+#undef S
+#undef U
+
+#endif
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_y.c
new file mode 100644
index 000000000..ea5dec226
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-22_y.c
@@ -0,0 +1,41 @@
+#include <stdarg.h>
+#include "compat-common.h"
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#ifndef SKIP_VLA_IN_STRUCT
+#define T(NAME, FIELDS, TYPE, FIELDINIT, FIELDTEST)			\
+void									\
+testva##NAME (int n, ...)						\
+{									\
+  va_list ap;								\
+  if (test_va)								\
+    {									\
+      struct S { FIELDS TYPE a[n]; } s;					\
+      int fail = 0, i, j;						\
+									\
+      va_start (ap, n);							\
+      for (j = 0; j < 2; ++j)						\
+        {								\
+	  s = va_arg (ap, struct S);					\
+	  for (i = 0; i < n; ++i)					\
+	    if (s.a[i] != 12 + n - i)					\
+	      ++fail;							\
+	  if (fail)							\
+	    { DEBUG_FAIL; }						\
+	  if (!j && va_arg (ap, int) != n)				\
+	    { DEBUG_FAIL; }						\
+	  FIELDTEST;							\
+	}								\
+      va_end (ap);							\
+    }									\
+}
+
+#include "struct-by-value-22_x.c"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_main.c
new file mode 100644
index 000000000..8cb6fc078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.
+   This test is based on one contributed by Alan Modra.  */
+
+extern void struct_by_value_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_2_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_x.c
new file mode 100644
index 000000000..57c6da0c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_x.c
@@ -0,0 +1,233 @@
+#include "compat-common.h"
+
+#define T(N, NAME, TYPE)					\
+struct S##NAME##N { TYPE i[N]; };				\
+struct S##NAME##N g1s##NAME##N, g2s##NAME##N;			\
+struct S##NAME##N g3s##NAME##N, g4s##NAME##N;			\
+struct S##NAME##N g5s##NAME##N, g6s##NAME##N;			\
+struct S##NAME##N g7s##NAME##N, g8s##NAME##N;			\
+struct S##NAME##N g9s##NAME##N, g10s##NAME##N;			\
+struct S##NAME##N g11s##NAME##N, g12s##NAME##N;			\
+struct S##NAME##N g13s##NAME##N, g14s##NAME##N;			\
+struct S##NAME##N g15s##NAME##N, g16s##NAME##N;			\
+								\
+extern void init##NAME##N (struct S##NAME##N *p, int i);	\
+extern void checkg##NAME##N (void);				\
+extern void							\
+test##NAME##N (struct S##NAME##N s1, struct S##NAME##N s2,	\
+	       struct S##NAME##N s3, struct S##NAME##N s4,	\
+	       struct S##NAME##N s5, struct S##NAME##N s6,	\
+	       struct S##NAME##N s7, struct S##NAME##N s8,	\
+	       struct S##NAME##N s9, struct S##NAME##N s10,	\
+	       struct S##NAME##N s11, struct S##NAME##N s12,	\
+	       struct S##NAME##N s13, struct S##NAME##N s14,	\
+	       struct S##NAME##N s15, struct S##NAME##N s16);	\
+extern void testva##NAME##N (int n, ...);			\
+extern void							\
+test2_##NAME##N (struct S##NAME##N s1, struct S##NAME##N s2,	\
+		 struct S##NAME##N s3, struct S##NAME##N s4,	\
+		 struct S##NAME##N s5, struct S##NAME##N s6,	\
+		 struct S##NAME##N s7, struct S##NAME##N s8);	\
+								\
+void								\
+check##NAME##N (struct S##NAME##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    if (p->i[j] != (TYPE) (i + j))				\
+      DEBUG_CHECK						\
+}								\
+								\
+void								\
+test2_##NAME##N (struct S##NAME##N s1, struct S##NAME##N s2,	\
+		 struct S##NAME##N s3, struct S##NAME##N s4,	\
+		 struct S##NAME##N s5, struct S##NAME##N s6,	\
+		 struct S##NAME##N s7, struct S##NAME##N s8)	\
+{								\
+  test##NAME##N (s1, g2s##NAME##N, s2, g4s##NAME##N,		\
+		 s3, g6s##NAME##N, s4, g8s##NAME##N,		\
+		 s5, g10s##NAME##N, s6, g12s##NAME##N,		\
+		 s7, g14s##NAME##N, s8, g16s##NAME##N);		\
+}								\
+								\
+void								\
+testit##NAME##N (void)						\
+{								\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME##N  ( &g1s##NAME##N,  1*16);			\
+  init##NAME##N  ( &g2s##NAME##N,  2*16);			\
+  init##NAME##N  ( &g3s##NAME##N,  3*16);			\
+  init##NAME##N  ( &g4s##NAME##N,  4*16);			\
+  init##NAME##N  ( &g5s##NAME##N,  5*16);			\
+  init##NAME##N  ( &g6s##NAME##N,  6*16);			\
+  init##NAME##N  ( &g7s##NAME##N,  7*16);			\
+  init##NAME##N  ( &g8s##NAME##N,  8*16);			\
+  init##NAME##N  ( &g9s##NAME##N,  9*16);			\
+  init##NAME##N  (&g10s##NAME##N, 10*16);			\
+  init##NAME##N  (&g11s##NAME##N, 11*16);			\
+  init##NAME##N  (&g12s##NAME##N, 12*16);			\
+  init##NAME##N  (&g13s##NAME##N, 13*16);			\
+  init##NAME##N  (&g14s##NAME##N, 14*16);			\
+  init##NAME##N  (&g15s##NAME##N, 15*16);			\
+  init##NAME##N  (&g16s##NAME##N, 16*16);			\
+  checkg##NAME##N ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" test: ");					\
+  test##NAME##N (g1s##NAME##N, g2s##NAME##N,			\
+		 g3s##NAME##N, g4s##NAME##N,			\
+		 g5s##NAME##N, g6s##NAME##N,			\
+		 g7s##NAME##N, g8s##NAME##N,			\
+		 g9s##NAME##N, g10s##NAME##N,			\
+		 g11s##NAME##N, g12s##NAME##N,			\
+		 g13s##NAME##N, g14s##NAME##N,			\
+		 g15s##NAME##N, g16s##NAME##N);			\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" testva:");					\
+  testva##NAME##N (16,						\
+		   g1s##NAME##N, g2s##NAME##N,			\
+		   g3s##NAME##N, g4s##NAME##N,			\
+		   g5s##NAME##N, g6s##NAME##N,			\
+		   g7s##NAME##N, g8s##NAME##N,			\
+		   g9s##NAME##N, g10s##NAME##N,			\
+		   g11s##NAME##N, g12s##NAME##N,		\
+		   g13s##NAME##N, g14s##NAME##N,		\
+		   g15s##NAME##N, g16s##NAME##N);		\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##NAME##N (g1s##NAME##N, g3s##NAME##N,			\
+		   g5s##NAME##N, g7s##NAME##N,			\
+		   g9s##NAME##N, g11s##NAME##N,			\
+		   g13s##NAME##N, g15s##NAME##N);		\
+  DEBUG_NL;							\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, uc, unsigned char)
+#endif
+T(1, uc, unsigned char)
+T(2, uc, unsigned char)
+T(3, uc, unsigned char)
+T(4, uc, unsigned char)
+T(5, uc, unsigned char)
+T(6, uc, unsigned char)
+T(7, uc, unsigned char)
+T(8, uc, unsigned char)
+T(9, uc, unsigned char)
+T(10, uc, unsigned char)
+T(11, uc, unsigned char)
+T(12, uc, unsigned char)
+T(13, uc, unsigned char)
+T(14, uc, unsigned char)
+T(15, uc, unsigned char)
+#ifndef SKIP_ZERO_ARRAY
+T(0, us, unsigned short)
+#endif
+T(1, us, unsigned short)
+T(2, us, unsigned short)
+T(3, us, unsigned short)
+T(4, us, unsigned short)
+T(5, us, unsigned short)
+T(6, us, unsigned short)
+T(7, us, unsigned short)
+T(8, us, unsigned short)
+T(9, us, unsigned short)
+T(10, us, unsigned short)
+T(11, us, unsigned short)
+T(12, us, unsigned short)
+T(13, us, unsigned short)
+T(14, us, unsigned short)
+T(15, us, unsigned short)
+#ifndef SKIP_ZERO_ARRAY
+T(0, ui, unsigned int)
+#endif
+T(1, ui, unsigned int)
+T(2, ui, unsigned int)
+T(3, ui, unsigned int)
+T(4, ui, unsigned int)
+T(5, ui, unsigned int)
+T(6, ui, unsigned int)
+T(7, ui, unsigned int)
+T(8, ui, unsigned int)
+T(9, ui, unsigned int)
+T(10, ui, unsigned int)
+T(11, ui, unsigned int)
+T(12, ui, unsigned int)
+T(13, ui, unsigned int)
+T(14, ui, unsigned int)
+T(15, ui, unsigned int)
+
+#undef T
+
+void
+struct_by_value_2_x ()
+{
+DEBUG_INIT
+
+#define T(N, NAME, TYPE) testit##NAME##N ();
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, uc, unsigned char)
+#endif
+T(1, uc, unsigned char)
+T(2, uc, unsigned char)
+T(3, uc, unsigned char)
+T(4, uc, unsigned char)
+T(5, uc, unsigned char)
+T(6, uc, unsigned char)
+T(7, uc, unsigned char)
+T(8, uc, unsigned char)
+T(9, uc, unsigned char)
+T(10, uc, unsigned char)
+T(11, uc, unsigned char)
+T(12, uc, unsigned char)
+T(13, uc, unsigned char)
+T(14, uc, unsigned char)
+T(15, uc, unsigned char)
+#ifndef SKIP_ZERO_ARRAY
+T(0, us, unsigned short)
+#endif
+T(1, us, unsigned short)
+T(2, us, unsigned short)
+T(3, us, unsigned short)
+T(4, us, unsigned short)
+T(5, us, unsigned short)
+T(6, us, unsigned short)
+T(7, us, unsigned short)
+T(8, us, unsigned short)
+T(9, us, unsigned short)
+T(10, us, unsigned short)
+T(11, us, unsigned short)
+T(12, us, unsigned short)
+T(13, us, unsigned short)
+T(14, us, unsigned short)
+T(15, us, unsigned short)
+#ifndef SKIP_ZERO_ARRAY
+T(0, ui, unsigned int)
+#endif
+T(1, ui, unsigned int)
+T(2, ui, unsigned int)
+T(3, ui, unsigned int)
+T(4, ui, unsigned int)
+T(5, ui, unsigned int)
+T(6, ui, unsigned int)
+T(7, ui, unsigned int)
+T(8, ui, unsigned int)
+T(9, ui, unsigned int)
+T(10, ui, unsigned int)
+T(11, ui, unsigned int)
+T(12, ui, unsigned int)
+T(13, ui, unsigned int)
+T(14, ui, unsigned int)
+T(15, ui, unsigned int)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_y.c
new file mode 100644
index 000000000..3b203fab2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-2_y.c
@@ -0,0 +1,157 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(N, NAME, TYPE)					\
+struct S##NAME##N { TYPE i[N]; };				\
+								\
+extern struct S##NAME##N g1s##NAME##N, g2s##NAME##N;		\
+extern struct S##NAME##N g3s##NAME##N, g4s##NAME##N;		\
+extern struct S##NAME##N g5s##NAME##N, g6s##NAME##N;		\
+extern struct S##NAME##N g7s##NAME##N, g8s##NAME##N;		\
+extern struct S##NAME##N g9s##NAME##N, g10s##NAME##N;		\
+extern struct S##NAME##N g11s##NAME##N, g12s##NAME##N;		\
+extern struct S##NAME##N g13s##NAME##N, g14s##NAME##N;		\
+extern struct S##NAME##N g15s##NAME##N, g16s##NAME##N;		\
+								\
+extern void check##NAME##N (struct S##NAME##N *p, int i);	\
+extern void							\
+test2_##NAME##N (struct S##NAME##N s1, struct S##NAME##N s2,	\
+		 struct S##NAME##N s3, struct S##NAME##N s4,	\
+		 struct S##NAME##N s5, struct S##NAME##N s6,	\
+		 struct S##NAME##N s7, struct S##NAME##N s8);	\
+								\
+void								\
+init##NAME##N (struct S##NAME##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    p->i[j] = i + j;						\
+}								\
+								\
+void								\
+checkg##NAME##N (void)						\
+{								\
+  check##NAME##N ( &g1s##NAME##N,  1*16);			\
+  check##NAME##N ( &g2s##NAME##N,  2*16);			\
+  check##NAME##N ( &g3s##NAME##N,  3*16);			\
+  check##NAME##N ( &g4s##NAME##N,  4*16);			\
+  check##NAME##N ( &g5s##NAME##N,  5*16);			\
+  check##NAME##N ( &g6s##NAME##N,  6*16);			\
+  check##NAME##N ( &g7s##NAME##N,  7*16);			\
+  check##NAME##N ( &g8s##NAME##N,  8*16);			\
+  check##NAME##N ( &g9s##NAME##N,  9*16);			\
+  check##NAME##N (&g10s##NAME##N, 10*16);			\
+  check##NAME##N (&g11s##NAME##N, 11*16);			\
+  check##NAME##N (&g12s##NAME##N, 12*16);			\
+  check##NAME##N (&g13s##NAME##N, 13*16);			\
+  check##NAME##N (&g14s##NAME##N, 14*16);			\
+  check##NAME##N (&g15s##NAME##N, 15*16);			\
+  check##NAME##N (&g16s##NAME##N, 16*16);			\
+}								\
+								\
+void								\
+test##NAME##N (struct S##NAME##N s1, struct S##NAME##N s2,	\
+	       struct S##NAME##N s3, struct S##NAME##N s4,	\
+	       struct S##NAME##N s5, struct S##NAME##N s6,	\
+	       struct S##NAME##N s7, struct S##NAME##N s8,	\
+	       struct S##NAME##N s9, struct S##NAME##N s10,	\
+	       struct S##NAME##N s11, struct S##NAME##N s12,	\
+	       struct S##NAME##N s13, struct S##NAME##N s14,	\
+	       struct S##NAME##N s15, struct S##NAME##N s16)	\
+{								\
+  check##NAME##N (&s1, 1*16);					\
+  check##NAME##N (&s2, 2*16);					\
+  check##NAME##N (&s3, 3*16);					\
+  check##NAME##N (&s4, 4*16);					\
+  check##NAME##N (&s5, 5*16);					\
+  check##NAME##N (&s6, 6*16);					\
+  check##NAME##N (&s7, 7*16);					\
+  check##NAME##N (&s8, 8*16);					\
+  check##NAME##N (&s9, 9*16);					\
+  check##NAME##N (&s10, 10*16);					\
+  check##NAME##N (&s11, 11*16);					\
+  check##NAME##N (&s12, 12*16);					\
+  check##NAME##N (&s13, 13*16);					\
+  check##NAME##N (&s14, 14*16);					\
+  check##NAME##N (&s15, 15*16);					\
+  check##NAME##N (&s16, 16*16);					\
+}								\
+								\
+void								\
+testva##NAME##N (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  struct S##NAME##N t = va_arg (ap, struct S##NAME##N);	\
+	  check##NAME##N (&t, (i+1)*16);			\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, uc, unsigned char)
+#endif
+T(1, uc, unsigned char)
+T(2, uc, unsigned char)
+T(3, uc, unsigned char)
+T(4, uc, unsigned char)
+T(5, uc, unsigned char)
+T(6, uc, unsigned char)
+T(7, uc, unsigned char)
+T(8, uc, unsigned char)
+T(9, uc, unsigned char)
+T(10, uc, unsigned char)
+T(11, uc, unsigned char)
+T(12, uc, unsigned char)
+T(13, uc, unsigned char)
+T(14, uc, unsigned char)
+T(15, uc, unsigned char)
+#ifndef SKIP_ZERO_ARRAY
+T(0, us, unsigned short)
+#endif
+T(1, us, unsigned short)
+T(2, us, unsigned short)
+T(3, us, unsigned short)
+T(4, us, unsigned short)
+T(5, us, unsigned short)
+T(6, us, unsigned short)
+T(7, us, unsigned short)
+T(8, us, unsigned short)
+T(9, us, unsigned short)
+T(10, us, unsigned short)
+T(11, us, unsigned short)
+T(12, us, unsigned short)
+T(13, us, unsigned short)
+T(14, us, unsigned short)
+T(15, us, unsigned short)
+#ifndef SKIP_ZERO_ARRAY
+T(0, ui, unsigned int)
+#endif
+T(1, ui, unsigned int)
+T(2, ui, unsigned int)
+T(3, ui, unsigned int)
+T(4, ui, unsigned int)
+T(5, ui, unsigned int)
+T(6, ui, unsigned int)
+T(7, ui, unsigned int)
+T(8, ui, unsigned int)
+T(9, ui, unsigned int)
+T(10, ui, unsigned int)
+T(11, ui, unsigned int)
+T(12, ui, unsigned int)
+T(13, ui, unsigned int)
+T(14, ui, unsigned int)
+T(15, ui, unsigned int)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_main.c
new file mode 100644
index 000000000..0b7206895
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_main.c
@@ -0,0 +1,15 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.  All struct members are scalar
+   integral types, and the structs are "small": 1, 2, 4, 8, and 12
+   bytes for LP64.  */
+
+extern void struct_by_value_3_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_3_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_x.c
new file mode 100644
index 000000000..38e5b546a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_x.c
@@ -0,0 +1,190 @@
+#include "compat-common.h"
+
+#define T(TYPE)							\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  1);				\
+  init##TYPE  ( &g2s##TYPE,  2);				\
+  init##TYPE  ( &g3s##TYPE,  3);				\
+  init##TYPE  ( &g4s##TYPE,  4);				\
+  init##TYPE  ( &g5s##TYPE,  5);				\
+  init##TYPE  ( &g6s##TYPE,  6);				\
+  init##TYPE  ( &g7s##TYPE,  7);				\
+  init##TYPE  ( &g8s##TYPE,  8);				\
+  init##TYPE  ( &g9s##TYPE,  9);				\
+  init##TYPE  (&g10s##TYPE, 10);				\
+  init##TYPE  (&g11s##TYPE, 11);				\
+  init##TYPE  (&g12s##TYPE, 12);				\
+  init##TYPE  (&g13s##TYPE, 13);				\
+  init##TYPE  (&g14s##TYPE, 14);				\
+  init##TYPE  (&g15s##TYPE, 15);				\
+  init##TYPE  (&g16s##TYPE, 16);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2:");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
+
+#include "small-struct-defs.h"
+#include "small-struct-check.h"
+
+T(Sc)
+T(Ss)
+T(Si)
+T(Scs)
+T(Ssc)
+T(Sic)
+T(Sci)
+T(Ssi)
+T(Sis)
+T(Scsi)
+T(Scis)
+T(Ssci)
+T(Ssic)
+T(Sisc)
+T(Sics)
+
+#undef T
+
+void
+struct_by_value_3_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Sc)
+T(Ss)
+T(Si)
+T(Scs)
+T(Ssc)
+T(Sic)
+T(Sci)
+T(Ssi)
+T(Sis)
+T(Scsi)
+T(Scis)
+T(Ssci)
+T(Ssic)
+T(Sisc)
+T(Sics)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_y.c
new file mode 100644
index 000000000..d5a31c9d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-3_y.c
@@ -0,0 +1,113 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "small-struct-defs.h"
+
+extern void checkSc (Sc x, int i);
+extern void checkSs (Ss x, int i);
+extern void checkSi (Si x, int i);
+extern void checkSsc (Ssc x, int i);
+extern void checkScs (Scs x, int i);
+extern void checkSsi (Ssi x, int i);
+extern void checkSis (Sis x, int i);
+extern void checkSic (Sic x, int i);
+extern void checkSci (Sci x, int i);
+extern void checkScsi (Scsi x, int i);
+extern void checkScis (Scis x, int i);
+extern void checkSsci (Ssci x, int i);
+extern void checkSsic (Ssic x, int i);
+extern void checkSisc (Sisc x, int i);
+extern void checkSics (Sics x, int i);
+
+#include "small-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  1);				\
+  check##TYPE (  g2s##TYPE,  2);				\
+  check##TYPE (  g3s##TYPE,  3);				\
+  check##TYPE (  g4s##TYPE,  4);				\
+  check##TYPE (  g5s##TYPE,  5);				\
+  check##TYPE (  g6s##TYPE,  6);				\
+  check##TYPE (  g7s##TYPE,  7);				\
+  check##TYPE (  g8s##TYPE,  8);				\
+  check##TYPE (  g9s##TYPE,  9);				\
+  check##TYPE ( g10s##TYPE, 10);				\
+  check##TYPE ( g11s##TYPE, 11);				\
+  check##TYPE ( g12s##TYPE, 12);				\
+  check##TYPE ( g13s##TYPE, 13);				\
+  check##TYPE ( g14s##TYPE, 14);				\
+  check##TYPE ( g15s##TYPE, 15);				\
+  check##TYPE ( g16s##TYPE, 16);				\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, 1);						\
+  check##TYPE (s2, 2);						\
+  check##TYPE (s3, 3);						\
+  check##TYPE (s4, 4);						\
+  check##TYPE (s5, 5);						\
+  check##TYPE (s6, 6);						\
+  check##TYPE (s7, 7);						\
+  check##TYPE (s8, 8);						\
+  check##TYPE (s9, 9);						\
+  check##TYPE (s10, 10);					\
+  check##TYPE (s11, 11);					\
+  check##TYPE (s12, 12);					\
+  check##TYPE (s13, 13);					\
+  check##TYPE (s14, 14);					\
+  check##TYPE (s15, 15);					\
+  check##TYPE (s16, 16);					\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(Sc)
+T(Ss)
+T(Si)
+T(Ssc)
+T(Scs)
+T(Sic)
+T(Sci)
+T(Ssi)
+T(Sis)
+T(Scsi)
+T(Scis)
+T(Ssci)
+T(Ssic)
+T(Sisc)
+T(Sics)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_main.c
new file mode 100644
index 000000000..570eddc5d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.  Each struct contains an array
+   of small structs with a single member.  */
+
+extern void struct_by_value_4_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_4_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_x.c
new file mode 100644
index 000000000..def20ce8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_x.c
@@ -0,0 +1,257 @@
+#include "compat-common.h"
+
+#define T(N, TYPE)						\
+struct S##TYPE##N { TYPE i[N]; };				\
+								\
+struct S##TYPE##N g1s##TYPE##N, g2s##TYPE##N;			\
+struct S##TYPE##N g3s##TYPE##N, g4s##TYPE##N;			\
+struct S##TYPE##N g5s##TYPE##N, g6s##TYPE##N;			\
+struct S##TYPE##N g7s##TYPE##N, g8s##TYPE##N;			\
+struct S##TYPE##N g9s##TYPE##N, g10s##TYPE##N;			\
+struct S##TYPE##N g11s##TYPE##N, g12s##TYPE##N;			\
+struct S##TYPE##N g13s##TYPE##N, g14s##TYPE##N;			\
+struct S##TYPE##N g15s##TYPE##N, g16s##TYPE##N;			\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE##N (void);				\
+extern void							\
+test##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+	       struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+	       struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+	       struct S##TYPE##N s7, struct S##TYPE##N s8,	\
+	       struct S##TYPE##N s9, struct S##TYPE##N s10,	\
+	       struct S##TYPE##N s11, struct S##TYPE##N s12,	\
+	       struct S##TYPE##N s13, struct S##TYPE##N s14,	\
+	       struct S##TYPE##N s15, struct S##TYPE##N s16);	\
+extern void testva##TYPE##N (int n, ...);			\
+								\
+								\
+void								\
+init##TYPE##N (struct S##TYPE##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    init##TYPE(&p->i[j], i+j);					\
+}								\
+								\
+void								\
+check##TYPE##N (struct S##TYPE##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    check##TYPE(p->i[j], i+j);					\
+}								\
+								\
+void								\
+test2_##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+		 struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+		 struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+		 struct S##TYPE##N s7, struct S##TYPE##N s8)	\
+{								\
+  test##TYPE##N (s1, g2s##TYPE##N, s2, g4s##TYPE##N,		\
+		 s3, g6s##TYPE##N, s4, g8s##TYPE##N,		\
+		 s5, g10s##TYPE##N, s6, g12s##TYPE##N,		\
+		 s7, g14s##TYPE##N, s8, g16s##TYPE##N);		\
+}								\
+								\
+void								\
+testit##TYPE##N (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE##N  ( &g1s##TYPE##N,  1*16);			\
+  init##TYPE##N  ( &g2s##TYPE##N,  2*16);			\
+  init##TYPE##N  ( &g3s##TYPE##N,  3*16);			\
+  init##TYPE##N  ( &g4s##TYPE##N,  4*16);			\
+  init##TYPE##N  ( &g5s##TYPE##N,  5*16);			\
+  init##TYPE##N  ( &g6s##TYPE##N,  6*16);			\
+  init##TYPE##N  ( &g7s##TYPE##N,  7*16);			\
+  init##TYPE##N  ( &g8s##TYPE##N,  8*16);			\
+  init##TYPE##N  ( &g9s##TYPE##N,  9*16);			\
+  init##TYPE##N  (&g10s##TYPE##N, 10*16);			\
+  init##TYPE##N  (&g11s##TYPE##N, 11*16);			\
+  init##TYPE##N  (&g12s##TYPE##N, 12*16);			\
+  init##TYPE##N  (&g13s##TYPE##N, 13*16);			\
+  init##TYPE##N  (&g14s##TYPE##N, 14*16);			\
+  init##TYPE##N  (&g15s##TYPE##N, 15*16);			\
+  init##TYPE##N  (&g16s##TYPE##N, 16*16);			\
+  checkg##TYPE##N ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE##N (g1s##TYPE##N, g2s##TYPE##N,			\
+		 g3s##TYPE##N, g4s##TYPE##N,			\
+		 g5s##TYPE##N, g6s##TYPE##N,			\
+		 g7s##TYPE##N, g8s##TYPE##N,			\
+		 g9s##TYPE##N, g10s##TYPE##N,			\
+		 g11s##TYPE##N, g12s##TYPE##N,			\
+		 g13s##TYPE##N, g14s##TYPE##N,			\
+		 g15s##TYPE##N, g16s##TYPE##N);			\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" testva:");					\
+  testva##TYPE##N (16,						\
+		   g1s##TYPE##N, g2s##TYPE##N,			\
+		   g3s##TYPE##N, g4s##TYPE##N,			\
+		   g5s##TYPE##N, g6s##TYPE##N,			\
+		   g7s##TYPE##N, g8s##TYPE##N,			\
+		   g9s##TYPE##N, g10s##TYPE##N,			\
+		   g11s##TYPE##N, g12s##TYPE##N,		\
+		   g13s##TYPE##N, g14s##TYPE##N,		\
+		   g15s##TYPE##N, g16s##TYPE##N);		\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##TYPE##N (g1s##TYPE##N, g3s##TYPE##N,			\
+		   g5s##TYPE##N, g7s##TYPE##N,			\
+		   g9s##TYPE##N, g11s##TYPE##N,			\
+		   g13s##TYPE##N, g15s##TYPE##N);		\
+  DEBUG_NL;							\
+}
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+
+void checkSc (Sc x, int i) { if (x.c != i/16) DEBUG_CHECK }
+void checkSs (Ss x, int i) { if (x.s != i) DEBUG_CHECK }
+void checkSi (Si x, int i) { if (x.i != i) DEBUG_CHECK }
+void checkSsc (Ssc x, int i)
+{ if (x.s != i || x.c != (i/16)+1) DEBUG_CHECK }
+void checkSis (Sis x, int i)
+{ if (x.i != i || x.s != i+1) DEBUG_CHECK }
+void checkScsi (Scsi x, int i)
+{ if (x.c != i/16 || x.s != i+1 || x.i != i+2) DEBUG_CHECK }
+void checkScis (Scis x, int i)
+{ if (x.c != i/16 || x.i != i+1 || x.s != i+2) DEBUG_CHECK }
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Sc)
+#endif
+T(1, Sc)
+T(2, Sc)
+T(3, Sc)
+T(4, Sc)
+T(5, Sc)
+T(6, Sc)
+T(7, Sc)
+T(8, Sc)
+T(9, Sc)
+T(10, Sc)
+T(11, Sc)
+T(12, Sc)
+T(13, Sc)
+T(14, Sc)
+T(15, Sc)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Ss)
+#endif
+T(1, Ss)
+T(2, Ss)
+T(3, Ss)
+T(4, Ss)
+T(5, Ss)
+T(6, Ss)
+T(7, Ss)
+T(8, Ss)
+T(9, Ss)
+T(10, Ss)
+T(11, Ss)
+T(12, Ss)
+T(13, Ss)
+T(14, Ss)
+T(15, Ss)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Si)
+#endif
+T(1, Si)
+T(2, Si)
+T(3, Si)
+T(4, Si)
+T(5, Si)
+T(6, Si)
+T(7, Si)
+T(8, Si)
+T(9, Si)
+T(10, Si)
+T(11, Si)
+T(12, Si)
+T(13, Si)
+T(14, Si)
+T(15, Si)
+
+#undef T
+
+void
+struct_by_value_4_x ()
+{
+DEBUG_INIT
+
+#define T(N, TYPE) testit##TYPE##N ();
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Sc)
+#endif
+T(1, Sc)
+T(2, Sc)
+T(3, Sc)
+T(4, Sc)
+T(5, Sc)
+T(6, Sc)
+T(7, Sc)
+T(8, Sc)
+T(9, Sc)
+T(10, Sc)
+T(11, Sc)
+T(12, Sc)
+T(13, Sc)
+T(14, Sc)
+T(15, Sc)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Ss)
+#endif
+T(1, Ss)
+T(2, Ss)
+T(3, Ss)
+T(4, Ss)
+T(5, Ss)
+T(6, Ss)
+T(7, Ss)
+T(8, Ss)
+T(9, Ss)
+T(10, Ss)
+T(11, Ss)
+T(12, Ss)
+T(13, Ss)
+T(14, Ss)
+T(15, Ss)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Si)
+#endif
+T(1, Si)
+T(2, Si)
+T(3, Si)
+T(4, Si)
+T(5, Si)
+T(6, Si)
+T(7, Si)
+T(8, Si)
+T(9, Si)
+T(10, Si)
+T(11, Si)
+T(12, Si)
+T(13, Si)
+T(14, Si)
+T(15, Si)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_y.c
new file mode 100644
index 000000000..fe1b09577
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-4_y.c
@@ -0,0 +1,162 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+
+void initSc (Sc *p, int i) { p->c = i/16; }
+void initSs (Ss *p, int i) { p->s = i; }
+void initSi (Si *p, int i) { p->i = i; }
+void initSsc (Ssc *p, int i) { p->s = i; p->c = (i/16)+1; }
+void initSis (Sis *p, int i) { p->i = i; p->s = i+1; }
+void initScsi (Scsi *p, int i) { p->c = i/16; p->s = i+1; p->i = i+2; }
+void initScis (Scis *p, int i) { p->c = i/16; p->i = i+1; p->s = i+2; }
+
+#define T(N, TYPE)						\
+struct S##TYPE##N { TYPE i[N]; };				\
+								\
+extern struct S##TYPE##N g1s##TYPE##N, g2s##TYPE##N;		\
+extern struct S##TYPE##N g3s##TYPE##N, g4s##TYPE##N;		\
+extern struct S##TYPE##N g5s##TYPE##N, g6s##TYPE##N;		\
+extern struct S##TYPE##N g7s##TYPE##N, g8s##TYPE##N;		\
+extern struct S##TYPE##N g9s##TYPE##N, g10s##TYPE##N;		\
+extern struct S##TYPE##N g11s##TYPE##N, g12s##TYPE##N;		\
+extern struct S##TYPE##N g13s##TYPE##N, g14s##TYPE##N;		\
+extern struct S##TYPE##N g15s##TYPE##N, g16s##TYPE##N;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+extern void							\
+check##TYPE##N (struct S##TYPE##N *p, int i);			\
+								\
+void								\
+checkg##TYPE##N (void)						\
+{								\
+  check##TYPE##N ( &g1s##TYPE##N,  1*16);			\
+  check##TYPE##N ( &g2s##TYPE##N,  2*16);			\
+  check##TYPE##N ( &g3s##TYPE##N,  3*16);			\
+  check##TYPE##N ( &g4s##TYPE##N,  4*16);			\
+  check##TYPE##N ( &g5s##TYPE##N,  5*16);			\
+  check##TYPE##N ( &g6s##TYPE##N,  6*16);			\
+  check##TYPE##N ( &g7s##TYPE##N,  7*16);			\
+  check##TYPE##N ( &g8s##TYPE##N,  8*16);			\
+  check##TYPE##N ( &g9s##TYPE##N,  9*16);			\
+  check##TYPE##N (&g10s##TYPE##N, 10*16);			\
+  check##TYPE##N (&g11s##TYPE##N, 11*16);			\
+  check##TYPE##N (&g12s##TYPE##N, 12*16);			\
+  check##TYPE##N (&g13s##TYPE##N, 13*16);			\
+  check##TYPE##N (&g14s##TYPE##N, 14*16);			\
+  check##TYPE##N (&g15s##TYPE##N, 15*16);			\
+  check##TYPE##N (&g16s##TYPE##N, 16*16);			\
+}								\
+								\
+void								\
+test##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+	       struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+	       struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+	       struct S##TYPE##N s7, struct S##TYPE##N s8,	\
+	       struct S##TYPE##N s9, struct S##TYPE##N s10,	\
+	       struct S##TYPE##N s11, struct S##TYPE##N s12,	\
+	       struct S##TYPE##N s13, struct S##TYPE##N s14,	\
+	       struct S##TYPE##N s15, struct S##TYPE##N s16)	\
+{								\
+  check##TYPE##N (&s1, 1*16);					\
+  check##TYPE##N (&s2, 2*16);					\
+  check##TYPE##N (&s3, 3*16);					\
+  check##TYPE##N (&s4, 4*16);					\
+  check##TYPE##N (&s5, 5*16);					\
+  check##TYPE##N (&s6, 6*16);					\
+  check##TYPE##N (&s7, 7*16);					\
+  check##TYPE##N (&s8, 8*16);					\
+  check##TYPE##N (&s9, 9*16);					\
+  check##TYPE##N (&s10, 10*16);					\
+  check##TYPE##N (&s11, 11*16);					\
+  check##TYPE##N (&s12, 12*16);					\
+  check##TYPE##N (&s13, 13*16);					\
+  check##TYPE##N (&s14, 14*16);					\
+  check##TYPE##N (&s15, 15*16);					\
+  check##TYPE##N (&s16, 16*16);					\
+}								\
+								\
+void								\
+testva##TYPE##N (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  struct S##TYPE##N t = va_arg (ap, struct S##TYPE##N);	\
+	  check##TYPE##N (&t, (i+1)*16);			\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Sc)
+#endif
+T(1, Sc)
+T(2, Sc)
+T(3, Sc)
+T(4, Sc)
+T(5, Sc)
+T(6, Sc)
+T(7, Sc)
+T(8, Sc)
+T(9, Sc)
+T(10, Sc)
+T(11, Sc)
+T(12, Sc)
+T(13, Sc)
+T(14, Sc)
+T(15, Sc)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Ss)
+#endif
+T(1, Ss)
+T(2, Ss)
+T(3, Ss)
+T(4, Ss)
+T(5, Ss)
+T(6, Ss)
+T(7, Ss)
+T(8, Ss)
+T(9, Ss)
+T(10, Ss)
+T(11, Ss)
+T(12, Ss)
+T(13, Ss)
+T(14, Ss)
+T(15, Ss)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Si)
+#endif
+T(1, Si)
+T(2, Si)
+T(3, Si)
+T(4, Si)
+T(5, Si)
+T(6, Si)
+T(7, Si)
+T(8, Si)
+T(9, Si)
+T(10, Si)
+T(11, Si)
+T(12, Si)
+T(13, Si)
+T(14, Si)
+T(15, Si)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_main.c
new file mode 100644
index 000000000..d6f9eff25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are float
+   scalars.  */
+
+extern void struct_by_value_5a_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_5a_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_x.c
new file mode 100644
index 000000000..90738a7a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_x.c
@@ -0,0 +1,43 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+DEFS(f, float)
+CHECKS(f, float)
+
+TEST(Sf1, float)
+TEST(Sf2, float)
+TEST(Sf3, float)
+TEST(Sf4, float)
+TEST(Sf5, float)
+TEST(Sf6, float)
+TEST(Sf7, float)
+TEST(Sf8, float)
+
+#undef T
+
+void
+struct_by_value_5a_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sf1, float)
+T(Sf2, float)
+T(Sf3, float)
+T(Sf4, float)
+T(Sf5, float)
+T(Sf6, float)
+T(Sf7, float)
+T(Sf8, float)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_y.c
new file mode 100644
index 000000000..9ac1f9134
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5a_y.c
@@ -0,0 +1,25 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+DEFS(f,float)
+INITS(f, float)
+
+TEST(Sf1, float)
+TEST(Sf2, float)
+TEST(Sf3, float)
+TEST(Sf4, float)
+TEST(Sf5, float)
+TEST(Sf6, float)
+TEST(Sf7, float)
+TEST(Sf8, float)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_main.c
new file mode 100644
index 000000000..dcb5f27ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are float
+   scalars.  */
+
+extern void struct_by_value_5b_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_5b_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_x.c
new file mode 100644
index 000000000..3c3715587
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_x.c
@@ -0,0 +1,43 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+DEFS(f, float)
+CHECKS(f, float)
+
+TEST(Sf9, float)
+TEST(Sf10, float)
+TEST(Sf11, float)
+TEST(Sf12, float)
+TEST(Sf13, float)
+TEST(Sf14, float)
+TEST(Sf15, float)
+TEST(Sf16, float)
+
+#undef T
+
+void
+struct_by_value_5b_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sf9, float)
+T(Sf10, float)
+T(Sf11, float)
+T(Sf12, float)
+T(Sf13, float)
+T(Sf14, float)
+T(Sf15, float)
+T(Sf16, float)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_y.c
new file mode 100644
index 000000000..cedc16607
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_y.c
@@ -0,0 +1,25 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+DEFS(f,float)
+INITS(f, float)
+
+TEST(Sf9, float)
+TEST(Sf10, float)
+TEST(Sf11, float)
+TEST(Sf12, float)
+TEST(Sf13, float)
+TEST(Sf14, float)
+TEST(Sf15, float)
+TEST(Sf16, float)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_main.c
new file mode 100644
index 000000000..609c1d673
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are double
+   scalars.  */
+
+extern void struct_by_value_6a_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_6a_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_x.c
new file mode 100644
index 000000000..e6852d9c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_x.c
@@ -0,0 +1,43 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+DEFS(d, double)
+CHECKS(d, double)
+
+TEST(Sd1, double)
+TEST(Sd2, double)
+TEST(Sd3, double)
+TEST(Sd4, double)
+TEST(Sd5, double)
+TEST(Sd6, double)
+TEST(Sd7, double)
+TEST(Sd8, double)
+
+#undef T
+
+void
+struct_by_value_6a_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sd1, double)
+T(Sd2, double)
+T(Sd3, double)
+T(Sd4, double)
+T(Sd5, double)
+T(Sd6, double)
+T(Sd7, double)
+T(Sd8, double)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_y.c
new file mode 100644
index 000000000..8684b53c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6a_y.c
@@ -0,0 +1,25 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+DEFS(d, double)
+INITS(d, double)
+
+TEST(Sd1, double)
+TEST(Sd2, double)
+TEST(Sd3, double)
+TEST(Sd4, double)
+TEST(Sd5, double)
+TEST(Sd6, double)
+TEST(Sd7, double)
+TEST(Sd8, double)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_main.c
new file mode 100644
index 000000000..ff1722171
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are double
+   scalars.  */
+
+extern void struct_by_value_6b_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_6b_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_x.c
new file mode 100644
index 000000000..5b285c9c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_x.c
@@ -0,0 +1,43 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+DEFS(d, double)
+CHECKS(d, double)
+
+TEST(Sd9, double)
+TEST(Sd10, double)
+TEST(Sd11, double)
+TEST(Sd12, double)
+TEST(Sd13, double)
+TEST(Sd14, double)
+TEST(Sd15, double)
+TEST(Sd16, double)
+
+#undef T
+
+void
+struct_by_value_6b_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sd9, double)
+T(Sd10, double)
+T(Sd11, double)
+T(Sd12, double)
+T(Sd13, double)
+T(Sd14, double)
+T(Sd15, double)
+T(Sd16, double)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_y.c
new file mode 100644
index 000000000..c568761b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-6b_y.c
@@ -0,0 +1,25 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+DEFS(d, double)
+INITS(d, double)
+
+TEST(Sd9, double)
+TEST(Sd10, double)
+TEST(Sd11, double)
+TEST(Sd12, double)
+TEST(Sd13, double)
+TEST(Sd14, double)
+TEST(Sd15, double)
+TEST(Sd16, double)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_main.c
new file mode 100644
index 000000000..8379dc563
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are long double
+   scalars.  */
+
+extern void struct_by_value_7a_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_7a_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_x.c
new file mode 100644
index 000000000..9818c3c22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_x.c
@@ -0,0 +1,43 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+DEFS(ld, long double)
+CHECKS(ld, long double)
+
+TEST(Sld1, long double)
+TEST(Sld2, long double)
+TEST(Sld3, long double)
+TEST(Sld4, long double)
+TEST(Sld5, long double)
+TEST(Sld6, long double)
+TEST(Sld7, long double)
+TEST(Sld8, long double)
+
+#undef T
+
+void
+struct_by_value_7a_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sld1, long double)
+T(Sld2, long double)
+T(Sld3, long double)
+T(Sld4, long double)
+T(Sld5, long double)
+T(Sld6, long double)
+T(Sld7, long double)
+T(Sld8, long double)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_y.c
new file mode 100644
index 000000000..cb53df89d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7a_y.c
@@ -0,0 +1,25 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+DEFS(ld, long double)
+INITS(ld, long double)
+
+TEST(Sld1, long double)
+TEST(Sld2, long double)
+TEST(Sld3, long double)
+TEST(Sld4, long double)
+TEST(Sld5, long double)
+TEST(Sld6, long double)
+TEST(Sld7, long double)
+TEST(Sld8, long double)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_main.c
new file mode 100644
index 000000000..5d6908bfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument lists.  All struct members are long double
+   scalars.  */
+
+extern void struct_by_value_7b_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_7b_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_x.c
new file mode 100644
index 000000000..508ff6165
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_x.c
@@ -0,0 +1,43 @@
+#include "compat-common.h"
+
+#include "fp-struct-defs.h"
+#include "fp-struct-check.h"
+#include "fp-struct-test-by-value-x.h"
+
+DEFS(ld, long double)
+CHECKS(ld, long double)
+
+TEST(Sld9, long double)
+TEST(Sld10, long double)
+TEST(Sld11, long double)
+TEST(Sld12, long double)
+TEST(Sld13, long double)
+TEST(Sld14, long double)
+TEST(Sld15, long double)
+TEST(Sld16, long double)
+
+#undef T
+
+void
+struct_by_value_7b_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE, MTYPE) testit##TYPE ();
+
+T(Sld9, long double)
+T(Sld10, long double)
+T(Sld11, long double)
+T(Sld12, long double)
+T(Sld13, long double)
+T(Sld14, long double)
+T(Sld15, long double)
+T(Sld16, long double)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_y.c
new file mode 100644
index 000000000..cc70a7d29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-7b_y.c
@@ -0,0 +1,25 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "fp-struct-defs.h"
+#include "fp-struct-init.h"
+#include "fp-struct-test-by-value-y.h"
+
+DEFS(ld, long double)
+INITS(ld, long double)
+
+TEST(Sld9, long double)
+TEST(Sld10, long double)
+TEST(Sld11, long double)
+TEST(Sld12, long double)
+TEST(Sld13, long double)
+TEST(Sld14, long double)
+TEST(Sld15, long double)
+TEST(Sld16, long double)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_main.c
new file mode 100644
index 000000000..cc094fcc9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.  Each struct contains an array
+   of small structs with two scalar members.  */
+
+extern void struct_by_value_8_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_8_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_x.c
new file mode 100644
index 000000000..5a376fd38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_x.c
@@ -0,0 +1,221 @@
+#include "compat-common.h"
+
+#define T(N, TYPE)						\
+struct S##TYPE##N { TYPE i[N]; };				\
+								\
+struct S##TYPE##N g1s##TYPE##N, g2s##TYPE##N;			\
+struct S##TYPE##N g3s##TYPE##N, g4s##TYPE##N;			\
+struct S##TYPE##N g5s##TYPE##N, g6s##TYPE##N;			\
+struct S##TYPE##N g7s##TYPE##N, g8s##TYPE##N;			\
+struct S##TYPE##N g9s##TYPE##N, g10s##TYPE##N;			\
+struct S##TYPE##N g11s##TYPE##N, g12s##TYPE##N;			\
+struct S##TYPE##N g13s##TYPE##N, g14s##TYPE##N;			\
+struct S##TYPE##N g15s##TYPE##N, g16s##TYPE##N;			\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE##N (void);				\
+extern void							\
+test##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+	       struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+	       struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+	       struct S##TYPE##N s7, struct S##TYPE##N s8,	\
+	       struct S##TYPE##N s9, struct S##TYPE##N s10,	\
+	       struct S##TYPE##N s11, struct S##TYPE##N s12,	\
+	       struct S##TYPE##N s13, struct S##TYPE##N s14,	\
+	       struct S##TYPE##N s15, struct S##TYPE##N s16);	\
+extern void testva##TYPE##N (int n, ...);			\
+								\
+								\
+void								\
+init##TYPE##N (struct S##TYPE##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    init##TYPE(&p->i[j], i+j);					\
+}								\
+								\
+void								\
+check##TYPE##N (struct S##TYPE##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    check##TYPE(p->i[j], i+j);					\
+}								\
+								\
+void								\
+test2_##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+		 struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+		 struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+		 struct S##TYPE##N s7, struct S##TYPE##N s8)	\
+{								\
+  test##TYPE##N (s1, g2s##TYPE##N, s2, g4s##TYPE##N,		\
+		 s3, g6s##TYPE##N, s4, g8s##TYPE##N,		\
+		 s5, g10s##TYPE##N, s6, g12s##TYPE##N,		\
+		 s7, g14s##TYPE##N, s8, g16s##TYPE##N);		\
+}								\
+								\
+void								\
+testit##TYPE##N (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE##N  ( &g1s##TYPE##N,  1*16);			\
+  init##TYPE##N  ( &g2s##TYPE##N,  2*16);			\
+  init##TYPE##N  ( &g3s##TYPE##N,  3*16);			\
+  init##TYPE##N  ( &g4s##TYPE##N,  4*16);			\
+  init##TYPE##N  ( &g5s##TYPE##N,  5*16);			\
+  init##TYPE##N  ( &g6s##TYPE##N,  6*16);			\
+  init##TYPE##N  ( &g7s##TYPE##N,  7*16);			\
+  init##TYPE##N  ( &g8s##TYPE##N,  8*16);			\
+  init##TYPE##N  ( &g9s##TYPE##N,  9*16);			\
+  init##TYPE##N  (&g10s##TYPE##N, 10*16);			\
+  init##TYPE##N  (&g11s##TYPE##N, 11*16);			\
+  init##TYPE##N  (&g12s##TYPE##N, 12*16);			\
+  init##TYPE##N  (&g13s##TYPE##N, 13*16);			\
+  init##TYPE##N  (&g14s##TYPE##N, 14*16);			\
+  init##TYPE##N  (&g15s##TYPE##N, 15*16);			\
+  init##TYPE##N  (&g16s##TYPE##N, 16*16);			\
+  checkg##TYPE##N ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE##N (g1s##TYPE##N, g2s##TYPE##N,			\
+		 g3s##TYPE##N, g4s##TYPE##N,			\
+		 g5s##TYPE##N, g6s##TYPE##N,			\
+		 g7s##TYPE##N, g8s##TYPE##N,			\
+		 g9s##TYPE##N, g10s##TYPE##N,			\
+		 g11s##TYPE##N, g12s##TYPE##N,			\
+		 g13s##TYPE##N, g14s##TYPE##N,			\
+		 g15s##TYPE##N, g16s##TYPE##N);			\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" testva:");					\
+  testva##TYPE##N (16,						\
+		   g1s##TYPE##N, g2s##TYPE##N,			\
+		   g3s##TYPE##N, g4s##TYPE##N,			\
+		   g5s##TYPE##N, g6s##TYPE##N,			\
+		   g7s##TYPE##N, g8s##TYPE##N,			\
+		   g9s##TYPE##N, g10s##TYPE##N,			\
+		   g11s##TYPE##N, g12s##TYPE##N,		\
+		   g13s##TYPE##N, g14s##TYPE##N,		\
+		   g15s##TYPE##N, g16s##TYPE##N);		\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##TYPE##N (g1s##TYPE##N, g3s##TYPE##N,			\
+		   g5s##TYPE##N, g7s##TYPE##N,			\
+		   g9s##TYPE##N, g11s##TYPE##N,			\
+		   g13s##TYPE##N, g15s##TYPE##N);		\
+  DEBUG_NL;							\
+}
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+
+void checkSc (Sc x, int i) { if (x.c != i/16) DEBUG_CHECK }
+void checkSs (Ss x, int i) { if (x.s != i) DEBUG_CHECK }
+void checkSi (Si x, int i) { if (x.i != i) DEBUG_CHECK }
+void checkSsc (Ssc x, int i)
+{ if (x.s != i || x.c != (i/16)+1) DEBUG_CHECK }
+void checkSis (Sis x, int i)
+{ if (x.i != i || x.s != i+1) DEBUG_CHECK }
+void checkScsi (Scsi x, int i)
+{ if (x.c != i/16 || x.s != i+1 || x.i != i+2) DEBUG_CHECK }
+void checkScis (Scis x, int i)
+{ if (x.c != i/16 || x.i != i+1 || x.s != i+2) DEBUG_CHECK }
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Ssc)
+#endif
+T(1, Ssc)
+T(2, Ssc)
+T(3, Ssc)
+T(4, Ssc)
+T(5, Ssc)
+T(6, Ssc)
+T(7, Ssc)
+T(8, Ssc)
+T(9, Ssc)
+T(10, Ssc)
+T(11, Ssc)
+T(12, Ssc)
+T(13, Ssc)
+T(14, Ssc)
+T(15, Ssc)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Sis)
+#endif
+T(1, Sis)
+T(2, Sis)
+T(3, Sis)
+T(4, Sis)
+T(5, Sis)
+T(6, Sis)
+T(7, Sis)
+T(8, Sis)
+T(9, Sis)
+T(10, Sis)
+T(11, Sis)
+T(12, Sis)
+T(13, Sis)
+T(14, Sis)
+T(15, Sis)
+
+#undef T
+
+void
+struct_by_value_8_x ()
+{
+DEBUG_INIT
+
+#define T(N, TYPE) testit##TYPE##N ();
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Ssc)
+#endif
+T(1, Ssc)
+T(2, Ssc)
+T(3, Ssc)
+T(4, Ssc)
+T(5, Ssc)
+T(6, Ssc)
+T(7, Ssc)
+T(8, Ssc)
+T(9, Ssc)
+T(10, Ssc)
+T(11, Ssc)
+T(12, Ssc)
+T(13, Ssc)
+T(14, Ssc)
+T(15, Ssc)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Sis)
+#endif
+T(1, Sis)
+T(2, Sis)
+T(3, Sis)
+T(4, Sis)
+T(5, Sis)
+T(6, Sis)
+T(7, Sis)
+T(8, Sis)
+T(9, Sis)
+T(10, Sis)
+T(11, Sis)
+T(12, Sis)
+T(13, Sis)
+T(14, Sis)
+T(15, Sis)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_y.c
new file mode 100644
index 000000000..b246fd448
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-8_y.c
@@ -0,0 +1,144 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+
+void initSc (Sc *p, int i) { p->c = i/16; }
+void initSs (Ss *p, int i) { p->s = i; }
+void initSi (Si *p, int i) { p->i = i; }
+void initSsc (Ssc *p, int i) { p->s = i; p->c = (i/16)+1; }
+void initSis (Sis *p, int i) { p->i = i; p->s = i+1; }
+void initScsi (Scsi *p, int i) { p->c = i/16; p->s = i+1; p->i = i+2; }
+void initScis (Scis *p, int i) { p->c = i/16; p->i = i+1; p->s = i+2; }
+
+#define T(N, TYPE)						\
+struct S##TYPE##N { TYPE i[N]; };				\
+								\
+extern struct S##TYPE##N g1s##TYPE##N, g2s##TYPE##N;		\
+extern struct S##TYPE##N g3s##TYPE##N, g4s##TYPE##N;		\
+extern struct S##TYPE##N g5s##TYPE##N, g6s##TYPE##N;		\
+extern struct S##TYPE##N g7s##TYPE##N, g8s##TYPE##N;		\
+extern struct S##TYPE##N g9s##TYPE##N, g10s##TYPE##N;		\
+extern struct S##TYPE##N g11s##TYPE##N, g12s##TYPE##N;		\
+extern struct S##TYPE##N g13s##TYPE##N, g14s##TYPE##N;		\
+extern struct S##TYPE##N g15s##TYPE##N, g16s##TYPE##N;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+extern void							\
+check##TYPE##N (struct S##TYPE##N *p, int i);			\
+								\
+void								\
+checkg##TYPE##N (void)						\
+{								\
+  check##TYPE##N ( &g1s##TYPE##N,  1*16);			\
+  check##TYPE##N ( &g2s##TYPE##N,  2*16);			\
+  check##TYPE##N ( &g3s##TYPE##N,  3*16);			\
+  check##TYPE##N ( &g4s##TYPE##N,  4*16);			\
+  check##TYPE##N ( &g5s##TYPE##N,  5*16);			\
+  check##TYPE##N ( &g6s##TYPE##N,  6*16);			\
+  check##TYPE##N ( &g7s##TYPE##N,  7*16);			\
+  check##TYPE##N ( &g8s##TYPE##N,  8*16);			\
+  check##TYPE##N ( &g9s##TYPE##N,  9*16);			\
+  check##TYPE##N (&g10s##TYPE##N, 10*16);			\
+  check##TYPE##N (&g11s##TYPE##N, 11*16);			\
+  check##TYPE##N (&g12s##TYPE##N, 12*16);			\
+  check##TYPE##N (&g13s##TYPE##N, 13*16);			\
+  check##TYPE##N (&g14s##TYPE##N, 14*16);			\
+  check##TYPE##N (&g15s##TYPE##N, 15*16);			\
+  check##TYPE##N (&g16s##TYPE##N, 16*16);			\
+}								\
+								\
+void								\
+test##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+	       struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+	       struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+	       struct S##TYPE##N s7, struct S##TYPE##N s8,	\
+	       struct S##TYPE##N s9, struct S##TYPE##N s10,	\
+	       struct S##TYPE##N s11, struct S##TYPE##N s12,	\
+	       struct S##TYPE##N s13, struct S##TYPE##N s14,	\
+	       struct S##TYPE##N s15, struct S##TYPE##N s16)	\
+{								\
+  check##TYPE##N (&s1, 1*16);					\
+  check##TYPE##N (&s2, 2*16);					\
+  check##TYPE##N (&s3, 3*16);					\
+  check##TYPE##N (&s4, 4*16);					\
+  check##TYPE##N (&s5, 5*16);					\
+  check##TYPE##N (&s6, 6*16);					\
+  check##TYPE##N (&s7, 7*16);					\
+  check##TYPE##N (&s8, 8*16);					\
+  check##TYPE##N (&s9, 9*16);					\
+  check##TYPE##N (&s10, 10*16);					\
+  check##TYPE##N (&s11, 11*16);					\
+  check##TYPE##N (&s12, 12*16);					\
+  check##TYPE##N (&s13, 13*16);					\
+  check##TYPE##N (&s14, 14*16);					\
+  check##TYPE##N (&s15, 15*16);					\
+  check##TYPE##N (&s16, 16*16);					\
+}								\
+								\
+void								\
+testva##TYPE##N (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  struct S##TYPE##N t = va_arg (ap, struct S##TYPE##N);	\
+	  check##TYPE##N (&t, (i+1)*16);			\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Ssc)
+#endif
+T(1, Ssc)
+T(2, Ssc)
+T(3, Ssc)
+T(4, Ssc)
+T(5, Ssc)
+T(6, Ssc)
+T(7, Ssc)
+T(8, Ssc)
+T(9, Ssc)
+T(10, Ssc)
+T(11, Ssc)
+T(12, Ssc)
+T(13, Ssc)
+T(14, Ssc)
+T(15, Ssc)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Sis)
+#endif
+T(1, Sis)
+T(2, Sis)
+T(3, Sis)
+T(4, Sis)
+T(5, Sis)
+T(6, Sis)
+T(7, Sis)
+T(8, Sis)
+T(9, Sis)
+T(10, Sis)
+T(11, Sis)
+T(12, Sis)
+T(13, Sis)
+T(14, Sis)
+T(15, Sis)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_main.c
new file mode 100644
index 000000000..942de1355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_main.c
@@ -0,0 +1,14 @@
+/* Test structures passed by value, including to a function with a
+   variable-length argument list.  Each struct contains an array
+   of small structs, each with three scalar members.  */
+
+extern void struct_by_value_9_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_by_value_9_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_x.c
new file mode 100644
index 000000000..5bbef770a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_x.c
@@ -0,0 +1,224 @@
+#include "compat-common.h"
+
+#define T(N, TYPE)						\
+struct S##TYPE##N { TYPE i[N]; };				\
+								\
+struct S##TYPE##N g1s##TYPE##N, g2s##TYPE##N;			\
+struct S##TYPE##N g3s##TYPE##N, g4s##TYPE##N;			\
+struct S##TYPE##N g5s##TYPE##N, g6s##TYPE##N;			\
+struct S##TYPE##N g7s##TYPE##N, g8s##TYPE##N;			\
+struct S##TYPE##N g9s##TYPE##N, g10s##TYPE##N;			\
+struct S##TYPE##N g11s##TYPE##N, g12s##TYPE##N;			\
+struct S##TYPE##N g13s##TYPE##N, g14s##TYPE##N;			\
+struct S##TYPE##N g15s##TYPE##N, g16s##TYPE##N;			\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE##N (void);				\
+extern void							\
+test##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+	       struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+	       struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+	       struct S##TYPE##N s7, struct S##TYPE##N s8,	\
+	       struct S##TYPE##N s9, struct S##TYPE##N s10,	\
+	       struct S##TYPE##N s11, struct S##TYPE##N s12,	\
+	       struct S##TYPE##N s13, struct S##TYPE##N s14,	\
+	       struct S##TYPE##N s15, struct S##TYPE##N s16);	\
+extern void testva##TYPE##N (int n, ...);			\
+								\
+								\
+void								\
+init##TYPE##N (struct S##TYPE##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    init##TYPE(&p->i[j], i+j);					\
+}								\
+								\
+void								\
+check##TYPE##N (struct S##TYPE##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    check##TYPE(p->i[j], i+j);					\
+}								\
+								\
+void								\
+test2_##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+		 struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+		 struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+		 struct S##TYPE##N s7, struct S##TYPE##N s8)	\
+{								\
+  test##TYPE##N (s1, g2s##TYPE##N, s2, g4s##TYPE##N,		\
+		 s3, g6s##TYPE##N, s4, g8s##TYPE##N,		\
+		 s5, g10s##TYPE##N, s6, g12s##TYPE##N,		\
+		 s7, g14s##TYPE##N, s8, g16s##TYPE##N);		\
+}								\
+								\
+void								\
+testit##TYPE##N (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE##N  ( &g1s##TYPE##N,  1*16);			\
+  init##TYPE##N  ( &g2s##TYPE##N,  2*16);			\
+  init##TYPE##N  ( &g3s##TYPE##N,  3*16);			\
+  init##TYPE##N  ( &g4s##TYPE##N,  4*16);			\
+  init##TYPE##N  ( &g5s##TYPE##N,  5*16);			\
+  init##TYPE##N  ( &g6s##TYPE##N,  6*16);			\
+  init##TYPE##N  ( &g7s##TYPE##N,  7*16);			\
+  init##TYPE##N  ( &g8s##TYPE##N,  8*16);			\
+  init##TYPE##N  ( &g9s##TYPE##N,  9*16);			\
+  init##TYPE##N  (&g10s##TYPE##N, 10*16);			\
+  init##TYPE##N  (&g11s##TYPE##N, 11*16);			\
+  init##TYPE##N  (&g12s##TYPE##N, 12*16);			\
+  init##TYPE##N  (&g13s##TYPE##N, 13*16);			\
+  init##TYPE##N  (&g14s##TYPE##N, 14*16);			\
+  init##TYPE##N  (&g15s##TYPE##N, 15*16);			\
+  init##TYPE##N  (&g16s##TYPE##N, 16*16);			\
+  checkg##TYPE##N ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE##N (g1s##TYPE##N, g2s##TYPE##N,			\
+		 g3s##TYPE##N, g4s##TYPE##N,			\
+		 g5s##TYPE##N, g6s##TYPE##N,			\
+		 g7s##TYPE##N, g8s##TYPE##N,			\
+		 g9s##TYPE##N, g10s##TYPE##N,			\
+		 g11s##TYPE##N, g12s##TYPE##N,			\
+		 g13s##TYPE##N, g14s##TYPE##N,			\
+		 g15s##TYPE##N, g16s##TYPE##N);			\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE##N (16,						\
+		   g1s##TYPE##N, g2s##TYPE##N,			\
+		   g3s##TYPE##N, g4s##TYPE##N,			\
+		   g5s##TYPE##N, g6s##TYPE##N,			\
+		   g7s##TYPE##N, g8s##TYPE##N,			\
+		   g9s##TYPE##N, g10s##TYPE##N,			\
+		   g11s##TYPE##N, g12s##TYPE##N,		\
+		   g13s##TYPE##N, g14s##TYPE##N,		\
+		   g15s##TYPE##N, g16s##TYPE##N);		\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE "[" #N "]");				\
+  DEBUG_FPUTS (" test2: ");					\
+  test2_##TYPE##N (g1s##TYPE##N, g3s##TYPE##N,			\
+		   g5s##TYPE##N, g7s##TYPE##N,			\
+		   g9s##TYPE##N, g11s##TYPE##N,			\
+		   g13s##TYPE##N, g15s##TYPE##N);		\
+  DEBUG_NL;							\
+}
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+
+extern void abort (void);
+
+void checkSc (Sc x, int i) { if (x.c != i/16) DEBUG_CHECK }
+void checkSs (Ss x, int i) { if (x.s != i) DEBUG_CHECK }
+void checkSi (Si x, int i) { if (x.i != i) DEBUG_CHECK }
+void checkSsc (Ssc x, int i)
+{ if (x.s != i || x.c != (i/16)+1) DEBUG_CHECK }
+void checkSis (Sis x, int i)
+{ if (x.i != i || x.s != i+1) DEBUG_CHECK }
+void checkScsi (Scsi x, int i)
+{ if (x.c != i/16 || x.s != i+1 || x.i != i+2) DEBUG_CHECK }
+void checkScis (Scis x, int i)
+{ if (x.c != i/16 || x.i != i+1 || x.s != i+2) DEBUG_CHECK }
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Scsi)
+#endif
+T(1, Scsi)
+T(2, Scsi)
+T(3, Scsi)
+T(4, Scsi)
+T(5, Scsi)
+T(6, Scsi)
+T(7, Scsi)
+T(8, Scsi)
+T(9, Scsi)
+T(10, Scsi)
+T(11, Scsi)
+T(12, Scsi)
+T(13, Scsi)
+T(14, Scsi)
+T(15, Scsi)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Scis)
+#endif
+T(1, Scis)
+T(2, Scis)
+T(3, Scis)
+T(4, Scis)
+T(5, Scis)
+T(6, Scis)
+T(7, Scis)
+T(8, Scis)
+T(9, Scis)
+T(10, Scis)
+T(11, Scis)
+T(12, Scis)
+T(13, Scis)
+T(14, Scis)
+T(15, Scis)
+
+#undef T
+
+void
+struct_by_value_9_x ()
+{
+DEBUG_INIT
+
+#define T(N, TYPE) testit##TYPE##N ();
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Scsi)
+#endif
+T(1, Scsi)
+T(2, Scsi)
+T(3, Scsi)
+T(4, Scsi)
+T(5, Scsi)
+T(6, Scsi)
+T(7, Scsi)
+T(8, Scsi)
+T(9, Scsi)
+T(10, Scsi)
+T(11, Scsi)
+T(12, Scsi)
+T(13, Scsi)
+T(14, Scsi)
+T(15, Scsi)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Scis)
+#endif
+T(1, Scis)
+T(2, Scis)
+T(3, Scis)
+T(4, Scis)
+T(5, Scis)
+T(6, Scis)
+T(7, Scis)
+T(8, Scis)
+T(9, Scis)
+T(10, Scis)
+T(11, Scis)
+T(12, Scis)
+T(13, Scis)
+T(14, Scis)
+T(15, Scis)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_y.c
new file mode 100644
index 000000000..0f6521800
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-by-value-9_y.c
@@ -0,0 +1,144 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+typedef struct { char c; } Sc;
+typedef struct { short s; } Ss;
+typedef struct { int i; } Si;
+typedef struct { short s; char c; } Ssc;
+typedef struct { int i; short s; } Sis;
+typedef struct { char c; short s; int i; } Scsi;
+typedef struct { char c; int i; short s; } Scis;
+
+void initSc (Sc *p, int i) { p->c = i/16; }
+void initSs (Ss *p, int i) { p->s = i; }
+void initSi (Si *p, int i) { p->i = i; }
+void initSsc (Ssc *p, int i) { p->s = i; p->c = (i/16)+1; }
+void initSis (Sis *p, int i) { p->i = i; p->s = i+1; }
+void initScsi (Scsi *p, int i) { p->c = i/16; p->s = i+1; p->i = i+2; }
+void initScis (Scis *p, int i) { p->c = i/16; p->i = i+1; p->s = i+2; }
+
+#define T(N, TYPE)						\
+struct S##TYPE##N { TYPE i[N]; };				\
+								\
+extern struct S##TYPE##N g1s##TYPE##N, g2s##TYPE##N;		\
+extern struct S##TYPE##N g3s##TYPE##N, g4s##TYPE##N;		\
+extern struct S##TYPE##N g5s##TYPE##N, g6s##TYPE##N;		\
+extern struct S##TYPE##N g7s##TYPE##N, g8s##TYPE##N;		\
+extern struct S##TYPE##N g9s##TYPE##N, g10s##TYPE##N;		\
+extern struct S##TYPE##N g11s##TYPE##N, g12s##TYPE##N;		\
+extern struct S##TYPE##N g13s##TYPE##N, g14s##TYPE##N;		\
+extern struct S##TYPE##N g15s##TYPE##N, g16s##TYPE##N;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+extern void							\
+check##TYPE##N (struct S##TYPE##N *p, int i);			\
+								\
+void								\
+checkg##TYPE##N (void)						\
+{								\
+  check##TYPE##N ( &g1s##TYPE##N,  1*16);			\
+  check##TYPE##N ( &g2s##TYPE##N,  2*16);			\
+  check##TYPE##N ( &g3s##TYPE##N,  3*16);			\
+  check##TYPE##N ( &g4s##TYPE##N,  4*16);			\
+  check##TYPE##N ( &g5s##TYPE##N,  5*16);			\
+  check##TYPE##N ( &g6s##TYPE##N,  6*16);			\
+  check##TYPE##N ( &g7s##TYPE##N,  7*16);			\
+  check##TYPE##N ( &g8s##TYPE##N,  8*16);			\
+  check##TYPE##N ( &g9s##TYPE##N,  9*16);			\
+  check##TYPE##N (&g10s##TYPE##N, 10*16);			\
+  check##TYPE##N (&g11s##TYPE##N, 11*16);			\
+  check##TYPE##N (&g12s##TYPE##N, 12*16);			\
+  check##TYPE##N (&g13s##TYPE##N, 13*16);			\
+  check##TYPE##N (&g14s##TYPE##N, 14*16);			\
+  check##TYPE##N (&g15s##TYPE##N, 15*16);			\
+  check##TYPE##N (&g16s##TYPE##N, 16*16);			\
+}								\
+								\
+void								\
+test##TYPE##N (struct S##TYPE##N s1, struct S##TYPE##N s2,	\
+	       struct S##TYPE##N s3, struct S##TYPE##N s4,	\
+	       struct S##TYPE##N s5, struct S##TYPE##N s6,	\
+	       struct S##TYPE##N s7, struct S##TYPE##N s8,	\
+	       struct S##TYPE##N s9, struct S##TYPE##N s10,	\
+	       struct S##TYPE##N s11, struct S##TYPE##N s12,	\
+	       struct S##TYPE##N s13, struct S##TYPE##N s14,	\
+	       struct S##TYPE##N s15, struct S##TYPE##N s16)	\
+{								\
+  check##TYPE##N (&s1, 1*16);					\
+  check##TYPE##N (&s2, 2*16);					\
+  check##TYPE##N (&s3, 3*16);					\
+  check##TYPE##N (&s4, 4*16);					\
+  check##TYPE##N (&s5, 5*16);					\
+  check##TYPE##N (&s6, 6*16);					\
+  check##TYPE##N (&s7, 7*16);					\
+  check##TYPE##N (&s8, 8*16);					\
+  check##TYPE##N (&s9, 9*16);					\
+  check##TYPE##N (&s10, 10*16);					\
+  check##TYPE##N (&s11, 11*16);					\
+  check##TYPE##N (&s12, 12*16);					\
+  check##TYPE##N (&s13, 13*16);					\
+  check##TYPE##N (&s14, 14*16);					\
+  check##TYPE##N (&s15, 15*16);					\
+  check##TYPE##N (&s16, 16*16);					\
+}								\
+								\
+void								\
+testva##TYPE##N (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  struct S##TYPE##N t = va_arg (ap, struct S##TYPE##N);	\
+	  check##TYPE##N (&t, (i+1)*16);			\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, Scsi)
+#endif
+T(1, Scsi)
+T(2, Scsi)
+T(3, Scsi)
+T(4, Scsi)
+T(5, Scsi)
+T(6, Scsi)
+T(7, Scsi)
+T(8, Scsi)
+T(9, Scsi)
+T(10, Scsi)
+T(11, Scsi)
+T(12, Scsi)
+T(13, Scsi)
+T(14, Scsi)
+T(15, Scsi)
+#ifndef SKIP_ZERO_ARRAY
+T(0, Scis)
+#endif
+T(1, Scis)
+T(2, Scis)
+T(3, Scis)
+T(4, Scis)
+T(5, Scis)
+T(6, Scis)
+T(7, Scis)
+T(8, Scis)
+T(9, Scis)
+T(10, Scis)
+T(11, Scis)
+T(12, Scis)
+T(13, Scis)
+T(14, Scis)
+T(15, Scis)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1.h
new file mode 100644
index 000000000..8b5393774
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1.h
@@ -0,0 +1,17 @@
+#include <complex.h>
+
+struct st
+{
+  int s1;
+  float complex x;
+  int s2;
+};
+
+typedef struct { float r, i; } _complex;
+
+struct stc
+{
+  int s1;
+  _complex x;
+  int s2;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_main.c
new file mode 100644
index 000000000..92e886acf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_main.c
@@ -0,0 +1,21 @@
+/* { dg-options "-O" } */
+
+#ifdef __x86_64__
+/* Test function argument passing.  PR target/15302.  */
+
+extern void struct_complex_1_x (void);
+extern void exit (int);
+
+int
+main ()
+{
+  struct_complex_1_x ();
+  exit (0);
+}
+#else
+int
+main ()
+{
+  return 0;
+}
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_x.c
new file mode 100644
index 000000000..0c6723948
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_x.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O -Wno-psabi" } */
+
+
+#ifdef __x86_64__
+#include "struct-complex-1.h"
+
+struct st st1;
+struct stc st2;
+
+extern void foo ();
+extern void bar ();
+
+int
+struct_complex_1_x ()
+{
+  st1.s1 = 1;
+  st1.s2 = 2;
+  __real__ st1.x = 2;
+  __imag__ st1.x = 4;
+  st2.s1 = 1;
+  st2.s2 = 2;
+  st2.x.r = 2;
+  st2.x.i = 4;
+  foo (st1);
+  foo (st2);
+  bar (st1);
+  bar (st2);
+  return 0;
+}
+#else
+int dummy_x;
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_y.c
new file mode 100644
index 000000000..858e6a9da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-1_y.c
@@ -0,0 +1,24 @@
+/* { dg-options "-O -Wno-psabi" } */
+
+#ifdef __x86_64__
+#include <stdlib.h>
+#include "struct-complex-1.h"
+
+void
+bar(struct st x)
+{
+  if (x.s1 != 1 || x.s2 != 2
+      || __real__ x.x != 2 || __imag__ x.x != 4)
+    abort ();
+}
+
+void
+foo(struct stc x)
+{
+  if (x.s1 != 1 || x.s2 != 2 || x.x.r != 2 || x.x.i != 4)
+    abort ();
+}
+#else
+int dummy_y;
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2.h
new file mode 100644
index 000000000..1fd1e86c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2.h
@@ -0,0 +1,15 @@
+#include <complex.h>
+
+struct st
+{
+  int s1;
+  float complex x;
+};
+
+typedef struct { float r, i; } _complex;
+
+struct stc
+{
+  int s1;
+  _complex x;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_main.c
new file mode 100644
index 000000000..74eae6242
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_main.c
@@ -0,0 +1,21 @@
+/* { dg-options "-O" } */
+
+#ifdef __x86_64__
+/* Test function argument passing.  PR target/39678.  */
+
+extern void struct_complex_2_x (void);
+extern void exit (int);
+
+int
+main ()
+{
+  struct_complex_2_x ();
+  exit (0);
+}
+#else
+int
+main ()
+{
+  return 0;
+}
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_x.c
new file mode 100644
index 000000000..2fb9826eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_x.c
@@ -0,0 +1,30 @@
+/* { dg-options "-O -Wno-psabi" } */
+
+
+#ifdef __x86_64__
+#include "struct-complex-2.h"
+
+struct st st1;
+struct stc st2;
+
+extern void foo ();
+extern void bar ();
+
+int
+struct_complex_2_x ()
+{
+  st1.s1 = 1;
+  __real__ st1.x = 2;
+  __imag__ st1.x = 4;
+  st2.s1 = 1;
+  st2.x.r = 2;
+  st2.x.i = 4;
+  foo (st1);
+  foo (st2);
+  bar (st1);
+  bar (st2);
+  return 0;
+}
+#else
+int dummy_x;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_y.c
new file mode 100644
index 000000000..54a72fa43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-complex-2_y.c
@@ -0,0 +1,23 @@
+/* { dg-options "-O -Wno-psabi" } */
+
+#ifdef __x86_64__
+#include <stdlib.h>
+#include "struct-complex-2.h"
+
+void
+bar(struct st x)
+{
+  if (x.s1 != 1
+      || __real__ x.x != 2 || __imag__ x.x != 4)
+    abort ();
+}
+
+void
+foo(struct stc x)
+{
+  if (x.s1 != 1 || x.x.r != 2 || x.x.i != 4)
+    abort ();
+}
+#else
+int dummy_y;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1.exp
new file mode 100644
index 000000000..e541f6ed3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1.exp
@@ -0,0 +1,130 @@
+# Copyright (C) 2002, 2003, 2004, 2007, 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
+# <http://www.gnu.org/licenses/>.
+#
+# This file was written by Jakub Jelinek, <jakub@redhat.com>
+# Based on compat.exp writte by Janis Johnson, <janis187@us.ibm.com>
+
+
+# Test interoperability of two compilers that follow the same ABI.
+#
+# Break simple tests into two pieces and see that they work when linked
+# together.  If an alternate compiler is specified then the two main
+# pieces of each test are compiled with different compilers.  The
+# alternate compiler must be installed, and is specified by defining
+# ALT_CC_UNDER_TEST in the environment.
+#
+# struct-layout-1 are generated structure layout interoperability tests,
+# so a generator first needs to be compiled on host, run there and the
+# generated tests then compiled on build and executed on target.
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+global GCC_UNDER_TEST
+global compat_save_gcc_under_test
+global compat_use_alt
+global compat_same_alt
+global compat_have_dfp
+
+# Load procedures from common libraries. 
+load_lib standard.exp
+load_lib gcc.exp
+load_lib target-libpath.exp
+
+# Load the language-dependent compabibility support procedures.
+load_lib c-compat.exp
+
+# Load the language-independent compabibility support procedures.
+load_lib compat.exp
+
+gcc_init
+
+# Save variables for the C compiler under test, which each test will
+# change a couple of times.  This must be done after calling gcc-init.
+set compat_save_gcc_under_test $GCC_UNDER_TEST
+
+# Define an identifier for use with this suite to avoid name conflicts
+# with other compat tests running at the same time.
+set sid "c_compat"
+
+# Find out whether there is an alternate compiler to test.  If the
+# variable is defined but is set to "same", that means we use the same
+# compiler twice, which is meaningful if the two parts of COMPAT_OPTIONS
+# are different.
+set compat_use_alt 0
+set compat_same_alt 0
+
+if [info exists ALT_CC_UNDER_TEST] then {
+    set compat_use_alt 1
+    if [string match "same" $ALT_CC_UNDER_TEST] then {
+	set compat_same_alt 1
+    }
+}
+
+compat_setup_dfp
+
+if { $compat_have_dfp == 0 } {
+    set skip_dfp "-DSKIP_DECIMAL_FLOAT"
+} else {
+    set skip_dfp ""
+}
+
+set tstobjdir "$tmpdir/gcc.dg-struct-layout-1"
+set generator "$tmpdir/gcc.dg-struct-layout-1_generate.exe"
+
+set generator_src "$srcdir/$subdir/struct-layout-1_generate.c"
+set generator_src "$generator_src $srcdir/$subdir/generate-random.c"
+set generator_src "$generator_src $srcdir/$subdir/generate-random_r.c"
+set generator_cmd "-o $generator $skip_dfp $generator_src"
+
+# Temporarily switch to the environment for the host compiler.
+restore_ld_library_path_env_vars
+set status [remote_exec build "$HOSTCC $HOSTCFLAGS $generator_cmd"]
+set status [lindex $status 0]
+set_ld_library_path_env_vars
+
+if { $status == 0 } then {
+    file delete -force $tstobjdir
+    file mkdir $tstobjdir
+    set generator_args "-s $srcdir/$subdir -d $tstobjdir"
+    if [info exists env(RUN_ALL_COMPAT_TESTS) ] then {
+	set generator_args "$generator_args -n 15000"
+    }
+    if [check_effective_target_short_enums] then {
+	set generator_args "-e $generator_args"
+    }
+    set status [remote_exec host "$generator $generator_args"]
+    set status [lindex $status 0]
+    if { $status == 0 } then {
+	foreach src [lsort [find $tstobjdir *_main.c]] {
+	    # If we're only testing specific files and this isn't one
+	    # of them, skip it.
+	    if ![runtest_file_p $runtests $src] then {
+		continue
+	    }
+
+	    compat-execute $src $sid $compat_use_alt
+	}
+    } else {
+	warning "Could not execute gcc.dg/compat/struct-layout-1 generator"
+    }
+} else {
+    warning "Could not compile gcc.dg/compat/struct-layout-1 generator"
+}
+
+# Restore the original compiler under test.
+compat-use-tst-compiler
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1.h
new file mode 100644
index 000000000..82ac9f82c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1.h
@@ -0,0 +1,787 @@
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "compat-common.h"
+
+#ifndef SKIP_ATTRIBUTE
+# include "vector-defs.h"
+#else
+typedef int qi;
+typedef int hi;
+typedef int si;
+typedef int di;
+typedef float sf;
+typedef float df;
+typedef int v8qi;
+typedef int v16qi;
+typedef int v2hi;
+typedef int v4hi;
+typedef int v8hi;
+typedef int v2si;
+typedef int v4si;
+typedef int v1di;
+typedef int v2di;
+typedef int v2sf;
+typedef int v4sf;
+typedef int v16sf;
+typedef int v2df;
+typedef int u8qi;
+typedef int u16qi;
+typedef int u2hi;
+typedef int u4hi;
+typedef int u8hi;
+typedef int u2si;
+typedef int u4si;
+typedef int u1di;
+typedef int u2di;
+typedef int u2sf;
+typedef int u4sf;
+typedef int u16sf;
+typedef int u2df;
+#endif
+#if (defined __i386__ || defined __x86_64__) && !defined SKIP_ATTRIBUTE
+# ifdef __MMX__
+typedef int __m64 __attribute__ ((__vector_size__ (8)));
+# else
+typedef int __m64;
+# endif
+# ifdef __SSE__
+typedef float __m128 __attribute__ ((__vector_size__ (16)));
+# else
+typedef int __m128;
+# endif
+#else
+typedef int __m64;
+typedef int __m128;
+#endif
+#if defined (__uClinux__)
+/* The maximum achievable alignment on uClinux is usually 16 bytes.  */
+#define v16sf v4sf
+#define u16sf u4sf
+#endif
+
+#define FLDS_MAX	32
+extern struct Info
+{
+  int nfields, nbitfields;
+  void *sp, *a0p, *a3p;
+  void *flds[FLDS_MAX];
+  size_t sz, sizes[FLDS_MAX];
+  size_t als, ala0, ala3, aligns[FLDS_MAX];
+} info;
+
+extern int intarray[256];
+extern int fn0 (void), fn1 (void), fn2 (void), fn3 (void), fn4 (void);
+extern int fn5 (void), fn6 (void), fn7 (void), fn8 (void), fn9 (void);
+
+#ifdef DBG
+#define FAIL(n, m) printf ("fail %d.%d\n", n, m), ++fails
+#else
+#define FAIL(n, m) ++fails
+#endif
+
+#ifdef SKIP_ATTRIBUTE
+# define __attribute__(x)
+#endif
+#define atal		__attribute__((aligned))
+#define atpa		__attribute__((packed))
+#define atalpa		__attribute__((aligned, packed))
+#define atpaal		__attribute__((packed, aligned))
+#define atal1		__attribute__((aligned (1)))
+#define atal2		__attribute__((aligned (2)))
+#define atal4		__attribute__((aligned (4)))
+#define atal8		__attribute__((aligned (8)))
+#define atal16		__attribute__((aligned (16)))
+#define atal1pa		__attribute__((aligned (1), packed))
+#define atal2pa		__attribute__((aligned (2), packed))
+#define atal4pa		__attribute__((aligned (4), packed))
+#define atal8pa		__attribute__((aligned (8), packed))
+#define atal16pa	__attribute__((aligned (16), packed))
+#define atpaal1		__attribute__((packed, aligned (1)))
+#define atpaal2		__attribute__((packed, aligned (2)))
+#define atpaal4		__attribute__((packed, aligned (4)))
+#define atpaal8		__attribute__((packed, aligned (8)))
+#define atpaal16	__attribute__((packed, aligned (16)))
+
+#if UCHAR_MAX == 255 && USHORT_MAX == 65535 && UINT_MAX == 4294967295U \
+    && ULLONG_MAX == 18446744073709551615ULL
+/* For ILP32 and LP64 targets, assume float is at least 32-bit
+   and double plus long double at least 64-bit.  */
+# define atalx1		atal1
+# define atalx2		atal2
+# define atalx4		atal4
+# define atalx8		atal8
+# define atalx16	atal16
+# define atalx1pa	atal1pa
+# define atalx2pa	atal2pa
+# define atalx4pa	atal4pa
+# define atalx8pa	atal8pa
+# define atalx16pa	atal16pa
+# define atpaalx1	atpaal1
+# define atpaalx2	atpaal2
+# define atpaalx4	atpaal4
+# define atpaalx8	atpaal8
+# define atpaalx16	atpaal16
+# if ULONG_MAX > 4294967295UL
+#  define ataly8	atal8
+#  define ataly8pa	atal8pa
+#  define atpaaly8	atpaal8
+#  define ataly16	atal16
+#  define ataly16pa	atal16pa
+#  define atpaaly16	atpaal16
+# else
+#  define ataly8
+#  define ataly8pa
+#  define atpaaly8
+#  define ataly16
+#  define ataly16pa
+#  define atpaaly16
+# endif
+#else
+# define atalx1
+# define atalx2
+# define atalx4
+# define atalx8
+# define atalx16
+# define atalx1pa
+# define atalx2pa
+# define atalx4pa
+# define atalx8pa
+# define atalx16pa
+# define atpaalx1
+# define atpaalx2
+# define atpaalx4
+# define atpaalx8
+# define atpaalx16
+# define ataly8
+# define ataly8pa
+# define atpaaly8
+# define ataly16
+# define ataly16pa
+# define atpaaly16
+#endif
+
+#define atQI		__attribute__((mode (QI)))
+#define atHI		__attribute__((mode (HI)))
+#define atSI		__attribute__((mode (SI)))
+#define atDI		__attribute__((mode (DI)))
+
+enum E0 { e0_0 };
+enum E1 { e1_0, e1_1 };
+enum E2 { e2_m3 = -3, e2_m2, e2_m1, e2_0, e2_1, e2_2, e2_3 };
+enum E3 { e3_m127 = -127, e3_m126, e3_m125, e3_0 = 0, e3_125 = 125, e3_126, e3_127 };
+enum E4 { e4_0, e4_1, e4_2, e4_3, e4_253 = 253, e4_254, e4_255 };
+enum E5 { e5_m32767 = -32767, e5_m32766, e5_m32765, e5_0 = 0, e5_32765 = 32765, e5_32766, e5_32767 };
+enum E6 { e6_0, e6_1, e6_2, e6_3, e6_65533 = 65533, e6_65534, e6_65535 };
+enum E7 { e7_m2147483647 = -2147483647, e7_m2147483646, e7_m2147483645,
+	  e7_0, e7_2147483645 = 2147483645, e7_2147483646, e7_2147483647 };
+enum E8 { e8_0, e8_1, e8_2, e8_3, e8_4294967293 = 4294967293U, e8_4294967294, e8_4294967295 };
+enum E9 { e9_m1099511627775 = -1099511627775LL, e9_m1099511627774, e9_m1099511627773,
+	  e9_0, e9_1099511627773 = 1099511627773LL, e9_1099511627774, e9_1099511627775 };
+
+typedef char Tchar;
+typedef signed char Tschar;
+typedef unsigned char Tuchar;
+typedef short int Tshort;
+typedef unsigned short int Tushort;
+typedef int Tint;
+typedef unsigned int Tuint;
+typedef long int Tlong;
+typedef unsigned long int Tulong;
+typedef long long int Tllong;
+typedef unsigned long long int Tullong;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Tcchar;
+typedef _Complex signed char Tcschar;
+typedef _Complex unsigned char Tcuchar;
+typedef _Complex short int Tcshort;
+typedef _Complex unsigned short int Tcushort;
+typedef _Complex int Tcint;
+typedef _Complex unsigned int Tcuint;
+typedef _Complex long int Tclong;
+typedef _Complex unsigned long int Tculong;
+typedef _Complex long long int Tcllong;
+typedef _Complex unsigned long long int Tcullong;
+#endif
+typedef float Tfloat;
+typedef double Tdouble;
+typedef long double Tldouble;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 TDecimal32;
+typedef _Decimal64 TDecimal64;
+typedef _Decimal128 TDecimal128;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Tcfloat;
+typedef _Complex double Tcdouble;
+typedef _Complex long double Tcldouble;
+#endif
+typedef bool Tbool;
+typedef enum E0 TE0;
+typedef enum E1 TE1;
+typedef enum E2 TE2;
+typedef enum E3 TE3;
+typedef enum E4 TE4;
+typedef enum E5 TE5;
+typedef enum E6 TE6;
+typedef enum E7 TE7;
+typedef enum E8 TE8;
+typedef enum E9 TE9;
+typedef void *Tptr;
+typedef char *Tcptr;
+typedef int *Tiptr;
+typedef char Talchar atal;
+typedef signed char Talschar atal;
+typedef unsigned char Taluchar atal;
+typedef short int Talshort atal;
+typedef unsigned short int Talushort atal;
+typedef int Talint atal;
+typedef unsigned int Taluint atal;
+typedef long int Tallong atal;
+typedef unsigned long int Talulong atal;
+typedef long long int Talllong atal;
+typedef unsigned long long int Talullong atal;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Talcchar atal;
+typedef _Complex signed char Talcschar atal;
+typedef _Complex unsigned char Talcuchar atal;
+typedef _Complex short int Talcshort atal;
+typedef _Complex unsigned short int Talcushort atal;
+typedef _Complex int Talcint atal;
+typedef _Complex unsigned int Talcuint atal;
+typedef _Complex long int Talclong atal;
+typedef _Complex unsigned long int Talculong atal;
+typedef _Complex long long int Talcllong atal;
+typedef _Complex unsigned long long int Talcullong atal;
+#endif
+typedef float Talfloat atal;
+typedef double Taldouble atal;
+typedef long double Talldouble atal;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 TalDecimal32 atal;
+typedef _Decimal64 TalDecimal64 atal;
+typedef _Decimal128 TalDecimal128 atal;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Talcfloat atal;
+typedef _Complex double Talcdouble atal;
+typedef _Complex long double Talcldouble atal;
+#endif
+typedef bool Talbool atal;
+typedef enum E0 TalE0 atal;
+typedef enum E1 TalE1 atal;
+typedef enum E2 TalE2 atal;
+typedef enum E3 TalE3 atal;
+typedef enum E4 TalE4 atal;
+typedef enum E5 TalE5 atal;
+typedef enum E6 TalE6 atal;
+typedef enum E7 TalE7 atal;
+typedef enum E8 TalE8 atal;
+typedef enum E9 TalE9 atal;
+typedef void *Talptr atal;
+typedef char *Talcptr atal;
+typedef int *Taliptr atal;
+typedef char Tal1char atal1;
+typedef signed char Tal1schar atal1;
+typedef unsigned char Tal1uchar atal1;
+typedef short int Tal1short atal1;
+typedef unsigned short int Tal1ushort atal1;
+typedef int Tal1int atal1;
+typedef unsigned int Tal1uint atal1;
+typedef long int Tal1long atal1;
+typedef unsigned long int Tal1ulong atal1;
+typedef long long int Tal1llong atal1;
+typedef unsigned long long int Tal1ullong atal1;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Tal1cchar atal1;
+typedef _Complex signed char Tal1cschar atal1;
+typedef _Complex unsigned char Tal1cuchar atal1;
+typedef _Complex short int Tal1cshort atal1;
+typedef _Complex unsigned short int Tal1cushort atal1;
+typedef _Complex int Tal1cint atal1;
+typedef _Complex unsigned int Tal1cuint atal1;
+typedef _Complex long int Tal1clong atal1;
+typedef _Complex unsigned long int Tal1culong atal1;
+typedef _Complex long long int Tal1cllong atal1;
+typedef _Complex unsigned long long int Tal1cullong atal1;
+#endif
+typedef float Tal1float atal1;
+typedef double Tal1double atal1;
+typedef long double Tal1ldouble atal1;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Tal1Decimal32 atal1;
+typedef _Decimal64 Tal1Decimal64 atal1;
+typedef _Decimal128 Tal1Decimal128 atal1;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Tal1cfloat atal1;
+typedef _Complex double Tal1cdouble atal1;
+typedef _Complex long double Tal1cldouble atal1;
+#endif
+typedef bool Tal1bool atal1;
+typedef enum E0 Tal1E0 atal1;
+typedef enum E1 Tal1E1 atal1;
+typedef enum E2 Tal1E2 atal1;
+typedef enum E3 Tal1E3 atal1;
+typedef enum E4 Tal1E4 atal1;
+typedef enum E5 Tal1E5 atal1;
+typedef enum E6 Tal1E6 atal1;
+typedef enum E7 Tal1E7 atal1;
+typedef enum E8 Tal1E8 atal1;
+typedef enum E9 Tal1E9 atal1;
+typedef void *Tal1ptr atal1;
+typedef char *Tal1cptr atal1;
+typedef int *Tal1iptr atal1;
+typedef char Tal2char atal2;
+typedef signed char Tal2schar atal2;
+typedef unsigned char Tal2uchar atal2;
+typedef short int Tal2short atal2;
+typedef unsigned short int Tal2ushort atal2;
+typedef int Tal2int atal2;
+typedef unsigned int Tal2uint atal2;
+typedef long int Tal2long atal2;
+typedef unsigned long int Tal2ulong atal2;
+typedef long long int Tal2llong atal2;
+typedef unsigned long long int Tal2ullong atal2;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Tal2cchar atal2;
+typedef _Complex signed char Tal2cschar atal2;
+typedef _Complex unsigned char Tal2cuchar atal2;
+typedef _Complex short int Tal2cshort atal2;
+typedef _Complex unsigned short int Tal2cushort atal2;
+typedef _Complex int Tal2cint atal2;
+typedef _Complex unsigned int Tal2cuint atal2;
+typedef _Complex long int Tal2clong atal2;
+typedef _Complex unsigned long int Tal2culong atal2;
+typedef _Complex long long int Tal2cllong atal2;
+typedef _Complex unsigned long long int Tal2cullong atal2;
+#endif
+typedef float Tal2float atal2;
+typedef double Tal2double atal2;
+typedef long double Tal2ldouble atal2;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Tal2Decimal32 atal2;
+typedef _Decimal64 Tal2Decimal64 atal2;
+typedef _Decimal128 Tal2Decimal128 atal2;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Tal2cfloat atal2;
+typedef _Complex double Tal2cdouble atal2;
+typedef _Complex long double Tal2cldouble atal2;
+#endif
+typedef bool Tal2bool atal2;
+typedef enum E0 Tal2E0 atal2;
+typedef enum E1 Tal2E1 atal2;
+typedef enum E2 Tal2E2 atal2;
+typedef enum E3 Tal2E3 atal2;
+typedef enum E4 Tal2E4 atal2;
+typedef enum E5 Tal2E5 atal2;
+typedef enum E6 Tal2E6 atal2;
+typedef enum E7 Tal2E7 atal2;
+typedef enum E8 Tal2E8 atal2;
+typedef enum E9 Tal2E9 atal2;
+typedef void *Tal2ptr atal2;
+typedef char *Tal2cptr atal2;
+typedef int *Tal2iptr atal2;
+typedef char Tal4char atal4;
+typedef signed char Tal4schar atal4;
+typedef unsigned char Tal4uchar atal4;
+typedef short int Tal4short atal4;
+typedef unsigned short int Tal4ushort atal4;
+typedef int Tal4int atal4;
+typedef unsigned int Tal4uint atal4;
+typedef long int Tal4long atal4;
+typedef unsigned long int Tal4ulong atal4;
+typedef long long int Tal4llong atal4;
+typedef unsigned long long int Tal4ullong atal4;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Tal4cchar atal4;
+typedef _Complex signed char Tal4cschar atal4;
+typedef _Complex unsigned char Tal4cuchar atal4;
+typedef _Complex short int Tal4cshort atal4;
+typedef _Complex unsigned short int Tal4cushort atal4;
+typedef _Complex int Tal4cint atal4;
+typedef _Complex unsigned int Tal4cuint atal4;
+typedef _Complex long int Tal4clong atal4;
+typedef _Complex unsigned long int Tal4culong atal4;
+typedef _Complex long long int Tal4cllong atal4;
+typedef _Complex unsigned long long int Tal4cullong atal4;
+#endif
+typedef float Tal4float atal4;
+typedef double Tal4double atal4;
+typedef long double Tal4ldouble atal4;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Tal4Decimal32 atal4;
+typedef _Decimal64 Tal4Decimal64 atal4;
+typedef _Decimal128 Tal4Decimal128 atal4;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Tal4cfloat atal4;
+typedef _Complex double Tal4cdouble atal4;
+typedef _Complex long double Tal4cldouble atal4;
+#endif
+typedef bool Tal4bool atal4;
+typedef enum E0 Tal4E0 atal4;
+typedef enum E1 Tal4E1 atal4;
+typedef enum E2 Tal4E2 atal4;
+typedef enum E3 Tal4E3 atal4;
+typedef enum E4 Tal4E4 atal4;
+typedef enum E5 Tal4E5 atal4;
+typedef enum E6 Tal4E6 atal4;
+typedef enum E7 Tal4E7 atal4;
+typedef enum E8 Tal4E8 atal4;
+typedef enum E9 Tal4E9 atal4;
+typedef void *Tal4ptr atal4;
+typedef char *Tal4cptr atal4;
+typedef int *Tal4iptr atal4;
+typedef char Tal8char atal8;
+typedef signed char Tal8schar atal8;
+typedef unsigned char Tal8uchar atal8;
+typedef short int Tal8short atal8;
+typedef unsigned short int Tal8ushort atal8;
+typedef int Tal8int atal8;
+typedef unsigned int Tal8uint atal8;
+typedef long int Tal8long atal8;
+typedef unsigned long int Tal8ulong atal8;
+typedef long long int Tal8llong atal8;
+typedef unsigned long long int Tal8ullong atal8;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Tal8cchar atal8;
+typedef _Complex signed char Tal8cschar atal8;
+typedef _Complex unsigned char Tal8cuchar atal8;
+typedef _Complex short int Tal8cshort atal8;
+typedef _Complex unsigned short int Tal8cushort atal8;
+typedef _Complex int Tal8cint atal8;
+typedef _Complex unsigned int Tal8cuint atal8;
+typedef _Complex long int Tal8clong atal8;
+typedef _Complex unsigned long int Tal8culong atal8;
+typedef _Complex long long int Tal8cllong atal8;
+typedef _Complex unsigned long long int Tal8cullong atal8;
+#endif
+typedef float Tal8float atal8;
+typedef double Tal8double atal8;
+typedef long double Tal8ldouble atal8;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Tal8Decimal32 atal8;
+typedef _Decimal64 Tal8Decimal64 atal8;
+typedef _Decimal128 Tal8Decimal128 atal8;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Tal8cfloat atal8;
+typedef _Complex double Tal8cdouble atal8;
+typedef _Complex long double Tal8cldouble atal8;
+#endif
+typedef bool Tal8bool atal8;
+typedef enum E0 Tal8E0 atal8;
+typedef enum E1 Tal8E1 atal8;
+typedef enum E2 Tal8E2 atal8;
+typedef enum E3 Tal8E3 atal8;
+typedef enum E4 Tal8E4 atal8;
+typedef enum E5 Tal8E5 atal8;
+typedef enum E6 Tal8E6 atal8;
+typedef enum E7 Tal8E7 atal8;
+typedef enum E8 Tal8E8 atal8;
+typedef enum E9 Tal8E9 atal8;
+typedef void *Tal8ptr atal8;
+typedef char *Tal8cptr atal8;
+typedef int *Tal8iptr atal8;
+typedef char Tal16char atal16;
+typedef signed char Tal16schar atal16;
+typedef unsigned char Tal16uchar atal16;
+typedef short int Tal16short atal16;
+typedef unsigned short int Tal16ushort atal16;
+typedef int Tal16int atal16;
+typedef unsigned int Tal16uint atal16;
+typedef long int Tal16long atal16;
+typedef unsigned long int Tal16ulong atal16;
+typedef long long int Tal16llong atal16;
+typedef unsigned long long int Tal16ullong atal16;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Tal16cchar atal16;
+typedef _Complex signed char Tal16cschar atal16;
+typedef _Complex unsigned char Tal16cuchar atal16;
+typedef _Complex short int Tal16cshort atal16;
+typedef _Complex unsigned short int Tal16cushort atal16;
+typedef _Complex int Tal16cint atal16;
+typedef _Complex unsigned int Tal16cuint atal16;
+typedef _Complex long int Tal16clong atal16;
+typedef _Complex unsigned long int Tal16culong atal16;
+typedef _Complex long long int Tal16cllong atal16;
+typedef _Complex unsigned long long int Tal16cullong atal16;
+#endif
+typedef float Tal16float atal16;
+typedef double Tal16double atal16;
+typedef long double Tal16ldouble atal16;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Tal16Decimal32 atal16;
+typedef _Decimal64 Tal16Decimal64 atal16;
+typedef _Decimal128 Tal16Decimal128 atal16;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Tal16cfloat atal16;
+typedef _Complex double Tal16cdouble atal16;
+typedef _Complex long double Tal16cldouble atal16;
+#endif
+typedef bool Tal16bool atal16;
+typedef enum E0 Tal16E0 atal16;
+typedef enum E1 Tal16E1 atal16;
+typedef enum E2 Tal16E2 atal16;
+typedef enum E3 Tal16E3 atal16;
+typedef enum E4 Tal16E4 atal16;
+typedef enum E5 Tal16E5 atal16;
+typedef enum E6 Tal16E6 atal16;
+typedef enum E7 Tal16E7 atal16;
+typedef enum E8 Tal16E8 atal16;
+typedef enum E9 Tal16E9 atal16;
+typedef void *Tal16ptr atal16;
+typedef char *Tal16cptr atal16;
+typedef int *Tal16iptr atal16;
+typedef char Talx1char atalx1;
+typedef signed char Talx1schar atalx1;
+typedef unsigned char Talx1uchar atalx1;
+typedef short int Talx1short atalx1;
+typedef unsigned short int Talx1ushort atalx1;
+typedef int Talx1int atalx1;
+typedef unsigned int Talx1uint atalx1;
+typedef long int Talx1long atalx1;
+typedef unsigned long int Talx1ulong atalx1;
+typedef long long int Talx1llong atalx1;
+typedef unsigned long long int Talx1ullong atalx1;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Talx1cchar atalx1;
+typedef _Complex signed char Talx1cschar atalx1;
+typedef _Complex unsigned char Talx1cuchar atalx1;
+typedef _Complex short int Talx1cshort atalx1;
+typedef _Complex unsigned short int Talx1cushort atalx1;
+typedef _Complex int Talx1cint atalx1;
+typedef _Complex unsigned int Talx1cuint atalx1;
+typedef _Complex long int Talx1clong atalx1;
+typedef _Complex unsigned long int Talx1culong atalx1;
+typedef _Complex long long int Talx1cllong atalx1;
+typedef _Complex unsigned long long int Talx1cullong atalx1;
+#endif
+typedef float Talx1float atalx1;
+typedef double Talx1double atalx1;
+typedef long double Talx1ldouble atalx1;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Talx1Decimal32 atalx1;
+typedef _Decimal64 Talx1Decimal64 atalx1;
+typedef _Decimal128 Talx1Decimal128 atalx1;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Talx1cfloat atalx1;
+typedef _Complex double Talx1cdouble atalx1;
+typedef _Complex long double Talx1cldouble atalx1;
+#endif
+typedef bool Talx1bool atalx1;
+typedef enum E0 Talx1E0 atalx1;
+typedef enum E1 Talx1E1 atalx1;
+typedef enum E2 Talx1E2 atalx1;
+typedef enum E3 Talx1E3 atalx1;
+typedef enum E4 Talx1E4 atalx1;
+typedef enum E5 Talx1E5 atalx1;
+typedef enum E6 Talx1E6 atalx1;
+typedef enum E7 Talx1E7 atalx1;
+typedef enum E8 Talx1E8 atalx1;
+typedef enum E9 Talx1E9 atalx1;
+typedef void *Talx1ptr atalx1;
+typedef char *Talx1cptr atalx1;
+typedef int *Talx1iptr atalx1;
+typedef short int Talx2short atalx2;
+typedef unsigned short int Talx2ushort atalx2;
+typedef int Talx2int atalx2;
+typedef unsigned int Talx2uint atalx2;
+typedef long int Talx2long atalx2;
+typedef unsigned long int Talx2ulong atalx2;
+typedef long long int Talx2llong atalx2;
+typedef unsigned long long int Talx2ullong atalx2;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex char Talx2cchar atalx2;
+typedef _Complex signed char Talx2cschar atalx2;
+typedef _Complex unsigned char Talx2cuchar atalx2;
+typedef _Complex short int Talx2cshort atalx2;
+typedef _Complex unsigned short int Talx2cushort atalx2;
+typedef _Complex int Talx2cint atalx2;
+typedef _Complex unsigned int Talx2cuint atalx2;
+typedef _Complex long int Talx2clong atalx2;
+typedef _Complex unsigned long int Talx2culong atalx2;
+typedef _Complex long long int Talx2cllong atalx2;
+typedef _Complex unsigned long long int Talx2cullong atalx2;
+#endif
+typedef float Talx2float atalx2;
+typedef double Talx2double atalx2;
+typedef long double Talx2ldouble atalx2;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Talx2Decimal32 atalx2;
+typedef _Decimal64 Talx2Decimal64 atalx2;
+typedef _Decimal128 Talx2Decimal128 atalx2;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Talx2cfloat atalx2;
+typedef _Complex double Talx2cdouble atalx2;
+typedef _Complex long double Talx2cldouble atalx2;
+#endif
+typedef enum E0 Talx2E0 atalx2;
+typedef enum E1 Talx2E1 atalx2;
+typedef enum E2 Talx2E2 atalx2;
+typedef enum E3 Talx2E3 atalx2;
+typedef enum E4 Talx2E4 atalx2;
+typedef enum E5 Talx2E5 atalx2;
+typedef enum E6 Talx2E6 atalx2;
+typedef enum E7 Talx2E7 atalx2;
+typedef enum E8 Talx2E8 atalx2;
+typedef enum E9 Talx2E9 atalx2;
+typedef void *Talx2ptr atalx2;
+typedef char *Talx2cptr atalx2;
+typedef int *Talx2iptr atalx2;
+typedef int Talx4int atalx4;
+typedef unsigned int Talx4uint atalx4;
+typedef long int Talx4long atalx4;
+typedef unsigned long int Talx4ulong atalx4;
+typedef long long int Talx4llong atalx4;
+typedef unsigned long long int Talx4ullong atalx4;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex short int Talx4cshort atalx4;
+typedef _Complex unsigned short int Talx4cushort atalx4;
+typedef _Complex int Talx4cint atalx4;
+typedef _Complex unsigned int Talx4cuint atalx4;
+typedef _Complex long int Talx4clong atalx4;
+typedef _Complex unsigned long int Talx4culong atalx4;
+typedef _Complex long long int Talx4cllong atalx4;
+typedef _Complex unsigned long long int Talx4cullong atalx4;
+#endif
+typedef float Talx4float atalx4;
+typedef double Talx4double atalx4;
+typedef long double Talx4ldouble atalx4;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal32 Talx4Decimal32 atalx4;
+typedef _Decimal64 Talx4Decimal64 atalx4;
+typedef _Decimal128 Talx4Decimal128 atalx4;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Talx4cfloat atalx4;
+typedef _Complex double Talx4cdouble atalx4;
+typedef _Complex long double Talx4cldouble atalx4;
+#endif
+typedef enum E0 Talx4E0 atalx4;
+typedef enum E1 Talx4E1 atalx4;
+typedef enum E2 Talx4E2 atalx4;
+typedef enum E3 Talx4E3 atalx4;
+typedef enum E4 Talx4E4 atalx4;
+typedef enum E5 Talx4E5 atalx4;
+typedef enum E6 Talx4E6 atalx4;
+typedef enum E7 Talx4E7 atalx4;
+typedef enum E8 Talx4E8 atalx4;
+typedef enum E9 Talx4E9 atalx4;
+typedef void *Talx4ptr atalx4;
+typedef char *Talx4cptr atalx4;
+typedef int *Talx4iptr atalx4;
+typedef long int Taly8long ataly8;
+typedef unsigned long int Taly8ulong ataly8;
+typedef long long int Talx8llong atalx8;
+typedef unsigned long long int Talx8ullong atalx8;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex int Talx8cint atalx8;
+typedef _Complex unsigned int Talx8cuint atalx8;
+typedef _Complex long int Talx8clong atalx8;
+typedef _Complex unsigned long int Talx8culong atalx8;
+typedef _Complex long long int Talx8cllong atalx8;
+typedef _Complex unsigned long long int Talx8cullong atalx8;
+#endif
+typedef double Talx8double atalx8;
+typedef long double Talx8ldouble atalx8;
+#ifndef SKIP_DECIMAL_FLOAT
+typedef _Decimal64 Talx8Decimal64 atalx8;
+typedef _Decimal128 Talx8Decimal128 atalx8;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex float Talx8cfloat atalx8;
+typedef _Complex double Talx8cdouble atalx8;
+typedef _Complex long double Talx8cldouble atalx8;
+#endif
+typedef void *Taly8ptr ataly8;
+typedef char *Taly8cptr ataly8;
+typedef int *Taly8iptr ataly8;
+#ifndef SKIP_COMPLEX_INT
+typedef _Complex long int Taly16clong ataly16;
+typedef _Complex unsigned long int Taly16culong ataly16;
+typedef _Complex long long int Talx16cllong atalx16;
+typedef _Complex unsigned long long int Talx16cullong atalx16;
+#endif
+#ifndef SKIP_COMPLEX
+typedef _Complex double Talx16cdouble atalx16;
+typedef _Complex long double Talx16cldouble atalx16;
+#endif
+typedef int (*Tfnptr) (void);
+
+/* Bitfield macros.  In C, it is invalid to use numbers larger
+   than type's bitsize, but we don't know the size when generating
+   the testcases.  */
+#define BN8(n) ((((n) - 1) & 7) + 1)
+#define BN16(n) ((((n) - 1) & 15) + 1)
+#define BN32(n) ((((n) - 1) & 31) + 1)
+#define BN64(n) ((((n) - 1) & 63) + 1)
+#define BCN(n) BN8 (n)
+#if USHRT_MAX == 255
+# define BSN(n) BN8 (n)
+#elif USHRT_MAX == 65535
+# define BSN(n) BN16 (n)
+#elif USHRT_MAX == 4294967295U
+# define BSN(n) BN32 (n)
+#elif USHRT_MAX == 18446744073709551615ULL
+# define BSN(n) BN64 (n)
+#endif
+#if UINT_MAX == 255
+# define BIN(n) BN8 (n)
+#elif UINT_MAX == 65535
+# define BIN(n) BN16 (n)
+#elif UINT_MAX == 4294967295U
+# define BIN(n) BN32 (n)
+#elif UINT_MAX == 18446744073709551615ULL
+# define BIN(n) BN64 (n)
+#endif
+#if ULONG_MAX == 255
+# define BLN(n) BN8 (n)
+#elif ULONG_MAX == 65535
+# define BLN(n) BN16 (n)
+#elif ULONG_MAX == 4294967295U
+# define BLN(n) BN32 (n)
+#elif ULONG_MAX == 18446744073709551615ULL
+# define BLN(n) BN64 (n)
+#endif
+#if ULONG_MAX == 255
+# define BLN(n) BN8 (n)
+#elif ULONG_MAX == 65535
+# define BLN(n) BN16 (n)
+#elif ULONG_MAX == 4294967295U
+# define BLN(n) BN32 (n)
+#elif ULONG_MAX == 18446744073709551615ULL
+# define BLN(n) BN64 (n)
+#endif
+#if !defined ULLONG_MAX && defined __LONG_LONG_MAX__
+# define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1ULL)
+#endif
+#if ULLONG_MAX == 255
+# define BQN(n) BN8 (n)
+#elif ULLONG_MAX == 65535
+# define BQN(n) BN16 (n)
+#elif ULLONG_MAX == 4294967295U
+# define BQN(n) BN32 (n)
+#elif ULLONG_MAX == 18446744073709551615ULL
+# define BQN(n) BN64 (n)
+#endif
+
+#define T(n, fields, ops) TX(n, struct, , fields, ({ ops });)
+#define U(n, fields, ops) TX(n, union, , fields, ({ ops });)
+#ifdef SKIP_COMPLEX_INT
+#define TXCI(n, type, attrs, fields, ops)
+#define TCI(n, fields, ops)
+#define UCI(n, fields, ops)
+#else
+#define TXCI(n, type, attrs, fields, ops) TX(n, type, attrs, fields, ({ ops });)
+#define TCI(n, fields, ops) TX(n, struct, , fields, ({ ops });)
+#define UCI(n, fields, ops) TX(n, union, , fields, ({ ops });)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_generate.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_generate.c
new file mode 100644
index 000000000..f563c2774
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_generate.c
@@ -0,0 +1,2086 @@
+/* Structure layout test generator.
+   Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Contributed by Jakub Jelinek <jakub@redhat.com>.
+
+This file is part of GCC.
+
+GCC 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, or (at your option) any later
+version.
+
+GCC 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/>.  */
+
+
+/* Compile with gcc -o struct-layout-1_generate{,.c} generate_random{,_r}.c */
+
+/* N.B. -- This program cannot use libiberty as that will not work
+   when testing an installed compiler.  */
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+/* We use our own pseudo-random number generator, so that it gives the same
+   values on all hosts.  */
+#include "generate-random.h"
+
+#if LLONG_MAX != 9223372036854775807LL && __LONG_LONG_MAX__ != 9223372036854775807LL
+# error Need 64-bit long long
+#endif
+
+#if defined __MSVCRT__ 
+#define COMPAT_PRLL "I64"
+#else 
+#define COMPAT_PRLL "ll"
+#endif
+
+const char *dg_options[] = {
+"/* { dg-options \"%s-I%s\" } */\n",
+"/* { dg-options \"%s-I%s -Wno-abi\" } */\n",
+"/* { dg-options \"%s-I%s -mno-mmx -Wno-abi\" { target i?86-*-* x86_64-*-* } } */\n",
+"/* { dg-options \"%s-I%s -fno-common\" { target hppa*-*-hpux* powerpc*-*-darwin* *-*-mingw32* *-*-cygwin* } } */\n",
+"/* { dg-options \"%s-I%s -mno-mmx -fno-common -Wno-abi\" { target i?86-*-darwin* x86_64-*-darwin* } } */\n",
+"/* { dg-options \"%s-I%s -mno-base-addresses\" { target mmix-*-* } } */\n",
+"/* { dg-options \"%s-I%s -mlongcalls -mtext-section-literals\" { target xtensa*-*-* } } */\n"
+#define NDG_OPTIONS (sizeof (dg_options) / sizeof (dg_options[0]))
+};
+
+typedef unsigned int hashval_t;
+
+enum TYPE
+{
+  TYPE_INT,
+  TYPE_UINT,
+  TYPE_CINT,
+  TYPE_CUINT,
+  TYPE_FLOAT,
+  TYPE_CFLOAT,
+  TYPE_DEC_FLOAT,
+  TYPE_SENUM,
+  TYPE_UENUM,
+  TYPE_PTR,
+  TYPE_FNPTR,
+  TYPE_OTHER
+};
+
+struct types
+{
+  const char *name;
+  enum TYPE type;
+  unsigned long long int maxval;
+  char bitfld;
+};
+
+struct types base_types[] = {
+/* As we don't know whether char will be signed or not, just limit ourselves
+   to unsigned values less than maximum signed char value.  */
+{ "char", TYPE_UINT, 127, 'C' },
+{ "signed char", TYPE_INT, 127, 'C' },
+{ "unsigned char", TYPE_UINT, 255, 'C' },
+{ "short int", TYPE_INT, 32767, 'S' },
+{ "unsigned short int", TYPE_UINT, 65535, 'S' },
+{ "int", TYPE_INT, 2147483647, 'I' },
+{ "unsigned int", TYPE_UINT, 4294967295U, 'I' },
+{ "long int", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "unsigned long int", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "long long int", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "unsigned long long int", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "bool", TYPE_UINT, 1, 'B' },
+{ "void *", TYPE_PTR, 0, 0 },
+{ "char *", TYPE_PTR, 0, 0 },
+{ "int *", TYPE_PTR, 0, 0 },
+{ "float", TYPE_FLOAT, 0, 0 },
+{ "double", TYPE_FLOAT, 0, 0 },
+{ "long double", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "_Decimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "_Decimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "_Decimal128", TYPE_DEC_FLOAT, 0, 0 },
+#define NTYPES1 21
+#else
+#define NTYPES1 18
+#endif
+{ "Tchar", TYPE_UINT, 127, 'C' },
+{ "Tschar", TYPE_INT, 127, 'C' },
+{ "Tuchar", TYPE_UINT, 255, 'C' },
+{ "Tshort", TYPE_INT, 32767, 'S' },
+{ "Tushort", TYPE_UINT, 65535, 'S' },
+{ "Tint", TYPE_INT, 2147483647, 'I' },
+{ "Tuint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tlong", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Tulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Tllong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Tullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Tbool", TYPE_UINT, 1, 'B' },
+{ "size_t", TYPE_UINT, 18446744073709551615ULL, 0 },
+{ "Tptr", TYPE_PTR, 0, 0 },
+{ "Tcptr", TYPE_PTR, 0, 0 },
+{ "Tiptr", TYPE_PTR, 0, 0 },
+{ "Tfnptr", TYPE_FNPTR, 0, 0 },
+{ "Tfloat", TYPE_FLOAT, 0, 0 },
+{ "Tdouble", TYPE_FLOAT, 0, 0 },
+{ "Tldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "TDecimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "TDecimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "TDecimal128", TYPE_DEC_FLOAT, 0, 0 },
+#endif
+{ "enum E0", TYPE_UENUM, 0, ' ' },
+{ "enum E1", TYPE_UENUM, 1, ' ' },
+{ "enum E2", TYPE_SENUM, 3, ' ' },
+{ "enum E3", TYPE_SENUM, 127, ' ' },
+{ "enum E4", TYPE_UENUM, 255, ' ' },
+{ "enum E5", TYPE_SENUM, 32767, ' ' },
+{ "enum E6", TYPE_UENUM, 65535, ' ' },
+{ "enum E7", TYPE_SENUM, 2147483647, ' ' },
+{ "enum E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "enum E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "TE0", TYPE_UENUM, 0, ' ' },
+{ "TE1", TYPE_UENUM, 1, ' ' },
+{ "TE2", TYPE_SENUM, 3, ' ' },
+{ "TE3", TYPE_SENUM, 127, ' ' },
+{ "TE4", TYPE_UENUM, 255, ' ' },
+{ "TE5", TYPE_SENUM, 32767, ' ' },
+{ "TE6", TYPE_UENUM, 65535, ' ' },
+{ "TE7", TYPE_SENUM, 2147483647, ' ' },
+{ "TE8", TYPE_UENUM, 4294967295U, ' ' },
+{ "TE9", TYPE_SENUM, 1099511627775LL, ' ' },
+/* vector-defs.h typedefs */
+{ "qi", TYPE_INT, 127, 0 },
+{ "hi", TYPE_INT, 32767, 0 },
+{ "si", TYPE_INT, 2147483647, 0 },
+{ "di", TYPE_INT, 9223372036854775807LL, 0 },
+{ "sf", TYPE_FLOAT, 0, 0 },
+{ "df", TYPE_FLOAT, 0, 0 }
+#define NTYPES2 (sizeof (base_types) / sizeof (base_types[0]))
+};
+struct types complex_types[] = {
+{ "_Complex char", TYPE_CUINT, 127, 0 },
+{ "_Complex signed char", TYPE_CINT, 127, 0 },
+{ "_Complex unsigned char", TYPE_CUINT, 255, 0 },
+{ "_Complex short int", TYPE_CINT, 32767, 0 },
+{ "_Complex unsigned short int", TYPE_CUINT, 65535, 0 },
+{ "_Complex int", TYPE_CINT, 2147483647, 0 },
+{ "_Complex unsigned int", TYPE_CUINT, 4294967295U, 0 },
+{ "_Complex long int", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "_Complex unsigned long int", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "_Complex long long int", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "_Complex unsigned long long int", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "_Complex float", TYPE_CFLOAT, 0, 0 },
+{ "_Complex double", TYPE_CFLOAT, 0, 0 },
+{ "_Complex long double", TYPE_CFLOAT, 0, 0 },
+{ "Tcchar", TYPE_CUINT, 127, 0 },
+{ "Tcschar", TYPE_CINT, 127, 0 },
+{ "Tcuchar", TYPE_CUINT, 255, 0 },
+{ "Tcshort", TYPE_CINT, 32767, 0 },
+{ "Tcushort", TYPE_CUINT, 65535, 0 },
+{ "Tcint", TYPE_CINT, 2147483647, 0 },
+{ "Tcuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Tclong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tculong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tcllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tcullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tcfloat", TYPE_CFLOAT, 0, 0 },
+{ "Tcdouble", TYPE_CFLOAT, 0, 0 },
+{ "Tcldouble", TYPE_CFLOAT, 0, 0 }
+#define NCTYPES2 (sizeof (complex_types) / sizeof (complex_types[0]))
+};
+struct types vector_types[] = {
+/* vector-defs.h typedefs */
+{ "v8qi", TYPE_OTHER, 0, 0 },
+{ "v16qi", TYPE_OTHER, 0, 0 },
+{ "v32qi", TYPE_OTHER, 0, 0 },
+{ "v2hi", TYPE_OTHER, 0, 0 },
+{ "v4hi", TYPE_OTHER, 0, 0 },
+{ "v8hi", TYPE_OTHER, 0, 0 },
+{ "v16hi", TYPE_OTHER, 0, 0 },
+{ "v2si", TYPE_OTHER, 0, 0 },
+{ "v4si", TYPE_OTHER, 0, 0 },
+{ "v8si", TYPE_OTHER, 0, 0 },
+{ "v1di", TYPE_OTHER, 0, 0 },
+{ "v2di", TYPE_OTHER, 0, 0 },
+{ "v4di", TYPE_OTHER, 0, 0 },
+{ "v2sf", TYPE_OTHER, 0, 0 },
+{ "v4sf", TYPE_OTHER, 0, 0 },
+{ "v8sf", TYPE_OTHER, 0, 0 },
+{ "v16sf", TYPE_OTHER, 0, 0 },
+{ "v2df", TYPE_OTHER, 0, 0 },
+{ "v4df", TYPE_OTHER, 0, 0 },
+{ "u8qi", TYPE_OTHER, 0, 0 },
+{ "u16qi", TYPE_OTHER, 0, 0 },
+{ "u32qi", TYPE_OTHER, 0, 0 },
+{ "u2hi", TYPE_OTHER, 0, 0 },
+{ "u4hi", TYPE_OTHER, 0, 0 },
+{ "u8hi", TYPE_OTHER, 0, 0 },
+{ "u16hi", TYPE_OTHER, 0, 0 },
+{ "u2si", TYPE_OTHER, 0, 0 },
+{ "u4si", TYPE_OTHER, 0, 0 },
+{ "u8si", TYPE_OTHER, 0, 0 },
+{ "u1di", TYPE_OTHER, 0, 0 },
+{ "u2di", TYPE_OTHER, 0, 0 },
+{ "u4di", TYPE_OTHER, 0, 0 },
+{ "u2sf", TYPE_OTHER, 0, 0 },
+{ "u4sf", TYPE_OTHER, 0, 0 },
+{ "u8sf", TYPE_OTHER, 0, 0 },
+{ "u16sf", TYPE_OTHER, 0, 0 },
+{ "u2df", TYPE_OTHER, 0, 0 },
+{ "u4df", TYPE_OTHER, 0, 0 },
+{ "__m64", TYPE_OTHER, 0, 0 },
+{ "__m128", TYPE_OTHER, 0, 0 }
+#define NVTYPES2 (sizeof (vector_types) / sizeof (vector_types[0]))
+};
+struct types attrib_types[] = {
+{ "Talchar", TYPE_UINT, 127, 'C' },
+{ "Talschar", TYPE_INT, 127, 'C' },
+{ "Taluchar", TYPE_UINT, 255, 'C' },
+{ "Talshort", TYPE_INT, 32767, 'S' },
+{ "Talushort", TYPE_UINT, 65535, 'S' },
+{ "Talint", TYPE_INT, 2147483647, 'I' },
+{ "Taluint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tallong", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Talulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Talllong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Talullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Talbool", TYPE_UINT, 1, 'B' },
+{ "Talptr", TYPE_PTR, 0, 0 },
+{ "Talcptr", TYPE_PTR, 0, 0 },
+{ "Taliptr", TYPE_PTR, 0, 0 },
+{ "Talfloat", TYPE_FLOAT, 0, 0 },
+{ "Taldouble", TYPE_FLOAT, 0, 0 },
+{ "Talldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "TalDecimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "TalDecimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "TalDecimal128", TYPE_DEC_FLOAT, 0, 0 },
+#endif
+{ "TalE0", TYPE_UENUM, 0, ' ' },
+{ "TalE1", TYPE_UENUM, 1, ' ' },
+{ "TalE2", TYPE_SENUM, 3, ' ' },
+{ "TalE3", TYPE_SENUM, 127, ' ' },
+{ "TalE4", TYPE_UENUM, 255, ' ' },
+{ "TalE5", TYPE_SENUM, 32767, ' ' },
+{ "TalE6", TYPE_UENUM, 65535, ' ' },
+{ "TalE7", TYPE_SENUM, 2147483647, ' ' },
+{ "TalE8", TYPE_UENUM, 4294967295U, ' ' },
+{ "TalE9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Tal1char", TYPE_UINT, 127, 'C' },
+{ "Tal1schar", TYPE_INT, 127, 'C' },
+{ "Tal1uchar", TYPE_UINT, 255, 'C' },
+{ "Tal1short", TYPE_INT, 32767, 'S' },
+{ "Tal1ushort", TYPE_UINT, 65535, 'S' },
+{ "Tal1int", TYPE_INT, 2147483647, 'I' },
+{ "Tal1uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tal1long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Tal1ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Tal1llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Tal1ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Tal1bool", TYPE_UINT, 1, 'B' },
+{ "Tal1ptr", TYPE_PTR, 0, 0 },
+{ "Tal1cptr", TYPE_PTR, 0, 0 },
+{ "Tal1iptr", TYPE_PTR, 0, 0 },
+{ "Tal1float", TYPE_FLOAT, 0, 0 },
+{ "Tal1double", TYPE_FLOAT, 0, 0 },
+{ "Tal1ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Tal1Decimal32", TYPE_DEC_FLOAT, 0, 0},
+{ "Tal1Decimal64", TYPE_DEC_FLOAT, 0, 0},
+{ "Tal1Decimal128", TYPE_DEC_FLOAT, 0, 0},
+#endif
+{ "Tal1E0", TYPE_UENUM, 0, ' ' },
+{ "Tal1E1", TYPE_UENUM, 1, ' ' },
+{ "Tal1E2", TYPE_SENUM, 3, ' ' },
+{ "Tal1E3", TYPE_SENUM, 127, ' ' },
+{ "Tal1E4", TYPE_UENUM, 255, ' ' },
+{ "Tal1E5", TYPE_SENUM, 32767, ' ' },
+{ "Tal1E6", TYPE_UENUM, 65535, ' ' },
+{ "Tal1E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Tal1E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Tal1E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Tal2char", TYPE_UINT, 127, 'C' },
+{ "Tal2schar", TYPE_INT, 127, 'C' },
+{ "Tal2uchar", TYPE_UINT, 255, 'C' },
+{ "Tal2short", TYPE_INT, 32767, 'S' },
+{ "Tal2ushort", TYPE_UINT, 65535, 'S' },
+{ "Tal2int", TYPE_INT, 2147483647, 'I' },
+{ "Tal2uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tal2long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Tal2ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Tal2llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Tal2ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Tal2bool", TYPE_UINT, 1, 'B' },
+{ "Tal2ptr", TYPE_PTR, 0, 0 },
+{ "Tal2cptr", TYPE_PTR, 0, 0 },
+{ "Tal2iptr", TYPE_PTR, 0, 0 },
+{ "Tal2float", TYPE_FLOAT, 0, 0 },
+{ "Tal2double", TYPE_FLOAT, 0, 0 },
+{ "Tal2ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Tal2Decimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal2Decimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal2Decimal128", TYPE_DEC_FLOAT, 0, 0 },
+#endif
+{ "Tal2E0", TYPE_UENUM, 0, ' ' },
+{ "Tal2E1", TYPE_UENUM, 1, ' ' },
+{ "Tal2E2", TYPE_SENUM, 3, ' ' },
+{ "Tal2E3", TYPE_SENUM, 127, ' ' },
+{ "Tal2E4", TYPE_UENUM, 255, ' ' },
+{ "Tal2E5", TYPE_SENUM, 32767, ' ' },
+{ "Tal2E6", TYPE_UENUM, 65535, ' ' },
+{ "Tal2E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Tal2E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Tal2E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Tal4char", TYPE_UINT, 127, 'C' },
+{ "Tal4schar", TYPE_INT, 127, 'C' },
+{ "Tal4uchar", TYPE_UINT, 255, 'C' },
+{ "Tal4short", TYPE_INT, 32767, 'S' },
+{ "Tal4ushort", TYPE_UINT, 65535, 'S' },
+{ "Tal4int", TYPE_INT, 2147483647, 'I' },
+{ "Tal4uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tal4long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Tal4ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Tal4llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Tal4ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Tal4bool", TYPE_UINT, 1, 'B' },
+{ "Tal4ptr", TYPE_PTR, 0, 0 },
+{ "Tal4cptr", TYPE_PTR, 0, 0 },
+{ "Tal4iptr", TYPE_PTR, 0, 0 },
+{ "Tal4float", TYPE_FLOAT, 0, 0 },
+{ "Tal4double", TYPE_FLOAT, 0, 0 },
+{ "Tal4ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Tal4Decimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal4Decimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal4Decimal128", TYPE_DEC_FLOAT, 0, 0 },
+#endif
+{ "Tal4E0", TYPE_UENUM, 0, ' ' },
+{ "Tal4E1", TYPE_UENUM, 1, ' ' },
+{ "Tal4E2", TYPE_SENUM, 3, ' ' },
+{ "Tal4E3", TYPE_SENUM, 127, ' ' },
+{ "Tal4E4", TYPE_UENUM, 255, ' ' },
+{ "Tal4E5", TYPE_SENUM, 32767, ' ' },
+{ "Tal4E6", TYPE_UENUM, 65535, ' ' },
+{ "Tal4E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Tal4E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Tal4E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Tal8char", TYPE_UINT, 127, 'C' },
+{ "Tal8schar", TYPE_INT, 127, 'C' },
+{ "Tal8uchar", TYPE_UINT, 255, 'C' },
+{ "Tal8short", TYPE_INT, 32767, 'S' },
+{ "Tal8ushort", TYPE_UINT, 65535, 'S' },
+{ "Tal8int", TYPE_INT, 2147483647, 'I' },
+{ "Tal8uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tal8long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Tal8ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Tal8llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Tal8ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Tal8bool", TYPE_UINT, 1, 'B' },
+{ "Tal8ptr", TYPE_PTR, 0, 0 },
+{ "Tal8cptr", TYPE_PTR, 0, 0 },
+{ "Tal8iptr", TYPE_PTR, 0, 0 },
+{ "Tal8float", TYPE_FLOAT, 0, 0 },
+{ "Tal8double", TYPE_FLOAT, 0, 0 },
+{ "Tal8ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Tal8Decimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal8Decimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal8Decimal128", TYPE_DEC_FLOAT, 0, 0 },
+#endif
+{ "Tal8E0", TYPE_UENUM, 0, ' ' },
+{ "Tal8E1", TYPE_UENUM, 1, ' ' },
+{ "Tal8E2", TYPE_SENUM, 3, ' ' },
+{ "Tal8E3", TYPE_SENUM, 127, ' ' },
+{ "Tal8E4", TYPE_UENUM, 255, ' ' },
+{ "Tal8E5", TYPE_SENUM, 32767, ' ' },
+{ "Tal8E6", TYPE_UENUM, 65535, ' ' },
+{ "Tal8E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Tal8E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Tal8E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Tal16char", TYPE_UINT, 127, 'C' },
+{ "Tal16schar", TYPE_INT, 127, 'C' },
+{ "Tal16uchar", TYPE_UINT, 255, 'C' },
+{ "Tal16short", TYPE_INT, 32767, 'S' },
+{ "Tal16ushort", TYPE_UINT, 65535, 'S' },
+{ "Tal16int", TYPE_INT, 2147483647, 'I' },
+{ "Tal16uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Tal16long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Tal16ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Tal16llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Tal16ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Tal16bool", TYPE_UINT, 1, 'B' },
+{ "Tal16ptr", TYPE_PTR, 0, 0 },
+{ "Tal16cptr", TYPE_PTR, 0, 0 },
+{ "Tal16iptr", TYPE_PTR, 0, 0 },
+{ "Tal16float", TYPE_FLOAT, 0, 0 },
+{ "Tal16double", TYPE_FLOAT, 0, 0 },
+{ "Tal16ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Tal16Decimal32", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal16Decimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "Tal16Decimal128", TYPE_DEC_FLOAT, 0, 0 },
+#endif
+{ "Tal16E0", TYPE_UENUM, 0, ' ' },
+{ "Tal16E1", TYPE_UENUM, 1, ' ' },
+{ "Tal16E2", TYPE_SENUM, 3, ' ' },
+{ "Tal16E3", TYPE_SENUM, 127, ' ' },
+{ "Tal16E4", TYPE_UENUM, 255, ' ' },
+{ "Tal16E5", TYPE_SENUM, 32767, ' ' },
+{ "Tal16E6", TYPE_UENUM, 65535, ' ' },
+{ "Tal16E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Tal16E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Tal16E9", TYPE_SENUM, 1099511627775LL, ' ' }
+#define NATYPES2 (sizeof (attrib_types) / sizeof (attrib_types[0]))
+};
+struct types complex_attrib_types[] = {
+{ "Talcchar", TYPE_CUINT, 127, 0 },
+{ "Talcschar", TYPE_CINT, 127, 0 },
+{ "Talcuchar", TYPE_CUINT, 255, 0 },
+{ "Talcshort", TYPE_CINT, 32767, 0 },
+{ "Talcushort", TYPE_CUINT, 65535, 0 },
+{ "Talcint", TYPE_CINT, 2147483647, 0 },
+{ "Talcuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Talclong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talculong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talcllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talcullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talcfloat", TYPE_CFLOAT, 0, 0 },
+{ "Talcdouble", TYPE_CFLOAT, 0, 0 },
+{ "Talcldouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal1cchar", TYPE_CUINT, 127, 0 },
+{ "Tal1cschar", TYPE_CINT, 127, 0 },
+{ "Tal1cuchar", TYPE_CUINT, 255, 0 },
+{ "Tal1cshort", TYPE_CINT, 32767, 0 },
+{ "Tal1cushort", TYPE_CUINT, 65535, 0 },
+{ "Tal1cint", TYPE_CINT, 2147483647, 0 },
+{ "Tal1cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Tal1clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal1culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal1cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal1cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal1cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Tal1cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal1cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal2cchar", TYPE_CUINT, 127, 0 },
+{ "Tal2cschar", TYPE_CINT, 127, 0 },
+{ "Tal2cuchar", TYPE_CUINT, 255, 0 },
+{ "Tal2cshort", TYPE_CINT, 32767, 0 },
+{ "Tal2cushort", TYPE_CUINT, 65535, 0 },
+{ "Tal2cint", TYPE_CINT, 2147483647, 0 },
+{ "Tal2cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Tal2clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal2culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal2cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal2cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal2cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Tal2cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal2cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal4cchar", TYPE_CUINT, 127, 0 },
+{ "Tal4cschar", TYPE_CINT, 127, 0 },
+{ "Tal4cuchar", TYPE_CUINT, 255, 0 },
+{ "Tal4cshort", TYPE_CINT, 32767, 0 },
+{ "Tal4cushort", TYPE_CUINT, 65535, 0 },
+{ "Tal4cint", TYPE_CINT, 2147483647, 0 },
+{ "Tal4cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Tal4clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal4culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal4cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal4cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal4cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Tal4cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal4cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal8cchar", TYPE_CUINT, 127, 0 },
+{ "Tal8cschar", TYPE_CINT, 127, 0 },
+{ "Tal8cuchar", TYPE_CUINT, 255, 0 },
+{ "Tal8cshort", TYPE_CINT, 32767, 0 },
+{ "Tal8cushort", TYPE_CUINT, 65535, 0 },
+{ "Tal8cint", TYPE_CINT, 2147483647, 0 },
+{ "Tal8cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Tal8clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal8culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal8cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal8cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal8cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Tal8cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal8cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal16cchar", TYPE_CUINT, 127, 0 },
+{ "Tal16cschar", TYPE_CINT, 127, 0 },
+{ "Tal16cuchar", TYPE_CUINT, 255, 0 },
+{ "Tal16cshort", TYPE_CINT, 32767, 0 },
+{ "Tal16cushort", TYPE_CUINT, 65535, 0 },
+{ "Tal16cint", TYPE_CINT, 2147483647, 0 },
+{ "Tal16cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Tal16clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal16culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal16cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Tal16cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Tal16cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Tal16cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Tal16cldouble", TYPE_CFLOAT, 0, 0 }
+#define NCATYPES2 (sizeof (complex_attrib_types) / sizeof (complex_attrib_types[0]))
+};
+struct types attrib_array_types[] = {
+{ "Talx1char", TYPE_UINT, 127, 'C' },
+{ "Talx1schar", TYPE_INT, 127, 'C' },
+{ "Talx1uchar", TYPE_UINT, 255, 'C' },
+{ "Talx1short", TYPE_INT, 32767, 'S' },
+{ "Talx1ushort", TYPE_UINT, 65535, 'S' },
+{ "Talx1int", TYPE_INT, 2147483647, 'I' },
+{ "Talx1uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Talx1long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Talx1ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Talx1llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Talx1ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Talx1bool", TYPE_UINT, 1, 'B' },
+{ "Talx1ptr", TYPE_PTR, 0, 0 },
+{ "Talx1cptr", TYPE_PTR, 0, 0 },
+{ "Talx1iptr", TYPE_PTR, 0, 0 },
+{ "Talx1float", TYPE_FLOAT, 0, 0 },
+{ "Talx1double", TYPE_FLOAT, 0, 0 },
+{ "Talx1ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Talx1Decimal32", TYPE_DEC_FLOAT, 0 ,0 },
+{ "Talx1Decimal64", TYPE_DEC_FLOAT, 0 ,0 },
+{ "Talx1Decimal128", TYPE_DEC_FLOAT, 0 ,0 },
+#endif
+{ "Talx1E0", TYPE_UENUM, 0, ' ' },
+{ "Talx1E1", TYPE_UENUM, 1, ' ' },
+{ "Talx1E2", TYPE_SENUM, 3, ' ' },
+{ "Talx1E3", TYPE_SENUM, 127, ' ' },
+{ "Talx1E4", TYPE_UENUM, 255, ' ' },
+{ "Talx1E5", TYPE_SENUM, 32767, ' ' },
+{ "Talx1E6", TYPE_UENUM, 65535, ' ' },
+{ "Talx1E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Talx1E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Talx1E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Talx2short", TYPE_INT, 32767, 'S' },
+{ "Talx2ushort", TYPE_UINT, 65535, 'S' },
+{ "Talx2int", TYPE_INT, 2147483647, 'I' },
+{ "Talx2uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Talx2long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Talx2ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Talx2llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Talx2ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Talx2ptr", TYPE_PTR, 0, 0 },
+{ "Talx2cptr", TYPE_PTR, 0, 0 },
+{ "Talx2iptr", TYPE_PTR, 0, 0 },
+{ "Talx2float", TYPE_FLOAT, 0, 0 },
+{ "Talx2double", TYPE_FLOAT, 0, 0 },
+{ "Talx2ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Talx2Decimal32", TYPE_DEC_FLOAT, 0 , 0 },
+{ "Talx2Decimal64", TYPE_DEC_FLOAT, 0 , 0 },
+{ "Talx2Decimal128", TYPE_DEC_FLOAT, 0 , 0 },
+#endif
+{ "Talx2E0", TYPE_UENUM, 0, ' ' },
+{ "Talx2E1", TYPE_UENUM, 1, ' ' },
+{ "Talx2E2", TYPE_SENUM, 3, ' ' },
+{ "Talx2E3", TYPE_SENUM, 127, ' ' },
+{ "Talx2E4", TYPE_UENUM, 255, ' ' },
+{ "Talx2E5", TYPE_SENUM, 32767, ' ' },
+{ "Talx2E6", TYPE_UENUM, 65535, ' ' },
+{ "Talx2E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Talx2E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Talx2E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Talx4int", TYPE_INT, 2147483647, 'I' },
+{ "Talx4uint", TYPE_UINT, 4294967295U, 'I' },
+{ "Talx4long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Talx4ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Talx4llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Talx4ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Talx4ptr", TYPE_PTR, 0, 0 },
+{ "Talx4cptr", TYPE_PTR, 0, 0 },
+{ "Talx4iptr", TYPE_PTR, 0, 0 },
+{ "Talx4float", TYPE_FLOAT, 0, 0 },
+{ "Talx4double", TYPE_FLOAT, 0, 0 },
+{ "Talx4ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Talx4Decimal32", TYPE_DEC_FLOAT, 0 , 0 },
+{ "Talx4Decimal64", TYPE_DEC_FLOAT, 0 , 0 },
+{ "Talx4Decimal128", TYPE_DEC_FLOAT, 0 , 0 },
+#endif
+{ "Talx4E0", TYPE_UENUM, 0, ' ' },
+{ "Talx4E1", TYPE_UENUM, 1, ' ' },
+{ "Talx4E2", TYPE_SENUM, 3, ' ' },
+{ "Talx4E3", TYPE_SENUM, 127, ' ' },
+{ "Talx4E4", TYPE_UENUM, 255, ' ' },
+{ "Talx4E5", TYPE_SENUM, 32767, ' ' },
+{ "Talx4E6", TYPE_UENUM, 65535, ' ' },
+{ "Talx4E7", TYPE_SENUM, 2147483647, ' ' },
+{ "Talx4E8", TYPE_UENUM, 4294967295U, ' ' },
+{ "Talx4E9", TYPE_SENUM, 1099511627775LL, ' ' },
+{ "Taly8long", TYPE_INT, 9223372036854775807LL, 'L' },
+{ "Taly8ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
+{ "Talx8llong", TYPE_INT, 9223372036854775807LL, 'Q' },
+{ "Talx8ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
+{ "Taly8ptr", TYPE_PTR, 0, 0 },
+{ "Taly8cptr", TYPE_PTR, 0, 0 },
+{ "Taly8iptr", TYPE_PTR, 0, 0 },
+{ "Talx8double", TYPE_FLOAT, 0, 0 },
+{ "Talx8ldouble", TYPE_FLOAT, 0, 0 },
+#ifndef SKIP_DECIMAL_FLOAT
+{ "Talx8Decimal64", TYPE_DEC_FLOAT, 0, 0 },
+{ "Talx8Decimal128", TYPE_DEC_FLOAT, 0, 0 }
+#endif
+#define NAATYPES2 (sizeof (attrib_array_types) / sizeof (attrib_array_types[0]))
+};
+struct types complex_attrib_array_types[] = {
+{ "Talx1cchar", TYPE_CUINT, 127, 0 },
+{ "Talx1cschar", TYPE_CINT, 127, 0 },
+{ "Talx1cuchar", TYPE_CUINT, 255, 0 },
+{ "Talx1cshort", TYPE_CINT, 32767, 0 },
+{ "Talx1cushort", TYPE_CUINT, 65535, 0 },
+{ "Talx1cint", TYPE_CINT, 2147483647, 0 },
+{ "Talx1cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Talx1clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx1culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx1cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx1cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx1cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Talx1cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx1cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx2cchar", TYPE_CUINT, 127, 0 },
+{ "Talx2cschar", TYPE_CINT, 127, 0 },
+{ "Talx2cuchar", TYPE_CUINT, 255, 0 },
+{ "Talx2cshort", TYPE_CINT, 32767, 0 },
+{ "Talx2cushort", TYPE_CUINT, 65535, 0 },
+{ "Talx2cint", TYPE_CINT, 2147483647, 0 },
+{ "Talx2cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Talx2clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx2culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx2cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx2cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx2cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Talx2cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx2cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx4cshort", TYPE_CINT, 32767, 0 },
+{ "Talx4cushort", TYPE_CUINT, 65535, 0 },
+{ "Talx4cint", TYPE_CINT, 2147483647, 0 },
+{ "Talx4cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Talx4clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx4culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx4cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx4cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx4cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Talx4cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx4cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx8cint", TYPE_CINT, 2147483647, 0 },
+{ "Talx8cuint", TYPE_CUINT, 4294967295U, 0 },
+{ "Talx8clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx8culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx8cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx8cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx8cfloat", TYPE_CFLOAT, 0, 0 },
+{ "Talx8cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx8cldouble", TYPE_CFLOAT, 0, 0 },
+{ "Taly16clong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Taly16culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx16cllong", TYPE_CINT, 9223372036854775807LL, 0 },
+{ "Talx16cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
+{ "Talx16cdouble", TYPE_CFLOAT, 0, 0 },
+{ "Talx16cldouble", TYPE_CFLOAT, 0, 0 }
+#define NCAATYPES2 (sizeof (complex_attrib_array_types) / sizeof (complex_attrib_array_types[0]))
+};
+
+struct types bitfld_types[NTYPES2];
+int n_bitfld_types;
+struct types aligned_bitfld_types[NATYPES2];
+int n_aligned_bitfld_types;
+
+const char *attributes[] = {
+"atal", 
+"atpa", 
+"atal1", 
+"atal2", 
+"atal4", 
+"atal8", 
+"atal16", 
+#define NATTRIBS1 7
+"atalpa", 
+"atpaal", 
+"atal1pa", 
+"atal2pa", 
+"atal4pa", 
+"atal8pa", 
+"atal16pa", 
+"atpaal1", 
+"atpaal2", 
+"atpaal4", 
+"atpaal8", 
+"atpaal16"
+#define NATTRIBS2 (sizeof (attributes) / sizeof (attributes[0]))
+};
+
+enum ETYPE
+{
+  ETYPE_TYPE,
+  ETYPE_ARRAY,
+  ETYPE_BITFLD,
+  ETYPE_STRUCT,
+  ETYPE_UNION,
+  ETYPE_STRUCT_ARRAY,
+  ETYPE_UNION_ARRAY
+};
+
+struct entry
+{
+#ifdef __GNUC__
+  enum ETYPE etype : 8;
+#else
+  unsigned char etype;
+#endif
+  unsigned short len;
+  unsigned char arr_len;
+  struct types *type;
+  const char *attrib;
+  /* Used to chain together entries in the hash table.  */
+  struct entry *next;
+};
+
+/* A prime number giving the number of slots in the hash table.  */ 
+#define HASH_SIZE 32749 
+static struct entry *hash_table[HASH_SIZE];
+
+static int idx, limidx, output_one, short_enums;
+static const char *destdir;
+static const char *srcdir;
+static const char *srcdir_safe;
+FILE *outfile;
+
+void
+switchfiles (int fields)
+{
+  static int filecnt;
+  static char *destbuf, *destptr;
+  int i;
+
+  ++filecnt;
+  if (outfile)
+    fclose (outfile);
+  if (output_one)
+    {
+      outfile = stdout;
+      return;
+    }
+  if (destbuf == NULL)
+    {
+      size_t len = strlen (destdir);
+      destbuf = malloc (len + 20);
+      if (!destbuf)
+	abort ();
+      memcpy (destbuf, destdir, len);
+      if (!len || destbuf[len - 1] != '/')
+	destbuf[len++] = '/';
+      destptr = destbuf + len;
+    }
+  sprintf (destptr, "t%03d_main.c", filecnt);
+  outfile = fopen (destbuf, "w");
+  if (outfile == NULL)
+    {
+    fail:
+      fputs ("failed to create test files\n", stderr);
+      exit (1);
+    }
+  fprintf (outfile, "/* { dg-require-effective-target int32plus } */\n");
+  for (i = 0; i < NDG_OPTIONS; i++)
+    fprintf (outfile, dg_options[i], "", srcdir_safe);
+  fprintf (outfile, "/* { dg-prune-output \".*-Wno-abi.*\" } */\n");
+  fprintf (outfile, "/* { dg-prune-output \".*Offset of packed bit-field.*\" } */\n");
+  fprintf (outfile, "\
+#include \"struct-layout-1.h\"\n\
+\n\
+#define TX(n, type, attrs, fields, ops) extern void test##n (void);\n\
+#include \"t%03d_test.h\"\n\
+#undef TX\n\
+\n\
+int main (void)\n\
+{\n\
+#define TX(n, type, attrs, fields, ops)   test##n ();\n\
+#include \"t%03d_test.h\"\n\
+#undef TX\n\
+  if (fails)\n\
+    {\n\
+      fflush (stdout);\n\
+      abort ();\n\
+    }\n\
+  exit (0);\n\
+}\n", filecnt, filecnt);
+  fclose (outfile);
+  sprintf (destptr, "t%03d_x.c", filecnt);
+  outfile = fopen (destbuf, "w");
+  if (outfile == NULL)
+    goto fail;
+  for (i = 0; i < NDG_OPTIONS; i++)
+    fprintf (outfile, dg_options[i], "-w ", srcdir_safe);
+  fprintf (outfile, "\
+#include \"struct-layout-1_x1.h\"\n\
+#include \"t%03d_test.h\"\n\
+#include \"struct-layout-1_x2.h\"\n\
+#include \"t%03d_test.h\"\n", filecnt, filecnt);
+  fclose (outfile);
+  sprintf (destptr, "t%03d_y.c", filecnt);
+  outfile = fopen (destbuf, "w");
+  if (outfile == NULL)
+    goto fail;
+  for (i = 0; i < NDG_OPTIONS; i++)
+    fprintf (outfile, dg_options[i], "-w ", srcdir_safe);
+  fprintf (outfile, "\
+#include \"struct-layout-1_y1.h\"\n\
+#include \"t%03d_test.h\"\n\
+#include \"struct-layout-1_y2.h\"\n\
+#include \"t%03d_test.h\"\n", filecnt, filecnt);
+  fclose (outfile);
+  sprintf (destptr, "t%03d_test.h", filecnt);
+  outfile = fopen (destbuf, "w");
+  if (outfile == NULL)
+    goto fail;
+  if (fields <= 2)
+    limidx = idx + 300;
+  else if (fields <= 4)
+    limidx = idx + 200;
+  else if (fields <= 6)
+    limidx = idx + 100;
+  else
+    limidx = idx + 50;
+}
+
+unsigned long long int
+getrandll (void)
+{
+  unsigned long long int ret;
+  ret = generate_random () & 0xffffff;
+  ret |= (generate_random () & 0xffffffLL) << 24;
+  ret |= ((unsigned long long int) generate_random ()) << 48;
+  return ret;
+}
+
+int
+subfield (struct entry *e, char *letter)
+{
+  int i, type;
+  char buf[20];
+  const char *p;
+  switch (e[0].etype)
+    {
+    case ETYPE_STRUCT:
+    case ETYPE_UNION:
+    case ETYPE_STRUCT_ARRAY:
+    case ETYPE_UNION_ARRAY:
+      type = e[0].attrib ? 1 + (generate_random () & 3) : 0;
+      if (e[0].etype == ETYPE_STRUCT || e[0].etype == ETYPE_STRUCT_ARRAY)
+	p = "struct";
+      else
+	p = "union";
+      if (e[0].etype == ETYPE_STRUCT_ARRAY || e[0].etype == ETYPE_UNION_ARRAY)
+	{
+	  if (e[0].arr_len == 255)
+	    snprintf (buf, 20, "%c[]", *letter);
+	  else
+	    snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len);
+	  /* If this is an array type, do not put aligned attributes on
+	     elements.  Aligning elements to a value greater than their
+	     size will result in a compiler error.  */
+	  if (type == 1
+	      && ((strncmp (e[0].attrib, "atal", 4) == 0)
+		   || strncmp (e[0].attrib, "atpaal", 6) == 0))
+	    type = 2;
+	}
+      else
+        {
+          buf[0] = *letter;
+          buf[1] = '\0';
+        }
+      ++*letter;
+      switch (type)
+        {
+        case 0:
+        case 3:
+        case 4:
+          fprintf (outfile, "%s{", p);
+          break;
+        case 1:
+          fprintf (outfile, "%s %s{", e[0].attrib, p);
+          break;
+        case 2:
+          fprintf (outfile, "%s %s{", p, e[0].attrib);
+          break;
+        }
+
+      for (i = 1; i <= e[0].len; )
+	i += subfield (e + i, letter);
+
+      switch (type)
+        {
+        case 0:
+        case 1:
+        case 2:
+          fprintf (outfile, "}%s;", buf);
+          break;
+	case 3:
+	  fprintf (outfile, "}%s %s;", e[0].attrib, buf);
+	  break;
+	case 4:
+	  fprintf (outfile, "}%s %s;", buf, e[0].attrib);
+	  break;
+        }
+      return 1 + e[0].len;
+    case ETYPE_TYPE:
+    case ETYPE_ARRAY:
+      if (e[0].etype == ETYPE_ARRAY)
+	{
+	  if (e[0].arr_len == 255)
+	    snprintf (buf, 20, "%c[]", *letter);
+	  else
+	    snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len);
+	}
+      else
+        {
+          buf[0] = *letter;
+          buf[1] = '\0';
+        }
+      ++*letter;
+      if (e[0].attrib)
+	{
+	  /* If this is an array type, do not put aligned attributes on
+	     elements.  Aligning elements to a value greater than their
+	     size will result in a compiler error.  */
+	  if (e[0].etype == ETYPE_ARRAY
+              && ((strncmp (e[0].attrib, "atal", 4) == 0)
+                   || strncmp (e[0].attrib, "atpaal", 6) == 0))
+	    type = 2;
+	  else
+            type = generate_random () % 3;
+	  switch (type)
+	    {
+	    case 0:
+	      fprintf (outfile, "%s %s %s;", e[0].attrib, e[0].type->name,
+		       buf);
+	      break;
+	    case 1:
+	      fprintf (outfile, "%s %s %s;", e[0].type->name, e[0].attrib,
+		       buf);
+	      break;
+	    case 2:
+	      fprintf (outfile, "%s %s %s;", e[0].type->name, buf,
+		       e[0].attrib);
+	      break;
+	    }
+	}
+      else
+	fprintf (outfile, "%s %s;", e[0].type->name, buf);
+      return 1;
+    case ETYPE_BITFLD:
+      if (e[0].len == 0)
+	{
+	  if (e[0].attrib)
+	    switch (generate_random () % 3)
+	      {
+	      case 0:
+		fprintf (outfile, "%s %s:0;", e[0].attrib, e[0].type->name);
+		break;
+	      case 1:
+		fprintf (outfile, "%s %s:0;", e[0].type->name, e[0].attrib);
+		break;
+	      case 2:
+		fprintf (outfile, "%s:0 %s;", e[0].type->name, e[0].attrib);
+		break;
+	      }
+	  else
+	    fprintf (outfile, "%s:0;", e[0].type->name);
+	  ++*letter;
+	  return 1;
+	}
+      switch (e[0].type->bitfld)
+	{
+	case 'C':
+	case 'S':
+	case 'I':
+	case 'L':
+	case 'Q':
+	  snprintf (buf, 20, "B%cN(%d)", e[0].type->bitfld, e[0].len);
+	  break;
+	case 'B':
+	case ' ':
+	  snprintf (buf, 20, "%d", e[0].len);
+	  break;
+	default:
+	  abort ();
+	}
+      if (e[0].attrib)
+	switch (generate_random () % 3)
+	  {
+	  case 0:
+	    fprintf (outfile, "%s %s %c:%s;", e[0].attrib, e[0].type->name,
+		     *letter, buf);
+	    break;
+	  case 1:
+	    fprintf (outfile, "%s %s %c:%s;", e[0].type->name, e[0].attrib,
+		     *letter, buf);
+	    break;
+	  case 2:
+	    fprintf (outfile, "%s %c:%s %s;", e[0].type->name, *letter,
+		     buf, e[0].attrib);
+	    break;
+	  }
+      else
+	fprintf (outfile, "%s %c:%s;", e[0].type->name, *letter, buf);
+      ++*letter;
+      return 1;
+    default:
+      abort ();
+  }
+}
+
+char namebuf[1024];
+
+void
+output_FNB (char mode, struct entry *e)
+{
+  unsigned long long int l1, l2, m;
+  int signs = 0;
+#ifndef SKIP_DECIMAL_FLOAT
+  int suffix = 0;
+  char DEC_SUFFIX[3][3]={"DF","DD","DL"};
+#endif
+  
+  const char *p, *q;
+
+  if (e->type->type == TYPE_OTHER)
+    {
+      if (mode == 'B')
+        abort ();
+      fprintf (outfile, "N(%d,%s)", idx, namebuf);
+      return;
+    }
+  fprintf (outfile, "%c(%d,%s,", mode, idx, namebuf);
+  l1 = getrandll ();
+  l2 = getrandll ();
+  switch (e->type->type)
+    {
+    case TYPE_INT:
+      signs = generate_random () & 3;
+      m = e->type->maxval;
+      if (mode == 'B')
+	m &= e->len > 1 ? (1ULL << (e->len - 1)) - 1 : 1;
+      l1 &= m;
+      l2 &= m;
+      fprintf (outfile, "%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s",
+	       (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
+	       (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
+      break;
+    case TYPE_UINT:
+      m = e->type->maxval;
+      if (mode == 'B')
+	m &= (1ULL << e->len) - 1;
+      l1 &= m;
+      l2 &= m;
+      fprintf (outfile, "%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s",
+	       l1, l1 > 4294967295U ? "LL" : "",
+	       l2, l2 > 4294967295U ? "LL" : "");
+      break;
+    case TYPE_FLOAT:
+      l1 &= 0xffffff;
+      l2 &= 0xffffff;
+      signs = generate_random () & 3;
+      fprintf (outfile, "%s%f,%s%f", (signs & 1) ? "-" : "",
+	       ((double) l1) / 64, (signs & 2) ? "-" : "", ((double) l2) / 64);
+      break;
+#ifndef SKIP_DECIMAL_FLOAT
+    case TYPE_DEC_FLOAT:
+      l1 &= 0xffffff;
+      l2 &= 0xffffff;
+      signs = generate_random () & 3;
+      
+      /* Get the suffix of Decimal Floting Points per 
+	 e->type->name.  Distinguish these three DFP types by
+         e->type->name.  */
+      if (strstr(e->type->name, "Decimal32")) suffix=0;
+      else if (strstr(e->type->name, "Decimal64")) suffix=1;
+      else if (strstr(e->type->name, "Decimal128")) suffix=2;
+      else
+	abort ();
+
+      /* Formatted input/output specifiers for DFP types have not been
+         implemented in GLIBC.  %f here used in fprintf is just to 
+         dump the numbers to outfile.  */
+      fprintf (outfile, "%s%f%s,%s%f%s", 
+	       (signs & 1) ? "-" : "", ((double) l1) / 64, DEC_SUFFIX[suffix], 
+	       (signs & 2) ? "-" : "", ((double) l2) / 64, DEC_SUFFIX[suffix]);
+      break;
+#endif
+    case TYPE_CINT:
+      signs = generate_random () & 3;
+      l1 &= e->type->maxval;
+      l2 &= e->type->maxval;
+      fprintf (outfile,
+	       "CINT(%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s),",
+	       (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
+	       (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
+      signs = generate_random () & 3;
+      l1 = getrandll ();
+      l2 = getrandll ();
+      l1 &= e->type->maxval;
+      l2 &= e->type->maxval;
+      fprintf (outfile,
+	       "CINT(%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s)",
+	       (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
+	       (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
+      break;
+    case TYPE_CUINT:
+      l1 &= e->type->maxval;
+      l2 &= e->type->maxval;
+      fprintf (outfile,
+	       "CINT(%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s),",
+	       l1, l1 > 4294967295U ? "LL" : "",
+	       l2, l2 > 4294967295U ? "LL" : "");
+      l1 = getrandll ();
+      l2 = getrandll ();
+      l1 &= e->type->maxval;
+      l2 &= e->type->maxval;
+      fprintf (outfile,
+	       "CINT(%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s)",
+	       l1, l1 > 4294967295U ? "LL" : "",
+	       l2, l2 > 4294967295U ? "LL" : "");
+      break;
+    case TYPE_CFLOAT:
+      l1 &= 0xffffff;
+      l2 &= 0xffffff;
+      signs = generate_random () & 3;
+      fprintf (outfile, "CDBL(%s%f,%s%f),",
+	       (signs & 1) ? "-" : "", ((double) l1) / 64,
+	       (signs & 2) ? "-" : "", ((double) l2) / 64);
+      l1 = getrandll ();
+      l2 = getrandll ();
+      l1 &= 0xffffff;
+      l2 &= 0xffffff;
+      signs = generate_random () & 3;
+      fprintf (outfile, "CDBL(%s%f,%s%f)",
+	       (signs & 1) ? "-" : "", ((double) l1) / 64,
+	       (signs & 2) ? "-" : "", ((double) l2) / 64);
+      break;
+    case TYPE_UENUM:
+      if (e->type->maxval == 0)
+	fputs ("e0_0,e0_0", outfile);
+      else if (e->type->maxval == 1)
+        fprintf (outfile, "e1_%" COMPAT_PRLL "d,e1_%" COMPAT_PRLL "d",
+		 l1 & 1, l2 & 1);
+      else
+        {
+	  p = strchr (e->type->name, '\0');
+	  while (--p >= e->type->name && *p >= '0' && *p <= '9');
+	  p++;
+          l1 %= 7;
+          l2 %= 7;
+          if (l1 > 3)
+            l1 += e->type->maxval - 6;
+          if (l2 > 3)
+            l2 += e->type->maxval - 6;
+	  fprintf (outfile, "e%s_%" COMPAT_PRLL "d,e%s_%" COMPAT_PRLL "d",
+	           p, l1, p, l2);
+        }
+      break;
+    case TYPE_SENUM:
+      p = strchr (e->type->name, '\0');
+      while (--p >= e->type->name && *p >= '0' && *p <= '9');
+      p++;
+      l1 %= 7;
+      l2 %= 7;
+      fprintf (outfile, "e%s_%s%" COMPAT_PRLL "d,e%s_%s%" COMPAT_PRLL "d",
+	       p, l1 < 3 ? "m" : "",
+	       l1 == 3 ? 0LL : e->type->maxval - (l1 & 3),
+	       p, l2 < 3 ? "m" : "",
+	       l2 == 3 ? 0LL : e->type->maxval - (l2 & 3));
+      break;
+    case TYPE_PTR:
+      l1 %= 256;
+      l2 %= 256;
+      fprintf (outfile,
+	       "(%s)&intarray[%" COMPAT_PRLL "d], (%s)&intarray[%" COMPAT_PRLL "d]",
+	       e->type->name, l1, e->type->name, l2);
+      break;
+    case TYPE_FNPTR:
+      l1 %= 10;
+      l2 %= 10;
+      fprintf (outfile, "fn%" COMPAT_PRLL "d,fn%" COMPAT_PRLL "d", l1, l2);
+      break;
+    default:
+      abort ();
+    }
+  fputs (")", outfile);
+}
+
+int
+subvalues (struct entry *e, char *p, char *letter)
+{
+  int i, j;
+  char *q;
+  if (p >= namebuf + sizeof (namebuf) - 32)
+    abort ();
+  p[0] = *letter;
+  p[1] = '\0';
+  q = p + 1;
+  switch (e[0].etype)
+    {
+    case ETYPE_STRUCT_ARRAY:
+    case ETYPE_UNION_ARRAY:
+      if (e[0].arr_len == 0 || e[0].arr_len == 255)
+	{
+	  *letter += 1 + e[0].len;
+	  return 1 + e[0].len;
+	}
+      i = generate_random () % e[0].arr_len;
+      snprintf (p, sizeof (namebuf) - (p - namebuf) - 1,
+		"%c[%d]", *letter, i);
+      q = strchr (p, '\0');
+      /* FALLTHROUGH */
+    case ETYPE_STRUCT:
+    case ETYPE_UNION:
+      *q++ = '.';
+      ++*letter;
+      for (i = 1; i <= e[0].len; )
+	{
+	  i += subvalues (e + i, q, letter);
+	  if (e[0].etype == ETYPE_UNION || e[0].etype == ETYPE_UNION_ARRAY)
+	    {
+	      *letter += e[0].len - i + 1;
+	      break;
+	    }
+	}
+      return 1 + e[0].len;
+    case ETYPE_TYPE:
+      ++*letter;
+      output_FNB ('F', e);
+      return 1;
+    case ETYPE_ARRAY:
+      if (e[0].arr_len == 0 || e[0].arr_len == 255)
+	{
+	  ++*letter;
+	  return 1;
+	}
+      i = generate_random () % e[0].arr_len;
+      snprintf (p, sizeof (namebuf) - (p - namebuf),
+		"%c[%d]", *letter, i);
+      output_FNB ('F', e);
+      if ((generate_random () & 7) == 0)
+	{
+	  j = generate_random () % e[0].arr_len;
+	  if (i != j)
+	    {
+	      snprintf (p, sizeof (namebuf) - (p - namebuf),
+			"%c[%d]", *letter, j);
+	      output_FNB ('F', e);
+	    }
+	}
+      ++*letter;
+      return 1;
+    case ETYPE_BITFLD:
+      ++*letter;
+      if (e[0].len != 0)
+	output_FNB ('B', e);
+      return 1;
+    }
+}
+
+/* DERIVED FROM:
+--------------------------------------------------------------------
+lookup2.c, by Bob Jenkins, December 1996, Public Domain.
+hash(), hash2(), hash3, and mix() are externally useful functions.
+Routines to test the hash are included if SELF_TEST is defined.
+You can use this free for any purpose.  It has no warranty.
+--------------------------------------------------------------------
+*/
+
+/*
+--------------------------------------------------------------------
+mix -- mix 3 32-bit values reversibly.
+For every delta with one or two bit set, and the deltas of all three
+  high bits or all three low bits, whether the original value of a,b,c
+  is almost all zero or is uniformly distributed,
+* If mix() is run forward or backward, at least 32 bits in a,b,c
+  have at least 1/4 probability of changing.
+* If mix() is run forward, every bit of c will change between 1/3 and
+  2/3 of the time.  (Well, 22/100 and 78/100 for some 2-bit deltas.)
+mix() was built out of 36 single-cycle latency instructions in a 
+  structure that could supported 2x parallelism, like so:
+      a -= b; 
+      a -= c; x = (c>>13);
+      b -= c; a ^= x;
+      b -= a; x = (a<<8);
+      c -= a; b ^= x;
+      c -= b; x = (b>>13);
+      ...
+  Unfortunately, superscalar Pentiums and Sparcs can't take advantage 
+  of that parallelism.  They've also turned some of those single-cycle
+  latency instructions into multi-cycle latency instructions.  Still,
+  this is the fastest good hash I could find.  There were about 2^^68
+  to choose from.  I only looked at a billion or so.
+--------------------------------------------------------------------
+*/
+/* same, but slower, works on systems that might have 8 byte hashval_t's */
+#define mix(a,b,c) \
+{ \
+  a -= b; a -= c; a ^= (c>>13); \
+  b -= c; b -= a; b ^= (a<< 8); \
+  c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
+  a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
+  b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
+  c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
+  a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
+  b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
+  c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
+}
+
+/*
+--------------------------------------------------------------------
+hash() -- hash a variable-length key into a 32-bit value
+  k     : the key (the unaligned variable-length array of bytes)
+  len   : the length of the key, counting by bytes
+  level : can be any 4-byte value
+Returns a 32-bit value.  Every bit of the key affects every bit of
+the return value.  Every 1-bit and 2-bit delta achieves avalanche.
+About 36+6len instructions.
+
+The best hash table sizes are powers of 2.  There is no need to do
+mod a prime (mod is sooo slow!).  If you need less than 32 bits,
+use a bitmask.  For example, if you need only 10 bits, do
+  h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+
+If you are hashing n strings (ub1 **)k, do it like this:
+  for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
+
+By Bob Jenkins, 1996.  bob_jenkins@burtleburtle.net.  You may use this
+code any way you wish, private, educational, or commercial.  It's free.
+
+See http://burtleburtle.net/bob/hash/evahash.html
+Use for hash table lookup, or anything where one collision in 2^32 is
+acceptable.  Do NOT use for cryptographic purposes.
+--------------------------------------------------------------------
+*/
+
+static hashval_t
+iterative_hash (const void *k_in /* the key */,
+                register size_t  length /* the length of the key */,
+                register hashval_t initval /* the previous hash, or
+                                              an arbitrary value */)
+{
+  register const unsigned char *k = (const unsigned char *)k_in;
+  register hashval_t a,b,c,len;
+
+  /* Set up the internal state */
+  len = length;
+  a = b = 0x9e3779b9;  /* the golden ratio; an arbitrary value */
+  c = initval;           /* the previous hash value */
+
+  /*---------------------------------------- handle most of the key */
+    while (len >= 12)
+      {
+	a += (k[0] +((hashval_t)k[1]<<8) +((hashval_t)k[2]<<16) +((hashval_t)k[3]<<24));
+	b += (k[4] +((hashval_t)k[5]<<8) +((hashval_t)k[6]<<16) +((hashval_t)k[7]<<24));
+	c += (k[8] +((hashval_t)k[9]<<8) +((hashval_t)k[10]<<16)+((hashval_t)k[11]<<24));
+	mix(a,b,c);
+	k += 12; len -= 12;
+      }
+
+  /*------------------------------------- handle the last 11 bytes */
+  c += length;
+  switch(len)              /* all the case statements fall through */
+    {
+    case 11: c+=((hashval_t)k[10]<<24);
+    case 10: c+=((hashval_t)k[9]<<16);
+    case 9 : c+=((hashval_t)k[8]<<8);
+      /* the first byte of c is reserved for the length */
+    case 8 : b+=((hashval_t)k[7]<<24);
+    case 7 : b+=((hashval_t)k[6]<<16);
+    case 6 : b+=((hashval_t)k[5]<<8);
+    case 5 : b+=k[4];
+    case 4 : a+=((hashval_t)k[3]<<24);
+    case 3 : a+=((hashval_t)k[2]<<16);
+    case 2 : a+=((hashval_t)k[1]<<8);
+    case 1 : a+=k[0];
+      /* case 0: nothing left to add */
+    }
+  mix(a,b,c);
+  /*-------------------------------------------- report the result */
+  return c;
+}
+
+hashval_t
+e_hash (const void *a)
+{
+  const struct entry *e = a;
+  hashval_t ret = 0;
+  int i;
+
+  if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION)
+    abort ();
+  for (i = 0; i <= e[0].len; ++i)
+    {
+      int attriblen;
+      ret = iterative_hash (&e[i], offsetof (struct entry, attrib), ret);
+      attriblen = e[i].attrib ? strlen (e[i].attrib) : -1;
+      ret = iterative_hash (&attriblen, sizeof (int), ret);
+      if (e[i].attrib)
+        ret = iterative_hash (e[i].attrib, attriblen, ret);
+    }
+  return ret;
+}
+
+int
+e_eq (const void *a, const void *b)
+{
+  const struct entry *ea = a, *eb = b;
+  int i;
+  if (ea[0].etype != ETYPE_STRUCT && ea[0].etype != ETYPE_UNION)
+    abort ();
+  if (ea[0].len != eb[0].len)
+    return 0;
+  for (i = 0; i <= ea[0].len; ++i)
+    {
+      if (ea[i].etype != eb[i].etype
+	  || ea[i].len != eb[i].len
+	  || ea[i].arr_len != eb[i].arr_len
+	  || ea[i].type != eb[i].type)
+	return 0;
+      if ((ea[i].attrib == NULL) ^ (eb[i].attrib == NULL))
+	return 0;
+      if (ea[i].attrib && strcmp (ea[i].attrib, eb[i].attrib) != 0)
+	return 0;
+    }
+  return 1;
+}
+
+static int 
+e_exists (const struct entry *e) 
+{
+  struct entry *h;
+  hashval_t hval;
+
+  hval = e_hash (e);
+  for (h = hash_table[hval % HASH_SIZE]; h; h = h->next)
+    if (e_eq (e, h))
+      return 1;
+  return 0;
+}
+
+static void
+e_insert (struct entry *e)
+{
+  hashval_t hval;
+
+  hval = e_hash (e);
+  e->next = hash_table[hval % HASH_SIZE];
+  hash_table[hval % HASH_SIZE] = e;
+}
+
+void
+output (struct entry *e)
+{
+  int i;
+  char c;
+  struct entry *n;
+  const char *skip_cint = "";
+
+  if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION)
+    abort ();
+
+  if (e_exists (e))
+    return;
+
+  n = (struct entry *) malloc ((e[0].len + 1) * sizeof (struct entry));
+  memcpy (n, e, (e[0].len + 1) * sizeof (struct entry));
+  e_insert (n);
+
+  if (idx == limidx)
+    switchfiles (e[0].len);
+
+  for (i = 1; i <= e[0].len; ++i)
+    if ((e[i].etype == ETYPE_TYPE || e[i].etype == ETYPE_ARRAY)
+	&& (e[i].type->type == TYPE_CINT || e[i].type->type == TYPE_CUINT))
+      break;
+  if (i <= e[0].len)
+    skip_cint = "CI";
+  if (e[0].attrib)
+    fprintf (outfile, (generate_random () & 1)
+	     ? "TX%s(%d,%s %s,," : "TX%s(%d,%s,%s,", skip_cint,
+	     idx, e[0].etype == ETYPE_STRUCT ? "struct" : "union",
+	     e[0].attrib);
+  else if (e[0].etype == ETYPE_STRUCT)
+    fprintf (outfile, "T%s(%d,", skip_cint, idx);
+  else
+    fprintf (outfile, "U%s(%d,", skip_cint, idx);
+  c = 'a';
+  for (i = 1; i <= e[0].len; )
+    i += subfield (e + i, &c);
+  fputs (",", outfile);
+  c = 'a';
+  for (i = 1; i <= e[0].len; )
+    {
+      i += subvalues (e + i, namebuf, &c);
+      if (e[0].etype == ETYPE_UNION)
+        break;
+    }
+  fputs (")\n", outfile);
+  if (output_one && idx == limidx)
+    exit (0);
+  ++idx;
+}
+
+enum FEATURE
+{
+  FEATURE_VECTOR = 1,
+  FEATURE_COMPLEX = 2,
+  FEATURE_ALIGNEDPACKED = 4,
+  FEATURE_ZEROARRAY = 8,
+  FEATURE_ZEROBITFLD = 16,
+  ALL_FEATURES = FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY
+		 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD
+};
+
+void
+singles (enum FEATURE features)
+{
+  struct entry e[2];
+  int i;
+  memset (e, 0, sizeof (e));
+  e[0].etype = ETYPE_STRUCT;
+  output (e);
+  e[0].etype = ETYPE_UNION;
+  output (e);
+  for (i = 0;
+       i < ((features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1);
+       ++i)
+    {
+      e[0].attrib = attributes[i];
+      e[0].etype = ETYPE_STRUCT;
+      output (e);
+      e[0].etype = ETYPE_UNION;
+      output (e);
+    }
+  e[0].len = 1;
+  e[0].attrib = NULL;
+  for (i = 0; i < NTYPES2; ++i)
+    {
+      e[0].etype = ETYPE_STRUCT;
+      e[1].etype = ETYPE_TYPE;
+      e[1].type = &base_types[i];
+      output (e);
+      e[0].etype = ETYPE_UNION;
+      output (e);
+    }
+  if (features & FEATURE_COMPLEX)
+    for (i = 0; i < NCTYPES2; ++i)
+      {
+	e[0].etype = ETYPE_STRUCT;
+	e[1].etype = ETYPE_TYPE;
+	e[1].type = &complex_types[i];
+	output (e);
+	e[0].etype = ETYPE_UNION;
+	output (e);
+      }
+  if (features & FEATURE_VECTOR)
+    for (i = 0; i < NVTYPES2; ++i)
+      {
+	e[0].etype = ETYPE_STRUCT;
+	e[1].etype = ETYPE_TYPE;
+	e[1].type = &vector_types[i];
+	output (e);
+	e[0].etype = ETYPE_UNION;
+	output (e);
+      }
+}
+
+void
+choose_type (enum FEATURE features, struct entry *e, int r, int in_array)
+{
+  int i;
+
+  i = NTYPES2 - NTYPES1;
+  if (features & FEATURE_COMPLEX)
+    i += NCTYPES2;
+  if (features & FEATURE_VECTOR)
+    i += NVTYPES2;
+  if ((r & 3) == 0)
+    {
+      if (in_array)
+	{
+	  i += NAATYPES2;
+	  if (features & FEATURE_COMPLEX)
+	    i += NCAATYPES2;
+	}
+      else
+	{
+	  i += NATYPES2;
+	  if (features & FEATURE_COMPLEX)
+	    i += NCATYPES2;
+	}
+    }
+  r >>= 2;
+  r %= i;
+  if (r < NTYPES2 - NTYPES1)
+    e->type = &base_types[r + NTYPES1];
+  r -= NTYPES2 - NTYPES1;
+  if (e->type == NULL && (features & FEATURE_COMPLEX))
+    {
+      if (r < NCTYPES2)
+	e->type = &complex_types[r];
+      r -= NCTYPES2;
+    }
+  if (e->type == NULL && (features & FEATURE_VECTOR))
+    {
+      if (r < NVTYPES2)
+	e->type = &vector_types[r];
+      r -= NVTYPES2;
+    }
+  if (e->type == NULL && !in_array)
+    {
+      if (r < NATYPES2)
+	e->type = &attrib_types[r];
+      r -= NATYPES2;
+    }
+  if (e->type == NULL && !in_array && (features & FEATURE_COMPLEX))
+    {
+      if (r < NCATYPES2)
+	e->type = &complex_attrib_types[r];
+      r -= NCATYPES2;
+    }
+  if (e->type == NULL && in_array)
+    {
+      if (r < NAATYPES2)
+	e->type = &attrib_array_types[r];
+      r -= NAATYPES2;
+    }
+  if (e->type == NULL && in_array && (features & FEATURE_COMPLEX))
+    {
+      if (r < NCAATYPES2)
+	e->type = &complex_attrib_array_types[r];
+      r -= NCAATYPES2;
+    }
+  if (e->type == NULL)
+    abort ();
+}
+
+/* This is from gcc.c-torture/execute/builtin-bitops-1.c.  */
+static int
+my_ffsll (unsigned long long x)
+{
+  int i;
+  if (x == 0)
+    return 0;
+  /* We've tested LLONG_MAX for 64 bits so this should be safe.  */
+  for (i = 0; i < 64; i++)
+    if (x & (1ULL << i))
+      break;
+  return i + 1;
+}
+
+void
+generate_fields (enum FEATURE features, struct entry *e, struct entry *parent,
+		 int len)
+{
+  int r, i, j, ret = 1, n, incr, sametype;
+
+  for (n = 0; n < len; n += incr)
+    {
+      r = generate_random ();
+      /* 50% ETYPE_TYPE base_types NTYPES1
+	 12.5% ETYPE_TYPE other
+	 12.5% ETYPE_ARRAY
+	 12.5% ETYPE_BITFLD
+	 12.5% ETYPE_STRUCT|ETYPE_UNION|ETYPE_STRUCT_ARRAY|ETYPE_UNION_ARRAY */
+      i = (r & 7);
+      r >>= 3;
+      incr = 1;
+      switch (i)
+	{
+	case 0:
+	case 1:
+	case 2:
+	case 3:
+	  e[n].etype = ETYPE_TYPE;
+	  e[n].type = &base_types[r % NTYPES1];
+	  break;
+	case 4:
+	  e[n].etype = ETYPE_TYPE;
+	  choose_type (features, &e[n], r, 0);
+	  break;
+	case 5:
+	  e[n].etype = ETYPE_ARRAY;
+	  i = r & 1;
+	  r >>= 1;
+	  if (i)
+	    e[n].type = &base_types[r % NTYPES1];
+	  else
+	    choose_type (features, &e[n], r, 1);
+	  r = generate_random ();
+	  if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0)
+	    {
+	      e[n].arr_len = 0;
+	      if (n == len - 1 && (r & 4)
+		  && (parent->etype == ETYPE_STRUCT
+		      || parent->etype == ETYPE_STRUCT_ARRAY))
+		{
+		  int k;
+		  for (k = 0; k < n; ++k)
+		    if (e[k].etype != ETYPE_BITFLD || e[k].len)
+		      {
+			e[n].arr_len = 255;
+			break;
+		      }
+		}
+	    }
+	  else if ((r & 3) != 3)
+	    e[n].arr_len = (r >> 2) & 7;
+	  else
+	    e[n].arr_len = (r >> 2) & 31;
+	  break;
+	case 6:
+	  sametype = 1;
+	  switch (r & 7)
+	    {
+	    case 0:
+	    case 1:
+	    case 2:
+	      break;
+	    case 3:
+	    case 4:
+	    case 5:
+	      incr = 1 + (r >> 3) % (len - n);
+	      break;
+	    case 6:
+	    case 7:
+	      sametype = 0;
+	      incr = 1 + (r >> 3) % (len - n);
+	      break;
+	    }
+	  for (j = n; j < n + incr; ++j)
+	    {
+	      int mi, ma;
+
+	      e[j].etype = ETYPE_BITFLD;
+	      if (j == n || !sametype)
+		{
+		  int k;
+		  r = generate_random ();
+		  k = r & 3;
+		  r >>= 2;
+		  if (!k)
+		    e[j].type
+		      = &aligned_bitfld_types[r % n_aligned_bitfld_types];
+		  else
+		    e[j].type
+		      = &bitfld_types[r % n_bitfld_types];
+		}
+	      else
+		e[j].type = e[n].type;
+	      r = generate_random ();
+	      mi = 0;
+	      ma = 0;
+	      switch (e[j].type->bitfld)
+	        {
+	        case 'C': ma = 8; break;
+	        case 'S': ma = 16; break;
+	        case 'I': ma = 32; break;
+	        case 'L':
+	        case 'Q': ma = 64; break;
+	        case 'B': ma = 1; break;
+	        case ' ':
+		  if (e[j].type->type == TYPE_UENUM)
+		    mi = my_ffsll (e[j].type->maxval + 1) - 1;
+		  else if (e[j].type->type == TYPE_SENUM)
+		    mi = my_ffsll (e[j].type->maxval + 1);
+		  else
+		    abort ();
+		  if (!mi)
+		    mi = 1;
+		  if (mi > 32)
+		    ma = 64;
+		  else if (mi > 16 || !short_enums)
+		    ma = 32;
+		  else if (mi > 8)
+		    ma = 16;
+		  else
+		    ma = 8;
+		  break;
+		default:
+		  abort ();
+	        }
+	      e[j].len = ma + 1;
+	      if (sametype && (r & 3) == 0 && ma > 1)
+		{
+		  int sum = 0, k;
+		  for (k = n; k < j; ++k)
+		    sum += e[k].len;
+		  sum %= ma;
+		  e[j].len = sum ? ma - sum : ma;
+		}
+	      r >>= 2;
+	      if (! (features & FEATURE_ZEROBITFLD) && mi == 0)
+		mi = 1;
+	      if (e[j].len < mi || e[j].len > ma)
+		e[j].len = mi + (r % (ma + 1 - mi));
+	      r >>= 6;
+	      if ((features & FEATURE_ZEROBITFLD) && (r & 3) == 0
+		  && mi == 0)
+		e[j].len = 0;
+	    }
+	  break;
+	case 7:
+	  switch (r & 7)
+	    {
+	    case 0:
+	    case 1:
+	    case 2:
+	      e[n].etype = ETYPE_STRUCT;
+	      break;
+	    case 3:
+	    case 4:
+	      e[n].etype = ETYPE_UNION;
+	      break;
+	    case 5:
+	    case 6:
+	      e[n].etype = ETYPE_STRUCT_ARRAY;
+	      break;
+	    case 7:
+	      e[n].etype = ETYPE_UNION_ARRAY;
+	      break;
+	    }
+	  r >>= 3;
+	  e[n].len = r % (len - n);
+	  incr = 1 + e[n].len;
+	  generate_fields (features, &e[n + 1], &e[n], e[n].len);
+	  if (e[n].etype == ETYPE_STRUCT_ARRAY
+	      || e[n].etype == ETYPE_UNION_ARRAY)
+	    {
+	      r = generate_random ();
+	      if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0)
+		{
+		  e[n].arr_len = 0;
+		  if (n + incr == len && (r & 4)
+		      && (parent->etype == ETYPE_STRUCT
+			  || parent->etype == ETYPE_STRUCT_ARRAY))
+		    {
+		      int k;
+		      for (k = 0; k < n; ++k)
+			if (e[k].etype != ETYPE_BITFLD || e[k].len)
+			  {
+			    e[n].arr_len = 255;
+			    break;
+			  }
+		    }
+		}
+	      else if ((r & 3) != 3)
+		e[n].arr_len = (r >> 2) & 7;
+	      else
+		e[n].arr_len = (r >> 2) & 31;
+	    }
+	  break;
+	}
+      r = generate_random ();
+      if ((r & 7) == 0)
+	{
+	  r >>= 3;
+	  i = (features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1;
+	  e[n].attrib = attributes[r % i];
+	  if (! (features & FEATURE_ALIGNEDPACKED)
+	      && strcmp (e[n].attrib, "atpa") == 0
+	      && ((e[n].type >= &attrib_types[0]
+		   && e[n].type < &attrib_types[NATYPES2])
+		  || (e[n].type >= &complex_attrib_types[0]
+		      && e[n].type < &complex_attrib_types[NCATYPES2])
+		  || (e[n].type >= &attrib_array_types[0]
+		      && e[n].type < &attrib_array_types[NAATYPES2])
+		  || (e[n].type >= &complex_attrib_array_types[0]
+		      && e[n].type < &complex_attrib_array_types[NAATYPES2])
+		  || (e[n].type >= &aligned_bitfld_types[0]
+		      && e[n].type < &aligned_bitfld_types[n_aligned_bitfld_types])))
+	    e[n].attrib = NULL;
+	}
+    }
+}
+
+void
+generate_random_tests (enum FEATURE features, int len)
+{
+  struct entry e[len + 1];
+  int i, r;
+  if (len > 'z' - 'a' + 1)
+    abort ();
+  memset (e, 0, sizeof (e));
+  r = generate_random ();
+  if ((r & 7) == 0)
+    e[0].etype = ETYPE_UNION;
+  else
+    e[0].etype = ETYPE_STRUCT;
+  r >>= 3;
+  e[0].len = len;
+  if ((r & 31) == 0)
+    {
+      r >>= 5;
+      if (features & FEATURE_ALIGNEDPACKED)
+	r %= NATTRIBS2;
+      else
+	r %= NATTRIBS1;
+      e[0].attrib = attributes[r];
+    }
+  generate_fields (features, &e[1], &e[0], len);
+  output (e);
+}
+
+struct { const char *name; enum FEATURE f; }
+features[] = {
+{ "normal", 0 },
+{ "complex", FEATURE_COMPLEX },
+{ "vector", FEATURE_VECTOR },
+{ "[0] :0", FEATURE_ZEROARRAY | FEATURE_ZEROBITFLD },
+{ "complex vector [0]",
+  FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY },
+{ "aligned packed complex vector [0] :0",
+  FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY
+  | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD },
+};
+
+int
+main (int argc, char **argv)
+{
+  int i, j, count, c, n = 3000;
+  char *optarg;
+
+  if (sizeof (int) != 4 || sizeof (long long) != 8)
+    return 1;
+  
+  i = 1;
+  while (i < argc) 
+    {
+      c = '\0';
+      if (argv[i][0] == '-' && argv[i][2] == '\0')
+	c = argv[i][1];
+      optarg = argv[i + 1];
+      if (!optarg)
+	goto usage;
+      switch (c)
+	{
+	case 'n':
+	  n = atoi (optarg);
+	  break;
+	case 'd':
+	  destdir = optarg;
+	  break;
+	case 's':
+	  srcdir = optarg;
+	  break;
+	case 'i':
+	  output_one = 1;
+	  limidx = atoi (optarg);
+	  break;
+	case 'e':
+	  short_enums = 1;
+	  i--;
+	  break;
+	default:
+	  fprintf (stderr, "unrecognized option %s\n", argv[i]);
+	  goto usage;
+      }
+      i += 2;
+    }
+
+  if (output_one)
+    {
+      outfile = fopen ("/dev/null", "w");
+      if (outfile == NULL)
+        {
+	  fputs ("could not open /dev/null", stderr);
+	  return 1;
+        }
+      n = limidx + 1;
+    }
+
+  if (destdir == NULL && !output_one)
+    {
+    usage:
+      fprintf (stderr, "Usage:\n\
+%s [-e] [-s srcdir -d destdir] [-n count] [-i idx]\n\
+Either -s srcdir -d destdir or -i idx must be used\n", argv[0]);
+      return 1;
+    }
+
+  if (srcdir == NULL && !output_one)
+    goto usage;
+
+  if (srcdir != NULL)
+    {
+      const char *s = srcdir;
+      char *ss, *t;
+      t = ss = malloc (strlen (srcdir) + 1);
+      if (!ss)
+	abort ();
+      do {
+	if (*s == '\\')
+	  *t++ = '/';
+	else
+	  *t++ = *s;
+      } while (*s++);
+      srcdir_safe = ss;
+    }
+
+  for (i = 0; i < NTYPES2; ++i)
+    if (base_types[i].bitfld)
+      bitfld_types[n_bitfld_types++] = base_types[i];
+  for (i = 0; i < NATYPES2; ++i)
+    if (attrib_types[i].bitfld)
+      aligned_bitfld_types[n_aligned_bitfld_types++] = attrib_types[i];
+  for (i = 0; i < sizeof (features) / sizeof (features[0]); ++i)
+    {
+      int startidx = idx;
+      if (! output_one)
+	limidx = idx;
+      if (!i)
+        count = 200;
+      else
+        count = 20;
+      for (j = 1; j <= 9; ++j)
+        while (idx < startidx + j * count)
+	  generate_random_tests (features[i].f, j);
+      while (idx < startidx + count * 10)
+	generate_random_tests (features[i].f, 10 + (generate_random () % 16));
+    }
+  for (i = 0; n > 3000 && i < sizeof (features) / sizeof (features[0]); ++i)
+    {
+      int startidx;
+      startidx = idx;
+      if (! output_one)
+	limidx = idx;
+      singles (features[i].f);
+      if (!i)
+	{
+	  count = 1000;
+	  while (idx < startidx + 1000)
+	    generate_random_tests (features[i].f, 1);
+	}
+      else
+	{
+	  startidx = idx;
+	  count = 100;
+	  while (idx < startidx + 100)
+	    generate_random_tests (features[i].f, 1);
+	}
+      startidx = idx;
+      for (j = 2; j <= 9; ++j)
+	while (idx < startidx + (j - 1) * count)
+	  generate_random_tests (features[i].f, j);
+      while (idx < startidx + count * 9)
+        generate_random_tests (features[i].f, 10 + (generate_random () % 16));
+    }
+  if (! output_one)
+    limidx = idx;
+  while (idx < n)
+    generate_random_tests (ALL_FEATURES, 1 + (generate_random () % 25));
+  fclose (outfile);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_main.c
new file mode 100644
index 000000000..b59453e0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_main.c
@@ -0,0 +1,17 @@
+/* { dg-prune-output ".*-Wno-abi.*" } */
+
+#include "struct-layout-1.h"
+
+#define TX(n, type, attrs, fields, ops) extern void test##n (void);
+#include "struct-layout-1_test.h"
+#undef TX
+
+int main (void)
+{
+#define TX(n, type, attrs, fields, ops)   test##n ();
+#include "struct-layout-1_test.h"
+#undef TX
+  if (fails)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_test.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_test.h
new file mode 100644
index 000000000..4a70dfd06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_test.h
@@ -0,0 +1,5 @@
+#if (__SIZEOF_INT__ >= 4) 
+T(0,enum E2 a:31;,B(0,a,e2_m1,e2_0))
+#else
+T(0,enum E2 a:15;,B(0,a,e2_m1,e2_0))
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x.c
new file mode 100644
index 000000000..02c885c62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x.c
@@ -0,0 +1,5 @@
+/* { dg-options "-w" } */
+#include "struct-layout-1_x1.h"
+#include "struct-layout-1_test.h"
+#include "struct-layout-1_x2.h"
+#include "struct-layout-1_test.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x1.h
new file mode 100644
index 000000000..0c7696fa7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x1.h
@@ -0,0 +1,68 @@
+#include "struct-layout-1.h"
+
+struct Info info;
+int fails;
+int intarray[256];
+int fn0 (void) { return 0; }
+int fn1 (void) { return 1; }
+int fn2 (void) { return 2; }
+int fn3 (void) { return 3; }
+int fn4 (void) { return 4; }
+int fn5 (void) { return 5; }
+int fn6 (void) { return 6; }
+int fn7 (void) { return 7; }
+int fn8 (void) { return 8; }
+int fn9 (void) { return 9; }
+
+/* This macro is intended for fields where their
+   addresses/sizes/alignments and value passing should be checked.  */
+#define F(n, x, v, w) 						\
+  info.flds[i] = &s##n.x;					\
+  info.sizes[i] = sizeof (s##n.x);				\
+  info.aligns[i] = __alignof__ (s##n.x);			\
+  s##n.x = v;							\
+  a##n[2].x = w;						\
+  ++i;
+/* This macro is for fields where just their addresses/sizes/alignments
+   should be checked.  */
+#define N(n, x) 						\
+  info.flds[i] = &s##n.x;					\
+  info.sizes[i] = sizeof (s##n.x);				\
+  info.aligns[i] = __alignof__ (s##n.x);			\
+  ++i;
+/* This macro is for fields where just value passing should be checked.  */
+#define B(n, x, v, w)						\
+  s##n.x = v;							\
+  a##n[2].x = w;						\
+  ++j;
+#define TX(n, type, attrs, fields, ops) 			\
+type S##n { fields } attrs;					\
+type S##n s##n;							\
+extern type S##n a##n[5];					\
+extern type S##n check##n (type S##n, type S##n *,		\
+			     type S##n);			\
+extern void check##n##va (int i, ...);				\
+extern void checkx##n (type S##n);				\
+void test##n (void)						\
+{								\
+  int i, j;							\
+  memset (&s##n, '\0', sizeof (s##n));				\
+  memset (a##n, '\0', sizeof (a##n));				\
+  memset (&info, '\0', sizeof (info));				\
+  info.sp = &s##n;						\
+  info.a0p = &a##n[0];						\
+  info.a3p = &a##n[3];						\
+  info.sz = sizeof (s##n);					\
+  info.als = __alignof__ (s##n);				\
+  info.ala0 = __alignof__ (a##n[0]);				\
+  info.ala3 = __alignof__ (a##n[3]);				\
+  if (((long) &a##n[3]) & (info.als - 1))			\
+    FAIL (n, 1);						\
+  i = 0; j = 0;							\
+  ops								\
+  info.nfields = i;						\
+  info.nbitfields = j;						\
+  checkx##n (check##n (s##n, &a##n[1], a##n[2]));		\
+  check##n##va (1, 1.0, s##n, 2LL, a##n[2], a##n[2]);		\
+  check##n##va (2, s##n, s##n, 2.0L, a##n[2], s##n);		\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x2.h
new file mode 100644
index 000000000..907a2c959
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_x2.h
@@ -0,0 +1,14 @@
+#undef F
+#undef N
+#undef B
+#undef TX
+#define F(n, x, v, w) 						\
+  if (arg.x != s##n.x) FAIL (n, 30);
+#define N(n, x)
+#define B(n, x, v, w)						\
+  if (arg.x != s##n.x) FAIL (n, 30);
+#define TX(n, type, attrs, fields, ops) 			\
+void checkx##n (type S##n arg)					\
+{								\
+  ops								\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y.c
new file mode 100644
index 000000000..ed95f5a50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y.c
@@ -0,0 +1,5 @@
+/* { dg-options "-w" } */
+#include "struct-layout-1_y1.h"
+#include "struct-layout-1_test.h"
+#include "struct-layout-1_y2.h"
+#include "struct-layout-1_test.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y1.h
new file mode 100644
index 000000000..9a5d2468a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y1.h
@@ -0,0 +1,76 @@
+#include "struct-layout-1.h"
+
+#define F(n, x, v, w) 						\
+  if (info.flds[i] != &s##n.x)					\
+    FAIL (n, 50);						\
+  if (info.sizes[i] != sizeof (s##n.x))				\
+    FAIL (n, 51);						\
+  if (info.aligns[i] != __alignof__ (s##n.x))			\
+    FAIL (n, 52);						\
+  if (s##n.x != (__typeof__ (s##n.x)) v)			\
+    FAIL (n, 53);						\
+  if (a##n[2].x != (__typeof__ (s##n.x)) w)			\
+    FAIL (n, 54);						\
+  if (arg0.x != s##n.x)						\
+    FAIL (n, 55);						\
+  if (arg2.x != a##n[2].x)					\
+    FAIL (n, 56);						\
+  ret.x = s##n.x;						\
+  ++i;
+#define N(n, x) 						\
+  if (info.flds[i] != &s##n.x)					\
+    FAIL (n, 50);						\
+  if (info.sizes[i] != sizeof (s##n.x))				\
+    FAIL (n, 51);						\
+  if (info.aligns[i] != __alignof__ (s##n.x))			\
+    FAIL (n, 52);						\
+  ++i;
+#define B(n, x, v, w) 						\
+  b1.x = v; b2.x = w;						\
+  if (s##n.x != b1.x)						\
+    FAIL (n, 53);						\
+  if (a##n[2].x != b2.x)					\
+    FAIL (n, 54);						\
+  if (arg0.x != s##n.x)						\
+    FAIL (n, 55);						\
+  if (arg2.x != a##n[2].x)					\
+    FAIL (n, 56);						\
+  ret.x = s##n.x;						\
+  ++j;
+#define TX(n, type, attrs, fields, ops) 			\
+type S##n { fields } attrs;					\
+extern type S##n s##n;						\
+type S##n a##n[5];						\
+type S##n							\
+check##n (type S##n arg0, type S##n *arg1, type S##n arg2)	\
+{								\
+  type S##n ret;						\
+  type S##n b1, b2;						\
+  int i, j;							\
+								\
+  memset (&ret, 0, sizeof (ret));				\
+  memset (&b1, 0, sizeof (b1));					\
+  memset (&b2, 0, sizeof (b2));					\
+  if (info.sp != &s##n)						\
+    FAIL (n, 10);						\
+  if (info.a0p != &a##n[0])					\
+    FAIL (n, 11);						\
+  if (info.a3p != &a##n[3])					\
+    FAIL (n, 12);						\
+  if (info.sz != sizeof (s##n))					\
+    FAIL (n, 13);						\
+  if (info.als != __alignof__ (s##n))				\
+    FAIL (n, 14);						\
+  if (info.ala0 != __alignof__ (a##n[0]))			\
+    FAIL (n, 15);						\
+  if (info.ala3 != __alignof__ (a##n[3]))			\
+    FAIL (n, 16);						\
+  if (arg1 != &a##n[1])						\
+    FAIL (n, 17);						\
+  i = 0; j = 0;							\
+  ops								\
+  if (i != info.nfields || j != info.nbitfields)		\
+    FAIL (n, 18);						\
+								\
+  return ret;							\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y2.h
new file mode 100644
index 000000000..02a341e1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-layout-1_y2.h
@@ -0,0 +1,69 @@
+#undef F
+#undef N
+#undef B
+#undef TX
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define F(n, x, v, w) 						\
+  if (p->x != arg.x) FAIL (n, 74);
+#define N(n, x)
+#define B(n, x, v, w) 						\
+  if (p->x != arg.x) FAIL (n, 74);
+#define TX(n, type, attrs, fields, ops) 			\
+void								\
+check##n##va (int z, ...)					\
+{								\
+  type S##n arg, *p;						\
+  va_list ap;							\
+  int i;							\
+								\
+  if (test_va)							\
+    {								\
+      va_start (ap, z);						\
+      for (i = 0; i < 5; ++i)					\
+	{							\
+	  p = NULL;						\
+	  switch ((z << 4) | i)					\
+	    {							\
+	    case 0x10:						\
+	      if (va_arg (ap, double) != 1.0)			\
+		FAIL (n, 70);					\
+	      break;						\
+	    case 0x12:						\
+	      if (va_arg (ap, long long) != 2LL)		\
+		FAIL (n, 71);					\
+	      break;						\
+	    case 0x22:						\
+	      if (va_arg (ap, long double) != 2.0L)		\
+		FAIL (n, 72);					\
+	      break;						\
+	    case 0x11:						\
+	    case 0x20:						\
+	    case 0x21:						\
+	    case 0x24:						\
+	      p = &s##n;					\
+	      arg = va_arg (ap, type S##n);			\
+	      break;						\
+	    case 0x13:						\
+	    case 0x14:						\
+	    case 0x23:						\
+	      p = &a##n[2];					\
+	      arg = va_arg (ap, type S##n);			\
+	      break;						\
+	    default:						\
+	      FAIL (n, 73);					\
+	      break;						\
+	    }							\
+	  if (p)						\
+	    {							\
+	      ops						\
+	    }							\
+	}							\
+      va_end (ap);						\
+    }								\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_main.c
new file mode 100644
index 000000000..fca68286c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_main.c
@@ -0,0 +1,13 @@
+/* Test function return values.  For this test, all struct members are
+   scalar floating point types.  */
+
+extern void struct_return_10_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_return_10_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_x.c
new file mode 100644
index 000000000..d1531b179
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_x.c
@@ -0,0 +1,119 @@
+#include "compat-common.h"
+
+#define T(TYPE)							\
+TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, double y);			\
+extern void checkg##TYPE (void);				\
+extern TYPE test0##TYPE (void);					\
+extern TYPE test1##TYPE (TYPE);					\
+extern TYPE testva##TYPE (int n, ...);				\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  (&g01##TYPE,  1.0);				\
+  init##TYPE  (&g02##TYPE,  2.0);				\
+  init##TYPE  (&g03##TYPE,  3.0);				\
+  init##TYPE  (&g04##TYPE,  4.0);				\
+  init##TYPE  (&g05##TYPE,  5.0);				\
+  init##TYPE  (&g06##TYPE,  6.0);				\
+  init##TYPE  (&g07##TYPE,  7.0);				\
+  init##TYPE  (&g08##TYPE,  8.0);				\
+  init##TYPE  (&g09##TYPE,  9.0);				\
+  init##TYPE  (&g10##TYPE, 10.0);				\
+  init##TYPE  (&g11##TYPE, 11.0);				\
+  init##TYPE  (&g12##TYPE, 12.0);				\
+  init##TYPE  (&g13##TYPE, 13.0);				\
+  init##TYPE  (&g14##TYPE, 14.0);				\
+  init##TYPE  (&g15##TYPE, 15.0);				\
+  init##TYPE  (&g16##TYPE, 16.0);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##TYPE ();					\
+  check##TYPE (rslt, 1.0);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##TYPE (g01##TYPE);				\
+  check##TYPE (rslt, 1.0);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  rslt = testva##TYPE (1, g01##TYPE);				\
+  check##TYPE (rslt, 1.0);					\
+  rslt = testva##TYPE (5, g01##TYPE, g02##TYPE,			\
+			  g03##TYPE, g04##TYPE,			\
+			  g05##TYPE);				\
+  check##TYPE (rslt, 5.0);					\
+  rslt = testva##TYPE (9, g01##TYPE, g02##TYPE,			\
+			  g03##TYPE, g04##TYPE,			\
+			  g05##TYPE, g06##TYPE,			\
+			  g07##TYPE, g08##TYPE,			\
+			  g09##TYPE);				\
+  check##TYPE (rslt, 9.0);					\
+  rslt = testva##TYPE (16, g01##TYPE, g02##TYPE,		\
+			  g03##TYPE, g04##TYPE,			\
+			  g05##TYPE, g06##TYPE,			\
+			  g07##TYPE, g08##TYPE,			\
+			  g09##TYPE, g10##TYPE,			\
+			  g11##TYPE, g12##TYPE,			\
+			  g13##TYPE, g14##TYPE,			\
+			  g15##TYPE, g16##TYPE);		\
+  check##TYPE (rslt, 16.0);					\
+  DEBUG_NL;							\
+}
+
+#include "fp2-struct-defs.h"
+#include "fp2-struct-check.h"
+
+T(Sfd)
+T(Sfl)
+T(Sdf)
+T(Sdl)
+T(Slf)
+T(Sld)
+T(Sfdl)
+T(Sfld)
+T(Sdfl)
+T(Sdlf)
+T(Slfd)
+T(Sldf)
+
+#undef T
+
+void
+struct_return_10_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Sfd);
+T(Sfl);
+T(Sdf);
+T(Sdl);
+T(Slf);
+T(Sld);
+T(Sfdl);
+T(Sfld);
+T(Sdfl);
+T(Sdlf);
+T(Slfd);
+T(Sldf);
+
+DEBUG_FINI
+
+if (fails != 0)
+  return;
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_y.c
new file mode 100644
index 000000000..dcc0b93c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-10_y.c
@@ -0,0 +1,79 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+
+#include "fp2-struct-defs.h"
+#include "fp2-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+extern TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+extern TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+extern TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void check##TYPE (TYPE x, double y);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (g01##TYPE,  1.0);					\
+  check##TYPE (g02##TYPE,  2.0);					\
+  check##TYPE (g03##TYPE,  3.0);					\
+  check##TYPE (g04##TYPE,  4.0);					\
+  check##TYPE (g05##TYPE,  5.0);					\
+  check##TYPE (g06##TYPE,  6.0);					\
+  check##TYPE (g07##TYPE,  7.0);					\
+  check##TYPE (g08##TYPE,  8.0);					\
+  check##TYPE (g09##TYPE,  9.0);					\
+  check##TYPE (g10##TYPE, 10.0);					\
+  check##TYPE (g11##TYPE, 11.0);					\
+  check##TYPE (g12##TYPE, 12.0);					\
+  check##TYPE (g13##TYPE, 13.0);					\
+  check##TYPE (g14##TYPE, 14.0);					\
+  check##TYPE (g15##TYPE, 15.0);					\
+  check##TYPE (g16##TYPE, 16.0);					\
+}								\
+								\
+TYPE								\
+test0##TYPE (void)						\
+{								\
+  return g01##TYPE;						\
+}								\
+								\
+TYPE								\
+test1##TYPE (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  if (1)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  rslt = va_arg (ap, TYPE);				\
+	}							\
+      va_end (ap);						\
+    }								\
+  return rslt;							\
+}
+
+T(Sfd)
+T(Sfl)
+T(Sdf)
+T(Sdl)
+T(Slf)
+T(Sld)
+T(Sfdl)
+T(Sfld)
+T(Sdfl)
+T(Sdlf)
+T(Slfd)
+T(Sldf)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_main.c
new file mode 100644
index 000000000..65d8365ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_main.c
@@ -0,0 +1,16 @@
+/* Test function return values.  Struct members are char, int, double,
+   and other structs containing these types.  This test was written in
+   response to a layout change for such structs for powerpc64-linux,
+   but this test only checks similar structs that are not affected by
+   that break in compatibility. */
+
+extern void struct_return_19_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_return_19_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_x.c
new file mode 100644
index 000000000..0085a9f68
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_x.c
@@ -0,0 +1,122 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(TYPE)							\
+TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern TYPE test0##TYPE (void);					\
+extern TYPE test1##TYPE (TYPE);					\
+extern TYPE testva##TYPE (int n, ...);				\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  (&g01##TYPE,  1);					\
+  init##TYPE  (&g02##TYPE,  2);					\
+  init##TYPE  (&g03##TYPE,  3);					\
+  init##TYPE  (&g04##TYPE,  4);					\
+  init##TYPE  (&g05##TYPE,  5);					\
+  init##TYPE  (&g06##TYPE,  6);					\
+  init##TYPE  (&g07##TYPE,  7);					\
+  init##TYPE  (&g08##TYPE,  8);					\
+  init##TYPE  (&g09##TYPE,  9);					\
+  init##TYPE  (&g10##TYPE, 10);					\
+  init##TYPE  (&g11##TYPE, 11);					\
+  init##TYPE  (&g12##TYPE, 12);					\
+  init##TYPE  (&g13##TYPE, 13);					\
+  init##TYPE  (&g14##TYPE, 14);					\
+  init##TYPE  (&g15##TYPE, 15);					\
+  init##TYPE  (&g16##TYPE, 16);					\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##TYPE ();					\
+  check##TYPE (rslt, 1);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##TYPE (g01##TYPE);				\
+  check##TYPE (rslt, 1);					\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#TYPE);					\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##TYPE (1, g01##TYPE);			\
+      check##TYPE (rslt, 1);					\
+      rslt = testva##TYPE (5, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE);				\
+      check##TYPE (rslt, 5);					\
+      rslt = testva##TYPE (9, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE);				\
+      check##TYPE (rslt, 9);					\
+      rslt = testva##TYPE (16, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE, g10##TYPE,		\
+			   g11##TYPE, g12##TYPE,		\
+			   g13##TYPE, g14##TYPE,		\
+			   g15##TYPE, g16##TYPE);		\
+      check##TYPE (rslt, 16);					\
+    }								\
+  DEBUG_NL;							\
+}
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+T(Scdc)
+T(Sd)
+T(Sdi)
+T(Scsdsc)
+T(Scsdis)
+T(Scsdisc)
+T(Ssds)
+T(Ssdsc)
+T(Scssdssc)
+
+#undef T
+
+void
+struct_return_19_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Scdc)
+T(Sd)
+T(Sdi)
+T(Scsdsc)
+T(Scsdis)
+T(Scsdisc)
+T(Ssds)
+T(Ssdsc)
+T(Scssdssc)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_y.c
new file mode 100644
index 000000000..6bbbb62cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-19_y.c
@@ -0,0 +1,70 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+extern TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+extern TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+extern TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (g01##TYPE,  1);					\
+  check##TYPE (g02##TYPE,  2);					\
+  check##TYPE (g03##TYPE,  3);					\
+  check##TYPE (g04##TYPE,  4);					\
+  check##TYPE (g05##TYPE,  5);					\
+  check##TYPE (g06##TYPE,  6);					\
+  check##TYPE (g07##TYPE,  7);					\
+  check##TYPE (g08##TYPE,  8);					\
+  check##TYPE (g09##TYPE,  9);					\
+  check##TYPE (g10##TYPE, 10);					\
+  check##TYPE (g11##TYPE, 11);					\
+  check##TYPE (g12##TYPE, 12);					\
+  check##TYPE (g13##TYPE, 13);					\
+  check##TYPE (g14##TYPE, 14);					\
+  check##TYPE (g15##TYPE, 15);					\
+  check##TYPE (g16##TYPE, 16);					\
+}								\
+								\
+TYPE								\
+test0##TYPE (void)						\
+{								\
+  return g01##TYPE;						\
+}								\
+								\
+TYPE								\
+test1##TYPE (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+      rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(Scdc)
+T(Sd)
+T(Sdi)
+T(Scsdsc)
+T(Scsdis)
+T(Scsdisc)
+T(Ssds)
+T(Ssdsc)
+T(Scssdssc)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_main.c
new file mode 100644
index 000000000..7f928ba82
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_main.c
@@ -0,0 +1,14 @@
+/* Test function return values.  Tested structs end with double.  This
+   was written in response to a layout change for such structs for
+   powerpc64-linux that breaks compatibility between 3.3 and 3.4.  */
+
+extern void struct_return_20_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_return_20_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_x.c
new file mode 100644
index 000000000..be7139f7d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_x.c
@@ -0,0 +1,110 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(TYPE)							\
+TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern TYPE test0##TYPE (void);					\
+extern TYPE test1##TYPE (TYPE);					\
+extern TYPE testva##TYPE (int n, ...);				\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  (&g01##TYPE,  1);					\
+  init##TYPE  (&g02##TYPE,  2);					\
+  init##TYPE  (&g03##TYPE,  3);					\
+  init##TYPE  (&g04##TYPE,  4);					\
+  init##TYPE  (&g05##TYPE,  5);					\
+  init##TYPE  (&g06##TYPE,  6);					\
+  init##TYPE  (&g07##TYPE,  7);					\
+  init##TYPE  (&g08##TYPE,  8);					\
+  init##TYPE  (&g09##TYPE,  9);					\
+  init##TYPE  (&g10##TYPE, 10);					\
+  init##TYPE  (&g11##TYPE, 11);					\
+  init##TYPE  (&g12##TYPE, 12);					\
+  init##TYPE  (&g13##TYPE, 13);					\
+  init##TYPE  (&g14##TYPE, 14);					\
+  init##TYPE  (&g15##TYPE, 15);					\
+  init##TYPE  (&g16##TYPE, 16);					\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##TYPE ();					\
+  check##TYPE (rslt, 1);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##TYPE (g01##TYPE);				\
+  check##TYPE (rslt, 1);					\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#TYPE);					\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##TYPE (1, g01##TYPE);			\
+      check##TYPE (rslt, 1);					\
+      rslt = testva##TYPE (5, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE);				\
+      check##TYPE (rslt, 5);					\
+      rslt = testva##TYPE (9, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE);				\
+      check##TYPE (rslt, 9);					\
+      rslt = testva##TYPE (16, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE, g10##TYPE,		\
+			   g11##TYPE, g12##TYPE,		\
+			   g13##TYPE, g14##TYPE,		\
+			   g15##TYPE, g16##TYPE);		\
+      check##TYPE (rslt, 16);					\
+    }								\
+  DEBUG_NL;							\
+}
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+T(Scd)
+T(Scsds)
+T(Scssdss)
+
+#undef T
+
+void
+struct_return_20_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Scd)
+T(Scsds)
+T(Scssdss)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_y.c
new file mode 100644
index 000000000..2c1c33426
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-20_y.c
@@ -0,0 +1,64 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+extern TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+extern TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+extern TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (g01##TYPE,  1);					\
+  check##TYPE (g02##TYPE,  2);					\
+  check##TYPE (g03##TYPE,  3);					\
+  check##TYPE (g04##TYPE,  4);					\
+  check##TYPE (g05##TYPE,  5);					\
+  check##TYPE (g06##TYPE,  6);					\
+  check##TYPE (g07##TYPE,  7);					\
+  check##TYPE (g08##TYPE,  8);					\
+  check##TYPE (g09##TYPE,  9);					\
+  check##TYPE (g10##TYPE, 10);					\
+  check##TYPE (g11##TYPE, 11);					\
+  check##TYPE (g12##TYPE, 12);					\
+  check##TYPE (g13##TYPE, 13);					\
+  check##TYPE (g14##TYPE, 14);					\
+  check##TYPE (g15##TYPE, 15);					\
+  check##TYPE (g16##TYPE, 16);					\
+}								\
+								\
+TYPE								\
+test0##TYPE (void)						\
+{								\
+  return g01##TYPE;						\
+}								\
+								\
+TYPE								\
+test1##TYPE (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+      rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(Scd)
+T(Scsds)
+T(Scssdss)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_main.c
new file mode 100644
index 000000000..34e0ab429
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_main.c
@@ -0,0 +1,13 @@
+/* Test function return values.  This was written when correcting
+   a deviation from the ABI on SPARC64 between 3.3 and 3.4.  */
+
+extern void struct_return_21_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_return_21_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_x.c
new file mode 100644
index 000000000..721deff03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_x.c
@@ -0,0 +1,112 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(TYPE)							\
+TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern TYPE test0##TYPE (void);					\
+extern TYPE test1##TYPE (TYPE);					\
+extern TYPE testva##TYPE (int n, ...);				\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  (&g01##TYPE,  1);					\
+  init##TYPE  (&g02##TYPE,  2);					\
+  init##TYPE  (&g03##TYPE,  3);					\
+  init##TYPE  (&g04##TYPE,  4);					\
+  init##TYPE  (&g05##TYPE,  5);					\
+  init##TYPE  (&g06##TYPE,  6);					\
+  init##TYPE  (&g07##TYPE,  7);					\
+  init##TYPE  (&g08##TYPE,  8);					\
+  init##TYPE  (&g09##TYPE,  9);					\
+  init##TYPE  (&g10##TYPE, 10);					\
+  init##TYPE  (&g11##TYPE, 11);					\
+  init##TYPE  (&g12##TYPE, 12);					\
+  init##TYPE  (&g13##TYPE, 13);					\
+  init##TYPE  (&g14##TYPE, 14);					\
+  init##TYPE  (&g15##TYPE, 15);					\
+  init##TYPE  (&g16##TYPE, 16);					\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##TYPE ();					\
+  check##TYPE (rslt, 1);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##TYPE (g01##TYPE);				\
+  check##TYPE (rslt, 1);					\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#TYPE);					\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##TYPE (1, g01##TYPE);			\
+      check##TYPE (rslt, 1);					\
+      rslt = testva##TYPE (5, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE);				\
+      check##TYPE (rslt, 5);					\
+      rslt = testva##TYPE (9, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE);				\
+      check##TYPE (rslt, 9);					\
+      rslt = testva##TYPE (16, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE, g10##TYPE,		\
+			   g11##TYPE, g12##TYPE,		\
+			   g13##TYPE, g14##TYPE,		\
+			   g15##TYPE, g16##TYPE);		\
+      check##TYPE (rslt, 16);					\
+    }								\
+  DEBUG_NL;							\
+}
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-check.h"
+
+T(Sfi)
+T(Sfii)
+T(Sfifi)
+T(Sfiifii)
+
+#undef T
+
+void
+struct_return_21_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Sfi)
+T(Sfii)
+T(Sfifi)
+T(Sfiifii)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_y.c
new file mode 100644
index 000000000..b44d7f58e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-21_y.c
@@ -0,0 +1,65 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#include "mixed-struct-defs.h"
+#include "mixed-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+extern TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+extern TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+extern TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (g01##TYPE,  1);					\
+  check##TYPE (g02##TYPE,  2);					\
+  check##TYPE (g03##TYPE,  3);					\
+  check##TYPE (g04##TYPE,  4);					\
+  check##TYPE (g05##TYPE,  5);					\
+  check##TYPE (g06##TYPE,  6);					\
+  check##TYPE (g07##TYPE,  7);					\
+  check##TYPE (g08##TYPE,  8);					\
+  check##TYPE (g09##TYPE,  9);					\
+  check##TYPE (g10##TYPE, 10);					\
+  check##TYPE (g11##TYPE, 11);					\
+  check##TYPE (g12##TYPE, 12);					\
+  check##TYPE (g13##TYPE, 13);					\
+  check##TYPE (g14##TYPE, 14);					\
+  check##TYPE (g15##TYPE, 15);					\
+  check##TYPE (g16##TYPE, 16);					\
+}								\
+								\
+TYPE								\
+test0##TYPE (void)						\
+{								\
+  return g01##TYPE;						\
+}								\
+								\
+TYPE								\
+test1##TYPE (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+      rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(Sfi)
+T(Sfii)
+T(Sfifi)
+T(Sfiifii)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_main.c
new file mode 100644
index 000000000..22a1f6ef7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_main.c
@@ -0,0 +1,13 @@
+/* Test function return values.  This test includes structs that are
+   arrays of unsigned integral scalars.  */
+
+extern void struct_return_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_return_2_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_x.c
new file mode 100644
index 000000000..590c30aa9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_x.c
@@ -0,0 +1,229 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(N, NAME, TYPE)					\
+struct S##NAME##N { TYPE i[N]; };				\
+struct S##NAME##N g1s##NAME##N, g2s##NAME##N;			\
+struct S##NAME##N g3s##NAME##N, g4s##NAME##N;			\
+struct S##NAME##N g5s##NAME##N, g6s##NAME##N;			\
+struct S##NAME##N g7s##NAME##N, g8s##NAME##N;			\
+struct S##NAME##N g9s##NAME##N, g10s##NAME##N;			\
+struct S##NAME##N g11s##NAME##N, g12s##NAME##N;			\
+struct S##NAME##N g13s##NAME##N, g14s##NAME##N;			\
+struct S##NAME##N g15s##NAME##N, g16s##NAME##N;			\
+								\
+extern void init##NAME##N (struct S##NAME##N *p, int i);	\
+extern void checkg##NAME##N (void);				\
+extern struct S##NAME##N test0##NAME##N (void);			\
+extern struct S##NAME##N test1##NAME##N (struct S##NAME##N);	\
+extern struct S##NAME##N testva##NAME##N (int n, ...);		\
+								\
+void								\
+check##NAME##N (struct S##NAME##N *p, int i)			\
+{								\
+  int j;							\
+  DEBUG_DOT;							\
+  for (j = 0; j < N; j++)					\
+    if (p->i[j] != (TYPE) (i + j))				\
+      {								\
+	DEBUG_FAIL;						\
+      }								\
+}								\
+								\
+void								\
+testit##NAME##N (void)						\
+{								\
+  struct S##NAME##N rslt;					\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" init: ");					\
+  init##NAME##N  ( &g1s##NAME##N,  1*16);			\
+  init##NAME##N  ( &g2s##NAME##N,  2*16);			\
+  init##NAME##N  ( &g3s##NAME##N,  3*16);			\
+  init##NAME##N  ( &g4s##NAME##N,  4*16);			\
+  init##NAME##N  ( &g5s##NAME##N,  5*16);			\
+  init##NAME##N  ( &g6s##NAME##N,  6*16);			\
+  init##NAME##N  ( &g7s##NAME##N,  7*16);			\
+  init##NAME##N  ( &g8s##NAME##N,  8*16);			\
+  init##NAME##N  ( &g9s##NAME##N,  9*16);			\
+  init##NAME##N  (&g10s##NAME##N, 10*16);			\
+  init##NAME##N  (&g11s##NAME##N, 11*16);			\
+  init##NAME##N  (&g12s##NAME##N, 12*16);			\
+  init##NAME##N  (&g13s##NAME##N, 13*16);			\
+  init##NAME##N  (&g14s##NAME##N, 14*16);			\
+  init##NAME##N  (&g15s##NAME##N, 15*16);			\
+  init##NAME##N  (&g16s##NAME##N, 16*16);			\
+  checkg##NAME##N ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##NAME##N ();					\
+  check##NAME##N (&rslt, 1*16);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#NAME "[" #N "]");				\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##NAME##N (g1s##NAME##N);				\
+  check##NAME##N (&rslt, 1*16);					\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#NAME "[" #N "]");				\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##NAME##N (1, g1s##NAME##N);			\
+      check##NAME##N (&rslt, 1*16);				\
+      rslt = testva##NAME##N (5,				\
+			      g1s##NAME##N, g2s##NAME##N,	\
+			      g3s##NAME##N, g4s##NAME##N,	\
+			      g5s##NAME##N);			\
+      check##NAME##N (&rslt, 5*16);				\
+      rslt = testva##NAME##N (9,				\
+			      g1s##NAME##N, g2s##NAME##N,	\
+			      g3s##NAME##N, g4s##NAME##N,	\
+			      g5s##NAME##N, g6s##NAME##N,	\
+			      g7s##NAME##N, g8s##NAME##N,	\
+			      g9s##NAME##N);			\
+      check##NAME##N (&rslt, 9*16);				\
+      rslt = testva##NAME##N (16,				\
+			      g1s##NAME##N, g2s##NAME##N,	\
+			      g3s##NAME##N, g4s##NAME##N,	\
+			      g5s##NAME##N, g6s##NAME##N,	\
+			      g7s##NAME##N, g8s##NAME##N,	\
+			      g9s##NAME##N, g10s##NAME##N,	\
+			      g11s##NAME##N, g12s##NAME##N,	\
+			      g13s##NAME##N, g14s##NAME##N,	\
+			      g15s##NAME##N, g16s##NAME##N);	\
+      check##NAME##N (&rslt, 16*16);				\
+    }								\
+  DEBUG_NL;							\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, uc, unsigned char)
+#endif
+T(1, uc, unsigned char)
+T(2, uc, unsigned char)
+T(3, uc, unsigned char)
+T(4, uc, unsigned char)
+T(5, uc, unsigned char)
+T(6, uc, unsigned char)
+T(7, uc, unsigned char)
+T(8, uc, unsigned char)
+T(9, uc, unsigned char)
+T(10, uc, unsigned char)
+T(11, uc, unsigned char)
+T(12, uc, unsigned char)
+T(13, uc, unsigned char)
+T(14, uc, unsigned char)
+T(15, uc, unsigned char)
+#ifndef SKIP_ZERO_ARRAY
+T(0, us, unsigned short)
+#endif
+T(1, us, unsigned short)
+T(2, us, unsigned short)
+T(3, us, unsigned short)
+T(4, us, unsigned short)
+T(5, us, unsigned short)
+T(6, us, unsigned short)
+T(7, us, unsigned short)
+T(8, us, unsigned short)
+T(9, us, unsigned short)
+T(10, us, unsigned short)
+T(11, us, unsigned short)
+T(12, us, unsigned short)
+T(13, us, unsigned short)
+T(14, us, unsigned short)
+T(15, us, unsigned short)
+#ifndef SKIP_ZERO_ARRAY
+T(0, ui, unsigned int)
+#endif
+T(1, ui, unsigned int)
+T(2, ui, unsigned int)
+T(3, ui, unsigned int)
+T(4, ui, unsigned int)
+T(5, ui, unsigned int)
+T(6, ui, unsigned int)
+T(7, ui, unsigned int)
+T(8, ui, unsigned int)
+T(9, ui, unsigned int)
+T(10, ui, unsigned int)
+T(11, ui, unsigned int)
+T(12, ui, unsigned int)
+T(13, ui, unsigned int)
+T(14, ui, unsigned int)
+T(15, ui, unsigned int)
+
+#undef T
+
+void
+struct_return_2_x ()
+{
+DEBUG_INIT
+
+#define T(N, NAME, TYPE) testit##NAME##N ();
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, uc, unsigned char)
+#endif
+T(1, uc, unsigned char)
+T(2, uc, unsigned char)
+T(3, uc, unsigned char)
+T(4, uc, unsigned char)
+T(5, uc, unsigned char)
+T(6, uc, unsigned char)
+T(7, uc, unsigned char)
+T(8, uc, unsigned char)
+T(9, uc, unsigned char)
+T(10, uc, unsigned char)
+T(11, uc, unsigned char)
+T(12, uc, unsigned char)
+T(13, uc, unsigned char)
+T(14, uc, unsigned char)
+T(15, uc, unsigned char)
+#ifndef SKIP_ZERO_ARRAY
+T(0, us, unsigned short)
+#endif
+T(1, us, unsigned short)
+T(2, us, unsigned short)
+T(3, us, unsigned short)
+T(4, us, unsigned short)
+T(5, us, unsigned short)
+T(6, us, unsigned short)
+T(7, us, unsigned short)
+T(8, us, unsigned short)
+T(9, us, unsigned short)
+T(10, us, unsigned short)
+T(11, us, unsigned short)
+T(12, us, unsigned short)
+T(13, us, unsigned short)
+T(14, us, unsigned short)
+T(15, us, unsigned short)
+#ifndef SKIP_ZERO_ARRAY
+T(0, ui, unsigned int)
+#endif
+T(1, ui, unsigned int)
+T(2, ui, unsigned int)
+T(3, ui, unsigned int)
+T(4, ui, unsigned int)
+T(5, ui, unsigned int)
+T(6, ui, unsigned int)
+T(7, ui, unsigned int)
+T(8, ui, unsigned int)
+T(9, ui, unsigned int)
+T(10, ui, unsigned int)
+T(11, ui, unsigned int)
+T(12, ui, unsigned int)
+T(13, ui, unsigned int)
+T(14, ui, unsigned int)
+T(15, ui, unsigned int)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_y.c
new file mode 100644
index 000000000..7d7df8ef6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-2_y.c
@@ -0,0 +1,126 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#define T(N, NAME, TYPE)					\
+struct S##NAME##N { TYPE i[N]; };				\
+								\
+extern struct S##NAME##N g1s##NAME##N, g2s##NAME##N;		\
+extern struct S##NAME##N g3s##NAME##N, g4s##NAME##N;		\
+extern struct S##NAME##N g5s##NAME##N, g6s##NAME##N;		\
+extern struct S##NAME##N g7s##NAME##N, g8s##NAME##N;		\
+extern struct S##NAME##N g9s##NAME##N, g10s##NAME##N;		\
+extern struct S##NAME##N g11s##NAME##N, g12s##NAME##N;		\
+extern struct S##NAME##N g13s##NAME##N, g14s##NAME##N;		\
+extern struct S##NAME##N g15s##NAME##N, g16s##NAME##N;		\
+								\
+extern void check##NAME##N (struct S##NAME##N *p, int i);	\
+								\
+void								\
+init##NAME##N (struct S##NAME##N *p, int i)			\
+{								\
+  int j;							\
+  for (j = 0; j < N; j++)					\
+    p->i[j] = i + j;						\
+}								\
+								\
+void								\
+checkg##NAME##N (void)						\
+{								\
+  check##NAME##N ( &g1s##NAME##N,  1*16);			\
+  check##NAME##N ( &g2s##NAME##N,  2*16);			\
+  check##NAME##N ( &g3s##NAME##N,  3*16);			\
+  check##NAME##N ( &g4s##NAME##N,  4*16);			\
+  check##NAME##N ( &g5s##NAME##N,  5*16);			\
+  check##NAME##N ( &g6s##NAME##N,  6*16);			\
+  check##NAME##N ( &g7s##NAME##N,  7*16);			\
+  check##NAME##N ( &g8s##NAME##N,  8*16);			\
+  check##NAME##N ( &g9s##NAME##N,  9*16);			\
+  check##NAME##N (&g10s##NAME##N, 10*16);			\
+  check##NAME##N (&g11s##NAME##N, 11*16);			\
+  check##NAME##N (&g12s##NAME##N, 12*16);			\
+  check##NAME##N (&g13s##NAME##N, 13*16);			\
+  check##NAME##N (&g14s##NAME##N, 14*16);			\
+  check##NAME##N (&g15s##NAME##N, 15*16);			\
+  check##NAME##N (&g16s##NAME##N, 16*16);			\
+}								\
+								\
+struct S##NAME##N						\
+test0##NAME##N (void)						\
+{								\
+  return g1s##NAME##N;						\
+}								\
+								\
+struct S##NAME##N						\
+test1##NAME##N (struct S##NAME##N x01)				\
+{								\
+  return x01;							\
+}								\
+								\
+struct S##NAME##N						\
+testva##NAME##N (int n, ...)					\
+{								\
+  int i;							\
+  struct S##NAME##N rslt;					\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+    rslt = va_arg (ap, struct S##NAME##N);			\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+#ifndef SKIP_ZERO_ARRAY
+T(0, uc, unsigned char)
+#endif
+T(1, uc, unsigned char)
+T(2, uc, unsigned char)
+T(3, uc, unsigned char)
+T(4, uc, unsigned char)
+T(5, uc, unsigned char)
+T(6, uc, unsigned char)
+T(7, uc, unsigned char)
+T(8, uc, unsigned char)
+T(9, uc, unsigned char)
+T(10, uc, unsigned char)
+T(11, uc, unsigned char)
+T(12, uc, unsigned char)
+T(13, uc, unsigned char)
+T(14, uc, unsigned char)
+T(15, uc, unsigned char)
+#ifndef SKIP_ZERO_ARRAY
+T(0, us, unsigned short)
+#endif
+T(1, us, unsigned short)
+T(2, us, unsigned short)
+T(3, us, unsigned short)
+T(4, us, unsigned short)
+T(5, us, unsigned short)
+T(6, us, unsigned short)
+T(7, us, unsigned short)
+T(8, us, unsigned short)
+T(9, us, unsigned short)
+T(10, us, unsigned short)
+T(11, us, unsigned short)
+T(12, us, unsigned short)
+T(13, us, unsigned short)
+T(14, us, unsigned short)
+T(15, us, unsigned short)
+#ifndef SKIP_ZERO_ARRAY
+T(0, ui, unsigned int)
+#endif
+T(1, ui, unsigned int)
+T(2, ui, unsigned int)
+T(3, ui, unsigned int)
+T(4, ui, unsigned int)
+T(5, ui, unsigned int)
+T(6, ui, unsigned int)
+T(7, ui, unsigned int)
+T(8, ui, unsigned int)
+T(9, ui, unsigned int)
+T(10, ui, unsigned int)
+T(11, ui, unsigned int)
+T(12, ui, unsigned int)
+T(13, ui, unsigned int)
+T(14, ui, unsigned int)
+T(15, ui, unsigned int)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_main.c
new file mode 100644
index 000000000..83f0d119a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_main.c
@@ -0,0 +1,14 @@
+/* Test function return values.  For this test, all struct members are
+   scalar integral types and the structs are "small": 1, 2, 4, 8, and 12
+   bytes for LP64.  */
+
+extern void struct_return_3_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  struct_return_3_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_x.c
new file mode 100644
index 000000000..e985f91e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_x.c
@@ -0,0 +1,134 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(TYPE)							\
+TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern TYPE test0##TYPE (void);					\
+extern TYPE test1##TYPE (TYPE);					\
+extern TYPE testva##TYPE (int n, ...);				\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  (&g01##TYPE,  1);					\
+  init##TYPE  (&g02##TYPE,  2);					\
+  init##TYPE  (&g03##TYPE,  3);					\
+  init##TYPE  (&g04##TYPE,  4);					\
+  init##TYPE  (&g05##TYPE,  5);					\
+  init##TYPE  (&g06##TYPE,  6);					\
+  init##TYPE  (&g07##TYPE,  7);					\
+  init##TYPE  (&g08##TYPE,  8);					\
+  init##TYPE  (&g09##TYPE,  9);					\
+  init##TYPE  (&g10##TYPE, 10);					\
+  init##TYPE  (&g11##TYPE, 11);					\
+  init##TYPE  (&g12##TYPE, 12);					\
+  init##TYPE  (&g13##TYPE, 13);					\
+  init##TYPE  (&g14##TYPE, 14);					\
+  init##TYPE  (&g15##TYPE, 15);					\
+  init##TYPE  (&g16##TYPE, 16);					\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##TYPE ();					\
+  check##TYPE (rslt, 1);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##TYPE (g01##TYPE);				\
+  check##TYPE (rslt, 1);					\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#TYPE);					\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##TYPE (1, g01##TYPE);			\
+      check##TYPE (rslt, 1);					\
+      rslt = testva##TYPE (5, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE);				\
+      check##TYPE (rslt, 5);					\
+      rslt = testva##TYPE (9, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE);				\
+      check##TYPE (rslt, 9);					\
+      rslt = testva##TYPE (16, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE, g10##TYPE,		\
+			   g11##TYPE, g12##TYPE,		\
+			   g13##TYPE, g14##TYPE,		\
+			   g15##TYPE, g16##TYPE);		\
+      check##TYPE (rslt, 16);					\
+    }								\
+  DEBUG_NL;							\
+}
+
+#include "small-struct-defs.h"
+#include "small-struct-check.h"
+
+T(Sc)
+T(Ss)
+T(Si)
+T(Scs)
+T(Ssc)
+T(Sic)
+T(Sci)
+T(Ssi)
+T(Sis)
+T(Scsi)
+T(Scis)
+T(Ssci)
+T(Ssic)
+T(Sisc)
+T(Sics)
+
+#undef T
+
+void
+struct_return_3_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Sc)
+T(Ss)
+T(Si)
+T(Scs)
+T(Ssc)
+T(Sic)
+T(Sci)
+T(Ssi)
+T(Sis)
+T(Scsi)
+T(Scis)
+T(Ssci)
+T(Ssic)
+T(Sisc)
+T(Sics)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_y.c
new file mode 100644
index 000000000..dbd471351
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/struct-return-3_y.c
@@ -0,0 +1,76 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#include "small-struct-defs.h"
+#include "small-struct-init.h"
+
+#define T(TYPE)							\
+extern TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+extern TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+extern TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+extern TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (g01##TYPE,  1);					\
+  check##TYPE (g02##TYPE,  2);					\
+  check##TYPE (g03##TYPE,  3);					\
+  check##TYPE (g04##TYPE,  4);					\
+  check##TYPE (g05##TYPE,  5);					\
+  check##TYPE (g06##TYPE,  6);					\
+  check##TYPE (g07##TYPE,  7);					\
+  check##TYPE (g08##TYPE,  8);					\
+  check##TYPE (g09##TYPE,  9);					\
+  check##TYPE (g10##TYPE, 10);					\
+  check##TYPE (g11##TYPE, 11);					\
+  check##TYPE (g12##TYPE, 12);					\
+  check##TYPE (g13##TYPE, 13);					\
+  check##TYPE (g14##TYPE, 14);					\
+  check##TYPE (g15##TYPE, 15);					\
+  check##TYPE (g16##TYPE, 16);					\
+}								\
+								\
+TYPE								\
+test0##TYPE (void)						\
+{								\
+  return g01##TYPE;						\
+}								\
+								\
+TYPE								\
+test1##TYPE (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+      rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(Sc)
+T(Ss)
+T(Si)
+T(Scs)
+T(Ssc)
+T(Sic)
+T(Sci)
+T(Ssi)
+T(Sis)
+T(Scsi)
+T(Scis)
+T(Ssci)
+T(Ssic)
+T(Sisc)
+T(Sics)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_main.c
new file mode 100644
index 000000000..cd9065920
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_main.c
@@ -0,0 +1,13 @@
+/* Test function argument passing.  This was written when correcting
+   a deviation from the ABI on SPARC64 between 3.3 and 3.4.  */
+
+extern void union_by_value_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  union_by_value_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_x.c
new file mode 100644
index 000000000..a3efd4ed7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_x.c
@@ -0,0 +1,180 @@
+#include "compat-common.h"
+
+#define T(TYPE)							\
+TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;		\
+TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern void							\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16);		\
+extern void testva##TYPE (int n, ...);				\
+								\
+void								\
+test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,		\
+	      TYPE s5, TYPE s6, TYPE s7, TYPE s8)		\
+{								\
+  test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE,			\
+	      s3, g6s##TYPE, s4, g8s##TYPE,			\
+	      s5, g10s##TYPE, s6, g12s##TYPE,			\
+	      s7, g14s##TYPE, s8, g16s##TYPE);			\
+}								\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  ( &g1s##TYPE,  1);				\
+  init##TYPE  ( &g2s##TYPE,  2);				\
+  init##TYPE  ( &g3s##TYPE,  3);				\
+  init##TYPE  ( &g4s##TYPE,  4);				\
+  init##TYPE  ( &g5s##TYPE,  5);				\
+  init##TYPE  ( &g6s##TYPE,  6);				\
+  init##TYPE  ( &g7s##TYPE,  7);				\
+  init##TYPE  ( &g8s##TYPE,  8);				\
+  init##TYPE  ( &g9s##TYPE,  9);				\
+  init##TYPE  (&g10s##TYPE, 10);				\
+  init##TYPE  (&g11s##TYPE, 11);				\
+  init##TYPE  (&g12s##TYPE, 12);				\
+  init##TYPE  (&g13s##TYPE, 13);				\
+  init##TYPE  (&g14s##TYPE, 14);				\
+  init##TYPE  (&g15s##TYPE, 15);				\
+  init##TYPE  (&g16s##TYPE, 16);				\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test: ");					\
+  test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+	      g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+	      g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+	      g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE);	\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" testva:");					\
+  DEBUG_NL;							\
+  testva##TYPE (1,						\
+		g1s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (2,						\
+		g1s##TYPE, g2s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (3,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (4,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (5,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (6,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (7,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (8,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (9,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (10,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE);				\
+  DEBUG_NL;							\
+  testva##TYPE (11,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (12,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE);	\
+  DEBUG_NL;							\
+  testva##TYPE (13,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE);					\
+  DEBUG_NL;							\
+  testva##TYPE (14,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE);			\
+  DEBUG_NL;							\
+  testva##TYPE (15,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE);		\
+  DEBUG_NL;							\
+  testva##TYPE (16,						\
+		g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE,	\
+		g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE,	\
+		g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE,	\
+		g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test2:");					\
+  test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE,	\
+		g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE);	\
+  DEBUG_NL;							\
+}
+
+#include "union-defs.h"
+#include "union-check.h"
+
+T(Ucs)
+T(Uci)
+T(Ucl)
+T(Ucll)
+T(Usi)
+T(Usl)
+T(Usll)
+T(Uil)
+T(Uill)
+T(Ulll)
+
+#undef T
+
+void
+union_by_value_1_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Ucs)
+T(Uci)
+T(Ucl)
+T(Ucll)
+T(Usi)
+T(Usl)
+T(Usll)
+T(Uil)
+T(Uill)
+T(Ulll)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_y.c
new file mode 100644
index 000000000..b17613e99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-by-value-1_y.c
@@ -0,0 +1,92 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#include "union-defs.h"
+#include "union-init.h"
+
+#define T(TYPE)							\
+extern void check##TYPE (TYPE x, int i);			\
+extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE;		\
+extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE;		\
+extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE;	\
+extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE;	\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (  g1s##TYPE,  1);				\
+  check##TYPE (  g2s##TYPE,  2);				\
+  check##TYPE (  g3s##TYPE,  3);				\
+  check##TYPE (  g4s##TYPE,  4);				\
+  check##TYPE (  g5s##TYPE,  5);				\
+  check##TYPE (  g6s##TYPE,  6);				\
+  check##TYPE (  g7s##TYPE,  7);				\
+  check##TYPE (  g8s##TYPE,  8);				\
+  check##TYPE (  g9s##TYPE,  9);				\
+  check##TYPE ( g10s##TYPE, 10);				\
+  check##TYPE ( g11s##TYPE, 11);				\
+  check##TYPE ( g12s##TYPE, 12);				\
+  check##TYPE ( g13s##TYPE, 13);				\
+  check##TYPE ( g14s##TYPE, 14);				\
+  check##TYPE ( g15s##TYPE, 15);				\
+  check##TYPE ( g16s##TYPE, 16);				\
+}								\
+								\
+void								\
+test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4,			\
+	    TYPE s5, TYPE s6, TYPE s7, TYPE s8,			\
+	    TYPE s9, TYPE s10, TYPE s11, TYPE s12,		\
+	    TYPE s13, TYPE s14, TYPE s15, TYPE s16)		\
+{								\
+  check##TYPE (s1, 1);						\
+  check##TYPE (s2, 2);						\
+  check##TYPE (s3, 3);						\
+  check##TYPE (s4, 4);						\
+  check##TYPE (s5, 5);						\
+  check##TYPE (s6, 6);						\
+  check##TYPE (s7, 7);						\
+  check##TYPE (s8, 8);						\
+  check##TYPE (s9, 9);						\
+  check##TYPE (s10, 10);					\
+  check##TYPE (s11, 11);					\
+  check##TYPE (s12, 12);					\
+  check##TYPE (s13, 13);					\
+  check##TYPE (s14, 14);					\
+  check##TYPE (s15, 15);					\
+  check##TYPE (s16, 16);					\
+}								\
+								\
+void								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  va_list ap;							\
+  if (test_va)							\
+    {								\
+      va_start (ap, n);						\
+      for (i = 0; i < n; i++)					\
+	{							\
+	  TYPE t = va_arg (ap, TYPE);				\
+	  check##TYPE (t, i+1);					\
+	}							\
+      va_end (ap);						\
+    }								\
+}
+
+T(Ucs)
+T(Uci)
+T(Ucl)
+T(Ucll)
+T(Usi)
+T(Usl)
+T(Usll)
+T(Uil)
+T(Uill)
+T(Ulll)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-check.h
new file mode 100644
index 000000000..b5157814d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-check.h
@@ -0,0 +1,34 @@
+/* Function definitions that are used by multiple tests.  */
+
+#define CHECK_CHAR(TYPE)		\
+  void check##TYPE (TYPE p, int i)	\
+   { if (p.c != (char)i) DEBUG_CHECK }
+
+CHECK_CHAR(Ucs)
+CHECK_CHAR(Uci)
+CHECK_CHAR(Ucl)
+CHECK_CHAR(Ucll)
+
+
+#define CHECK_SHORT(TYPE)		\
+  void check##TYPE (TYPE p, int i)	\
+   { if (p.s != (short)i) DEBUG_CHECK }
+
+CHECK_SHORT(Usi)
+CHECK_SHORT(Usl)
+CHECK_SHORT(Usll)
+
+
+#define CHECK_INT(TYPE)			\
+  void check##TYPE (TYPE p, int i)	\
+   { if (p.i != i) DEBUG_CHECK }
+
+CHECK_INT(Uil)
+CHECK_INT(Uill)
+
+
+#define CHECK_LONG(TYPE)		\
+  void check##TYPE (TYPE p, int i)	\
+   { if (p.l != (long)i) DEBUG_CHECK }
+
+CHECK_LONG(Ulll)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-defs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-defs.h
new file mode 100644
index 000000000..887cd6da8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-defs.h
@@ -0,0 +1,15 @@
+/* Type definitions that are used by multiple tests.  */
+
+typedef union { char c; short s; } Ucs;
+typedef union { char c; int i; } Uci;
+typedef union { char c; long l; } Ucl;
+typedef union { char c; long long ll; } Ucll;
+
+typedef union { short s; int i; } Usi;
+typedef union { short s; long l; } Usl;
+typedef union { short s; long long ll; } Usll;
+
+typedef union { int i; long l; } Uil;
+typedef union { int i; long long ll; } Uill;
+
+typedef union { long l; long long ll; } Ulll;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-init.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-init.h
new file mode 100644
index 000000000..5add7b4a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-init.h
@@ -0,0 +1,34 @@
+/* Function definitions that are used by multiple tests.  */
+
+#define INIT_CHAR(TYPE)			\
+  void init##TYPE (TYPE *p, int i)	\
+   { p->c = (char)i; }
+
+INIT_CHAR(Ucs)
+INIT_CHAR(Uci)
+INIT_CHAR(Ucl)
+INIT_CHAR(Ucll)
+
+
+#define INIT_SHORT(TYPE)		\
+  void init##TYPE (TYPE *p, int i)	\
+   { p->s = (short)i; }
+
+INIT_SHORT(Usi)
+INIT_SHORT(Usl)
+INIT_SHORT(Usll)
+
+
+#define INIT_INT(TYPE)			\
+  void init##TYPE (TYPE *p, int i)	\
+   { p->i = i; }
+
+INIT_INT(Uil)
+INIT_INT(Uill)
+
+
+#define INIT_LONG(TYPE)			\
+  void init##TYPE (TYPE *p, int i)	\
+   { p->l = (long)i; }
+
+INIT_LONG(Ulll)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1.h
new file mode 100644
index 000000000..56d80cbfb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1.h
@@ -0,0 +1,17 @@
+#include <xmmintrin.h>
+
+typedef struct
+{
+  __m128 x;
+} SS_struct_mi128;
+
+typedef union
+{
+  __m128 x;
+} SS_union_mi128;
+
+typedef union
+{
+  __m128 x;
+  unsigned long long u[2];
+} union_mi128;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_main.c
new file mode 100644
index 000000000..11f872154
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_main.c
@@ -0,0 +1,24 @@
+/* { dg-skip-if "test SSE2 support" { ! { i?86-*-* x86_64-*-* } } } */
+/* { dg-options "-O" } */
+
+#include "cpuid.h"
+
+/* Test function argument passing.  PR target/15301.  */
+
+extern void union_m128_1_x (void);
+extern void exit (int);
+
+int
+main ()
+{
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE vector test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    union_m128_1_x ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_x.c
new file mode 100644
index 000000000..1f92303d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_x.c
@@ -0,0 +1,24 @@
+/* { dg-options "-O -msse2" } */
+
+#include "union-m128-1.h"
+
+SS_union_mi128 un;
+SS_struct_mi128 st;
+
+extern void bar ();
+extern void foo ();
+
+void
+union_m128_1_x ()
+{
+  union_mi128 x;
+
+  x.u [0] = 0x123456789abcedf0LL;
+  x.u [1] = 0xfedcba9876543210LL;
+  un.x = x.x;
+  st.x = x.x;
+  bar(un);
+  bar(st);
+  foo(un);
+  foo(st);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_y.c
new file mode 100644
index 000000000..be9d6e8f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-m128-1_y.c
@@ -0,0 +1,27 @@
+/* { dg-options "-O -msse2" } */
+
+#include <stdlib.h>
+
+#include "union-m128-1.h"
+
+void
+bar (SS_union_mi128 un)
+{
+  union_mi128 x;
+  
+  x.x = un.x;
+  if (x.u [0] != 0x123456789abcedf0LL
+      || x.u [1] != 0xfedcba9876543210LL)
+    abort ();
+}
+
+void
+foo (SS_struct_mi128 st)
+{
+  union_mi128 x;
+  
+  x.x = st.x;
+  if (x.u [0] != 0x123456789abcedf0LL
+      || x.u [1] != 0xfedcba9876543210LL)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_main.c
new file mode 100644
index 000000000..edf15166b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_main.c
@@ -0,0 +1,13 @@
+/* Test function return values.  This was written when correcting
+   a deviation from the ABI on SPARC64 between 3.3 and 3.4.  */
+
+extern void union_return_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  union_return_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_x.c
new file mode 100644
index 000000000..761f000aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_x.c
@@ -0,0 +1,124 @@
+#include "compat-common.h"
+
+#ifdef SKIP_VA
+const int test_va = 0;
+#else
+const int test_va = 1;
+#endif
+
+#define T(TYPE)							\
+TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void init##TYPE (TYPE *p, int i);			\
+extern void checkg##TYPE (void);				\
+extern TYPE test0##TYPE (void);					\
+extern TYPE test1##TYPE (TYPE);					\
+extern TYPE testva##TYPE (int n, ...);				\
+								\
+void								\
+testit##TYPE (void)						\
+{								\
+  TYPE rslt;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" init: ");					\
+  init##TYPE  (&g01##TYPE,  1);					\
+  init##TYPE  (&g02##TYPE,  2);					\
+  init##TYPE  (&g03##TYPE,  3);					\
+  init##TYPE  (&g04##TYPE,  4);					\
+  init##TYPE  (&g05##TYPE,  5);					\
+  init##TYPE  (&g06##TYPE,  6);					\
+  init##TYPE  (&g07##TYPE,  7);					\
+  init##TYPE  (&g08##TYPE,  8);					\
+  init##TYPE  (&g09##TYPE,  9);					\
+  init##TYPE  (&g10##TYPE, 10);					\
+  init##TYPE  (&g11##TYPE, 11);					\
+  init##TYPE  (&g12##TYPE, 12);					\
+  init##TYPE  (&g13##TYPE, 13);					\
+  init##TYPE  (&g14##TYPE, 14);					\
+  init##TYPE  (&g15##TYPE, 15);					\
+  init##TYPE  (&g16##TYPE, 16);					\
+  checkg##TYPE ();						\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test0: ");					\
+  rslt = test0##TYPE ();					\
+  check##TYPE (rslt, 1);					\
+  DEBUG_NL;							\
+  DEBUG_FPUTS (#TYPE);						\
+  DEBUG_FPUTS (" test1: ");					\
+  rslt = test1##TYPE (g01##TYPE);				\
+  check##TYPE (rslt, 1);					\
+  if (test_va)							\
+    {								\
+      DEBUG_NL;							\
+      DEBUG_FPUTS (#TYPE);					\
+      DEBUG_FPUTS (" testva: ");				\
+      rslt = testva##TYPE (1, g01##TYPE);			\
+      check##TYPE (rslt, 1);					\
+      rslt = testva##TYPE (5, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE);				\
+      check##TYPE (rslt, 5);					\
+      rslt = testva##TYPE (9, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE);				\
+      check##TYPE (rslt, 9);					\
+      rslt = testva##TYPE (16, g01##TYPE, g02##TYPE,		\
+			   g03##TYPE, g04##TYPE,		\
+			   g05##TYPE, g06##TYPE,		\
+			   g07##TYPE, g08##TYPE,		\
+			   g09##TYPE, g10##TYPE,		\
+			   g11##TYPE, g12##TYPE,		\
+			   g13##TYPE, g14##TYPE,		\
+			   g15##TYPE, g16##TYPE);		\
+      check##TYPE (rslt, 16);					\
+    }								\
+  DEBUG_NL;							\
+}
+
+#include "union-defs.h"
+#include "union-check.h"
+
+T(Ucs)
+T(Uci)
+T(Ucl)
+T(Ucll)
+T(Usi)
+T(Usl)
+T(Usll)
+T(Uil)
+T(Uill)
+T(Ulll)
+
+#undef T
+
+void
+union_return_1_x ()
+{
+DEBUG_INIT
+
+#define T(TYPE) testit##TYPE ();
+
+T(Ucs)
+T(Uci)
+T(Ucl)
+T(Ucll)
+T(Usi)
+T(Usl)
+T(Usll)
+T(Uil)
+T(Uill)
+T(Ulll)
+
+DEBUG_FINI
+
+if (fails != 0)
+  abort ();
+
+#undef T
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_y.c
new file mode 100644
index 000000000..9eaa9777e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/union-return-1_y.c
@@ -0,0 +1,71 @@
+#include <stdarg.h>
+
+#include "compat-common.h"
+
+#include "union-defs.h"
+#include "union-init.h"
+
+#define T(TYPE)							\
+extern TYPE g01##TYPE, g02##TYPE, g03##TYPE, g04##TYPE;		\
+extern TYPE g05##TYPE, g06##TYPE, g07##TYPE, g08##TYPE;		\
+extern TYPE g09##TYPE, g10##TYPE, g11##TYPE, g12##TYPE;		\
+extern TYPE g13##TYPE, g14##TYPE, g15##TYPE, g16##TYPE;		\
+								\
+extern void check##TYPE (TYPE x, int i);			\
+								\
+void								\
+checkg##TYPE (void)						\
+{								\
+  check##TYPE (g01##TYPE,  1);					\
+  check##TYPE (g02##TYPE,  2);					\
+  check##TYPE (g03##TYPE,  3);					\
+  check##TYPE (g04##TYPE,  4);					\
+  check##TYPE (g05##TYPE,  5);					\
+  check##TYPE (g06##TYPE,  6);					\
+  check##TYPE (g07##TYPE,  7);					\
+  check##TYPE (g08##TYPE,  8);					\
+  check##TYPE (g09##TYPE,  9);					\
+  check##TYPE (g10##TYPE, 10);					\
+  check##TYPE (g11##TYPE, 11);					\
+  check##TYPE (g12##TYPE, 12);					\
+  check##TYPE (g13##TYPE, 13);					\
+  check##TYPE (g14##TYPE, 14);					\
+  check##TYPE (g15##TYPE, 15);					\
+  check##TYPE (g16##TYPE, 16);					\
+}								\
+								\
+TYPE								\
+test0##TYPE (void)						\
+{								\
+  return g01##TYPE;						\
+}								\
+								\
+TYPE								\
+test1##TYPE (TYPE x01)						\
+{								\
+  return x01;							\
+}								\
+								\
+TYPE								\
+testva##TYPE (int n, ...)					\
+{								\
+  int i;							\
+  TYPE rslt;							\
+  va_list ap;							\
+  va_start (ap, n);						\
+  for (i = 0; i < n; i++)					\
+      rslt = va_arg (ap, TYPE);					\
+  va_end (ap);							\
+  return rslt;							\
+}
+
+T(Ucs)
+T(Uci)
+T(Ucl)
+T(Ucll)
+T(Usi)
+T(Usl)
+T(Usll)
+T(Uil)
+T(Uill)
+T(Ulll)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_main.c
new file mode 100644
index 000000000..6c995e7c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_main.c
@@ -0,0 +1,14 @@
+/* Test compatibility of vector types: layout between separately-compiled
+   modules, parameter passing, and function return.  This test uses
+   vectors of integer values.  */
+
+extern void vector_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  vector_1_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_x.c
new file mode 100644
index 000000000..ab4f88bf4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_x.c
@@ -0,0 +1,50 @@
+/* { dg-options "-w" } */
+
+#ifndef SKIP_ATTRIBUTE
+
+#include "compat-common.h"
+#include "vector-defs.h"
+#include "vector-setup.h"
+
+SETUP (8, qi);
+SETUP (16, qi);
+SETUP (32, qi);
+SETUP (2, hi);
+SETUP (4, hi);
+SETUP (8, hi);
+SETUP (16, hi);
+SETUP (2, si);
+SETUP (4, si);
+SETUP (8, si);
+SETUP (1, di);
+SETUP (2, di);
+SETUP (4, di);
+
+#endif
+
+void
+vector_1_x (void)
+{
+#ifndef SKIP_ATTRIBUTE
+  DEBUG_INIT
+
+  CHECK (8, qi);
+  CHECK (16, qi);
+  CHECK (32, qi);
+  CHECK (2, hi);
+  CHECK (4, hi);
+  CHECK (8, hi);
+  CHECK (16, hi);
+  CHECK (2, si);
+  CHECK (4, si);
+  CHECK (8, si);
+  CHECK (1, di);
+  CHECK (2, di);
+  CHECK (4, di);
+
+  DEBUG_FINI
+
+  if (fails != 0)
+    abort ();
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_y.c
new file mode 100644
index 000000000..5a09c0ead
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1_y.c
@@ -0,0 +1,23 @@
+/* { dg-options "-w" } */
+
+#ifndef SKIP_ATTRIBUTE
+
+#include "compat-common.h"
+#include "vector-defs.h"
+#include "vector-check.h"
+
+TEST (8, qi, 101)
+TEST (16, qi, 101)
+TEST (32, qi, 90)
+TEST (2, hi, 201)
+TEST (4, hi, 202)
+TEST (8, hi, 203)
+TEST (16, hi, 203)
+TEST (2, si, 301)
+TEST (4, si, 302)
+TEST (8, si, 303)
+TEST (1, di, 401)
+TEST (2, di, 402)
+TEST (4, di, 403)
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_main.c
new file mode 100644
index 000000000..76fb2915e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_main.c
@@ -0,0 +1,26 @@
+/* { dg-skip-if "test SSE2 vector" { ! { i?86-*-* x86_64-*-* } } } */
+
+/* Test compatibility of vector types: layout between separately-compiled
+   modules, parameter passing, and function return.  This test uses
+   vectors of integer values.  */
+
+#include "cpuid.h"
+
+extern void vector_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE vector test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    vector_1_x ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_x.c
new file mode 100644
index 000000000..aa0fa7f20
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_x.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -msse2" } */
+
+#include "vector-1_x.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_y.c
new file mode 100644
index 000000000..2c88e1988
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1a_y.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -msse2" } */
+
+#include "vector-1_y.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_main.c
new file mode 100644
index 000000000..fb5a5a93d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_main.c
@@ -0,0 +1,27 @@
+/* { dg-skip-if "test AVX vector" { ! { i?86-*-* x86_64-*-* } } } */
+/* { dg-require-effective-target avx } */
+
+/* Test compatibility of vector types: layout between separately-compiled
+   modules, parameter passing, and function return.  This test uses
+   vectors of integer values.  */
+
+#include "cpuid.h"
+
+extern void vector_1_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run AVX vector test only if host has AVX support.  */
+  if (ecx & bit_AVX)
+    vector_1_x ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_x.c
new file mode 100644
index 000000000..fe2565cc6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_x.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -mavx" } */
+
+#include "vector-1_x.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_y.c
new file mode 100644
index 000000000..3212bf55d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-1b_y.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -mavx" } */
+
+#include "vector-1_y.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_main.c
new file mode 100644
index 000000000..37f36fe0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_main.c
@@ -0,0 +1,14 @@
+/* Test compatibility of vector types: layout between separately-compiled
+   modules, parameter passing, and function return.  This test uses
+   vectors of floating points values.  */
+
+extern void vector_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  vector_2_x ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_x.c
new file mode 100644
index 000000000..d08c77fe3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_x.c
@@ -0,0 +1,37 @@
+/* { dg-options "-w" } */
+/* { dg-options "-w -mno-mmx" { target { i?86-*-* x86_64-*-* } } } */
+
+#ifndef SKIP_ATTRIBUTE
+
+#include "compat-common.h"
+#include "vector-defs.h"
+#include "vector-setup.h"
+
+SETUP (2, sf);
+SETUP (4, sf);
+SETUP (16, sf);
+SETUP (8, sf);
+SETUP (2, df);
+SETUP (4, df);
+
+#endif
+
+void
+vector_2_x (void)
+{
+#ifndef SKIP_ATTRIBUTE
+  DEBUG_INIT
+
+  CHECK (2, sf);
+  CHECK (4, sf);
+  CHECK (8, sf);
+  CHECK (16, sf);
+  CHECK (4, df);
+  CHECK (2, df);
+
+  DEBUG_FINI
+
+  if (fails != 0)
+    abort ();
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_y.c
new file mode 100644
index 000000000..fd5830c35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2_y.c
@@ -0,0 +1,17 @@
+/* { dg-options "-w" } */
+/* { dg-options "-w -mno-mmx" { target { i?86-*-* x86_64-*-* } } } */
+
+#ifndef SKIP_ATTRIBUTE
+
+#include "compat-common.h"
+#include "vector-defs.h"
+#include "vector-check.h"
+
+TEST (2, sf, 301.0)
+TEST (4, sf, 302.0)
+TEST (8, sf, 303.0)
+TEST (16, sf, 304.0)
+TEST (2, df, 402.0)
+TEST (4, df, 402.0)
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_main.c
new file mode 100644
index 000000000..96c1111fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_main.c
@@ -0,0 +1,26 @@
+/* { dg-skip-if "test SSE2 support" { ! { i?86-*-* x86_64-*-* } } } */
+
+/* Test compatibility of vector types: layout between separately-compiled
+   modules, parameter passing, and function return.  This test uses
+   vectors of floating points values.  */
+
+#include "cpuid.h"
+
+extern void vector_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE vector test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    vector_2_x ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_x.c
new file mode 100644
index 000000000..fcfacec04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_x.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -msse2" } */
+
+#include "vector-2_x.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_y.c
new file mode 100644
index 000000000..3797acb6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2a_y.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -msse2" } */
+
+#include "vector-2_y.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_main.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_main.c
new file mode 100644
index 000000000..c5a9300c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_main.c
@@ -0,0 +1,27 @@
+/* { dg-skip-if "test AVX support" { ! { i?86-*-* x86_64-*-* } } } */
+/* { dg-require-effective-target avx } */
+
+/* Test compatibility of vector types: layout between separately-compiled
+   modules, parameter passing, and function return.  This test uses
+   vectors of floating points values.  */
+
+#include "cpuid.h"
+
+extern void vector_2_x (void);
+extern void exit (int);
+int fails;
+
+int
+main ()
+{
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run AVX vector test only if host has AVX support.  */
+  if (ecx & bit_AVX)
+    vector_2_x ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_x.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_x.c
new file mode 100644
index 000000000..4dd343615
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_x.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -mavx" } */
+
+#include "vector-2_x.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_y.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_y.c
new file mode 100644
index 000000000..2820e0bad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-2b_y.c
@@ -0,0 +1,3 @@
+/* { dg-options "-w -mno-mmx -mavx" } */
+
+#include "vector-2_y.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-check.h
new file mode 100644
index 000000000..2d586d287
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-check.h
@@ -0,0 +1,64 @@
+#define TEST(NUM,TMODE,VAL)				\
+extern v##NUM##TMODE g_v##NUM##TMODE;			\
+extern TMODE g_##TMODE;					\
+							\
+extern void pass_v##NUM##TMODE (v##NUM##TMODE);		\
+extern v##NUM##TMODE return_v##NUM##TMODE (void);	\
+							\
+void							\
+checkp_##NUM##TMODE (TMODE *p)				\
+{							\
+  int i;						\
+  for (i = 0; i < NUM; i++)				\
+    {							\
+      if (p[i] != g_##TMODE + i)			\
+	DEBUG_CHECK;					\
+    }							\
+}							\
+							\
+void							\
+checkg_##NUM##TMODE (void)				\
+{							\
+  u##NUM##TMODE u;					\
+  TMODE *p = u.a;					\
+							\
+  u.v = g_v##NUM##TMODE;				\
+  checkp_##NUM##TMODE (p);				\
+}							\
+							\
+void							\
+init_##NUM##TMODE (void)				\
+{							\
+  int i;						\
+  u##NUM##TMODE u;					\
+  g_##TMODE = VAL;					\
+  for (i = 0; i < NUM; i++)				\
+    u.a[i] = VAL + i;					\
+  g_v##NUM##TMODE = u.v;				\
+}							\
+							\
+void							\
+test_v##NUM##TMODE (void)				\
+{							\
+  v##NUM##TMODE v;					\
+  u##NUM##TMODE u;					\
+  TMODE *p = u.a;					\
+							\
+  DEBUG_FPUTS ("v" #NUM #TMODE);			\
+  DEBUG_NL;						\
+  DEBUG_FPUTS ("  global variable:");			\
+  init_##NUM##TMODE ();					\
+  checkg_##NUM##TMODE ();				\
+  DEBUG_NL;						\
+  DEBUG_FPUTS ("  pass global variable:");		\
+  pass_v##NUM##TMODE (g_v##NUM##TMODE);			\
+  DEBUG_NL;						\
+  DEBUG_FPUTS ("  pass local variable:");		\
+  v = g_v##NUM##TMODE;					\
+  pass_v##NUM##TMODE (v);				\
+  DEBUG_NL;						\
+  DEBUG_FPUTS ("  function return:");			\
+  u.v = return_v##NUM##TMODE ();			\
+  checkp_##NUM##TMODE (p);				\
+  DEBUG_NL;						\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-defs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-defs.h
new file mode 100644
index 000000000..f2f050527
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-defs.h
@@ -0,0 +1,90 @@
+/* This includes all of the vector modes that are recognized by
+   c_common_type_for_mode.  */
+
+typedef int __attribute__((mode(QI))) qi;
+typedef int __attribute__((mode(HI))) hi;
+typedef int __attribute__((mode(SI))) si;
+typedef int __attribute__((mode(DI))) di;
+typedef float __attribute__((mode(SF))) sf;
+#if ((__SIZEOF_DOUBLE__ >= 8) || (__SIZEOF_LONG_DOUBLE__ >= 8))
+typedef float __attribute__((mode(DF))) df;
+#else
+typedef float __attribute__((mode(SF))) df;
+#endif
+
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 5)
+
+typedef qi __attribute__((vector_size (8))) v8qi;
+typedef qi __attribute__((vector_size (16))) v16qi;
+
+typedef hi __attribute__((vector_size (4))) v2hi;
+typedef hi __attribute__((vector_size (8))) v4hi;
+typedef hi __attribute__((vector_size (16))) v8hi;
+
+typedef si __attribute__((vector_size (8))) v2si;
+typedef si __attribute__((vector_size (16))) v4si;
+
+typedef di __attribute__((vector_size (8))) v1di;
+typedef di __attribute__((vector_size (16))) v2di;
+
+typedef sf __attribute__((vector_size (8))) v2sf;
+typedef sf __attribute__((vector_size (16))) v4sf;
+typedef sf __attribute__((vector_size (64))) v16sf;
+
+typedef df __attribute__((vector_size (16))) v2df;
+
+#else
+
+typedef int __attribute__((mode(V8QI))) v8qi;
+typedef int __attribute__((mode(V16QI))) v16qi;
+
+typedef int __attribute__((mode(V2HI))) v2hi;
+typedef int __attribute__((mode(V4HI))) v4hi;
+typedef int __attribute__((mode(V8HI))) v8hi;
+
+typedef int __attribute__((mode(V2SI))) v2si;
+typedef int __attribute__((mode(V4SI))) v4si;
+
+typedef int __attribute__((mode(V1DI))) v1di;
+typedef int __attribute__((mode(V2DI))) v2di;
+
+typedef float __attribute__((mode(V2SF))) v2sf;
+typedef float __attribute__((mode(V4SF))) v4sf;
+typedef float __attribute__((mode(V16SF))) v16sf;
+
+typedef float __attribute__((mode(V2DF))) v2df;
+
+#endif
+
+typedef qi __attribute__((vector_size (32))) v32qi;
+typedef hi __attribute__((vector_size (32))) v16hi;
+typedef si __attribute__((vector_size (32))) v8si;
+typedef di __attribute__((vector_size (32))) v4di;
+typedef sf __attribute__((vector_size (32))) v8sf;
+typedef df __attribute__((vector_size (32))) v4df;
+
+typedef union U32QI { v32qi v; qi a[32]; } u32qi;
+typedef union U16HI { v16hi v; hi a[16]; } u16hi;
+typedef union U8SI { v8si v; si a[8]; } u8si;
+typedef union U4DI { v4di v; di a[4]; } u4di;
+typedef union U8SF { v8sf v; sf a[8]; } u8sf;
+typedef union U4DF { v4df v; df a[4]; } u4df;
+
+typedef union U8QI { v8qi v; qi a[8]; } u8qi;
+typedef union U16QI { v16qi v; qi a[16]; } u16qi;
+
+typedef union U2HI { v2hi v; hi a[2]; } u2hi;
+typedef union U4HI { v4hi v; hi a[4]; } u4hi;
+typedef union U8HI { v8hi v; hi a[8]; } u8hi;
+
+typedef union U2SI { v2si v; si a[2]; } u2si;
+typedef union U4SI { v4si v; si a[4]; } u4si;
+
+typedef union U1DI { v1di v; di a[1]; } u1di;
+typedef union U2DI { v2di v; di a[2]; } u2di;
+
+typedef union U2SF { v2sf v; sf a[2]; } u2sf;
+typedef union U4SF { v4sf v; sf a[4]; } u4sf;
+typedef union U16SF { v16sf v; sf a[16]; } u16sf;
+
+typedef union U2DF { v2df v; df a[2]; } u2df;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-setup.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-setup.h
new file mode 100644
index 000000000..60419f851
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compat/vector-setup.h
@@ -0,0 +1,28 @@
+#define SETUP(NUM,TMODE)				\
+v##NUM##TMODE g_v##NUM##TMODE;				\
+TMODE g_##TMODE;					\
+							\
+extern void test_v##NUM##TMODE (void);			\
+extern void checkp_##NUM##TMODE (TMODE *);		\
+							\
+void							\
+pass_v##NUM##TMODE (v##NUM##TMODE v)			\
+{							\
+  u##NUM##TMODE u;					\
+  int j;						\
+  TMODE a[NUM];						\
+  							\
+  u.v = v;						\
+  for (j = 0; j < NUM; j++)				\
+    a[j] = u.a[j];					\
+  checkp_##NUM##TMODE (a);				\
+}							\
+							\
+v##NUM##TMODE						\
+return_v##NUM##TMODE (void)				\
+{							\
+  return g_v##NUM##TMODE;				\
+}
+
+#define CHECK(NUM,TMODE)				\
+  test_v##NUM##TMODE()
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complete-port.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/complete-port.c
new file mode 100644
index 000000000..c8ebcc10e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complete-port.c
@@ -0,0 +1,96 @@
+/* This small program uses all the arithmetic operators that may
+   generate calls to library routines which must be implemented in
+   port-specific assembly language.  */
+/* { dg-do link } */
+
+#include <stddef.h>
+
+int foo ();
+double dfoo ();
+void discard (int);
+void ddiscard (double);
+
+int
+main (void)
+{
+  int a = foo (), b = foo ();
+  unsigned int au = foo (), bu = foo ();
+  float af = dfoo (), bf = dfoo ();
+  double ad = dfoo (), bd = dfoo ();
+
+  discard (a * b);
+  discard (a / b);
+  discard (a % b);
+
+  discard (au / bu);
+  discard (au % bu);
+
+  discard (a >> b);
+  discard (a << b);
+
+  discard (au >> bu);
+  discard (au << bu);
+
+  ddiscard (ad + bd);
+  ddiscard (ad - bd);
+  ddiscard (ad * bd);
+  ddiscard (ad / bd);
+  ddiscard (-ad);
+
+  ddiscard (af + bf);
+  ddiscard (af - bf);
+  ddiscard (af * bf);
+  ddiscard (af / bf);
+  ddiscard (-af);
+
+  discard ((int) ad);
+  discard ((int) af);
+
+  ddiscard ((double) a);
+  ddiscard ((float) a);
+  ddiscard ((float) ad);
+
+  discard (ad == bd);
+  discard (ad < bd);
+  discard (ad > bd);
+  discard (ad != bd);
+  discard (ad <= bd);
+  discard (ad >= bd);
+
+  discard (af == bf);
+  discard (af < bf);
+  discard (af > bf);
+  discard (af != bf);
+  discard (af <= bf);
+  discard (af >= bf);
+
+  return 0;
+}
+
+void
+discard (x)
+     int x __attribute__((__unused__));
+{}
+
+void
+ddiscard (x)
+     double x __attribute__((__unused__));
+{}
+
+int
+foo ()
+{
+  static int table[] = {20, 69, 4, 12};
+  static int idx;
+
+  return table[idx++];
+}
+
+double
+dfoo ()
+{
+  static double table[] = {20.4, 69.96, 4.4, 202.202};
+  static int idx;
+
+  return table[idx++];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-1.c
new file mode 100644
index 000000000..7153433d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-1.c
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+
+/* Verify that the 6th complex floating-point argument is
+   correctly passed as unnamed argument on SPARC64.  */
+
+extern void abort(void);   
+
+void foo(long arg1, long arg2, long arg3, long arg4, long arg5, ...)
+{
+  __builtin_va_list ap;
+  _Complex float cf;
+
+  __builtin_va_start(ap, arg5);
+  cf = __builtin_va_arg(ap, _Complex float);
+  __builtin_va_end(ap);
+
+  if (__imag__ cf != 2.0f)
+    abort();
+}
+
+int bar(long arg1, long arg2, long arg3, long arg4, long arg5, _Complex float arg6)
+{
+  foo(arg1, arg2, arg3, arg4, arg5, arg6);
+  return 0;
+}
+
+int main(void)
+{
+  return bar(0, 0, 0, 0, 0, 2.0fi);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-2.c
new file mode 100644
index 000000000..85adcde2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-2.c
@@ -0,0 +1,7 @@
+/* Allow complex types in system headers even with -std=iso9899:1990
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+#include "complex-2.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-2.h
new file mode 100644
index 000000000..752d7f26d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-2.h
@@ -0,0 +1,6 @@
+/* Allow complex types in system headers even with -std=iso9899:1990
+   -pedantic-errors.  Header file.  */
+
+#pragma GCC system_header
+
+_Complex double x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-3.c
new file mode 100644
index 000000000..54ec82c0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-3.c
@@ -0,0 +1,25 @@
+/* Verify that rtl expansion cleanup doesn't get too aggressive about
+   code dealing with complex CONCATs.  */
+/* { dg-do run } */
+/* { dg-options "-O -fno-tree-sra" } */
+
+extern void abort (void);
+extern void exit (int);
+
+__complex__ float foo (void)
+{
+  __complex__ float f[1];
+  __real__ f[0] = 1;
+  __imag__ f[0] = 1;
+  f[0] = __builtin_conjf (f[0]);
+  return f[0];
+}
+
+int main (void)
+{
+  __complex__ double d[1];
+  d[0] = foo ();
+  if (__real__ d[0] != 1 || __imag__ d[0] != -1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-4.c
new file mode 100644
index 000000000..6becd3b94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-4.c
@@ -0,0 +1,7 @@
+/* PR c/22393 */
+/* { dg-options "-O -std=gnu99" } */
+
+__complex__ double foo (__complex__ double x)
+{
+    return 1.0 / x * -1.0i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-5.c
new file mode 100644
index 000000000..41c4ba0b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/complex-5.c
@@ -0,0 +1,55 @@
+/* PR middle-end/33088 */
+/* Origin: Joseph S. Myers <jsm28@gcc.gnu.org> */
+
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* } } */
+/* { dg-options "-std=c99 -O -ffloat-store -lm" } */
+
+#include <fenv.h>
+#include <stdlib.h>
+
+volatile int x[1024];
+
+void __attribute__((noinline))
+fill_stack (void)
+{
+  volatile int y[1024];
+  int i;
+  for (i = 0; i < 1024; i++)
+    y[i] = 0x7ff00000;
+  for (i = 0; i < 1024; i++)
+    x[i] = y[i];
+}
+
+volatile _Complex double vc;
+
+void __attribute__((noinline))
+use_complex (_Complex double c)
+{
+  vc = c;
+}
+
+double t0, t1, t2, t3;
+
+#define USE_COMPLEX(X, R, C) \
+  do { __real__ X = R; __imag__ X = C; use_complex (X); } while (0)
+
+void __attribute__((noinline))
+use_stack (void)
+{
+  _Complex double a, b, c, d;
+  USE_COMPLEX (a, t0, t1);
+  USE_COMPLEX (b, t1, t2);
+  USE_COMPLEX (c, t2, t3);
+  USE_COMPLEX (d, t3, t0);
+}
+
+int
+main (void)
+{
+  fill_stack ();
+  feclearexcept (FE_INVALID);
+  use_stack ();
+  if (fetestexcept (FE_INVALID))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/compound-lvalue-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/compound-lvalue-1.c
new file mode 100644
index 000000000..30ed58ff8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/compound-lvalue-1.c
@@ -0,0 +1,13 @@
+/* Test for deprecation of compound expressions as lvalues.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int x, y;
+
+void
+foo (void)
+{
+  (x, y) = 1; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "lvalue" "compound expression as lvalue" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/concat.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/concat.c
new file mode 100644
index 000000000..0b9d6f6a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/concat.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+/* Test we output an error for concatenation of artificial strings.
+
+   Neil Booth, 10 Dec 2001.  */
+
+void foo ()
+{
+  char s1[] = __FUNCTION__".";	     /* { dg-error "(parse|syntax|expected|invalid|array)" } */
+  char s2[] = __PRETTY_FUNCTION__".";/* { dg-error "(parse|syntax|expected|invalid|array)" } */
+  char s3[] = "."__FUNCTION__;	     /* { dg-error "(parse|syntax|expected|invalid)" } */
+  char s4[] = "."__PRETTY_FUNCTION__;/* { dg-error "(parse|syntax|expected|invalid)" } */
+  char s5[] = "."".";                /* No error.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/concat2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/concat2.c
new file mode 100644
index 000000000..1e9240066
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/concat2.c
@@ -0,0 +1,16 @@
+/* PR c/3581 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Intended as a compile-time test for string literal concatenation.
+   The fact that the string isn't actually used in the resulting program
+   should allow this to compile for any target.  */
+
+#define e0	"a"
+#define e1	e0 e0 e0 e0 e0 e0 e0 e0 e0 e0
+#define e2	e1 e1 e1 e1 e1 e1 e1 e1 e1 e1
+#define e3	e2 e2 e2 e2 e2 e2 e2 e2 e2 e2
+#define e4	e3 e3 e3 e3 e3 e3 e3 e3 e3 e3
+#define e5	e4 e4 e4 e4 e4 e4 e4 e4 e4 e4
+
+void foo() { (void)(e5); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cond-constqual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cond-constqual-1.c
new file mode 100644
index 000000000..3354c7214
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cond-constqual-1.c
@@ -0,0 +1,15 @@
+/* Test for const qualification of type of conditional expression.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int foo (int) __attribute__ ((const));
+const int i;
+
+void
+test (void)
+{
+  __typeof__ (1 ? foo (0) : 0) texpr;
+  __typeof__ (1 ? i : 0) texpr2;
+  texpr = 0;  /* { dg-bogus "read-only variable" "conditional expression with call to const function" } */
+  texpr2 = 0; /* { dg-error "read-only variable" "conditional expression with const variable" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cond-lvalue-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cond-lvalue-1.c
new file mode 100644
index 000000000..f2605af6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cond-lvalue-1.c
@@ -0,0 +1,13 @@
+/* Test for deprecation of conditional expressions as lvalues.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int x, y, z;
+
+void
+foo (void)
+{
+  (x ? y : z) = 1; /* { dg-bogus "warning" "warning in place of error" } */
+}
+/* { dg-error "lvalue" "conditional expression as lvalue" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/const-elim-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-elim-1.c
new file mode 100644
index 000000000..c9c57a278
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-elim-1.c
@@ -0,0 +1,48 @@
+/* Verify that constants in memory, referenced only by dead code,
+   are not emitted to the object file.
+   FIXME: Not presently possible to apply -pedantic to code with
+   complex constants in it.  The __extension__ should shut up the
+   warning but doesn't.  (Hard to fix -- the lexer is not aware of
+   the parser's state.)  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=c99" } */
+/* { dg-final { scan-assembler-not "L\\\$?C\[^A-Z\]" } } */
+
+#define I (__extension__ 1.0iF)
+
+struct S { int a; double b[2]; void *c; };
+
+extern void use_str(const char *);
+extern void use_S(const struct S *);
+extern void use_cplx(__complex__ double);
+
+static inline int
+returns_23(void) { return 23; }
+
+void
+test1(void)
+{
+	if (returns_23() == 23)
+		return;
+
+	use_str("waltz, nymph, for quick jigs vex bud");
+	use_S(&(const struct S){12, {3.1415, 2.1828}, 0 });
+	use_cplx(3.1415 + 2.1828*I);
+}
+
+void
+test2(void)
+{
+	const char *str = "pack my box with five dozen liquor jugs";
+	const struct S S = { 23, { 1.414, 1.618 }, 0 };
+	const __complex__ double cplx = 1.414 + 1.618*I;
+
+	if (returns_23() == 23)
+		return;
+
+	use_str(str);
+	use_S(&S);
+	use_cplx(cplx);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/const-elim-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-elim-2.c
new file mode 100644
index 000000000..ce55ba1c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-elim-2.c
@@ -0,0 +1,10 @@
+/* The string constant in this test case should be emitted exactly once.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler-times "hi there" 1 } } */
+
+static inline int returns_23() { return 23; }
+
+const char *test1(void) { if (returns_23()) return 0; return "hi there"; }
+const char *test2(void) { return "hi there"; }
+const char *test3(void) { return "hi there"; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float128-ped.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float128-ped.c
new file mode 100644
index 000000000..6a6b6223c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float128-ped.c
@@ -0,0 +1,5 @@
+/* Test 'q' suffix with -pedantic on __float128 type constants.  */
+/* { dg-do compile { target ia64-*-* i?86-*-* x86_64-*-* } } */
+/* { dg-options "-pedantic" } */
+
+__float128 a = 123.456789q; /* { dg-warning "non-standard suffix on floating constant" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float128.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float128.c
new file mode 100644
index 000000000..116e4597b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float128.c
@@ -0,0 +1,6 @@
+/* Test 'q' and 'Q' suffixes on __float128 type constants.  */
+/* { dg-do compile { target ia64-*-* i?86-*-* x86_64-*-* } } */
+/* { dg-options "" } */
+
+__float128 a = 123.456789q;
+__float128 b = 123.456789Q;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float80-ped.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float80-ped.c
new file mode 100644
index 000000000..d1cf316dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float80-ped.c
@@ -0,0 +1,5 @@
+/* Test 'w' suffix with -pedantic on __float80 type constants.  */
+/* { dg-do compile { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "-pedantic" } */
+
+__float80 a = 123.456789w;  /* { dg-warning "non-standard suffix on floating constant" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float80.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float80.c
new file mode 100644
index 000000000..8ec771f8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/const-float80.c
@@ -0,0 +1,6 @@
+/* Test 'w' and 'W' suffixes on __float80 type constants.  */
+/* { dg-do compile { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "" } */
+
+__float80 a = 123.456789W;
+__float80 b = 123.456789w;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-1.c
new file mode 100644
index 000000000..07e41a6ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-1.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do compile } */
+
+double
+foo (unsigned long var)
+{
+  return var;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-2.c
new file mode 100644
index 000000000..388dee3d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-Wpointer-sign" } */
+
+void f1(long *); /* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" } */
+void f2(unsigned long *); /* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" } */
+
+int main()
+{
+  long *lp;
+  unsigned long *ulp;
+  char *cp;
+  unsigned char *ucp;
+  signed char *scp;
+
+  ulp = lp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  lp = ulp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  f1(ulp);	/* { dg-warning " differ in signedness" } */
+  f2(lp);	/* { dg-warning " differ in signedness" } */
+
+  cp = ucp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  cp = scp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  ucp = scp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  ucp = cp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  scp = ucp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+  scp = cp;	/* { dg-warning " pointer targets in assignment differ in signedness" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-3.c
new file mode 100644
index 000000000..3b4f4309d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/conv-3.c
@@ -0,0 +1,18 @@
+/* PR middle-end/19100 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort (void);
+
+int test (int v)
+{
+  return ((signed char) (v ? 0x100 : 0)) ? 17 : 18;
+}
+
+int main()
+{
+  if (test (2) != 18)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/convert-vec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/convert-vec-1.c
new file mode 100644
index 000000000..498729840
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/convert-vec-1.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+typedef float v2sf __attribute__ ((vector_size (8)));
+v2sf sub (void) { return (v2sf) 0.0; } /* { dg-error "can't convert" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/#cmdlne-M-2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/#cmdlne-M-2.h
new file mode 100644
index 000000000..40a8c178f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/#cmdlne-M-2.h
@@ -0,0 +1 @@
+/* empty */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19921210-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19921210-1.c
new file mode 100644
index 000000000..32d2a816e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19921210-1.c
@@ -0,0 +1,13 @@
+/* Test for proper disabling of macros within their own expansions.  */
+/* { dg-do compile } */
+
+/* The following is a trick to evaluate a complex boolean expression
+   at compile time, inspired by autoconf 2.13's sizeof-detection.  */
+
+enum { a = 4, f = 3 };
+
+#define a1(y) (y+2)
+#define a2(y) a1(y)+1
+#define f a+f
+
+char array[(a2(f)) == 10 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19930510-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19930510-1.c
new file mode 100644
index 000000000..62c120674
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19930510-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+extern void exit (int);
+
+#define ugly 3
+#ugly "foobar" 3	/* { dg-error "invalid" "invalid directive" } */
+int main() { exit (0); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1.c
new file mode 100644
index 000000000..98bcd7679
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1.c
@@ -0,0 +1,19 @@
+/* { dg-do preprocess } */
+/* PR 4713 */
+
+/* dg.exp doesn't read the header files for magic comments. */
+/* { dg-error "unterminated comment" "" { target *-*-* } 4 } */
+/* { dg-error "unterminated comment" "header error" { target *-*-* } 8 } */
+
+#include "19940712-1.h"	  /* { dg-message "" }  // In file included from: */
+#include "19940712-1a.h"  /* { dg-message "" }  // In file included from: */
+#include "19940712-1b.h"
+
+/* comment start in comment error
+/* in a .c file */
+
+int main ()
+{
+    return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1.h
new file mode 100644
index 000000000..183821334
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1.h
@@ -0,0 +1,10 @@
+/* comment start in comment error
+/* in a .h file */
+
+#if 0
+#endif /* comment start in comment error
+/* after a cpp directive */
+
+/* comment start in comment error
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1a.h
new file mode 100644
index 000000000..55ab6b844
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1a.h
@@ -0,0 +1,4 @@
+/* spanning a .h file */
+
+#if 0
+#endif /* comment start in comment error
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1b.h
new file mode 100644
index 000000000..d75156c04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19940712-1b.h
@@ -0,0 +1,2 @@
+/* spanning a .h file */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19951025-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19951025-1.c
new file mode 100644
index 000000000..b817b68c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19951025-1.c
@@ -0,0 +1,4 @@
+/* { dg-do preprocess } */
+/* { dg-error "include expects" "include" { target *-*-* } 4 } */
+/* { dg-error "newline at end" "newline" { target *-*-* } 4 } */
+#include /\
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19951227-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19951227-1.c
new file mode 100644
index 000000000..da2f6d851
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19951227-1.c
@@ -0,0 +1,3 @@
+/* { dg-do preprocess } */
+#if 0xe-1	/* { dg-error "invalid suffix" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19960224-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19960224-1.c
new file mode 100644
index 000000000..5efc62769
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19960224-1.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+
+#if 0
+#if 0
+#endif \
+\
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990119-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990119-1.c
new file mode 100644
index 000000000..10a7baae3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990119-1.c
@@ -0,0 +1,9 @@
+/* This checks for two things:
+   - an obscure corner case in the standard rules for __LINE__
+   - regression of an associated bug in cpplib where the semicolon got lost */
+/* { dg-do compile } */
+
+enum { i = __LINE__\
+};
+
+char array[i == 6 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990228-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990228-1.c
new file mode 100644
index 000000000..acae1169a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990228-1.c
@@ -0,0 +1,21 @@
+/* Regression test for cpp.  The following input may cause core dumps
+   or # line markers in the middle of the line.  */
+/* { dg-do preprocess } */
+
+#define foo(string, arg) bar(2, string, arg)
+
+foo ("\
+\
+\
+\
+\
+\
+\
+\
+\
+\
+\
+",
+NULL);
+
+/* { dg-final { scan-file-not 19990228-1.i "\[^\\n\]#" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990407-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990407-1.c
new file mode 100644
index 000000000..d6da8d656
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990407-1.c
@@ -0,0 +1,19 @@
+/* Regression test for a cpplib macro-expansion bug where
+   `@' becomes `@@' when stringified.  */
+
+/* { dg-do run } */
+
+#include <string.h>
+#include <stdlib.h>
+
+#define STR(x) #x
+
+char *a = STR(@foo), *b = "@foo";
+
+int
+main(void)
+{
+  if (strcmp (a, b))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990409-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990409-1.c
new file mode 100644
index 000000000..d7f5e2852
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990409-1.c
@@ -0,0 +1,6 @@
+/* Test that __LINE__ works when embedded in a macro. */
+/* { dg-do compile } */
+
+#define XLINE __LINE__
+
+char array[XLINE == __LINE__ ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990413-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990413-1.c
new file mode 100644
index 000000000..17d8441e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/19990413-1.c
@@ -0,0 +1,13 @@
+/* Verify that cpp doesn't screw up the line numbering when a macro argument
+   extends over multiple lines.  */
+/* { dg-do compile } */
+
+#define FOO(x)  /* nothing */
+
+void
+func(void)
+{
+  FOO(i
+      = 4)
+  else;  /* { dg-error "'else' without a previous 'if'" "error on this line" { target *-*-* } { 12 } } */ 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000127-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000127-1.c
new file mode 100644
index 000000000..467ad2c3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000127-1.c
@@ -0,0 +1,139 @@
+/* { dg-do compile } */
+
+/* Test for core dump in the preprocessor.  Originally exposed by
+   XEmacs, but this has been synthesized from scratch.  */
+
+#define foo(bar) bar
+
+int x = 
+foo(
+    /*
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+  */
+ 2);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000129-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000129-1.c
new file mode 100644
index 000000000..878002bee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000129-1.c
@@ -0,0 +1,15 @@
+/* Regression test for trigraph warnings.  Under certain conditions we
+   got the line numbers wrong.
+   Originally exposed by XEmacs and reported by Martin Buchholz
+   <martin@xemacs.org>; this test case is synthetic.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -Wall } */
+
+#define some_macro \
+	blah	\
+	blah	\
+	blah	\
+	blah
+
+??>	/* { dg-warning "trigraph ..." "trigraph encountered" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000207-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000207-1.c
new file mode 100644
index 000000000..931cc0d47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000207-1.c
@@ -0,0 +1,16 @@
+/* { dg-do preprocess } */
+
+/* Test for proper handling of unary minus in #if.  */
+
+#if !(-1)
+#error Error	/* { dg-bogus "Error" "case !(-1)" } */
+#endif
+
+#if !-1
+#error Error	/* { dg-bogus "Error" "case !-1" } */
+#endif
+
+#if -1
+#else
+#error Error	/* { dg-bogus "Error" "case -1" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000207-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000207-2.c
new file mode 100644
index 000000000..fbdf39e14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000207-2.c
@@ -0,0 +1,16 @@
+/* { dg-do preprocess } */
+
+/* Test for proper handling of unary plus in #if.  */
+
+#if !(+1)
+#error Error	/* { dg-bogus "Error" "case !(+1)" } */
+#endif
+
+#if !+1
+#error Error	/* { dg-bogus "Error" "case !+1" } */
+#endif
+
+#if +1
+#else
+#error Error	/* { dg-bogus "Error" "case +1" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000209-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000209-1.c
new file mode 100644
index 000000000..fe7105857
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000209-1.c
@@ -0,0 +1,34 @@
+/* { dg-do preprocess } */
+
+/* Tests for line numbering around function-like macro calls.
+   Bug found by Mark Mitchell.  */
+
+#define f(x) x
+#define g f
+
+f (3);
+#error here	/* { dg-error "here" "case 0" } */
+
+f
+  (3);
+#error here	/* { dg-error "here" "case 1" } */
+
+(f
+  )(3);
+#error here	/* { dg-error "here" "case 2" } */
+
+g
+  (3);
+#error here	/* { dg-error "here" "case 3" } */
+
+(g
+  )(3);
+#error here	/* { dg-error "here" "case 4" } */
+
+f /* some
+     text */  (3);
+#error here	/* { dg-error "here" "case 5" } */
+
+(g /* some
+      text */ )(3);
+#error here	/* { dg-error "here" "case 6" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000209-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000209-2.c
new file mode 100644
index 000000000..6a9198f64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000209-2.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+/* Distilled from glibc sources.  Tests preprocessor corner cases.
+   Since it uses rest args, we must turn off -pedantic-errors.  */
+
+#define NO_PAREN(rest...) rest
+#define DEFINE_CATEGORY(category, items) \
+const int _nl_value_type_##category[] = { NO_PAREN items }
+
+DEFINE_CATEGORY
+(
+ LC_COLLATE,
+ (
+   1,
+   2,
+   3,
+  ));
+
+DEFINE_CATEGORY(LC_CTYPE, (1, 2, 3));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000301-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000301-1.c
new file mode 100644
index 000000000..85645b062
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000301-1.c
@@ -0,0 +1,3 @@
+/* { dg-do preprocess } */
+/* Test for crash with indented empty definitions.  */
+ #define _LIBC_LIMITS_H_ /* nothing */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000419-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000419-1.c
new file mode 100644
index 000000000..c4400ee6c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000419-1.c
@@ -0,0 +1,15 @@
+/* Test for erroneous deletion of the entire macro expansion when pruning
+   \r escapes.  Problem noted by DJ Delorie <dj@delorie.com>; test case
+   distilled from GNU libc header files.  */
+/* { dg-do preprocess } */
+
+#define __REDIRECT(name, proto, alias) name proto __asm__ (__ASMNAME (#alias))
+#define __ASMNAME(cname)  __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
+#define __ASMNAME2(prefix, cname) __STRING (prefix) cname
+#define __STRING(x)    #x
+
+__REDIRECT (a, b, c)
+__ASMNAME2 (__USER_LABEL_PREFIX__, harumph)
+
+/* { dg-bogus "used without args" "no args, 1" { target *-*-* } 11 } */
+/* { dg-bogus "used without args" "no args, 1" { target *-*-* } 12 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000519-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000519-1.c
new file mode 100644
index 000000000..7cd7daa3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000519-1.c
@@ -0,0 +1,11 @@
+/* Regression test for preprocessor crash.
+   Reported by Mathias Froehlich <frohlich@na.uni-tuebingen.de>.  */
+/* { dg-do preprocess } */
+/* { dg-options "-ansi" } */
+#define foo
+
+#define __CAT__(a,b,c,d) a##b##c##d
+#define CAT(a,b,c,d) __CAT__(a,b,c,d)
+
+#define bar CAT(,foo,bar,)
+bar
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000529-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000529-1.c
new file mode 100644
index 000000000..6343a81fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000529-1.c
@@ -0,0 +1,14 @@
+/* Regression test for bug with macro expansion on #if lines -
+   exposed by glibc.  */
+/* { dg-do compile } */
+
+# define SHLIB_COMPAT(lib, introduced, obsoleted) \
+  (!(ABI_##lib##_##obsoleted - 0) \
+   || ((ABI_##lib##_##introduced - 0) < (ABI_##lib##_##obsoleted - 0)))
+
+#if 0
+bad
+#elif SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
+int
+#endif
+x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000625-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000625-1.c
new file mode 100644
index 000000000..01ce98bf6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000625-1.c
@@ -0,0 +1,17 @@
+
+/* Regression test for paste corner cases.  Distilled from
+   syscall stub logic in glibc.  */
+
+/* { dg-do compile } */
+
+#define ENTRY(name)	name##:
+#define socket bind
+
+int
+main(void)
+{
+  goto socket;
+
+  ENTRY(socket) /* { dg-error "valid preprocessing token" "" } */
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000627-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000627-1.c
new file mode 100644
index 000000000..dc0173244
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000627-1.c
@@ -0,0 +1,10 @@
+/* Test for spurious warnings with backslashes in perverse locations.
+   Bug exposed by Plumhall.  */
+/* { dg-do compile } */
+
+extern int bar;
+
+#def\
+ine foo bar
+
+int main(void) { return foo; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1.c
new file mode 100644
index 000000000..41b84108c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1.c
@@ -0,0 +1,5 @@
+/* Test if #line commands are generated properly even when header
+   includes self.  */
+/* { dg-do compile } */
+#include "20000628-1.h"
+int main(void) { return a + b + c; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1.h
new file mode 100644
index 000000000..2b2fb479e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1.h
@@ -0,0 +1,8 @@
+/* Test if #line commands are generated properly even when header
+   includes self.  */
+#include "20000628-1a.h"
+#ifndef t20000628_1_h
+#define t20000628_1_h 1
+#include "20000628-1.h"
+#include "20000628-1a.h"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1a.h
new file mode 100644
index 000000000..0fdc46d58
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000628-1a.h
@@ -0,0 +1,15 @@
+/* Included from 20000628-1.h.  This header is supposed to be seen
+   exactly three times.  */
+
+#if !defined A
+#define A
+int a;
+#elif !defined B
+#define B
+int b;
+#elif !defined C
+#define C
+int c;
+#else
+#error Included a fourth time
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000725-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000725-1.c
new file mode 100644
index 000000000..6fa72e454
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20000725-1.c
@@ -0,0 +1,3 @@
+/* { dg-do preprocess } */
+
+#define foo(x, y, defined) bar(x, y, defined)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20020927-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20020927-1.c
new file mode 100644
index 000000000..91f89518a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20020927-1.c
@@ -0,0 +1,91 @@
+/* Test case for buffer overflow bug in token stringification.
+   See PR preprocessor/8055 for details.
+   Reported by Alexander N. Kabaev <ak03@gte.com>.
+   Test case written by Zack Weinberg <zack@codesourcery.com>.  */
+
+/* { dg-do preprocess } */
+
+#define S(x) #x
+
+/* Fill up one internal buffer with data.  */
+S(1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  1234567890123456789012345678901234567890123456789012345678901234567890
+  12345678901234567890123456789012345678901234567890123456789012345)
+
+/* When stringify_arg() was called with an empty macro argument, it would
+   advance the buffer pointer by one but fail to check for running past the
+   end of the buffer.  We can only know where the end of the buffer is to
+   within about eight bytes, so do this sixteen times to be sure of hitting
+   it.  */
+
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+S()
+
+/* Now allocate more memory in the buffer, which should provoke a crash.  */
+
+S(abcdefghijklmnopqrstuvwxyz)
+S(abcdefghijklmnopqrstuvwxyz)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20050215-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20050215-1.c
new file mode 100644
index 000000000..e5aaf220e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/20050215-1.c
@@ -0,0 +1,10 @@
+/* Testcase for memory corruption bug in macro processing.
+   See PR preprocessor/19077 for details.  */
+
+/* { dg-do compile } */
+/* { dg-options "-g3" } */
+#define FOO(a,b,c,d,e) a b c d e \
+"                                                                           " \
+"                                                                           " \
+"                                                                             "
+int i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/System/Library/Frameworks/Carbon.framework/Headers/Carbon.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/System/Library/Frameworks/Carbon.framework/Headers/Carbon.h
new file mode 100644
index 000000000..4259c3718
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/System/Library/Frameworks/Carbon.framework/Headers/Carbon.h
@@ -0,0 +1,4 @@
+/* Used by gcc.dg/cpp/isysroot-2.c to test isysroot.  */
+void foo()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wmissingdirs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wmissingdirs.c
new file mode 100644
index 000000000..915aaa8de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wmissingdirs.c
@@ -0,0 +1,7 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu99 -I /jolly/well/better/not/exist -Wmissing-include-dirs -fno-show-column" } */
+
+/* Test that -Wmissing-include-dirs issues a warning when a specified
+   directory does not exist.  Source Ben Elliston, 2004-05-13.  */
+
+/* { dg-warning "No such file or directory" "-Wmissing-include-dirs" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wsignprom.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wsignprom.c
new file mode 100644
index 000000000..7cdbccb3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wsignprom.c
@@ -0,0 +1,26 @@
+/* { dg-do preprocess } */
+/* { dg-options "-Wall -fshow-column" } */
+
+/* Test that -Wall emits the warnings about integer promotion changing
+   the sign of an operand.  */
+
+#if -1 > 0U  /* { dg-warning "5:changes sign when promoted" } */
+#endif
+
+#if 0U + -1  /* { dg-warning "10:changes sign when promoted" } */
+#endif
+
+#if 0U * -1  /* { dg-warning "10:changes sign when promoted" } */
+#endif
+
+#if 1U / -2  /* { dg-warning "10:changes sign when promoted" } */
+#endif
+
+#if -1 % 1U  /* { dg-warning "5:changes sign when promoted" } */
+#endif
+
+#if 1 ? 0U : -1  /* { dg-warning "14:changes sign when promoted" } */
+#endif
+
+#if 1 ? -1 : 0U  /* { dg-warning "9:changes sign when promoted" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wtrigraphs-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wtrigraphs-2.c
new file mode 100644
index 000000000..43bf13484
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wtrigraphs-2.c
@@ -0,0 +1,20 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -Wtrigraphs -fno-show-column" } */
+
+/* Test warnings for trigraphs in comments, with trigraphs enabled.
+   Neil Booth.  4 May 2003.  */
+
+/* { dg-bogus "converted" } Test ??< ??= a few ??/ random things in
+   { dg-warning "converted" } some ??/
+   { dg-bogus "converted" } ??< comments.  */
+
+// { dg-bogus "converted" } More ??/ comment ??> tests.
+
+// { dg-warning "converted" } Another ??/
+   Test
+
+// { dg-warning "converted" } And another with space after ??/  
+   the escape
+
+// { dg-bogus "converted" } A tricky one ??/\
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wtrigraphs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wtrigraphs.c
new file mode 100644
index 000000000..5ed6c98ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wtrigraphs.c
@@ -0,0 +1,27 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu99 -Wtrigraphs -fno-show-column" } */
+
+/* Test we don't double warn for trigraphs immediately after preceding
+   text.  Source Neil Booth.  22 Nov 2000.  */
+
+abcdef??<			/* { dg-warning "ignored" } */
+123456??>			/* { dg-warning "ignored" } */
++??=				/* { dg-warning "ignored" } */
+
+/* Test we warn of escaped newlines only in comments.  Source Neil
+   Booth.  4 May 2003.  */
+
+/* { dg-bogus "ignored" } Test ??< ??= a few ??/ random things in
+   { dg-warning "ignored" } some ??/
+   { dg-bogus "ignored" } ??< comments.  */
+
+// { dg-bogus "ignored" } More ??/ comment ??> tests.
+
+// { dg-warning "ignored" } Another ??/
+   Test
+
+// { dg-warning "ignored" } And another with space after ??/  
+   the escape
+
+// { dg-bogus "ignored" } A tricky one ??/\
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunknown-pragmas-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunknown-pragmas-1.c
new file mode 100644
index 000000000..4f6a04be4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunknown-pragmas-1.c
@@ -0,0 +1,29 @@
+/* Copyright 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wunknown-pragmas" } */
+
+/* Make sure we get warnings in the expected lines.  */
+
+#pragma unknown1 /* { dg-warning "unknown1" "unknown1" } */
+
+#define COMMA ,
+#define FOO(x) x
+#define BAR(x) _Pragma("unknown_before") x
+#define BAZ(x) x _Pragma("unknown_after")
+
+int _Pragma("unknown2") bar1; /* { dg-warning "unknown2" "unknown2" } */
+
+FOO(int _Pragma("unknown3") bar2); /* { dg-warning "unknown3" "unknown3" } */
+
+int BAR(bar3); /* { dg-warning "unknown_before" "unknown_before 1" } */
+
+BAR(int bar4); /* { dg-warning "unknown_before" "unknown_before 2" } */
+
+int BAZ(bar5); /* { dg-warning "unknown_after" "unknown_after 1" } */
+
+int BAZ(bar6;) /* { dg-warning "unknown_after" "unknown_after 2" } */
+
+FOO(int bar7; _Pragma("unknown4")) /* { dg-warning "unknown4" "unknown4" } */
+
+#pragma unknown5 /* { dg-warning "unknown5" "unknown5" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunused.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunused.c
new file mode 100644
index 000000000..ac363ad04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunused.c
@@ -0,0 +1,38 @@
+/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* Duplicate command line options should not warn.  */
+/* { dg-options "-Wunused-macros -Dfoo -Dfoo" } */
+
+/* Test everything related to -Wunused-macros.
+
+   Source: Neil Booth, 23 Jul 2002.  */
+
+#include "Wunused.h"
+
+#define used1			/* { dg-bogus "used" } */
+#define used2			/* { dg-bogus "used" } */
+#define used3			/* { dg-bogus "used" } */
+#define used4 used4		/* { dg-bogus "used" } */
+
+#define unused5			/* { dg-warning "used" } */
+#define unused6			/* { dg-warning "used" } */
+#define unused7()		/* { dg-warning "used" } */
+
+#if defined used1
+#endif
+#ifdef used2
+#endif
+#ifndef used3
+#endif
+used4
+
+unused7				/* This does not count as a use.  */
+
+#if 0
+unused5				/* This does not count as a use.  */
+#endif
+#undef unused5
+
+#define unused6
+unused6
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunused.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunused.h
new file mode 100644
index 000000000..8b54412bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wunused.h
@@ -0,0 +1 @@
+#define unused_but_ok
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-1.c
new file mode 100644
index 000000000..88e27932e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-1.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Werror" } */
+
+#define f(x,...)	/* { dg-error "variadic" } */
+#define g(x,y...)	/* { dg-error "variadic" } */
+int not_empty;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-2.c
new file mode 100644
index 000000000..f72e311f6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Werror -Wno-variadic-macros" } */
+
+#define f(x,...)	/* { dg-bogus "variadic" } */
+#define g(x,y...)	/* { dg-bogus "variadic" } */
+int not_empty;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-3.c
new file mode 100644
index 000000000..056af8389
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-3.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Werror" } */
+
+#define f(x,...)
+#define g(x,y...)	/* { dg-error "variadic" } */
+int not_empty;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-4.c
new file mode 100644
index 000000000..428365e0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/Wvariadic-4.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Werror -Wno-variadic-macros" } */
+
+#define f(x,...)
+#define g(x,y...)
+int not_empty;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma1.c
new file mode 100644
index 000000000..0f211a985
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma1.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests the _Pragma operator.  Contributed by Neil Booth 1 Nov 2000.  */
+
+/* Within the preprocessor, the easy pragma to test is "poison".  */
+
+#pragma GCC poison p1
+p1				/* { dg-error "poisoned" } */
+
+/* Standard use of _Pragma.  */
+_Pragma ("GCC poison p2")
+p2				/* { dg-error "poisoned" } */
+
+/* Don't interpret _Pragmas in directives.  The standard is not clear
+   on this, but I think this makes most sense.  */
+#if 1 _Pragma (L"GCC poison p3") /* { dg-error "missing binary operator" } */
+p3
+#endif
+
+#define M1 _Pragma ("GCC poison p4")
+p4				/* No problem; not yet poisoned.  */
+#define M2(x) _Pragma (#x)
+
+/* Now test macro expansion with embedded _Pragmas.  */
+M1 p4				/* { dg-error "poisoned" } */
+M2 (GCC poison p5) p5		/* { dg-error "poisoned" } */
+
+/* Not interpreting _Pragma in directives means they don't nest.  */
+_Pragma ("_Pragma (\"GCC poison p6\") GCC poison p7")
+p6
+p7
+
+/* Check we ignore them in false conditionals.  */
+#if 0
+_Pragma ("GCC poison p8")
+#endif
+p8				/* No problem.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma2.c
new file mode 100644
index 000000000..24c4457ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma2.c
@@ -0,0 +1,13 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Don't allow directives in a _Pragma string. */
+
+/* Contributed by Neil Booth 14 Nov 2000.  */
+
+_Pragma("#define test")
+
+#ifdef test
+#error Do not allow directives in _Pragma strings
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma3.c
new file mode 100644
index 000000000..7d1b42aab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma3.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Pragma buffers have a NULL "inc" member, which we would dereference
+   when getting a file's date and time.
+
+   Based on PR 7526.  14 Aug 2002.  */
+
+#define GCC_PRAGMA(x) _Pragma (#x)
+GCC_PRAGMA(GCC dependency "mi1c.h")
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma4.c
new file mode 100644
index 000000000..f6f43d6b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma4.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+
+/* Based on Debian GNATS PR 157416.  3 Sep 2002.  */
+
+#define b foo _Pragma ("bar") baz
+a b c 
+
+/* { dg-final { scan-file "_Pragma4.i" "(^|\\n)#pragma bar($|\\n)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma5.c
new file mode 100644
index 000000000..141d56b9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma5.c
@@ -0,0 +1,10 @@
+/* { dg-do preprocess } */
+
+/* Based on Debian GNATS PR 8524.  17 Nov 2002.  */
+
+#define ALPHA(A) alpha_ ## A
+#define BETA(B) beta_ ## B
+#define GAMMA(C) _Pragma("moose") ALPHA(C) BETA(C)
+GAMMA(baz);
+
+/* { dg-final { scan-file "_Pragma5.i" "alpha_baz beta_baz;" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma6.c
new file mode 100644
index 000000000..74511a100
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/_Pragma6.c
@@ -0,0 +1,11 @@
+/* PR c/27747 */
+/* This is supposed to succeed only if
+   the target defines HANDLE_PRAGMA_PACK_PUSH_POP
+   and doesn't define HANDLE_PRAGMA_PACK_WITH_EXPANSION.  */
+/* { dg-do compile { target { ! { powerpc-ibm-aix* *-*-solaris2* fido-*-* m68k-*-* sh*-[us]*-elf m32c-*-* } } } } */
+
+#define push bar
+#define foo _Pragma ("pack(push)")
+foo
+int i;
+#pragma pack(pop)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/arith-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/arith-1.c
new file mode 100644
index 000000000..85d5848d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/arith-1.c
@@ -0,0 +1,257 @@
+/* Preprocessor arithmetic semantic tests.  */
+
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+/* Source: Neil Booth, 25 May 2002.  */
+
+/* The file tests all aspects of preprocessor arithmetic that are
+   independent of target precision.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -fno-show-column } */
+
+/* Test || operator and its short circuiting.  */
+#if 0 || 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 5 || 0
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0 || 1
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 || 4
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 || (8 / 0) /* { dg-bogus "division by zero" }  */
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 || (1 << 256) /* { dg-bogus "overflow" }  */
+#endif
+
+/* Test && operator and its short circuiting.  */
+#if (0 && 0) || (0 && 1) || (1 && 0)
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 && 2
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0 && (8 / 0)/* { dg-bogus "division by zero" }  */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0 && (1 << 256) /* { dg-bogus "overflow" }  */
+#endif
+
+/* Test == and != operators, and their signedness.  */
+#if 1 == 0 || 0 == 1 || 20 != 0x014 || 142 != 0216
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (1 == 1) - 2 > 0 || (1U != 1U) - 2 > 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test ? : operator, its short circuiting, and its signedness.  */
+#if (1 ? 3: 5) != 3 || (0 ? 3: 5) != 5
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 ? 0: 1 / 0 /* { dg-bogus "division by zero" }  */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0 ? 1 / 0: 0 /* { dg-bogus "division by zero" }  */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0 ? (1 << 256): 0 /* { dg-bogus "overflow" }  */
+#endif
+
+#if 1 ? 0: (1 << 256) /* { dg-bogus "overflow" }  */
+#endif
+
+/* Test unary + and its signedness.  */
+
+#if 23 != +23 || 23 != + +23
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (+1 - 2) > 0 || (+1U - 2) < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test unary - and its signedness.  */
+
+#if -1 + 1 != 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -1 >= 0 || -1U <= 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test unary ! and its signedness.  */
+#if !5 != 0 || !1 != 0 || !0 != 1
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if !5 - 1 > 0 || !5U - 1 > 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test unary ~ and its signedness.  */
+#if ~0 != -1 || ~~5 != 5 || ~-2 != 1
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if ~5 > 0 || ~5U < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test comparison operators and their signedness.  */
+#if 1 >= 1 && 2 >= 1 && -1 >= -1 && -1 >= -2 && 1 >= -1 && 1 >= -2 \
+    && !(-2 >= -1) && !(2 >= 3) && -1U >= 2 && !(-1 >= 1)
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if ((1 > 0) - 2) > 0 || ((1U > 0) - 2) > 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if !(1 > 1) && 2 > 1 && !(-1 > -1) && -1 > -2 && 1 > -1 && 1 > -2 \
+    && !(-2 > -1) && !(2 > 3) && -1U > 2 && !(-1 > 1)
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if ((1 >= 0) - 2) > 0 || ((1U >= 0) - 2) > 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 <= 1 && !(2 <= 1) && -1 <= -1 && !(-1 <= -2) && !(1 <= -1) && !(1 <= -2) \
+    && -2 <= -1 && 2 <= 3 && !(-1U <= 2) && -1 <= 1
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if ((1 <= 0) - 2) > 0 || ((1U <= 0) - 2) > 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if !(1 < 1) && !(2 < 1) && !(-1 < -1) && !(-1 < -2) && !(1 < -1) && !(1 < -2) \
+    && -2 < -1 && 2 < 3 && !(-1U < 2) && -1 < 1
+#else
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if ((1 < 0) - 2) > 0 || ((1U < 0) - 2) > 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test bitwise operators and their signedness.  */
+#if (3 & 7) != 3 || (-1 & 34) != 34
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 & 7) - 20 > 0 || (3 & 7U) - 20 < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 | 5) != 7 || (-1 | 34) != -1
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 | 7) - 20 > 0 || (3 | 7U) - 20 < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (7 ^ 5) != 2 || (-1 ^ 34) != ~34
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 ^ 7) - 20 > 0 || (3 ^ 7U) - 20 < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test shifts and their signedness.  */
+#if 3 << 2 != 12 || 3 << -2 != 0 || -1 << 1 != -2
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 5 >> 1 != 2 || 5 >> -2 != 20 || -5 >> 1 != -3
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (5 >> 2) - 2 >= 0 || (5U >> 2) - 2 <= 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (5 << 1) - 20 >= 0 || (5U << 1) - 20 <= 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0
+/* Test min / max and their signedness.  */
+#if (3 >? 2) != 3 || (-3 >? -2) != -2
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 <? 2) != 2 || (-3 <? -2) != -3
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 >? 2) - 4 >= 0 || (3 >? 2U) - 4 <= 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (3 <? 2) - 4 >= 0 || (3 <? 2U) - 4 <= 0
+# error		/* { dg-bogus "error" }  */
+#endif
+#endif
+
+/* Test *, / and % and their signedness.  */
+#if 3 * 2 != 6 || 3 * -2 != -6 || -2 * 3 != -6 || -2 * -3 != 6
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 3 * 2 - 7 >= 0 || 3 * 2U - 7 < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 5 / 2 != 2 || -325 / 50 != -6 || 53 / -4 != -13 || -55 / -12 != 4
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 3 / 2 - 7 >= 0 || 3 / 2U - 7 < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 5 % 2 != 1 || -325 % 50 != -25 || 53 % -4 != 1 || -55 % -12 != -7
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 3 % 2 - 7 >= 0 || 3U % 2 - 7 < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test , and its signedness.  */
+#if (1, 2) != 2 || (2, 1) != 1
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (1, 2) - 3 >= 0 || (1, 2U) - 3 <= 0 || (1U, 2) - 3 >= 0
+# error		/* { dg-bogus "error" }  */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/arith-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/arith-3.c
new file mode 100644
index 000000000..cc5fd1b3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/arith-3.c
@@ -0,0 +1,447 @@
+/* Preprocessor arithmetic semantic tests.  */
+
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+/* Source: Neil Booth, 26 May 2002.  */
+
+/* The file tests overflow warnings for, and values of, preprocessor
+   arithmetic that are dependent on target precision.
+
+   Please keep changes to arith-2.c and arith-3.c in sync.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -fno-show-column" } */
+
+#include <limits.h>
+
+#define APPEND2(NUM, SUFF) NUM ## SUFF
+#define APPEND(NUM, SUFF) APPEND2(NUM, SUFF)
+
+#define TARGET_UTYPE_MAX  ULLONG_MAX
+
+/* The tests in this file depend only on the macros defined in this
+   #if block.  Note that it is no good calculating these values, as
+   the intent is to test both the preprocessor's number parser and
+   arithmetic.  */
+#if TARGET_UTYPE_MAX == 65535ULL
+
+#  define TARG_PRECISION 16
+#  define MAX_INT  32767
+#  define MAX_UINT 65535
+
+#  define TARG_MAX_HEX 0x7fff
+#  define TARG_MAX_OCT 077777
+#  define TARG_MAX_PLUS_1 32768L
+#  define TARG_MAX_PLUS_1_U 32768UL
+#  define TARG_MAX_PLUS_1_HEX 0x8000
+#  define TARG_MAX_PLUS_1_OCT 0100000
+#  define UTARG_MAX_HEX 0xffff
+#  define UTARG_MAX_OCT 0177777
+#  define UTARG_MAX_PLUS_1 65536L
+#  define UTARG_MAX_PLUS_1_HEX 0x10000
+#  define UTARG_MAX_PLUS_1_OCT 0200000
+
+#  define TARG_LOWPART_PLUS_1 256L
+#  define TARG_LOWPART_PLUS_1_U 256UL
+
+  /* Division and modulo; anything that uses the high half in both
+     dividend and divisor.  */
+#  define LONG_UDIVISION 61234UL / 260L
+#  define LONG_UDIVISION_ANSWER 235
+#  define LONG_SDIVISION -15000L / 299L
+#  define LONG_SDIVISION_ANSWER -50
+#  define LONG_UMODULO 61234UL % 260L
+#  define LONG_UMODULO_ANSWER 134
+#  define LONG_SMODULO -15000L % 299L
+#  define LONG_SMODULO_ANSWER -50
+
+#elif TARGET_UTYPE_MAX == 4294967295ULL
+
+#  define TARG_PRECISION 32
+#  define MAX_INT  2147483647
+#  define MAX_UINT 4294967295
+
+#  define TARG_MAX_HEX 0x7fffffff
+#  define TARG_MAX_OCT 017777777777
+#  define TARG_MAX_PLUS_1 2147483648L
+#  define TARG_MAX_PLUS_1_U 2147483648UL
+#  define TARG_MAX_PLUS_1_HEX 0x80000000
+#  define TARG_MAX_PLUS_1_OCT 020000000000
+#  define UTARG_MAX_HEX 0xffffffff
+#  define UTARG_MAX_OCT 037777777777
+#  define UTARG_MAX_PLUS_1 4294967296L
+#  define UTARG_MAX_PLUS_1_HEX 0x100000000
+#  define UTARG_MAX_PLUS_1_OCT 040000000000
+
+#  define TARG_LOWPART_PLUS_1 65536
+#  define TARG_LOWPART_PLUS_1_U 65536UL
+
+  /* Division and modulo; anything that uses the high half in both
+     dividend and divisor.  */
+#  define LONG_UDIVISION 268335456UL / 70000L
+#  define LONG_UDIVISION_ANSWER 3833
+#  define LONG_SDIVISION -368335456L / 123456L
+#  define LONG_SDIVISION_ANSWER -2983
+#  define LONG_UMODULO 268335456UL % 70000L
+#  define LONG_UMODULO_ANSWER 25456
+#  define LONG_SMODULO -368335456L % 123456L
+#  define LONG_SMODULO_ANSWER -66208
+
+#elif TARGET_UTYPE_MAX == 18446744073709551615ULL
+
+#  define TARG_PRECISION 64
+#  define MAX_INT  9223372036854775807
+#  define MAX_UINT 18446744073709551615
+
+#  define TARG_MAX_HEX 0x7fffffffffffffff
+#  define TARG_MAX_OCT 0777777777777777777777
+#  define TARG_MAX_PLUS_1 9223372036854775808L
+#  define TARG_MAX_PLUS_1_U 9223372036854775808UL
+#  define TARG_MAX_PLUS_1_HEX 0x8000000000000000
+#  define TARG_MAX_PLUS_1_OCT 01000000000000000000000
+#  define UTARG_MAX_HEX 0xffffffffffffffff
+#  define UTARG_MAX_OCT 01777777777777777777777
+#  define UTARG_MAX_PLUS_1 18446744073709551616L
+#  define UTARG_MAX_PLUS_1_HEX 0x10000000000000000
+#  define UTARG_MAX_PLUS_1_OCT 02000000000000000000000
+
+#  define TARG_LOWPART_PLUS_1 4294967296
+#  define TARG_LOWPART_PLUS_1_U 4294967296U
+
+  /* Division and modulo; anything that uses the high half in both
+     dividend and divisor.  */
+#  define LONG_UDIVISION 235184372088832UL / 17279869184L
+#  define LONG_UDIVISION_ANSWER 13610
+#  define LONG_SDIVISION -234582345927345L / 12345678901L
+#  define LONG_SDIVISION_ANSWER -19001
+#  define LONG_UMODULO 235184372088832UL % 17279869184L
+#  define LONG_UMODULO_ANSWER 5352494592L
+#  define LONG_SMODULO -234582345927345L % 12345678901L
+#  define LONG_SMODULO_ANSWER -2101129444L
+
+#else
+
+#  error Please extend the macros here so that this file tests your target
+
+#endif
+
+/* Create more macros based on the above.  */
+#define TARG_PART_BITS (TARG_PRECISION / 2)
+#define TARG_MIN (-TARG_MAX - 1)
+#define TARG_MAX APPEND (MAX_INT, L)
+#define TARG_MAX_U APPEND (MAX_INT, UL)
+#define UTARG_MAX APPEND (MAX_UINT, L)
+#define UTARG_MAX_U APPEND (MAX_UINT, UL)
+
+/* And now the tests.  */
+
+#if TARG_MAX			/* { dg-bogus "so large" }  */
+#endif
+#if TARG_MAX_PLUS_1_HEX		/* { dg-bogus "so large" }  */
+#endif
+#if TARG_MAX_PLUS_1_OCT		/* { dg-bogus "so large" }  */
+#endif
+
+#if UTARG_MAX			/* { dg-warning "so large" }  */
+#endif
+#if UTARG_MAX_PLUS_1		/* { dg-warning "too large" }  */
+#endif
+#if UTARG_MAX_PLUS_1_HEX	/* { dg-warning "too large" }  */
+#endif
+#if UTARG_MAX_HEX		/* { dg-bogus "too large" }  */
+#endif
+#if UTARG_MAX_PLUS_1_OCT	/* { dg-warning "too large" }  */
+#endif
+#if UTARG_MAX_OCT		/* { dg-bogus "too large" }  */
+#endif
+
+#if TARG_MAX < 0 || TARG_MAX_PLUS_1 < 0	/* { dg-warning "so large" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if UTARG_MAX_HEX < 0 || TARG_MAX_HEX < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if UTARG_MAX_OCT < 0 || TARG_MAX_OCT < 0
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -1 != UTARG_MAX_U
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Test each operator correctly warns of overflow conditions, and
+   gives the right answer.  */
+
+/* Binary +.  */
+#if TARG_MAX + 1 != TARG_MIN	/* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX + -2 != TARG_MAX	/* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX + -1 != TARG_MIN	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX_U + 1 != TARG_MIN	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX_U + -2 != TARG_MAX /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Binary -.  */
+#if TARG_MAX - -1 != TARG_MIN	/* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX - 2 != TARG_MAX	/* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX - 1 != TARG_MIN	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX_U - -1 != TARG_MIN	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX_U - 2 != TARG_MAX /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+
+/* Binary *.  */
+#if TARG_LOWPART_PLUS_1 * (TARG_LOWPART_PLUS_1 >> 1) != TARG_MIN /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_LOWPART_PLUS_1 >> 1) * TARG_LOWPART_PLUS_1 != TARG_MIN /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_LOWPART_PLUS_1 << 1) * (TARG_LOWPART_PLUS_1 + 1) != (TARG_LOWPART_PLUS_1 << 1) /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX * 1 != TARG_MAX	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_MAX >> 1) * 2	!= TARG_MAX - 1 /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_LOWPART_PLUS_1_U + 61) * (TARG_LOWPART_PLUS_1 << 1) != 61 * (TARG_LOWPART_PLUS_1 << 1) /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_LOWPART_PLUS_1 >> 1) * TARG_LOWPART_PLUS_1_U != TARG_MIN /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 * TARG_MIN != TARG_MIN	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Binary /.  */
+#if TARG_MIN / -1 != TARG_MIN	/* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MIN / 1 != TARG_MIN	/* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -TARG_MAX_PLUS_1_U / -1 != 0 /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -5 / (2 - 2) /* { dg-error "division by zero" } */
+#endif
+
+#if LONG_UDIVISION != LONG_UDIVISION_ANSWER
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if LONG_SDIVISION != LONG_SDIVISION_ANSWER
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Binary %.  Cannot overflow.  */
+#if -5 % (2 - 2) /* { dg-error "division by zero" } */
+#endif
+
+#if TARG_MIN % 1 /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if LONG_UMODULO != LONG_UMODULO_ANSWER
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if LONG_SMODULO != LONG_SMODULO_ANSWER
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 234 % -1U != 234
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MIN % -1U != TARG_MIN
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Binary << and Binary >>, the latter cannot overflow.  */
+#if -1 >> 3 != -1     /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX >> 3 != TARG_MAX / 8     /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 0 << 256 != 0  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1 << 256 != 0 /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if 1U << 256 != 0  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX << 1 != -2  /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX_U << 1 != -2  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_LOWPART_PLUS_1 << TARG_PART_BITS != 0  /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_LOWPART_PLUS_1 << (TARG_PART_BITS - 1) != TARG_MIN  /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_LOWPART_PLUS_1_U << (TARG_PART_BITS - 1) != TARG_MIN  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_LOWPART_PLUS_1 << (TARG_PART_BITS - 2) != (TARG_MAX_PLUS_1_U >> 1)  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+/* Test how the sign bit is handled.  */
+#if (TARG_MIN << 1) != 0    /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_MAX_PLUS_1_U << 1) != 0    /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_MIN >> 1) != 3U << (TARG_PRECISION - 2)    /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if (TARG_MAX_PLUS_1_U >> 1) != 1 << (TARG_PRECISION - 2)    /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+/* Unary -.  It can overflow in just one case.  */
+#if -TARG_MIN != TARG_MIN  /* { dg-warning "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if - -TARG_MAX != TARG_MAX   /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Unary +, ~, and !.  They cannot overflow.  */
+#if +TARG_MAX != TARG_MAX  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if !TARG_MAX + !TARG_MIN != 0   /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if ~TARG_MAX , ~TARG_MIN != TARG_MAX  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Bitwise &, ^, |.  They cannot overflow.  */
+#if (TARG_MAX & -1), (TARG_MIN & -1) != TARG_MIN  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX | -1, (TARG_MIN | -1) != -1  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if TARG_MAX ^ -1, (TARG_MIN ^ -1) != TARG_MAX  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Comparison operators.  They cannot overflow.  */
+#if -1 <= TARG_MAX, (TARG_MIN <= 1) != 1  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -1 >= TARG_MAX, (TARG_MIN >= 1) != 0  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -1 < TARG_MAX, (TARG_MIN < 1) != 1  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -1 > TARG_MAX, (TARG_MIN > 1) != 0  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+
+
+
+/* Comma and ? : operators.  They cannot overflow.  */
+#if -1, TARG_MAX, TARG_MIN != TARG_MIN  /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
+
+#if -1 ? TARG_MAX: TARG_MAX, 0 ? 1: TARG_MIN != TARG_MIN /* { dg-bogus "overflow" } */
+# error		/* { dg-bogus "error" }  */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assembl2.S b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assembl2.S
new file mode 100644
index 000000000..0cfad1fa2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assembl2.S
@@ -0,0 +1,19 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Source: Bug report of Jonathan Larmour.  Tweaked for test suite by
+   Neil Booth, 17 Jan 2000.  */
+
+/* We would not test the buffer->was_skipping variable when skipping,
+   meaning that some false directives confused CPP.  */
+
+#if 0
+        # foo
+        # fee
+        # fie
+        # foe
+        # fum
+#elif 0
+        # bundy
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assembler.S b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assembler.S
new file mode 100644
index 000000000..7069b7b50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assembler.S
@@ -0,0 +1,26 @@
+/* Regression test - in assembly language, # may have some significance
+   other than 'stringize macro argument' and therefore must be preserved
+   in the output, and should not be warned about.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "" } */
+
+#define foo() mov r0, #5  /* { dg-bogus "not followed" "spurious warning" } */
+
+entry:
+	foo()
+
+/* Check we don't EOF on an unknown directive.  */
+#unknown directive
+#error a later diagnostic	/* { dg-error "diagnostic" } */
+		
+/*
+   { dg-final { if ![file exists 20000510-1.i] { return }	} }
+   { dg-final { set tmp [grep 20000510-1.i # line]		} }
+   { dg-final { if {[string length $tmp] > 0} \{		} }
+   { dg-final {     pass "20000510-1.S: # preservation"		} }
+   { dg-final { \} else \{					} }
+   { dg-final {     fail "20000510-1.S: # preservation"		} }
+   { dg-final { \}						} }
+*/
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert1.c
new file mode 100644
index 000000000..d1446105c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert1.c
@@ -0,0 +1,46 @@
+/* Basic tests of the #assert preprocessor extension. */
+/* { dg-do compile } */
+/* { dg-options "-Wno-deprecated" } */
+
+#define def unused expansion
+#define fail  int fail
+
+#assert abc (def)
+#assert abc (ghi)
+#assert abc (jkl)
+#assert space ( s p a c e )
+
+/* Basic: */
+#if !#abc (def) || !#abc (ghi) || !#abc (jkl)
+fail
+#endif
+
+/* any answer for #abc */
+#if !#abc
+fail
+#endif
+
+/* internal whitespace is collapsed,
+   external whitespace is deleted  */
+#if !#space (s p  a  c e) || !#space (  s p a c e  ) || #space (space)
+fail
+#endif
+
+/* removing assertions */
+#unassert abc (jkl)
+#if !#abc || !#abc (def) || !#abc (ghi) || #abc (jkl)
+fail
+#endif
+
+#unassert abc
+#if #abc || #abc (def) || #abc (ghi) || #abc (jkl)
+fail
+#endif
+
+int gobble
+
+/* make sure it can succeed too.
+   also check space before open paren isn't significant */
+#if #space(s p a c e)
+;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert2.c
new file mode 100644
index 000000000..130f7f532
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert2.c
@@ -0,0 +1,24 @@
+/* Malformed assertion tests.  */
+/* { dg-do preprocess } */
+/* { dg-options "-fno-show-column -Wno-deprecated" } */
+
+#assert		/* { dg-error "without predicate" "assert w/o predicate" } */
+#assert %	/* { dg-error "an identifier" "assert punctuation" } */
+#assert 12	/* { dg-error "an identifier" "assert number" } */
+#assert abc	/* { dg-error "missing" "assert w/o answer" } */
+
+#if #		/* { dg-error "without predicate" "test w/o predicate" } */
+#endif
+
+#if #%		/* { dg-error "an identifier" "test punctuation" } */
+#endif
+
+#if #12		/* { dg-error "an identifier" "test number" } */
+#endif
+
+#if #abc
+#error		/* { dg-bogus "error" "test w/o answer" } */
+#endif
+
+#if #abc[def]	/* { dg-error "is not valid" "test with malformed answer" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert3.c
new file mode 100644
index 000000000..9010ecebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert3.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-A abc=def -A abc\(ghi\) \"-Aabc = jkl\" -A abc=mno -A -abc=mno -Wno-deprecated" } */
+
+/* Test -A command line syntax.  Source Neil Booth.  31 Oct 2000.  */
+
+#if !#abc (def) || !#abc (ghi) || !#abc (jkl) || #abc(mno)
+#error Command line -A assertions
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert4.c
new file mode 100644
index 000000000..0bd88ce06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/assert4.c
@@ -0,0 +1,399 @@
+/* Copyright (C) 2003, 2006, 2008 Free Software Foundation, Inc.
+   Test builtin preprocessor assertions.
+   By Kaveh Ghazi <ghazi@caip.rutgers.edu>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-ansi -Wno-deprecated" } */
+
+/* Check for #system assertions.  */
+
+#if defined __gnu_linux__
+# if !#system(linux) || !#system(unix) || !#system(posix)
+#  error
+# endif
+#elif #system(linux)
+# error
+#endif
+
+#if defined __gnu_hurd__
+# if !#system(gnu) || !#system(unix) || !#system(posix) || !#system(mach)
+#  error
+# endif
+#elif #system(gnu)
+# error
+#endif
+
+#if defined __FreeBSD__
+# if !#system(FreeBSD) || !#system(unix) || !#system(bsd)
+#  error
+# endif
+#elif #system(FreeBSD)
+# error
+#endif
+
+#if defined __NetBSD__
+# if !#system(NetBSD) || !#system(unix) || !#system(bsd)
+#  error
+# endif
+#elif #system(NetBSD)
+# error
+#endif
+
+#if defined __OpenBSD__
+# if !#system(OpenBSD) || !#system(unix) || !#system(bsd)
+#  error
+# endif
+#elif #system(OpenBSD)
+# error
+#endif
+
+#if defined __svr4__ || defined __SYSTYPE_SVR4__
+# if !#system(svr4) || !#system(unix)
+#  error
+# endif
+#elif #system(svr4)
+# error
+#endif
+
+#if defined __hpux__
+# if !#system(hpux) || !#system(unix)
+#  error
+# endif
+#elif #system(hpux)
+# error
+#endif
+
+#if defined _AIX
+# if !#system(aix) || !#system(unix)
+#  error
+# endif
+#elif #system(aix)
+# error
+#endif
+
+#if defined __lynx__
+# if !#system(lynx) || !#system(unix)
+#  error
+# endif
+#elif #system(lynx)
+# error
+#endif
+
+#if ( defined __unix__ && !defined __CYGWIN__ ) || defined _AIX \
+    || defined __vxworks
+# if !#system(unix)
+#  error
+# endif
+#elif #system(unix)
+# error
+#endif
+
+#if defined __rtems__
+# if !#system(rtems)
+#  error
+# endif
+#elif #system(rtems)
+# error
+#endif
+
+#if defined __vms__
+# if !#system(vms)
+#  error
+# endif
+#elif #system(vms)
+# error
+#endif
+
+#if defined __mvs__
+# if !#system(mvs)
+#  error
+# endif
+#elif #system(mvs)
+# error
+#endif
+
+#if defined __MSDOS__
+# if !#system(msdos)
+#  error
+# endif
+#elif #system(msdos)
+# error
+#endif
+
+#if defined __WINNT__ || defined __CYGWIN__
+# if !#system(winnt)
+#  error
+# endif
+#elif #system(winnt)
+# error
+#endif
+
+#if defined __netware__
+# if !#system(netware)
+#  error
+# endif
+#elif #system(netware)
+# error
+#endif
+
+
+/* Check for #cpu and #machine assertions.  */
+
+#if defined __arc__
+# if !#cpu(arc) || !#machine(arc)
+#  error
+# endif
+#elif #cpu(arc) || #machine(arc)
+# error
+#endif
+
+#if defined __alpha__
+# if !#cpu(alpha) || !#machine(alpha) \
+	|| (defined __alpha_cix__ && !#cpu(cix)) \
+	|| (!defined __alpha_cix__ && #cpu(cix)) \
+	|| (defined __alpha_fix__ && !#cpu(fix)) \
+	|| (!defined __alpha_fix__ && #cpu(fix)) \
+	|| (defined __alpha_bwx__ && !#cpu(bwx)) \
+	|| (!defined __alpha_bwx__ && #cpu(bwx)) \
+	|| (defined __alpha_max__ && !#cpu(max)) \
+	|| (!defined __alpha_max__ && #cpu(max)) \
+	|| (defined __alpha_ev6__ && !#cpu(ev6)) \
+	|| (!defined __alpha_ev6__ && #cpu(ev6)) \
+	|| (defined __alpha_ev5__ && !#cpu(ev5)) \
+	|| (!defined __alpha_ev5__ && #cpu(ev5)) \
+	|| (defined __alpha_ev4__ && !#cpu(ev4)) \
+	|| (!defined __alpha_ev4__ && #cpu(ev4))
+#  error
+# endif
+#elif #cpu(alpha) || #machine(alpha) || #cpu(cix) || #cpu(fix) || #cpu(bwx) \
+	|| #cpu(max) || #cpu(ev6) || #cpu(ev5) || #cpu(ev4)
+# error
+#endif
+
+#if defined __arm__
+# if !#cpu(arm) || !#machine(arm)
+#  error
+# endif
+#elif #cpu(arm) || #machine(arm)
+# error
+#endif
+
+#if defined __cris__
+# if !#cpu(cris) || !#machine(cris)
+#  error
+# endif
+#elif #cpu(cris) || #machine(cris)
+# error
+#endif
+
+#if defined __fr30__
+# if !#cpu(fr30) || !#machine(fr30)
+#  error
+# endif
+#elif #cpu(fr30) || #machine(fr30)
+# error
+#endif
+
+#if defined __frv__
+# if !#cpu(frv) || !#machine(frv)
+#  error
+# endif
+#elif #cpu(frv) || #machine(frv)
+# error
+#endif
+
+#if defined __H8300__ 
+# if !#cpu(h8300) || !#machine(h8300) \
+  || (defined __H8300__ && (!#cpu(h8300) || !#machine(h8300))) \
+  || (defined __H8300H__ && (!#cpu(h8300h) || !#machine(h8300h))) \
+  || (!defined __H8300H__ && (#cpu(h8300h) || #machine(h8300h))) \
+  || (defined __H8300S__ && (!#cpu(h8300s) || !#machine(h8300s))) \
+  || (!defined __H8300S__ && (#cpu(h8300s) || #machine(h8300s)))
+#  error
+# endif
+#elif #cpu(h8300) || #machine(h8300) || #cpu(h8300h) || #machine(h8300h) || \
+  #cpu(h8300s) || #machine(h8300s)
+# error
+#endif
+
+#if defined __hppa__
+# if !#cpu(hppa) || !#machine(hppa)
+#  error
+# endif
+#elif #cpu(hppa) || #machine(hppa)
+# error
+#endif
+
+#if defined __i370__
+# if !#cpu(i370) || !#machine(i370)
+#  error
+# endif
+#elif #cpu(i370) || #machine(i370)
+# error
+#endif
+
+#if defined __x86_64__
+# if !#cpu(x86_64) || !#machine(x86_64)
+#  error
+# endif
+#elif #cpu(x86_64) || #machine(x86_64)
+# error
+#endif
+
+#if defined __i386__
+# if !#cpu(i386) || !#machine(i386)
+#  error
+# endif
+#elif #cpu(i386) || #machine(i386)
+# error
+#endif
+
+#if defined __ia64__
+# if !#cpu(ia64) || !#machine(ia64)
+#  error
+# endif
+#elif #cpu(ia64) || #machine(ia64)
+# error
+#endif
+
+#if defined __iq2000__
+# if !#cpu(iq2000) || !#machine(iq2000)
+#  error
+# endif
+#elif #cpu(iq2000) || #machine(iq2000)
+# error
+#endif
+
+#if defined __M32R__
+# if !#cpu(m32r) || !#machine(m32r)
+#  error
+# endif
+#elif #cpu(m32r) || #machine(m32r)
+# error
+#endif
+
+#if defined __m68k__
+# if !#cpu(m68k) || !#machine(m68k)
+#  error
+# endif
+#elif #cpu(m68k) || #machine(m68k)
+# error
+#endif
+
+#if defined __mcore__
+# if !#cpu(mcore) || !#machine(mcore)
+#  error
+# endif
+#elif #cpu(mcore) || #machine(mcore)
+# error
+#endif
+
+#if defined __mips__
+# if !#cpu(mips) || (defined __sgi__ && !#machine(sgi)) \
+  || (!defined __sgi__ && !#machine(mips))
+#  error
+# endif
+#elif #cpu(mips) || #machine(sgi) || #machine(mips)
+# error
+#endif
+
+#if defined __mn10300__
+# if !#cpu(mn10300) || !#machine(mn10300)
+#  error
+# endif
+#elif #cpu(mn10300) || #machine(mn10300)
+# error
+#endif
+
+#if defined __pdp11__
+# if !#cpu(pdp11) || !#machine(pdp11)
+#  error
+# endif
+#elif #cpu(pdp11) || #machine(pdp11)
+# error
+#endif
+
+#if defined __powerpc__ || defined __PPC__
+# if defined __powerpc64__
+#  if (#cpu(powerpc) || #machine(powerpc) \
+       || !#cpu(powerpc64) || !#machine(powerpc64))
+#   error
+#  endif
+# else
+#  if (!#cpu(powerpc) || !#machine(powerpc) \
+       || #cpu(powerpc64) || #machine(powerpc64))
+#   error
+#  endif
+# endif
+#elif (#cpu(powerpc) || #machine(powerpc) \
+       || #cpu(powerpc64) || #machine(powerpc64))
+# error
+#endif
+
+#if defined __rs6000__
+# if !#cpu(rs6000) || !#machine(rs6000)
+#  error
+# endif
+#elif #cpu(rs6000) || #machine(rs6000)
+# error
+#endif
+
+#if defined __s390__
+# if !#cpu(s390) || !#machine(s390)
+#  error
+# endif
+#elif #cpu(s390) || #machine(s390)
+# error
+#endif
+
+#if defined __sh__
+# if !#cpu(sh) || !#machine(sh)
+#  error
+# endif
+#elif #cpu(sh) || #machine(sh)
+# error
+#endif
+
+#if defined __sparc__
+# if (defined __arch64__ \
+      && (!#cpu(sparc64) || !#machine(sparc64) || #cpu(sparc) || #machine(sparc)))
+  || (!defined __arch64__ \
+      && (#cpu(sparc64) || #machine(sparc64) || !#cpu(sparc) || !#machine(sparc)))
+#  error
+# endif
+#elif #cpu(sparc64) || #machine(sparc64) || #cpu(sparc) || #machine(sparc)
+# error
+#endif
+
+#if defined __xstormy16__
+# if !#cpu(xstormy16) || !#machine(xstormy16)
+#  error
+# endif
+#elif #cpu(xstormy16) || #machine(xstormy16)
+# error
+#endif
+
+#if defined __v850__
+# if !#cpu(v850) || !#machine(v850)
+#  error
+# endif
+#elif #cpu(v850) || #machine(v850)
+# error
+#endif
+
+#if defined __vax__
+# if !#cpu(vax) || !#machine(vax)
+#  error
+# endif
+#elif #cpu(vax) || #machine(vax)
+# error
+#endif
+
+#if defined __XTENSA__
+# if !#cpu(xtensa) || !#machine(xtensa)
+#  error
+# endif
+#elif #cpu(xtensa) || #machine(xtensa)
+# error
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/avoidpaste1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/avoidpaste1.c
new file mode 100644
index 000000000..3591f9c08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/avoidpaste1.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 2001, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-ansi" } */
+
+/* This tests that we avoid accidental pasting only before and after
+   macros and arguments, and not when the tokens are already pasted
+   in the souce file (e.g. "::" in a C source file).
+
+   Neil Booth, 28 Jan 2001.  */
+
+#define f(x) x
+#define g
+#define tricky 1.0e ## -1
+
+/* This should preprocess as
+
+:: : : : : :^: 1.0e- 1
+: : : .. . 0 0 .
+
+It relies on the fact that even when preprocessing C we bother to separate
+the colons of C++'s :: operator.  If we confine this behavior to C++
+in future, this test needs to change.  */
+
+:: :g: :f(): :f(^): tricky
+:f(:): .. .__INCLUDE_LEVEL__ __INCLUDE_LEVEL__. /* Check builtins, too.  */
+
+/* { dg-final { scan-file avoidpaste1.i ":: : : : : :\\^: 1.0e- 1" } }
+   { dg-final { scan-file avoidpaste1.i ": : : \\\.\\\. \\\. 0 0 \\\." } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/avoidpaste2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/avoidpaste2.c
new file mode 100644
index 000000000..dc5bbc7f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/avoidpaste2.c
@@ -0,0 +1,31 @@
+/* Copyright (C) 2001, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-ansi" } */
+
+/* This tests that we avoid accidental pasting, as well as gratuitous
+   space insertion, in various nasty places _inside_ a macro's
+   replacement list: on either side of a paste, and on either side of
+   an argument.  It also tests that we don't pass empty macro leading
+   whitespace to the next line - this problem use to break Emacs
+   preprocessor abuse.
+
+   Neil Booth, 1 Feb 2001.  */
+
+#define EMPTY_WITH_LEADING_SPACE
+#define f(x, y) :x: -y##> -##y>
+#define g(x, y) :x: :y##2 2##y:
+
+/* This should preprocess as
+
+: : : - > - >
+:2: :22 22:
+
+We used to get a space at the start of the line.  */
+
+ EMPTY_WITH_LEADING_SPACE
+f(:,) 
+g(2, 2)
+
+/* { dg-final { scan-file avoidpaste2.i "(^|\\n): : : - > - >" } } 
+   { dg-final { scan-file avoidpaste2.i "(^|\\n):2: :22 22:" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/backslash.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/backslash.c
new file mode 100644
index 000000000..f1b094a0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/backslash.c
@@ -0,0 +1,21 @@
+/* Test backslash newline with and without trailing spaces.  */
+
+#define alpha(a, b, c) \
+	a, \
+	b, \
+	c
+
+/* Note the trailing whitespace on the next three lines.  */
+#define beta(a, b, c) \ 
+	a, \	
+	b, \ 	
+	c
+
+/* { dg-warning "separated by space" "space" { target *-*-* } 9 } */
+/* { dg-warning "separated by space" "tab" { target *-*-* } 10 } */
+/* { dg-warning "separated by space" "space and tab" { target *-*-* } 11 } */
+
+int x[] = {
+   alpha(1, 2, 3),
+   beta(4, 5, 6)
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/backslash2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/backslash2.c
new file mode 100644
index 000000000..65142d930
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/backslash2.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test warnings for backslash-space-newline.
+   Source: Neil Booth. 6 Dec 2000.  */
+
+foo \  
+bar
+/* { dg-warning "separated by space" "" { target *-*-* } 8 } */
+
+/* foo \   
+   bar */
+/* { dg-bogus "separated by space" "" { target *-*-* } 12 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c89-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c89-pedantic.c
new file mode 100644
index 000000000..3b7f6dd02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c89-pedantic.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=c89 -pedantic" } */
+
+/* This file is for testing the preprocessor in -std=c89 -pedantic mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL				/* { dg-warning "long long" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c89.c
new file mode 100644
index 000000000..8c5fd28a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c89.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=c89" } */
+
+/* This file is for testing the preprocessor in -std=c89 mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c90-empty-macro-args.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c90-empty-macro-args.c
new file mode 100644
index 000000000..e90f8e6cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c90-empty-macro-args.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic" } */
+
+#define f(a,b)   f2(a,,b) 
+#define f2(a,b,c) a; b; c;
+#define f3(a)    a
+
+#define g()   p()
+
+void p(void) {}
+
+
+void foo(void)
+{
+    f(p(),p()); /* { dg-warning "macro f2 argument 2: empty macro arguments are undefined" } */
+    f2(p(),,p()); /* { dg-warning "macro f2 argument 2: empty macro arguments are undefined" } */
+    f3(); /* { dg-warning "macro f3 argument 1: empty macro arguments are undefined" } */
+    g();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c90-if-comma-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c90-if-comma-1.c
new file mode 100644
index 000000000..c00403f16
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c90-if-comma-1.c
@@ -0,0 +1,11 @@
+/* Test for commas in constant expressions in #if: not permitted in C90
+   but permitted in unevaluated subexpressions in C99.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
+
+#if (1, 2) /* { dg-error "comma" "evaluated comma" } */
+#endif
+
+#if 1 || (1, 2) /* { dg-error "comma" "unevaluated comma" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c94-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c94-pedantic.c
new file mode 100644
index 000000000..1c1216449
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c94-pedantic.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:199409 -pedantic" } */
+
+/* This file is for testing the preprocessor in -std=iso9899:199409
+   -pedantic mode.  Neil Booth, 2 Dec 2000.  */
+
+#if 1LL				/* { dg-warning "long long" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c94.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c94.c
new file mode 100644
index 000000000..d7a5e75da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c94.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:199409" } */
+
+/* This file is for testing the preprocessor in -std=iso9899:199409 mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-empty-macro-args.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-empty-macro-args.c
new file mode 100644
index 000000000..e1e0c61ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-empty-macro-args.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic" } */
+
+#define f(a,b)   f2(a,,b) 
+#define f2(a,b,c) a; b; c;
+#define f3(a)    a
+
+#define g()   p()
+
+void p(void) {}
+
+
+void foo(void)
+{
+    f(p(),p());
+    f2(p(),,p());
+    f3();
+    g();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-hexfloat-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-hexfloat-3.c
new file mode 100644
index 000000000..44c49c995
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-hexfloat-3.c
@@ -0,0 +1,6 @@
+/* Test for hex floating point constants: in C99 only.  Compiler test.  */
+/* Origin: Michael Matz <matz@suse.de> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+double d = 0x.2p2; /* { dg-bogus "radix 16" "bogus C99 hex float error" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-if-comma-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-if-comma-1.c
new file mode 100644
index 000000000..cb8eb6f73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-if-comma-1.c
@@ -0,0 +1,11 @@
+/* Test for commas in constant expressions in #if: not permitted in C90
+   but permitted in unevaluated subexpressions in C99.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#if (1, 2) /* { dg-error "comma" "evaluated comma" } */
+#endif
+
+#if 1 || (1, 2)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-pedantic.c
new file mode 100644
index 000000000..0128a323c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99-pedantic.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -pedantic" } */
+
+/* This file is for testing the preprocessor in -std=c99 -pedantic mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99.c
new file mode 100644
index 000000000..b74ff6387
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/c99.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99" } */
+
+/* This file is for testing the preprocessor in -std=c99 mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-2.c
new file mode 100644
index 000000000..59fa500e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-2.c
@@ -0,0 +1,19 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fsigned-char" } */
+
+/* Crosscompiling from i686-linux (32-bit) to x86_64-linux (64-bit)
+   gave extra warnings on the two assignments:
+   warning: large integer implicitly truncated to unsigned type
+   warning: overflow in implicit constant conversion
+   This test has been added as a regression test after fixing the bug
+   by Andreas Jaeger, 23 Nov 2001.  */
+int
+main (void)
+{
+  signed char c = '\xff';
+  unsigned char d = '\xff';
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-3.c
new file mode 100644
index 000000000..7c1966391
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-3.c
@@ -0,0 +1,50 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options -Wno-multichar } */
+
+/* This tests values and signedness of multichar charconsts.
+
+   Neil Booth, 5 May 2002.  */
+
+#include <limits.h>
+
+extern void abort (void);
+
+int main ()
+{
+  /* These tests require at least 2-byte ints.  8-)  */
+#if INT_MAX > 127
+  int scale = (int) (unsigned char) -1 + 1;
+
+  if ('ab' != (int) ((unsigned char) 'a' * scale + (unsigned char) 'b'))
+    abort ();
+
+  if ('\234b' != (int) ((unsigned char) '\234' * scale + (unsigned char) 'b'))
+    abort ();
+
+  if ('b\234' != (int) ((unsigned char) 'b' * scale + (unsigned char) '\234'))
+    abort ();
+  /* Multichar charconsts have type int and should be signed.  */
+#if INT_MAX == 32767
+# if '\234a' > 0
+#  error Preprocessor charconsts 1
+# endif
+  if ('\234a' > 0)
+    abort ();
+#elif INT_MAX == 2147483647
+# if '\234aaa' > 0
+#  error Preprocessor charconsts 2
+# endif
+  if ('\234aaa' > 0)
+    abort ();
+#elif INT_MAX == 9223372036854775807
+# if '\234aaaaaaa' > 0
+#  error Preprocessor charconsts 3
+# endif
+  if ('\234aaaaaaa' > 0)
+    abort ();
+#endif
+#endif
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-4.c
new file mode 100644
index 000000000..aae33d35e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst-4.c
@@ -0,0 +1,52 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-Wno-multichar -fsigned-char" } */
+
+/* This tests how overly-long multichar charconsts are truncated, and
+   whether "short" multichar charconsts are incorrectly sign extended
+   (regardless of char signedness).  Preprocessor is used so that we
+   have only one place where the too long warning is generated, so
+   that the test works for all targets.
+
+   Neil Booth, 8 May 2002.  */
+
+#include <limits.h>
+
+extern void abort (void);
+
+#if INT_MAX == 32767
+# define LONG_CHARCONST '!\234a'
+# define SHORT_CHARCONST '\234a'
+# define POS_CHARCONST '\1'
+#elif INT_MAX == 2147483647
+# define LONG_CHARCONST '!\234abc'
+# define SHORT_CHARCONST '\234abc'
+# define POS_CHARCONST '\234a'
+#elif INT_MAX == 9223372036854775807
+# define LONG_CHARCONST '!\234abcdefg'
+# define SHORT_CHARCONST '\234abcdefg'
+# define POS_CHARCONST '\234a'
+#else
+/* Target int size not handled, do something that won't fail.  */
+# define LONG_CHARCONST '\234a'
+# define SHORT_CHARCONST '\234a'
+# define POS_CHARCONST '\1'
+#endif
+
+#if POS_CHARCONST < 0
+# error Charconst incorrectly sign-extended
+#endif
+
+#if LONG_CHARCONST != SHORT_CHARCONST /* { dg-warning "too long" "" } */
+# error Overly long charconst truncates wrongly for preprocessor
+#endif
+
+int main ()
+{
+  if (POS_CHARCONST < 0)
+    abort ();
+  if (LONG_CHARCONST != SHORT_CHARCONST)  /* { dg-warning "too long" "" } */
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst.c
new file mode 100644
index 000000000..8934d6a67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/charconst.c
@@ -0,0 +1,36 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+/* This tests various diagnostics about character constants, for both
+   the preprocessor and the compiler.
+
+   Neil Booth, 22 May 2001.  */
+
+#if ''			/* { dg-error "empty" "empty charconst" } */
+#endif
+#if L''			/* { dg-error "empty" "empty wide charconst" } */
+#endif
+#if 'very long'		/* { dg-warning "too long" "long charconst" } */
+#endif
+#if L'very long'	/* { dg-warning "too long" "long wide charconst" } */
+#endif
+/* Don't do this test for L'ab'; it depends upon sizeof (wchar_t).  */
+#if 'ab'		/* { dg-warning "multi-char" "multi-character" } */
+#endif
+
+void foo ()
+{
+  int c;
+  __WCHAR_TYPE__ w;
+
+  c = '';		/* { dg-error "empty" "empty charconst" } */
+  w = L'';		/* { dg-error "empty" "empty wide charconst" } */
+
+  c = 'very long';	/* { dg-warning "too long" "long charconst" } */
+  w = L'very long';	/* { dg-warning "too long" "long wide charconst" } */
+
+  c = 'ab';		/* { dg-warning "multi-char" "multi-char" } */
+  /* Wide charconsts cannot contain more than one wide character.  */
+  w = L'ab';		/* { dg-warning "too long" "multi-char wide" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-C.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-C.c
new file mode 100644
index 000000000..2dafec253
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-C.c
@@ -0,0 +1,37 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -C } */
+
+/* Test -C doesn't fail with #define.  #define is the tricky case,
+   being the only directive that remembers its comments.
+
+   -C treats comments as tokens in their own right, so e.g. comment at
+   the beginning of a directive turns it into a non-directive.  */
+
+#define simple no comments
+
+#define/**/obj_like/**/(some)/**/thing/**/
+#define fun_like(/**/x/**/,/**/y/**/)/**/
+/**/#define not_a_macro
+
+#if !defined simple || !defined obj_like || !defined fun_like
+#error Missed some macros with -C
+#endif
+
+#ifdef not_a_macro
+#error not_a_macro is!
+#endif
+
+/* Check obj_like doesn't expect arguments, and fun_like does.  */
+obj_like
+fun_like (foo, bar)
+
+/* Check OK to redefine fun_like without comments in the params.  */
+#define fun_like(x, y)/**/
+
+/* Check comments in macros in directives are OK.  */
+#define ZERO 0 /* A trailing comment.  */
+
+#if ZERO
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-C2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-C2.c
new file mode 100644
index 000000000..be046704c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-C2.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-C" } */
+
+/* This tests that C++ comments are either dropped, or converted to C
+   comments in macro expansions.  The + in the regexp stops it from
+   matching itself 8-)
+
+   Neil Booth, 9 Oct 2001.  */
+
+#define ZERO 0 // A comment
+
+ZERO:
+
+/* { dg-final { scan-file-not cmdlne-C2.i "c+omment:" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M-2#.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M-2#.h
new file mode 100644
index 000000000..40a8c178f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M-2#.h
@@ -0,0 +1 @@
+/* empty */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M-2.c
new file mode 100644
index 000000000..6479822f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M-2.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-M" } */
+
+/* Test that dependency output suppresses warnings by implying -w.  */
+
+#include "#cmdlne-M-2.h"
+#include "cmdlne-M-2#.h"
+
+/* { dg-final { scan-file cmdlne-M-2.i "(^|\\n)cmdlne-M-2.o:" } }
+   { dg-final { scan-file cmdlne-M-2.i "cmdlne-M-2.c" } }
+   { dg-final { scan-file cmdlne-M-2.i "\\\\#cmdlne-M-2.h" } }
+   { dg-final { scan-file cmdlne-M-2.i "cmdlne-M-2\\\\#.h" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M.c
new file mode 100644
index 000000000..4eb6407cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-M.c
@@ -0,0 +1,8 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-M" } */
+
+/* Test that dependency output suppresses warnings by implying -w.  */
+
+#warning bogus /* { dg-bogus "warning" "warning not suppressed" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-P.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-P.c
new file mode 100644
index 000000000..faadf9fbf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-P.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2000, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-P" } */
+
+/* Test that we don't stair-step output with -P.  Source: Neil Booth,
+   18 Dec 2000.  */
+
+int x = 1;
+
+/* { dg-final { scan-file cmdlne-P.i "(^|\n)int x = 1;($|\n)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD-M.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD-M.c
new file mode 100644
index 000000000..d1a3b8f09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD-M.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2002, 2003, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dD -M" } */
+
+/* Test -dD -M does not fail.  It should print just
+   the Makefile rule with dependencies.  */
+
+#define foo bar
+#define funlike(like) fun like
+int variable;
+
+/* { dg-final { scan-file-not cmdlne-dD-M.i "(^|\\n)#define foo bar($|\\n)" } }
+   { dg-final { scan-file-not cmdlne-dD-M.i "variable" } }
+   { dg-final { scan-file cmdlne-dD-M.i "(^|\n)cmdlne-dD-M\[^\\n\]*:( *\\\\\\n)?\[^\\n\]*cmdlne-dD-M.c" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD-dM.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD-dM.c
new file mode 100644
index 000000000..9e3c732d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD-dM.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dD -dM" } */
+
+/* Test -dD -dM does not fail.  It should give the same output
+   as plain -dM.  */
+
+#define foo bar
+#define funlike(like) fun like
+int variable;
+
+/* { dg-final { scan-file cmdlne-dD-dM.i "(^|\\n)#define foo bar($|\\n)" } }
+   { dg-final { scan-file-not cmdlne-dD-dM.i "variable" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD.c
new file mode 100644
index 000000000..59d521195
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dD.c
@@ -0,0 +1,12 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -dD } */
+
+/* Test -dD does not fail.  */
+
+#define objlike obj like
+#define funlike(like) fun like
+#define funlike2(fun, like) fun ## like
+#define varargs(x, ...) x #x __VA_ARGS__
+#define gnu_varargs(x, y...) x ## y 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-C.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-C.c
new file mode 100644
index 000000000..6b4bfee22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-C.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2005 Free Software Foundation, Inc.  */
+/* PR 13726 */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dI -C" } */
+
+#include "cmdlne-dI-C.h" /* #include comment */
+/* comment 2 */
+
+/* { dg-final { scan-file cmdlne-dI-C.i "#include c+omment" } } */
+/* { dg-final { scan-file cmdlne-dI-C.i "header file c+omment" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-C.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-C.h
new file mode 100644
index 000000000..5021488e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-C.h
@@ -0,0 +1 @@
+/* header file comment */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-M.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-M.c
new file mode 100644
index 000000000..db08a72b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-M.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2002, 2003, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dI -M" } */
+
+/* Test -dI -M does not fail.  It should print just
+   the Makefile rule with dependencies.  */
+
+#define foo bar
+#include "cmdlne-dI-M.h"
+#define funlike(like) fun like
+int variable;
+
+/* { dg-final { scan-file-not cmdlne-dI-M.i "(^|\\n)#define foo bar($|\\n)" } }
+   { dg-final { scan-file-not cmdlne-dI-M.i "variable" } }
+   { dg-final { scan-file cmdlne-dI-M.i "(^|\\n)cmdlne-dI-M\[^\\n\]*:( *\\\\\\n)?\[^\\n\]*cmdlne-dI-M.c" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-M.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-M.h
new file mode 100644
index 000000000..cbaf810a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dI-M.h
@@ -0,0 +1,2 @@
+#define baz baz
+int othervar;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM-M.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM-M.c
new file mode 100644
index 000000000..0cd901104
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM-M.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2002, 2003, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dM -M" } */
+
+/* Test -dM -M does not fail.  It should print both the
+   #define lines and a Makefile rule with dependencies.  */
+
+#define foo bar
+#define funlike(like) fun like
+int variable;
+
+/* { dg-final { scan-file cmdlne-dM-M.i "(^|\\n)#define foo bar($|\\n)" } }
+   { dg-final { scan-file-not cmdlne-dM-M.i "variable" } }
+   { dg-final { scan-file cmdlne-dM-M.i "(^|\\n)cmdlne-dM-M\[^\\n\]*:( *\\\\\\n)?\[^\\n\]*cmdlne-dM-M.c"} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM-dD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM-dD.c
new file mode 100644
index 000000000..66ec7dd9b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM-dD.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dM -dD" } */
+
+/* Test -dM -dD does not fail.  It should give the same output
+   as plain -dD.  */
+
+#define foo bar
+#define funlike(like) fun like
+int variable;
+
+/* { dg-final { scan-file cmdlne-dM-dD.i "(^|\\n)#define foo bar($|\\n)" } }
+   { dg-final { scan-file cmdlne-dM-dD.i "variable" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM.c
new file mode 100644
index 000000000..98660f8f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dM.c
@@ -0,0 +1,12 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -dM } */
+
+/* Test -dM does not fail.  */
+
+#define objlike obj like
+#define funlike(like) fun like
+#define funlike2(fun, like) fun ## like
+#define varargs(x, ...) x #x #__VA_ARGS__ __VA_ARGS__
+#define gnu_varargs(x, y...) #y x ## y y 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dN-M.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dN-M.c
new file mode 100644
index 000000000..2182e370c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dN-M.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2002, 2003, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dN -M" } */
+
+/* Test -dN -M does not fail.  It should print just
+   the Makefile rule with dependencies.  */
+
+#define foo bar
+#define funlike(like) fun like
+int variable;
+
+/* { dg-final { scan-file-not cmdlne-dN-M.i "(^|\\n)#define foo" } }
+   { dg-final { scan-file-not cmdlne-dN-M.i "variable" } }
+   { dg-final { scan-file cmdlne-dN-M.i "(^|\\n)cmdlne-dN-M\[^\\n\]*:( *\\\\\\n)?\[^\\n\]*cmdlne-dN-M.c" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-1.c
new file mode 100644
index 000000000..ce3f5b721
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-1.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-1.i "^\n*#undef A\n*$" } } */
+#ifdef A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-10.c
new file mode 100644
index 000000000..dd1474ad0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-10.c
@@ -0,0 +1,7 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-10.i "^\n*C\n+#define B C\n+#define A B\n*$" } } */
+/* This file deliberately has no final newline.  */
+#define A B
+#define B C
+A
\ No newline at end of file
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-11.c
new file mode 100644
index 000000000..c9cc59346
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-11.c
@@ -0,0 +1,7 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-11.i "^\n*\n*$" } } */
+#define A B
+#if 0
+A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-12.c
new file mode 100644
index 000000000..bf765fbf0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-12.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-12.i "^\n*#define A 1\n*$" } } */
+#define A 1
+#if A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-13.c
new file mode 100644
index 000000000..3ab08d5d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-13.c
@@ -0,0 +1,7 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-13.i "^\n*#undef A\n*$" } } */
+#ifdef A
+#endif
+#ifdef A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-14.c
new file mode 100644
index 000000000..5d36f1acb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-14.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-14.i "^\n*B\n+#define A B\n+B\n*$" } } */
+#define A B
+A
+A
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-15.c
new file mode 100644
index 000000000..a6a961826
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-15.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-15.i "^\n*\n*$" } } */
+#if A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-16.c
new file mode 100644
index 000000000..463c0b9e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-16.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-options "-P -dU -std=c89" { target *-*-solaris2.* } } */
+/* { dg-final { scan-file cmdlne-dU-16.i "^\n*#define __STDC__ 1\n*$" } } */
+#ifdef __STDC__
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-17.c
new file mode 100644
index 000000000..2ae9d273a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-17.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-options "-P -dU -std=c89" { target *-*-solaris2.* } } */
+/* { dg-final { scan-file cmdlne-dU-17.i "^\n*1\n+#define __STDC__ 1\n*$" } } */
+__STDC__
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-18.c
new file mode 100644
index 000000000..0b2c54307
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-18.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-18.i "^\n*x 1 y\n+#define A 1\n*$" } } */
+#define A 1
+x A y
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-19.c
new file mode 100644
index 000000000..50edfc2b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-19.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-19.i "^\n*B\n+#define A B\n+#undef A\n*$" } } */
+#define A B
+A
+#undef A
+#ifdef A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-2.c
new file mode 100644
index 000000000..e47546304
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-2.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-2.i "^\n*#define A *\n*$" } } */
+#define A
+#ifdef A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-20.c
new file mode 100644
index 000000000..4845b51e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-20.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-20.i "^\n*A B\n*$" } } */
+#define A(x) x
+A B
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-21.c
new file mode 100644
index 000000000..c17a0435e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-21.c
@@ -0,0 +1,9 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-21.i "^\n*hello There\n+#define ASTRING There\n+#define MACROARGS\\(A\\) A\n+#undef BSTRING\n*$" } } */
+#define ASTRING There
+#define MACROARGS(A) A
+MACROARGS(hello) ASTRING
+#ifdef BSTRING
+bye
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-22.c
new file mode 100644
index 000000000..383a29f85
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-22.c
@@ -0,0 +1,14 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-22.i "^\n*#undef AAA\n+AAA is undefined\n+#undef BBB\n+BBB is undefined\n+#undef CCC\n+CCC is undefined\n*$" } } */
+#ifndef AAA
+AAA is undefined
+#endif
+
+#ifndef BBB
+BBB is undefined
+#endif
+
+#ifndef CCC
+CCC is undefined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-23.c
new file mode 100644
index 000000000..c99a43b08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-23.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file-not cmdlne-dU-23.i "__FILE__" } } */
+#ifdef __FILE__
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-3.c
new file mode 100644
index 000000000..26c6ec1de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-3.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-3.i "^\n*#define A B\n*$" } } */
+#define A B
+#ifndef A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-4.c
new file mode 100644
index 000000000..9c57ffe7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-4.c
@@ -0,0 +1,5 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-4.i "^\n*#undef A\n*$" } } */
+#if defined(A)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-5.c
new file mode 100644
index 000000000..01880b77b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-5.c
@@ -0,0 +1,7 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-5.i "^\n*#undef A\n*$" } } */
+#ifdef A
+#ifdef B
+#endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-6.c
new file mode 100644
index 000000000..edf6b4445
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-6.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-6.i "^\n*#undef A\n+#define A *\n*$" } } */
+#ifdef A
+#endif
+#define A
+#ifdef A
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-7.c
new file mode 100644
index 000000000..43a66341d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-7.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-7.i "^\n*B\n+#define A B\n+C\n+#define A C\n*$" } } */
+#define A B
+A
+#undef A
+#define A C
+A
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-8.c
new file mode 100644
index 000000000..d5984a314
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-8.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-8.i "^\n*B D\n+#define A\\(x\\) B x\n+#define C D\n*$" } } */
+#define A(x) B x
+#define C D
+A(C)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-9.c
new file mode 100644
index 000000000..ac8b92114
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cmdlne-dU-9.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+/* { dg-options "-P -dU" } */
+/* { dg-final { scan-file cmdlne-dU-9.i "^\n*C\n+#define B C\n+#define A B\n*$" } } */
+#define A B
+#define B C
+A
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-1.c
new file mode 100644
index 000000000..80d8b7892
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-1.c
@@ -0,0 +1,20 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+/* { dg-do preprocess } */
+
+/* Tests __COUNTER__ macro is correctly expanded.  */
+
+#define counter __COUNTER__
+
+#if __COUNTER__ != 0
+#error __COUNTER__ != 0
+#endif
+
+#if counter != 1
+#error counter != 1
+#endif
+
+#if __COUNTER__ != 2
+#error __COUNTER__ != 2
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-2.c
new file mode 100644
index 000000000..7d6578d9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-2.c
@@ -0,0 +1,14 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -fdirectives-only } */
+
+/* Tests __COUNTER__ macro expansion is disabled inside directives with
+   -fdirectives-only. */
+
+#ifdef __COUNTER__  /* Macro not expanded. */
+#endif
+
+#if __COUNTER__ == 0  /* { dg-error "__COUNTER__ expanded inside directive with -fdirectives-only" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-3.c
new file mode 100644
index 000000000..3b1824f25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/counter-3.c
@@ -0,0 +1,10 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fdirectives-only -fpreprocessed" } */
+
+/* Tests __COUNTER__ macro expansion is enabled outside directives with
+   -fdirectives-only. */
+
+int zero = __COUNTER__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cpp.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cpp.exp
new file mode 100644
index 000000000..1dc504e30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cpp.exp
@@ -0,0 +1,43 @@
+#   Copyright (C) 1997, 2000, 2003, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# There's a bunch of headers we need.
+if [is_remote host] {
+    foreach header [glob -nocomplain $srcdir/$subdir/*.{h,def} ] {
+	remote_download host $header
+    }
+}
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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/*.{c,S} ]] \
+	"-fno-show-column" $DEFAULT_CFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom1.c
new file mode 100644
index 000000000..8e254ff75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom1.c
@@ -0,0 +1,11 @@
+/* { dg-do preprocess } */
+/* { dg-options "-pedantic -std=gnu89" } */
+
+/* You can't do this in your own code... */
+// C++ comment is not in C89  { dg-warning "style comment|reported only once" "good warning" }
+
+/* ...but we don't bitch about it more than once.  */
+// C++ comment is not in C89  { dg-bogus "style comment" "bad warning" }
+
+/* { dg-final { scan-file-not cxxcom1.i "is not in C89" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom2.c
new file mode 100644
index 000000000..0dbb8f2fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom2.c
@@ -0,0 +1,7 @@
+/* { dg-do preprocess } */
+/* { dg-options "-pedantic -std=c89 -Wall" } */
+
+#include "cxxcom2.h"
+
+/* { dg-final { scan-file-not cxxcom2.i "is not in C89" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom2.h
new file mode 100644
index 000000000..546b8fd92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/cxxcom2.h
@@ -0,0 +1,4 @@
+/* A system header may contain C++ comments irrespective of mode.  */
+#pragma GCC system_header
+// C++ comment is not in C89  { dg-bogus "style comment" "bad warning" }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/defined.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/defined.c
new file mode 100644
index 000000000..9a60bdd5d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/defined.c
@@ -0,0 +1,85 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests behavior of the defined operator.  */
+
+/*  Source: Neil Booth, 29 Oct 2000, Zack Weinberg 11 Dec 2000.  */
+
+#define defined			/* { dg-error "defined" } */
+
+/* No diagnostics, though you could argue there should be.  */
+#if defined defined
+#error defined is defined!
+#endif
+
+#define is_Z_defined defined Z
+
+#if defined Z
+#error Z is not defined
+#endif
+
+/* The behavior of "defined" when it comes from a macro expansion is
+   now documented.  */
+#if is_Z_defined
+#error Macro expanding into defined operator test 1
+#endif
+
+#define Z
+
+#if !defined Z
+#error Z is defined
+#endif
+
+#if !is_Z_defined
+#error Macro expanding into defined operator test 2
+#endif
+
+#undef is_Z_defined
+#undef Z
+
+/* Do all the tests over again with the () form of defined.  */
+
+/* No diagnostics, though you could argue there should be.  */
+#if defined(defined)
+#error defined is defined!
+#endif
+
+#define is_Z_defined defined ( Z )
+
+#if defined(Z)
+#error Z is not defined
+#endif
+
+/* The behavior of "defined" when it comes from a macro expansion is
+   now documented.  */
+#if is_Z_defined
+#error Macro expanding into defined operator test 1
+#endif
+
+#define Z
+
+#if !defined(Z)
+#error Z is defined
+#endif
+
+#if !is_Z_defined
+#error Macro expanding into defined operator test 2
+#endif
+
+/* Use of defined in different contexts.  */
+
+#define bad1 defined
+#if !bad1 Z			/* { dg-warning "may not be portable" } */
+#error Z is defined
+#endif 
+
+#if !bad1 (Z)			/* { dg-warning "may not be portable" } */
+#error Z is defined
+#endif 
+
+#define bad2 defined (Z
+#if !bad2)			/* { dg-warning "may not be portable" } */
+#error Z is defined
+#endif 
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraph1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraph1.c
new file mode 100644
index 000000000..e098d68da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraph1.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:199409" } */
+
+/* Just simple check that digraphs are on under c94, for both
+   preprocessor and compiler.  digraphs.c is the general test.  */
+
+%:define glue
+#ifndef glue
+#error glue not defined!
+#endif
+
+int main (int argc, char *argv<::>)
+<%
+  return 0;
+%>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraph2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraph2.c
new file mode 100644
index 000000000..293cafa49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraph2.c
@@ -0,0 +1,19 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+
+/* Just simple check that digraphs are not on in c89, for both
+   preprocessor and compiler.  digraphs.c is the general test.  */
+
+int main (int argc, char *argv[])
+{
+  return 0;
+%>				/* { dg-error "parse error|syntax error|expected" } */
+
+/* Place this after main () so we get to test both the compiler above
+   and the preprocessor below.  */
+%:define glue                   /* { dg-error "expected declaration" } */
+#ifdef glue
+#error glue is defined!
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraphs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraphs.c
new file mode 100644
index 000000000..49a1bcd86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/digraphs.c
@@ -0,0 +1,31 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+
+/* Fully test the 6 digraphs under c99 assumptions.  Four are pasted,
+   to check that digraph pasting works.  */
+
+extern int strcmp (const char *, const char *);
+extern void abort (void);
+extern int puts (const char *);
+#define err(str) do { puts(str); abort(); } while (0)
+
+%:define glue(x, y) x %:%: y	/* #define glue(x, y) x ## y. */
+#ifndef glue
+#error glue not defined!
+#endif
+%:define str(x) %:x		/* #define str(x) #x */
+
+int main (int argc, char *argv<::>) /* argv[] */
+glue (<, %) /* { */
+             /* di_str[] = */
+  const char di_str glue(<, :)glue(:, >) = str(%:%:<::><%%>%:);
+
+  /* Check the glue macro actually pastes, and that the spelling of
+     all digraphs is preserved.  */
+  if (glue(str, cmp) (di_str, "%:%:<::><%%>%:"))
+    err ("Digraph spelling not preserved!");
+
+  return 0;
+glue (%, >) /* } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-1.c
new file mode 100644
index 000000000..3c2261683
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-1.c
@@ -0,0 +1,73 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -fdirectives-only } */
+
+/* Tests scan_translation_unit_directives_only()'s handling of corner cases. */
+
+/* Ignore directives inside block comments...
+#error directive inside block comment
+*/
+
+// Escaped newline doesn't terminate line comment \
+#error directive inside line comment
+
+/* A comment canot start inside a string. */
+const char *c1 = "/*";
+#define NOT_IN_COMMENT
+const char *c2 = "*/";
+#ifndef NOT_IN_COMMENT
+#error Comment started inside a string literal
+#endif
+
+/* Escaped newline handling. */
+int i; \
+#error ignored escaped newline
+  \
+  \
+#define BOL
+#ifndef BOL
+#error escaped newline did not preserve beginning of line
+#endif
+
+/* Handles \\ properly at the end of a string. */
+"string ends in \\"/*
+#error Missed string terminator.
+*/
+
+/* Handles macro expansion in preprocessing directives. */
+#define HEADER "dir-only-1.h"
+#include HEADER
+#ifndef GOT_HEADER
+#error Failed to include header.
+#endif
+
+/\
+*
+#define IN_COMMENT
+*/
+#ifdef IN_COMMENT
+#error Escaped newline breaks block comment initiator.
+#endif
+
+/*
+*\
+/
+#define NOT_IN_COMMENT2
+/**/
+#ifndef NOT_IN_COMMENT2
+#error Escaped newline breaks block comment terminator.
+#endif
+
+/* Test escaped newline inside character escape sequence. */
+"\\
+\"/*
+#error Missed string terminator
+*/
+
+/* Block comments don't mask trailing preprocessing
+   directive. */ #define NOT_MASKED
+#ifndef NOT_MASKED
+#error Comment masks trailing directive.
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-1.h
new file mode 100644
index 000000000..96dbcc048
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-1.h
@@ -0,0 +1,3 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+#define GOT_HEADER
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-2.c
new file mode 100644
index 000000000..489b4d6ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-2.c
@@ -0,0 +1,12 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fpreprocessed -fdirectives-only -DNOT_SET" } */
+
+/* Tests -fdirectives-only + -fpreprocessed. */
+
+/* Check this is not defined. */
+#ifdef NOT_SET
+#error Command line macro not disabled.
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3.c
new file mode 100644
index 000000000..e6eaa0180
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3.c
@@ -0,0 +1,13 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fdirectives-only -H" } */
+/* { dg-message "dir-only-3a\.h\n\[^\n\]*dir-only-3b\.h\n\[^\n\]*dir-only-3a\.h\n" "include guard check" { target *-*-* } 0 } */
+
+/* Tests include guards. */
+
+#include "dir-only-3a.h"
+#include "dir-only-3b.h"
+#include "dir-only-3b.h"
+#include "dir-only-3a.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3a.h
new file mode 100644
index 000000000..6644bbfb0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3a.h
@@ -0,0 +1,8 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+extern int outside_guard
+
+#ifndef DIR_ONLY_3A_H
+#define DIR_ONLY_3A_H
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3b.h
new file mode 100644
index 000000000..4edaa7b6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-3b.h
@@ -0,0 +1,9 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+#ifndef DIR_ONLY_3B_H
+#define DIR_ONLY_3B_H
+
+extern int inside guard;
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-4.c
new file mode 100644
index 000000000..a7b5f048f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-4.c
@@ -0,0 +1,6 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fdirectives-only -Wunused-macros" } */
+/* { dg-error "-fdirectives-only is incompatible with -Wunused_macros\n" "-Wunused-macros check" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-5.c
new file mode 100644
index 000000000..643a4d7ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-5.c
@@ -0,0 +1,6 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fdirectives-only -traditional" } */
+/* { dg-error "-fdirectives-only is incompatible with -traditional\n" "-traditional check" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-6.c
new file mode 100644
index 000000000..0023205fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/dir-only-6.c
@@ -0,0 +1,7 @@
+/* Copyright 2007 Free Software Foundation, Inc.
+   Contributed by Ollie Wild <aaw@google.com>.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -fdirectives-only } */
+
+/* { dg-error "unterminated comment" }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/direct2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/direct2.c
new file mode 100644
index 000000000..5ea04da37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/direct2.c
@@ -0,0 +1,46 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.
+   Contributed by Nathan Sidwell 8 May 2001 <nathan@codesourcery.com> */
+
+/* Test of prohibition on directives which result from macro expansion.
+   See also direct2s.c */
+
+/* { dg-do compile } */
+
+#define HASH #
+#define HASHDEFINE #define
+#define HASHINCLUDE #include
+
+HASH include "somerandomfile" /*{ dg-error "stray" "non-include" }*/
+/*{ dg-bogus "No such" "don't execute non-include" { target *-*-* } 13 }*/
+int resync_parser_1; /*{ dg-error "parse|syntax|expected" "" { target *-*-* } 13 }*/
+
+HASHINCLUDE <somerandomfile> /*{ dg-error "stray|expected" "non-include 2" }*/
+/*{ dg-bogus "No such" "don't execute non-include 2" { target *-*-* } 17 }*/
+int resync_parser_2;
+
+void g1 ()
+{
+HASH define X 1 /* { dg-error "stray|undeclared|parse|syntax|expected|for each" "# from macro" } */
+  int resync_parser_3;
+}
+
+void g2 ()
+{
+HASHDEFINE  Y 1 /* { dg-error "stray|undeclared|parse|syntax|expected|for each" "#define from macro" } */
+  int resync_parser_4;
+}
+
+#pragma GCC dependency "direct2.c"
+#
+
+void f ()
+{
+  int i = X;    /* { dg-error "undeclared|for each" "no macro X" } */
+  int j = Y;    /* { dg-error "undeclared|for each" "no macro Y" } */
+}
+
+#define slashstar /##*
+#define starslash *##/
+
+slashstar starslash /* { dg-error "parse error|syntax error|expected" "not a comment" } */
+/* { dg-error "does not give" "paste warning(s)" { target *-*-* } 45 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/direct2s.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/direct2s.c
new file mode 100644
index 000000000..89c0f6b91
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/direct2s.c
@@ -0,0 +1,44 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.
+   Contributed by Nathan Sidwell 8 May 2001 <nathan@codesourcery.com> */
+
+/* Test of prohibition on directives which result from macro
+   expansion.  Same as direct2.c, with -save-temps applied; results
+   should be identical.  */
+
+/* { dg-do compile } */
+/* { dg-options "-save-temps -ansi -pedantic-errors" } */
+
+#define HASH #
+#define HASHDEFINE #define
+#define HASHINCLUDE #include
+
+HASH include "somerandomfile" /*{ dg-error "stray" "non-include" }*/
+/*{ dg-bogus "No such" "don't execute non-include" { target *-*-* } 15 }*/
+int resync_parser_1; /*{ dg-error "parse|syntax|expected" "" { target *-*-* } 15 }*/
+
+HASHINCLUDE <somerandomfile> /*{ dg-error "stray|expected" "non-include 2" }*/
+/*{ dg-bogus "No such" "don't execute non-include 2" { target *-*-* } 18 }*/
+int resync_parser_2;
+
+void g1 ()
+{
+HASH define X 1 /* { dg-error "stray|undeclared|parse|syntax|expected|for each" "# from macro" } */
+  int resync_parser_3;
+}
+
+void g2 ()
+{
+HASHDEFINE  Y 1 /* { dg-error "stray|undeclared|parse|syntax|expected|for each" "#define from macro" } */
+  int resync_parser_4;
+}
+
+#pragma GCC dependency "direct2.c"
+#
+
+void f ()
+{
+  int i = X;    /* { dg-error "undeclared|for each" "no macro X" } */
+  int j = Y;    /* { dg-error "undeclared|for each" "no macro Y" } */
+}
+
+/* { dg-final { cleanup-saved-temps } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/directiv.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/directiv.c
new file mode 100644
index 000000000..aafe2ec10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/directiv.c
@@ -0,0 +1,35 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -pedantic } */
+
+/* Tests general directive syntax, and directive error recovery.  */
+
+
+/* Test directive name is not expanded.  */
+#define foo define
+#foo EMPTY			/* { dg-error "invalid" } */
+
+/* Test # must be first on line.  */
+EMPTY #define bar
+#ifdef bar
+#error bar is defined
+#endif
+
+/* Test form feed and vertical tab warn pedantically, see 6.10
+   paragraph 5.  Tab is OK.  */
+#define something		/* { dg-warning "form feed" } */
+#define something_else	/* { dg-warning "vertical tab" } */
+#define some	thing		/* Tab OK, as is form feed before #.  */
+
+/* Our friend the null directive OK?  */
+#
+
+/* Check newlines end directives, even in function-like macro
+   invocations.  6.10 paragraph 1.
+
+   Note that the #if is still treated as a conditional, so there
+   should be no errors about #endif without #if.  */
+#define func(x) x
+#if func (			/* { dg-error "unterminated argument" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/empty-include.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/empty-include.c
new file mode 100644
index 000000000..f0f5b40bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/empty-include.c
@@ -0,0 +1,13 @@
+/* 
+ * Copyright 2004 Free Software Foundation, Inc.
+ * Contributed and written by Nathanael Nerode.
+ *
+ * GCC 3.4 would attempt to open stdin as the included file
+ * (PR 17610), causing a sort of hang.
+ * 
+ * We should get an error.
+ */
+
+/* { dg-do preprocess } */
+#include "" /* { dg-error "empty" "error on empty filename in include" } */
+int x; /* Otherwise we have an empty file and get more errors. */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif-pedantic1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif-pedantic1.c
new file mode 100644
index 000000000..c97e32907
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif-pedantic1.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-pedantic -Wno-endif-labels" } */
+
+/* Tests combinations of -pedantic and -Wno-endif-labels; see extratokens2.c
+   for more general tests.  */
+
+/* Source: Phil Edwards, 25 Mar 2002.  Copied from extratokens2.c and
+   modified.  */
+
+#if 1 
+#if 0
+#else foo	/* { dg-bogus "extra tokens" "bad warning" } */
+#endif /	/* { dg-bogus "extra tokens" "bad warning" } */
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif-pedantic2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif-pedantic2.c
new file mode 100644
index 000000000..55cc5eb66
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif-pedantic2.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-Wno-endif-labels -pedantic-errors" } */
+
+/* Tests combinations of -pedantic and -Wno-endif-labels; see extratokens2.c
+   for more general tests.  */
+
+/* Source: Phil Edwards, 25 Mar 2002.  Copied from endif-pedantic1.c and
+   modified.  */
+
+#if 1 
+#if 0
+#else foo	/* { dg-error "extra tokens" "tokens after #else" } */
+#endif /	/* { dg-error "extra tokens" "tokens after #endif" } */
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif.c
new file mode 100644
index 000000000..efea52c46
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test case for PR preprocessor/6386 by Andreas Schwab.  We'd back up
+   over the CPP_EOF token (indicating not a funlike macro invocation)
+   in the header file, which would then be passed through as a real
+   EOF, leading to an early exit (and therefore bogus complaint about
+   unterminated #if).  */
+
+#define S(x)
+#if 1
+#include "endif.h"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif.h
new file mode 100644
index 000000000..37622491d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/endif.h
@@ -0,0 +1 @@
+S
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/error-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/error-1.c
new file mode 100644
index 000000000..1bc6a3f6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/error-1.c
@@ -0,0 +1,5 @@
+/* Test that error messages include "error:" in the text.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do preprocess } */
+
+/* { dg-error "unterminated comment" }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape-1.c
new file mode 100644
index 000000000..0f5c11e9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape-1.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+/* This tests various diagnostics about escape sequences, for both
+   the preprocessor and the compiler.
+
+   Neil Booth, 22 May 2001.  */
+
+#if '\x'	/* { dg-error "no following" "\x with no digits" } */
+#endif
+#if '\x400'	/* { dg-error "out of range" "\x out of range" } */
+#endif
+#if '\x0ff'	/* { dg-bogus "out of range" "\x out of range" } */
+#endif
+#if '\400'	/* { dg-error "out of range" "\x out of range" } */
+#endif
+#if '\377'	/* { dg-bogus "out of range" "bogus \x out of range" } */
+#endif
+#if '\177' != 0x7f /* { dg-bogus "out of range" "bogus \x out of range" } */
+#error bad octal /* { dg-bogus "bad" "bad octal evaluation" } */
+#endif
+#if '\0377'	/* { dg-warning "multi" "too long octal" } */
+#endif
+#if '\p'	/* { dg-error "unknown escape" "unknown escape seq" } */
+#endif
+
+void foo ()
+{
+  int c;
+
+  c = '\x';	/* { dg-error "no following" "\x with no digits" } */
+  c = '\x100';	/* { dg-error "out of range" "\x out of range" } */
+  c = '\x0ff';	/* { dg-bogus "out of range" "\x out of range" } */
+  c = '\400';	/* { dg-error "out of range" "\x out of range" } */
+  c = '\377';	/* { dg-bogus "out of range" "bogus \x out of range" } */
+  c = '\0377';	/* { dg-warning "multi" "too long octal" } */
+  c = '\p';	/* { dg-error "unknown escape" "unknown escape seq" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape-2.c
new file mode 100644
index 000000000..e79fa91cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape-2.c
@@ -0,0 +1,20 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-pedantic -std=c99 -fno-show-column" } */
+
+/* This tests various diagnostics with -pedantic about escape
+   sequences, for both the preprocessor and the compiler.
+
+   Neil Booth, 22 May 2001.  */
+
+#if '\e'		/* { dg-warning "non-ISO" "non-ISO \\e" } */
+#endif
+#if L'\u00a0'		/* { dg-bogus "unknown" "\\u is known in C99" } */
+#endif
+
+void foo ()
+{
+  int c = '\E';		/* { dg-warning "non-ISO" "non-ISO \\E" } */
+  c = L'\u00a0';	/* { dg-bogus "unknown" "\\u is known in C99" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape.c
new file mode 100644
index 000000000..c9dd44e43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/escape.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional -std=c89 -fno-show-column" } */
+
+/* This tests various diagnostics with -Wtraditioanl about escape
+   sequences, for both the preprocessor and the compiler.
+
+   Neil Booth, 22 May 2001.  */
+
+#if '\a'		/* { dg-warning "traditional" "traditional bell" } */
+#endif
+#if '\x1a' != 26	/* { dg-warning "traditional" "traditional hex" } */
+ #error bad hex		/* { dg-bogus "bad" "bad hexadecimal evaluation" } */
+#endif
+#if L'\u00a1'		/* { dg-warning "only valid" "\u is unknown in C89" } */
+#endif
+
+void foo ()
+{
+  int c = '\a';		/* { dg-warning "traditional" "traditional bell" } */
+
+  c = '\xa1';		/* { dg-warning "traditional" "traditional hex" } */
+  c = L'\u00a1';	/* { dg-warning "only valid" "\u is unknown in C89" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/expr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/expr.c
new file mode 100644
index 000000000..532bd6812
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/expr.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2000, 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test we get signedness of ?: operator correct.  We would skip
+   evaluation of one argument, and might therefore not transfer its
+   unsignedness to the result.  */
+
+/* Neil Booth, 19 Jul 2002.  */
+
+#if (1 ? -2: 0 + 1U) < 0
+#error				/* { dg-bogus "error" } */
+#endif
+
+#if (0 ? 0 + 1U: -2) < 0
+#error				/* { dg-bogus "error" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/extratokens.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/extratokens.c
new file mode 100644
index 000000000..d3e941bff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/extratokens.c
@@ -0,0 +1,38 @@
+/* Copyright (C) 2000, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fno-show-column -Wno-deprecated" } */
+
+/* Tests all directives that do not permit excess tokens at the end of
+   the line.  */
+
+/* Source: Neil Booth, 4 Dec 2000.  The combination of separate test
+   cases.  */
+
+#ifdef foo bar  /* { dg-warning "extra tokens" "tokens after #ifdef" } */
+#endif
+
+#ifndef foo bar  /* { dg-warning "extra tokens" "tokens after #ifndef" } */
+#endif
+
+#if 1 
+#if 0
+#else foo	/* { dg-warning "extra tokens" "tokens after #else" } */
+#endif /	/* { dg-warning "extra tokens" "tokens after #endif" } */
+#endif
+
+#undef foo bar  /* { dg-warning "extra tokens" "tokens after #undef" } */
+
+#assert foo(bar) bar /* { dg-warning "extra tokens" "tokens after #assert" } */
+
+#unassert foo(bar) b /* { dg-warning "extra tokens" "tokens after #unassert" } */
+
+#include "mi1c.h" bar /* { dg-warning "extra tokens" "tokens after #include" } */
+
+#ident "something" bar /* { dg-warning "extra tokens" "tokens after #ident" } */
+
+# 36 "file.c" 3
+
+/* ... but in a system header, it's acceptable.  */
+#ifdef KERNEL
+#endif KERNEL  /* { dg-bogus "extra tokens" "bad warning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/extratokens2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/extratokens2.c
new file mode 100644
index 000000000..fe682bfa5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/extratokens2.c
@@ -0,0 +1,22 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fno-show-column -Wno-endif-labels" } */
+
+/* Tests that -Wno-endif-labels correctly disables the checks done by
+   default (and tested in extratokens.c).  */
+
+/* Source: Phil Edwards, 21 Mar 2002.  Copied from extratokens.c and
+   modified.  */
+
+#if 1 
+#if 0
+#else foo	/* { dg-bogus "extra tokens" "bad warning" } */
+#endif /	/* { dg-bogus "extra tokens" "bad warning" } */
+#endif
+
+# 36 "file.c" 3
+
+/* ... but in a system header, it's acceptable.  */
+#ifdef KERNEL
+#endif KERNEL  /* { dg-bogus "extra tokens" "bad warning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/fpreprocessed.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/fpreprocessed.c
new file mode 100644
index 000000000..53d298f53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/fpreprocessed.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -fpreprocessed } */
+
+/* Source: Jason Merrill, 19 Nov 2001.  We'd try and back up a token
+   and move to a non-existent token run with -fpreprocessed on a file
+   without a leading # line.  */
+
+foo
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/A.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/A.h
new file mode 100644
index 000000000..557372951
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/A.h
@@ -0,0 +1 @@
+#import <OneSub/C.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/B.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/B.h
new file mode 100644
index 000000000..557372951
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/B.h
@@ -0,0 +1 @@
+#import <OneSub/C.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/C.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/C.h
new file mode 100644
index 000000000..5afd8050c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Frameworks/OneSub.framework/Headers/C.h
@@ -0,0 +1,4 @@
+#ifdef ONESUB_C_INCLUDED
+#error should only be imported once
+#endif
+#define ONESUB_C_INCLUDED 1
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Headers/one-includeSubs.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Headers/one-includeSubs.h
new file mode 100644
index 000000000..adaeb95ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/frame/one.framework/Headers/one-includeSubs.h
@@ -0,0 +1,2 @@
+#import <OneSub/A.h>
+#import <OneSub/B.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc89-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc89-pedantic.c
new file mode 100644
index 000000000..2749ad739
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc89-pedantic.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu89 -pedantic" } */
+
+/* This file is for testing the preprocessor in -std=gnu89 -pedantic mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL				/* { dg-warning "long long" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc89.c
new file mode 100644
index 000000000..b655ead02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc89.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu89" } */
+
+/* This file is for testing the preprocessor in -std=gnu89 mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc99-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc99-pedantic.c
new file mode 100644
index 000000000..9e3550d3e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc99-pedantic.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+/* This file is for testing the preprocessor in -std=gnu99 -pedantic mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc99.c
new file mode 100644
index 000000000..5e2ee29c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/gnuc99.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu99" } */
+
+/* This file is for testing the preprocessor in -std=gnu99 mode.
+   Neil Booth, 2 Dec 2000.  */
+
+#if 1LL
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/hash1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/hash1.c
new file mode 100644
index 000000000..a4c4b3516
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/hash1.c
@@ -0,0 +1,9 @@
+/* Test for proper handling of # in object-like macros.
+   From Linux kernel.  */
+/* { dg-do preprocess } */
+
+#define FIXUP	.section ".fixup",#alloc,#execinstr
+
+FIXUP
+
+/* { dg-bogus "not followed by" "object-like #" { target *-*-* } 3 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ident-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ident-1.c
new file mode 100644
index 000000000..da6e516d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ident-1.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+/* { dg-options "-Wno-deprecated" } */ /* shut off -pedantic */
+
+/* Based on PR 16999 */
+
+#ident "this is an ident"
+
+/* { dg-final { scan-file "ident-1.i" "(^|\\n)#ident \"this is an ident\"($|\\n)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ident.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ident.c
new file mode 100644
index 000000000..5477cbe10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ident.c
@@ -0,0 +1,7 @@
+/* Test #ident.  */
+/* { dg-do compile } */
+/* { dg-options "-Wno-deprecated" } */ /* shut off -pedantic */
+
+#ident "this is an ident"
+
+int dummy(void) { return 12; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-1.c
new file mode 100644
index 000000000..c30f21561
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-1.c
@@ -0,0 +1,41 @@
+/* { dg-do preprocess } */ 
+/* { dg-options "-pedantic-errors" } */
+
+#if 0xa != 10
+#error 0xa != 10 /* { dg-bogus "#error" "normal conversion" } */
+#endif
+
+#if 077 != 63
+#error 077 != 63 /* { dg-bogus "#error" "normal conversion" } */
+#endif
+
+#if 12wrt /* { dg-error "invalid suffix" "invalid number" } */
+#endif
+
+#if 0abc /* { dg-error "invalid suffix" "invalid number" } */
+#endif
+
+#if 42abc /* { dg-error "invalid suffix" "invalid number" } */
+#endif
+
+#if 0xabc != 2748
+#error 0xabc	/* { dg-bogus "#error" "normal conversion" } */
+#endif
+
+#if 1.2 /* { dg-error "loating constant" "floating point in #if" } */
+#endif
+
+#if 4uu /* { dg-error "invalid suffix" "too many suffixes" } */
+#endif
+
+#if 124123231lll /* { dg-error "invalid suffix" "too many suffixes" } */
+#endif
+
+#if 1234lul	/* { dg-error "invalid suffix" "u between ls" } */
+#endif
+
+#if 099 /* { dg-error "invalid digit" "decimal in octal constant" } */
+#endif
+
+#if 0xfffffffffffffffff /* { dg-error "integer constant" "range error" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-2.c
new file mode 100644
index 000000000..dc136b456
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-2.c
@@ -0,0 +1,28 @@
+/* { dg-do preprocess } */
+/* { dg-options -pedantic-errors } */
+
+#if 'a' != 'a' || '\001' != 1 || '\x12' != 0x12
+#error a,1,0x12 /* { dg-bogus "#error" "basic charconst recognition" } */
+#endif
+
+#if 'a' != L'a'
+#error L'a'	/* { dg-bogus "error" "wide charconst recognition 1" } */
+#endif
+
+#if L'\xfeed' != 0xfeed && L'\xfeed' != (0xfeed - 0x10000)
+#error 0xfeed	/* { dg-bogus "error" "wide charconst recognition 2" } */
+#endif
+
+#if L'\x1234' != 0x1234
+#error 0x1234	/* { dg-bogus "error" "wide charconst recognition 3" } */
+#endif
+
+/* The 'character constant (is )?too long' message is produced by 16-bit targets.  */
+#if 'abcd' /* { dg-warning "(multi-character character constant)|(character constant (is )?too long)" "multi-character charconst" } */
+#endif
+
+#if 'abcdefghi' /* { dg-warning "character constant (is )?too long" "charconst too long" } */
+#endif
+
+#if '' /* { dg-error "empty character constant" "empty charconst" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-4.c
new file mode 100644
index 000000000..fbab9efc1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-4.c
@@ -0,0 +1,8 @@
+/* Regression test for proper error message.  The token name isn't
+   NUL terminated, so we would print garbage after it.  */
+/* { dg-do compile } */
+
+#if 1 += 2   /* { dg-error "is not valid" "+= in if" } */
+syntax_error
+#endif
+int foo;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-5.c
new file mode 100644
index 000000000..8238a12ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-5.c
@@ -0,0 +1,9 @@
+/* Regression test: #ifdef 0 should not crash.  Problem noted by
+   Jakub Jelinek <jakub@redhat.com>.  */
+/* { dg-do preprocess } */
+
+#ifdef 0  /* { dg-error "macro names" } */
+#endif
+
+#ifndef 0  /* { dg-error "macro names" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-cexp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-cexp.c
new file mode 100644
index 000000000..1ebd11929
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-cexp.c
@@ -0,0 +1,14 @@
+/* { dg-do preprocess } */
+
+/* Test the ? : opearator, for precedence and both true and false.  */
+
+#if  1 ? 1 ? 2 : 0 : 0
+#error OK	/* { dg-error "OK" "nested ? :" } */
+#endif
+
+#if  ((0) ? (1) ? (2) : (3) : (4) ? (5): (6)) == 5
+#error OK	/* { dg-error "OK" "nested ? : with parens" } */
+#endif
+
+#if 2:		/* { dg-error "':' without" "immediate :" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-div.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-div.c
new file mode 100644
index 000000000..4e4216812
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-div.c
@@ -0,0 +1,6 @@
+/* { dg-do preprocess } */
+
+/* Test that this preprocesses without error.  */
+
+#if (-1)/2
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-mop.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-mop.c
new file mode 100644
index 000000000..119c7392e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-mop.c
@@ -0,0 +1,31 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Source: Neil Booth.  */
+
+/* Various illegal expressions with missing components.  */
+
+#if		/* { dg-error "no expression" "empty #if" } */
+#endif
+
+#if ~		/* { dg-error "no right op" "no unary operand" } */
+#endif
+
+#if 3 + * 6 + 4  /* { dg-error "no right op" "no right operand" } */
+#endif
+
+#if 2 ~2	/* { dg-error "missing bin" "no binary operator" } */
+#endif
+
+#if 1 + 2 (3)   /* { dg-error "missing bin" "immediate then open paren" } */
+#endif
+
+#if (2) 4 * 2  /* { dg-error "missing bin" "close paren then immediate" } */
+#endif
+
+#if == 2  /* { dg-error "no left op" } */
+#endif
+
+#if (==2)  /* { dg-error "no left op" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-mpar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-mpar.c
new file mode 100644
index 000000000..633cefcb4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-mpar.c
@@ -0,0 +1,30 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* Test various combinations of missing parentheses give the correct
+   missing parenthesis message.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fshow-column" } */
+#if (1          /* { dg-error "5:missing '\\)'" "missing ')' no. 1" } */
+#endif
+
+#if 2 * (3 + 4	/* { dg-error "9:missing '\\)'" "missing ')' no. 2" } */
+#endif
+
+#if (2))	/* { dg-error "8:missing '\\('" "missing '(' no. 1" } */
+#endif
+
+#if )		/* { dg-error "5:missing '\\('" "missing '(' no. 2" } */
+#endif
+
+#if 4)		/* { dg-error "6:missing '\\('" "missing '(' no. 3" } */
+#endif
+
+#if (		/* { dg-error "5:missing '\\)'" "missing ')' no. 3" } */
+#endif
+
+#if ((2 + 3) + 5 /* { dg-error "5:missing '\\)'" "missing ')' no. 3" } */
+#endif
+
+#if ((2 + 3 + 5 /* { dg-error "6:missing '\\)'" "missing ')' no. 3" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-oppr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-oppr.c
new file mode 100644
index 000000000..a46a815cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-oppr.c
@@ -0,0 +1,92 @@
+/* Copyright (C) 2000, 2008 Free Software Foundation, Inc.  */
+
+/* Test the full range of preprocessor operator precedence.  Each
+   operator is tested with one of immediately higher precedence to
+   verify it is of strictly lower precedence.  To avoid complications,
+   each test uses just those two operators.  Occasionally this assumes
+   correct operation of if-then-else, so the first tests verify this.  */
+
+/* { dg-do preprocess } */
+
+/* Ensure correct functioning of if-then-else.  */
+#if 1
+#else
+#error #else block evaluated for true conditional
+#endif
+
+#if 0
+#error #if block evaluated for false conditional
+#else
+#endif
+
+/* : strictly higher than ?.  This would give a syntax error otherwise.  */
+#if 0 ? 0 : 1 ? 1 : 1
+#endif
+
+/* || strictly higher than ?:. */
+#if 1 ? 0: 0 || 1
+#error operator ?: has higher precedence than operator ||
+#endif
+
+/* && strictly higher than ||.  */
+#if 1 || 0 && 0
+#else
+#error operator || has higher precedence than operator &&
+#endif
+
+/* | strictly higher than &&.  */
+#if 0 && 0 | 1
+#error operator && has higher precedence than operator |
+#endif
+
+/* ^ strictly higher than |.  */
+#if 1 | 0 ^ 1
+#else
+#error operator | has higher precedence than operator ^
+#endif
+
+/* & strictly higher than ^.  */
+#if 1 ^ 0 & 0
+#else
+#error operator ^ has higher precedence than operator &
+#endif
+
+/* == (!=) strictly higher than &.  */
+#if 0 & 0 == 0
+#error operator & has higher precedence than operator ==
+#endif
+
+/* < (>, <=, >=) strictly higher than == (!=).  */
+
+#if 0 == 0 < 0
+#else
+#error operator == has higher precedence than operator <
+#endif
+
+/* << (>>) strictly higher than < (>, <=, >=).  */
+#if 1 < 1 << 1
+#else
+#error operator < has higher precedence than operator <<
+#endif
+
+/* Binary + (-) strictly higher than << (>>).  */
+#if 0 << 0 + 1
+#error operator << has higher precedence than binary +
+#endif
+
+/* Binary * (/, %) strictly higher than binary + (-).  */
+#if 1 + 0 * 0
+#else
+#error binary + has higher precedence than binary *
+#endif
+
+/* Unary operators (!, ~, -, +) strictly higher than binary * (/, %).
+   Equality is hard to detect because of right-associativity.  */
+#if ~1 * 0
+#error binary * has higher precedence than operator ~
+#endif
+
+/* () > Unary.  Unfortunately this requires an additional operator.  */
+#if -(1 - 1)
+#error unary - has higher precedence than operator ()
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-oppr2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-oppr2.c
new file mode 100644
index 000000000..bcfe7cca2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-oppr2.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.  */
+
+/* Another test of operator precedence.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "" } */
+
+#if 1 ? 2 : 3 , 0
+#error
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-paren.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-paren.c
new file mode 100644
index 000000000..407a302b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-paren.c
@@ -0,0 +1,31 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* These now use "!=" rather than "<" to increase chance of failure.  */
+#if 16 * (1) + 4 != 20
+#error		/* { dg-bogus "error" "with paren" } */
+#endif
+
+#if 16 * 1 + 4 != 20
+#error		/* { dg-bogus "error" "without paren" } */
+#endif
+
+#if ()	        /* { dg-error "expression between" "empty paren" } */
+#endif
+
+#if (1) == 1
+#error		/* { dg-error "" "simple parens no. 1" } */
+#endif
+
+#if (2)
+#error		/* { dg-error "" "simple parens no. 2" } */
+#endif
+
+#if 3 == (3)
+#error		/* { dg-error "" "simple parens no. 3" } */
+#endif
+
+#if (((-1) + 8)) == ((+2) * ((3)) - -1)
+#error		/* { dg-error "" "nested parentheses" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-sc.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-sc.c
new file mode 100644
index 000000000..1607669f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-sc.c
@@ -0,0 +1,26 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test that all operators correctly short circuit.  */
+
+#if (2 || 3 / 0) != 1
+#error		/* { dg-bogus "error" "|| short circuit" } */
+#endif
+
+#if 0 && 3 / 0
+#error		/* { dg-bogus "error" "&& short circuit" } */
+#endif
+
+#if 1 ? 0 : 3 / 0
+#error		/* { dg-bogus "error" "? : right short circuit" } */
+#endif
+
+#if 0 ? 3 / 0 : 2
+#else
+#error		/* { dg-bogus "error" "? : left short circuit" } */
+#endif
+
+#if -1 ? 0 && 3 / 0 : 3 / 0 + 5 == 5
+#error		/* { dg-bogus "error" "nested short circuiting" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-shift.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-shift.c
new file mode 100644
index 000000000..a55420a79
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-shift.c
@@ -0,0 +1,22 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test shift operators.  */
+
+#if 1 << 4 != 16
+#error		/* { dg-bogus "error" "<< +ve shift" } */
+#endif
+
+#if 19 >> 2 != 4
+#error		/* { dg-bogus "error" ">> +ve shift" } */
+#endif
+
+#if 17 << -2 != 17 >> 2
+#error		/* { dg-bogus "error" "<< -ve shift" } */
+#endif
+
+#if 25 >> -2 != 25 << 2
+#error		/* { dg-bogus "error" ">> -ve shift" } */
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-unary.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-unary.c
new file mode 100644
index 000000000..f5442afe8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/if-unary.c
@@ -0,0 +1,32 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test the various unary operators.  */
+
+#if 1 + + + 1   /* allow multiple unary sign operators :) */
+#endif
+
+#if 8 - +3 != +4 + +1
+#error		/* { dg-bogus "error" "unary +" } */
+#endif
+
+#if -2 - -1 != -1
+#error		/* { dg-bogus "error" "unary -" } */
+#endif
+
+#if ~0 != -1
+#error		/* { dg-bogus "error" "unary ~" } */
+#endif
+
+#if !0 && (!1 == 0) && !!1 != 1
+#error		/* { dg-bogus "error" "unary !" } */
+#endif
+
+#if ~~8 != 8
+#error		/* { dg-bogus "error" "double unary ~" } */
+#endif
+
+#if 5 + +!-4 != 5
+#error		/* { dg-bogus "error" "compound unary +, !, -" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import1.c
new file mode 100644
index 000000000..07130f014
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import1.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2003, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-Wno-deprecated" } */
+
+/* This tests that our eagerness to apply the multiple include guard
+   optimization to the #import doesn't stop us marking the file
+   once-only.
+
+   Neil Booth, 2 August 2003.  */
+
+#include "import1.h"
+#import "import1.h"
+#undef IMPORT1_H
+#define BUG
+#include "import1.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import1.h
new file mode 100644
index 000000000..936c525eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import1.h
@@ -0,0 +1,6 @@
+#ifndef IMPORT1_H
+#define IMPORT1_H
+#ifdef BUG
+#error Should not happen
+#endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import2.c
new file mode 100644
index 000000000..99b987551
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import2.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2003, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-Wno-deprecated" } */
+
+/* This tests that the file is only included once
+   Neil Booth, 2 August 2003.  */
+
+#include "import2.h"
+#import "import2.h"
+#include "import2.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import2.h
new file mode 100644
index 000000000..c6a0fa597
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/import2.h
@@ -0,0 +1,4 @@
+#ifdef BUG
+#error Should not happen!
+#endif
+#define BUG
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/foo.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/foo.h
new file mode 100644
index 000000000..ec770476c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/foo.h
@@ -0,0 +1 @@
+extern int a;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20348-aux.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20348-aux.h
new file mode 100644
index 000000000..1f04c7569
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20348-aux.h
@@ -0,0 +1 @@
+#include "pr20348.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20348.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20348.h
new file mode 100644
index 000000000..810bb36d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20348.h
@@ -0,0 +1,9 @@
+#ifndef MIDDLE
+# ifndef INC_PR20348_H_SEEN
+#  define INC_PR20348_H_SEEN
+# else
+#  error inc/pr20348.h included twice before MIDDLE definition
+# endif
+#else
+# error inc/pr20348.h included after MIDDLE definition
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20356-aux.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20356-aux.h
new file mode 100644
index 000000000..3f4a67f8e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20356-aux.h
@@ -0,0 +1 @@
+#include "pr20356.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20356.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20356.h
new file mode 100644
index 000000000..582925739
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pr20356.h
@@ -0,0 +1,6 @@
+#ifndef INC_PR20356_H
+# define INC_PR20356_H
+#endif
+#ifndef PR20356_H
+# include_next <pr20356.h>
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pragma-once-1a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pragma-once-1a.h
new file mode 100644
index 000000000..7de641216
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/inc/pragma-once-1a.h
@@ -0,0 +1,6 @@
+#ifndef _A_H_
+#define _A_H_
+
+#include "../pragma-once-1b.h"
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include1.c
new file mode 100644
index 000000000..a0a54e005
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include1.c
@@ -0,0 +1,13 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests that "#include MACRO" works.  */
+
+/* Source: Neil Booth, 29 Oct 2000.  */
+
+#define MACRO "mi1c.h"
+#include MACRO
+#ifndef CPP_MIC_H
+#error #include MACRO does not work
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include2.c
new file mode 100644
index 000000000..cda818ed5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include2.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests that #include does not allow the terminating '>' or '"' to be
+   escaped, as per the standard.  */
+
+/* Source: Neil Booth, 4 Nov 2000.  */
+
+#include <silly\>>  /* { dg-error "extra tokens" "" } */
+#include "silly\""  /* { dg-error "extra tokens" "" } */
+
+/* These error is No such file or directory, just once.  However, this
+   message is locale-dependent, so don't test for it.  */
+/* { dg-error "silly" "" { target *-*-* } 10 } */
+/* { dg-error "missing" "" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include3.c
new file mode 100644
index 000000000..8bea2b78e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include3.c
@@ -0,0 +1,7 @@
+/* Unpatched, this file would include "inc/ foo.h" (note the space)  */
+
+#define PREINC_XSTR(str)             #str
+#define PREINC_STR(str)              PREINC_XSTR(str)
+#define COMP_INC(comp,file)          PREINC_STR(comp/file)
+
+#include COMP_INC(inc, foo.h)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include4.c
new file mode 100644
index 000000000..d5e7fee88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/include4.c
@@ -0,0 +1,14 @@
+/* Preprocessing tokens are always formed according to a greedy algorithm,
+   so "#include <stddef.h" must be interpreted as a sequence of tokens,
+   of which the "h" then gets macro expanded.  Likewise the other
+   examples.  */
+
+#define h h>
+#include <stddef.h
+#undef h
+
+#define foo stddef.h>
+#include <foo
+
+#include <foo /*
+> */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/isysroot-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/isysroot-1.c
new file mode 100644
index 000000000..7263ce415
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/isysroot-1.c
@@ -0,0 +1,10 @@
+/* { dg-options "-isysroot ${srcdir}/gcc.dg/cpp" } */
+/* { dg-do compile  { target *-*-darwin* } } */
+
+#include <stdio.h>
+int main()
+{
+  /* Special stdio.h supplies function foo.  */
+  void (*x)(void) = foo;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/isysroot-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/isysroot-2.c
new file mode 100644
index 000000000..346d4093c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/isysroot-2.c
@@ -0,0 +1,10 @@
+/* { dg-options "-isysroot ${srcdir}/gcc.dg/cpp" } */
+/* { dg-do compile { target *-*-darwin* } } */
+
+#include <Carbon/Carbon.h>
+int main()
+{
+  /* Special Carbon.h supplies function foo.  */
+  void (*x)(void) = foo;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexident.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexident.c
new file mode 100644
index 000000000..fdf54a2e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexident.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-trigraphs -fdollars-in-identifiers" } */
+
+/* Test lexing of identifiers.  */
+
+/* Escaped newlines, _ and $ in identifiers.  */
+#def\
+\
+ine foo_
+
+#d\
+ef??/
+in\
+e b\
+a$r
+
+#ifndef foo_
+#error foo_
+#endif
+
+#ifndef ba$r
+#error ba$r
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexnum.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexnum.c
new file mode 100644
index 000000000..7df155408
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexnum.c
@@ -0,0 +1,50 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-trigraphs" } */
+
+/* Test lexing of numbers.  */
+
+extern int puts (const char *);
+extern void abort (void);
+#define err(str) do { puts(str); abort(); } while (0)
+
+/* Escaped newlines.  */
+#define foo 12\
+3\
+\
+4??/
+5
+
+#if foo != 12345
+#error foo
+#endif
+
+int main (int argc, char *argv[])
+{
+  double a = 5.;
+  double x = .5;
+
+/* Decimal points, including initially and immediately before and
+   after an escaped newline.  */
+  if (a != 5)
+    err ("a");
+  if (x != .\
+5)
+    err ("x != .5");
+  x = 25\
+.\
+6;
+  if (x != 25.6)
+    err ("x != 25.6");
+
+  /* Test exponentials and their signs.  A buggy lexer is more likely
+     to fail the compile, but never mind.  */
+  if (250 != 25e+1 || 250 != 25e1 || 250 != 2500e-1)
+    err ("exponentials");
+
+  /* Todo: p exponentials, and how to test preprocessing number
+     tokenisation?  */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexstrng.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexstrng.c
new file mode 100644
index 000000000..b03533003
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/lexstrng.c
@@ -0,0 +1,67 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-trigraphs" } */
+
+/* Test lexing of strings and character constants.  */
+
+#ifndef __WCHAR_TYPE__
+#define __WCHAR_TYPE__ int
+#endif
+typedef __WCHAR_TYPE__ wchar_t;
+
+extern int strcmp (const char *, const char *);
+extern int puts (const char *);
+extern void abort (void);
+#define err(str) do { puts(str); abort(); } while (0)
+
+/* Escaped newlines.  */
+const char *str1 = "s\
+t\
+\
+r??/
+  1";
+
+const char x = '\
+??/
+b';
+
+/* Test escaped terminators.  */
+const char *term = "\"\\\"\\";
+const char termc = '\'';
+const char *terms = "'";
+
+/* Test wide strings and chars are lexed.  */
+const wchar_t wchar = L'w';
+const wchar_t* wstring = L"wide string";
+
+/* Test all 9 trigraphs embedded in a string.  Test trigraphs do not
+   survive an embedded backslash newline.  Test trigraphs preceded by
+   a '?' are still noticed.  */
+const char *t = "??/\??<??>??=??)??\
+(??(??!??'??-???=???/
+?-";
+
+int main (int argc, char *argv[])
+{
+  if (strcmp (str1, "str  1"))
+    err ("str1");
+
+  if (x != 'b')
+    err ("b");
+
+  /* We have to split the string up to avoid trigraph replacement
+     here.  Split the 2 trigraphs after both 1 and 2 ?s; just doing
+     this exposed a bug in the initial release of the tokenized lexer.  */
+  if (strcmp (t, "\\{}#]?" "?([|^~?#??" "-"))
+    err ("Embedded trigraphs");
+
+  if (term[0] != '"' || term[1] != '\\' || term[2] != '"'
+      || term[3] != '\\' || term[4] != '\0')
+    err ("Escaped string terminators");
+
+  if (termc != terms[0])
+    err ("Escaped character constant terminator");
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line1.c
new file mode 100644
index 000000000..b13c1229d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line1.c
@@ -0,0 +1,12 @@
+/* Copyright (C) 2000, 2003  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do preprocess } */
+
+/* The line number below must be just a few lines greater than the
+   actual line number. */
+#line 10 "baz"
+wibble
+
+/* { dg-final { scan-file line1.i baz } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line2.c
new file mode 100644
index 000000000..5ee0e04be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line2.c
@@ -0,0 +1,13 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do preprocess } */
+
+#line 1
+#line 0 
+#line 2
+#line 32768 
+
+/* { dg-error "out of range" "line # too low" { target *-*-* } 1 } */
+/* { dg-error "out of range" "line # too high" { target *-*-* } 2 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line3.c
new file mode 100644
index 000000000..dc5bf818d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line3.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-Wwrite-strings" } */ 
+/* The purpose of this test is to ensure that line numbers in diagnostics
+   are accurate after macros whose arguments contain newlines and are
+   substituted multiple times.  The semicolons are on separate lines because
+   #line can only correct numbering on line boundaries.  */
+#define one(x) x
+#define two(x) x x
+#define four(x) two(x) two(x)
+
+int
+main(void)
+{
+  char *A;
+
+  A = "text";		/* { dg-warning "discards qualifiers" "case zero" } */
+  A = one("text"
+	  "text")
+	;		/* { dg-warning "discards qualifiers" "case one" } */
+  A = two("text"
+	  "text")
+	;		/* { dg-warning "discards qualifiers" "case two" } */
+  A = four("text"
+	   "text")
+	;		/* { dg-warning "discards qualifiers" "case four" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line4.c
new file mode 100644
index 000000000..84dbf9623
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line4.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+
+/* Test #line with and without macros for the line number.  */
+
+extern void abort (void);
+
+#define L 90
+
+#line 44
+enum { i = __LINE__ };
+
+#line L
+enum { j = __LINE__ };
+
+#line 16  /* N.B. the _next_ line is line 16.  */
+
+char array1[i        == 44 ? 1 : -1];
+char array2[j        == 90 ? 1 : -1];
+char array3[__LINE__ == 19 ? 1 : -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line5.c
new file mode 100644
index 000000000..4cad6a171
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line5.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fpreprocessed" } */
+
+/* Source: Neil Booth, 16 Sep 2001.
+
+   This file, with an indented line marker, is not possible without
+   user editing of preprocessed output, or the user using
+   -fpreprocessed on raw source.  Nevertheless, we should not
+   segfault.  This is a test that we don't back up two tokens in
+   cpplib.c - one to back up over the number, and one when we
+   recognize that it's not a valid directive in preprocessed input.  */
+
+ # 1 "foo.c"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line6.c
new file mode 100644
index 000000000..c59ea3af7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/line6.c
@@ -0,0 +1,7 @@
+/* PR 28079 */
+/* { dg-do preprocess } */
+/* { dg-options "" } */
+
+#line 18446744073709551616 /* { dg-warning "line number out of range" } */
+
+#line 12312312312435 /* { dg-warning "line number out of range" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-dir-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-dir-1.c
new file mode 100644
index 000000000..002c47f5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-dir-1.c
@@ -0,0 +1,34 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Source: Neil Booth, 26 Feb 2002.
+
+   Test that we allow directives in macro arguments.  */
+
+/* { dg-do run } */
+/* { dg-options "" } */
+
+#define f(x) x
+extern void abort (void);
+
+int main ()
+{
+  if (f (
+#if f(1)			/* True.  */
+	0))			/* False. */
+#else
+    	1))
+#endif
+     abort ();
+
+     /* Outer f expands to original definition, f in argument expands
+	to new definition, so result is: if (1 != 2 - 1).  */
+     if (1 != f(2
+#undef f
+#define f - 1
+     f))
+     abort ();
+
+     return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-dir-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-dir-2.c
new file mode 100644
index 000000000..b31ab3bee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-dir-2.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Source: Neil Booth, 26 Feb 2002.
+
+   Test that we allow directives in macro arguments.  */
+
+/* { dg-do preprocess } */
+
+#define f(x) x
+
+f (
+#if 1		/* { dg-error "not portable" } */
+1)
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-eol-at-eof.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-eol-at-eof.c
new file mode 100644
index 000000000..6b0a279dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mac-eol-at-eof.c
@@ -0,0 +1 @@
+/* Test no newline at eof warning when Mac line ending is used*/
/* { dg-do compile } */
int main() { return 0; } 
\ No newline at end of file
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom1.c
new file mode 100644
index 000000000..2e01911c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom1.c
@@ -0,0 +1,14 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC" } */
+
+/* This tests to make sure that comments are ignored between # and the
+   directive name when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#/**/define def passed
+
+def
+
+/* { dg-final { scan-file maccom1.i "(^|\\n)passed" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom2.c
new file mode 100644
index 000000000..a448082e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom2.c
@@ -0,0 +1,14 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC" } */
+
+/* This tests to make sure that comments between the #define directive
+   and the macro identifier are ignored (i.e. treated like whitespace)
+   when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define/**/def passed
+
+def
+
+/* { dg-final { scan-file maccom2.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom3.c
new file mode 100644
index 000000000..580c52c06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom3.c
@@ -0,0 +1,13 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC" } */
+
+/* This tests to make sure that comments in the definition of a macro
+   parameter list are ignored when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define def(x /**/, y) passed
+
+def(x,y)
+
+/* { dg-final { scan-file maccom3.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom4.c
new file mode 100644
index 000000000..54806c154
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom4.c
@@ -0,0 +1,17 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC" } */
+
+/* This tests to make sure the comment is saved in the macro and copied
+   to the output file when the macro is expanded when the -CC option is
+   used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define def /* passed */
+
+def
+
+/*
+   /* The + in the regexp prevents it from matching itself.  */
+   { dg-final { scan-file maccom4.i "p+assed" } }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom5.c
new file mode 100644
index 000000000..b01a045e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom5.c
@@ -0,0 +1,18 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC" } */
+
+/* This tests to make sure that C++ comments are converted to C comments
+   when saved in the macro and copied to the output file when the macro
+   is expanded when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define def // passed
+
+def:
+
+/*
+   /* The + in the regexp prevents it from matching itself.  */
+   { dg-final { scan-file maccom5.i "p+assed" } }
+   { dg-final { scan-file-not maccom5.i "p+assed:" } }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom6.c
new file mode 100644
index 000000000..09ca87d4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/maccom6.c
@@ -0,0 +1,20 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC" } */
+
+/* This tests to make sure that expressions function properly
+   when used with macros containing comments and the -CC option
+   is being used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define ONE   1 /* one */
+#define TWO   2 /* two */
+#define THREE 3 /* three */
+
+#if (ONE + TWO) != THREE
+failed
+#else
+passed
+#endif
+
+/* { dg-final { scan-file maccom6.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro1.c
new file mode 100644
index 000000000..e7235f577
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro1.c
@@ -0,0 +1,128 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+
+/* Tests various macro abuse is correctly expanded.  */
+
+extern int puts (const char *);
+extern void abort (void);
+extern int strcmp(const char *s1, const char *s2);
+
+#define err(str) do { puts(str); abort(); } while (0)
+#define j(x, y) x + y
+#define k(x, y) j(x + 2, y +
+#define glue(x, y) x ## y
+#define xglue(x, y) glue(x, y)
+
+/* Functions called when macros are left unexpanded.  */
+int q(int x)		{return x + 40;}
+int B(int x)		{return x + 20;}
+int foo(int x)		{return x + 10;}
+int bar(int x, int y)	{return x + y;}
+int baz(int x, int y)	{return x + y;}
+int toupper(int x)	{return x + 32;}
+int M(int x)		{return x * 2;}
+
+int main (int argc, char *argv[])
+{
+#define q(x) x
+  if (q(q)(2) != 42)
+    err ("q");
+
+#define A(x) B(x)
+  if (A(A(2)) != 42)
+    err ("A");
+
+#define E(x) A x
+#define F (22)
+  if (E(F) != 42)
+    err ("E(F)");
+
+#define COMMA ,
+#define NASTY(a) j(a 37)
+  if (NASTY (5 COMMA) != 42)
+    err ("NASTY");
+
+#define bar(x, y) foo(x(y, 0))
+#define apply(x, y) foo(x(y, 22))
+#define bam bar
+  if (bar(bar, 32) != 42)	/* foo(bar(32, 0)).  */
+    err ("bar bar");
+  if (bar(bam, 32) != 42)	/* Same.  */
+    err ("bar bam");
+  if (apply(bar, baz) != 42)	/* foo(foo(baz(22, 0))).  */
+    err ("apply bar baz");
+
+  /* Taken from glibc.  */
+#define __tobody(c, f) f (c)
+#define toupper(c) __tobody (c, toupper)
+  if (toupper (10) != 42)	/* toupper (10). */
+    err ("toupper");
+
+  /* This tests that M gets expanded the right no. of times.  Too many
+     times, and we get excess "2 +"s and the wrong sum.  Derived from
+     nested stpcpy in dggettext.c.  */
+#define M(x) 2 + M(x)
+#define stpcpy(a) M(a)
+  if (stpcpy (stpcpy (9)) != 42) /*  2 + M (2 + M (9)) */
+    err ("stpcpy");
+
+  /* Another test derived from nested stpcpy's of dggettext.c.  Uses
+     macro A(x) and function B(x) as defined above.  The problem was
+     the same - excess "1 +"s and the wrong sum.  */
+#define B(x) 1 + B(x)
+#define C(x) A(x)
+  if (C(B(0)) != 42)		/* 1 + B (1 + B (0)) */
+    err ("C");
+
+  /* More tests derived from gcc itself - the use of XEXP and COST.
+     These first two should both expand to the same thing.  */
+  {
+    int insn = 6, i = 2, b = 2;
+#define XEXP(RTX, N)  (RTX * N + 2)
+#define PATTERN(INSN) XEXP(INSN, 3)
+    if (XEXP (PATTERN (insn), i) != 42)	/* ((insn * 3 + 2) * i + 2) */
+      err ("XEXP (PATTERN)");
+    if (XEXP (XEXP (insn, 3), i) != 42)	/* ((insn * 3 + 2) * i + 2) */
+      err ("XEXP (XEXP)");
+
+#define COST(X) XEXP (XEXP (X, 4), 4)
+    if (COST (b) != 42)		/* ((b * 4 + 2) * 4 + 2) */
+      err ("COST");
+  }
+
+  /* This tests macro recursion and expand-after-paste.  */
+#define FORTYTWO "forty"
+#define TWO TWO "-two"
+  if (strcmp (glue(FORTY, TWO), "forty"))
+    err ("glue");
+  if (strcmp (xglue(FORTY, TWO), "forty-two"))
+    err ("xglue");
+
+  /* Test ability to call macro over multiple logical lines.  */
+  if (q
+      (42) != 42
+      || q (
+	 42) != 42
+      || q (42
+	    ) != 42
+      || q
+      (
+       42
+       )
+      != 42)
+    err ("q over multiple lines");
+
+  /* Corner case.  Test that macro expansion is turned off for later
+     q, when not at start but at end of argument context, and supplied
+     with the '(' necessary for expansion.  */
+  if (q(1 + q)(1) != 42)	/* 1 + q(1) */
+    err ("Nested q");
+
+  /* This looks like it has too many ')', but it hasn't.  */
+  if (k(1, 4) 35) != 42)
+    err ("k");
+
+  /* Phew! */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro10.c
new file mode 100644
index 000000000..20d4911e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro10.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Source: Neil Booth, 23 Sep 2001.
+
+   A tricky, pathological corner case we used to get wrong.  Expansion
+   should go as follows.  The asterisk indicates the token has "blue
+   paint" can no longer be macro expanded.  We used to lose that
+   information when parsing arguments and dropping to the lexer to get
+   the ')'.
+
+   foo )
+   bar foo* )
+   func (foo* )
+   foo*   
+
+   If we try and expand the final foo, we get an "unterminated
+   argument list invoking macro <func>" error.  If we do the right
+   thing and leave it as is, no diagnostics are emitted.  */
+
+#define func(x) x
+#define bar func(
+#define foo bar foo
+foo )
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro11.c
new file mode 100644
index 000000000..b131223b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro11.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Source: Neil Booth, 2 Oct 2001.
+
+   Tests that we clear the disabled flag that is set by the
+   macro-defined-to-itself optimization (the optimization might not be
+   worth it).  */
+
+#define foo foo
+#undef foo
+#define foo 1
+#if !foo
+#error foo still disabled! 
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro2.c
new file mode 100644
index 000000000..2265a2b4c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro2.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests the argument context get set at the lower level if we drop
+   contexts whilst parsing arguments.  This would enter an infinite
+   loop in is_macro_disabled previously.  */
+
+#define A Something
+#define B C
+#define C K(
+#define K(S) S  
+#define T B A )
+T				/* Expands to <Something>.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro3.c
new file mode 100644
index 000000000..e6a5ffc1e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro3.c
@@ -0,0 +1,37 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+
+/* First two tests sourced from a bug report of Thomas Pornin.
+   Varargs test source Jamie Lokier.
+   All adapted for the testsuite by Neil Booth, Oct 2000.  */
+
+/* Tests various macro abuse is correctly expanded.  */
+static int d = 4;
+#define c(x) d
+#define d(x) c(2)
+
+#if 0
+/* This macro chain above sucks up the whole file once it starts, so
+   I've commented it out.  The example is left for idle amusement :-) */
+#define a(x) b(
+#define b(x) a(
+#endif
+
+#define apply(...)   apply2 (__VA_ARGS__)  
+#define half(x)      ((x) / 2)
+#define apply2(f,x)  f (x)
+
+extern void abort (void);
+extern void exit (int);
+
+int main()
+{
+  /* Expands to c(2) then d.  */
+  if (c(c)(c) != 4)
+    abort ();
+
+  if (apply (half, 200) != 100)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro4.c
new file mode 100644
index 000000000..ceaf8ddbf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro4.c
@@ -0,0 +1,13 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test source Neil Booth.  */
+
+#define glue(x, y) x ## y
+#define xglue(x, y) glue (x, y)
+
+/* Should expand to glue (1, 2), then 12.  */
+#if glue (xgl, ue) (1, 2) != 12
+#error glue macro
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro5.c
new file mode 100644
index 000000000..9e226b871
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro5.c
@@ -0,0 +1,24 @@
+/* { dg-do preprocess } */
+
+/* Test source Robert Lipe, with minor modifications for the testsuite
+   by Neil Booth.  29 Oct 2000.  */
+
+#define _VA_ARGS_0() 42
+#define _L_0()                      (
+#define _R_0()                      )
+
+#define __VA_ARGLIST(argc,list) \
+                _VA_ARGS_##argc list
+
+#define _CAT_LIST(argc,list1,list2) \
+                _L_##argc list1 _R_##argc list2
+
+#define _VA_ARGLIST(argc,list1,list2) \
+                __VA_ARGLIST(argc, \
+                        _CAT_LIST(argc, list1, list2))
+
+#define BLAH(a) _VA_ARGLIST(a, (), ())
+
+#if BLAH (0) != 42
+#error Simulated varargs macros
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro6.c
new file mode 100644
index 000000000..0fe52ee43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro6.c
@@ -0,0 +1,32 @@
+/* { dg-do run } */
+
+/* Test that, when a macro expansion spills into the source file, we
+   expand macros we suck in from there, as the standard clearly states
+   they are not nested.
+
+   Submitter: Neil Booth, with minor modifications to the originals. 3
+   Dec 2000.
+   Source: PR 962 and Thomas Pornin.  */
+
+extern void abort (void);
+int e = 10, f = 100;
+
+#define e(n) 4 + n
+#define X e
+#define f(x) x
+#define h(x) x + f
+
+int
+main ()
+{
+  if (X(X) != 14)		/* Should expand to "4 + e".  */
+    abort ();
+
+  if (X(X(f)) != 108)		/* Should expand to "4 + 4 + f".  */
+    abort ();
+
+  if (h(e)(h(e)) != 120)	/* Should expand to "e + e + f".  */
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro7.c
new file mode 100644
index 000000000..6f2c67c10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro7.c
@@ -0,0 +1,10 @@
+/* { dg-do preprocess } */
+
+/* Test we don't complain about directives in macro expansions when
+   looking for the '(' of a function-like macro.
+
+   Submitter: Neil Booth. 3 Mar 2000.  */
+
+#define f(x) x
+f
+#define g
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro8.c
new file mode 100644
index 000000000..f49b0be9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro8.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options -std=gnu89 } */
+
+/* GCC 2.95.2 used to get the following variable argument macro
+   expansions wrong.
+
+   Source: Neil Booth, from PR 3852 with persmission.  31 Jul 2001.  */
+
+#define TEST_WORSE(args...) (5, ## args)
+#define TEST_BAD(foo, args...) (2, (foo), ## args)
+
+extern void abort ();
+
+static int add (int a, int b)
+{
+  return a + b;
+}
+
+int main ()
+{
+  /* Would expand to a single closing parenthesis, maybe because of
+     the "no args requires space" brokenness.  */
+  if (TEST_WORSE () != 5)
+    abort ();
+  /* The macro would expand to (0, (0) with a missing closing parenthesis.  */
+  if (add TEST_BAD (5) != 7)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro9.c
new file mode 100644
index 000000000..ef9e3697e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macro9.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+/* Source: Neil Booth, 15 Sep 2001.
+
+   A silly test to check that if a function-like macro name is
+   immediately followed by a directive, then we process the directive
+   properly.  */
+
+#define main()
+int main
+#define mainbody () { return 0; }
+mainbody
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macspace1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macspace1.c
new file mode 100644
index 000000000..daf14d2b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macspace1.c
@@ -0,0 +1,63 @@
+/* PR preprocessor/19475 */
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors -fno-show-column" } */
+
+#define a!		/* { dg-warning "missing whitespace" } */
+#define b"		/* { dg-warning "missing whitespace" } */
+#define c#		/* { dg-warning "missing whitespace" } */
+#define d%		/* { dg-warning "missing whitespace" } */
+#define e&		/* { dg-warning "missing whitespace" } */
+#define f'		/* { dg-warning "missing whitespace" } */
+#define g)		/* { dg-warning "missing whitespace" } */
+#define h*		/* { dg-warning "missing whitespace" } */
+#define i+		/* { dg-warning "missing whitespace" } */
+#define j,		/* { dg-warning "missing whitespace" } */
+#define k-		/* { dg-warning "missing whitespace" } */
+#define l.		/* { dg-warning "missing whitespace" } */
+#define m/		/* { dg-warning "missing whitespace" } */
+#define n:		/* { dg-warning "missing whitespace" } */
+#define o;		/* { dg-warning "missing whitespace" } */
+#define p<		/* { dg-warning "missing whitespace" } */
+#define q=		/* { dg-warning "missing whitespace" } */
+#define r>		/* { dg-warning "missing whitespace" } */
+#define s?		/* { dg-warning "missing whitespace" } */
+#define t[		/* { dg-warning "missing whitespace" } */
+#define u]		/* { dg-warning "missing whitespace" } */
+#define v^		/* { dg-warning "missing whitespace" } */
+#define w{		/* { dg-warning "missing whitespace" } */
+#define x|		/* { dg-warning "missing whitespace" } */
+#define y}		/* { dg-warning "missing whitespace" } */
+#define z~		/* { dg-warning "missing whitespace" } */
+#define A>>		/* { dg-warning "missing whitespace" } */
+#define B<<		/* { dg-warning "missing whitespace" } */
+#define E&&		/* { dg-warning "missing whitespace" } */
+#define F||		/* { dg-warning "missing whitespace" } */
+#define G==		/* { dg-warning "missing whitespace" } */
+#define H!=		/* { dg-warning "missing whitespace" } */
+#define I>=		/* { dg-warning "missing whitespace" } */
+#define J<=		/* { dg-warning "missing whitespace" } */
+#define K+=		/* { dg-warning "missing whitespace" } */
+#define L-=		/* { dg-warning "missing whitespace" } */
+#define M*=		/* { dg-warning "missing whitespace" } */
+#define N/=		/* { dg-warning "missing whitespace" } */
+#define O%=		/* { dg-warning "missing whitespace" } */
+#define P&=		/* { dg-warning "missing whitespace" } */
+#define Q|=		/* { dg-warning "missing whitespace" } */
+#define R^=		/* { dg-warning "missing whitespace" } */
+#define S>>=		/* { dg-warning "missing whitespace" } */
+#define T<<=		/* { dg-warning "missing whitespace" } */
+#define W...		/* { dg-warning "missing whitespace" } */
+#define X++		/* { dg-warning "missing whitespace" } */
+#define Y--		/* { dg-warning "missing whitespace" } */
+#define Z->		/* { dg-warning "missing whitespace" } */
+#define aa::		/* { dg-warning "missing whitespace" } */
+#define ab->*		/* { dg-warning "missing whitespace" } */
+#define ac.*		/* { dg-warning "missing whitespace" } */
+#define ad\x		/* { dg-warning "missing whitespace" } */
+#define ae\\x		/* { dg-warning "missing whitespace" } */
+#define af'1'		/* { dg-warning "missing whitespace" } */
+#define ag"abc"		/* { dg-warning "missing whitespace" } */
+
+int dummy;
+/* { dg-error "missing terminating" "" { target *-*-* } 6 } */
+/* { dg-error "missing terminating" "" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macspace2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macspace2.c
new file mode 100644
index 000000000..7a81eceea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macspace2.c
@@ -0,0 +1,63 @@
+/* PR preprocessor/19475 */
+/* { dg-do preprocess } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors -fno-show-column" } */
+
+#define a!		/* { dg-error "requires whitespace" } */
+#define b"		/* { dg-error "requires whitespace" } */
+#define c#		/* { dg-error "requires whitespace" } */
+#define d%		/* { dg-error "requires whitespace" } */
+#define e&		/* { dg-error "requires whitespace" } */
+#define f'		/* { dg-error "requires whitespace" } */
+#define g)		/* { dg-error "requires whitespace" } */
+#define h*		/* { dg-error "requires whitespace" } */
+#define i+		/* { dg-error "requires whitespace" } */
+#define j,		/* { dg-error "requires whitespace" } */
+#define k-		/* { dg-error "requires whitespace" } */
+#define l.		/* { dg-error "requires whitespace" } */
+#define m/		/* { dg-error "requires whitespace" } */
+#define n:		/* { dg-error "requires whitespace" } */
+#define o;		/* { dg-error "requires whitespace" } */
+#define p<		/* { dg-error "requires whitespace" } */
+#define q=		/* { dg-error "requires whitespace" } */
+#define r>		/* { dg-error "requires whitespace" } */
+#define s?		/* { dg-error "requires whitespace" } */
+#define t[		/* { dg-error "requires whitespace" } */
+#define u]		/* { dg-error "requires whitespace" } */
+#define v^		/* { dg-error "requires whitespace" } */
+#define w{		/* { dg-error "requires whitespace" } */
+#define x|		/* { dg-error "requires whitespace" } */
+#define y}		/* { dg-error "requires whitespace" } */
+#define z~		/* { dg-error "requires whitespace" } */
+#define A>>		/* { dg-error "requires whitespace" } */
+#define B<<		/* { dg-error "requires whitespace" } */
+#define E&&		/* { dg-error "requires whitespace" } */
+#define F||		/* { dg-error "requires whitespace" } */
+#define G==		/* { dg-error "requires whitespace" } */
+#define H!=		/* { dg-error "requires whitespace" } */
+#define I>=		/* { dg-error "requires whitespace" } */
+#define J<=		/* { dg-error "requires whitespace" } */
+#define K+=		/* { dg-error "requires whitespace" } */
+#define L-=		/* { dg-error "requires whitespace" } */
+#define M*=		/* { dg-error "requires whitespace" } */
+#define N/=		/* { dg-error "requires whitespace" } */
+#define O%=		/* { dg-error "requires whitespace" } */
+#define P&=		/* { dg-error "requires whitespace" } */
+#define Q|=		/* { dg-error "requires whitespace" } */
+#define R^=		/* { dg-error "requires whitespace" } */
+#define S>>=		/* { dg-error "requires whitespace" } */
+#define T<<=		/* { dg-error "requires whitespace" } */
+#define W...		/* { dg-error "requires whitespace" } */
+#define X++		/* { dg-error "requires whitespace" } */
+#define Y--		/* { dg-error "requires whitespace" } */
+#define Z->		/* { dg-error "requires whitespace" } */
+#define aa::		/* { dg-error "requires whitespace" } */
+#define ab->*		/* { dg-error "requires whitespace" } */
+#define ac.*		/* { dg-error "requires whitespace" } */
+#define ad\x		/* { dg-error "requires whitespace" } */
+#define ae\\x		/* { dg-error "requires whitespace" } */
+#define af'1'		/* { dg-error "requires whitespace" } */
+#define ag"abc"		/* { dg-error "requires whitespace" } */
+
+int dummy;
+/* { dg-error "missing terminating" "" { target *-*-* } 6 } */
+/* { dg-error "missing terminating" "" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macsyntx.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macsyntx.c
new file mode 100644
index 000000000..495921efa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/macsyntx.c
@@ -0,0 +1,72 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-pedantic -std=gnu99" } */
+
+/* Tests macro syntax, for both definition and invocation, including:-
+
+   o Full range of macro definition semantics.
+   o No. of arguments supplied to function-like macros.
+   o Odd GNU rest args behavior.
+   o Macro arguments do not flow into the rest of the file.  */
+
+
+/* Test basic macro definition syntax.  The macros are all called
+   "foo" deliberately to provoke an (excess) redefinition warning in
+   case the macros succeed in being entered in the macro hash table
+   despite being an error.
+
+   Split a couple of the lines to check that the errors appear on the
+   right line (i.e. are associated with the correct token).  */
+
+#define ;			/* { dg-error "identifier" } */
+#define SEMI;			/* { dg-warning "space" } */
+#define foo(X			/* { dg-error "missing" } */
+#define foo\
+(X,)				/* { dg-error "parameter name" } */
+#define foo(, X)		/* { dg-error "parameter name" } */
+#define foo(X, X)		/* { dg-error "duplicate" } */
+#define foo(X Y)		/* { dg-error "comma" } */
+#define foo(()			/* { dg-error "may not appear" } */
+#define foo(..., X)		/* { dg-error "missing" } */
+#define foo \
+__VA_ARGS__			/* { dg-warning "__VA_ARGS__" } */
+#define goo(__VA_ARGS__)	/* { dg-warning "__VA_ARGS__" } */
+#define hoo(...) __VA_ARGS__	/* OK.  */
+#define __VA_ARGS__		/* { dg-warning "__VA_ARGS__" } */
+__VA_ARGS__			/* { dg-warning "__VA_ARGS__" } */
+
+/* test # of supplied arguments.  */
+#define none()
+#define one(x)
+#define two(x, y)
+#define var0(...)
+#define var1(x, ...)
+none()				/* OK.  */
+none(ichi)			/* { dg-error "passed 1" } */
+one()				/* OK.  */
+one(ichi)			/* OK.  */
+one(ichi\
+, ni)				/* { dg-error "passed 2" } */
+two(ichi)			/* { dg-error "requires 2" } */
+var0()				/* OK.  */
+var0(ichi)			/* OK.  */
+var1()				/* { dg-warning "rest arguments to be used" } */
+var1(ichi)			/* { dg-warning "rest arguments to be used" } */
+var1(ichi, ni)			/* OK.  */
+
+/* This tests two oddities of GNU rest args - omitting a comma is OK,
+   and backtracking a token on pasting an empty rest args.  */
+#define rest(x, y...) x ## y	/* { dg-warning "ISO C" } */
+rest(ichi,)			/* OK.  */
+rest(ichi)			/* { dg-warning "rest arguments to be used" } */
+#if 23 != rest(2, 3)		/* OK, no warning.  */
+#error 23 != 23 !!
+#endif
+
+/* Test that we don't allow arguments to flow into the rest of the
+   file.  */
+#define half_invocation do_nowt(2
+#define do_nowt(x) x
+half_invocation )		/* OK.  */
+do_nowt (half_invocation))	/* { dg-error "unterminated argument" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1.c
new file mode 100644
index 000000000..0cfedad2f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1.c
@@ -0,0 +1,39 @@
+/* Test "ignore redundant include" facility.
+
+   We must test with C and C++ comments, and null directives, outside
+   the guard conditional; also, we test guarding with #ifndef and #if
+   !defined.  -H is used because cpp might confuse the issue by
+   optimizing out #line markers.  This test only passes if each of the
+   headers is read exactly once.
+
+   The disgusting regexp in the dg-error line, when stuck into
+   dg.exp's compiler-output regexp, matches the correct -H output and
+   only the correct -H output.  It has to be all on one line because
+   otherwise it will not be interpreted all in one unit.  */
+
+/* { dg-do compile }
+   { dg-options "-H" }
+   { dg-message "mi1c\.h\n\[^\n\]*mi1cc\.h\n\[^\n\]*mi1nd\.h\n\[^\n\]*mi1ndp\.h\n\[^\n\]*mi1x\.h" "redundant include check" { target *-*-* } 0 } */
+
+#include "mi1c.h"
+#include "mi1c.h"
+#include "mi1c.h"
+
+#include "mi1cc.h"
+#include "mi1cc.h"
+
+#include "mi1nd.h"
+#include "mi1nd.h"
+
+#include "mi1ndp.h"
+#include "mi1ndp.h"
+
+#define MIX_H
+#include "mi1x.h"
+#include "mi1x.h"
+
+int
+main (void)
+{
+  return a + b + c + d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1c.h
new file mode 100644
index 000000000..2956286eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1c.h
@@ -0,0 +1,12 @@
+/* Redundant header include test with C comments at top.  */
+# /* And a null directive at the top.  */
+
+#ifndef CPP_MIC_H
+#define CPP_MIC_H
+
+int a;
+
+#endif
+
+# /* And at the end, too!  */
+/* And at the end too!  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1cc.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1cc.h
new file mode 100644
index 000000000..46a38cded
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1cc.h
@@ -0,0 +1,10 @@
+// Redundant header include test with C comments at top.
+
+#ifndef CPP_MICC_H
+#define CPP_MICC_H
+
+int b;
+
+#endif
+
+// And at the end too!
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1nd.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1nd.h
new file mode 100644
index 000000000..c14c1a3c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1nd.h
@@ -0,0 +1,8 @@
+/* Redundant include check with #if !defined.  */
+
+#if !defined CPP_MIND_H
+#define CPP_MIND_H
+
+int c;
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1ndp.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1ndp.h
new file mode 100644
index 000000000..b84202c6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1ndp.h
@@ -0,0 +1,7 @@
+#if !defined ( CPP_MINDP_H)
+#define CPP_MINDP_H
+
+/* Redundant include check with #if !defined and parentheses.  */
+int d;
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1x.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1x.h
new file mode 100644
index 000000000..a317cf852
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi1x.h
@@ -0,0 +1,9 @@
+/* This header is never to have its contents visible, but it should
+   still receive the optimization.  */
+
+#ifndef MIX_H
+#define MIX_H
+
+#define main wibble
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2.c
new file mode 100644
index 000000000..916d5a949
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2.c
@@ -0,0 +1,12 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h.
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+/* { dg-do compile } */
+
+#include "mi2a.h"
+#include "mi2b.h"
+
+int main (void)
+{
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2a.h
new file mode 100644
index 000000000..e3f53b6cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2a.h
@@ -0,0 +1,5 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h. 
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+
+#include "mi2c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2b.h
new file mode 100644
index 000000000..1d9a8b9b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2b.h
@@ -0,0 +1,6 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h. 
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+
+#define need_x
+#include "mi2c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2c.h
new file mode 100644
index 000000000..521792bee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi2c.h
@@ -0,0 +1,15 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h. 
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+#ifdef need_x
+#undef need_x
+#ifndef have_x
+#define have_x
+extern int x;
+#endif
+#endif
+
+#ifndef t_h
+#define t_h
+extern int y;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.c
new file mode 100644
index 000000000..f33fd7887
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.c
@@ -0,0 +1,20 @@
+/* Another test case for over-eager multiple include optimization.
+   This one distilled from glibc's setlocale.c and categories.def.  */
+/* { dg-do compile } */
+
+#define X a
+#include "mi3.def"
+#undef X
+
+#define X b
+#include "mi3.def"
+#undef X
+
+#include "mi3.h"
+#include "mi3.h"  /* The second include declares variable c.  */
+
+int
+main(void)
+{
+  return a + b + c;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.def b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.def
new file mode 100644
index 000000000..375d9c7fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.def
@@ -0,0 +1,10 @@
+/* Another test case for over-eager multiple include optimization.    
+   This one distilled from glibc's setlocale.c and categories.def.
+   The #ifdef block doesn't cover the entire file, so it must not be
+   taken for a reinclude guard.  */
+
+#ifndef NO_POSTLOAD
+#define NO_POSTLOAD NULL
+#endif
+
+int X;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.h
new file mode 100644
index 000000000..8774fcf48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi3.h
@@ -0,0 +1,7 @@
+/* Another test case for over-eager multiple include optimization. */
+
+#ifndef GUARD
+#define GUARD
+#elif 1				/* #elif kills optimisation  */
+int c;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi4.c
new file mode 100644
index 000000000..c886cc2c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi4.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Undefining a macro guard and re-including the file used to confuse
+   file caching in cppfiles.c, and attempt to open a bad fd.  */
+
+#include "mi1c.h"
+#undef CPP_MIC_H
+#include "mi1c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi5.c
new file mode 100644
index 000000000..327c47621
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi5.c
@@ -0,0 +1,13 @@
+/* Test "ignore redundant include" facility, with -C on.
+
+   The disgusting regexp in the dg-error line, when stuck into
+   dg.exp's compiler-output regexp, matches the correct -H output and
+   only the correct -H output.  It has to be all on one line because
+   otherwise it will not be interpreted all in one unit.  */
+
+/* { dg-do preprocess }
+   { dg-options "-H -C" }
+   { dg-message "mi1c\.h" "redundant include check with -C" { target *-*-* } 0 } */
+
+#include "mi1c.h"
+#include "mi1c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6.c
new file mode 100644
index 000000000..c3af2d3f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6.c
@@ -0,0 +1,61 @@
+/* Another test case for over-eager multiple include optimization,
+   where the leading "#if !defined" expression is obtained partially,
+   or wholly, from macros.  Neil Booth, 30 Sep 2001.  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern void abort (void);
+
+/* Each include file should not be subject to MI optimisation, since
+   macro definitions can change.  Each header increments the variable
+   VAR if it is defined.
+
+   The first set of inclusions gets the headers into CPP's cache, but
+   does nothing since VAR is not defined.  The second set should each
+   increment VAR, since none of the initial set should have been
+   flagged as optimizable.  */
+
+#define EMPTYL
+#define EMPTYR
+#define NOT !
+#define DEFINED defined (guard)
+#define NOT_DEFINED ! defined (guard)
+
+#include "mi6a.h"
+#include "mi6b.h"
+#include "mi6c.h"
+#include "mi6d.h"
+#include "mi6e.h"
+
+/* Define the macro guard, and redefine the macros to something that
+   forces compilation of the conditional blocks.  */
+#define guard
+#undef EMPTYL
+#define EMPTYL 1 ||
+#undef EMPTYR
+#define EMPTYR || 1
+#undef NOT
+#define NOT
+#undef DEFINED
+#define DEFINED 0
+#undef NOT_DEFINED
+#define NOT_DEFINED 1
+
+#define VAR five
+
+int
+main(void)
+{
+  unsigned int five = 0;
+
+#include "mi6a.h"
+#include "mi6b.h"
+#include "mi6c.h"
+#include "mi6d.h"
+#include "mi6e.h"
+
+  if (five != 5)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6a.h
new file mode 100644
index 000000000..68a2fce47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6a.h
@@ -0,0 +1,5 @@
+#if NOT_DEFINED
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6b.h
new file mode 100644
index 000000000..d2fe8be17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6b.h
@@ -0,0 +1,5 @@
+#if NOT defined (guard)
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6c.h
new file mode 100644
index 000000000..d19cb5433
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6c.h
@@ -0,0 +1,5 @@
+#if !DEFINED
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6d.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6d.h
new file mode 100644
index 000000000..a1eabba8e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6d.h
@@ -0,0 +1,5 @@
+#if EMPTYL !defined (guard)
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6e.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6e.h
new file mode 100644
index 000000000..26ba71514
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi6e.h
@@ -0,0 +1,5 @@
+#if !defined (guard) EMPTYR
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7.c
new file mode 100644
index 000000000..415186cba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7.c
@@ -0,0 +1,19 @@
+/* Test "ignore redundant include" facility.
+
+   -H is used because cpp might confuse the issue by optimizing out
+   #line markers.  This test only passes if the headers is read
+   twice.
+
+   The disgusting regexp in the dg-error line, when stuck into
+   dg.exp's compiler-output regexp, matches the correct -H output and
+   only the correct -H output.  It has to be all on one line because
+   otherwise it will not be interpreted all in one unit.  */
+
+/* { dg-do preprocess }
+   { dg-options "-H" }
+   { dg-message "mi7a\.h\n\[^\n\]*mi7a\.h\n\[^\n\]*mi7b\.h\n\[^\n\]*mi7b\.h" "redundant include check" { target *-*-* } 0 } */
+
+#include "mi7a.h"
+#include "mi7a.h"
+#include "mi7b.h"
+#include "mi7b.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7a.h
new file mode 100644
index 000000000..0c701d7e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7a.h
@@ -0,0 +1,4 @@
+:
+#ifndef GUARD1
+#define GUARD1
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7b.h
new file mode 100644
index 000000000..1747e5482
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi7b.h
@@ -0,0 +1,4 @@
+#ifndef GUARD2
+#define GUARD2
+#endif
+:
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8.c
new file mode 100644
index 000000000..1999918de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8.c
@@ -0,0 +1,8 @@
+/* Test multiple include guards suggestions.  */
+
+/* { dg-do preprocess }
+   { dg-options "-H" }
+   { dg-message "mi8a\.h\n\[^\n\]*mi8c\.h\n\[^\n\]*mi8b\.h\n\[^\n\]*mi8d\.h\nMultiple include guards may be useful for:\n\[^\n\]*mi8a\.h\n\[^\n\]*mi8d\.h\n" "" { target *-*-* } 0 } */
+
+#include "mi8a.h"
+#include "mi8b.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8a.h
new file mode 100644
index 000000000..893d9ff13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8a.h
@@ -0,0 +1 @@
+#include "mi8c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8b.h
new file mode 100644
index 000000000..8e3482ce7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8b.h
@@ -0,0 +1,4 @@
+#ifndef GUARDB
+#define GUARDB
+#include "mi8d.h"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8c.h
new file mode 100644
index 000000000..08c5cab94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8c.h
@@ -0,0 +1,4 @@
+#ifndef GUARDC
+#define GUARDC
+/* Empty */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8d.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8d.h
new file mode 100644
index 000000000..710cecca9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/mi8d.h
@@ -0,0 +1 @@
+/* Empty */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-header-MD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-header-MD.c
new file mode 100644
index 000000000..dd4617405
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-header-MD.c
@@ -0,0 +1,5 @@
+/* Test that missing user headers are fatal errors with -MD.  */
+/* { dg-do compile } */
+/* { dg-options "-MD" } */
+
+#include "nonexistent.h" /* { dg-error "nonexistent.h" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-header-MMD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-header-MMD.c
new file mode 100644
index 000000000..e87cc6ee2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-header-MMD.c
@@ -0,0 +1,5 @@
+/* Test that missing user headers are fatal errors with -MMD.  */
+/* { dg-do compile } */
+/* { dg-options "-MMD" } */
+
+#include "nonexistent.h" /* { dg-error "nonexistent.h" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-sysheader-MD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-sysheader-MD.c
new file mode 100644
index 000000000..ca2b98905
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-sysheader-MD.c
@@ -0,0 +1,5 @@
+/* Test that missing system headers are fatal errors with -MD.  */
+/* { dg-do compile } */
+/* { dg-options "-MD" } */
+
+#include <nonexistent.h> /* { dg-error "nonexistent.h" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-sysheader-MMD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-sysheader-MMD.c
new file mode 100644
index 000000000..67f649f6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/missing-sysheader-MMD.c
@@ -0,0 +1,5 @@
+/* Test that missing system headers are fatal errors with -MMD.  */
+/* { dg-do compile } */
+/* { dg-options "-MMD" } */
+
+#include <nonexistent.h> /* { dg-error "nonexistent.h" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/multiline-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/multiline-2.c
new file mode 100644
index 000000000..6a674b4dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/multiline-2.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2000, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+/* Test that multi-line tokens are rejected by the compiler.  Source:
+   Neil Booth.  */
+
+const char *p = "line 1
+"
+"";			      /* The compiler front end sees this.  */
+
+/* { dg-error "missing term" "multiline strings" { target *-*-* } 8 } */
+/* { dg-error "missing term" "multiline strings" { target *-*-* } 9 } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/multiline.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/multiline.c
new file mode 100644
index 000000000..38798bdfa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/multiline.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 2000, 2003 Free Software Foundation, Inc.  */
+/* { dg-do preprocess } */
+/* { dg-options "-C" } */
+/* Test that multi-line tokens are recognized by cpp0 as being
+   multiline .  Source: Neil Booth, 17 Dec 2000.  */
+/* Line 1
+   Line 2
+   Line 3
+   Line 4
+*/
+"line 1
+ line 2
+ line 3
+ line 4"
+L"line 1
+  line 2
+  line 3
+  line 4"
+/* Nowhere in the output of this file should there be a blank line.
+   We check for that in the .i file.
+   { dg-final { scan-file-not multiline.i "(^|\\n)\\n" } } */
+/* { dg-warning "missing term" "multiline strings" { target *-*-* } 11 } */
+/* { dg-warning "missing term" "multiline strings" { target *-*-* } 14 } */
+/* { dg-warning "missing term" "multiline strings" { target *-*-* } 15 } */
+/* { dg-warning "missing term" "multiline strings" { target *-*-* } 18 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-1.c
new file mode 100644
index 000000000..b20f235ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-1.c
@@ -0,0 +1,34 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+
+\u00AA
+\u00B7
+\u0F43  /* { dg-warning "not in NFC" } */
+a\u05B8\u05B9\u05B9\u05BBb
+ a\u05BB\u05B9\u05B8\u05B9b  /* { dg-warning "not in NFC" } */
+\u09CB
+\u09C7\u09BE /* { dg-warning "not in NFC" } */
+\u0B4B
+\u0B47\u0B3E /* { dg-warning "not in NFC" } */
+\u0BCA
+\u0BC6\u0BBE /* { dg-warning "not in NFC" } */
+\u0BCB
+\u0BC7\u0BBE /* { dg-warning "not in NFC" } */
+\u0CCA
+\u0CC6\u0CC2 /* { dg-warning "not in NFC" } */
+\u0D4A
+\u0D46\u0D3E /* { dg-warning "not in NFC" } */
+\u0D4B
+\u0D47\u0D3E /* { dg-warning "not in NFC" } */
+
+K
+\u212A /* { dg-warning "not in NFC" } */
+
+\u03AC
+\u1F71 /* { dg-warning "not in NFC" } */
+
+\uAC00
+\u1100\u1161 /* { dg-warning "not in NFC" } */
+\uAC01
+\u1100\u1161\u11A8 /* { dg-warning "not in NFC" } */
+\uAC00\u11A8 /* { dg-warning "not in NFC" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-2.c
new file mode 100644
index 000000000..6f2f49564
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-2.c
@@ -0,0 +1,34 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -fextended-identifiers -Wnormalized=nfkc" } */
+
+\u00AA  /* { dg-warning "not in NFKC" } */
+\u00B7
+\u0F43  /* { dg-warning "not in NFC" } */
+a\u05B8\u05B9\u05B9\u05BBb
+ a\u05BB\u05B9\u05B8\u05B9b  /* { dg-warning "not in NFC" } */
+\u09CB
+\u09C7\u09BE /* { dg-warning "not in NFC" } */
+\u0B4B
+\u0B47\u0B3E /* { dg-warning "not in NFC" } */
+\u0BCA
+\u0BC6\u0BBE /* { dg-warning "not in NFC" } */
+\u0BCB
+\u0BC7\u0BBE /* { dg-warning "not in NFC" } */
+\u0CCA
+\u0CC6\u0CC2 /* { dg-warning "not in NFC" } */
+\u0D4A
+\u0D46\u0D3E /* { dg-warning "not in NFC" } */
+\u0D4B
+\u0D47\u0D3E /* { dg-warning "not in NFC" } */
+
+K
+\u212A /* { dg-warning "not in NFC" } */
+
+\u03AC
+\u1F71 /* { dg-warning "not in NFC" } */
+
+\uAC00
+\u1100\u1161 /* { dg-warning "not in NFC" } */
+\uAC01
+\u1100\u1161\u11A8 /* { dg-warning "not in NFC" } */
+\uAC00\u11A8 /* { dg-warning "not in NFC" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-3.c
new file mode 100644
index 000000000..a4f496fbb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-3.c
@@ -0,0 +1,34 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -fextended-identifiers -Wnormalized=id" } */
+
+\u00AA
+\u00B7
+\u0F43  /* { dg-warning "not in NFC" } */
+a\u05B8\u05B9\u05B9\u05BBb
+ a\u05BB\u05B9\u05B8\u05B9b  /* { dg-warning "not in NFC" } */
+\u09CB
+\u09C7\u09BE /* { dg-warning "not in NFC" } */
+\u0B4B
+\u0B47\u0B3E /* { dg-warning "not in NFC" } */
+\u0BCA
+\u0BC6\u0BBE /* { dg-warning "not in NFC" } */
+\u0BCB
+\u0BC7\u0BBE /* { dg-warning "not in NFC" } */
+\u0CCA
+\u0CC6\u0CC2 /* { dg-warning "not in NFC" } */
+\u0D4A
+\u0D46\u0D3E /* { dg-warning "not in NFC" } */
+\u0D4B
+\u0D47\u0D3E /* { dg-warning "not in NFC" } */
+
+K
+\u212A
+
+\u03AC
+\u1F71 /* { dg-warning "not in NFC" } */
+
+\uAC00
+\u1100\u1161
+\uAC01
+\u1100\u1161\u11A8
+\uAC00\u11A8
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-4.c
new file mode 100644
index 000000000..0040c03aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/normalize-4.c
@@ -0,0 +1,34 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -fextended-identifiers -Wnormalized=none" } */
+
+\u00AA
+\u00B7
+\u0F43
+a\u05B8\u05B9\u05B9\u05BBb
+ a\u05BB\u05B9\u05B8\u05B9b
+\u09CB
+\u09C7\u09BE
+\u0B4B
+\u0B47\u0B3E
+\u0BCA
+\u0BC6\u0BBE
+\u0BCB
+\u0BC7\u0BBE
+\u0CCA
+\u0CC6\u0CC2
+\u0D4A
+\u0D46\u0D3E
+\u0D4B
+\u0D47\u0D3E
+
+K
+\u212A
+
+\u03AC
+\u1F71
+
+\uAC00
+\u1100\u1161
+\uAC01
+\u1100\u1161\u11A8
+\uAC00\u11A8
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste1.c
new file mode 100644
index 000000000..7b07f740c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste1.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test operator ## semantics.  */
+
+#define bad1 ## owt	/* { dg-error "cannot" "## at objlike start" } */
+#define bad2 owt ##	/* { dg-error "cannot" "## at objlike end" } */
+#define bad3(x) ## x	/* { dg-error "cannot" "## at funlike start" } */
+#define bad4(x) x ##	/* { dg-error "cannot" "## at funlike end" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste10.c
new file mode 100644
index 000000000..ab3cb9050
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste10.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "" } */
+
+/* This testcase used to produce a bogus "invalid paste" warning, owing
+   to not clearing a PASTE_LEFT flag.  */
+
+#define strcpy(src) __strcpy_small (src)
+
+#define __strcpy_small(src) src
+
+#define tprintf(format, args...) sprintf(format, ## args)
+
+strcpy(tprintf("<%s>", test))
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste11.c
new file mode 100644
index 000000000..e3860ebb7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste11.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test correct pasting of identifiers and numbers.  We can paste any
+   number, as long as no '.', '-' or '+' appears in its spelling.  */
+
+#define glue(x, y) x ## y
+
+glue (ident, 12)		/* OK.  */
+glue (ident, 12e3)		/* OK.  */
+glue (ident, 12e+3)		/* { dg-error "valid preprocessing tok" } */
+glue (ident, 12e-3)		/* { dg-error "valid preprocessing tok" } */
+glue (ident, 1.2)		/* { dg-error "valid preprocessing tok" } */
+glue (ident, .12)		/* { dg-error "valid preprocessing tok" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste12.c
new file mode 100644
index 000000000..e61ec5143
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste12.c
@@ -0,0 +1,8 @@
+/* { dg-do preprocess } */
+
+/* Test correct diagnostics when pasting in #include.
+   Source: PR preprocessor/6780.  */
+
+#define inc2(a,b) <##a.b>
+#define INC(X) inc2(X,h)
+#include INC(stdio) /* { dg-error "pasting \"<\" and \"stdio\" does not" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste13.c
new file mode 100644
index 000000000..62c72d449
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste13.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* This used to be recognized as a comment when lexing after pasting
+   spellings.  Neil Booth, 9 Oct 2002.  */
+
+#define a /##/=
+a			/* { dg-error "valid preprocessing tok" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste14.c
new file mode 100644
index 000000000..ec243c232
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste14.c
@@ -0,0 +1,7 @@
+/* PR preprocessor/28709 */
+/* { dg-do preprocess } */
+
+#define foo - ## >>
+foo		/* { dg-error "pasting \"-\" and \">>\"" } */
+#define bar = ## ==
+bar		/* { dg-error "pasting \"=\" and \"==\"" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste15.c
new file mode 100644
index 000000000..9d4ec3631
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste15.c
@@ -0,0 +1,15 @@
+/* PR preprocessor/20077 */
+/* { dg-do preprocess } */
+
+#define a   a ## ## /* { dg-error "end of a macro expansion" } */
+#define b() b ## ## /* { dg-error "end of a macro expansion" } */
+#define c   c ##    /* { dg-error "end of a macro expansion" } */
+#define d() d ##    /* { dg-error "end of a macro expansion" } */
+
+
+#define e   ## ## e /* { dg-error "end of a macro expansion" } */
+#define f() ## ## f /* { dg-error "end of a macro expansion" } */
+#define g   ## g    /* { dg-error "end of a macro expansion" } */
+#define h() ## h    /* { dg-error "end of a macro expansion" } */
+#define i   ##      /* { dg-error "end of a macro expansion" } */
+#define j() ##      /* { dg-error "end of a macro expansion" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste2.c
new file mode 100644
index 000000000..788e4eb51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste2.c
@@ -0,0 +1,118 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+/* Test ## behavior and corner cases thoroughly.  The macro expander
+   failed many of these during development.  */
+
+#ifndef __WCHAR_TYPE__
+#define __WCHAR_TYPE__ int
+#endif
+typedef __WCHAR_TYPE__ wchar_t;
+
+extern int strcmp (const char *, const char *);
+extern int puts (const char *);
+extern void abort (void);
+#define err(str) do { puts(str); abort(); } while (0)
+
+#define EMPTY
+#define str(x) #x
+#define xstr(x) str(x)
+#define glue(x, y) x ## y
+#define xglue(x, y) glue (x, y)
+#define glue3(x, y, z) x ## y ## z
+#define glue_var(x, ...) x ## __VA_ARGS__
+
+#define __muldi3 __NDW(mul, 3 = 50)
+#define __NDW(a,b) __ ## a ## di ## b
+#define m3 NDW()
+#define NDW(x) m3 ## x = 50
+#define five 5
+#define fifty int fif ## ty
+
+/* Defines a function called glue, returning what it is passed.  */
+int glue (glue,) (int x)
+{
+  return x;
+}
+
+int main ()
+{
+  /* m3 and __muldi3 would sometimes cause an infinite loop.  Ensure
+     we only expand fifty once.  */
+  fifty = 50, m3, __muldi3;
+
+  /* General glue and macro expanding test.  */
+  int five0 = xglue (glue (fi, ve), 0);
+
+  /* Tests only first and last tokens are pasted, and pasting to form
+     the != operator.  Should expand to: if (five0 != 50).  */
+  if (glue3 (fi, ve0 !,= glue (EMPTY 5, 0)))
+    err ("five0 != 50");
+
+  /* Test varags pasting, and pasting to form the >> operator.  */
+  if (glue_var(50 >, > 1 != 25))
+    err ("Operator >> pasting");
+
+  /* The LHS should not attempt to expand twice, and thus becomes a
+     call to the function glue.  */
+  if (glue (gl, ue) (12) != 12)
+    err ("Recursive macros");
+
+  /* Test placemarker pasting.  The glued lines should all appear
+     neatly in the same column and below each other, though we don't
+     test that here.  */
+  {
+    int glue3(a, b, ) = 1, glue3(a,,) = 1;
+    glue3(a, , b)++;
+    glue3(, a, b)++;
+    glue3(,a,)++;
+    glue3(,,a)++;
+    if (a != 3 || ab != 3 glue3(,,))
+      err ("Placemarker pasting");
+  }
+
+  /* Test that macros in arguments are not expanded.  */
+  {
+    int glue (EMPTY,1) = 123, glue (T, EMPTY) = 123;
+    if (EMPTY1 != 123 || TEMPTY != 123)
+      err ("Pasted arguments macro expanding");
+  }
+
+  /* Test various paste combinations.  */
+  {
+    const wchar_t* wc_array = glue(L, "wide string");
+    wchar_t wc = glue(L, 'w');
+    const char * hh = xstr(xglue(glue(%, :), glue(%, :)));
+    int array glue (<, :) 1 glue (:, >) = glue(<, %) 1 glue(%, >);
+    int x = 4;
+
+    if (array[0] != 1)
+      err ("Digraph pasting");
+
+    x glue (>>, =) 1;		/* 2 */
+    x glue (<<, =) 1;		/* 4 */
+    x glue (*, =) 2;		/* 8 */
+    x glue (+, =) 100;		/* 108 */
+    x glue (-, =) 50;		/* 58 */
+    x glue (/, =) 2;		/* 29 */
+    x glue (%, =) 20;		/* 9 */
+    x glue (&, =) 254;		/* 8 */
+    x glue (|, =) 16;		/* 24 */
+    x glue (^, =) 18;		/* 10 */
+    
+    if (x != 10 || 0 glue (>, =) 1 glue (|, |) 1 glue (<, =) 0)
+      err ("Various operator pasting");
+    if (strcmp (hh, "%:%:"))
+      err ("Pasted digraph spelling");
+    if ((glue (., 1) glue (!, =) .1))
+      err ("Pasted numbers 1");
+    /* glue3 here will only work if we paste left-to-right.  If a
+       future implementation does not do this, change the test.  */
+    if (glue3 (1.0e, +, 1) != 10.0)
+      err ("Pasted numbers 2");
+  }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste3.c
new file mode 100644
index 000000000..0c9c52de3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste3.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+#define plus +
+
+void foo()
+{
+  int a, b = 1;
+
+  /* The correct "a = 1 + ++b" will compile.
+     The incorrect "a = 1 +++b" won't.  */
+  a = 1 plus++b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste4.c
new file mode 100644
index 000000000..dfc455ded
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste4.c
@@ -0,0 +1,18 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+/* { dg-do compile } */
+/* { dg-options -save-temps } */
+
+/* Since 1.0e and + form the pasted token, 1 is a separate token and
+   so should be output with a preceding space.  The old preprocessor
+   gets this wrong.  We use -save-temps to avoid direct use of the
+   integrated preprocessor.  */
+
+#define glue(x, y) x ## y
+
+int main ()
+{
+  double d = glue (1.0e, +1); /* { dg-error "exponent|parse error|syntax error|expected" } */
+  return 0;
+}
+
+/* { dg-final { cleanup-saved-temps } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste5.c
new file mode 100644
index 000000000..fd0406674
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste5.c
@@ -0,0 +1,24 @@
+/* Regression test for bug in convoluted situation involving token paste
+   plus function-like macros used outside function context.  It may be
+   easier to understand if you mentally replace 'struct' with 'A'
+   throughout this file; 'struct' is used only to get the code to compile
+   when preprocessed correctly.
+
+   The original problem was seen in the Linux kernel and reported by
+   Jakub Jelinek <jakub@redhat.com>; this test is synthetic.  */
+
+/* { dg-do compile } */
+
+#define glue(a,b) a##b
+#define struct(x) B(x)
+#define E(x) struct x
+#define FG (22)
+
+extern void B(int);
+
+void foo(void)
+{
+  E(glue(F,*)) dummy;  /* { dg-error "valid preprocessing token" } */
+
+  E(glue(F,G)) ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste6.c
new file mode 100644
index 000000000..ac9ae3901
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste6.c
@@ -0,0 +1,12 @@
+/* Regression test for paste appearing at the beginning of a set of
+   actual arguments.  Original bug exposed by Linux kernel.  Problem
+   reported by Jakub Jelinek <jakub@redhat.com>.  */
+
+/* { dg-do compile } */
+
+extern int foo(int x);
+
+#define bar(x) foo(x)
+#define baz(x) bar(##x)
+
+int quux(int y) { return baz(y); }  /* { dg-error "valid preprocessing" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste7.c
new file mode 100644
index 000000000..ce29db847
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste7.c
@@ -0,0 +1,19 @@
+/* { dg-do run } */
+
+#define D_2 1, 2
+#define C_2(X, I0, I1) X##_a = I0, X##_b = I1
+#define B_2(X, I) C_2(X, I)
+#define A(N, X) B_##N (X, D_##N)
+
+extern void abort(void);
+extern void exit(int);
+
+int x_a, x_b;
+
+int main(void)
+{
+  A(2, x);
+  if (x_a != 1 || x_b != 2)
+    abort();
+  exit(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste8.c
new file mode 100644
index 000000000..ab0177978
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste8.c
@@ -0,0 +1,15 @@
+/* { dg-do preprocess } */
+/* { dg-options "" } */
+
+int foo(int, ...);
+
+#define a(x, y...) foo(x, ##y)
+a(1)
+a(1, 2, 3)
+#define b(x, y, z...) foo(x, ##y)
+b(1, 2, 3)			/* { dg-error "valid preprocessing token" } */
+#define c(x, y, z...) foo(x, ##z)
+c(1, 2)
+c(1, 2, 3)
+#define d(x) fo(##x)
+d(1)				/* { dg-error "valid preprocessing token" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste9.c
new file mode 100644
index 000000000..35c86b4e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/paste9.c
@@ -0,0 +1,23 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "" } */
+
+/* Apparently older preprocessors used to fail this test.  */
+
+#include <string.h>
+
+extern void abort (void);
+
+#define S(str, args...) "  " str "\n", ##args
+
+int
+main()
+{
+  const char *s = S("foo");
+
+  if (strchr (s, '\n') == NULL)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/poison.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/poison.c
new file mode 100644
index 000000000..d667183de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/poison.c
@@ -0,0 +1,25 @@
+/* { dg-do preprocess }
+   { dg-options "-fno-show-column" } */
+
+#pragma GCC poison foo
+foo			/* { dg-error "foo" "use of foo" } */
+#pragma GCC poison foo2 foo3
+foo2			/* { dg-error "foo2" "use of foo2" } */
+foo3			/* { dg-error "foo3" "use of foo3" } */
+#pragma GCC poison	foo4 	foo5
+foo4			/* { dg-error "foo4" "use of foo4" } */
+foo5			/* { dg-error "foo5" "use of foo5" } */
+#pragma GCC poison +++	/* { dg-error "invalid" "poison non-identifier" } */
+#define foo6 123
+#pragma GCC poison foo6	/* { dg-warning "foo6" "poison defined macro" } */
+#define foo6 345	/* { dg-error "foo6" "def of foo6" } */
+#define foo6 456	/* { dg-error "foo6" "redef of foo6" } */
+#ifdef foo6		/* { dg-error "foo6" "#ifdef foo6" } */
+#error hey! foo6 defined!
+#endif
+#if defined(foo6)	/* { dg-error "foo6" "#if defined foo6" } */
+#error foo6 still defined!
+#else
+foo6			/* { dg-error "foo6" "use of foo6" } */
+#endif
+#pragma GCC poison
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20348.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20348.c
new file mode 100644
index 000000000..f75f14290
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20348.c
@@ -0,0 +1,16 @@
+/* PR preprocessor/20348 */
+/* { dg-do compile } */
+/* { dg-options "-I$srcdir/gcc.dg/cpp -I$srcdir/gcc.dg/cpp/inc" } */
+
+#include <pr20348-aux.h>
+#define MIDDLE
+#include <pr20348.h>
+
+#ifndef PR20348_H_SEEN
+# error pr20348.h not included after MIDDLE definition
+#endif
+#ifndef INC_PR20348_H_SEEN
+# error inc/pr20348.h not included before MIDDLE definition
+#endif
+
+int i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20348.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20348.h
new file mode 100644
index 000000000..97ef80edb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20348.h
@@ -0,0 +1,9 @@
+#ifdef MIDDLE
+# ifndef PR20348_H_SEEN
+#  define PR20348_H_SEEN
+# else
+#  error pr20348.h included twice after MIDDLE definition
+# endif
+#else
+# error pr20348.h included before MIDDLE definition
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20356.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20356.c
new file mode 100644
index 000000000..469ab0c0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20356.c
@@ -0,0 +1,14 @@
+/* PR preprocessor/20356 */
+/* { dg-do compile } */
+/* { dg-options "-I$srcdir/gcc.dg/cpp -I$srcdir/gcc.dg/cpp/inc" } */
+
+#include <pr20356-aux.h>
+
+#ifndef PR20356_H
+# error PR20356_H not defined
+#endif
+#ifndef INC_PR20356_H
+# error INC_PR20356_H not defined
+#endif
+
+int i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20356.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20356.h
new file mode 100644
index 000000000..a3f289145
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr20356.h
@@ -0,0 +1,5 @@
+#ifndef PR20356_H
+# define PR20356_H
+#else
+# include_next <pr20356.h>
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr22168-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr22168-2.c
new file mode 100644
index 000000000..c1e308dfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr22168-2.c
@@ -0,0 +1,12 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.  */
+/* PR preprocessor/22168 */
+
+/* { dg-do preprocess }
+   { dg-options -Wdeprecated } */
+#if #foo(bar)    /* { dg-warning "deprecated" } */
+int x;
+#else
+int y;
+#endif
+#assert zzz(a)   /* { dg-warning "deprecated" } */
+#unassert yyy    /* { dg-warning "deprecated" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr22168.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr22168.c
new file mode 100644
index 000000000..fecb972f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr22168.c
@@ -0,0 +1,12 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.  */
+/* PR preprocessor/22168 */
+
+/* { dg-do preprocess }
+   { dg-options -pedantic } */
+#if #foo(bar)    /* { dg-warning "GCC extension" } */
+int x;
+#else
+int y;
+#endif
+#assert zzz(a)   /* { dg-warning "GCC extension" } */
+#unassert yyy    /* { dg-warning "GCC extension" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr27777.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr27777.c
new file mode 100644
index 000000000..89258b95e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr27777.c
@@ -0,0 +1,8 @@
+/* PR preprocessor/27777 */
+/* { dg-do preprocess } */
+/* { dg-options { -trigraphs -Wall } } */
+
+#error "BUG??!"
+
+/* { dg-error "BUG" "" { target *-*-* } 5 } */
+/* { dg-warning "trigraph" "" { target *-*-* } 5 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28165.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28165.c
new file mode 100644
index 000000000..71c7c1dba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28165.c
@@ -0,0 +1,6 @@
+/* Copyright (C) 2007 Free Software Foundation, Inc.  */
+/* PR preprocessor/28165 */
+
+/* { dg-do preprocess } */
+#pragma GCC system_header   /* { dg-warning "system_header" "ignored" } */
+_Pragma ("GCC system_header")   /* { dg-warning "system_header" "ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28227.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28227.c
new file mode 100644
index 000000000..3b70dd539
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28227.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2007 Free Software Foundation, Inc.  */
+/* PR preprocessor/28227 */
+
+/* { dg-do preprocess } */
+#ifdef defined
+#endif
+#ifndef defined
+#endif
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28709.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28709.c
new file mode 100644
index 000000000..11cccbe8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr28709.c
@@ -0,0 +1,8 @@
+/* Copyright (C) 2006 Free Software Foundation, Inc.  */
+/* PR preprocessor/28709 */
+
+/* { dg-do compile } */
+#define foo - ## >>
+foo;
+/* { dg-error "expected identifier.*'-'" "" { target *-*-* } 6 } */
+/* { dg-error pasting "" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr29612-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr29612-1.c
new file mode 100644
index 000000000..f840c3823
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr29612-1.c
@@ -0,0 +1,15 @@
+/* PR preprocessor/29612 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+# 6 "pr29612-1.c"
+
+int foo (void) { return 'ab'; } /* { dg-warning "multi-character" } */
+
+# 1 "foo.h" 1 3
+
+int bar (void) { return 'ab'; } /* No warning in system header.  */
+
+# 14 "pr29612-1.c" 2
+
+int baz (void) { return 'ab'; } /* { dg-warning "multi-character" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr29612-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr29612-2.c
new file mode 100644
index 000000000..813eb77af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr29612-2.c
@@ -0,0 +1,18 @@
+/* PR preprocessor/29612 */
+/* { dg-do preprocess } */
+/* { dg-options "-Wtraditional -fno-show-column" } */
+
+# 6 "pr29612-2.c"
+
+#if 1U /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+#endif
+
+# 1 "foo.h" 1 3
+
+#if 1U
+#endif /* No warning in system header.  */
+
+# 16 "pr29612-2.c" 2
+
+#if 1U /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr30786.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr30786.c
new file mode 100644
index 000000000..f39f83cc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr30786.c
@@ -0,0 +1,9 @@
+/* PR preprocessor/30786 - _Pragma at end of file should not ICE */
+/* { dg-do compile } */
+
+/* { dg-error "parenthesized" "" { target *-*-* } 9 } */
+/* { dg-error "expected" "" { target *-*-* } 9 } */
+
+int x;
+
+_Pragma
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr30805.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr30805.c
new file mode 100644
index 000000000..bdfce45e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr30805.c
@@ -0,0 +1,6 @@
+/* PR preprocessor/30805 - ICE while token pasting.  */
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu89" } */
+
+#define A(x,...) x##,##__VA_ARGS__
+A(1)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr32868.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr32868.c
new file mode 100644
index 000000000..ea896214c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr32868.c
@@ -0,0 +1,6 @@
+/* PR preprocessor/32868.  It is ok to redefine __STDC_FORMAT_MACROS.  */
+
+/* { dg-do preprocess } */
+
+#define __STDC_FORMAT_MACROS 1
+#define __STDC_FORMAT_MACROS 1
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr32974.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr32974.c
new file mode 100644
index 000000000..cec6a9e0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr32974.c
@@ -0,0 +1,6 @@
+/* PR preprocessor/32974 - don't warn for extra tokens in pragma dependency */
+/* { dg-do compile } */
+
+#pragma GCC dependency "pr32974.c" extra tokens are ok
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr33415.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr33415.c
new file mode 100644
index 000000000..28ffe2372
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr33415.c
@@ -0,0 +1,6 @@
+ /* Test case for PR 33415.  Note that the first bytes of this file
+     are a UTF-8 BOM.  */
+
+/* { dg-do compile } */
+
+int f(void) { return 5; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34602.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34602.c
new file mode 100644
index 000000000..343c0917a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34602.c
@@ -0,0 +1,6 @@
+/* PR preprocessor/34602 - no internal error trying to spell EOF.  */
+/* { dg-do preprocess } */
+
+/* { dg-error "unexpected end" "" { target *-*-* } 6 } */
+
+#line
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34692.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34692.c
new file mode 100644
index 000000000..bcb0ca33d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34692.c
@@ -0,0 +1,35 @@
+/* PR preprocessor/34692 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "vara" } } */
+/* { dg-final { scan-hidden "varb" } } */
+/* { dg-final { scan-hidden "varc" } } */
+/* { dg-final { scan-hidden "vard" } } */
+/* { dg-final { scan-assembler "a b cde f g h" } } */
+
+#define FOO(y, x) y #x
+#define BAR(x) x
+#define BAZ(x) x
+FOO (const char *vara =,
+a
+#pragma GCC visibility push(hidden)
+b
+#pragma GCC visibility push(hidden)
+cde f g h);
+int varb = 6;
+#pragma GCC visibility pop
+#pragma GCC visibility pop
+FOO (
+BAR (
+#pragma GCC visibility push(hidden)
+const) char *varc =,);
+#pragma GCC visibility pop
+FOO (
+BAR (
+BAZ (
+#pragma GCC visibility push(hidden)
+#pragma GCC visibility push(hidden)
+const) char) *vard =,);
+#pragma GCC visibility pop
+#pragma GCC visibility pop
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34859.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34859.c
new file mode 100644
index 000000000..0fb90994e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr34859.c
@@ -0,0 +1,10 @@
+/* PR c++/34859.
+   It is ok to redefine __STDC_CONSTANT_MACROS and __STDC_LIMIT_MACROS.  */
+
+/* { dg-do preprocess } */
+
+#define __STDC_CONSTANT_MACROS 1
+#define __STDC_CONSTANT_MACROS 1
+
+#define __STDC_LIMIT_MACROS 1
+#define __STDC_LIMIT_MACROS 1
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr35313.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr35313.c
new file mode 100644
index 000000000..e12636e0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr35313.c
@@ -0,0 +1,11 @@
+/* Test two failing cases for libcpp parser.  From PRs 35313, 36088*/
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+extern int x;
+
+#if 0 ? 3,4 : 2
+#endif
+
+#if 1 ? 0 : 1 ? 1/0 : 1/0
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr35322.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr35322.c
new file mode 100644
index 000000000..1af9605ea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr35322.c
@@ -0,0 +1,4 @@
+/* Test case for PR 35322 -- _Pragma ICE.  */
+
+/* { dg-do preprocess } */
+_Pragma("GCC dependency") /* { dg-error "#pragma dependency expects" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr36320.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr36320.c
new file mode 100644
index 000000000..d136a69b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr36320.c
@@ -0,0 +1,8 @@
+/* PR 36320 - #elif still requires valid expression.  */
+
+/* { dg-do preprocess } */
+
+int z;
+#if 1
+#elif   /* { dg-error "with no expression" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-2.c
new file mode 100644
index 000000000..5ed10d020
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-2.c
@@ -0,0 +1,28 @@
+/* PR 7263:  __extension__ keyword doesn't suppress warning on LL or ULL constants.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic-errors" } */
+#include "pr7263-2.h"
+unsigned long long /* { dg-error "ISO C90 does not support .long long." } */
+bar ()
+{
+  return BIG_EXT;
+}
+
+unsigned long long /* { dg-error "ISO C90 does not support .long long." } */
+bar2 ()
+{
+  return 0x1b27da572ef3cd86ULL; /* { dg-error "use of C99 long long integer constant" } */
+}
+
+
+unsigned long long /* { dg-error "ISO C90 does not support .long long." } */
+bar3 ()
+{
+  return __extension__ (0x1b27da572ef3cd86ULL);
+}
+
+__extension__ unsigned long long 
+bar4 ()
+{
+  return BIG; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-2.h
new file mode 100644
index 000000000..54f1757c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-2.h
@@ -0,0 +1,4 @@
+#define BIG_EXT  __extension__(0x1b27da572ef3cd86ULL)
+
+#define BIG  0x1b27da572ef3cd86ULL
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-3.c
new file mode 100644
index 000000000..efa619ad3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-3.c
@@ -0,0 +1,19 @@
+/* PR 7263:  __extension__ keyword doesn't suppress warning on LL or ULL constants.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+#include "pr7263-3.h"
+__complex__  bar () /* { dg-error "ISO C does not support plain .complex. meaning .double complex." } */
+{
+  return _Complex_I_ext;
+}
+
+__extension__ __complex__ 
+bar2 ()
+{
+  return _Complex_I;
+}
+
+__complex__ bar3 () /* { dg-error "ISO C does not support plain .complex. meaning .double complex." } */
+{
+  return _Complex_I; /* { dg-error "imaginary constants are a GCC extension" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-3.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-3.h
new file mode 100644
index 000000000..ad6690e2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pr7263-3.h
@@ -0,0 +1,3 @@
+#define _Complex_I_ext      (__extension__ 1.0iF)
+
+#define _Complex_I      (1.0iF)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-1.c
new file mode 100644
index 000000000..4b9295f78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-1.c
@@ -0,0 +1,13 @@
+/* Verify that preprocessor does not insert redundant newlines
+   after #pragma */
+/* { dg-do compile } */
+int
+main ()
+{
+#pragma unknown
+  {
+    error;
+  /* { dg-error "undeclared" "undeclared-variable message" { target *-*-* } { 9 } } */
+  /* { dg-error "function it appears in" "reminder message" { target *-*-* } { 9 } } */ 
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-2.c
new file mode 100644
index 000000000..18d540fe9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-2.c
@@ -0,0 +1,16 @@
+/* Verify that preprocessor does not insert redundant newlines
+   after #pragma, also check this for #include, #define and #undef */
+/* { dg-do compile } */
+/* { dg-options "-dD" } */
+#include <stdio.h>
+
+#undef unknow_def
+
+int main () {
+
+#pragma unknown
+  {}
+  error;
+  /* { dg-error "undeclared" "undeclared-variable message" { target *-*-* } { 13 } } */
+  /* { dg-error "function it appears in" "reminder message" { target *-*-* } { 13 } } */ 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1.c
new file mode 100644
index 000000000..23e24b8c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1.c
@@ -0,0 +1,8 @@
+/* PR preprocessor/15167 */
+/* Origin: Roland Meub <Roland.Meub@Tenovis.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-I." } */
+
+#include "inc/pragma-once-1a.h"
+#include "pragma-once-1d.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1b.h
new file mode 100644
index 000000000..9c17db4dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1b.h
@@ -0,0 +1,8 @@
+#ifndef _B_H_
+#define _B_H_
+
+#pragma once
+
+#include "pragma-once-1c.h"
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1c.h
new file mode 100644
index 000000000..cd50024f6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1c.h
@@ -0,0 +1,6 @@
+#ifndef _C_H_
+#define _C_H_
+
+#include "pragma-once-1b.h"
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1d.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1d.h
new file mode 100644
index 000000000..0c5db2dc7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-once-1d.h
@@ -0,0 +1,6 @@
+#ifndef _D_H_
+#define _D_H_
+
+#include "pragma-once-1b.h"
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-pop_macro-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-pop_macro-1.c
new file mode 100644
index 000000000..c9a904864
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/pragma-pop_macro-1.c
@@ -0,0 +1,12 @@
+/* PR preprocessor/35061 */
+/* Do nothing if there is nothing on the macro stack to pop.  */
+
+/* { dg-do preprocess } */
+
+#define X  1
+/* # pragma push_macro("X") */
+# undef X
+# pragma pop_macro("X")
+#ifdef X
+#error X is defined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef1.c
new file mode 100644
index 000000000..a5fe2bacc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef1.c
@@ -0,0 +1,19 @@
+/* Test for redefining macros with insignificant (i.e. whitespace)
+   differences.  */
+
+/* { dg-do preprocess } */
+
+#define foo bar
+#define /* x */ foo /* x */ bar /* x */
+
+#define quux(thud) a one and a thud and a two
+#define /**/ quux( thud ) /**/ a one and a /**/ thud /**/ and /**/ a two
+#define quux(thud) a one	and a thud and a 	two /* bah */
+
+/* { dg-bogus "redefined" "foo redefined"	{ target *-*-* } 7 } */
+/* { dg-bogus "redefined" "quux redefined"	{ target *-*-* } 10 } */
+/* { dg-bogus "redefined" "quux redefined"	{ target *-*-* } 11 } */
+
+/* { dg-bogus "previous def" "foo prev def"	{ target *-*-* } 6 } */
+/* { dg-bogus "previous def" "quux prev def"	{ target *-*-* } 9 } */
+/* { dg-bogus "previous def" "quux prev def"	{ target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef2.c
new file mode 100644
index 000000000..b0068d916
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef2.c
@@ -0,0 +1,31 @@
+/* Test for redefining macros with significant differences.  */
+
+/* { dg-do preprocess }
+   { dg-options "-ansi -Wall -fno-show-column" } */
+
+#define mac(a, b) (a) + (b)
+#define mac(a, b) (a) * (b)
+#define mac(a, b) (a) * (x)
+#define mac(a, g) (a) * (x)
+
+#define ro(x) foo x bar
+#define ro(x, b) foo x bar
+
+#define va(a...) a
+#define va(...) __VA_ARGS__
+
+#define foo(x) x
+#define foo(x)x		/* { dg-bogus "redefined" "redefined foo" } */
+
+/* { dg-warning "redefined" "redef mac"     { target *-*-* } 7  }
+   { dg-warning "redefined" "redef mac"     { target *-*-* } 8  }
+   { dg-warning "redefined" "redef mac"     { target *-*-* } 9  }
+   { dg-warning "redefined" "redef ro"      { target *-*-* } 12 }
+   { dg-warning "redefined" "redef va"      { target *-*-* } 15 }
+
+   { dg-warning "previous"  "prev def mac"  { target *-*-* } 6  }
+   { dg-warning "previous"  "prev def mac"  { target *-*-* } 7  }
+   { dg-warning "previous"  "prev def mac"  { target *-*-* } 8  }
+   { dg-warning "previous"  "prev def ro"   { target *-*-* } 11 }
+   { dg-warning "previous"  "prev def va"   { target *-*-* } 14 }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef3.c
new file mode 100644
index 000000000..78ee71e65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/redef3.c
@@ -0,0 +1,21 @@
+/* Test for redefining macros with mismatch token count (and the oddity). */
+
+/* { dg-do preprocess } */
+/* { dg-options "-DC -DD=1 -DE" } */
+
+#define A
+#define A 1
+#define B 2 3
+#define B 2
+#define C 1
+#define D 1 2
+#define E
+
+/* { dg-warning "redefined" "redef A"      { target *-*-* } 7  }
+   { dg-warning "redefined" "redef B"      { target *-*-* } 9  }
+   { dg-warning "redefined" "redef D"      { target *-*-* } 11 }
+   { dg-warning "redefined" "redef E"      { target *-*-* } 12 }
+   { dg-warning "previous"  "prev def A"   { target *-*-* } 6  }
+   { dg-warning "previous"  "prev def B"   { target *-*-* } 8  }
+   { dg-warning "previous"  "prev def D/E" { target *-*-* } 0  }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/separate-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/separate-1.c
new file mode 100644
index 000000000..6814a0fa2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/separate-1.c
@@ -0,0 +1,17 @@
+/* Copyright 2003 Free Software Foundation.  */
+
+/* { dg-do compile } */
+/* { dg-options "-save-temps" } */
+
+/* Make sure we report errors in the right line, even if separate
+   preprocessing is used.  */
+
+#define FOO()
+
+int FOO( /* { dg-error "parse error|syntax error|expected" "error on this line" } */
+	), bar;
+
+int baz FOO /* { dg-error "parse error|syntax error|expected" "error on this line" } */
+;
+
+/* { dg-final { cleanup-saved-temps } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/skipping.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/skipping.c
new file mode 100644
index 000000000..b8daa890b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/skipping.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests expansion of macros whilst skipping false conditionals.  */
+
+/* Source: Neil Booth, 29 Oct 2000.  */
+
+#define F()
+#define TRUE 1
+
+#if 0
+F(			/* No diagnostic: don't even try to expand it.  */
+#endif
+
+#if 0
+#elif TRUE		/* Expand this, even though we were skipping.  */
+#else
+#error Macros not expanded in #elif
+#endif
+
+/* Check we don't warn about bad identifiers when skipping.  */
+#if 0
+#define foo __VA_ARGS__	/* { dg-bogus "warned about identifier" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/skipping2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/skipping2.c
new file mode 100644
index 000000000..14dafc01e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/skipping2.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests that excess tokens in skipped conditional blocks don't warn.  */
+
+/* Source: Neil Booth, 25 Jul 2001.  */
+
+#if 0
+#if foo
+#else foo   /* { dg-bogus "extra tokens" "extra tokens in skipped block" } */
+#endif foo  /* { dg-bogus "extra tokens" "extra tokens in skipped block" } */
+#endif bar  /* { dg-error "extra tokens" "tokens after #endif" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/spacing1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/spacing1.c
new file mode 100644
index 000000000..2d70f869d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/spacing1.c
@@ -0,0 +1,65 @@
+/* Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* This tests correct spacing of macro expansion output, as well as
+   the line it falls on.  This is quite subtle; it involves newlines
+   within macro arguments becoming spaces, but not if it turns out to
+   not be a macro invocation.  Also, multiple macro invocations spread
+   across many lines.
+
+   Neil Booth, 1 Dec 2000, 23 Sep 2001.  */
+
+/* The actual location of the expansion of a multi-line macro
+   invocation is not defined: we might consider them to be in the same
+   line as the initial token of the invocation, or as the final token
+   of the invocation, or even anything in between.  We choose to make
+   it the initial token, such that everything that is in a logical
+   line ends up in a single line after preprocessing.
+
+   Alexandre Oliva, Sept 13, 2003.  */
+
+#define str(x) #x
+#define f(x) x
+#define glue(x, y) x ## y
+#define EMPTY
+/* These are based on PR 4492, we mustn't lose padding tokens when
+   scanning ahead for a '(' and failing to find it.  */
+#define A(x) B x
+#define B(x)
+#define C A
+#define D() A
+
+/* The correct output is shown here.  Note the spaces, and the way
+   everything after the invocation of f appears on the same line.
+
+ 44 ;
+B Q B Q A Q A:
+f
+bar
+A
+bad
+g "1 2" bam baz
+
+*/
+
+glue (EMPTY 4, 4) EMPTY;
+A(Q) C(Q) D()Q D():
+f
+bar
+A
+bad
+f (g) str
+(
+1
+2
+) f
+(bam) baz
+
+/* { dg-final { scan-file spacing1.i " 44 ;" } }
+   { dg-final { scan-file spacing1.i "B Q B Q A Q A:" } }
+   { dg-final { scan-file-not spacing1.i "f\[^\n\]*bar" } }
+   { dg-final { scan-file spacing1.i "(^|\n)bar" } }
+   { dg-final { scan-file spacing1.i "(^|\n)A($|\n)" } }
+   { dg-final { scan-file spacing1.i "(^|\n)bad($|\n)" } }
+   { dg-final { scan-file spacing1.i "g \"1 2\" bam baz" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/spacing2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/spacing2.c
new file mode 100644
index 000000000..6cfa5a3d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/spacing2.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2001, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* We used to output an unnecessary leading space, leading to Emacs
+   confusion with its Makefile abuse.
+
+   Neil Booth, 12 Oct 2001.  */
+
+#define EMPTY
+#define foo bar
+
+a = EMPTY
+foo..				/* No leading space on output.  */
+
+/* { dg-final { scan-file spacing2.i "(^|\n)bar\.\." } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify1.c
new file mode 100644
index 000000000..35355401a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify1.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Test operator # semantics.  */
+
+#define OK1 #		/* No problem.  */
+#define OK2(x) x#x	/* No problem.  */
+#define bad1(x) #	/* { dg-error "followed by a macro parameter" "#1" } */
+#define bad2(x) #y	/* { dg-error "followed by a macro parameter" "#2" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify2.c
new file mode 100644
index 000000000..2c768dcd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify2.c
@@ -0,0 +1,56 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-std=c99 -pedantic-errors -fno-show-column" } */
+
+/* Tests a whole bunch of things are correctly stringified.  */
+
+extern int strcmp (const char *, const char *);
+extern int puts (const char *);
+extern void abort (void);
+#define err(str) do { puts(str); abort(); } while (0)
+
+#define str(x) #x
+#define xstr(x) str(x)
+#define strvar(...) #__VA_ARGS__
+
+#define glibc_str(x) glibc_str2 (w, x)
+#define glibc_str2(w, x) #x
+#define ver GLIBC_2.2
+
+int main (int argc, char *argv[])
+{
+  str (\);		/* { dg-warning "valid string" "str(\\)" } */
+  str (\\);		/* OK.  */
+  str (\\\);		/* { dg-warning "valid string" "str(\\\\\\)" } */
+
+  /* This also serves as a useful test of the value of __INCLUDE_LEVEL.  */
+  if (strcmp (xstr (__INCLUDE_LEVEL__), "0"))
+    err ("macro expansion");
+
+  if (strcmp(str (__INCLUDE_LEVEL__), "__INCLUDE_LEVEL__"))
+    err ("macro name");
+
+  if (strcmp(str(), "") || strcmp(str( ), ""))
+    err ("empty string");
+
+  if (strcmp(str ("s\n"), "\"s\\n\""))
+    err ("quoted string");
+
+  if (strcmp (str (a € b), "a \200 b"))
+    err ("unprintable char");
+
+  if (strcmp (str (	a    b@ c   ), "a b@ c"))
+    err ("internal whitespace");
+
+  if (strcmp (str(a \n), "a \n"))
+    err ("backslash token");
+
+  if (strcmp (strvar (foo, bar), "foo, bar"))
+    err ("variable arguments");
+
+  if (strcmp (glibc_str (ver), "GLIBC_2.2"))
+    err ("whitespace");
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify3.c
new file mode 100644
index 000000000..5d76b5e75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify3.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+
+/* Tests we stringify without inserting a space.  GCC 2.95.x and
+   earlier would insert a bogus space before bar in the string, simply
+   because a space was there in the invocation.
+
+   Neil Booth, 24 Sep 2001.  */
+
+extern int strcmp (const char *, const char *);
+extern int puts (const char *);
+extern void abort (void);
+#define err(str) do { puts(str); abort(); } while (0)
+
+#define str(x) #x
+#define xstr(x) str(x)
+#define glibc_hack(x, y) x@y
+
+int main (int argc, char *argv[])
+{
+  /* The space before "bar" here is vital.  */
+  char a[] = xstr(glibc_hack(foo, bar));
+
+  if (strcmp (a, "foo@bar"))
+    err ("stringification without spaces");
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify4.c
new file mode 100644
index 000000000..b8b2f11e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strify4.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* Tests we stringify without changing unprintable characts.  
+
+   Andrew Pinski */
+
+extern int strcmp (const char *, const char *);
+extern int puts (const char *);
+extern void abort (void);
+#define err(str) do { puts(str); abort(); } while (0)
+
+
+#define S(X) S2(X)
+#define S2(X) #X
+#define TAB "	" /* Note there is a tab character here. */
+
+int main (int argc, char *argv[])
+{
+  /* The space before "bar" here is vital.  */
+  char a[] = S(S(TAB));
+
+  if (strcmp (a, "\"\\\"	\\\"\""))
+    err ("stringification caused octal");
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strp1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strp1.c
new file mode 100644
index 000000000..096d968c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strp1.c
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+
+/* Regression test for stringizing and token pasting.
+   We got internal escape markers in the strings.  */
+
+#include <string.h>
+#include <stdlib.h>
+
+#define S(x) _S(x)
+#define _S(x) #x
+
+#define I 1
+static const char s1[] = S(I.1);
+static const char t1[] = "1.1";
+
+#define f h
+#define h(a) a+f
+static const char s2[] = S( f(1)(2) );
+static const char t2[] = "1+h(2)";
+
+#undef I
+#undef f
+#undef h
+
+int
+main(void)
+{
+  if (strcmp (s1, t1))
+    abort ();
+
+  if (strcmp (s2, t2))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strp2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strp2.c
new file mode 100644
index 000000000..d1fcd9182
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/strp2.c
@@ -0,0 +1,23 @@
+/* { dg-do run } */
+
+/* Test for odd corner cases in stringizing/pasting.
+   Taken more or less verbatim from C99 section 6.10.3.3.  */
+
+#include <stdlib.h>
+#include <string.h>
+
+#define hash_hash # ## #
+#define mkstr(a) # a
+#define in_between(a) mkstr(a)
+#define join(c, d) in_between(c hash_hash d)
+
+const char p[] = join(x, y);
+const char q[] = "x ## y";
+
+int
+main (void)
+{
+  if (strcmp (p, q))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/subframework1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/subframework1.c
new file mode 100644
index 000000000..35d64d7fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/subframework1.c
@@ -0,0 +1,15 @@
+/* Copyright (C) 2004 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess { target *-*-darwin* } } */
+/* { dg-options "-Wno-deprecated -F$srcdir/gcc.dg/cpp/frame" } */
+
+/* Contributed by Robert Bowdidge <bowdidge@apple.com>  */
+/* include a file from a subframework that will import two files that
+   both look at the same file.  Make sure we only include that file once;
+   if so, the program will compile fine.  If not, we'll get redefinition
+   errors */
+
+#include <one/one-includeSubs.h>
+#ifndef ONESUB_C_INCLUDED
+#error C.h not included
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr.c
new file mode 100644
index 000000000..751377393
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr.c
@@ -0,0 +1,12 @@
+/* Test for proper suppression of warnings in system headers,
+   and only in system headers.  */
+/* FRAGILITY WARNING: The only way we have to distinguish the good error
+   from the bad error is that the good error is on line 4 and the bad is
+   on line 5 (of their respective files).  dg.exp doesn't have any way to
+   condition error matchers on the file they're in.  */
+
+/* { dg-do preprocess } */
+/* { dg-error "include_next" "good error" { target *-*-* } 4 } */
+
+#include "syshdr1.h"  /* { dg-message "" "In file included from:" } */
+#include "syshdr2.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr.h
new file mode 100644
index 000000000..3f546aa52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr.h
@@ -0,0 +1,10 @@
+/* Indented to avoid "suggest hiding ..." warnings.   */
+ #pragma GCC system_header
+
+#define sys_uint 1U
+#define sys_str(x) x
+#define sys_foo(x, y...) bar (x, ##y)
+
+#define sys_uint 1U
+#define sys_fl 1.0f
+#define sys_ld 1.0L
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr1.h
new file mode 100644
index 000000000..310f39b5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr1.h
@@ -0,0 +1,4 @@
+/* This file should generate an error because #include_next is not a
+   standard directive.  */
+
+#include_next <stdio.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr2.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr2.h
new file mode 100644
index 000000000..0140fdac1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/syshdr2.h
@@ -0,0 +1,5 @@
+/* This file would generate an error because of #include_next, but the
+   #pragma marks it a system header, so the error is suppressed.  */
+
+#pragma GCC system_header
+#include_next <stdio.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/sysmac1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/sysmac1.c
new file mode 100644
index 000000000..fa741a426
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/sysmac1.c
@@ -0,0 +1,26 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu99 -pedantic -Wtraditional" } */
+
+/* Tests diagnostics are suppressed for some macros defined in system
+   headers.  */
+
+/* Source: Neil Booth, 15 Jan 2001.  */
+
+#include "syshdr.h"
+
+#define uint 1U
+#define str(x) x
+#define foo(x, y...) bar(x, ##y) /* { dg-warning "named variadic macros" } */
+
+#if uint			/* { dg-warning "traditional C rejects" } */
+#endif
+#if sys_uint			/* { dg-bogus "traditional C rejects" } */
+#endif
+
+(str);				/* { dg-warning "used with arguments" } */
+(sys_str);			/* { dg-bogus "used with arguments" } */
+
+foo (one_arg);			/* { dg-warning "requires rest arguments" } */
+sys_foo (one_arg);		/* { dg-bogus "requires rest arguments" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/sysmac2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/sysmac2.c
new file mode 100644
index 000000000..0d1efabdc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/sysmac2.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic -Wtraditional -fno-show-column" } */
+
+/* Tests diagnostics are suppressed for some macros defined in system
+   headers.  */
+
+/* Source: Neil Booth, 15 Jan 2001.  */
+
+#include "syshdr.h"
+
+#define uint 1U
+#define fl 1.0f
+#define ld 1.0L
+
+int
+main ()
+{
+  int u1 = uint;		/* { dg-warning "traditional C rejects" } */
+  int u2 = sys_uint;		/* { dg-bogus "traditional C rejects" } */
+  float f1 = fl;		/* { dg-warning "traditional C rejects" } */
+  float f2 = sys_fl;		/* { dg-bogus "traditional C rejects" } */
+  long double ld1 = ld;		/* { dg-warning "traditional C rejects" } */
+  long double l2 = sys_ld;	/* { dg-bogus "traditional C rejects" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-paste.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-paste.c
new file mode 100644
index 000000000..1dd827663
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-paste.c
@@ -0,0 +1,19 @@
+/* Test for proper comment elimination semantics from cpplib's -traditional.
+   This should compile and link with compiled with `gcc -traditional-cpp'.
+   Test case by Jason R. Thorpe <thorpej@zembu.com>.  */
+
+/* { dg-do compile } */
+/* { dg-options "-traditional-cpp" } */
+
+extern int printf (const char *, ...);
+
+#define A(name) X/**/name
+
+#define B(name) \
+void A(Y/**/name)() { A(name)(); }
+
+void Xhello() { printf("hello world\n"); }
+
+B(hello)
+
+int main() { XYhello(); return (0); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn1.c
new file mode 100644
index 000000000..259f92882
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn1.c
@@ -0,0 +1,39 @@
+/* Test for warnings about nontraditional directives.  */
+/* { dg-do preprocess } */
+/* { dg-options "-pedantic -Wtraditional -fno-show-column" } */
+
+/* Block 1: K+R directives should have the # indented.  */
+
+#define foo bar		/* { dg-bogus "indented" "^#kandr"     } */
+# define foo bar	/* { dg-bogus "indented" "^# kandr"    } */
+ #define foo bar	/* { dg-warning "indented" "^ #kandr"  } */
+ # define foo bar	/* { dg-warning "indented" "^ # kandr" } */
+
+/* Block 2: C89 directives should not have the # indented.  */
+
+#pragma whatever	/* { dg-warning "indented" "^#c89"     } */
+# pragma whatever	/* { dg-warning "indented" "^# c89"    } */
+ #pragma whatever	/* { dg-bogus "indented" "^ #c89"      } */
+ # pragma whatever	/* { dg-bogus "indented" "^ # c89"     } */
+
+/* Block 3: Extensions should not have the # indented,
+   _and_ they should get a -pedantic warning. */
+
+#assert foo(bar)	/* { dg-warning "indented" "^#ext"    } */
+# assert bar(baz)	/* { dg-warning "indented" "^# ext"   } */
+ #assert baz(quux)	/* { dg-bogus "indented" "^ #ext"     } */
+ # assert quux(weeble)	/* { dg-bogus "indented" "^ # ext"    } */
+
+/* We warn of #elif regardless of whether we're skipping or not, and
+   do not warn about indentaion.  */
+#if 0
+#if 1
+#elif 1			/* { dg-warning "#elif" "#elif skipping" }  */
+#endif
+#elif 0			/* { dg-warning "#elif" "#elif not skipping" }  */
+#endif
+
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 22 } */
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 23 } */
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 24 } */
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 25 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn2.c
new file mode 100644
index 000000000..85b624761
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn2.c
@@ -0,0 +1,18 @@
+/* K+R rejects use of function-like macros in non-function context.
+   ANSI C explicitly permits this (the macro is not expanded).
+
+   We should not warn about this during pre-expansion of arguments,
+   since traditional preprocessors don't do pre-expansion, and we get
+   the warning anyway during the re-scan pass if and only if it is
+   appropriate.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -Wtraditional } */
+
+#define f(x) x
+#define g(x) x / 2
+#define h(a, b) a(b)
+f(g) (3)	    /* { dg-bogus "must be used with arguments" } */
+f 2		    /* { dg-warning "must be used with arguments" } */
+f(g) 3		    /* { dg-warning "must be used with arguments" } */
+h(f, 3)		    /* { dg-bogus "must be used with arguments" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn3.c
new file mode 100644
index 000000000..e802b4dd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn3.c
@@ -0,0 +1,61 @@
+/* Test for warnings about nontraditional directives inside the unused
+   clauses of #if statements.  Extensions do _not_ receive pedantic
+   warnings inside unused clauses because they are often hidden this
+   way on purpose.  However they do still require indentation for K&R.  */
+/* { dg-do preprocess } */
+/* { dg-options "-pedantic -Wtraditional -fno-show-column" } */
+
+#if 1
+
+/* Block 1: K+R directives should have the # indented to warn.  */
+
+#define foo bar		/* { dg-bogus "indented" "^#kandr"     } */
+# define foo bar	/* { dg-bogus "indented" "^# kandr"    } */
+ #define foo bar	/* { dg-warning "indented" "^ #kandr"  } */
+ # define foo bar	/* { dg-warning "indented" "^ # kandr" } */
+
+/* Block 2: C89 directives should not have the # indented to warn.  */
+
+#pragma whatever	/* { dg-warning "indented" "^#c89"     } */
+# pragma whatever	/* { dg-warning "indented" "^# c89"    } */
+ #pragma whatever	/* { dg-bogus "indented" "^ #c89"      } */
+ # pragma whatever	/* { dg-bogus "indented" "^ # c89"     } */
+
+/* Block 3: Extensions should not have the # indented to warn, _and_
+   they should get a -pedantic warning. */
+
+#assert foo(bar)	/* { dg-warning "indented" "^#ext"    } */
+# assert bar(baz)	/* { dg-warning "indented" "^# ext"   } */
+ #assert baz(quux)	/* { dg-bogus "indented" "^ #ext"     } */
+ # assert quux(weeble)	/* { dg-bogus "indented" "^ # ext"    } */
+
+#else
+
+/* Block 1: K+R directives should have the # indented to warn.  */
+
+#undef foo bar		/* { dg-bogus "indented" "^#kandr"     } */
+# undef foo bar		/* { dg-bogus "indented" "^# kandr"    } */
+ #undef foo bar		/* { dg-warning "indented" "^ #kandr"  } */
+ # undef foo bar	/* { dg-warning "indented" "^ # kandr" } */
+
+/* Block 2: C89 directives should not have the # indented to warn.  */
+
+#error whatever		/* { dg-warning "indented" "^#c89"     } */
+# error whatever	/* { dg-warning "indented" "^# c89"    } */
+ #error whatever	/* { dg-bogus "indented" "^ #c89"      } */
+ # error whatever	/* { dg-bogus "indented" "^ # c89"     } */
+
+/* Block 3: Extensions should not have the # indented to warn, and
+   they should _not_ get a -pedantic warning. */
+
+#unassert foo(bar)		/* { dg-warning "indented" "^#ext"    } */
+# unassert bar(baz)		/* { dg-warning "indented" "^# ext"   } */
+ #unassert baz(quux)		/* { dg-bogus "indented" "^ #ext"     } */
+ # unassert quux(weeble)	/* { dg-bogus "indented" "^ # ext"    } */
+
+#endif
+
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 27 } */
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 28 } */
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 29 } */
+/* { dg-warning "GCC extension" "extension warning" { target *-*-* } 30 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn4.c
new file mode 100644
index 000000000..14dd8a316
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn4.c
@@ -0,0 +1,26 @@
+/* Test for -Wtraditional warnings on integer constant suffixes.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do preprocess } */
+/* { dg-options "-Wtraditional -fno-show-column" } */
+
+#if 1U /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+#endif
+#if 1u /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+#endif
+#if 1L
+#endif
+#if 1l
+#endif
+  
+# 17 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+#if 1U
+#endif
+#if 1u
+#endif
+#if 1L
+#endif
+#if 1l
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn5.c
new file mode 100644
index 000000000..16dcf4c08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn5.c
@@ -0,0 +1,14 @@
+/* Test for -Wtraditional warnings on the unary plus operator.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do preprocess } */
+/* { dg-options "-Wtraditional -fno-show-column" } */
+
+#if +1 /* { dg-warning "unary plus operator" "unary plus operator" } */
+#endif
+  
+# 11 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+#if +1
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn6.c
new file mode 100644
index 000000000..e9aa851d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/tr-warn6.c
@@ -0,0 +1,27 @@
+/* Test for -Wtraditional warnings for stringification of macro args.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 9/8/2000.  */
+/* { dg-do preprocess } */
+/* { dg-options "-Wtraditional -fno-show-column" } */
+
+#define foo1(h) sdf "h3" fds "h" /* { dg-warning "macro argument \"h\" would be stringified" "traditional stringification" } */
+#define foo2(h2) sdf "h2" fds "h3" /* { dg-warning "macro argument \"h2\" would be stringified" "traditional stringification" } */
+#define foo3(h3) sdf "h2" fds "h3" /* { dg-warning "macro argument \"h3\" would be stringified" "traditional stringification" } */
+#define foo4(h) sdf 'h3' fds 'h' /* { dg-warning "macro argument \"h\" would be stringified" "traditional stringification" } */
+#define foo5(h2) sdf 'h2' fds 'h3' /* { dg-warning "macro argument \"h2\" would be stringified" "traditional stringification" } */
+#define foo6(h3) sdf 'h2' fds 'h3' /* { dg-warning "macro argument \"h3\" would be stringified" "traditional stringification" } */
+#define foo7(AA, hello, world, EEE) sdf "A B hello C,world,DhelloE F" fds EEE /* { dg-warning "macro argument \"hello\" would be stringified" "traditional stringification" } */
+
+/* Catch the second warning from the above line.  */
+/* { dg-warning "macro argument \"world\" would be stringified" "traditional stringification second warning" { target *-*-* } 13 } */
+
+# 19 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+#define bar1(h) sdf "h3" fds "h"
+#define bar2(h2) sdf "h2" fds "h3"
+#define bar3(h3) sdf "h2" fds "h3"
+#define bar4(h) sdf 'h3' fds 'h'
+#define bar5(h2) sdf 'h2' fds 'h3'
+#define bar6(h3) sdf 'h2' fds 'h3'
+#define bar7(AA, hello, world, EEE) sdf "A B hello C,world,DhelloE F" fds EEE
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/Wunused.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/Wunused.c
new file mode 100644
index 000000000..403d617f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/Wunused.c
@@ -0,0 +1,37 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-Wunused-macros -traditional-cpp" } */
+
+/* Test everything related to -Wunused-macros.
+
+   Source: Neil Booth, 23 Jul 2002.  */
+
+#include "Wunused.h"
+
+#define used1			/* { dg-bogus "used" } */
+#define used2			/* { dg-bogus "used" } */
+#define used3			/* { dg-bogus "used" } */
+#define used4 something		/* { dg-bogus "used" } */
+
+#define unused5			/* { dg-warning "used" } */
+#define unused6			/* { dg-warning "used" } */
+#define unused7()		/* { dg-warning "used" } */
+
+#if defined used1
+#endif
+#ifdef used2
+#endif
+#ifndef used3
+#endif
+used4
+
+unused7;			/* This does not count as a use.  */
+
+#if 0
+unused5				/* This does not count as a use.  */
+#endif
+
+#undef unused5
+#define unused6
+unused6
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/Wunused.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/Wunused.h
new file mode 100644
index 000000000..8b54412bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/Wunused.h
@@ -0,0 +1 @@
+#define unused_but_ok
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/__STDC__.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/__STDC__.c
new file mode 100644
index 000000000..b25bcb9aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/__STDC__.c
@@ -0,0 +1,7 @@
+/* Test that __STDC__ is not defined.  */
+
+/* { dg-do preprocess } */
+
+#if defined __STDC__
+# error __STDC__ defined /* { dg-bogus "__STDC__" "__STDC__ defined" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/argcount.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/argcount.c
new file mode 100644
index 000000000..208cd44b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/argcount.c
@@ -0,0 +1,21 @@
+/* Test that we correctly complain about an invalid number of macro
+   arguments.  */
+
+/* { dg-do preprocess } */
+
+#define f(x) x
+#define g(x, y) x y
+#define h()
+
+f(); 		/* { dg-bogus "requires 1" "no arg is 1 empty arg" } */
+f( ); 		/* { dg-bogus "macro" "1 arg to 1 param macro" } */
+f(1,); 		/* { dg-error "passed 2" "2 args to 1 param macro" } */
+f(1,2);		/* { dg-error "passed 2" "2 args to 1 param macro" } */
+h();		/* { dg-bogus "macro" "no arg to 1 param macro" } */
+h( );		/* { dg-error "passed 1" "1 arg to 0 param macro" } */
+h(1,2);		/* { dg-error "passed 2" "2 args to 0 param macro" } */
+g();		/* { dg-error "requires 2" "0 args to 2 param macro" } */
+g( );		/* { dg-error "requires 2" "1 args to 2 param macro" } */
+g( ,2);		/* { dg-bogus "requires 2" "2 args to 2 param macro" } */
+g(,);		/* { dg-bogus "requires 2" "2 args to 2 param macro" } */
+g(1,2,3);	/* { dg-error "passed 3" "3 args to 2 param macro" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assembler.S b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assembler.S
new file mode 100644
index 000000000..75bb62841
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assembler.S
@@ -0,0 +1,29 @@
+/* Regression test - in assembly language, # may have some significance
+   other than 'stringize macro argument' and therefore must be preserved
+   in the output, and should not be warned about.  */
+
+/* { dg-do preprocess } */
+
+#ifndef FOO
+#1			/* Once caused a bogus unterminated #ifndef.  */
+#endif
+		
+#define foo() mov r0, #5  /* { dg-bogus "not followed" "spurious warning" } */
+
+entry:
+	foo()
+
+/* Check we don't EOF on an unknown directive.  */
+#unknown directive
+#error a later diagnostic	/* { dg-error "diagnostic" } */
+		
+/*
+   { dg-final { if ![file exists 20000510-1.i] { return }	} }
+   { dg-final { set tmp [grep 20000510-1.i # line]		} }
+   { dg-final { if {[string length $tmp] > 0} \{		} }
+   { dg-final {     pass "20000510-1.S: # preservation"		} }
+   { dg-final { \} else \{					} }
+   { dg-final {     fail "20000510-1.S: # preservation"		} }
+   { dg-final { \}						} }
+*/
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert1.c
new file mode 100644
index 000000000..d1446105c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert1.c
@@ -0,0 +1,46 @@
+/* Basic tests of the #assert preprocessor extension. */
+/* { dg-do compile } */
+/* { dg-options "-Wno-deprecated" } */
+
+#define def unused expansion
+#define fail  int fail
+
+#assert abc (def)
+#assert abc (ghi)
+#assert abc (jkl)
+#assert space ( s p a c e )
+
+/* Basic: */
+#if !#abc (def) || !#abc (ghi) || !#abc (jkl)
+fail
+#endif
+
+/* any answer for #abc */
+#if !#abc
+fail
+#endif
+
+/* internal whitespace is collapsed,
+   external whitespace is deleted  */
+#if !#space (s p  a  c e) || !#space (  s p a c e  ) || #space (space)
+fail
+#endif
+
+/* removing assertions */
+#unassert abc (jkl)
+#if !#abc || !#abc (def) || !#abc (ghi) || #abc (jkl)
+fail
+#endif
+
+#unassert abc
+#if #abc || #abc (def) || #abc (ghi) || #abc (jkl)
+fail
+#endif
+
+int gobble
+
+/* make sure it can succeed too.
+   also check space before open paren isn't significant */
+#if #space(s p a c e)
+;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert2.c
new file mode 100644
index 000000000..4aa0b9944
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert2.c
@@ -0,0 +1,24 @@
+/* Malformed assertion tests.  */
+/* { dg-do preprocess } */
+/* { dg-options "-Wno-deprecated" } */
+
+#assert		/* { dg-error "without predicate" "assert w/o predicate" } */
+#assert %	/* { dg-error "an identifier" "assert punctuation" } */
+#assert 12	/* { dg-error "an identifier" "assert number" } */
+#assert abc	/* { dg-error "missing" "assert w/o answer" } */
+
+#if #		/* { dg-error "without predicate" "test w/o predicate" } */
+#endif
+
+#if #%		/* { dg-error "an identifier" "test punctuation" } */
+#endif
+
+#if #12		/* { dg-error "an identifier" "test number" } */
+#endif
+
+#if #abc
+#error		/* { dg-bogus "error" "test w/o answer" } */
+#endif
+
+#if #abc[def]	/* { dg-error "not valid in" "bad syntax" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert3.c
new file mode 100644
index 000000000..9010ecebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/assert3.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000, 2008 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-A abc=def -A abc\(ghi\) \"-Aabc = jkl\" -A abc=mno -A -abc=mno -Wno-deprecated" } */
+
+/* Test -A command line syntax.  Source Neil Booth.  31 Oct 2000.  */
+
+#if !#abc (def) || !#abc (ghi) || !#abc (jkl) || #abc(mno)
+#error Command line -A assertions
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/builtins.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/builtins.c
new file mode 100644
index 000000000..74798bbb4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/builtins.c
@@ -0,0 +1,54 @@
+/* Test that builtin-macros are OK.  */
+
+/* { dg-do run } */
+
+#include "builtins.h"
+
+void abort (void);
+char *strstr (const char *, const char *); 
+int strcmp (const char *, const char *);
+
+#define LINE __LINE__
+
+#if __LINE__ != 13
+# error __LINE__ part 1  /* { dg-bogus "__LINE__" } */
+#endif
+
+#if \
+  __LINE__ != 18
+# error __LINE__ part 2  /* { dg-bogus "__LINE__" } */
+#endif
+
+#if LINE != 22
+# error __LINE__ part 3  /* { dg-bogus "__LINE__" } */
+#endif
+
+#if __INCLUDE_LEVEL != 0
+# error __INCLUDE_LEVEL__  /* { dg-bogus "__INCLUDE_LEVEL__" } */
+#endif
+
+#if !defined (__TIME__)
+# error __TIME__  /* { dg-bogus "__TIME__" } */
+#endif
+
+#if !defined (__DATE__)
+# error __DATE__  /* { dg-bogus "__DATE__" } */
+#endif
+
+
+int main ()
+{
+  /* level is defined in builtins.h.  */
+  if (level != 1)
+    abort ();
+
+  if (!strstr (__FILE__, "builtins.c"))
+    abort ();
+
+  if (!strcmp (__BASE_FILE__, "builtins.c"))
+    abort ();
+
+  return 0;
+}
+
+/* { dg-require-host-local "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/builtins.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/builtins.h
new file mode 100644
index 000000000..9f2b9a014
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/builtins.h
@@ -0,0 +1 @@
+int level = __INCLUDE_LEVEL__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-C.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-C.c
new file mode 100644
index 000000000..ff67ddbdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-C.c
@@ -0,0 +1,37 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-C -traditional-cpp" } */
+
+/* Test -C doesn't fail with #define.  #define is the tricky case,
+   being the only directive that remembers its comments.
+
+   -C treats comments as tokens in their own right, so e.g. comment at
+   the beginning of a directive turns it into a non-directive.  */
+
+#define simple no comments
+
+#define/**/obj_like/**/(some)/**/thing/**/
+#define fun_like(/**/x/**/,/**/y/**/)/**/
+/**/#define not_a_macro
+
+#if !defined simple || !defined obj_like || !defined fun_like
+#error Missed some macros with -C
+#endif
+
+#ifdef not_a_macro
+#error not_a_macro is!
+#endif
+
+/* Check obj_like doesn't expect arguments, and fun_like does.  */
+obj_like
+fun_like (foo, bar)
+
+/* Check OK to redefine fun_like without comments in the params.  */
+#define fun_like(x, y)/**/
+
+/* Check comments in macros in directives are OK.  */
+#define ZERO 0 /* A trailing comment.  */
+
+#if ZERO
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-C2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-C2.c
new file mode 100644
index 000000000..96bd371a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-C2.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-C -traditional-cpp" } */
+
+/* Test that comments are actually written out
+
+   Neil Booth, 24 Jun 2002.  */
+
+/* { dg-final { scan-file cmdlne-C2.i "dg-final" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-dD.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-dD.c
new file mode 100644
index 000000000..1e4c8c867
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-dD.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2000, 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dD -traditional-cpp" } */
+
+/* Test -dD does not fail.  */
+
+#define objlike obj like
+#define funlike(like) fun like
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-dM.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-dM.c
new file mode 100644
index 000000000..0fb5bd9dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/cmdlne-dM.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2000, 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-dM -traditional-cpp" } */
+
+/* Test -dM does not fail.  */
+
+#define objlike obj like
+#define funlike(like) fun like
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment-2.c
new file mode 100644
index 000000000..8d54e3a0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment-2.c
@@ -0,0 +1,11 @@
+/* Test for warning of nested comments.  */
+
+/* { dg-do preprocess } */
+
+/* { dg-options "-traditional-cpp -Wcomments" }
+
+/* /* */   /* { dg-warning "within comment" } */
+
+/*
+
+ /* { dg-warning "within comment" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment-3.c
new file mode 100644
index 000000000..e2710ad56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment-3.c
@@ -0,0 +1,6 @@
+/* Test we don't accept C++ comments.  */
+
+/* { dg-do preprocess } */
+
+#if 0
+#endif //  /* { dg-warning "extra tokens" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment.c
new file mode 100644
index 000000000..971a78a6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/comment.c
@@ -0,0 +1,5 @@
+/* Test for warning of unterminated comment.  */
+
+/* { dg-do preprocess } */
+
+/* { dg-error "unterminated comment" }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/define.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/define.c
new file mode 100644
index 000000000..d83288df2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/define.c
@@ -0,0 +1,2 @@
+/* { dg-do preprocess } */
+/* { dg-options "-traditional-cpp -DDEFINE1DEFINE -DDEFINE2DEFIN=" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/defined.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/defined.c
new file mode 100644
index 000000000..5fa1d93b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/defined.c
@@ -0,0 +1,78 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Tests tradcpp0 with defined.  The defined operator in traditional C
+   works just the same as the defined operator in Standard C.  */
+
+/* Source: Zack Weinberg, glibc, Neil Booth 11 Dec 2000.  */
+
+#if defined REGPARMS
+#error REGPARMS should not be defined
+#endif
+
+#define REGPARMS 1
+#if !defined REGPARMS
+#error REGPARMS should be defined
+#endif
+
+#define defined			/* { dg-error "defined" } */
+
+/* No diagnostics, though you could argue there should be.  */
+#if defined defined
+#error defined is defined!
+#endif
+
+#define is_Z_defined defined Z
+
+#if defined Z
+#error Z is not defined
+#endif
+
+/* The behavior of "defined" when it comes from a macro expansion is
+   now documented.  */
+#if is_Z_defined
+#error Macro expanding into defined operator test 1
+#endif
+
+#define Z
+
+#if !defined Z
+#error Z is defined
+#endif
+
+#if !is_Z_defined
+#error Macro expanding into defined operator test 2
+#endif
+
+#undef is_Z_defined
+#undef Z
+
+/* Do all the tests over again with the () form of defined.  */
+
+/* No diagnostics, though you could argue there should be.  */
+#if defined(defined)
+#error defined is defined!
+#endif
+
+#define is_Z_defined defined ( Z )
+
+#if defined(Z)
+#error Z is not defined
+#endif
+
+/* The behavior of "defined" when it comes from a macro expansion is
+   now documented.  */
+#if is_Z_defined
+#error Macro expanding into defined operator test 1
+#endif
+
+#define Z
+
+#if !defined(Z)
+#error Z is defined
+#endif
+
+#if !is_Z_defined
+#error Macro expanding into defined operator test 2
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/directive.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/directive.c
new file mode 100644
index 000000000..ee7ebcab0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/directive.c
@@ -0,0 +1,23 @@
+/* Test for some basic aspects of -traditional directive processing.  */
+
+/* { dg-do preprocess } */
+
+#define HASH #
+HASH
+
+/* There is a #error directive.  */
+
+#error bad	/* { dg-error "bad" } */
+
+/* Directives with their #s indented are not recognized.  */
+ #if 0	/* { dg-bogus "unterminated" } */
+
+#wrong	/* { dg-error "invalid" } */
+
+#define foo 2
+#define bar + 3
+#define foobar 6
+
+#if foo/**/bar != 5
+# error Comments in directive is a separator /* { dg-bogus "error" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/escaped-eof.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/escaped-eof.c
new file mode 100644
index 000000000..2c9c185b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/escaped-eof.c
@@ -0,0 +1,6 @@
+/* Test for warning of escaped EOF.  */
+
+/* { dg-do preprocess } */
+
+/* { dg-warning "backslash-new" "escaped EOF warning" { target *-*-* } 6 } */
+\
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/escaped-nl.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/escaped-nl.c
new file mode 100644
index 000000000..be8cc53fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/escaped-nl.c
@@ -0,0 +1,10 @@
+/* Test escaped newlines at start of macro definition are properly
+   skipped (buglet in skip_whitespace () in cpptrad.c).  */
+
+/* { dg-do preprocess } */
+
+#define NUM \
+100
+#if NUM != 100
+# error NUM not defined properly /* { dg-bogus "error" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-2.c
new file mode 100644
index 000000000..edcf2abf2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-2.c
@@ -0,0 +1,23 @@
+/* Test that nested commas and parentheses in macro arguments are
+   OK.  */
+
+/* { dg-do preprocess } */
+
+#define f(x) x
+#define g(x, y) x y
+
+#if f((1)) != 1
+# error		/* { dg-bogus "error" "nested parens 1" } */
+#endif
+
+#if f((1, 2)) != 2
+# error		/* { dg-bogus "error" "nested comma 1" } */
+#endif
+
+#if g(, (1)) != 1
+# error		/* { dg-bogus "error" "nested parens 2" } */
+#endif
+
+#if g((1, 2), + 3) != 5
+# error		/* { dg-bogus "error" "nested comma 2" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-3.c
new file mode 100644
index 000000000..5300afba7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-3.c
@@ -0,0 +1,12 @@
+/* Test that function-like macros are restricted to directives, and
+   that unterminated ones are warned about.  */
+
+/* { dg-do preprocess } */
+
+#define f(x) x
+
+#if 2 f(/* { dg-error "unterminated" "unterminated macro in directive" } */
+)
+#endif
+
+f( /* { dg-error "unterminated" "unterminated macro" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-4.c
new file mode 100644
index 000000000..fcc65a8d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-4.c
@@ -0,0 +1,26 @@
+/* Test that undefined names evaluate to zero, that macros after a
+   funlike macro are expanded, and that if it is a '(' the funlike
+   macro is not treated as such.  */
+
+/* { dg-do run } */
+
+extern void abort (void);
+
+#define f(x) x
+
+int main ()
+{
+#if f(1) == f /**/ (/**/1/**/)
+  int x;
+#endif
+
+  x = 0;
+  if (f
+      /**/   (
+	      /**/ 0/**/
+	      /**/)
+      )
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-5.c
new file mode 100644
index 000000000..f60a6ea78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike-5.c
@@ -0,0 +1,10 @@
+/* Test function like macro. */
+/* Contributed by Devang Patel <dpatel@apple.com> */
+
+/* {do-do preprocess } */
+/* { dg-options "-traditional-cpp -E -dD" } */
+int     __srget (char *);
+#define __sgetc(p) (--(p)->_r < 0 ? __srget(p) : (int)(*(p)->_p++))
+#define getc(fp)        __sgetc(fp)
+#define getchar()       getc(stdin)
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike.c
new file mode 100644
index 000000000..db550d53c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/funlike.c
@@ -0,0 +1,25 @@
+/* Test that undefined names evaluate to zero, that macros after a
+   funlike macro are expanded, and that if it is a '(' the funlike
+   macro is not treated as such.  */
+
+/* { dg-do preprocess } */
+
+#define f(x) x
+#define h != 0
+#define i
+#define paren (
+
+#if f != 0
+# error		/* { dg-bogus "error" "undefined name" } */
+#endif
+
+#if f h
+# error		/* { dg-bogus "error" "h not expanded" } */
+#endif
+
+#if f i
+# error		/* { dg-bogus "error" "empty macro" } */
+#endif
+
+#if f paren 6) /* { dg-error "missing binary" "macro-expanded parenthesis" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/hash.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/hash.c
new file mode 100644
index 000000000..8108c89fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/hash.c
@@ -0,0 +1,14 @@
+/* Test for erroneously thinking comments are token-pastes.
+   From XFree86 4.0.  */
+/* { dg-do preprocess } */
+
+#ifndef foo
+#define foo	/**/
+#endif
+
+#ifndef foo
+#define foo	/* as nothing */
+#endif
+
+/* { dg-bogus "(start|end) of macro" "paste at end" { target *-*-* } 7 } */
+/* { dg-bogus "(start|end) of macro" "comment at end" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/include.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/include.c
new file mode 100644
index 000000000..94d25f815
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/include.c
@@ -0,0 +1,12 @@
+/* Copyright (c) 2002 Free Software Foundation Inc.  */
+
+/* Test that macros are not expanded in the <> quotes of #inlcude.  */
+
+/* vxWorksCommon.h uses the "#" operator to construct the name of an
+   include file, thus making the file incompatible with -traditional-cpp.
+   Newlib uses ## when including stdlib.h as of 2007-09-07.  */
+/* { dg-do preprocess { target { { ! vxworks_kernel } && { ! newlib } } } } */
+
+#define __STDC__ 1		/* Stop complaints about non-ISO compilers.  */
+#define stdlib 1
+#include <stdlib.h>		/* { dg-bogus "o such file or directory" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/literals-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/literals-1.c
new file mode 100644
index 000000000..15c8030fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/literals-1.c
@@ -0,0 +1,28 @@
+/* Test that (what looks like) comments are not recognized in literals
+   and that quotes within quotes do not confused the preprocessor.  */
+
+/* { dg-do run } */
+
+extern void abort (void);
+
+int main ()
+{
+  const char *str1 = "/*";
+  const char *str2 = "'";
+
+  if (str1[0] != '/' || str1[1] != '*' || str1[2] != '\0')
+    abort ();
+
+  if (str2[0] != '\'' || str2[1] != '\0')
+    abort ();
+
+#if '"' != '\"'
+#  error /* { dg-bogus "error" "double quote in charconst" } */
+#endif
+
+#if !'\''
+#  error quote /* { dg-bogus "quote" "quote in charconst" } */
+#endif
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/literals-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/literals-2.c
new file mode 100644
index 000000000..b471772f6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/literals-2.c
@@ -0,0 +1,8 @@
+/* Test that unterminated quotes in CPP expressions are
+   recognized.  */
+
+/* { dg-do preprocess } */
+/* { dg-warning "missing terminating" "bad charconst" { target *-*-* } 7 } */
+/* { dg-error "not valid" "bad charconst" { target *-*-* } 7 } */
+#if 'x
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom1.c
new file mode 100644
index 000000000..28602a51a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom1.c
@@ -0,0 +1,13 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC -traditional-cpp" } */
+
+/* This tests to make sure that comments are ignored between # and the
+   directive name when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#/**/define def passed
+
+def
+
+/* { dg-final { scan-file maccom1.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom2.c
new file mode 100644
index 000000000..068c357c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom2.c
@@ -0,0 +1,14 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC -traditional-cpp" } */
+
+/* This tests to make sure that comments between the #define directive
+   and the macro identifier are ignored (i.e. treated like whitespace)
+   when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define/**/def passed
+
+def
+
+/* { dg-final { scan-file maccom2.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom3.c
new file mode 100644
index 000000000..a6eb3f854
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom3.c
@@ -0,0 +1,13 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC -traditional-cpp" } */
+
+/* This tests to make sure that comments in the definition of a macro
+   parameter list are ignored when the -CC option is used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define def(x /**/, y) passed
+
+def(x,y)
+
+/* { dg-final { scan-file maccom3.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom4.c
new file mode 100644
index 000000000..eac52da0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom4.c
@@ -0,0 +1,17 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC -traditional-cpp" } */
+
+/* This tests to make sure the comment is saved in the macro and copied
+   to the output file when the macro is expanded when the -CC option is
+   used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define def /* passed */
+
+def
+
+/*
+   /* The + in the regexp prevents it from matching itself.  */
+   { dg-final { scan-file maccom4.i "p+assed" } }
+*/
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom6.c
new file mode 100644
index 000000000..baf5e980d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/maccom6.c
@@ -0,0 +1,20 @@
+/* { dg-do preprocess } */
+/* { dg-options "-CC -traditional-cpp" } */
+
+/* This tests to make sure that expressions function properly
+   when used with macros containing comments and the -CC option
+   is being used.
+
+   Jason R. Thorpe, 6 Apr 2002  */
+
+#define ONE   1 /* one */
+#define TWO   2 /* two */
+#define THREE 3 /* three */
+
+#if (ONE + TWO) != THREE
+failed
+#else
+passed
+#endif
+
+/* { dg-final { scan-file maccom6.i "(^|\n)passed" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/macro.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/macro.c
new file mode 100644
index 000000000..164b4ecfe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/macro.c
@@ -0,0 +1,11 @@
+/* Test that varargs are rejected, and that we don't complain about
+   macro args in skipped blocks.  */
+
+/* { dg-do preprocess } */
+
+#define f(x) 
+#define g(x, y...)		/* { dg-error "macro parameter list" } */
+
+#if 0
+#define f(a,b)			/* { dg-bogus "passed 2 arguments" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/macroargs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/macroargs.c
new file mode 100644
index 000000000..c5f91d9f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/macroargs.c
@@ -0,0 +1,43 @@
+/* Test that whitespace in arguments is preserved, and that each
+   newline in macro arguments become a space.  */
+
+/* { dg-do run } */
+
+#define f(x, y) "x y"
+#define g(x) x
+
+extern void abort (void);
+
+void testquoting ()
+{
+  const char *str1 = f("a", "\"a\"");
+  const char *str2 = f( \t, " \t");
+
+  if (strcmp (str1, "\"a\"  \"\\\"a\\\"\""))
+    abort ();
+  if (strcmp (str2, " \t  \" \\t\""))
+    abort ();
+}
+
+int main ()
+{
+  const char *str1 = f( foo ,bar);
+  const char *str2 = f(
+foo
+,bar);
+
+  if (strcmp (str1, " foo  bar"))
+    abort ();
+
+  if (strcmp (str1, str2))
+    abort ();
+
+  /* Verify that quoted state is preserved over a newline.  */
+  if (strcmp (g /* { dg-bogus "unterminated 2" } */ ("1
+, 2"), "1 , 2"))	
+    abort ();
+
+  testquoting ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1.c
new file mode 100644
index 000000000..4004d2183
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1.c
@@ -0,0 +1,36 @@
+/* Test "ignore redundant include" facility.
+
+   We must test with C comments, and null directives, outside
+   the guard conditional; also, we test guarding with #ifndef and #if
+   !defined.  -H is used because cpp might confuse the issue by
+   optimizing out #line markers.  This test only passes if each of the
+   headers is read exactly once.
+
+   The disgusting regexp in the dg-error line, when stuck into
+   dg.exp's compiler-output regexp, matches the correct -H output and
+   only the correct -H output.  It has to be all on one line because
+   otherwise it will not be interpreted all in one unit.  */
+
+/* { dg-do compile }
+   { dg-options "-H -traditional-cpp" }
+   { dg-message "mi1c\.h\n\[^\n\]*mi1nd\.h\n\[^\n\]*mi1ndp\.h\n\[^\n\]*mi1x\.h" "redundant include check" { target *-*-* } 0 } */
+
+#include "mi1c.h"
+#include "mi1c.h"
+#include "mi1c.h"
+
+#include "mi1nd.h"
+#include "mi1nd.h"
+
+#include "mi1ndp.h"
+#include "mi1ndp.h"
+
+#define MIX_H
+#include "mi1x.h"
+#include "mi1x.h"
+
+int
+main (void)
+{
+  return a + c + d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1c.h
new file mode 100644
index 000000000..2956286eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1c.h
@@ -0,0 +1,12 @@
+/* Redundant header include test with C comments at top.  */
+# /* And a null directive at the top.  */
+
+#ifndef CPP_MIC_H
+#define CPP_MIC_H
+
+int a;
+
+#endif
+
+# /* And at the end, too!  */
+/* And at the end too!  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1nd.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1nd.h
new file mode 100644
index 000000000..c14c1a3c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1nd.h
@@ -0,0 +1,8 @@
+/* Redundant include check with #if !defined.  */
+
+#if !defined CPP_MIND_H
+#define CPP_MIND_H
+
+int c;
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1ndp.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1ndp.h
new file mode 100644
index 000000000..b84202c6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1ndp.h
@@ -0,0 +1,7 @@
+#if !defined ( CPP_MINDP_H)
+#define CPP_MINDP_H
+
+/* Redundant include check with #if !defined and parentheses.  */
+int d;
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1x.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1x.h
new file mode 100644
index 000000000..a317cf852
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi1x.h
@@ -0,0 +1,9 @@
+/* This header is never to have its contents visible, but it should
+   still receive the optimization.  */
+
+#ifndef MIX_H
+#define MIX_H
+
+#define main wibble
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2.c
new file mode 100644
index 000000000..916d5a949
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2.c
@@ -0,0 +1,12 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h.
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+/* { dg-do compile } */
+
+#include "mi2a.h"
+#include "mi2b.h"
+
+int main (void)
+{
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2a.h
new file mode 100644
index 000000000..e3f53b6cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2a.h
@@ -0,0 +1,5 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h. 
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+
+#include "mi2c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2b.h
new file mode 100644
index 000000000..1d9a8b9b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2b.h
@@ -0,0 +1,6 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h. 
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+
+#define need_x
+#include "mi2c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2c.h
new file mode 100644
index 000000000..521792bee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi2c.h
@@ -0,0 +1,15 @@
+/* Test for overly eager multiple include optimization.
+   Problem distilled from glibc 2.0.7's time.h, sys/time.h, timebits.h. 
+   Problem noted by Tom Tromey <tromey@cygnus.com>.  */
+#ifdef need_x
+#undef need_x
+#ifndef have_x
+#define have_x
+extern int x;
+#endif
+#endif
+
+#ifndef t_h
+#define t_h
+extern int y;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.c
new file mode 100644
index 000000000..f33fd7887
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.c
@@ -0,0 +1,20 @@
+/* Another test case for over-eager multiple include optimization.
+   This one distilled from glibc's setlocale.c and categories.def.  */
+/* { dg-do compile } */
+
+#define X a
+#include "mi3.def"
+#undef X
+
+#define X b
+#include "mi3.def"
+#undef X
+
+#include "mi3.h"
+#include "mi3.h"  /* The second include declares variable c.  */
+
+int
+main(void)
+{
+  return a + b + c;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.def b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.def
new file mode 100644
index 000000000..375d9c7fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.def
@@ -0,0 +1,10 @@
+/* Another test case for over-eager multiple include optimization.    
+   This one distilled from glibc's setlocale.c and categories.def.
+   The #ifdef block doesn't cover the entire file, so it must not be
+   taken for a reinclude guard.  */
+
+#ifndef NO_POSTLOAD
+#define NO_POSTLOAD NULL
+#endif
+
+int X;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.h
new file mode 100644
index 000000000..8774fcf48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi3.h
@@ -0,0 +1,7 @@
+/* Another test case for over-eager multiple include optimization. */
+
+#ifndef GUARD
+#define GUARD
+#elif 1				/* #elif kills optimisation  */
+int c;
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi4.c
new file mode 100644
index 000000000..c886cc2c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi4.c
@@ -0,0 +1,10 @@
+/* Copyright (C) 2000 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+
+/* Undefining a macro guard and re-including the file used to confuse
+   file caching in cppfiles.c, and attempt to open a bad fd.  */
+
+#include "mi1c.h"
+#undef CPP_MIC_H
+#include "mi1c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi5.c
new file mode 100644
index 000000000..ece38b5a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi5.c
@@ -0,0 +1,13 @@
+/* Test "ignore redundant include" facility, with -C on.
+
+   The disgusting regexp in the dg-error line, when stuck into
+   dg.exp's compiler-output regexp, matches the correct -H output and
+   only the correct -H output.  It has to be all on one line because
+   otherwise it will not be interpreted all in one unit.  */
+
+/* { dg-do preprocess }
+   { dg-options "-H -C -traditional-cpp" }
+   { dg-message "mi1c\.h" "redundant include check with -C" { target *-*-* } 0 } */
+
+#include "mi1c.h"
+#include "mi1c.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6.c
new file mode 100644
index 000000000..c3af2d3f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6.c
@@ -0,0 +1,61 @@
+/* Another test case for over-eager multiple include optimization,
+   where the leading "#if !defined" expression is obtained partially,
+   or wholly, from macros.  Neil Booth, 30 Sep 2001.  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern void abort (void);
+
+/* Each include file should not be subject to MI optimisation, since
+   macro definitions can change.  Each header increments the variable
+   VAR if it is defined.
+
+   The first set of inclusions gets the headers into CPP's cache, but
+   does nothing since VAR is not defined.  The second set should each
+   increment VAR, since none of the initial set should have been
+   flagged as optimizable.  */
+
+#define EMPTYL
+#define EMPTYR
+#define NOT !
+#define DEFINED defined (guard)
+#define NOT_DEFINED ! defined (guard)
+
+#include "mi6a.h"
+#include "mi6b.h"
+#include "mi6c.h"
+#include "mi6d.h"
+#include "mi6e.h"
+
+/* Define the macro guard, and redefine the macros to something that
+   forces compilation of the conditional blocks.  */
+#define guard
+#undef EMPTYL
+#define EMPTYL 1 ||
+#undef EMPTYR
+#define EMPTYR || 1
+#undef NOT
+#define NOT
+#undef DEFINED
+#define DEFINED 0
+#undef NOT_DEFINED
+#define NOT_DEFINED 1
+
+#define VAR five
+
+int
+main(void)
+{
+  unsigned int five = 0;
+
+#include "mi6a.h"
+#include "mi6b.h"
+#include "mi6c.h"
+#include "mi6d.h"
+#include "mi6e.h"
+
+  if (five != 5)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6a.h
new file mode 100644
index 000000000..68a2fce47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6a.h
@@ -0,0 +1,5 @@
+#if NOT_DEFINED
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6b.h
new file mode 100644
index 000000000..d2fe8be17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6b.h
@@ -0,0 +1,5 @@
+#if NOT defined (guard)
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6c.h
new file mode 100644
index 000000000..d19cb5433
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6c.h
@@ -0,0 +1,5 @@
+#if !DEFINED
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6d.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6d.h
new file mode 100644
index 000000000..a1eabba8e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6d.h
@@ -0,0 +1,5 @@
+#if EMPTYL !defined (guard)
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6e.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6e.h
new file mode 100644
index 000000000..26ba71514
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi6e.h
@@ -0,0 +1,5 @@
+#if !defined (guard) EMPTYR
+ #ifdef VAR
+   VAR++;
+ #endif
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7.c
new file mode 100644
index 000000000..d980586f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7.c
@@ -0,0 +1,19 @@
+/* Test "ignore redundant include" facility.
+
+   -H is used because cpp might confuse the issue by optimizing out
+   #line markers.  This test only passes if the headers is read
+   twice.
+
+   The disgusting regexp in the dg-error line, when stuck into
+   dg.exp's compiler-output regexp, matches the correct -H output and
+   only the correct -H output.  It has to be all on one line because
+   otherwise it will not be interpreted all in one unit.  */
+
+/* { dg-do preprocess }
+   { dg-options "-H -traditional-cpp" }
+   { dg-message "mi7a\.h\n\[^\n\]*mi7a\.h\n\[^\n\]*mi7b\.h\n\[^\n\]*mi7b\.h" "redundant include check" { target *-*-* } 0 } */
+
+#include "mi7a.h"
+#include "mi7a.h"
+#include "mi7b.h"
+#include "mi7b.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7a.h
new file mode 100644
index 000000000..0c701d7e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7a.h
@@ -0,0 +1,4 @@
+:
+#ifndef GUARD1
+#define GUARD1
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7b.h
new file mode 100644
index 000000000..1747e5482
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/mi7b.h
@@ -0,0 +1,4 @@
+#ifndef GUARD2
+#define GUARD2
+#endif
+:
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/null-drctv.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/null-drctv.c
new file mode 100644
index 000000000..99fd251f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/null-drctv.c
@@ -0,0 +1,6 @@
+/* Test that the null directive doesn't swallow the following line.  */
+
+/* { dg-do preprocess } */
+
+#
+#error OK	/* { dg-error "OK" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/num-sign.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/num-sign.c
new file mode 100644
index 000000000..64f12c072
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/num-sign.c
@@ -0,0 +1,16 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+/* Tests that traditional numbers are signed, unless otherwise
+   specified.  This test assumes a 32 bit target.
+
+   Neil Booth, 5 Aug 2001.  Inspired by PR 3824.  */
+
+#if 0xffffffffffffffff >= 0
+# error	0xffffffffffffffff /* { dg-bogus "0xffffffffffffffff" "0xffffffffffffffff positive" } */
+#endif
+
+#if 0xffffffffffffffffU <= 0
+# error	0xffffffffffffffffU	/* { dg-bogus "0xffffffffffffffffU" "0xffffffffffffffffU negative" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/paste.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/paste.c
new file mode 100644
index 000000000..9b83fd30f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/paste.c
@@ -0,0 +1,18 @@
+/* Test for proper comment elimination semantics from cpplib's -traditional.
+   This should compile and link with compiled with `gcc -traditional-cpp'.
+   Test case by Jason R. Thorpe <thorpej@zembu.com>.  */
+
+/* { dg-do compile } */
+
+extern int printf (const char *, ...);
+
+#define A(name) X/**/name
+
+#define B(name) \
+void A(Y/**/name)() { A(name)(); }
+
+void Xhello() { printf("hello world\n"); }
+
+B(hello)
+
+int main() { XYhello(); return (0); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/quote.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/quote.c
new file mode 100644
index 000000000..f8e61700f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/quote.c
@@ -0,0 +1,6 @@
+/* Test that unterminated quotes are OK when only preprocessing.  */
+
+/* { dg-do preprocess } */
+
+/* { dg-bogus "unterminated" } */  'x
+/* { dg-bogus "unterminated" } */  "x
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-1.c
new file mode 100644
index 000000000..b5fd7af7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-1.c
@@ -0,0 +1,10 @@
+/* Test for warning of and recovery from recursion in object-like
+   macros.  */
+
+/* { dg-do preprocess } */
+
+#define foo foo
+foo				/* { dg-error "detected recursion" } */
+
+#define bar a bar b
+bar				/* { dg-error "detected recursion" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-2.c
new file mode 100644
index 000000000..5c6550fae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-2.c
@@ -0,0 +1,16 @@
+/* Test for warning of and recovery from recursion in function-like
+   macros.  */
+
+/* { dg-do preprocess } */
+
+#define foo() foo()
+foo();				/* { dg-error "detected recursion" } */
+
+#define bar() bar baz() bar
+bar();				/* { dg-bogus "detected recursion" } */
+
+#define baz() foo()
+baz();			       /* { dg-error "detected recursion" } */
+
+#define a(x) x(a)
+a(a);			       /* { dg-error "detected recursion" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-3.c
new file mode 100644
index 000000000..91485ae5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/recurse-3.c
@@ -0,0 +1,25 @@
+/* Tests that macros that look recursive but are not are accepted.  */
+
+/* { dg-do preprocess } */
+
+#define g(x) x
+g(g(g(g(g(g(g))))));	       /* { dg-bogus "detected recursion" } */
+
+/* This macro gets longer with each loop, to thwart tests for
+   recursion based on length.  */
+#define f(a,b,c,d,e,f,g,h,i) a(b,c,d,e,f,g,h,i,2 3 4 5)
+f(f,f,f,f,f,f,f,f,f)	       /* { dg-bogus "detected recursion" } */
+
+/* The above cases should be enough, but this is taken from cccp
+   sources so let's try it too.  */
+#define foo(x,y) bar (x (y,0), y)
+foo (foo, baz);	       /* { dg-bogus "detected recursion" } */
+
+#define mac mac/**/ro
+mac		       /* { dg-bogus "detected recursion" } */
+
+#define mac2 mac2
+"mac2" 		       /* { dg-bogus "detected recursion" } */
+
+#define macro "macro
+macro mac2	       /* { dg-bogus "detected recursion" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/redef1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/redef1.c
new file mode 100644
index 000000000..ce5dde0bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/redef1.c
@@ -0,0 +1,36 @@
+/* Test for redefining traditional macros with insignificant
+   (i.e. whitespace) differences.  */
+
+/* { dg-do preprocess } */
+
+
+#define foo bar
+#define /* x */ foo /* x */ bar /* x */
+
+#define quux(thud) a one and a thud and a two
+#define /**/ quux( thud ) /**/ a one and a /**/ thud /**/ and /**/ a two
+#define quux(thud) a one	and a thud and a 	two /* bah */
+
+#define f(x, y)x "x  y z"  y
+#define f(x, y) x  "x  y z" y
+
+#define baz() whiz bang
+#define baz() whiz  bang
+
+#define g foo
+#undef g
+#define g
+
+/* { dg-bogus "redefined" "foo redefined"	{ target *-*-* } 8 } */
+/* { dg-bogus "redefined" "quux redefined"	{ target *-*-* } 11 } */
+/* { dg-bogus "redefined" "quux redefined"	{ target *-*-* } 12 } */
+/* { dg-bogus "redefined" "f redefined"		{ target *-*-* } 15 } */
+/* { dg-bogus "redefined" "baz redefined"	{ target *-*-* } 18 } */
+/* { dg-bogus "redefined" "g redefined"		{ target *-*-* } 22 } */
+
+/* { dg-bogus "previous def" "foo prev def"	{ target *-*-* } 7 } */
+/* { dg-bogus "previous def" "quux prev def"	{ target *-*-* } 10 } */
+/* { dg-bogus "previous def" "quux prev def"	{ target *-*-* } 11 } */
+/* { dg-bogus "previous def" "f prev def"	{ target *-*-* } 14 } */
+/* { dg-bogus "previous def" "baz prev def"	{ target *-*-* } 17 } */
+/* { dg-bogus "previous def" "g prev def"	{ target *-*-* } 20 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/redef2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/redef2.c
new file mode 100644
index 000000000..269a84626
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/redef2.c
@@ -0,0 +1,32 @@
+/* Test for redefining traditional macros with significant differences.  */
+
+/* { dg-do preprocess } */
+
+#define foo bar    /* { dg-warning "previous def" "foo prev def" } */
+#define foo barr   /* { dg-warning "redefined" "foo redefined" } */
+
+#undef foo
+#define foo bar    /* { dg-warning "previous def" "foo prev def 2" } */
+#define foo() bar    /* { dg-warning "redefined" "foo redefined 2" } */
+
+#undef foo
+#define foo() bar    /* { dg-warning "previous def" "foo prev def" } */
+#define foo() barr   /* { dg-warning "redefined" "foo redefined" } */
+
+#define quux(thud) a thud b /* { dg-warning "previous def" "quux prev def" } */
+#define quux(thu) a thud b   /* { dg-warning "redefined" "quux redefined" } */
+
+#define bar(x, y) x+y /* { dg-warning "previous def" "bar prev def" } */
+#define bar(x, y) x+x   /* { dg-warning "redefined" "bar redefined" } */
+
+#define bat(x, y) x+y  /* { dg-warning "previous def" "bat prev def" } */
+#define bat(x, y) x+ y   /* { dg-warning "redefined" "bat redefined" } */
+
+#define baz(x, y) x+y  /* { dg-warning "previous def" "baz prev def" } */
+#define baz(x, y) x +y   /* { dg-warning "redefined" "baz redefined" } */
+
+#define f(x, y) "x y"  /* { dg-warning "previous def" "f prev def" } */
+#define f(x, y) "x  y"   /* { dg-warning "redefined" "f redefined" } */
+
+#define g(x, y) 'x'  /* { dg-warning "previous def" "g prev def" } */
+#define g(x, y) ' x'   /* { dg-warning "redefined" "g redefined" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/strify.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/strify.c
new file mode 100644
index 000000000..d97a43970
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/strify.c
@@ -0,0 +1,18 @@
+/* Test whether traditional stringify works.  */
+/* { dg-do run } */
+
+#define foo(a, b) c="a"; d="b";
+
+extern void abort ();
+extern void exit (int);
+
+int main ()
+{
+  char *c, *d;
+
+  foo (p,q);
+  if (c[0] != 'p' || d[0] != 'q')
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/trad.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/trad.exp
new file mode 100644
index 000000000..22225e519
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/trad.exp
@@ -0,0 +1,43 @@
+#   Copyright (C) 1997, 2000, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# There's a bunch of headers we need.
+if [is_remote host] {
+    foreach header [glob -nocomplain $srcdir/$subdir/*.{h,def} ] {
+	remote_download host $header
+    }
+}
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# If a testcase doesn't have special options, use these.
+global DEFAULT_TRADCPPFLAGS
+if ![info exists DEFAULT_TRADCPPFLAGS] then {
+    set DEFAULT_TRADCPPFLAGS " -traditional-cpp"
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] \
+	"-fno-show-column" $DEFAULT_TRADCPPFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/uchar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/uchar.c
new file mode 100644
index 000000000..8ea54a1f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/uchar.c
@@ -0,0 +1,8 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-funsigned-char -fsigned-char -traditional-cpp" } */
+
+#if defined (__CHAR_UNSIGNED__)
+# error __CHAR_UNSIGNED__ defined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/xwin1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/xwin1.c
new file mode 100644
index 000000000..21220d1db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trad/xwin1.c
@@ -0,0 +1,13 @@
+/* XWindows (as of 4.3) does some pretty strange things with cpp.
+   This tests one of them; the leading comments are supposed to be
+   eaten by the preprocessor; but the 'directives' after them are
+   supposed to be retained as text, not processed, so that imake's cpp
+   can be run on the output!
+   { dg-do preprocess }
+*/
+
+/**/#if 0
+passed
+/**/#endif
+
+/* { dg-final { scan-file xwin1.i "(^|\n)#if 0" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trigraphs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trigraphs.c
new file mode 100644
index 000000000..3ec5ed721
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/trigraphs.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-ansi" } */
+
+extern void abort (void);
+
+/* Basic tests for trigraph conversion.
+   All of them are here, but not in all possible contexts.  *??/
+/
+
+??=include <stdio.h>
+
+??=define TWELVE 1??/
+2
+
+static const char str??(??) = "0123456789??/n";
+
+int
+main(void)
+??<
+  unsigned char x = 5;
+
+  if (sizeof str != TWELVE)
+    abort ();
+
+  /* Test ^=, the only multi-character token to come from trigraphs.  */
+  x ??'= 3;
+  if (x != 6)
+    abort ();
+
+  if ((5 ??! 3) != 7)
+    abort ();
+
+  return 0;
+??>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/uchar-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/uchar-1.c
new file mode 100644
index 000000000..3483e3281
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/uchar-1.c
@@ -0,0 +1,8 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-funsigned-char -fsigned-char" } */
+
+#if defined (__CHAR_UNSIGNED__)
+# error __CHAR_UNSIGNED__ defined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/uchar-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/uchar-3.c
new file mode 100644
index 000000000..41b987f5c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/uchar-3.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-funsigned-char -fpreprocessed" } */
+
+/* Source: Ziemowit Laski.  -fpreprocessed doesn't define macros, but
+   CPP would interpret charconsts based upon whether __CHAR_UNSIGNED__
+   was defined.  */
+
+int foo()
+{
+  char f = 0x83;
+  if (f == '\x83')		/* { dg-bogus "always false" } */
+    f = 0;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-1.c
new file mode 100644
index 000000000..3fad08831
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-1.c
@@ -0,0 +1,26 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+void abort (void);
+
+#define \u00C0 1
+#define \u00C1 2
+#define \U000000C2 3
+#define wh\u00ff 4
+#define a\u00c4b\u0441\U000003b4e 5
+
+int main (void)
+{
+  
+  if (\u00C0 != 1)
+    abort ();
+  if (\u00c1 != 2)
+    abort ();
+  if (\u00C2 != 3)
+    abort ();
+  if (wh\u00ff != 4)
+    abort ();
+  if (a\u00c4b\u0441\U000003b4e != 5)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-2.c
new file mode 100644
index 000000000..6719c783f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-2.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+#include <stdlib.h>
+#include <string.h>
+
+#define str(t) #t
+
+int main (void)
+{
+  const char s[] = str (\u30b2);
+
+  if (strcmp (s, "\u30b2") != 0)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-3.c
new file mode 100644
index 000000000..6389b7ebf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-3.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+
+#define paste(x, y) x ## y
+
+int paste(\u00aa, \u0531) = 3;
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-4.c
new file mode 100644
index 000000000..6a6699b94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-4.c
@@ -0,0 +1,17 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+
+\u00AA
+\u00AB /* { dg-error "not valid in an identifier" } */
+\u00B6 /* { dg-error "not valid in an identifier" } */
+\u00BA
+\u00C0
+\u00D6
+\u0384
+
+\u0669 /* { dg-error "not valid at the start of an identifier" } */
+A\u0669
+0\u00BA
+0\u0669
+\u0E59 /* { dg-error "not valid at the start of an identifier" } */
+A\u0E59
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-5.c
new file mode 100644
index 000000000..cdccd3cdf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-5.c
@@ -0,0 +1,17 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99 -pedantic -fextended-identifiers" } */
+
+\u00AA
+\u00AB /* { dg-error "not valid in an identifier" } */
+\u00B6 /* { dg-error "not valid in an identifier" } */
+\u00BA
+\u00C0
+\u00D6
+\u0384 /* { dg-error "not valid in an identifier" } */
+
+\u0669 /* { dg-error "not valid at the start of an identifier" } */
+A\u0669
+0\u00BA
+0\u0669
+\u0E59 /* { dg-error "not valid at the start of an identifier" } */
+A\u0E59
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-6.c
new file mode 100644
index 000000000..9ee0858dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-6.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+#define a b(
+#define b(x) q
+int a\u00aa);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-7.c
new file mode 100644
index 000000000..93404225d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-7.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+#define a b(
+#define b(x) q
+int a\U0000000z );
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-8.c
new file mode 100644
index 000000000..1f0379a5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucnid-8.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+/* Test that -std=c99 does not enable extended identifiers while the
+   feature is experimental; remove this test after audit of all
+   identifier uses in the compiler.  */
+#define a b(
+#define b(x) q
+int a\u00aa);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucs.c
new file mode 100644
index 000000000..3f3d97edf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/ucs.c
@@ -0,0 +1,67 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* This tests universal character sequences.
+
+   Neil Booth, 22 May 2001.
+   Richard Henderson, 3 Apr 2002.  */
+
+#include <limits.h>
+
+#define unsigned        +0
+#define int             +0 
+#define char            +1
+#define short           +2 
+#define long            +3
+
+#if __WCHAR_TYPE__ == 0
+# define WCHAR_MAX      INT_MAX
+#elif __WCHAR_TYPE__ == 1
+# define WCHAR_MAX      CHAR_MAX
+#elif __WCHAR_TYPE__ == 2
+# define WCHAR_MAX      SHRT_MAX
+#elif __WCHAR_TYPE__ == 3
+# define WCHAR_MAX      LONG_MAX
+#else
+# error wacky wchar_t
+#endif
+
+#undef unsigned
+#undef int
+#undef char
+#undef short
+#undef long
+
+#if L'\u1234' != 0x1234
+#error bad short ucs	/* { dg-bogus "bad" "bad u1234 evaluation" } */
+#endif
+
+#if WCHAR_MAX >= 0x7ffffff
+# if L'\U1234abcd' != 0x1234abcd
+#  error bad long ucs	/* { dg-bogus "bad" "bad U1234abcd evaluation" } */
+# endif
+#endif
+
+void foo ()
+{
+  int c;
+
+  c = L'\ubad';		/* { dg-error "incomplete" "incomplete UCN 1" } */
+  c = L"\U1234"[0];	/* { dg-error "incomplete" "incompete UCN 2" } */
+
+  c = L'\u000x';	/* { dg-error "incomplete" "non-hex digit in UCN" } */
+  /* If sizeof(HOST_WIDE_INT) > sizeof(wchar_t), we can get a multi-character
+     constant warning even for wide characters.  */
+  /* { dg-warning "too long|multi-character" "" { target *-*-* } 54 } */
+
+  c = '\u0024';		/* { dg-bogus "invalid" "0024 is a valid UCN" } */
+  c = "\u0040"[0];	/* { dg-bogus "invalid" "0040 is a valid UCN" } */
+  c = L'\u00a0';	/* { dg-bogus "invalid" "00a0 is a valid UCN" } */
+  c = '\U00000060';	/* { dg-bogus "invalid" "0060 is a valid UCN" } */
+
+  c = '\u0025';		/* { dg-error "not a valid" "0025 invalid UCN" } */
+  c = L"\uD800"[0];	/* { dg-error "not a valid" "D800 invalid UCN" } */
+  c = L'\U0000DFFF';	/* { dg-error "not a valid" "DFFF invalid UCN" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc1.c
new file mode 100644
index 000000000..18c306fc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc1.c
@@ -0,0 +1,14 @@
+/* Tests for un-terminated conditionals: 1.  */
+/* { dg-do preprocess } */
+
+#if 1  /* { dg-error "unterminated" "unterminated #if" } */
+
+#ifdef notdef /* { dg-bogus "unterminated" "nested terminated #ifdef" } */
+
+blah blah blah
+
+#endif
+
+more text
+
+/* oops! */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc2.c
new file mode 100644
index 000000000..976d2b181
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc2.c
@@ -0,0 +1,12 @@
+/* Tests for unterminated conditionals: 2.  */
+/* { dg-do preprocess } */
+
+#ifdef __sparc__  /* { dg-error "unterminated" "unterminated if-elif-elif..." } */
+sparc
+#elif defined __powerpc__
+ppc
+#elif defined __i386__
+i386
+#elif defined __vax__
+vax
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc3.c
new file mode 100644
index 000000000..d5f16f738
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc3.c
@@ -0,0 +1,5 @@
+/* Tests for unterminated conditionals: 3.  */
+/* { dg-do preprocess } */
+
+#if 1  /* { dg-error "#else" "unterminated #else" } */
+#else
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc4.c
new file mode 100644
index 000000000..758e5bbc6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/unc4.c
@@ -0,0 +1,40 @@
+/* { dg-do preprocess } */
+/* { dg-options "-fno-show-column" } */
+
+/* Tests for un-terminated conditional diagnostics.
+   Copyright (c) 1999 Free Software Foundation.
+   Contributed by Zack Weinberg, who made it up all by himself.  */
+
+#endif /* { dg-error "#endif" "#endif without #if" } */
+
+#else  /* { dg-error "#else" "#else without #if" } */
+#endif /* { dg-error "#endif" "#endif after #else without #if" } */
+
+#elif 0 /* { dg-error "#elif" "#elif without #if" } */
+#endif  /* { dg-error "#endif" "#endif after #else without #if" } */
+
+#if 1  /* { dg-bogus "unterminated" "terminated true conditional" } */
+blah
+#endif
+
+#if 0  /* { dg-bogus "unterminated" "terminated false conditional" } */
+ignored
+#endif
+
+/* We shouldn't see unbalanced conditionals inside #if'ed out #includes.  */
+#if 0
+#include "unc1.c"
+#endif
+
+/* The ifdef below should not get an error just because there's a bad if
+   inside the included file.  
+   The odd dg-error tag on the include matches the "In file included from"
+   message.  */
+#define FOO
+#ifdef FOO  /* { dg-bogus "unterminated" "nested unterm" } */
+#include "unc1.c"  /* { dg-message "file included from" "" { target *-*-* } 0 } */
+#endif
+
+/* dg.exp doesn't read the included files for tags, so we have to
+   do them explicitly here.  */
+/* { dg-error "#if" "unc1.c: unterminated #if" { target *-*-* } 4 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/undef2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/undef2.c
new file mode 100644
index 000000000..4e6a690dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/undef2.c
@@ -0,0 +1,25 @@
+/* C99 6.10.8 para 4: None of [the predefined macro names] shall be
+   the subject of a #define or an #undef preprocessing directive.  We
+   pass -fno-show-column as otherwise dejagnu gets confused.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-fno-show-column" } */
+
+#undef __DATE__		/* { dg-warning "undefining" "__DATE__" } */
+#undef __TIME__		/* { dg-warning "undefining" "__TIME__" } */
+#undef __FILE__		/* { dg-warning "undefining" "__FILE__" } */
+#undef __LINE__		/* { dg-warning "undefining" "__LINE__" } */
+#undef __STDC__		/* { dg-warning "undefining" "__STDC__" } */
+
+/* These should be protected from #undef, but aren't, because they
+   are set with normal #define commands - and on top of that, some
+   of them are library properties, outside our control.  To consider:
+   warn about undefining/redefining any identifier beginning with
+   __STDC_ .
+
+   __STDC_HOSTED__
+   __STDC_VERSION__
+   __STDC_IEC_559__
+   __STDC_IEC_559_COMPLEX__
+   __STDC_ISO_10646__
+ */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/usr/include/stdio.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/usr/include/stdio.h
new file mode 100644
index 000000000..c674e89f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/usr/include/stdio.h
@@ -0,0 +1,4 @@
+/* Used by gcc.dg/cpp/isysroot-1.c to test isysroot.  */
+void foo()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg1.c
new file mode 100644
index 000000000..38bf56bd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg1.c
@@ -0,0 +1,26 @@
+/* { dg-do run } */
+/* { dg-options -w } */
+
+/* count() used to give 1 owing to a buggy test for varargs.  */
+#define count(y...)  count1 ( , ##y)
+#define count1(y...) count2 (y,1,0)
+#define count2(_,x0,n,y...) n
+#if count() != 0 || count(A) != 1
+#error Incorrect vararg argument counts
+#endif
+
+/* Test for changed behavior of the GNU varargs extension.
+   ##args, where args is a rest argument which received zero tokens,
+   used to delete the previous sequence of nonwhitespace characters.
+   Now it deletes the previous token.  */
+
+#include <string.h>
+
+#define S(str, args...) "  " str "\n", ##args
+
+int
+main()
+{
+  const char *s = S("foo");
+  return strchr (s, '\n') == NULL;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg2.c
new file mode 100644
index 000000000..2b2b0335c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg2.c
@@ -0,0 +1,131 @@
+/* { dg-do preprocess } */
+/* { dg-options "-std=gnu99" } */
+
+/* Jamie's varargs macros from hell.  Not for the faint of heart.
+   Great tests that C99 and GNU varargs give identical results.
+   Adapted to the testsuite by Neil Booth, 1 Nov 2000.  */
+
+/* Permission is granted to use, copy, modify and distribute this file
+   freely for any purpose whatsoever.  This file is free software, and
+   there's no warranty.
+
+   -- Jamie Lokier <jamie.lokier@cern.ch>, 25/Sep/2000.  */
+
+#define dup3(x)            x,x,x
+
+/* Count elements in a list (0 to 10 max). */
+#define gnu_count(y...)   _gnu_count1 ( , ##y)
+#define _gnu_count1(y...) _gnu_count2 (y,10,9,8,7,6,5,4,3,2,1,0)
+#define _gnu_count2(_,x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,n,ys...) n
+
+/* Tail of a list. */
+#define gnu_tail(y...)    _gnu_tail (y)
+#define _gnu_tail(x,y...) y
+
+/* Repeat N times. */
+#define gnu_repeat(n, x) gnu_tail (_gnu_repeat (n, x))
+#define _gnu_repeat(n, x) _gnu_repeat_##n (x)
+#define _gnu_repeat_0(x)
+#define _gnu_repeat_1(x) ,x
+#define _gnu_repeat_2(x) ,x,x
+#define _gnu_repeat_3(x) ,x,x,x
+#define _gnu_repeat_4(x) ,x,x,x,x
+#define _gnu_repeat_5(x) ,x,x,x,x,x
+
+#define _gnu_keep(xs...) xs
+#define _gnu_discard(xs...)
+#define _gnu_split_r(n,xs...) _gnu_split_rd (n,_gnu_keep,_gnu_discard xs)
+#define _gnu_split_d(n,xs...) _gnu_split_rd (n,_gnu_discard,_gnu_keep xs)
+#define _gnu_split_rd(n,xs...) _gnu_split_##n (xs)
+#define _gnu_split_0(a,b,xs...) a() b(xs)
+#define _gnu_split_1(a,b,x0,xs...) a(x0) b(xs)
+#define _gnu_split_2(a,b,x0,x1,xs...) a(x0,x1) b(xs)
+#define _gnu_split_3(a,b,x0,x1,x2,xs...) a(x0,x1,x2) b(xs)
+#define _gnu_split_4(a,b,x0,x1,x2,x3,xs...) a(x0,x1,x2,x3) b(xs)
+#define _gnu_split_5(a,b,x0,x1,x2,x3,x4,xs...) a(x0,x1,x2,x3,x4) b(xs)
+
+/* List manipulations.  Surprise: index zero is the rightmost element. */
+#define gnu_take(n, xs...) \
+  _gnu_split_d (_gnu_count1 ( , ## xs), _gnu_repeat (n, _gnu_error) , ## xs)
+#define gnu_drop(n, xs...) \
+  _gnu_split_d (n,,_gnu_split_r  (_gnu_count1 ( , ## xs), _gnu_repeat (n, _gnu_error) , ## xs))
+#define gnu_index(pos, xs...) gnu_take (1, gnu_drop (pos , ## xs))
+
+/* C99 __VA_ARGS__ versions */
+#define c99_count(...)    _c99_count1 ( , ##__VA_ARGS__)/* If only ## worked.*/
+#define _c99_count1(...)  _c99_count2 (__VA_ARGS__,10,9,8,7,6,5,4,3,2,1,0)
+#define _c99_count2(_,x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,n,...) n
+
+#define c99_tail(...)     _c99_tail (__VA_ARGS__)
+#define _c99_tail(x,...)  __VA_ARGS__
+
+/* Repeat N times. */
+#define c99_repeat(n, x) c99_tail (_c99_repeat (n, x))
+#define _c99_repeat(n, x) _c99_repeat_##n (x)
+#define _c99_repeat_0(x)
+#define _c99_repeat_1(x) ,x
+#define _c99_repeat_2(x) ,x,x
+#define _c99_repeat_3(x) ,x,x,x
+#define _c99_repeat_4(x) ,x,x,x,x
+#define _c99_repeat_5(x) ,x,x,x,x,x
+
+#define _c99_keep(...)    __VA_ARGS__
+#define _c99_discard(...)
+#define _c99_split_r(n,...) _c99_split_rd(n,_c99_keep,_c99_discard __VA_ARGS__)
+#define _c99_split_d(n,...) _c99_split_rd(n,_c99_discard,_c99_keep __VA_ARGS__)
+#define _c99_split_rd(n,...) _c99_split_##n (__VA_ARGS__)
+#define _c99_split_0(a,b,...) a() b(__VA_ARGS__)
+#define _c99_split_1(a,b,x0,...) a(x0) b(__VA_ARGS__)
+#define _c99_split_2(a,b,x0,x1,...) a(x0,x1) b(__VA_ARGS__)
+#define _c99_split_3(a,b,x0,x1,x2,...) a(x0,x1,x2) b(__VA_ARGS__)
+#define _c99_split_4(a,b,x0,x1,x2,x3,...) a(x0,x1,x2,x3) b(__VA_ARGS__)
+#define _c99_split_5(a,b,x0,x1,x2,x3,x4,...) a(x0,x1,x2,x3,x4) b(__VA_ARGS__)
+
+/* List manipulations.  Surprise: index zero is the rightmost element. */
+#define c99_take(n, ...) \
+  _c99_split_d (_c99_count1 ( , ## __VA_ARGS__), _c99_repeat (n, _c99_error) , ## __VA_ARGS__)
+#define c99_drop(n, ...) \
+  _c99_split_d (n,,_c99_split_r  (_c99_count1 ( , ## __VA_ARGS__), _c99_repeat (n, _c99_error) , ## __VA_ARGS__))
+#define c99_index(pos, ...) c99_take (1, c99_drop (pos , ## __VA_ARGS__))
+
+/************** Expansions **************/
+
+/* Correct answers are 0, 0, 1, 2, 10.  */
+#if _gnu_count1 () != 0 || gnu_count () != 0 || gnu_count (A) != 1 \
+    || gnu_count (,) != 2 || gnu_count (A, B, C, D, E, F, G, H, I, J) != 10
+#error gnu_count
+#endif
+
+/* Correct answers are empty, 'x'.  */
+#if gnu_repeat (0, 'x') gnu_repeat (1, 'x') != 'x'
+#error gnu_repeat
+#endif
+
+/* Correct answers are "e", "b", "a", empty.  */
+#if gnu_index (0, 'a', 'b', 'c', 'd', 'e') != 'e' \
+ || gnu_index (3, 'a', 'b', 'c', 'd', 'e') != 'b' \
+ || gnu_index (4, 'a', 'b', 'c', 'd', 'e') != 'a' \
+    gnu_index (5, 'a', 'b', 'c', 'd', 'e')
+#error gnu_index
+#endif
+
+/************* C99 tests *************/
+
+/* The answers are 0, 0, 1, 2, 10 as for the non-C99 version.  */
+#if _c99_count1 () != 0 || c99_count () != 0 || c99_count (A) != 1 \
+    || c99_count (,) != 2 || c99_count (A, B, C, D, E, F, G, H, I, J) != 10
+#error c99_count
+#endif
+
+/* Correct answers are empty, 'x'.  */
+#if c99_repeat (0, 'x') c99_repeat (1, 'x') != 'x'
+#error c99_repeat
+#endif
+
+/* Correct answers are "e", "b", "a", empty.  */
+#if c99_index (0, 'a', 'b', 'c', 'd', 'e') != 'e' \
+ || c99_index (3, 'a', 'b', 'c', 'd', 'e') != 'b' \
+ || c99_index (4, 'a', 'b', 'c', 'd', 'e') != 'a' \
+    c99_index (5, 'a', 'b', 'c', 'd', 'e')
+#error gnu_index
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg3.c
new file mode 100644
index 000000000..b17afd89e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg3.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options "-std=c99" } */
+
+/* Source: Neil Booth, 6 Aug 2002.
+
+   Tests that we DTRT with varargs commas for a single-parameter macro
+   when in standards-conforming mode.  */
+
+#define f(...) , ## __VA_ARGS__
+
+/* The comma from f's expansion should be retained (standards
+   conforming mode only).  Tests that it isn't in non-standards mode
+   include macro8.c and vararg1.c.  */
+#if 2 f() 3		  /* { dg-bogus "missing binary operator" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg4.c
new file mode 100644
index 000000000..460cebf28
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/vararg4.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do preprocess } */
+/* { dg-options -std=gnu99 } */
+
+/* Source: Neil Booth, 6 Aug 2002.
+
+   Tests that we DTRT with varargs commas.  */
+
+#define g(a, ...) a , ## __VA_ARGS__
+
+/* The comma from g's expansion should be retained.  */
+#if g (2, ) 3		  /* { dg-bogus "missing binary operator" } */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/very-long-comment.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/very-long-comment.c
new file mode 100644
index 000000000..88d8eb936
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/very-long-comment.c
@@ -0,0 +1,14 @@
+/*
+This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment. This is a really long comment.
+ */
+/* This testcase for PR 20907 is a bit finicky about the placement of
+   comment so avoid editing the text above here. */
+/* { dg-options "-Wall" } */
+/* { dg-do compile } */
+#warning test warning /* { dg-warning "test warning" } */
+#include <stdio.h>
+int main()
+{
+  printf("This is line %d\n", __LINE__);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/wchar-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/wchar-1.c
new file mode 100644
index 000000000..ac9b38b80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/wchar-1.c
@@ -0,0 +1,24 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-w" } */
+
+/* Source: Neil Booth, 24 Feb 2002.
+
+   Test if compiler and preprocessor agree on signeness of wide
+   chars.  */
+
+int main ()
+{
+  __WCHAR_TYPE__ c = -1;
+
+#if L'\x0' - 1 < 0
+  if (c > 0)
+    abort ();
+#else
+  if (c < 0)
+    abort ();
+#endif
+ 
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/widestr1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/widestr1.c
new file mode 100644
index 000000000..0b68201b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/cpp/widestr1.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2000, 2001  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do preprocess } */
+
+#line 1 L"foo" /* { dg-error "not a valid filename" "wide string in #line" } */
+#include L"stdio.h" /* { dg-error "expects" "wide string in #include" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ctor1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ctor1.c
new file mode 100644
index 000000000..6c1cd72cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ctor1.c
@@ -0,0 +1,10 @@
+/* Related to PR c++/38410.
+   We shouldn't write out a static variable for an all-zero aggregate
+   initializer.  The variable named C.0 was created by
+   gimplify_init_constructor. */
+/* { dg-final { scan-assembler-not "C\\.0" } } */
+
+int main()
+{
+  int a[] = { 0,0 };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-20040809-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-20040809-2.c
new file mode 100644
index 000000000..a38f75f26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-20040809-2.c
@@ -0,0 +1,15 @@
+/* Test dead code strip support.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-gstabs+ -fno-eliminate-unused-debug-symbols" } */
+
+int
+main ()
+{
+  return 0;
+}
+
+/* { dg-final { scan-assembler ".stabd.46,0,0" } } */
+/* { dg-final { scan-assembler ".stabd.78,0,0" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-20040812-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-20040812-1.c
new file mode 100644
index 000000000..4ae8657ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-20040812-1.c
@@ -0,0 +1,24 @@
+/* Test dead code strip support.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+ 
+/* { dg-do compile { target *-*-darwin* } } */
+
+const char my_version_string[] __attribute__((__used__))
+  = "Do not remove this string\n";
+ 
+ static int
+ __attribute__((__used__))
+      static_debug_routine()
+{
+   int i;
+   i = 42;
+}
+ 
+int
+main ()
+{
+   return 0;
+}
+ 
+/* { dg-final { scan-assembler ".no_dead_strip _my_version_string" } } */
+/* { dg-final { scan-assembler ".no_dead_strip _static_debug_routine" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-comm.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-comm.c
new file mode 100644
index 000000000..8c8619c87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-comm.c
@@ -0,0 +1,4 @@
+/* { dg-do compile { target *-*-darwin[912]* } } */
+/* { dg-final { scan-assembler ".comm _foo,1,15" } } */
+
+char foo __attribute__ ((aligned(32768)));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-1.c
new file mode 100644
index 000000000..60761577e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-1.c
@@ -0,0 +1,11 @@
+/* Test Darwin linker option -all_load.  */
+/* Developed by Devang Patel <dpatel@apple.com>.  */
+
+/* { dg-options "-all_load" } */
+/* { dg-do link { target *-*-darwin* } } */
+
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-2.c
new file mode 100644
index 000000000..5de19524f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-2.c
@@ -0,0 +1,11 @@
+/* Test Darwin linker option -bind_at_load.  */
+/* Developed by Devang Patel <dpatel@apple.com>.  */
+
+/* { dg-options "-bind_at_load" } */
+/* { dg-do link { target *-*-darwin* } } */
+
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040809-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040809-1.c
new file mode 100644
index 000000000..c54a4aa0c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040809-1.c
@@ -0,0 +1,13 @@
+/* Test -dead_strip support.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-dead_strip" } */
+
+
+int
+main ()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040809-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040809-2.c
new file mode 100644
index 000000000..73d788db0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040809-2.c
@@ -0,0 +1,12 @@
+/* Test -no_dead_strip_inits_and_terms support. */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-no_dead_strip_inits_and_terms" } */
+
+int
+main ()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-1.c
new file mode 100644
index 000000000..b90328be9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-1.c
@@ -0,0 +1,13 @@
+/* Test -segaddr.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-segaddr __DATA 4000" } */
+
+
+int
+main ()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-2.c
new file mode 100644
index 000000000..51f5ae830
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-2.c
@@ -0,0 +1,13 @@
+/* Test -segs_read_only_addr.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-segs_read_only_addr 4000 -dynamiclib" } */
+
+
+int
+main ()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-3.c
new file mode 100644
index 000000000..ca8928bd8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-20040828-3.c
@@ -0,0 +1,13 @@
+/* Test -segs_read_write_addr.  */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-segs_read_only_addr 4000 -segs_read_write_addr 8000 -dynamiclib" } */
+
+
+int
+main ()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-3.c
new file mode 100644
index 000000000..e3efacaba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-3.c
@@ -0,0 +1,12 @@
+
+/* Test Darwin linker option -arch_errors_fatal.  */
+/* Developed by Devang Patel <dpatel@apple.com>.  */
+
+/* { dg-options "-arch_errors_fatal" } */
+/* { dg-do link { target *-*-darwin* } } */
+
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-4.c
new file mode 100644
index 000000000..5cac36ccf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-4.c
@@ -0,0 +1,11 @@
+/* Test Darwin linker option -bundle.  */
+/* Developed by Devang Patel <dpatel@apple.com>.  */
+
+/* { dg-options "-bundle" } */
+/* { dg-do link { target *-*-darwin* } } */
+
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-5.c
new file mode 100644
index 000000000..0540f92bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-ld-5.c
@@ -0,0 +1,11 @@
+/* Test Darwin linker option -dynamic.  */
+/* Developed by Devang Patel <dpatel@apple.com>.  */
+
+/* { dg-options "-dynamic" } */
+/* { dg-do link { target *-*-darwin* } } */
+
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-1.c
new file mode 100644
index 000000000..d8a3243bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-1.c
@@ -0,0 +1,11 @@
+/* Basic test for -mmacosx-version-min switch on Darwin.  */
+/* { dg-options "-mmacosx-version-min=10.1" } */
+/* { dg-do run { target *-*-darwin* } } */
+
+int main(void)
+{
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1010
+  fail me;
+#endif
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-2.c
new file mode 100644
index 000000000..fd4975a52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-2.c
@@ -0,0 +1,11 @@
+/* Basic test for -mmacosx-version-min switch on Darwin.  */
+/* { dg-options "-mmacosx-version-min=10.1 -mmacosx-version-min=10.3" } */
+/* { dg-do run { target *-*-darwin* } } */
+
+int main(void)
+{
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1030
+  fail me;
+#endif
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-3.c
new file mode 100644
index 000000000..d0c5934b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-minversion-3.c
@@ -0,0 +1,11 @@
+/* Test that most-minor versions greater than 9 work.  */
+/* { dg-options "-mmacosx-version-min=10.4.10" } */
+/* { dg-do compile { target *-*-darwin* } } */
+
+int main(void)
+{
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1040
+  fail me;
+#endif
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-version-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-version-1.c
new file mode 100644
index 000000000..11cfceff3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-version-1.c
@@ -0,0 +1,10 @@
+/* Basic test of the -mmacosx-version-min option.  */
+
+/* { dg-options "-mmacosx-version-min=10.1" } */
+/* { dg-do link { target *-*-darwin* } } */
+
+int main()
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-1.c
new file mode 100644
index 000000000..16b7024fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common -fno-asynchronous-unwind-tables" } */
+
+/* { dg-final { scan-assembler "weak_reference _a" } } */
+/* { dg-final { scan-assembler-not "weak_\[a-z \t\]*_b" } } */
+
+extern void a (void) __attribute__((weak_import));
+extern void b (void) __attribute__((weak_import));
+
+void b(void)
+{
+  a();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-2.c
new file mode 100644
index 000000000..1c9817222
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-require-weak "" } */
+
+/* { dg-final { scan-assembler "weak_reference _foo" } } */
+
+extern int foo __attribute__((weak_import));
+
+int main(void)
+{
+  if (&foo)
+    return foo;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-3.c
new file mode 100644
index 000000000..77ab980b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakimport-3.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-fno-asynchronous-unwind-tables" } */
+/* { dg-require-weak "" } */
+
+/* { dg-final { scan-assembler-not "coalesced" } } */
+
+extern void foo(void) __attribute__((weak_import));
+
+void foo(void)
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakref-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakref-1.c
new file mode 100644
index 000000000..22a3cc079
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/darwin-weakref-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile { target *-*-darwin* } } */
+// { dg-require-weak "" }
+// { dg-options "-O2" }
+// { dg-options "-O2 -mmacosx-version-min=10.2" { target { powerpc-*-darwin* } } }
+/* { dg-final { scan-assembler "weak_reference _wv1" } } */
+/* { dg-final { scan-assembler "weak_reference _wf1" } } */
+/* { dg-final { scan-assembler-not "weak_reference _w.2" } } */
+
+
+typedef int vtype;
+
+extern vtype wv1;
+static vtype Wv1a __attribute__((weakref ("wv1")));
+vtype *pv1a = &Wv1a;
+
+extern vtype wv2;
+static vtype Wv2a __attribute__((weakref ("wv2")));
+vtype *pv2a = &wv2;
+
+typedef void ftype(void);
+
+extern ftype wf1;
+static ftype Wf1a __attribute__((weakref ("wf1")));
+ftype *pf1a = &Wf1a;
+
+extern ftype wf2;
+static ftype Wf2a __attribute__((weakref ("wf2")));
+ftype *pf2a = &wf2;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20000503-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20000503-1.c
new file mode 100644
index 000000000..27d3c55dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20000503-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+/* Distilled from GCC's stmt.c.  Caused abort in dwarf-1 code. */
+
+static void
+expand_nl_goto_receiver ()
+{
+{
+static struct elims {int from, to;} elim_regs[] = {{ 16, 7}, { 16, 6}, { 20, 7},{ 20, 6}};
+      int i;
+
+      for (i = 0; i < sizeof elim_regs / sizeof elim_regs[0]; i++)
+	if (elim_regs[i].from == 16 && elim_regs[i].to == 6)
+	break;
+      }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20010207-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20010207-1.c
new file mode 100644
index 000000000..513d7a433
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20010207-1.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+extern inline int f1 (void) {return f2();}
+int f3 (void) {return f1();}
+int f1 (void) {return 0;}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20011223-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20011223-1.c
new file mode 100644
index 000000000..f8d70abce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20011223-1.c
@@ -0,0 +1,11 @@
+/* Origin: PR c/5163 from aj@suse.de.  */
+/* { dg-do compile } */
+
+extern int bar (int);
+
+int
+foo (void)
+{
+  extern int bar (int);
+  return bar (5);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020104-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020104-2.c
new file mode 100644
index 000000000..854d17448
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020104-2.c
@@ -0,0 +1,9 @@
+/* This testcase used to fail because outlining_inline_function was called
+   too early, before rtl was generated.  */
+/* { dg-do compile } */
+
+int foo (const int *x)
+{
+  char a[*x];
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020220-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020220-1.c
new file mode 100644
index 000000000..07109e86a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020220-1.c
@@ -0,0 +1,31 @@
+/* PR debug/4461
+   This testcase failed to link in Dwarf-2 because
+   constant -4.0 in constant pool was never referenced by anything
+   but Dwarf-2 location descriptor.  */
+/* { dg-do run } */
+
+void __attribute__((noinline))
+foo (const char *x __attribute__((unused)),
+     __complex__ long double y __attribute__((unused)),
+     __complex__ long double z __attribute__((unused)))
+{
+}
+
+void
+bar (void)
+{
+  foo ("",
+       __builtin_conjl (({ __complex__ long double r;
+			   __real__ r = 3.0;
+			   __imag__ r = -4.0;
+			   r; })),
+       ({ __complex__ long double s;
+	  __real__ s = 3.0;
+	  __imag__ s = 4.0;
+	  s; }));
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020224-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020224-1.c
new file mode 100644
index 000000000..968b5655b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020224-1.c
@@ -0,0 +1,71 @@
+/* { dg-options "-g3 -O" } */
+/* { dg-do compile } */
+
+/* Here's the deal: f4 is inlined into main, f3 is inlined into f4, f2 is
+   inlined into f1. The DIE of main should contain DW_TAG_inlined_subroutines
+   children for f4, f3, f2 and f1. Also, there should be a DIE representing
+   and out of line instance of f4, aside the DIE representing its abstract
+   instance.
+   We used to fail to emit debugging info for t1, because it was moved
+   inside the (inlined) block of f1, marked as abstract, then we'd crash.  */
+
+#define UNUSED __attribute__((unused))
+#define EXT __extension__
+
+int undef(void);
+
+inline static void
+f1 (int i UNUSED)
+{
+}
+
+inline static void
+f2 (void)
+{
+  f1 (EXT ({ int t1 UNUSED; undef (); }));
+}
+
+inline static void
+f3 (void)
+{
+  int v1 UNUSED;
+  int v2 UNUSED;
+
+  EXT ({ int t2 UNUSED; if (0) undef (); 0; })
+    && EXT ({ int t3 UNUSED; if (0) undef (); 0; });
+
+  if (1)
+    {
+      undef ();
+      if (1)
+        f2 ();
+    }
+
+  {
+    undef ();
+  }
+}
+
+inline static void
+f4 (void)
+{
+  EXT ({ undef (); 1; }) && EXT ({ int t4 UNUSED = ({ 1; }); 1; });
+
+  { }
+
+  EXT ({ int t5 UNUSED; if (0) undef (); 0; });
+
+  f4 ();
+
+  undef ();
+  f3 ();
+
+  return;
+}
+
+int
+main ()
+{
+    int foo = 1;
+    f4 ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020327-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020327-1.c
new file mode 100644
index 000000000..49d00a16c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20020327-1.c
@@ -0,0 +1,12 @@
+/* { dg-do link } */
+
+#ifndef __powerpc64__
+/* Fails on powerpc64-linux due to the function Letext using a global
+   .Letext symbol that conflicts with .Letext emitted by gcc with
+   -gstabs.  Some day the linker will be fixed to not require global
+   "dot" syms, but for now disable this test entirely for powerpc64.
+   Using xfail doesn't work, nor does dg-excess-errors because some
+   combinations of command line options won't cause this test to fail.  */
+void Letext (void) { }
+#endif
+int main() { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20030605-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20030605-1.c
new file mode 100644
index 000000000..548faaf5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20030605-1.c
@@ -0,0 +1,7 @@
+/* Verify we don't ICE on statement-expressions.  */
+/* { dg-do compile } */
+
+void foo(void)
+{
+  char buf[({ 4; })];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20031231-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20031231-1.c
new file mode 100644
index 000000000..fa20260b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20031231-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+
+/* We used to fail because GCC didn't expect always inline to be inlined at
+   -O0.  */
+typedef union tree_node *tree;
+typedef struct c_pretty_print_info c_pretty_printer;
+
+
+void pp_c_string_literal (c_pretty_printer *, tree);
+
+
+static __inline__  __attribute__((always_inline)) void
+pp_c_shift_expression (c_pretty_printer *pp, tree e)
+{
+}
+
+static void
+pp_c_relational_expression (c_pretty_printer *pp, tree e)
+{
+        pp_c_shift_expression (pp, e);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20041023-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20041023-1.c
new file mode 100644
index 000000000..12b7cb9a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20041023-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+
+static void
+foo (unsigned char x)
+{
+  unsigned char a[5 + x];
+}
+
+void
+bar (void)
+{
+  foo (80);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20041219-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20041219-1.c
new file mode 100644
index 000000000..6a62bb95b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20041219-1.c
@@ -0,0 +1,8 @@
+/* PR 18067 */
+/* { dg-do compile } */
+
+void foo(int i)
+{
+    const int j=i+1;
+    int a[1][j*j];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20050907-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20050907-1.c
new file mode 100644
index 000000000..0112ff7d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/20050907-1.c
@@ -0,0 +1,24 @@
+/* PR 23190 */
+/* Well, collateral damage from a proposed patch fixing 23190.  We'd emit
+   debug info for multilib_exclusions_raw without emitting the variable
+   itself, leading to link errors.  This reduced form is filed as PR 23777,
+   for not eliminating things soon enough.  */
+/* { dg-do link } */
+
+static const char *const multilib_exclusions_raw[] = { 0 };
+
+void __attribute__((noinline)) f(char *const *p)
+{
+  __asm__ ("" : : "g"(p) : "memory");
+}
+
+void g (char **o)
+{
+  const char *const *q = multilib_exclusions_raw;
+
+  f (o);
+  while (*q++)
+    f (o);
+}
+
+int main() { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-1.c
new file mode 100644
index 000000000..bc526612f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-1.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+typedef float FloatVect __attribute__((__vector_size__(16)));
+static FloatVect Foo = { 250000000.0, 0.0, 0.0, 0.0 };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-2.c
new file mode 100644
index 000000000..7b9c24403
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-2.c
@@ -0,0 +1,2 @@
+/* { dg-do compile } */
+static __complex__ int x = 3.0;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-3.c
new file mode 100644
index 000000000..2e9db490c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/const-3.c
@@ -0,0 +1,7 @@
+/* Make sure we don't emit strings just because of debug information
+   for string initializers.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+/* { dg-final { scan-assembler-not "dontgenerate" } } */
+static const char *p = "dontgenerate1";
+static const char *q[2] = { 0, "dontgenerate2" };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/crash1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/crash1.c
new file mode 100644
index 000000000..259e259f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/crash1.c
@@ -0,0 +1,8 @@
+/* PR c/14492 */
+/* { dg-options "" } */
+
+int main() {
+  double d = 1.0;
+  char x[(int) d];
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-1.c
new file mode 100644
index 000000000..35b5c91b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-1.c
@@ -0,0 +1,34 @@
+/* Verify that the scheduler does not discard the lexical block.  */
+/* { dg-do compile } */
+/* { dg-options "-dA" } */
+/* On MIPS targets that support conditional moves, the optimal
+   implementation of this function is:
+
+	l[wd] tmp,p
+	li $2,2
+	jr $31
+	movz $2,$0,tmp
+
+   After if-conversion, we have a conditional move into a pseudo P
+   followed a copy of P into the return register ($2).  P is associated
+   with xyzzy, so if-conversion is behaving as expected, and has not lost
+   the variable association.  The destination of the second instruction
+   is associated with the function return value.  Combine then combines
+   these two instructions, removing the last use of P and xyzzy.
+
+   Everything is behaving as expected in this scenario, so we avoid
+   using conditional moves for this test.  */
+/* { dg-options "-dA -fno-if-conversion" { target mips*-*-* } } */
+/* { dg-final { scan-assembler "xyzzy" } } */
+
+long p;
+
+long foo(void)
+{
+  {
+    long xyzzy = 0;
+    if (p)
+      xyzzy = 2;
+    return xyzzy;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-2.c
new file mode 100644
index 000000000..1e86f2fc7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-2.c
@@ -0,0 +1,24 @@
+/* Verify that the scheduler does not discard the lexical block.  */
+/* { dg-do compile } */
+/* { dg-options "-dA" } */
+/* See the comment in debug-1.c.  */
+/* { dg-options "-dA -fno-if-conversion" { target mips*-*-* } } */
+/* { dg-final { scan-assembler "xyzzy" } } */
+
+long p;
+
+long foo(void)
+{
+  if (1)
+    {
+      long xyzzy = 0;
+      if (p)
+        xyzzy = 2;
+      return xyzzy;
+    }
+  else
+    {
+      int x = 0;
+      return x;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-3.c
new file mode 100644
index 000000000..e2b7a4b18
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-3.c
@@ -0,0 +1,35 @@
+/* This testcase failed, because scope containing baz was deleted
+   (spanned 0 basic blocks) and DWARF-2 couldn't find baz origin.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target trampolines } */
+
+struct A { char *a, *b, *c, *d; };
+
+static int
+bar (struct A *x)
+{
+  return x->c - x->b;
+}
+
+void fnptr (void (*fn) (void));
+
+void
+foo (void)
+{
+  struct A e;
+
+  {
+    void baz (void)
+      {
+	bar (&e);
+      }
+    fnptr (baz);
+  }
+  {
+    struct A *f;
+
+    f = &e;
+    if (f->c - f->a > f->d - f->a)
+      f->c = f->d;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-4.c
new file mode 100644
index 000000000..62e824a54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-4.c
@@ -0,0 +1,26 @@
+/* This testcase failed, because scope containing baz was not emitted
+   (doesn't contain any instructions) and DWARF-2 couldn't find baz origin.  */
+/* { dg-do compile } */
+
+struct A { char *a, *b, *c, *d; };
+
+static int
+bar (struct A *x)
+{
+  return x->c - x->b;
+}
+
+void
+foo (void)
+{
+  struct A e;
+
+  {
+    int baz (void)
+      {
+	return bar (&e);
+      }
+  }
+  if (e.c - e.a > e.d - e.a)
+    e.c = e.d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-5.c
new file mode 100644
index 000000000..f66b861c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-5.c
@@ -0,0 +1,47 @@
+/* This testcase failed, because scope containing baz was deleted
+   (spanned 0 basic blocks) and DWARF-2 couldn't find baz origin.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target trampolines } */
+
+extern void abort (void);
+
+struct A { char *a, *b, *c, *d; };
+
+static int
+bar (struct A *x)
+{
+  return x->c - x->b;
+}
+
+static int
+bar2 (struct A *x)
+{
+  int a = x->c - x->b;
+  x->c += 26;
+  return a;
+}
+
+void fnptr (void (*fn) (void));
+
+void
+foo (void)
+{
+  struct A e;
+
+  if (bar2 (&e) < 0)
+    abort ();
+  {
+    void baz (void)
+      {
+	bar (&e);
+      }
+    fnptr (baz);
+  }
+  {
+    struct A *f;
+
+    f = &e;
+    if (f->c - f->a > f->d - f->a)
+      f->c = f->d;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-6.c
new file mode 100644
index 000000000..4fe680df0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-6.c
@@ -0,0 +1,38 @@
+/* Verify that bb-reorder re-inserts nested scopes properly.  */
+/* { dg-do compile } */
+/* { dg-options "-dA" } */
+/* { dg-final { scan-assembler "xyzzy" } } */
+
+extern void abort (void);
+
+struct A { char *a, *b, *c, *d; };
+
+static int
+bar2 (struct A *x)
+{
+  int a = x->c - x->b;
+  x->c += 26;
+  return a;
+}
+   
+void fnptr (int *);
+
+void
+foo (void)
+{
+  struct A e;
+
+  if (bar2 (&e) < 0)
+    abort ();
+  {
+    int xyzzy;
+    fnptr (&xyzzy);
+  }
+  {
+    struct A *f;
+  
+    f = &e;
+    if (f->c - f->a > f->d - f->a)
+      f->c = f->d;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-7.c
new file mode 100644
index 000000000..d424e91f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug-7.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-dA" } */
+/* PR debug/12934.  */
+
+static inline int foo ()
+{
+  return 42;
+}
+
+void bar (int *);
+
+void baz ()
+{
+  int a[foo ()];
+  bar (a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug.exp
new file mode 100644
index 000000000..94c1564a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/debug.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 2002, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+
+gcc-dg-debug-runtest gcc_target_compile trivial.c [list -O -O3] \
+    [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]]
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-1.c
new file mode 100644
index 000000000..4ca98e2f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+
+/* Copyright (C) 2000  Free Software Foundation  */
+/* Contributed by Alexandre Oliva <aoliva@cygnus.com> */
+
+static int foo () { return 0; }
+
+void bar () {
+  int foo ();
+  int foo ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-2.c
new file mode 100644
index 000000000..0c3cee1a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+/* Copyright (C) 2000  Free Software Foundation  */
+/* Contributed by Alexandre Oliva <aoliva@redhat.com> */
+
+inline double fx (double x)
+{
+  return 3 * x;
+}
+
+main ()
+{
+  double a = 0, fx (double), foo ();
+  fx (a);
+  if (a != 3)
+    foo ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-3.c
new file mode 100644
index 000000000..f0c129c60
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-3.c
@@ -0,0 +1,13 @@
+/* Test -feliminate-dwarf2-dups */
+/* Contributed by Devang Patel <dpatel@apple.com> */
+/* { dg-do compile } */
+/* { dg-options "-feliminate-dwarf2-dups" } */
+
+#include "dwarf2-3.h"
+
+int main()
+{
+  struct point p;
+  p.x = 0;
+  p.y = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-3.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-3.h
new file mode 100644
index 000000000..26ad0bace
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2-3.h
@@ -0,0 +1,9 @@
+/* Test -feliminate-dwarf2-dups */
+/* Contributed by Devang Patel <dpatel@apple.com> */
+
+struct point
+{
+  int x;
+  int y;
+};
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/aranges-fnsec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/aranges-fnsec-1.c
new file mode 100644
index 000000000..873188fe8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/aranges-fnsec-1.c
@@ -0,0 +1,14 @@
+/* Test that .debug_aranges does not have an entry for the text
+   section if nothing went in there.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-gdwarf-2 -ffunction-sections -w -dA" } */
+/* { dg-final { scan-assembler-not "\\.Letext0-\\.Ltext0" } } */
+/* { dg-final { scan-assembler-not "\\.Ltext0\[^\n\r\]*Offset 0x0" } } */
+/* { dg-final { scan-assembler "DW_AT_ranges" } } */
+
+int
+f (void)
+{
+  return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/c99-typedef1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/c99-typedef1.c
new file mode 100644
index 000000000..b7bd66a60
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/c99-typedef1.c
@@ -0,0 +1,9 @@
+// { dg-options "-std=iso9899:1999 -gdwarf-2" }
+
+void f() {
+  int n = 3;
+  typedef int T[n++];
+  
+  T t;
+  t[0] = 7;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-1.c
new file mode 100644
index 000000000..aa20e6d5c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-1.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "DW_AT_const_value" } } */
+
+extern void x();
+static void (*f)() = x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-2.c
new file mode 100644
index 000000000..16e1d8bd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile { target powerpc_altivec_ok } } */
+/* { dg-options "-O -gdwarf-2 -dA -maltivec" } */
+/* { dg-final { scan-assembler "DW_AT_const_value" } } */
+
+typedef float FloatVect __attribute__((__vector_size__(16)));
+static FloatVect Foo = { 250000000.0, 0.0, 0.0, 0.0 };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-2b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-2b.c
new file mode 100644
index 000000000..9d577ea77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/const-2b.c
@@ -0,0 +1,6 @@
+/* { dg-do compile { target i386*-*-* } } */
+/* { dg-options "-O -gdwarf-2 -dA -msse" } */
+/* { dg-final { scan-assembler "DW_AT_const_value" } } */
+
+typedef float FloatVect __attribute__((__vector_size__(16)));
+static FloatVect Foo = { 250000000.0, 0.0, 0.0, 0.0 };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dashgdwarf-4-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dashgdwarf-4-2.c
new file mode 100644
index 000000000..a84987243
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dashgdwarf-4-2.c
@@ -0,0 +1,15 @@
+/* Verify that -gdwarf-2 overrides -gdwarf-4.  */
+
+/* { dg-do compile */
+/* { dg-options "-O0 -gdwarf-4 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler-not "DW_TAG_type_unit" } } */
+
+struct bar {
+  int i;
+  int j;
+};
+
+void foo ()
+{
+  struct bar b = { 1, 2 };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char1.c
new file mode 100644
index 000000000..ed32349b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char1.c
@@ -0,0 +1,13 @@
+/* PR debug/7241 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "0x\[68\]\[ \t\]+\[#@;!/|\]+\[ \t\]+DW_AT_encoding" } } */
+/* { dg-final { scan-assembler-not "0x\[57\]\[ \t\]+\[#@;!/|\]+\[ \t\]+DW_AT_encoding" } } */
+
+char a;
+const char b;
+signed char c;
+volatile signed char d;
+unsigned char e;
+volatile const unsigned char f;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char2.c
new file mode 100644
index 000000000..dc145852f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char2.c
@@ -0,0 +1,13 @@
+/* PR debug/7241 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "0x\[68\]\[ \t\]+\[#@;!/|\]+\[ \t\]+DW_AT_encoding" } } */
+/* { dg-final { scan-assembler-not "0x\[57\]\[ \t\]+\[#@;!/|\]+\[ \t\]+DW_AT_encoding" } } */
+
+const char a;
+char b;
+volatile signed char c;
+signed char d;
+const volatile unsigned char e;
+unsigned char f;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char3.c
new file mode 100644
index 000000000..edc1d83ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-char3.c
@@ -0,0 +1,8 @@
+/* PR debug/7241 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "0x\[68\]\[ \t\]+\[#@;!/|\]+\[ \t\]+DW_AT_encoding" } } */
+/* { dg-final { scan-assembler-not "0x\[57\]\[ \t\]+\[#@;!/|\]+\[ \t\]+DW_AT_encoding" } } */
+
+const char *p = "abc";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-dfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-dfp.c
new file mode 100644
index 000000000..ddb602250
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-dfp.c
@@ -0,0 +1,16 @@
+/* Verify the DWARF encoding of C99 decimal floating point types.  */
+
+/* { dg-do compile */
+/* { dg-require-effective-target dfp } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "0x10.*DW_AT_encoding" } } */
+/* { dg-final { scan-assembler "0x4.*DW_AT_byte_size" } } */
+/* { dg-final { scan-assembler "0x8.*DW_AT_byte_size" } } */
+/* { dg-final { scan-assembler "0x10.*DW_AT_byte_size" } } */
+
+void foo ()
+{
+  _Decimal32 f = 1.5df;
+  _Decimal64 d = 1.5dd;
+  _Decimal128 l = 1.5dl;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die1.c
new file mode 100644
index 000000000..fdfbf8321
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die1.c
@@ -0,0 +1,8 @@
+/* Verify that inline function never actually inlined has no abstract DIE.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler-not "DW_AT_inline" } } */
+inline int t()
+{
+}
+int (*q)()=t;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die2.c
new file mode 100644
index 000000000..ac897ab78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die2.c
@@ -0,0 +1,7 @@
+/* Verify that inline function never actually emit has no DIE.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler-not "CIE Version" } } */
+static inline int t()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die3.c
new file mode 100644
index 000000000..04b2f36c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die3.c
@@ -0,0 +1,11 @@
+/* Verify that extern inline function never actually inlined has no abstract DIE.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler-not "DW_AT_inline" } } */
+extern inline int t()
+{
+}
+int (*q)()=t;
+int t()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die5.c
new file mode 100644
index 000000000..3fefd41ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die5.c
@@ -0,0 +1,12 @@
+/* Inlined inline function must have abstract DIE  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA -fpreprocessed" } */
+/* { dg-final { scan-assembler "3.*DW_AT_inline" } } */
+#1 "test.h"
+inline int t()
+{
+}
+int q()
+{
+  t();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die6.c
new file mode 100644
index 000000000..d8f477f54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die6.c
@@ -0,0 +1,12 @@
+/* not inline inline function must not have abstract DIE  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-inline -gdwarf-2 -dA -fpreprocessed" } */
+/* { dg-final { scan-assembler-not "DW_AT_inline" } } */
+#1 "test.h"
+inline int t()
+{
+}
+int q()
+{
+  t();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die7.c
new file mode 100644
index 000000000..b747076ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-die7.c
@@ -0,0 +1,14 @@
+/* Inlined non-inline function must have abstract DIE  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA -fpreprocessed" } */
+/* { dg-final { scan-assembler "1.*DW_AT_inline" } } */
+#1 "test.h"
+void f(void);
+static int t()
+{
+	f();
+}
+int q()
+{
+  t();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-file1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-file1.c
new file mode 100644
index 000000000..c68dfe436
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-file1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "File Entry:|.file" } } */
+/* Verify that a file entry is output for this file.  Only systems that
+   do not define HAVE_AS_DWARF2_DEBUG_LINE will put out "File Entry:",
+   but systems that do define HAVE_AS_DWARF2_DEBUG_LINE will put out a
+   ".file" so we check for either.  */
+
+int bar = 3;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-float.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-float.c
new file mode 100644
index 000000000..84d605fcd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-float.c
@@ -0,0 +1,15 @@
+/* Verify the DWARF encoding of C99 floating point types.  */
+
+/* { dg-do compile */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "0x4.*DW_AT_encoding" } } */
+/* { dg-final { scan-assembler "0x4.*DW_AT_byte_size" } } */
+/* { dg-final { scan-assembler "0x8.*DW_AT_byte_size" } } */
+/* { dg-final { scan-assembler "0x10.*DW_AT_byte_size" } } */
+
+void foo ()
+{
+  float f = 1.5f;
+  double d = 1.5;
+  long double l = 1.5l;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-merge.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-merge.c
new file mode 100644
index 000000000..767d38b17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-merge.c
@@ -0,0 +1,10 @@
+/* Verify that mergeable strings are used in the CU DIE.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target string_merging } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "DW_AT_producer: \"GNU C" } } */
+/* { dg-final { scan-assembler-not "GNU C\[^\\n\\r\]*DW_AT_producer" } } */
+
+void func (void)
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-uninit.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-uninit.c
new file mode 100644
index 000000000..7bcebe355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf-uninit.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "DW_TAG_variable" } } */
+/* PR debug/21828 */
+
+static int i;
+int main() {
+  i += 3;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf2-macro.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf2-macro.c
new file mode 100644
index 000000000..4efb25e8c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf2-macro.c
@@ -0,0 +1,13 @@
+/* Test to make sure the mcaro info includes a start file command for the main source */
+/* { dg-do compile } */
+/* { dg-options "-g3 -gdwarf-2 -dA -fverbose-asm" } */
+/* { dg-final { scan-assembler "Start new file" } } */
+
+#define ADD(x) (M + x)
+
+int main (void)
+{
+#define N 28
+#define M 42
+   return ADD(N);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf2.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf2.exp
new file mode 100644
index 000000000..73c2c44ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/dwarf2.exp
@@ -0,0 +1,43 @@
+#   Copyright (C) 2002, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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 -gdwarf-2"
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+set comp_output [gcc_target_compile \
+    "$srcdir/$subdir/../trivial.c" "trivial.S" assembly \
+    "additional_flags=-gdwarf-2"]
+if { ! [string match "*: target system does not support the * debug format*" \
+    $comp_output] } {
+    remove-build-file "trivial.S"
+    dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] \
+	    "" $DEFAULT_CFLAGS
+}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-any.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-any.c
new file mode 100644
index 000000000..fc510903c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-any.c
@@ -0,0 +1,84 @@
+// { dg-do compile }
+// { dg-options "-gdwarf-2 -dA -femit-struct-debug-detailed=any" }
+// { dg-final { scan-assembler "timespec.*DW_AT_name" } }
+// { dg-final { scan-assembler "tv_sec.*DW_AT_name" } }
+// { dg-final { scan-assembler "tv_nsec.*DW_AT_name" } }
+// { dg-final { scan-assembler "itimerspec.*DW_AT_name" } }
+// { dg-final { scan-assembler "it_interval.*DW_AT_name" } }
+// { dg-final { scan-assembler "it_value.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_var_head_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_var_head_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_var_head_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_var_head_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_decl_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_decl_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_decl_ref_base.*DW_AT_name" } }
+# 1 "fesd-any.c"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "fesd-any.c"
+
+//#include "time.h"
+# 1 "time.h" 1 3 4
+struct timespec
+  {
+    long int tv_sec;
+    long int tv_nsec;
+  };
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+# 6 "fesd-any.c" 2
+
+struct timespec base_var8;
+struct itimerspec *base_var9;
+
+#include "fesd-any.h"
+
+struct gstruct_head_ordy_defn_var_base base_var1;
+struct gstruct_base_ordy_defn_var_base base_var2;
+
+int base_function() {
+    return 0
++ base_var1.field_head_ordy_defn_var_base
++ base_var2.field1_base_ordy_defn_var_base_ptr->field_head_ordy_defn_ptr_base
++ base_var2.field1_base_ordy_defn_var_base_fld.field_head_ordy_defn_fld_base
++ base_var2.field2_base_ordy_defn_var_base_ptr->field_base_ordy_defn_ptr_base
++ base_var2.field2_base_ordy_defn_var_base_fld.field_base_ordy_defn_fld_base
+;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-any.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-any.h
new file mode 100644
index 000000000..a7146b65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-any.h
@@ -0,0 +1,19 @@
+#include "fesd.h"
+
+struct gstruct_base_ordy_decl_not;
+struct gstruct_base_ordy_defn_not { int field_base_ordy_defn_not; };
+
+struct gstruct_base_ordy_decl_ref_base;
+struct gstruct_base_ordy_defn_ref_base { int field_base_ordy_defn_ref_base; };
+struct gstruct_base_ordy_defn_ptr_base { int field_base_ordy_defn_ptr_base; };
+struct gstruct_base_ordy_defn_fld_base { int field_base_ordy_defn_fld_base; };
+struct gstruct_base_ordy_defn_var_base {
+    struct gstruct_head_ordy_decl_ref_base *field1_base_ordy_defn_var_base_inc;
+    struct gstruct_head_ordy_defn_ref_base *field1_base_ordy_defn_var_base_ref;
+    struct gstruct_head_ordy_defn_ptr_base *field1_base_ordy_defn_var_base_ptr;
+    struct gstruct_head_ordy_defn_fld_base  field1_base_ordy_defn_var_base_fld;
+    struct gstruct_base_ordy_decl_ref_base *field2_base_ordy_defn_var_base_inc;
+    struct gstruct_base_ordy_defn_ref_base *field2_base_ordy_defn_var_base_ref;
+    struct gstruct_base_ordy_defn_ptr_base *field2_base_ordy_defn_var_base_ptr;
+    struct gstruct_base_ordy_defn_fld_base  field2_base_ordy_defn_var_base_fld;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-baseonly.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-baseonly.c
new file mode 100644
index 000000000..a32abb5a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-baseonly.c
@@ -0,0 +1,83 @@
+// { dg-do compile }
+// { dg-options "-gdwarf-2 -dA -femit-struct-debug-baseonly" }
+// { dg-final { scan-assembler "timespec.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "tv_sec.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "tv_nsec.*DW_AT_name" } }
+// { dg-final { scan-assembler "itimerspec.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "it_interval.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "it_value.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_decl_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_decl_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_decl_ref_base.*DW_AT_name" } }
+# 1 "fesd-baseonly.c"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "fesd-baseonly.c"
+
+//#include "time.h"
+# 1 "time.h" 1 3 4
+struct timespec
+  {
+    long int tv_sec;
+    long int tv_nsec;
+  };
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+# 6 "fesd-baseonly.c" 2
+
+struct timespec base_var8;
+struct itimerspec *base_var9;
+
+#include "fesd-baseonly.h"
+
+struct gstruct_head_ordy_defn_var_base base_var1;
+struct gstruct_base_ordy_defn_var_base base_var2;
+
+int base_function() {
+    return 0
++ base_var1.field_head_ordy_defn_var_base
++ base_var2.field1_base_ordy_defn_var_base_ptr->field_head_ordy_defn_ptr_base
++ base_var2.field1_base_ordy_defn_var_base_fld.field_head_ordy_defn_fld_base
++ base_var2.field2_base_ordy_defn_var_base_ptr->field_base_ordy_defn_ptr_base
++ base_var2.field2_base_ordy_defn_var_base_fld.field_base_ordy_defn_fld_base
+;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-baseonly.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-baseonly.h
new file mode 100644
index 000000000..a7146b65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-baseonly.h
@@ -0,0 +1,19 @@
+#include "fesd.h"
+
+struct gstruct_base_ordy_decl_not;
+struct gstruct_base_ordy_defn_not { int field_base_ordy_defn_not; };
+
+struct gstruct_base_ordy_decl_ref_base;
+struct gstruct_base_ordy_defn_ref_base { int field_base_ordy_defn_ref_base; };
+struct gstruct_base_ordy_defn_ptr_base { int field_base_ordy_defn_ptr_base; };
+struct gstruct_base_ordy_defn_fld_base { int field_base_ordy_defn_fld_base; };
+struct gstruct_base_ordy_defn_var_base {
+    struct gstruct_head_ordy_decl_ref_base *field1_base_ordy_defn_var_base_inc;
+    struct gstruct_head_ordy_defn_ref_base *field1_base_ordy_defn_var_base_ref;
+    struct gstruct_head_ordy_defn_ptr_base *field1_base_ordy_defn_var_base_ptr;
+    struct gstruct_head_ordy_defn_fld_base  field1_base_ordy_defn_var_base_fld;
+    struct gstruct_base_ordy_decl_ref_base *field2_base_ordy_defn_var_base_inc;
+    struct gstruct_base_ordy_defn_ref_base *field2_base_ordy_defn_var_base_ref;
+    struct gstruct_base_ordy_defn_ptr_base *field2_base_ordy_defn_var_base_ptr;
+    struct gstruct_base_ordy_defn_fld_base  field2_base_ordy_defn_var_base_fld;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-none.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-none.c
new file mode 100644
index 000000000..bd218f826
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-none.c
@@ -0,0 +1,84 @@
+// { dg-do compile }
+// { dg-options "-gdwarf-2 -dA -femit-struct-debug-detailed=none" }
+// { dg-final { scan-assembler "timespec.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "tv_sec.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "tv_nsec.*DW_AT_name" } }
+// { dg-final { scan-assembler "itimerspec.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "it_interval.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "it_value.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_decl_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field1_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field1_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field1_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field1_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field2_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field2_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field2_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field2_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_decl_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_base_ordy_decl_ref_base.*DW_AT_name" } }
+# 1 "fesd-none.c"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "fesd-none.c"
+
+//#include "time.h"
+# 1 "time.h" 1 3 4
+struct timespec
+  {
+    long int tv_sec;
+    long int tv_nsec;
+  };
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+# 6 "fesd-none.c" 2
+
+struct timespec base_var8;
+struct itimerspec *base_var9;
+
+#include "fesd-none.h"
+
+struct gstruct_head_ordy_defn_var_base base_var1;
+struct gstruct_base_ordy_defn_var_base base_var2;
+
+int base_function() {
+    return 0
++ base_var1.field_head_ordy_defn_var_base
++ base_var2.field1_base_ordy_defn_var_base_ptr->field_head_ordy_defn_ptr_base
++ base_var2.field1_base_ordy_defn_var_base_fld.field_head_ordy_defn_fld_base
++ base_var2.field2_base_ordy_defn_var_base_ptr->field_base_ordy_defn_ptr_base
++ base_var2.field2_base_ordy_defn_var_base_fld.field_base_ordy_defn_fld_base
+;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-none.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-none.h
new file mode 100644
index 000000000..a7146b65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-none.h
@@ -0,0 +1,19 @@
+#include "fesd.h"
+
+struct gstruct_base_ordy_decl_not;
+struct gstruct_base_ordy_defn_not { int field_base_ordy_defn_not; };
+
+struct gstruct_base_ordy_decl_ref_base;
+struct gstruct_base_ordy_defn_ref_base { int field_base_ordy_defn_ref_base; };
+struct gstruct_base_ordy_defn_ptr_base { int field_base_ordy_defn_ptr_base; };
+struct gstruct_base_ordy_defn_fld_base { int field_base_ordy_defn_fld_base; };
+struct gstruct_base_ordy_defn_var_base {
+    struct gstruct_head_ordy_decl_ref_base *field1_base_ordy_defn_var_base_inc;
+    struct gstruct_head_ordy_defn_ref_base *field1_base_ordy_defn_var_base_ref;
+    struct gstruct_head_ordy_defn_ptr_base *field1_base_ordy_defn_var_base_ptr;
+    struct gstruct_head_ordy_defn_fld_base  field1_base_ordy_defn_var_base_fld;
+    struct gstruct_base_ordy_decl_ref_base *field2_base_ordy_defn_var_base_inc;
+    struct gstruct_base_ordy_defn_ref_base *field2_base_ordy_defn_var_base_ref;
+    struct gstruct_base_ordy_defn_ptr_base *field2_base_ordy_defn_var_base_ptr;
+    struct gstruct_base_ordy_defn_fld_base  field2_base_ordy_defn_var_base_fld;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-reduced.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-reduced.c
new file mode 100644
index 000000000..ac599f43f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-reduced.c
@@ -0,0 +1,83 @@
+// { dg-do compile }
+// { dg-options "-gdwarf-2 -dA -femit-struct-debug-reduced" }
+// { dg-final { scan-assembler "timespec.*DW_AT_name" } }
+// { dg-final { scan-assembler "tv_sec.*DW_AT_name" } }
+// { dg-final { scan-assembler "tv_nsec.*DW_AT_name" } }
+// { dg-final { scan-assembler "itimerspec.*DW_AT_name" } }
+// { dg-final { scan-assembler "it_interval.*DW_AT_name" } }
+// { dg-final { scan-assembler "it_value.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_decl_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_decl_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_decl_ref_base.*DW_AT_name" } }
+# 1 "fesd-reduced.c"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "fesd-reduced.c"
+
+//#include "time.h"
+# 1 "time.h" 1 3 4
+struct timespec
+  {
+    long int tv_sec;
+    long int tv_nsec;
+  };
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+# 6 "fesd-reduced.c" 2
+
+struct timespec base_var8;
+struct itimerspec *base_var9;
+
+#include "fesd-reduced.h"
+
+struct gstruct_head_ordy_defn_var_base base_var1;
+struct gstruct_base_ordy_defn_var_base base_var2;
+
+int base_function() {
+    return 0
++ base_var1.field_head_ordy_defn_var_base
++ base_var2.field1_base_ordy_defn_var_base_ptr->field_head_ordy_defn_ptr_base
++ base_var2.field1_base_ordy_defn_var_base_fld.field_head_ordy_defn_fld_base
++ base_var2.field2_base_ordy_defn_var_base_ptr->field_base_ordy_defn_ptr_base
++ base_var2.field2_base_ordy_defn_var_base_fld.field_base_ordy_defn_fld_base
+;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-reduced.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-reduced.h
new file mode 100644
index 000000000..a7146b65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-reduced.h
@@ -0,0 +1,19 @@
+#include "fesd.h"
+
+struct gstruct_base_ordy_decl_not;
+struct gstruct_base_ordy_defn_not { int field_base_ordy_defn_not; };
+
+struct gstruct_base_ordy_decl_ref_base;
+struct gstruct_base_ordy_defn_ref_base { int field_base_ordy_defn_ref_base; };
+struct gstruct_base_ordy_defn_ptr_base { int field_base_ordy_defn_ptr_base; };
+struct gstruct_base_ordy_defn_fld_base { int field_base_ordy_defn_fld_base; };
+struct gstruct_base_ordy_defn_var_base {
+    struct gstruct_head_ordy_decl_ref_base *field1_base_ordy_defn_var_base_inc;
+    struct gstruct_head_ordy_defn_ref_base *field1_base_ordy_defn_var_base_ref;
+    struct gstruct_head_ordy_defn_ptr_base *field1_base_ordy_defn_var_base_ptr;
+    struct gstruct_head_ordy_defn_fld_base  field1_base_ordy_defn_var_base_fld;
+    struct gstruct_base_ordy_decl_ref_base *field2_base_ordy_defn_var_base_inc;
+    struct gstruct_base_ordy_defn_ref_base *field2_base_ordy_defn_var_base_ref;
+    struct gstruct_base_ordy_defn_ptr_base *field2_base_ordy_defn_var_base_ptr;
+    struct gstruct_base_ordy_defn_fld_base  field2_base_ordy_defn_var_base_fld;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-sys.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-sys.c
new file mode 100644
index 000000000..3a5c0bf14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-sys.c
@@ -0,0 +1,83 @@
+// { dg-do compile }
+// { dg-options "-gdwarf-2 -dA -femit-struct-debug-detailed=sys" }
+// { dg-final { scan-assembler "timespec.*DW_AT_name" } }
+// { dg-final { scan-assembler "tv_sec.*DW_AT_name" } }
+// { dg-final { scan-assembler "tv_nsec.*DW_AT_name" } }
+// { dg-final { scan-assembler "itimerspec.*DW_AT_name" } }
+// { dg-final { scan-assembler "it_interval.*DW_AT_name" } }
+// { dg-final { scan-assembler "it_value.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_head.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_head_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "gstruct_head_ordy_decl_ref_head.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler-not "field_head_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_ptr_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field_base_ordy_defn_fld_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_defn_var_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field1_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_inc.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ref.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_ptr.*DW_AT_name" } }
+// { dg-final { scan-assembler "field2_base_ordy_defn_var_base_fld.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_head_ordy_decl_ref_base.*DW_AT_name" } }
+// { dg-final { scan-assembler "gstruct_base_ordy_decl_ref_base.*DW_AT_name" } }
+# 1 "fesd-sys.c"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "fesd-sys.c"
+
+//#include "time.h"
+# 1 "time.h" 1 3 4
+struct timespec
+  {
+    long int tv_sec;
+    long int tv_nsec;
+  };
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+# 6 "fesd-sys.c" 2
+
+struct timespec base_var8;
+struct itimerspec *base_var9;
+
+#include "fesd-sys.h"
+
+struct gstruct_head_ordy_defn_var_base base_var1;
+struct gstruct_base_ordy_defn_var_base base_var2;
+
+int base_function() {
+    return 0
++ base_var1.field_head_ordy_defn_var_base
++ base_var2.field1_base_ordy_defn_var_base_ptr->field_head_ordy_defn_ptr_base
++ base_var2.field1_base_ordy_defn_var_base_fld.field_head_ordy_defn_fld_base
++ base_var2.field2_base_ordy_defn_var_base_ptr->field_base_ordy_defn_ptr_base
++ base_var2.field2_base_ordy_defn_var_base_fld.field_base_ordy_defn_fld_base
+;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-sys.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-sys.h
new file mode 100644
index 000000000..a7146b65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd-sys.h
@@ -0,0 +1,19 @@
+#include "fesd.h"
+
+struct gstruct_base_ordy_decl_not;
+struct gstruct_base_ordy_defn_not { int field_base_ordy_defn_not; };
+
+struct gstruct_base_ordy_decl_ref_base;
+struct gstruct_base_ordy_defn_ref_base { int field_base_ordy_defn_ref_base; };
+struct gstruct_base_ordy_defn_ptr_base { int field_base_ordy_defn_ptr_base; };
+struct gstruct_base_ordy_defn_fld_base { int field_base_ordy_defn_fld_base; };
+struct gstruct_base_ordy_defn_var_base {
+    struct gstruct_head_ordy_decl_ref_base *field1_base_ordy_defn_var_base_inc;
+    struct gstruct_head_ordy_defn_ref_base *field1_base_ordy_defn_var_base_ref;
+    struct gstruct_head_ordy_defn_ptr_base *field1_base_ordy_defn_var_base_ptr;
+    struct gstruct_head_ordy_defn_fld_base  field1_base_ordy_defn_var_base_fld;
+    struct gstruct_base_ordy_decl_ref_base *field2_base_ordy_defn_var_base_inc;
+    struct gstruct_base_ordy_defn_ref_base *field2_base_ordy_defn_var_base_ref;
+    struct gstruct_base_ordy_defn_ptr_base *field2_base_ordy_defn_var_base_ptr;
+    struct gstruct_base_ordy_defn_fld_base  field2_base_ordy_defn_var_base_fld;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd.h
new file mode 100644
index 000000000..46b24f5e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/fesd.h
@@ -0,0 +1,36 @@
+/*
+where from: base = matching base; head = other header
+what kind:  ordy = ordinary struct; tmpl = template struct
+definition: decl = incomplete declaration; defn = full definition
+how used:   not = not used; ref = by ref; ptr = through pointer;
+            fld = as field; var = as variable
+from where: base = from base; head = other header
+*/
+
+struct gstruct_head_ordy_decl_not;
+struct gstruct_head_ordy_defn_not { int field_head_ordy_defn_not; };
+
+struct gstruct_head_ordy_decl_ref_head;
+struct gstruct_head_ordy_defn_ref_head { int field_head_ordy_defn_ref_head; };
+struct gstruct_head_ordy_defn_ptr_head { int field_head_ordy_defn_ptr_head; };
+struct gstruct_head_ordy_defn_fld_head { int field_head_ordy_defn_fld_head; };
+struct gstruct_head_ordy_defn_var_head {
+    struct gstruct_head_ordy_decl_ref_head *field_head_ordy_defn_var_head_inc;
+    struct gstruct_head_ordy_defn_ref_head *field_head_ordy_defn_var_head_ref;
+    struct gstruct_head_ordy_defn_ptr_head *field_head_ordy_defn_var_head_ptr;
+    struct gstruct_head_ordy_defn_fld_head  field_head_ordy_defn_var_head_fld;
+};
+extern struct gstruct_head_ordy_defn_var_head head_var1;
+
+struct gstruct_head_ordy_decl_ref_base;
+struct gstruct_head_ordy_defn_ref_base { int field_head_ordy_defn_ref_base; };
+struct gstruct_head_ordy_defn_ptr_base { int field_head_ordy_defn_ptr_base; };
+struct gstruct_head_ordy_defn_fld_base { int field_head_ordy_defn_fld_base; };
+struct gstruct_head_ordy_defn_var_base { int field_head_ordy_defn_var_base; };
+
+inline int head_function() {
+    return 0
++ head_var1.field_head_ordy_defn_var_head_ptr->field_head_ordy_defn_ptr_head
++ head_var1.field_head_ordy_defn_var_head_fld.field_head_ordy_defn_fld_head
+;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/global-used-types.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/global-used-types.c
new file mode 100644
index 000000000..1c2d40326
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/global-used-types.c
@@ -0,0 +1,14 @@
+/*
+ Contributed by Dodji Seketeli <dodji@redhat.com>
+ { dg-options "-g -dA -fno-merge-debug-strings" }
+ { dg-do compile }
+ { dg-final { scan-assembler-times "DIE \\(0x.*?\\) DW_TAG_enumeration_type" 1 } }
+ { dg-final { scan-assembler-times "DIE \\(0x.*?\\) DW_TAG_enumerator" 2 } }
+ { dg-final { scan-assembler-times "ascii \"a.0\"\[\t \]+.*?DW_AT_name" 1 } }
+ { dg-final { scan-assembler-times "ascii \"b.0\"\[\t \]+.*?DW_AT_name" 1 } }
+ */
+
+enum { a, b };
+
+int v = a;
+char s[b];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/inline1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/inline1.c
new file mode 100644
index 000000000..11c8fad78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/inline1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+void e(int);
+__attribute__ ((always_inline)) inline int
+t(int function_parameter)
+{
+  e(function_parameter);
+}
+
+void test (int function_parameter2)
+{
+  t(function_parameter2);
+}
+
+/* Verify that we get both function_parameter and function_parameter2 declared
+   in test.  Overall we should have 3 variables with location defined (also
+   function_parameter in offline copy of t.  */
+/* { dg-final { scan-assembler-times " DW_AT_location" 3 } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/inline2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/inline2.c
new file mode 100644
index 000000000..3a6318ea5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/inline2.c
@@ -0,0 +1,70 @@
+/* Contributed by Dodji Seketeli <dodji@redhat.com>
+   Origin: PR debug/37801
+
+  Abstract instances (DW_TAG_subroutines having the DW_AT_inline attribute)
+  of second and first were having a DW_TAG_lexical_block DIE wrongly
+  representing the inlined calls to third (in second) and to
+  second (in first). At the same time, main didn't have children
+  DW_TAG_inlined_subroutine DIEs representing the inlined calls to
+  first, second and third.
+
+  The ideal goal here is to test that we have no superfluous
+  DW_TAG_lexical_block DIE anymore, that abstract instances DIEs have
+  no descendant DIE with a DW_AT_abstract_origin attribute, and that main has
+  properly nested DW_TAG_inlined_subroutine DIEs for third, second and first.
+*/
+
+/* { dg-options "-O -g3 -dA" } */
+/* { dg-do compile } */
+
+/* There are 6 inlined subroutines:
+   - One for each subroutine inlined into main, that's 3.
+   - One for earch subroutine inline into the out of line instances
+     of third, second and first.  */
+/* { dg-final { scan-assembler-times "\\(DIE \\(.*?\\) DW_TAG_inlined_subroutine" 6 } } */
+
+/* Likewise we should have 6 DW_TAG_lexical_block DIEs:
+   - One for each subroutine inlined into main, so that's 3.
+   - One for each subroutine inlined in the out of line instances
+     of third, second and first, that's 3.
+*/
+/* { dg-final { scan-assembler-times "\\(DIE \\(.*?\\) DW_TAG_lexical_block" 6 } } */
+
+
+/* There are 3 DW_AT_inline attributes: one per abstract inline instance.
+   The value of the attribute must be 0x3, meaning the function was
+   actually inlined.  */
+/* { dg-final { scan-assembler-times "byte.*?0x3.*? DW_AT_inline" 3 } } */
+
+
+inline void
+third (int arg3)
+{
+  int var3 = arg3;
+  int* a = 0;
+  a[0] = var3;
+}
+
+inline void
+second (int arg2)
+{
+  int var2 = arg2;
+  third (var2+1);
+}
+
+inline void
+first (int arg1)
+{
+  int var1 = arg1;
+  second (var1+1);
+}
+
+int
+main ()
+{
+  int some_int = 1;
+  first (some_int);
+  return 0;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/ipa-cp1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/ipa-cp1.c
new file mode 100644
index 000000000..7442dab19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/ipa-cp1.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+void q(int p);
+static void
+t(int constant_propagated_par)
+{
+  int local_var = constant_propagated_par + 1;
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+  q(local_var);
+}
+main()
+{
+  t(5);
+  t(5);
+  t(5);
+  t(5);
+  t(5);
+  t(5);
+  t(5);
+}
+/* { dg-final { scan-assembler "local_var" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/mlt1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/mlt1.c
new file mode 100644
index 000000000..7b0b2e994
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/mlt1.c
@@ -0,0 +1,32 @@
+/* Test that -gmlt includes line tables and inlined subroutine entries,
+   and excludes types and variables.  */
+/* Origin: Cary Coutant  <ccoutant@google.com> */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA -gmlt" } */
+/* { dg-final { scan-assembler "DW_AT_stmt_list" } } */
+/* { dg-final { scan-assembler "DW_TAG_subprogram" } } */
+/* { dg-final { scan-assembler "DW_TAG_inlined_subroutine" } } */
+/* { dg-final { scan-assembler-not "DW_TAG_variable" } } */
+/* { dg-final { scan-assembler-not "DW_TAG_formal_parameter" } } */
+/* { dg-final { scan-assembler-not "DW_TAG_base_type" } } */
+
+static inline __attribute__((always_inline)) int
+a(int i, int j)
+{
+  return (i << 5) + j;
+}
+
+int
+b(int i, int j)
+{
+  return (i >> 5) + (j << 27);
+}
+
+int
+c(int i, int j)
+{
+  int r = a(i, j);
+  r = b(r, i);
+  r = b(r, j);
+  return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/mlt2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/mlt2.c
new file mode 100644
index 000000000..bd7ad05ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/mlt2.c
@@ -0,0 +1,31 @@
+/* Test that -g overrides -gmlt.  */
+/* Origin: Cary Coutant  <ccoutant@google.com> */
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2 -dA -gmlt -g" } */
+/* { dg-final { scan-assembler "DW_AT_stmt_list" } } */
+/* { dg-final { scan-assembler "DW_TAG_subprogram" } } */
+/* { dg-final { scan-assembler "DW_TAG_inlined_subroutine" } } */
+/* { dg-final { scan-assembler "DW_TAG_variable" } } */
+/* { dg-final { scan-assembler "DW_TAG_formal_parameter" } } */
+/* { dg-final { scan-assembler "DW_TAG_base_type" } } */
+
+static inline __attribute__((always_inline)) int
+a(int i, int j)
+{
+  return (i << 5) + j;
+}
+
+int
+b(int i, int j)
+{
+  return (i >> 5) + (j << 27);
+}
+
+int
+c(int i, int j)
+{
+  int r = a(i, j);
+  r = b(r, i);
+  r = b(r, j);
+  return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr29609-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr29609-1.c
new file mode 100644
index 000000000..5476aac0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr29609-1.c
@@ -0,0 +1,32 @@
+/* PR debug/29609 */
+/* Verify that breakpoint on the break is hit.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+
+void abort (void);
+
+int
+foo (void)
+{
+  int a, i;
+
+  for (i = 1; i <= 10; i++)
+    {
+      if (i < 3)
+	a = 1;
+      else
+	break;
+      a = 5;
+    }
+  return a;
+}
+
+int
+main (void)
+{
+  if (foo () != 5)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pr29609-1.c:18" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr29609-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr29609-2.c
new file mode 100644
index 000000000..43bc54524
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr29609-2.c
@@ -0,0 +1,53 @@
+/* PR debug/29609 */
+/* Verify that breakpoint on both goto failure; stmts is hit.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+
+extern void abort (void);
+int x;
+
+int
+foo (void)
+{
+  return 0 ^ x;
+}
+
+int
+bar (void)
+{
+  return 1 ^ x;
+}
+
+int
+baz (void)
+{
+  int c;
+
+  if (!foo ())
+    goto failure;
+
+  if (!bar ())
+    goto failure;
+
+  return 0;
+
+failure:
+  return 1;
+}
+
+int
+main (void)
+{
+  if (baz () != 1)
+    abort ();
+  x = 1;
+  if (baz () != 1)
+    abort ();
+  x = 2;
+  if (baz () != 0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pr29609-2.c:27" } } */
+/* { dg-final { scan-assembler "pr29609-2.c:30" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-1.c
new file mode 100644
index 000000000..de90acb81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-1.c
@@ -0,0 +1,22 @@
+/* PR debug/36690 */
+/* Verify that break func is hit.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+
+int i;
+
+void
+func (void)
+{
+  while (i == 1)
+    i = 0;
+}
+
+int
+main (void)
+{
+  func ();
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pr36690-1.c:11" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-2.c
new file mode 100644
index 000000000..2330f5385
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-2.c
@@ -0,0 +1,39 @@
+/* PR debug/36690 */
+/* Verify that breakpoint can be put on goto f1, it is hit and
+   varz at that spot is defined and contains 5.  Nowhere else
+   in the function should be varz in the scope.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+
+int cnt;
+
+void
+bar (int i)
+{
+  cnt += i;
+}
+
+void
+foo (int i)
+{
+  if (!i)
+    bar (0);
+  else
+    {
+      static int varz = 5;
+      goto f1;
+    }
+  bar (1);
+f1:
+  bar (2);
+}
+
+int
+main (void)
+{
+  foo (0);
+  foo (1);
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pr36690-2.c:24" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-3.c
new file mode 100644
index 000000000..234ad1263
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr36690-3.c
@@ -0,0 +1,53 @@
+/* PR debug/36690 */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+
+int cnt;
+
+void
+bar (int i)
+{
+  cnt += i;
+}
+
+void
+foo (int i, int j)
+{
+  if (j)
+    {
+      bar (i + 1);
+      goto f1;
+    }
+  bar (i + 2);
+  goto f2;
+f1:
+  if (i > 10)
+    goto f3;
+f2:
+  if (i > 40)
+    goto f4;
+  else
+    goto f5;
+f3:
+  bar (i);
+f4:
+  bar (i);
+f5:
+  bar (i);
+}
+
+int
+main (void)
+{
+  foo (0, 1);
+  foo (11, 1);
+  foo (21, 0);
+  foo (41, 0);
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pr36690-3.c:19" } } */
+/* { dg-final { scan-assembler "pr36690-3.c:22" } } */
+/* { dg-final { scan-assembler "pr36690-3.c:25" } } */
+/* { dg-final { scan-assembler "pr36690-3.c:28" } } */
+/* { dg-final { scan-assembler "pr36690-3.c:30" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr37616.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr37616.c
new file mode 100644
index 000000000..badff447a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr37616.c
@@ -0,0 +1,41 @@
+/* PR debug/37616 */
+/* Test that one can put breakpoints onto continue, exitlab and break
+   and actually see program reaching those breakpoints.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+
+extern void abort (void);
+
+int
+foo (int parm)
+{
+  int varj, varm;
+
+  for (varj = 0; varj < 10; varj++)
+    {
+      if (varj == 5)
+	continue;
+      if (varj == 7 && !parm)
+	goto exitlab;
+      if (varj == 9)
+	break;
+      varm = varj;
+    }
+
+exitlab:
+  return varm;
+}
+
+int
+main (void)
+{
+  if (foo (0) != 6)
+    abort ();
+  if (foo (1) != 8)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pr37616.c:17" } } */
+/* { dg-final { scan-assembler "pr37616.c:19" } } */
+/* { dg-final { scan-assembler "pr37616.c:21" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr37726.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr37726.c
new file mode 100644
index 000000000..60fb83961
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/pr37726.c
@@ -0,0 +1,25 @@
+/* PR debug/37726 */
+/* { dg-do compile } */
+/* { dg-options "-g -O0 -dA -fno-merge-debug-strings" } */
+
+int foo (int parm)
+{
+  int var = 0;
+  int bar (void)
+  {
+    return parm + var;
+  }
+  parm++;
+  var++;
+  return bar ();
+}
+
+int
+main (void)
+{
+  return foo (4) - 6;
+}
+
+/* Both parm and var variables should be in debug info for both foo and bar.  */
+/* { dg-final { scan-assembler-times "\"parm\[^\n\]*\"\[^\n\]*DW_AT_name" 2 } } */
+/* { dg-final { scan-assembler-times "\"var\[^\n\]*\"\[^\n\]*DW_AT_name" 2 } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/static1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/static1.c
new file mode 100644
index 000000000..b9b5d0b37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/static1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -gdwarf-2" } */
+void
+main(void)
+{
+ static int unused_local_var;
+}
+/* { dg-final { scan-assembler "unused_local_var" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/var1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/var1.c
new file mode 100644
index 000000000..04dd12976
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/var1.c
@@ -0,0 +1,10 @@
+/* PR 23190 */
+/* { dg-do compile }
+/* { dg-options "-gdwarf-2 -dA -fno-merge-debug-strings" } */
+/* { dg-final { scan-assembler "xyzzy\[^\\n\\r\]+DW_AT_name" } } */
+
+void f(void)
+{
+   static int xyzzy;
+   xyzzy += 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/var2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/var2.c
new file mode 100644
index 000000000..8ef2a7438
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/dwarf2/var2.c
@@ -0,0 +1,14 @@
+/* PR 23190 */
+/* { dg-do compile }
+/* { dg-options "-O2 -gdwarf-2 -dA" } */
+/* { dg-final { scan-assembler "DW_OP_addr\[\\n\\r\]+\[^\\n\\r\]+foo" } } */
+/* { dg-final { scan-assembler "DW_OP_addr\[\\n\\r\]+\[^\\n\\r\]+bar" } } */
+
+static int foo;
+int bar;
+int main(void)
+{
+   foo += 3;
+   bar *= 5;
+   return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/enum-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/enum-1.c
new file mode 100644
index 000000000..7681e9b52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/enum-1.c
@@ -0,0 +1,16 @@
+/* Verify that used enums are output.  */
+/* { dg-do compile } */
+/* { dg-final { scan-assembler "JTI_MAX" } } */
+
+int var;
+
+enum java_tree_index
+{
+  JTI_MAX
+};
+
+void function (void)
+{
+  var = JTI_MAX;
+}
+ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr16676.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr16676.c
new file mode 100644
index 000000000..a9758858f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr16676.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+
+void foo (void) { 
+  void nested () {} 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr26881.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr26881.c
new file mode 100644
index 000000000..156a2c455
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr26881.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-g -O0" } */
+int
+main (int argc, char **argv)
+{
+  if (0)
+    {
+      static union
+      {
+      }
+      u;
+      typedef char tt;
+      static tt c[8];
+      return c[0] == 0x01 && c[1] == 0x02;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29558.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29558.c
new file mode 100644
index 000000000..99386b335
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29558.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+
+void stpi_unpack_16_1(int length, unsigned char *out, unsigned char bit)
+{
+  unsigned char tempin;
+  unsigned char temp[16];
+  for (bit = 128; length > 0; length--) {
+    if (tempin & 128)
+      temp[0] |= bit;
+    else
+      {
+        *out++ = temp[1];
+        *out++ = temp[2];
+        *out++ = temp[3];
+        *out++ = temp[4];
+        *out++ = temp[5];
+        *out++ = temp[6];
+        *out++ = temp[7];
+        *out++ = temp[9];
+        *out++ = temp[10];
+        *out++ = temp[11];
+        *out++ = temp[12];
+        *out++ = temp[13];
+        *out++ = temp[14];
+        *out++ = temp[15];
+        __builtin_memset (temp, 0, 16);
+     }
+  }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29609-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29609-1.c
new file mode 100644
index 000000000..85069ebd6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29609-1.c
@@ -0,0 +1,33 @@
+/* PR debug/29609 */
+/* Verify that breakpoint on the break is hit.
+   This version of the test just checks that it can be compiled, linked
+   and executed, further testing is done in corresponding gcc.dg/dwarf2/
+   test and hopefully in gdb testsuite.  */
+/* { dg-do run } */
+/* { dg-options "-O0 -g -dA" } */
+
+extern void abort (void);
+
+int
+foo (void)
+{
+  int a, i;
+
+  for (i = 1; i <= 10; i++)
+    {
+      if (i < 3)
+	a = 1;
+      else
+	break;
+      a = 5;
+    }
+  return a;
+}
+
+int
+main (void)
+{
+  if (foo () != 5)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29609-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29609-2.c
new file mode 100644
index 000000000..1ae1a738d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr29609-2.c
@@ -0,0 +1,53 @@
+/* PR debug/29609 */
+/* Verify that breakpoint on both goto failure; stmts is hit.
+   This version of the test just checks that it can be compiled, linked
+   and executed, further testing is done in corresponding gcc.dg/dwarf2/
+   test and hopefully in gdb testsuite.  */
+/* { dg-do run } */
+/* { dg-options "-O0 -g -dA" } */
+
+extern void abort (void);
+int x;
+
+int
+foo (void)
+{
+  return 0 ^ x;
+}
+
+int
+bar (void)
+{
+  return 1 ^ x;
+}
+
+int
+baz (void)
+{
+  int c;
+
+  if (!foo ())
+    goto failure;
+
+  if (!bar ())
+    goto failure;
+
+  return 0;
+
+failure:
+  return 1;
+}
+
+int
+main (void)
+{
+  if (baz () != 1)
+    abort ();
+  x = 1;
+  if (baz () != 1)
+    abort ();
+  x = 2;
+  if (baz () != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr32610.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr32610.c
new file mode 100644
index 000000000..d1dae1d38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr32610.c
@@ -0,0 +1,14 @@
+/* PR debug/32610 */
+/* { dg-do compile } */
+
+inline void
+foo (int x)
+{
+  double (*arr)[x];
+}
+
+void
+bar (void)
+{
+  foo (1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr33316.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr33316.c
new file mode 100644
index 000000000..d43478bb5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr33316.c
@@ -0,0 +1,15 @@
+/* PR debug/33316 */
+
+int
+foo (void *x, int y)
+{
+  const struct { int d[y]; } *a = x;
+  return a[0].d[0];
+}
+
+int
+bar (void *x, int y)
+{
+  const struct S { int d[y]; } *a = x;
+  return a[0].d[0];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr35154.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr35154.c
new file mode 100644
index 000000000..8706c5c29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr35154.c
@@ -0,0 +1,34 @@
+/* Test to make sure that stabs for C symbols that go into .comm have the
+   proper structure.  These should be lettered G for the struct that gives
+   the name to the .comm, and should be V or S for .lcomm symbols.  */
+
+static char i_outer;
+struct {
+   char f1;
+   char f2;
+} opta;
+struct {
+   char f1;
+   char f2;
+} optb;
+
+int
+main()
+{
+   static char i_inner[2];
+   i_inner[0] = 'a'; i_inner[1] = 'b';
+   opta.f1 = 'c';
+   opta.f2 = 'd';
+   optb.f1 = 'C';
+   optb.f2 = 'D';
+   i_outer = 'e';
+/* { dg-do compile } */
+/* { dg-skip-if "No stabs" { mmix-*-* *-*-netware* alpha*-*-* hppa*64*-*-* ia64-*-* *-*-vxworks* } { "*" } { "" } } */
+/* { dg-skip-if "stabs only" { *-*-* } { "*" } { "-gstabs" } } */
+   return 0;
+}
+
+/* { dg-final { scan-assembler ".stabs.*i_inner:V" } } */
+/* { dg-final { scan-assembler ".stabs.*i_outer:S" } } */
+/* { dg-final { scan-assembler ".stabs.*opta:G" } } */
+/* { dg-final { scan-assembler ".stabs.*optb:G" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-1.c
new file mode 100644
index 000000000..e3c913b6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-1.c
@@ -0,0 +1,23 @@
+/* PR debug/36690 */
+/* Verify that break func is hit.  
+   This version of the test just checks that it can be compiled, linked
+   and executed, further testing is done in corresponding gcc.dg/dwarf2/
+   test and hopefully in gdb testsuite.  */
+/* { dg-do run } */
+/* { dg-options "-O0 -g -dA" } */
+
+int i;
+
+void
+func (void)
+{
+  while (i == 1)
+    i = 0;
+}
+
+int
+main (void)
+{
+  func ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-2.c
new file mode 100644
index 000000000..ddda18cf7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-2.c
@@ -0,0 +1,40 @@
+/* PR debug/36690 */
+/* Verify that breakpoint can be put on goto f1, it is hit and
+   varz at that spot is defined and contains 5.  Nowhere else
+   in the function should be varz in the scope.
+   This version of the test just checks that it can be compiled, linked
+   and executed, further testing is done in corresponding gcc.dg/dwarf2/
+   test and hopefully in gdb testsuite.  */
+/* { dg-do run } */
+/* { dg-options "-O0 -g -dA" } */
+
+int cnt;
+
+void
+bar (int i)
+{
+  cnt += i;
+}
+
+void
+foo (int i)
+{
+  if (!i)
+    bar (0);
+  else
+    {
+      static int varz = 5;
+      goto f1;
+    }
+  bar (1);
+f1:
+  bar (2);
+}
+
+int
+main (void)
+{
+  foo (0);
+  foo (1);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-3.c
new file mode 100644
index 000000000..62d3494da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr36690-3.c
@@ -0,0 +1,47 @@
+/* PR debug/36690 */
+/* { dg-do run } */
+/* { dg-options "-O0 -g -dA" } */
+
+int cnt;
+
+void
+bar (int i)
+{
+  cnt += i;
+}
+
+void
+foo (int i, int j)
+{
+  if (j)
+    {
+      bar (i + 1);
+      goto f1;
+    }
+  bar (i + 2);
+  goto f2;
+f1:
+  if (i > 10)
+    goto f3;
+f2:
+  if (i > 40)
+    goto f4;
+  else
+    goto f5;
+f3:
+  bar (i);
+f4:
+  bar (i);
+f5:
+  bar (i);
+}
+
+int
+main (void)
+{
+  foo (0, 1);
+  foo (11, 1);
+  foo (21, 0);
+  foo (41, 0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr37616.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr37616.c
new file mode 100644
index 000000000..3bbaebbdf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr37616.c
@@ -0,0 +1,40 @@
+/* PR debug/37616 */
+/* Test that one can put breakpoints onto continue, exitlab and break
+   and actually see program reaching those breakpoints.
+   This version of the test just checks that it can be compiled, linked
+   and executed, further testing is done in corresponding gcc.dg/dwarf2/
+   test and hopefully in gdb testsuite.  */
+/* { dg-do run } */
+/* { dg-options "-O0 -g -dA" } */
+
+extern void abort (void);
+
+int
+foo (int parm)
+{
+  int varj, varm;
+
+  for (varj = 0; varj < 10; varj++)
+    {
+      if (varj == 5)
+	continue;
+      if (varj == 7 && !parm)
+	goto exitlab;
+      if (varj == 9)
+	break;
+      varm = varj;
+    }
+
+exitlab:
+  return varm;
+}
+
+int
+main (void)
+{
+  if (foo (0) != 6)
+    abort ();
+  if (foo (1) != 8)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr39412.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr39412.c
new file mode 100644
index 000000000..71b7b5e21
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr39412.c
@@ -0,0 +1,16 @@
+/* PR debug/39412 */
+/* { dg-do compile } */
+
+struct S { int i; };
+
+inline void
+bar (const void *x, unsigned long y)
+{
+  const union { struct S a[y]; } *u = x;
+}
+
+void
+foo (const void *x, unsigned long y)
+{
+  bar (x, y);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr41717.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr41717.c
new file mode 100644
index 000000000..21250883a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr41717.c
@@ -0,0 +1,10 @@
+/* PR debug/41717 */
+/* { dg-do compile } */
+
+void
+foo (void)
+{
+  _Complex float v[1], w;
+  v[1] = 0.0f + 0.8fi;
+  w = __builtin_conjf (v[1] * v[1]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr42244.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr42244.c
new file mode 100644
index 000000000..ff2542873
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/pr42244.c
@@ -0,0 +1,13 @@
+/* PR debug/42444 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g -fmodulo-sched -ffloat-store" } */
+
+extern int a, b;
+
+double
+foo (double x)
+{
+  for (; a > b; a--)
+    x *= (double) a;
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-1.c
new file mode 100644
index 000000000..14a453e04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-1.c
@@ -0,0 +1,352 @@
+/* Test for multiple declarations and composite types.  As in bug
+   13801.  Test no problems in debug information generation.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int IA[];
+typedef int A10[10];
+
+/* Test all combinations of: a variable declared at file scope (no
+   type specifiers, or extern, or static), or just inside a function
+   (with extern), redeclared in an inner scope (with extern), and
+   redeclared in an inner scope when the previous declaration is
+   hidden (with extern, and not if the original declaration was
+   static).  Test three times: incomplete variable types; pointers to
+   incomplete types; functions returning such pointers.
+
+   This test only includes the valid code cases, to test debug info
+   generation.  (Incomplete static at file scope is not permitted by
+   ISO C, but is accepted by GCC as an extension without
+   -pedantic.)  */
+
+A10 a5;
+void
+f5 (void)
+{
+  sizeof(a5);
+  {
+    extern IA a5;
+    sizeof(a5);
+    {
+      int a5;
+      {
+        extern A10 a5;
+        sizeof(a5);
+      }
+    }
+    sizeof(a5);
+  }
+  sizeof(a5);
+}
+extern A10 a5;
+
+A10 a7;
+void
+f7 (void)
+{
+  sizeof(a7);
+  {
+    extern A10 a7;
+    sizeof(a7);
+    {
+      int a7;
+      {
+        extern A10 a7;
+        sizeof(a7);
+      }
+    }
+    sizeof(a7);
+  }
+  sizeof(a7);
+}
+extern A10 a7;
+
+extern A10 a13;
+void
+f13 (void)
+{
+  sizeof(a13);
+  {
+    extern IA a13;
+    sizeof(a13);
+    {
+      int a13;
+      {
+        extern A10 a13;
+        sizeof(a13);
+      }
+    }
+    sizeof(a13);
+  }
+  sizeof(a13);
+}
+extern A10 a13;
+
+extern A10 a15;
+void
+f15 (void)
+{
+  sizeof(a15);
+  {
+    extern A10 a15;
+    sizeof(a15);
+    {
+      int a15;
+      {
+        extern A10 a15;
+        sizeof(a15);
+      }
+    }
+    sizeof(a15);
+  }
+  sizeof(a15);
+}
+extern A10 a15;
+
+
+static A10 a18;
+void
+f18 (void)
+{
+  sizeof(a18);
+  {
+    extern IA a18;
+    sizeof(a18);
+  }
+  sizeof(a18);
+}
+extern A10 a18;
+
+static A10 a19;
+void
+f19 (void)
+{
+  sizeof(a19);
+  {
+    extern A10 a19;
+    sizeof(a19);
+  }
+  sizeof(a19);
+}
+extern A10 a19;
+
+A10 *b5;
+void
+g5 (void)
+{
+  sizeof(*b5);
+  {
+    extern IA *b5;
+    sizeof(*b5);
+    {
+      int b5;
+      {
+        extern A10 *b5;
+        sizeof(*b5);
+      }
+    }
+    sizeof(*b5);
+  }
+  sizeof(*b5);
+}
+extern A10 *b5;
+
+A10 *b7;
+void
+g7 (void)
+{
+  sizeof(*b7);
+  {
+    extern A10 *b7;
+    sizeof(*b7);
+    {
+      int b7;
+      {
+        extern A10 *b7;
+        sizeof(*b7);
+      }
+    }
+    sizeof(*b7);
+  }
+  sizeof(*b7);
+}
+extern A10 *b7;
+
+extern A10 *b13;
+void
+g13 (void)
+{
+  sizeof(*b13);
+  {
+    extern IA *b13;
+    sizeof(*b13);
+    {
+      int b13;
+      {
+        extern A10 *b13;
+        sizeof(*b13);
+      }
+    }
+    sizeof(*b13);
+  }
+  sizeof(*b13);
+}
+extern A10 *b13;
+
+extern A10 *b15;
+void
+g15 (void)
+{
+  sizeof(*b15);
+  {
+    extern A10 *b15;
+    sizeof(*b15);
+    {
+      int b15;
+      {
+        extern A10 *b15;
+        sizeof(*b15);
+      }
+    }
+    sizeof(*b15);
+  }
+  sizeof(*b15);
+}
+extern A10 *b15;
+
+static A10 *b18;
+void
+g18 (void)
+{
+  sizeof(*b18);
+  {
+    extern IA *b18;
+    sizeof(*b18);
+  }
+  sizeof(*b18);
+}
+extern A10 *b18;
+
+static A10 *b19;
+void
+g19 (void)
+{
+  sizeof(*b19);
+  {
+    extern A10 *b19;
+    sizeof(*b19);
+  }
+  sizeof(*b19);
+}
+extern A10 *b19;
+
+A10 *c5 (void);
+void
+h5 (void)
+{
+  sizeof(*c5());
+  {
+    extern IA *c5 (void);
+    sizeof(*c5());
+    {
+      int c5;
+      {
+        extern A10 *c5 (void);
+        sizeof(*c5());
+      }
+    }
+    sizeof(*c5());
+  }
+  sizeof(*c5());
+}
+A10 *c5 (void) { return 0; }
+
+A10 *c7 (void);
+void
+h7 (void)
+{
+  sizeof(*c7());
+  {
+    extern A10 *c7 (void);
+    sizeof(*c7());
+    {
+      int c7;
+      {
+        extern A10 *c7 (void);
+        sizeof(*c7());
+      }
+    }
+    sizeof(*c7());
+  }
+  sizeof(*c7());
+}
+A10 *c7 (void) { return 0; }
+
+extern A10 *c13 (void);
+void
+h13 (void)
+{
+  sizeof(*c13());
+  {
+    extern IA *c13 (void);
+    sizeof(*c13());
+    {
+      int c13;
+      {
+        extern A10 *c13 (void);
+        sizeof(*c13());
+      }
+    }
+    sizeof(*c13());
+  }
+  sizeof(*c13());
+}
+extern A10 *c13 (void) { return 0; }
+
+extern A10 *c15 (void);
+void
+h15 (void)
+{
+  sizeof(*c15());
+  {
+    extern A10 *c15 (void);
+    sizeof(*c15());
+    {
+      int c15;
+      {
+        extern A10 *c15 (void);
+        sizeof(*c15());
+      }
+    }
+    sizeof(*c15());
+  }
+  sizeof(*c15());
+}
+extern A10 *c15 (void) { return 0; }
+
+static A10 *c18 (void);
+void
+h18 (void)
+{
+  sizeof(*c18());
+  {
+    extern IA *c18 (void);
+    sizeof(*c18());
+  }
+  sizeof(*c18());
+}
+static A10 *c18 (void) { return 0; }
+
+static A10 *c19 (void);
+void
+h19 (void)
+{
+  sizeof(*c19());
+  {
+    extern A10 *c19 (void);
+    sizeof(*c19());
+  }
+  sizeof(*c19());
+}
+static A10 *c19 (void) { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-2.c
new file mode 100644
index 000000000..2bf661fdc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-2.c
@@ -0,0 +1,24 @@
+/* Test for multiple declarations and composite types.  As in bug
+   13801.  Illustrates how bug causes correct code to be wrongly
+   diagnosed.  Debug test: avoid ICE.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int IA[];
+typedef int A5[5];
+typedef int A10[10];
+
+A10 array10;
+
+A5 *ap;
+void
+f (void)
+{
+  int ap;
+  {
+    extern IA *ap;
+    /* This assignment is valid.  */
+    ap = &array10;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-3.c
new file mode 100644
index 000000000..3f0c053a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-3.c
@@ -0,0 +1,12 @@
+/* Test for multiple declarations and composite types.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int y[];
+void
+g (void)
+{
+  extern int y[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-4.c
new file mode 100644
index 000000000..aac4ee7d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-4.c
@@ -0,0 +1,12 @@
+/* Test for multiple declarations and composite types.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+static int y[];
+void
+g (void)
+{
+  extern int y[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-5.c
new file mode 100644
index 000000000..b915b3fdf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/redecl-5.c
@@ -0,0 +1,31 @@
+/* Test for multiple declarations and composite types, as in bug
+   13801.  Test types saved from outer scopes are up to date.  Debug
+   test.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int x[];
+
+void
+f (void)
+{
+  extern int x[];
+}
+
+int x[10];
+
+void
+g (void)
+{
+  int x;
+  {
+    extern int x[10];
+  }
+}
+
+void
+h (void)
+{
+  sizeof (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/trivial.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/trivial.c
new file mode 100644
index 000000000..5b125eca9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/debug/trivial.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+
+int main(void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-1.c
new file mode 100644
index 000000000..bfbc9fb53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-1.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.
+
+   Source: Neil Booth, 12 Feb 2002.
+
+   In the declaration of proc, x must be parsed as a typedef name (C99
+   6.7.5.3 p11.  Also see C89 DR #009, which was erroneously ommitted
+   from C99, and resubmitted as DR #249: if in a parameter
+   declaration, an identifier can be read as a typedef name or a
+   paramter name, it is read as a typedef name).  */
+
+/* { dg-do compile } */
+
+typedef int x;
+typedef int y;
+int proc(int (x));	/* x is a typedef, param to proc is a function.  */
+int proc2(int x);	/* x is an identifier, param is an int.  */
+
+/* Parameter to proc3 is unnamed, with type a function that returns
+   int and takes a single argument of type function with one int
+   parameter returning int.  In particular, proc3 is not a function
+   that takes a parameter y that is a function with one int parameter
+   returning int.  8-)  */
+int proc3(int (y (x)));
+
+int main ()
+{
+  proc (proc2);		/* { dg-bogus "integer from pointer" } */
+  return proc3 (proc);  /* { dg-bogus "incompatible pointer type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-2.c
new file mode 100644
index 000000000..40d744c92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-2.c
@@ -0,0 +1,16 @@
+/* PR c/7411 */
+/* Contributed by Christian Ehrhardt */
+/* Added extra line-breaks to check that diagnostics refer to correct token.
+   --Per Bothner. */
+/* { dg-do compile } */
+
+void foo(void)
+{
+  char
+    c	/* { dg-message "note: previous declaration" } */
+    ;
+  int i;
+  int
+    c	/* { dg-error "conflicting types" } */
+    = i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-3.c
new file mode 100644
index 000000000..cba0b906d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-3.c
@@ -0,0 +1,5 @@
+/* PR c/9928 */
+/* { dg-do compile } */
+
+enum { CODES }; /* { dg-message "note: previous definition" } */
+enum { CODES }; /* { dg-error "conflicting types|redeclaration of enumerator" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-4.c
new file mode 100644
index 000000000..ce640c99c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-4.c
@@ -0,0 +1,10 @@
+/* Redeclaration of parameters is an error.  PR 13728.  */
+/* { dg-do compile } */
+
+void f (int fred,	/* { dg-message "note: previous definition" "" } */
+	int fred);	/* { dg-error "redefinition of parameter" "" } */
+
+void f2 (int fred,	/* { dg-message "note: previous definition" "" } */
+	 int fred)	/* { dg-error "redefinition of parameter" "" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-5.c
new file mode 100644
index 000000000..9b7782464
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-5.c
@@ -0,0 +1,20 @@
+/* PR c/14114 */
+/* Origin: <snyder@fnal.gov> */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+/* This used to fail because the compiler thought that the
+   declaration of 'c' from 'b' was shadowing that from 'a'.  */
+
+void a()
+{
+  void c();
+  c();
+}
+
+void b()
+{
+  void c();
+}
+
+void c() {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-6.c
new file mode 100644
index 000000000..0fd45d3c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-6.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+
+extern int var;
+
+int foo1(void)
+{
+  extern int var;
+
+  var += 1;
+}
+
+int foo2(void)
+{
+  var += 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-7.c
new file mode 100644
index 000000000..14b67baef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-7.c
@@ -0,0 +1,6 @@
+/* Test diagnostic for array defaulting to one element.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int a[]; /* { dg-warning "array 'a' assumed to have one element" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-8.c
new file mode 100644
index 000000000..d0da48f7b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-8.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for duplicate typedefs.  Basic diagnostics.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int I; /* { dg-message "note: previous declaration of 'I' was here" } */
+typedef int I; /* { dg-error "redefinition of typedef 'I'" } */
+
+typedef int I1; /* { dg-message "note: previous declaration of 'I1' was here" } */
+typedef long I1; /* { dg-error "conflicting types for 'I1'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-global-ext.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-global-ext.c
new file mode 100644
index 000000000..97ffa7c2f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-global-ext.c
@@ -0,0 +1,13 @@
+int merror = 0;
+extern int merror;
+
+void mtherr (int code)       
+{
+  merror = code + 1;
+}
+
+int main()
+{
+	mtherr(7);
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-1.c
new file mode 100644
index 000000000..5767c3b08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-1.c
@@ -0,0 +1,8 @@
+/* Data definition with no type or storage class should receive a
+   pedwarn, rather than a warning which becomes an error with
+   -pedantic.  Test with no options.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+foo(); /* { dg-warning "data definition has no type or storage class" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-2.c
new file mode 100644
index 000000000..ab628949b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-2.c
@@ -0,0 +1,8 @@
+/* Data definition with no type or storage class should receive a
+   pedwarn, rather than a warning which becomes an error with
+   -pedantic.  Test with -pedantic.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+foo(); /* { dg-warning "data definition has no type or storage class" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-3.c
new file mode 100644
index 000000000..8fb03ea4c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/decl-nospec-3.c
@@ -0,0 +1,8 @@
+/* Data definition with no type or storage class should receive a
+   pedwarn, rather than a warning which becomes an error with
+   -pedantic.  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+foo(); /* { dg-error "data definition has no type or storage class" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-1.c
new file mode 100644
index 000000000..c19f1074e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-1.c
@@ -0,0 +1,27 @@
+/* Test declaration specifiers.  Test cases that used to be handled in
+   a loop in grokdeclarator.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+typedef int t;
+
+/* These should all be diagnosed, but only once, not for every
+   identifier declared.  */
+struct s0 int x0, /* { dg-error "two or more data types" } */
+x1;
+
+char union u0 x2, /* { dg-error "two or more data types" } */
+x3;
+
+enum e0 struct s1 x4, /* { dg-error "two or more data types" } */
+x5;
+
+short short x6, /* { dg-error "duplicate" } */
+x7;
+
+t int x8, /* { dg-error "two or more data types" } */
+x9;
+
+long long long x10, /* { dg-error "long long long" } */
+x11;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-10.c
new file mode 100644
index 000000000..d29fb7ab4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-10.c
@@ -0,0 +1,45 @@
+/* Test declaration specifiers.  Test various checks on storage class
+   and function specifiers that depend on information about the
+   declaration, not just the specifiers.  Test with -pedantic.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+auto void f0 (void) {} /* { dg-warning "function definition declared 'auto'" } */
+register void f1 (void) {} /* { dg-error "function definition declared 'register'" } */
+typedef void f2 (void) {} /* { dg-error "function definition declared 'typedef'" } */
+
+void f3 (auto int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f4 (extern int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f5 (register int);
+void f6 (static int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f7 (typedef int); /* { dg-error "storage class specified for parameter 'type name'" } */
+
+auto int x; /* { dg-error "file-scope declaration of 'x' specifies 'auto'" } */
+register int y; /* { dg-warning "file-scope declaration of 'y' specifies 'register'" } */
+
+void h (void) { extern void x (void) {} } /* { dg-error "nested function 'x' declared 'extern'" } */
+/* { dg-warning "ISO C forbids nested functions" "nested" { target *-*-* } 21 } */
+
+void
+g (void)
+{
+  void a; /* { dg-error "variable or field 'a' declared void" } */
+  const void b; /* { dg-error "variable or field 'b' declared void" } */
+  static void c; /* { dg-error "variable or field 'c' declared void" } */
+}
+
+void p;
+const void p1;
+extern void q;
+extern const void q1;
+static void r; /* { dg-error "variable or field 'r' declared void" } */
+static const void r1; /* { dg-error "variable or field 'r1' declared void" } */
+
+register void f8 (void); /* { dg-error "invalid storage class for function 'f8'" } */
+/* { dg-warning "file-scope declaration of 'f8' specifies 'register'" "register function" { target *-*-* } 39 } */
+
+void i (void) { auto void y (void) {} } /* { dg-warning "ISO C forbids nested functions" } */
+/* { dg-warning "function definition declared 'auto'" "nested" { target *-*-* } 42 } */
+
+inline int main (void) { return 0; } /* { dg-warning "cannot inline function 'main'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-11.c
new file mode 100644
index 000000000..4204b6f21
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-11.c
@@ -0,0 +1,45 @@
+/* Test declaration specifiers.  Test various checks on storage class
+   and function specifiers that depend on information about the
+   declaration, not just the specifiers.  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+auto void f0 (void) {} /* { dg-error "function definition declared 'auto'" } */
+register void f1 (void) {} /* { dg-error "function definition declared 'register'" } */
+typedef void f2 (void) {} /* { dg-error "function definition declared 'typedef'" } */
+
+void f3 (auto int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f4 (extern int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f5 (register int);
+void f6 (static int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f7 (typedef int); /* { dg-error "storage class specified for parameter 'type name'" } */
+
+auto int x; /* { dg-error "file-scope declaration of 'x' specifies 'auto'" } */
+register int y; /* { dg-error "file-scope declaration of 'y' specifies 'register'" } */
+
+void h (void) { extern void x (void) {} } /* { dg-error "nested function 'x' declared 'extern'" } */
+/* { dg-error "ISO C forbids nested functions" "nested" { target *-*-* } 21 } */
+
+void
+g (void)
+{
+  void a; /* { dg-error "variable or field 'a' declared void" } */
+  const void b; /* { dg-error "variable or field 'b' declared void" } */
+  static void c; /* { dg-error "variable or field 'c' declared void" } */
+}
+
+void p;
+const void p1;
+extern void q;
+extern const void q1;
+static void r; /* { dg-error "variable or field 'r' declared void" } */
+static const void r1; /* { dg-error "variable or field 'r1' declared void" } */
+
+register void f8 (void); /* { dg-error "invalid storage class for function 'f8'" } */
+/* { dg-error "file-scope declaration of 'f8' specifies 'register'" "register function" { target *-*-* } 39 } */
+
+void i (void) { auto void y (void) {} } /* { dg-error "ISO C forbids nested functions" } */
+/* { dg-error "function definition declared 'auto'" "nested" { target *-*-* } 42 } */
+
+inline int main (void) { return 0; } /* { dg-error "cannot inline function 'main'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-12.c
new file mode 100644
index 000000000..66c153740
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-12.c
@@ -0,0 +1,6 @@
+/* Test type qualifier in empty declaration: OK but useless.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+const struct foo; /* { dg-warning "useless type qualifier in empty declaration" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-13.c
new file mode 100644
index 000000000..a325c0d88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-13.c
@@ -0,0 +1,86 @@
+/* Test declaration specifiers.  Test messages for bad type
+   specifiers.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -pedantic" } */
+
+/* typeof should act much like typedef, so the following are
+   invalid.  */
+typeof(double) long x0; /* { dg-error "two or more data types in declaration specifiers" } */
+typeof(double) _Complex x1; /* { dg-error "two or more data types in declaration specifiers" } */
+
+/* The following is erroneous, and used to get a bogus message about
+   complex integer types.  */
+typedef double D;
+D _Complex x2; /* { dg-error "two or more data types in declaration specifiers" } */
+
+/* The following empty declarations should have problems in their type
+   specifiers diagnosed, not just the general problem that they are
+   empty declarations.  */
+long short; /* { dg-error "both 'long' and 'short' in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 20 } */
+_Complex double; /* { dg-warning "ISO C90 does not support complex types" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 22 } */
+_Complex; /* { dg-warning "ISO C90 does not support complex types" } */
+/* { dg-warning "ISO C does not support plain 'complex' meaning 'double complex'" "ISO C" { target *-*-* } 24 } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 24 } */
+_Complex int; /* { dg-warning "ISO C90 does not support complex types" } */
+/* { dg-warning "ISO C does not support complex integer types" "ISO C" { target *-*-* } 27 } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 27 } */
+
+/* Specific messages for each invalid combination.  (That some message
+   is given when appropriate for a larger collection of combinations
+   of type specifiers is tested in *typespec*.c.)  */
+
+long double long x3; /* { dg-error "both 'long long' and 'double' in declaration specifiers" } */
+short long x4; /* { dg-error "both 'long' and 'short' in declaration specifiers" } */
+void long x5; /* { dg-error "both 'long' and 'void' in declaration specifiers" } */
+_Bool long x6; /* { dg-error "both 'long' and '_Bool' in declaration specifiers" } */
+char long x7; /* { dg-error "both 'long' and 'char' in declaration specifiers" } */
+float long x8; /* { dg-error "both 'long' and 'float' in declaration specifiers" } */
+long short x9; /* { dg-error "both 'long' and 'short' in declaration specifiers" } */
+void short x10; /* { dg-error "both 'short' and 'void' in declaration specifiers" } */
+_Bool short x11; /* { dg-error "both 'short' and '_Bool' in declaration specifiers" } */
+char short x12; /* { dg-error "both 'short' and 'char' in declaration specifiers" } */
+float short x13; /* { dg-error "both 'short' and 'float' in declaration specifiers" } */
+double short x14; /* { dg-error "both 'short' and 'double' in declaration specifiers" } */
+unsigned signed x15; /* { dg-error "both 'signed' and 'unsigned' in declaration specifiers" } */
+void signed x16; /* { dg-error "both 'signed' and 'void' in declaration specifiers" } */
+_Bool signed x17; /* { dg-error "both 'signed' and '_Bool' in declaration specifiers" } */
+float signed x18; /* { dg-error "both 'signed' and 'float' in declaration specifiers" } */
+double signed x19; /* { dg-error "both 'signed' and 'double' in declaration specifiers" } */
+signed unsigned x20; /* { dg-error "both 'signed' and 'unsigned' in declaration specifiers" } */
+void unsigned x21; /* { dg-error "both 'unsigned' and 'void' in declaration specifiers" } */
+_Bool unsigned x22; /* { dg-error "both 'unsigned' and '_Bool' in declaration specifiers" } */
+float unsigned x23; /* { dg-error "both 'unsigned' and 'float' in declaration specifiers" } */
+double unsigned x24; /* { dg-error "both 'unsigned' and 'double' in declaration specifiers" } */
+void _Complex x25; /* { dg-error "both 'complex' and 'void' in declaration specifiers" } */
+/* { dg-warning "ISO C90 does not support complex types" "C90" { target *-*-* } 57 } */
+_Bool _Complex x26; /* { dg-error "both 'complex' and '_Bool' in declaration specifiers" } */
+/* { dg-warning "ISO C90 does not support complex types" "C90" { target *-*-* } 59 } */
+
+long void x27; /* { dg-error "both 'long' and 'void' in declaration specifiers" } */
+short void x28; /* { dg-error "both 'short' and 'void' in declaration specifiers" } */
+signed void x29; /* { dg-error "both 'signed' and 'void' in declaration specifiers" } */
+unsigned void x30; /* { dg-error "both 'unsigned' and 'void' in declaration specifiers" } */
+_Complex void x31; /* { dg-error "both 'complex' and 'void' in declaration specifiers" } */
+/* { dg-warning "ISO C90 does not support complex types" "C90" { target *-*-* } 66 } */
+/* { dg-warning "ISO C does not support plain 'complex' meaning 'double complex'" "complex" { target *-*-* } 66 } */
+long _Bool x32; /* { dg-error "both 'long' and '_Bool' in declaration specifiers" } */
+short _Bool x33; /* { dg-error "both 'short' and '_Bool' in declaration specifiers" } */
+signed _Bool x34; /* { dg-error "both 'signed' and '_Bool' in declaration specifiers" } */
+unsigned _Bool x35; /* { dg-error "both 'unsigned' and '_Bool' in declaration specifiers" } */
+_Complex _Bool x36; /* { dg-error "both 'complex' and '_Bool' in declaration specifiers" } */
+/* { dg-warning "ISO C90 does not support complex types" "C90" { target *-*-* } 73 } */
+/* { dg-warning "ISO C does not support plain 'complex' meaning 'double complex'" "complex" { target *-*-* } 73 } */
+long char x37; /* { dg-error "both 'long' and 'char' in declaration specifiers" } */
+short char x38; /* { dg-error "both 'short' and 'char' in declaration specifiers" } */
+long float x39; /* { dg-error "both 'long' and 'float' in declaration specifiers" } */
+short float x40; /* { dg-error "both 'short' and 'float' in declaration specifiers" } */
+signed float x41; /* { dg-error "both 'signed' and 'float' in declaration specifiers" } */
+unsigned float x42; /* { dg-error "both 'unsigned' and 'float' in declaration specifiers" } */
+long long double x43; /* { dg-error "both 'long long' and 'double' in declaration specifiers" } */
+/* { dg-warning "ISO C90 does not support 'long long'" "C90" { target *-*-* } 82 } */
+short double x44; /* { dg-error "both 'short' and 'double' in declaration specifiers" } */
+signed double x45; /* { dg-error "both 'signed' and 'double' in declaration specifiers" } */
+unsigned double x46; /* { dg-error "both 'unsigned' and 'double' in declaration specifiers" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-14.c
new file mode 100644
index 000000000..d8ec78c9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-14.c
@@ -0,0 +1,11 @@
+/* Test that "typeof(struct foo)" and similar as declaration
+   specifiers act like typedef.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typeof(struct foo); /* { dg-warning "useless type name in empty declaration" } */
+
+struct bar { int a; } x;
+
+typeof(x); /* { dg-warning "useless type name in empty declaration" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-15.c
new file mode 100644
index 000000000..dc3da61c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-15.c
@@ -0,0 +1,12 @@
+/* Test diagnostic for empty declarations in old-style parameter
+   declarations.  Test with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+void
+f (a, b)
+     int; /* { dg-warning "empty declaration" } */
+     register; /* { dg-warning "empty declaration" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-16.c
new file mode 100644
index 000000000..598623930
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-16.c
@@ -0,0 +1,12 @@
+/* Test diagnostic for empty declarations in old-style parameter
+   declarations.  Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -pedantic" } */
+
+void
+f (a, b)
+     int; /* { dg-warning "empty declaration" } */
+     register; /* { dg-warning "empty declaration" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-17.c
new file mode 100644
index 000000000..d27faa1b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-17.c
@@ -0,0 +1,12 @@
+/* Test diagnostic for empty declarations in old-style parameter
+   declarations.  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -pedantic-errors" } */
+
+void
+f (a, b)
+     int; /* { dg-error "empty declaration" } */
+     register; /* { dg-error "empty declaration" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-2.c
new file mode 100644
index 000000000..f2c535ad8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-2.c
@@ -0,0 +1,14 @@
+/* Test declaration specifiers.  Test cases that used to be handled in
+   a loop in grokdeclarator.  Pedantic cases.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -pedantic" } */
+
+/* These should all be diagnosed, but only once, not for every
+   identifier declared.  */
+
+const const int x0, /* { dg-warning "duplicate" } */
+x1;
+
+long long x2, /* { dg-warning "long long" } */
+x3;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3-Wextra.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3-Wextra.c
new file mode 100644
index 000000000..66378cc71
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3-Wextra.c
@@ -0,0 +1,32 @@
+/* See declspec-3.c . Test -Wold-style-declaration is enabled by -Wextra. */
+/* { dg-do compile } */
+/* { dg-options "-Wextra" } */
+
+static int x0;
+int static x1; /* { dg-warning "not at beginning" } */
+
+extern int x2;
+int extern x3; /* { dg-warning "not at beginning" } */
+
+typedef int x4;
+int typedef x5; /* { dg-warning "not at beginning" } */
+
+void g (int);
+
+void
+f (void)
+{
+  auto int x6 = 0;
+  int auto x7 = 0; /* { dg-warning "not at beginning" } */
+  register int x8 = 0;
+  int register x9 = 0; /* { dg-warning "not at beginning" } */
+  g (x6 + x7 + x8 + x9);
+}
+
+const static int x10; /* { dg-warning "not at beginning" } */
+
+/* Attributes are OK before storage class specifiers, since some
+   attributes are like such specifiers themselves.  */
+
+__attribute__((format(printf, 1, 2))) static void h (const char *, ...);
+__attribute__((format(printf, 1, 2))) void static i (const char *, ...); /* { dg-warning "not at beginning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3-no.c
new file mode 100644
index 000000000..678b4f2d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3-no.c
@@ -0,0 +1,32 @@
+/* See declspec-3.c . Test disabling -Wold-style-declaration. */
+/* { dg-do compile } */
+/* { dg-options "-Wextra -Wno-old-style-declaration" } */
+
+static int x0;
+int static x1; /* { dg-bogus "not at beginning" } */
+
+extern int x2;
+int extern x3; /* { dg-bogus "not at beginning" } */
+
+typedef int x4;
+int typedef x5; /* { dg-bogus "not at beginning" } */
+
+void g (int);
+
+void
+f (void)
+{
+  auto int x6 = 0;
+  int auto x7 = 0; /* { dg-bogus "not at beginning" } */
+  register int x8 = 0;
+  int register x9 = 0; /* { dg-bogus "not at beginning" } */
+  g (x6 + x7 + x8 + x9);
+}
+
+const static int x10; /* { dg-bogus "not at beginning" } */
+
+/* Attributes are OK before storage class specifiers, since some
+   attributes are like such specifiers themselves.  */
+
+__attribute__((format(printf, 1, 2))) static void h (const char *, ...);
+__attribute__((format(printf, 1, 2))) void static i (const char *, ...); /* { dg-bogus "not at beginning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3.c
new file mode 100644
index 000000000..95052a986
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-3.c
@@ -0,0 +1,34 @@
+/* Test declaration specifiers.  Test diagnosis of storage class
+   specifiers not at start.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-Wold-style-declaration" } */
+
+static int x0;
+int static x1; /* { dg-warning "not at beginning" } */
+
+extern int x2;
+int extern x3; /* { dg-warning "not at beginning" } */
+
+typedef int x4;
+int typedef x5; /* { dg-warning "not at beginning" } */
+
+void g (int);
+
+void
+f (void)
+{
+  auto int x6 = 0;
+  int auto x7 = 0; /* { dg-warning "not at beginning" } */
+  register int x8 = 0;
+  int register x9 = 0; /* { dg-warning "not at beginning" } */
+  g (x6 + x7 + x8 + x9);
+}
+
+const static int x10; /* { dg-warning "not at beginning" } */
+
+/* Attributes are OK before storage class specifiers, since some
+   attributes are like such specifiers themselves.  */
+
+__attribute__((format(printf, 1, 2))) static void h (const char *, ...);
+__attribute__((format(printf, 1, 2))) void static i (const char *, ...); /* { dg-warning "not at beginning" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-4.c
new file mode 100644
index 000000000..eb692ca2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-4.c
@@ -0,0 +1,43 @@
+/* Test declaration specifiers.  Test empty declarations.  Test with
+   no special options.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* If a declaration does not declare a declarator, it must declare a
+   tag or the members of an enumeration, and must only contain one
+   type specifier.  */
+
+typedef int T;
+
+struct s0;
+union u0;
+enum e0; /* A GNU extension.  */
+enum { E0 };
+enum e1 { E1 };
+
+/* Not declaring anything (pedwarns).  */
+struct { int a; }; /* { dg-warning "unnamed struct/union that defines no instances" } */
+int; /* { dg-warning "useless type name in empty declaration" } */
+long; /* { dg-warning "useless type name in empty declaration" } */
+T; /* { dg-warning "useless type name in empty declaration" } */
+static const; /* { dg-warning "useless storage class specifier in empty declaration" } */
+/* { dg-warning "empty declaration" "static const" { target *-*-* } 24 } */
+union { long b; }; /* { dg-warning "unnamed struct/union that defines no instances" } */
+
+/* Multiple type names (errors).  */
+struct s1 int; /* { dg-error "two or more data types in declaration specifiers" } */
+char union u1; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "char union" { target *-*-* } 30 } */
+double enum { E2 }; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "double enum" { target *-*-* } 32 } */
+T struct s2; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "T struct" { target *-*-* } 34 } */
+long union u2; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 36 } */
+struct s3 short; /* { dg-error "two or more data types in declaration specifiers" } */
+union u3 signed; /* { dg-error "two or more data types in declaration specifiers" } */
+unsigned struct s4; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 40 } */
+_Complex enum { E3 }; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 42 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-5.c
new file mode 100644
index 000000000..e44412e01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-5.c
@@ -0,0 +1,45 @@
+/* Test declaration specifiers.  Test empty declarations.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+/* If a declaration does not declare a declarator, it must declare a
+   tag or the members of an enumeration, and must only contain one
+   type specifier.  */
+
+typedef int T;
+
+struct s0;
+union u0;
+enum e0; /* { dg-warning "ISO C forbids forward references" } */
+enum { E0 };
+enum e1 { E1 };
+
+/* Not declaring anything (pedwarns).  */
+struct { int a; }; /* { dg-warning "unnamed struct/union that defines no instances" } */
+int; /* { dg-warning "useless type name in empty declaration" } */
+long; /* { dg-warning "useless type name in empty declaration" } */
+T; /* { dg-warning "useless type name in empty declaration" } */
+static const; /* { dg-warning "useless storage class specifier in empty declaration" } */
+/* { dg-warning "empty declaration" "static const" { target *-*-* } 24 } */
+union { long b; }; /* { dg-warning "unnamed struct/union that defines no instances" } */
+
+/* Multiple type names (errors).  */
+struct s1 int; /* { dg-error "two or more data types in declaration specifiers" } */
+char union u1; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "char union" { target *-*-* } 30 } */
+double enum { E2 }; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "double enum" { target *-*-* } 32 } */
+T struct s2; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "T struct" { target *-*-* } 34 } */
+long union u2; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 36 } */
+struct s3 short; /* { dg-error "two or more data types in declaration specifiers" } */
+union u3 signed; /* { dg-error "two or more data types in declaration specifiers" } */
+unsigned struct s4; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 40 } */
+_Complex enum { E3 }; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-warning "useless type name in empty declaration" "empty" { target *-*-* } 42 } */
+/* { dg-warning "ISO C90 does not support complex types" "C90" { target *-*-* } 42 } */
+/* { dg-warning "ISO C does not support plain 'complex' meaning 'double complex'" "ISO C" { target *-*-* } 42 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-6.c
new file mode 100644
index 000000000..a20aa94cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-6.c
@@ -0,0 +1,45 @@
+/* Test declaration specifiers.  Test empty declarations.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+/* If a declaration does not declare a declarator, it must declare a
+   tag or the members of an enumeration, and must only contain one
+   type specifier.  */
+
+typedef int T;
+
+struct s0;
+union u0;
+enum e0; /* { dg-error "ISO C forbids forward references" } */
+enum { E0 };
+enum e1 { E1 };
+
+/* Not declaring anything (pedwarns).  */
+struct { int a; }; /* { dg-error "unnamed struct/union that defines no instances" } */
+int; /* { dg-error "useless type name in empty declaration" } */
+long; /* { dg-error "useless type name in empty declaration" } */
+T; /* { dg-error "useless type name in empty declaration" } */
+static const; /* { dg-warning "useless storage class specifier in empty declaration" } */
+/* { dg-error "empty declaration" "static const" { target *-*-* } 24 } */
+union { long b; }; /* { dg-error "unnamed struct/union that defines no instances" } */
+
+/* Multiple type names (errors).  */
+struct s1 int; /* { dg-error "two or more data types in declaration specifiers" } */
+char union u1; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-error "useless type name in empty declaration" "char union" { target *-*-* } 30 } */
+double enum { E2 }; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-error "useless type name in empty declaration" "double enum" { target *-*-* } 32 } */
+T struct s2; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-error "useless type name in empty declaration" "T struct" { target *-*-* } 34 } */
+long union u2; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-error "useless type name in empty declaration" "empty" { target *-*-* } 36 } */
+struct s3 short; /* { dg-error "two or more data types in declaration specifiers" } */
+union u3 signed; /* { dg-error "two or more data types in declaration specifiers" } */
+unsigned struct s4; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-error "useless type name in empty declaration" "empty" { target *-*-* } 40 } */
+_Complex enum { E3 }; /* { dg-error "two or more data types in declaration specifiers" } */
+/* { dg-error "useless type name in empty declaration" "empty" { target *-*-* } 42 } */
+/* { dg-error "ISO C90 does not support complex types" "C90" { target *-*-* } 42 } */
+/* { dg-error "ISO C does not support plain 'complex' meaning 'double complex'" "ISO C" { target *-*-* } 42 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-7.c
new file mode 100644
index 000000000..370172468
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-7.c
@@ -0,0 +1,39 @@
+/* Test declaration specifiers.  Test checks on storage class
+   specifiers that can be made at parse time rather than for each
+   declarator.  Note that __thread is tested in
+   gcc.dg/tls/diag-*.c.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Duplicate specifiers.  */
+
+inline inline void f0 (void),
+  f1 (void);
+
+static static int a, /* { dg-error "duplicate 'static'" } */
+  b;
+
+extern extern int c, /* { dg-error "duplicate 'extern'" } */
+  d;
+
+typedef typedef int e, /* { dg-error "duplicate 'typedef'" } */
+  f;
+
+void
+h (void)
+{
+  auto auto int p, /* { dg-error "duplicate 'auto'" } */
+    q;
+
+  register register int r, /* { dg-error "duplicate 'register'" } */
+    s;
+}
+
+/* Multiple specifiers.  */
+
+static extern int x, /* { dg-error "multiple storage classes in declaration specifiers" } */
+  y;
+
+extern typedef long z, /* { dg-error "multiple storage classes in declaration specifiers" } */
+  w;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-8.c
new file mode 100644
index 000000000..e1061e85b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-8.c
@@ -0,0 +1,32 @@
+/* Test declaration specifiers.  Test checks on storage class
+   specifiers and function specifiers in empty declarations.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* The constraints on storage class specifiers and function specifiers
+   must be met for empty declarations where they are useless.  Thus
+   there may be only one storage class specifier (C90 6.5.1, C99
+   6.7.1#2) and "inline" must not be used because the declaration is
+   not that of an identifier for a function (C99 6.7.4#1), and
+   "register" and "auto" must not be used at file scope (C90 6.7, C99
+   6.9#2).  */
+
+static static struct s; /* { dg-error "duplicate 'static'" } */
+/* { dg-warning "useless storage class specifier in empty declaration" "static static" { target *-*-* } 15 } */
+
+static extern struct t; /* { dg-error "multiple storage classes in declaration specifiers" } */
+/* { dg-warning "useless storage class specifier in empty declaration" "static extern" { target *-*-* } 18 } */
+
+inline union u; /* { dg-error "'inline' in empty declaration" } */
+
+auto struct v; /* { dg-error "'auto' in file-scope empty declaration" } */
+
+register struct w; /* { dg-error "'register' in file-scope empty declaration" } */
+
+void
+f (void)
+{
+  auto union p; /* { dg-warning "useless storage class specifier in empty declaration" } */
+  register struct q; /* { dg-warning "useless storage class specifier in empty declaration" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-9.c
new file mode 100644
index 000000000..670fe25cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/declspec-9.c
@@ -0,0 +1,43 @@
+/* Test declaration specifiers.  Test various checks on storage class
+   and function specifiers that depend on information about the
+   declaration, not just the specifiers.  Test with no special
+   options.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+auto void f0 (void) {} /* { dg-warning "function definition declared 'auto'" } */
+register void f1 (void) {} /* { dg-error "function definition declared 'register'" } */
+typedef void f2 (void) {} /* { dg-error "function definition declared 'typedef'" } */
+
+void f3 (auto int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f4 (extern int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f5 (register int);
+void f6 (static int); /* { dg-error "storage class specified for parameter 'type name'" } */
+void f7 (typedef int); /* { dg-error "storage class specified for parameter 'type name'" } */
+
+auto int x; /* { dg-error "file-scope declaration of 'x' specifies 'auto'" } */
+register int y;
+
+void h (void) { extern void x (void) {} } /* { dg-error "nested function 'x' declared 'extern'" } */
+
+void
+g (void)
+{
+  void a; /* { dg-error "variable or field 'a' declared void" } */
+  const void b; /* { dg-error "variable or field 'b' declared void" } */
+  static void c; /* { dg-error "variable or field 'c' declared void" } */
+}
+
+void p;
+const void p1;
+extern void q;
+extern const void q1;
+static void r; /* { dg-error "variable or field 'r' declared void" } */
+static const void r1; /* { dg-error "variable or field 'r1' declared void" } */
+
+register void f8 (void); /* { dg-error "invalid storage class for function 'f8'" } */
+
+void i (void) { auto void y (void) {} }
+
+inline int main (void) { return 0; } /* { dg-warning "cannot inline function 'main'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/delay-slot-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/delay-slot-1.c
new file mode 100644
index 000000000..f3bcd8ec7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/delay-slot-1.c
@@ -0,0 +1,59 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mabi=64" { target mips-*-linux-* } } */
+
+struct offset_v1 {
+    int k_uniqueness;
+};
+
+struct offset_v2 {
+ long v;
+} __attribute__ ((__packed__));
+
+struct reiserfs_key {
+    int k_objectid;
+    union {
+ struct offset_v1 k_offset_v1;
+ struct offset_v2 k_offset_v2;
+    } u;
+};
+
+struct item_head
+{
+ struct reiserfs_key ih_key;
+ int ih_version;
+};
+
+static void set_offset_v2_k_type(struct offset_v2 *v2)
+{
+    v2->v &= 1;
+}
+
+static void set_le_key_k_type (int version, struct reiserfs_key * key)
+{
+    version ? (key->u.k_offset_v1.k_uniqueness = 1)
+	    : set_offset_v2_k_type(&(key->u.k_offset_v2));
+}
+
+static void set_le_ih_k_type (struct item_head * ih)
+{
+    set_le_key_k_type((__builtin_constant_p((ih)->ih_version) ? (ih)->ih_version : (ih)->ih_version), &(ih->ih_key));
+}
+
+void boo(struct item_head *ih, const char *body);
+
+void direct2indirect(void)
+{
+    struct item_head *p_le_ih;
+    struct item_head ind_ih;
+    unsigned int unfm_ptr;
+
+    if (__builtin_expect(32, 0)) __asm__ ("break");
+
+    set_le_ih_k_type (&ind_ih);
+
+    if (__builtin_constant_p(p_le_ih) ? 1 : 2) {
+        (__builtin_constant_p(__builtin_constant_p(1) == 1));
+      boo(&ind_ih, (char *)&unfm_ptr);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated-2.c
new file mode 100644
index 000000000..c4ca8a272
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated-2.c
@@ -0,0 +1,7 @@
+/* Test __attribute__((deprecated)).  Test types without names.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct { int a; } __attribute__((deprecated)) x; /* { dg-warning "type is deprecated" } */
+typeof(x) y; /* { dg-warning "type is deprecated" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated-3.c
new file mode 100644
index 000000000..2c35bb314
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated-3.c
@@ -0,0 +1,11 @@
+/* Test __attribute__((deprecated)).  Test merging with multiple
+   declarations.  Bug 7425.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void func(void);
+void func(void) __attribute__((deprecated));
+
+void f(void) {
+  func(); /* { dg-warning "'func' is deprecated" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated.c
new file mode 100644
index 000000000..6ca95d42a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/deprecated.c
@@ -0,0 +1,117 @@
+/* Test __attribute__ ((deprecated)) */
+/* { dg-do compile } */
+/* { dg-options "-Wdeprecated-declarations" } */
+
+#if 1
+typedef int INT1 __attribute__((deprecated));
+typedef INT1 INT2 __attribute__ ((__deprecated__));
+
+typedef INT1 INT1a; 			/* { dg-warning "'INT1' is deprecated" "" } */
+typedef INT1 INT1b __attribute__ ((deprecated));
+
+INT1 should_be_unavailable; 		/* { dg-warning "'INT1' is deprecated" "" } */
+INT1a should_not_be_deprecated;
+
+INT1 f1(void) __attribute__ ((deprecated)); 
+INT1 f2(void) { return 0; }		/* { dg-warning "'INT1' is deprecated" "" } */
+
+INT2 f3(void) __attribute__ ((__deprecated__)); 
+INT2 f4(void) { return 0; }		/* { dg-warning "'INT2' is deprecated" "" } */
+int f5(INT2 x);				/* { dg-warning "'INT2' is deprecated" "" } */
+int f6(INT2 x) __attribute__ ((__deprecated__)); /* { dg-warning "'INT2' is deprecated" "" } */
+
+typedef enum {red, green, blue} Color __attribute__((deprecated));
+
+int g1;
+int g2 __attribute__ ((deprecated));
+int g3 __attribute__ ((__deprecated__));
+Color k;				/* { dg-warning "'Color' is deprecated" "" } */
+
+typedef struct {
+  int field1;
+  int field2 __attribute__ ((deprecated));
+  int field3;
+  int field4 __attribute__ ((__deprecated__));
+  union {
+    int field5;
+    int field6 __attribute__ ((deprecated));
+  } u1;
+  int field7:1;
+  int field8:1 __attribute__ ((deprecated));
+  union {
+    int field9;
+    int field10;
+  } u2 __attribute__ ((deprecated));
+} S1;
+
+int func1()
+{
+   INT1 w;				/* { dg-warning "'INT1' is deprecated" "" } */
+   int x __attribute__ ((deprecated));
+   int y __attribute__ ((__deprecated__));
+   int z;
+   int (*pf)() = f1;			/* { dg-warning "'f1' is deprecated" "" } */
+
+   z = w + x + y + g1 + g2 + g3;	/* { dg-warning "'x' is deprecated" "" } */
+   					/* { dg-warning "'y' is deprecated" "y" { target *-*-* } 55 } */
+   					/* { dg-warning "'g2' is deprecated" "g2" { target *-*-* } 55 } */
+   					/* { dg-warning "'g3' is deprecated" "g3" { target *-*-* } 55 } */
+   return f1(); 			/* { dg-warning "'f1' is deprecated" "f1" } */
+}
+
+int func2(S1 *p)
+{
+  S1 lp;
+  
+  if (p->field1)
+     return p->field2;			/* { dg-warning "'field2' is deprecated" "" } */
+  else if (lp.field4)			/* { dg-warning "'field4' is deprecated" "" } */
+     return p->field3;
+  
+  p->u1.field5 = g1 + p->field7;
+  p->u2.field9;				/* { dg-warning "'u2' is deprecated" "" } */
+  return p->u1.field6 + p->field8;	/* { dg-warning "'field6' is deprecated" "" } */
+  					/* { dg-warning "'field8' is deprecated" "field8" { target *-*-* } 73 } */
+}
+
+struct SS1 {
+  int x;
+  INT1 y; 				/* { dg-warning "'INT1' is deprecated" "" } */
+} __attribute__ ((deprecated));
+
+struct SS1 *p1;				/* { dg-warning "'SS1' is deprecated" "" } */
+
+struct __attribute__ ((__deprecated__)) SS2 {
+  int x;
+  INT1 y; 				/* { dg-warning "'INT1' is deprecated" "" } */
+};
+
+struct SS2 *p2;				/* { dg-warning "'SS2' is deprecated" "" } */
+#endif
+
+#ifdef __cplusplus
+class T {
+  public:
+    void member1(int) __attribute__ ((deprecated));
+    void member2(INT1) __attribute__ ((__deprecated__));
+    int member3(T *);
+    int x;
+} __attribute__ ((deprecated));
+
+T *p2;
+
+inline void T::member1(int) {}
+
+int T::member2(T *p)
+{
+  p->member1(1);			/* { xxdg-warning "'member1' is deprecated" "" } */
+  (*p).member1(2);			/* { xxdg-warning "'member1' is deprecated" "" } */
+  p->member2(1);			/* { xxdg-warning "'member2' is deprecated" "" } */
+  (*p).member2(2);			/* { xxdg-warning "'member2' is deprecated" "" } */
+  p->member3(p);
+  (*p).member3(p);
+  return f1(); 				/* { xxdg-warning "'f1' is deprecated" "" } */
+}
+#endif
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/Wbad-function-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/Wbad-function-cast-1.c
new file mode 100644
index 000000000..95e8ce198
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/Wbad-function-cast-1.c
@@ -0,0 +1,44 @@
+/* Test operation of -Wbad-function-cast.  */
+/* Based on gcc.dg/Wbad-function-cast-1.c.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wbad-function-cast" } */
+
+int if1(void);
+char if2(void);
+long if3(void);
+float rf1(void);
+double rf2(void);
+_Decimal32 rf3(void);
+_Decimal64 rf4(void);
+_Decimal128 rf5(void);
+_Complex double cf(void);
+
+void
+foo(void)
+{
+  /* Casts to void types are always OK.  */
+  (void)rf3();
+  (void)rf4();
+  (void)rf5();
+  (const void)rf3();
+  /* Casts to the same type or similar types are OK.  */
+  (_Decimal32)rf1();
+  (_Decimal64)rf2();
+  (_Decimal128)rf3();
+  (_Decimal128)rf4();
+  (_Decimal128)rf5();
+  (float)rf3();
+  (double)rf4();
+  (long double)rf5();
+   /* Casts to types with different TREE_CODE (which is how this
+     warning has been defined) are not OK, except for casts to void
+     types.  */
+  (_Decimal32)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Decimal32'" } */
+  (_Decimal64)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Decimal64'" } */
+  (_Decimal128)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Decimal128'" } */
+  (int)rf3(); /* { dg-warning "cast from function call of type '_Decimal32' to non-matching type 'int'" } */
+  (long)rf4(); /* { dg-warning "cast from function call of type '_Decimal64' to non-matching type 'long int'" } */
+  (long int)rf5(); /* { dg-warning "cast from function call of type '_Decimal128' to non-matching type 'long int'" } */
+  (_Decimal32)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Decimal32'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/Wtraditional-conversion-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/Wtraditional-conversion-2.c
new file mode 100644
index 000000000..7e0d3ad99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/Wtraditional-conversion-2.c
@@ -0,0 +1,46 @@
+/* Test messages for -Wtraditional-conversion 
+   (based on gcc.dg/Wtraditional-conversion-2.c).  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wtraditional-conversion" } */
+
+void fsi(signed int);
+void fd32(_Decimal32);
+void fd64(_Decimal64);
+void fd128(_Decimal128);
+
+struct s {
+  void (*fsi)(signed int);
+  void (*fd32)(_Decimal32);
+  void (*fd64)(_Decimal64);
+  void (*fd128)(_Decimal128);
+} x;
+
+signed int si;
+unsigned int ui;
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+
+void
+g (void)
+{
+  fsi(d32); /* { dg-warning "passing argument 1 of 'fsi' as integer rather than floating due to prototype" } */
+  x.fsi(d32); /* { dg-warning "passing argument 1 of 'x.fsi' as integer rather than floating due to prototype" } */
+  fsi(d64); /* { dg-warning "passing argument 1 of 'fsi' as integer rather than floating due to prototype" } */
+  x.fsi(d64); /* { dg-warning "passing argument 1 of 'x.fsi' as integer rather than floating due to prototype" } */
+  fsi(d128); /* { dg-warning "passing argument 1 of 'fsi' as integer rather than floating due to prototype" } */
+  x.fsi(d128); /* { dg-warning "passing argument 1 of 'x.fsi' as integer rather than floating due to prototype" } */
+  fd32(si); /* { dg-warning "passing argument 1 of 'fd32' as floating rather than integer due to prototype" } */
+  x.fd32(si); /* { dg-warning "passing argument 1 of 'x.fd32' as floating rather than integer due to prototype" } */  
+  fd64(ui); /* { dg-warning "passing argument 1 of 'fd64' as floating rather than integer due to prototype" } */
+  x.fd64(ui); /* { dg-warning "passing argument 1 of 'x.fd64' as floating rather than integer due to prototype" } */
+  fd128(si); /* { dg-warning "passing argument 1 of 'fd128' as floating rather than integer due to prototype" } */
+  x.fd128(ui); /* { dg-warning "passing argument 1 of 'x.fd128' as floating rather than integer due to prototype" } */  
+  fd32(1.0); /* { dg-warning "passing argument 1 of 'fd32' as '_Decimal32' rather than 'double' due to prototype" } */
+  x.fd32(1.0); /* { dg-warning "passing argument 1 of 'x.fd32' as '_Decimal32' rather than 'double' due to prototype" } */
+  fd64(1.0); /* { dg-warning "passing argument 1 of 'fd64' as '_Decimal64' rather than 'double' due to prototype" } */
+  x.fd64(1.0); /* { dg-warning "passing argument 1 of 'x.fd64' as '_Decimal64' rather than 'double' due to prototype" } */
+  fd128(1.0); /* { dg-warning "passing argument 1 of 'fd128' as '_Decimal128' rather than 'double' due to prototype" } */
+  x.fd128(1.0); /* { dg-warning "passing argument 1 of 'x.fd128' as '_Decimal128' rather than 'double' due to prototype" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/altivec-types.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/altivec-types.c
new file mode 100644
index 000000000..e11ddc5e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/altivec-types.c
@@ -0,0 +1,9 @@
+/* { dg-do compile { target { powerpc*-*-linux* && powerpc_altivec_ok } } } */
+/* { dg-options "-maltivec" } */
+
+/* GNU extension: PowerPC AltiVec Built-in Functions.
+   These should be rejected as invalid AltiVec types.  */
+
+__vector _Decimal32 vd32;		/* { dg-error "AltiVec types" "" } */
+__vector _Decimal64 vd64;		/* { dg-error "AltiVec types" "" } */
+__vector _Decimal128 vd128;		/* { dg-error "AltiVec types" "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/call-by-value.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/call-by-value.c
new file mode 100644
index 000000000..4232a3018
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/call-by-value.c
@@ -0,0 +1,45 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.9.1(9) Function definitions; parameter has automatic storage.
+
+   Test that actual parameters are passed by value and that modifications
+   made within functions are lost on function return.  */
+
+extern void abort (void);
+
+int foo32 (_Decimal32 z)
+{
+  z = z + 1.0df;
+}
+
+int foo64 (_Decimal64 z)
+{
+  z = z + 1.0dd;
+}
+
+int foo128 (_Decimal128 z)
+{
+  z = z + 1.0dl;
+}
+
+int
+main ()
+{
+  _Decimal32 d32 = 1.1df;
+  _Decimal64 d64 = 1.2dd;
+  _Decimal128 d128 = 1.3dl;
+
+  foo32 (d32);
+  if (d32 != 1.1df)
+    abort ();
+
+  foo64 (d64);
+  if (d64 != 1.2dd)
+    abort ();
+
+  foo128 (d128);
+  if (d128 != 1.3dl)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/cast-bad.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/cast-bad.c
new file mode 100644
index 000000000..e99180824
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/cast-bad.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.4 Cast operators.
+   Test invalid casts involving decimal float.  */
+
+struct s { _Decimal32 d32; } sv;
+union u { _Decimal32 d32; } uv;
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+
+_Decimal32* d32p;
+_Decimal64* d64p;
+_Decimal128* d128p;
+
+void
+f (void)
+{
+  (_Decimal32 []) d32p; /* { dg-error "cast specifies array type" } */
+  (_Decimal32 ()) d32p; /* { dg-error "cast specifies function type" } */
+  (_Decimal64 []) d64p; /* { dg-error "cast specifies array type" } */
+  (_Decimal64 ()) d64p; /* { dg-error "cast specifies function type" } */
+  (_Decimal128 []) d128p; /* { dg-error "cast specifies array type" } */
+  (_Decimal128 ()) d128p; /* { dg-error "cast specifies function type" } */
+  
+  (struct s) d32; /* { dg-error "conversion to non-scalar type requested" } */
+  (union u) d32;
+  (struct s) d64; /* { dg-error "conversion to non-scalar type requested" } */
+  (union u) d64; /* { dg-error "cast to union type from type not present in union" } */
+  (struct s) d128; /* { dg-error "conversion to non-scalar type requested" } */
+  (union u) d128; /* { dg-error "cast to union type from type not present in union" } */
+		
+  (_Decimal32) sv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Decimal32) uv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Decimal64) sv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Decimal64) uv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Decimal128) sv; /* { dg-error "aggregate value used where a float was expected" } */
+  (_Decimal128) uv; /* { dg-error "aggregate value used where a float was expected" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/cast.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/cast.c
new file mode 100644
index 000000000..1e88bee7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/cast.c
@@ -0,0 +1,88 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.4 Cast operators.
+   Test valid casts involving decimal float.  */
+
+extern void abort (void);
+int failcnt;
+                                                                                
+#ifdef DBG
+extern int printf (const char *, ...);
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+
+static float f = 2.f;
+static double d = 2.l;
+
+int
+main (void)
+{
+  /* Casts between DFP types.  */
+  d32 = 1.2df;
+  d64 = 1.2dd;
+  d128 = 1.2dl;
+
+  if (d32 != (_Decimal32) d64)
+    FAILURE
+  if (d32 != (_Decimal32) d128)
+    FAILURE
+
+  if (d64 != (_Decimal64) d32)
+    FAILURE
+  if (d64 != (_Decimal64) d128)
+    FAILURE
+
+  if (d128 != (_Decimal128) d32)
+    FAILURE
+  if (d128 != (_Decimal128) d64)
+    FAILURE
+
+  /* Casts between generic and decimal floating point types.  Use a
+     value that we can assume can be represented exactly in all
+     representations. */
+  
+  d32 = 2.0df;
+  d64 = 2.0dd;
+  d128 = 2.0dl;
+
+  /* To generic floating types.  */
+  if ((float) d32 != 2.0f)
+    FAILURE
+  if ((double) d32 != 2.0l)
+    FAILURE
+  if ((float) d64 != 2.0f)
+    FAILURE
+  if ((double) d64 != 2.0l)
+    FAILURE
+  if ((float) d128 != 2.0f)
+    FAILURE
+  if ((double) d128 != 2.0l)
+    FAILURE
+
+  /* float to decimal floating types.  */
+  if (d32 != (_Decimal32) f)
+    FAILURE
+  if (d64 != (_Decimal64) f)
+    FAILURE
+  if (d128 != (_Decimal128) f)
+    FAILURE
+
+  /* double to decimal floating types.  */
+  if (d32 != (_Decimal32) d)
+    FAILURE
+  if (d64 != (_Decimal64) d)
+    FAILURE
+  if (d128 != (_Decimal128) d)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-const.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-const.c
new file mode 100644
index 000000000..dd295200f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-const.c
@@ -0,0 +1,28 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.9 Equality operators.
+   Compare decimal float constants against each other. */
+
+extern void link_error (void);
+
+int
+main ()
+{
+  /* Compare like-typed positive constants. */
+  if (2.0df != 2.0df)
+    link_error ();
+
+  /* Compare decimal float constants of different types. */
+  if (500e-2dl != 0.05e2df)
+    link_error ();
+
+  /* Binary floating point introduces errors to decimal values. */
+  if (1.4 + 1.4 + 1.4 == 4.2)
+    link_error ();
+
+  /* But, this looks more like what one would expect. */
+  if (1.4dd + 1.4dd + 1.4dd != 4.2dd)
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d128.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d128.c
new file mode 100644
index 000000000..158e2f90b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d128.c
@@ -0,0 +1,13 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.9 Equality operators.
+   Compare decimal float values against each other at runtime.  */
+
+#define WIDTH 128
+#include "compare-eq.h"
+
+int main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d32.c
new file mode 100644
index 000000000..d5e3bb378
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d32.c
@@ -0,0 +1,13 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.9 Equality operators.
+   Compare decimal float values against each other at runtime.  */
+
+#define WIDTH 32
+#include "compare-eq.h"
+
+int main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d64.c
new file mode 100644
index 000000000..8fa39dfcd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-d64.c
@@ -0,0 +1,13 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.9 Equality operators.
+   Compare decimal float values against each other at runtime.  */
+
+#define WIDTH 64
+#include "compare-eq.h"
+
+int main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-dfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-dfp.c
new file mode 100644
index 000000000..4203470a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq-dfp.c
@@ -0,0 +1,65 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.9 Equality operators.
+   Compare decimal float values against variables of different types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+
+/* Use some typedefs of decimal float types, too.  */
+typedef _Decimal32 SDtype;
+typedef _Decimal64 DDtype;
+typedef _Decimal128 TDtype;
+
+SDtype d32b;
+DDtype d64b;
+TDtype d128b;
+
+void
+inits (void)
+{
+  d32 = 1.0df;
+  d64 = 3.0dd;
+  d128 = 5.0dl;
+  d32b = -1.0df;
+  d64b = -4.0dd;
+  d128b = -6.0dl;
+}
+
+void
+compare_dfp (void)
+{
+  if ((d32 == d64) != 0) FAILURE
+  if ((d32 != d128b) != 1) FAILURE
+
+  if ((d64 != d32) != 1) FAILURE
+  if ((d64 == d128) != 0) FAILURE
+
+  if ((d128 != d32) != 1) FAILURE
+  if ((d128 == d64) != 0) FAILURE
+}
+
+int
+main ()
+{
+  inits ();
+
+  compare_dfp ();
+
+  if (failcnt)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq.h
new file mode 100644
index 000000000..809d64259
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-eq.h
@@ -0,0 +1,96 @@
+/* Basic test of runtime equality comparisons using simple values that
+   are not affected by rounding.  */
+
+#include <stdlib.h>
+
+static int failcnt;
+
+#define PASTE2(A,B) A ## B
+#define PASTE(A,B) PASTE2(A,B)
+
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE(OP,KIND) \
+  { printf ("failed at line %d: %s for %s values\n", __LINE__, OP, KIND); \
+    failcnt++; }
+#else
+#define FAILURE(OP,KIND) abort ();
+#endif
+
+#ifndef WIDTH
+#error define WIDTH as decimal float size in bytes
+#endif
+
+#if WIDTH == 32
+#define DTYPE _Decimal32
+#define SUFFIX DF
+#elif WIDTH == 64
+#define DTYPE _Decimal64
+#define SUFFIX DD
+#elif WIDTH == 128
+#define DTYPE _Decimal128
+#define SUFFIX DL
+#elif WIDTH == 0
+/* This is for testing the test using a type known to work.  */
+#define DTYPE double
+#define SUFFIX
+#else
+#error invalid width for decimal float type
+#endif
+
+DTYPE m_two = PASTE(-2.0, SUFFIX);
+DTYPE m_one = PASTE(-1.0, SUFFIX);
+DTYPE zero  = PASTE(0.0, SUFFIX);
+DTYPE one   = PASTE(1.0, SUFFIX);
+DTYPE two   = PASTE(2.0, SUFFIX);
+
+void
+test_compares (void)
+{
+  DTYPE x = one;
+  DTYPE y = zero;
+  DTYPE z = m_one;
+
+  /* Equal to: comparisons against equal values.  */
+
+  if (! (x == one))   FAILURE ("==", "equal")
+  if (! (y == zero))  FAILURE ("==", "equal")
+  if (! (z == m_one)) FAILURE ("==", "equal")
+
+  /* Equal to: comparisons against lesser values.  */
+
+  if (x == m_one)     FAILURE ("==", "lesser")
+  if (x == zero)      FAILURE ("==", "lesser")
+  if (y == m_one)     FAILURE ("==", "lesser")
+  if (z == m_two)     FAILURE ("==", "lesser")
+
+  /* Equal to: comparisons against greater values.  */
+
+  if (x == two)       FAILURE ("==", "greater")
+  if (y == one)       FAILURE ("==", "greater")
+  if (z == zero)      FAILURE ("==", "greater")
+  if (z == one)       FAILURE ("==", "greater")
+
+  /* Not equal to: comparisons against equal values.  */
+
+  if (x != one)        FAILURE ("!=", "equal")
+  if (y != zero)       FAILURE ("!=", "equal")
+  if (z != m_one)      FAILURE ("!=", "equal")
+
+  /* Not equal to: comparisons against lesser values.  */
+
+  if (! (x != m_one))  FAILURE ("!=", "lesser")
+  if (! (x != zero))   FAILURE ("!=", "lesser")
+  if (! (y != m_one))  FAILURE ("!=", "lesser")
+  if (! (z != m_two))  FAILURE ("!=", "lesser")
+
+  /* Not equal to: comparisons against greater values.  */
+
+  if (! (x != m_one)) FAILURE ("!=", "greater")
+  if (! (x != zero))  FAILURE ("!=", "greater")
+  if (! (y != m_one)) FAILURE ("!=", "greater")
+  if (! (z != m_two)) FAILURE ("!=", "greater")
+
+  if (failcnt)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-const.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-const.c
new file mode 100644
index 000000000..d2dda48e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-const.c
@@ -0,0 +1,59 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.8 Relational operators.
+   Compare decimal float constants against each other. */
+
+extern void link_error (void);
+
+int
+main ()
+{
+  /* Compare like-typed negative constants. */
+  if (-2.0dl < -2.0dl)
+    link_error ();
+
+  /* Compare like-typed constants. */
+  if (-2.0dl >= .01dl)
+    link_error ();
+
+  /* Compare like-typed constants. */
+  if (0.2dd > 0.02e1dd)
+    link_error ();
+  
+  /* Compare decimal float constants of different types. */
+  if (-.000005dd >= -.0000049DL)
+  link_error();
+
+  /* Test use gcc builtins for comparisons. */
+  if (__builtin_isless(-2.0dl,-2.0dl))
+    link_error();
+
+  if (__builtin_isgreaterequal(-2.0dl,.01dl))
+    link_error();
+
+  if (!(__builtin_islessequal(-2.0dl, -2.0dd)))
+    link_error();
+
+  if (!(__builtin_isgreater(2.0dl, -2.0dd)))
+    link_error();
+
+  if (__builtin_islessequal(2.0df, __builtin_nand64("")))
+    link_error();
+
+  if (__builtin_islessgreater(2.0dd, __builtin_nand64("")))
+    link_error();
+
+  if (!__builtin_islessgreater(2.0dd, -2.0dd))
+    link_error();
+
+  if (!__builtin_islessgreater(-3.0dd, 2.0dd))
+    link_error();
+
+  if (__builtin_isunordered(1.1df, 0.003dd))
+    link_error();
+
+  if (!__builtin_isunordered(-3.1df, __builtin_nand32("")))
+    link_error();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d128.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d128.c
new file mode 100644
index 000000000..0d46925c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d128.c
@@ -0,0 +1,14 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   Compare decimal float values against each other at runtime.  */
+
+#define WIDTH 128
+#include "compare-rel.h"
+
+int
+main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d32.c
new file mode 100644
index 000000000..257a3c2b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d32.c
@@ -0,0 +1,14 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   Compare decimal float values against each other at runtime.  */
+
+#define WIDTH 32
+#include "compare-rel.h"
+
+int
+main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d64.c
new file mode 100644
index 000000000..73cbcee44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-d64.c
@@ -0,0 +1,14 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   Compare decimal float values against each other at runtime.  */
+
+#define WIDTH 64
+#include "compare-rel.h"
+
+int
+main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-dfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-dfp.c
new file mode 100644
index 000000000..58523b6ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel-dfp.c
@@ -0,0 +1,65 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   Compare decimal float values against variables of different types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+
+/* Use some typedefs of decimal float types, too.  */
+typedef _Decimal32 SDtype;
+typedef _Decimal64 DDtype;
+typedef _Decimal128 TDtype;
+
+SDtype d32b;
+DDtype d64b;
+TDtype d128b;
+
+void
+inits (void)
+{
+  d32 = 1.0df;
+  d64 = 3.0dd;
+  d128 = 5.0dl;
+  d32b = -1.0df;
+  d64b = -4.0dd;
+  d128b = -6.0dl;
+}
+
+void
+compare_dfp (void)
+{
+  if ((d32 > d64) != 0) FAILURE
+  if ((d32 >= d128b) != 1) FAILURE
+
+  if ((d64 < d32) != 0) FAILURE
+  if ((d64 <= d128) != 1) FAILURE
+
+  if ((d128 > d32) != 1) FAILURE
+  if ((d128 >= d64) != 1) FAILURE
+}
+
+int
+main ()
+{
+  inits ();
+
+  compare_dfp ();
+
+  if (failcnt)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel.h
new file mode 100644
index 000000000..06b2559bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-rel.h
@@ -0,0 +1,136 @@
+/* Basic test of runtime relational comparisons using simple values that
+   are not affected by rounding.  */
+
+#include <stdlib.h>
+
+static int failcnt;
+
+#define PASTE2(A,B) A ## B
+#define PASTE(A,B) PASTE2(A,B)
+
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE(OP,KIND) \
+  { printf ("failed at line %d: %s for %s values\n", __LINE__, OP, KIND); \
+    failcnt++; }
+#else
+#define FAILURE(OP,KIND) abort ();
+#endif
+
+#ifndef WIDTH
+#error define WIDTH as decimal float size in bytes
+#endif
+
+#if WIDTH == 32
+#define DTYPE _Decimal32
+#define SUFFIX DF
+#elif WIDTH == 64
+#define DTYPE _Decimal64
+#define SUFFIX DD
+#elif WIDTH == 128
+#define DTYPE _Decimal128
+#define SUFFIX DL
+#elif WIDTH == 0
+/* This is for testing the test using a type known to work.  */
+#define DTYPE double
+#define SUFFIX
+#else
+#error invalid width for decimal float type
+#endif
+
+DTYPE m_two = PASTE(-2.0, SUFFIX);
+DTYPE m_one = PASTE(-1.0, SUFFIX);
+DTYPE zero  = PASTE(0.0, SUFFIX);
+DTYPE one   = PASTE(1.0, SUFFIX);
+DTYPE two   = PASTE(2.0, SUFFIX);
+
+void
+test_compares (void)
+{
+  DTYPE x = one;
+  DTYPE y = zero;
+  DTYPE z = m_one;
+
+  /* Less than or equal to: comparisons against equal values.  */
+
+  if (! (x <= one))   FAILURE ("<=", "equal")
+  if (! (y <= zero))  FAILURE ("<=", "equal")
+  if (! (z <= m_one)) FAILURE ("<=", "equal")
+
+  /* Less than or equal to: comparisons against lesser values.  */
+
+  if (x <= m_one)     FAILURE ("<=", "lesser")
+  if (x <= zero)      FAILURE ("<=", "lesser")
+  if (y <= m_one)     FAILURE ("<=", "lesser")
+  if (z <= m_two)     FAILURE ("<=", "lesser")
+
+  /* Less than or equal to: comparisons against greater values.  */
+
+  if (! (x <= two))   FAILURE ("<=", "greater")
+  if (! (y <= one))   FAILURE ("<=", "greater")
+  if (! (z <= zero))  FAILURE ("<=", "greater")
+  if (! (z <= one))   FAILURE ("<=", "greater")
+
+  /* Less than: comparisons against equal values.  */
+
+  if (x < one)        FAILURE ("<", "equal")
+  if (y < zero)       FAILURE ("<", "equal")
+  if (z < m_one)      FAILURE ("<", "equal")
+
+  /* Less than: comparisons against lesser values.  */
+
+  if (x < m_one)      FAILURE ("<", "lesser")
+  if (x < zero)       FAILURE ("<", "lesser")
+  if (y < m_one)      FAILURE ("<", "lesser")
+  if (z < m_two)      FAILURE ("<", "lesser")
+
+  /* Less than: comparisons against greater values.  */
+
+  if (! (x < two))    FAILURE ("<", "greater")
+  if (! (y < one))    FAILURE ("<", "greater")
+  if (! (z < zero))   FAILURE ("<", "greater")
+  if (! (z < one))    FAILURE ("<", "greater")
+
+  /* Greater than or equal to: comparisons against equal values.  */
+
+  if (! (x >= one))   FAILURE (">=", "equal")
+  if (! (y >= zero))  FAILURE (">=", "equal")
+  if (! (z >= m_one)) FAILURE (">=", "equal")
+
+  /* Greater than or equal to: comparisons against lesser values.  */
+
+  if (! (x >= m_one)) FAILURE (">=", "lesser")
+  if (! (x >= zero))  FAILURE (">=", "lesser")
+  if (! (y >= m_one)) FAILURE (">=", "lesser")
+  if (! (z >= m_two)) FAILURE (">=", "lesser")
+
+  /* Greater than or equal to: comparisons against greater values.  */
+
+  if (x >= two)       FAILURE (">=", "greater")
+  if (y >= one)       FAILURE (">=", "greater")
+  if (z >= zero)      FAILURE (">=", "greater")
+  if (z >= one)       FAILURE (">=", "greater")
+
+  /* Greater than: comparisons against equal values.  */
+
+  if (x > one)        FAILURE (">", "equal")
+  if (y > zero)       FAILURE (">", "equal")
+  if (z > m_one)      FAILURE (">", "equal")
+
+  /* Greater than: comparisons against lesser values.  */
+
+  if (! (x > m_one))  FAILURE (">", "lesser")
+  if (! (x > zero))   FAILURE (">", "lesser")
+  if (! (y > m_one))  FAILURE (">", "lesser")
+  if (! (z > m_two))  FAILURE (">", "lesser")
+
+  /* Greater than: comparisons against greater values.  */
+
+  if (x > two)        FAILURE (">", "greater")
+  if (y > one)        FAILURE (">", "greater")
+  if (z > zero)       FAILURE (">", "greater")
+  if (z > one)        FAILURE (">", "greater")
+
+  if (failcnt)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d128.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d128.c
new file mode 100644
index 000000000..cef4670b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d128.c
@@ -0,0 +1,15 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   C99 6.5.9 Equality operators.
+   Compare decimal float special values at runtime.  */
+
+#define WIDTH 128
+#include "compare-special.h"
+
+int
+main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d32.c
new file mode 100644
index 000000000..fa91d7edd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d32.c
@@ -0,0 +1,15 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   C99 6.5.9 Equality operators.
+   Compare decimal float special values at runtime.  */
+
+#define WIDTH 32
+#include "compare-special.h"
+
+int
+main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d64.c
new file mode 100644
index 000000000..2238e0190
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special-d64.c
@@ -0,0 +1,15 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.8 Relational operators.
+   C99 6.5.9 Equality operators.
+   Compare decimal float special values at runtime.  */
+
+#define WIDTH 64
+#include "compare-special.h"
+
+int
+main ()
+{
+  test_compares ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special.h
new file mode 100644
index 000000000..c5bef2344
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/compare-special.h
@@ -0,0 +1,287 @@
+/* Basic test of runtime relational comparisons using NaNs and infinities.  */
+
+#include <stdlib.h>
+
+static int failcnt;
+
+#define PASTE2(A,B) A ## B
+#define PASTE(A,B) PASTE2(A,B)
+
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE(OP,KIND) \
+  { printf ("failed at line %d: %s for %s values\n", __LINE__, OP, KIND); \
+    failcnt++; }
+#else
+#define FAILURE(OP,KIND) abort ();
+#endif
+
+#ifndef WIDTH
+#error define WIDTH as decimal float size in bytes
+#endif
+
+#if WIDTH == 32
+#define DTYPE _Decimal32
+#define SUFFIX DF
+#define SUFFIX2 d32
+#elif WIDTH == 64
+#define DTYPE _Decimal64
+#define SUFFIX DD
+#define SUFFIX2 d64
+#elif WIDTH == 128
+#define DTYPE _Decimal128
+#define SUFFIX DL
+#define SUFFIX2 d128
+#elif WIDTH == 0
+/* This is for testing the test using a type known to work.  */
+#define DTYPE double
+#define SUFFIX
+#define SUFFIX2
+#else
+#error invalid width for decimal float type
+#endif
+
+DTYPE m_two = PASTE(-2.0, SUFFIX);
+DTYPE m_one = PASTE(-1.0, SUFFIX);
+DTYPE zero  = PASTE(0.0, SUFFIX);
+DTYPE one   = PASTE(1.0, SUFFIX);
+DTYPE two   = PASTE(2.0, SUFFIX);
+
+volatile DTYPE x, y, z, _nan, inf, m_inf;
+
+void
+test_compares (void)
+{
+  _nan = PASTE(__builtin_nan, SUFFIX2) ("");
+  inf =  PASTE(__builtin_inf, SUFFIX2) ();
+  m_inf = - PASTE(__builtin_inf, SUFFIX2) ();
+
+  x = PASTE(__builtin_nan, SUFFIX2) ("");
+  y = PASTE(__builtin_inf, SUFFIX2) ();
+  z = - PASTE(__builtin_inf, SUFFIX2) ();
+
+  /* Less than or equal to with NaN.  */
+
+  if (x <= two)   FAILURE ("<=", "NaN")
+  if (x <= zero)  FAILURE ("<=", "NaN")
+  if (x <= m_one) FAILURE ("<=", "NaN")
+  if (x <= _nan)  FAILURE ("<=", "NaN")
+  if (x <= inf)   FAILURE ("<=", "NaN")
+  if (x <= m_inf) FAILURE ("<=", "NaN")
+
+  if (two <= x)   FAILURE ("<=", "NaN")
+  if (zero <= x)  FAILURE ("<=", "NaN")
+  if (m_one <= x) FAILURE ("<=", "NaN")
+  if (_nan <= x)  FAILURE ("<=", "NaN")
+  if (inf <= x)   FAILURE ("<=", "NaN")
+  if (m_inf <= x) FAILURE ("<=", "NaN")
+
+  /* Less than or equal to with infinities, no NaNs.  */
+
+  if (y <= two)      FAILURE ("<=", "inf")
+  if (y <= zero)     FAILURE ("<=", "inf")
+  if (y <= m_one)    FAILURE ("<=", "inf")
+  if (!(two <= y))   FAILURE ("<=", "inf")
+  if (!(zero <= y))  FAILURE ("<=", "inf")
+  if (!(m_one <= y)) FAILURE ("<=", "inf")
+
+  if (!(z <= two))   FAILURE ("<=", "-inf")
+  if (!(z <= zero))  FAILURE ("<=", "-inf")
+  if (!(z <= m_one)) FAILURE ("<=", "-inf")
+  if (two <= z)      FAILURE ("<=", "-inf")
+  if (zero <= z)     FAILURE ("<=", "-inf")
+  if (m_one <= z)    FAILURE ("<=", "-inf")
+
+  if (!(y <= inf))   FAILURE ("<=", "inf")
+  if (y <= m_inf)    FAILURE ("<=", "inf")
+  if (!(z <= inf))   FAILURE ("<=", "inf")
+  if (!(z <= m_inf)) FAILURE ("<=", "inf")
+
+  /* Less than with NaN.  */
+
+  if (x < two)       FAILURE ("<", "NaN")
+  if (x < zero)      FAILURE ("<", "NaN")
+  if (x < m_one)     FAILURE ("<", "NaN")
+  if (x < _nan)      FAILURE ("<", "NaN")
+  if (x < inf)       FAILURE ("<", "NaN")
+  if (x < m_inf)     FAILURE ("<", "NaN")
+
+  if (two < x)       FAILURE ("<", "NaN")
+  if (zero < x)      FAILURE ("<", "NaN")
+  if (m_one < x)     FAILURE ("<", "NaN")
+  if (_nan < x)      FAILURE ("<", "NaN")
+  if (inf < x)       FAILURE ("<", "NaN")
+  if (m_inf < x)     FAILURE ("<", "NaN")
+
+  /* Less than with infinities, no NaNs.  */
+
+  if (y < two)       FAILURE ("<", "inf")
+  if (y < zero)      FAILURE ("<", "inf")
+  if (y < m_one)     FAILURE ("<", "inf")
+  if (!(two < y))    FAILURE ("<", "inf")
+  if (!(zero < y))   FAILURE ("<", "inf")
+  if (!(m_one < y))  FAILURE ("<", "inf")
+
+  if (!(z < two))    FAILURE ("<", "-inf")
+  if (!(z < zero))   FAILURE ("<", "-inf")
+  if (!(z < m_one))  FAILURE ("<", "-inf")
+  if (two < z)       FAILURE ("<", "-inf")
+  if (zero < z)      FAILURE ("<", "-inf")
+  if (m_one < z)     FAILURE ("<", "-inf")
+
+  if (y < inf)       FAILURE ("<=", "inf")
+  if (y < m_inf)     FAILURE ("<=", "inf")
+  if (!(z < inf))    FAILURE ("<=", "inf")
+  if (z < m_inf)     FAILURE ("<=", "inf")
+
+  /* Greater than or equal to with NaN.  */
+
+  if (x >= two)      FAILURE (">=", "NaN")
+  if (x >= zero)     FAILURE (">=", "NaN")
+  if (x >= m_one)    FAILURE (">=", "NaN")
+  if (x >= _nan)     FAILURE (">=", "NaN")
+  if (x >= inf)      FAILURE (">=", "NaN")
+  if (x >= m_inf)    FAILURE (">=", "NaN")
+
+  if (two >= x)      FAILURE (">=", "NaN")
+  if (zero >= x)     FAILURE (">=", "NaN")
+  if (m_one >= x)    FAILURE (">=", "NaN")
+  if (_nan >= x)     FAILURE (">=", "NaN")
+  if (inf >= x)      FAILURE (">=", "NaN")
+  if (m_inf >= x)    FAILURE (">=", "NaN")
+
+  /* Greater than or equal to with infinities, no NaNs.  */
+
+  if (!(y >= two))   FAILURE (">=", "inf")
+  if (!(y >= zero))  FAILURE (">=", "inf")
+  if (!(y >= m_one)) FAILURE (">=", "inf")
+  if (two >= y)      FAILURE (">=", "inf")
+  if (zero >= y)     FAILURE (">=", "inf")
+  if (m_one >= y)    FAILURE (">=", "inf")
+
+  if (z >= two)      FAILURE (">=", "-inf")
+  if (z >= zero)     FAILURE (">=", "-inf")
+  if (z >= m_one)    FAILURE (">=", "-inf")
+  if (!(two >= z))   FAILURE (">=", "-inf")
+  if (!(zero >= z))  FAILURE (">=", "-inf")
+  if (!(m_one >= z)) FAILURE (">=", "-inf")
+
+  if (!(y >= inf))   FAILURE ("<=", "inf")
+  if (!(y >= m_inf)) FAILURE ("<=", "inf")
+  if (z >= inf)      FAILURE ("<=", "inf")
+  if (!(z >= m_inf)) FAILURE ("<=", "inf")
+
+  /* Greater than with NaN.  */
+
+  if (x > two)       FAILURE (">", "NaN")
+  if (x > zero)      FAILURE (">", "NaN")
+  if (x > m_one)     FAILURE (">", "NaN")
+  if (x > _nan)      FAILURE (">", "NaN")
+  if (x > inf)       FAILURE (">", "NaN")
+  if (x > m_inf)     FAILURE (">", "NaN")
+
+  if (two > x)       FAILURE (">", "NaN")
+  if (zero > x)      FAILURE (">", "NaN")
+  if (m_one > x)     FAILURE (">", "NaN")
+  if (_nan > x)      FAILURE (">", "NaN")
+  if (inf > x)       FAILURE (">", "NaN")
+  if (m_inf > x)     FAILURE (">", "NaN")
+
+  /* Greater than with infinities, no NaNs.  */
+
+  if (!(y > two))    FAILURE (">", "inf")
+  if (!(y > zero))   FAILURE (">", "inf")
+  if (!(y > m_one))  FAILURE (">", "inf")
+  if (two > y)       FAILURE (">", "inf")
+  if (zero > y)      FAILURE (">", "inf")
+  if (m_one > y)     FAILURE (">", "inf")
+
+  if (z > two)       FAILURE (">", "-inf")
+  if (z > zero)      FAILURE (">", "-inf")
+  if (z > m_one)     FAILURE (">", "-inf")
+  if (!(two > z))    FAILURE (">", "-inf")
+  if (!(zero > z))   FAILURE (">", "-inf")
+  if (!(m_one > z))  FAILURE (">", "-inf")
+
+  if (y > inf)       FAILURE (">", "inf")
+  if (!(y > m_inf))  FAILURE (">", "inf")
+  if (z > inf)       FAILURE (">", "inf")
+  if (z > m_inf)     FAILURE (">", "inf")
+
+  /* Equal with NaN.  */
+
+  if (x == two)      FAILURE ("==", "NaN")
+  if (x == zero)     FAILURE ("==", "NaN")
+  if (x == m_one)    FAILURE ("==", "NaN")
+  if (x == _nan)     FAILURE ("==", "NaN")
+  if (x == inf)      FAILURE ("==", "NaN")
+  if (x == m_inf)    FAILURE ("==", "NaN")
+
+  if (two == x)      FAILURE ("==", "NaN")
+  if (zero == x)     FAILURE ("==", "NaN")
+  if (m_one == x)    FAILURE ("==", "NaN")
+  if (_nan == x)     FAILURE ("==", "NaN")
+  if (inf == x)      FAILURE ("==", "NaN")
+  if (m_inf == x)    FAILURE ("==", "NaN")
+
+  /* Equal with infinities, no NaNs.  */
+
+  if (y == two)      FAILURE ("==", "inf")
+  if (y == zero)     FAILURE ("==", "inf")
+  if (y == m_one)    FAILURE ("==", "inf")
+  if (two == y)      FAILURE ("==", "inf")
+  if (zero == y)     FAILURE ("==", "inf")
+  if (m_one == y)    FAILURE ("==", "inf")
+
+  if (z == two)      FAILURE ("==", "-inf")
+  if (z == zero)     FAILURE ("==", "-inf")
+  if (z == m_one)    FAILURE ("==", "-inf")
+  if (two == z)      FAILURE ("==", "-inf")
+  if (zero == z)     FAILURE ("==", "-inf")
+  if (m_one == z)    FAILURE ("==", "-inf")
+
+  if (!(y == inf))   FAILURE ("==", "inf")
+  if (y == m_inf)    FAILURE ("==", "inf")
+  if (z == inf)      FAILURE ("==", "inf")
+  if (!(z == m_inf)) FAILURE ("==", "inf")
+
+  /* Not equal with NaN.  */
+
+  if (!(x != two))   FAILURE ("!=", "NaN")
+  if (!(x != zero))  FAILURE ("!=", "NaN")
+  if (!(x != m_one)) FAILURE ("!=", "NaN")
+  if (!(x != _nan))  FAILURE ("!=", "NaN")
+  if (!(x != inf))   FAILURE ("!=", "NaN")
+  if (!(x != m_inf)) FAILURE ("!=", "NaN")
+
+  if (!(two != x))   FAILURE ("!=", "NaN")
+  if (!(zero != x))  FAILURE ("!=", "NaN")
+  if (!(m_one != x)) FAILURE ("!=", "NaN")
+  if (!(_nan != x))  FAILURE ("!=", "NaN")
+  if (!(inf != x))   FAILURE ("!=", "NaN")
+  if (!(m_inf != x)) FAILURE ("!=", "NaN")
+
+  /* Not equal with infinities, no NaNs.  */
+
+  if (!(y != two))   FAILURE ("!=", "inf")
+  if (!(y != zero))  FAILURE ("!=", "inf")
+  if (!(y != m_one)) FAILURE ("!=", "inf")
+  if (!(two != y))   FAILURE ("!=", "inf")
+  if (!(zero != y))  FAILURE ("!=", "inf")
+  if (!(m_one != y)) FAILURE ("!=", "inf")
+
+  if (!(z != two))   FAILURE ("!=", "-inf")
+  if (!(z != zero))  FAILURE ("!=", "-inf")
+  if (!(z != m_one)) FAILURE ("!=", "-inf")
+  if (!(two != z))   FAILURE ("!=", "-inf")
+  if (!(zero != z))  FAILURE ("!=", "-inf")
+  if (!(m_one != z)) FAILURE ("!=", "-inf")
+
+  if (y != inf)      FAILURE ("!=", "inf")
+  if (!(y != m_inf)) FAILURE ("!=", "inf")
+  if (!(z != inf))   FAILURE ("!=", "inf")
+  if (z != m_inf)    FAILURE ("!=", "inf")
+
+  if (failcnt)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/composite-type.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/composite-type.c
new file mode 100644
index 000000000..2abc82175
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/composite-type.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O -Wall" } */
+
+/* C99 6.2.7: Compatible type and composite type.  */
+
+#define DECIMAL_COMPOSITE_DECL(TYPE) \
+  _Decimal##TYPE g1_##TYPE(); \
+  _Decimal##TYPE g2_##TYPE(); \
+  _Decimal##TYPE (*h1_##TYPE)[2]; \
+  _Decimal##TYPE (*h2_##TYPE)[3]; \
+  _Decimal##TYPE (*h3_##TYPE)[4]; \
+  _Decimal##TYPE f1_##TYPE(_Decimal##TYPE(*)()); \
+  _Decimal##TYPE f1_##TYPE(_Decimal##TYPE(*)(_Decimal##TYPE*)); \
+  _Decimal##TYPE f1_##TYPE (_Decimal##TYPE(*g)(_Decimal##TYPE*)) \
+   { \
+     _Decimal##TYPE d##TYPE; \
+     d##TYPE = ((_Decimal##TYPE (*) (_Decimal##TYPE*)) g)(&d##TYPE); \
+     d##TYPE = ((_Decimal##TYPE (*) ()) g); \
+     return d##TYPE; \
+   } \
+   _Decimal##TYPE f2_##TYPE(_Decimal##TYPE(*)[]); \
+   _Decimal##TYPE f2_##TYPE(_Decimal##TYPE(*)[3]);
+
+#define DECIMAL_COMPOSITE_TEST(TYPE) \
+do \
+{ \
+ _Decimal##TYPE d##TYPE; \
+ d##TYPE = f1_##TYPE(g1_##TYPE); \
+ d##TYPE = f1_##TYPE(g2_##TYPE); \
+ d##TYPE = f2_##TYPE(h1_##TYPE); \
+ d##TYPE = f2_##TYPE(h2_##TYPE); \
+ d##TYPE = f2_##TYPE(h3_##TYPE); \
+} while(0)
+ 
+DECIMAL_COMPOSITE_DECL(32);  /* { dg-error "incompatible types when assigning to type '\[^\n\]*' from type '\[^\n\]*'" } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 35 } */
+
+
+DECIMAL_COMPOSITE_DECL(64);  /* { dg-error "incompatible types when assigning to type '\[^\n\]*' from type '\[^\n\]*'" } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 39 } */
+
+
+DECIMAL_COMPOSITE_DECL(128); /* { dg-error "incompatible types when assigning to type '\[^\n\]*' from type '\[^\n\]*'" } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 43 } */
+
+
+int main()
+{
+  DECIMAL_COMPOSITE_TEST(32);  /* { dg-warning "incompatible pointer type" } */
+  DECIMAL_COMPOSITE_TEST(64);  /* { dg-warning "incompatible pointer type" } */
+  DECIMAL_COMPOSITE_TEST(128); /* { dg-warning "incompatible pointer type" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-c99.c
new file mode 100644
index 000000000..8dcfc7b24
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-c99.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* N1150 6: Constants.
+   C99 6.4.4.2: Floating constants.  */
+
+_Decimal32 a = 1.1df;			/* { dg-error "" } */
+_Decimal32 b = -.003DF;			/* { dg-error "" } */
+_Decimal64 c = 11e-1dl;			/* { dg-error "" } */
+_Decimal64 d = -.3DL;			/* { dg-error "" } */
+_Decimal128 e = 000.3e0dl;		/* { dg-error "" } */
+_Decimal128 f = 3000300030003e0DL;	/* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-hex.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-hex.c
new file mode 100644
index 000000000..936f0ed84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-hex.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 6: Constants.
+   C99 6.4.4.2: Floating constants.
+
+   The df, dd, dl, DF, DD and DL suffixes shall not be used in a
+   hexadecimal-floating-constant.  */
+
+_Decimal32 bad1 = 0x1.0p1df;   /* { dg-error "invalid suffix" "hexadecimal floating constant" } */
+_Decimal32 bad2 = 0x1.0p1DF;   /* { dg-error "invalid suffix" "hexadecimal floating constant" } */
+_Decimal64 bad3 = 0x2.0p-2dd;  /* { dg-error "invalid suffix" "hexadecimal floating constant" } */
+_Decimal64 bad4 = 0x2.0p2DD;   /* { dg-error "invalid suffix" "hexadecimal floating constant" } */
+_Decimal128 bad5 = 0x3.0p3dl;  /* { dg-error "invalid suffix" "hexadecimal floating constant" } */
+_Decimal128 bad6 = 0x3.0p3DL;  /* { dg-error "invalid suffix" "hexadecimal floating constant" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-pedantic.c
new file mode 100644
index 000000000..540b76840
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-pedantic.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+/* N1150 6: Constants.
+   C99 6.4.4.2: Floating constants.  */
+
+_Decimal32 a = 1.1df;		/* { dg-warning "GCC extension|ISO C" } */
+_Decimal32 b = -.003DF;		/* { dg-warning "GCC extension|ISO C" } */
+_Decimal64 c = 11e-1dl;		/* { dg-warning "GCC extension|ISO C" } */
+_Decimal64 d = -.3DL;		/* { dg-warning "GCC extension|ISO C" } */
+_Decimal128 e = 000.3e0dl;	/* { dg-warning "GCC extension|ISO C" } */
+_Decimal128 f = 3000300030003e0DL;  /* { dg-warning "GCC extension|ISO C" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-zero.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-zero.c
new file mode 100644
index 000000000..e0db28cc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants-zero.c
@@ -0,0 +1,159 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* Decimal float values can have significant trailing zeroes.  This is
+   true for zero values as well.  Check that various representations of
+   zero are handled correctly when specified as literal constants.  */
+
+extern void abort (void);
+
+int big_endian;
+
+typedef union U32 {
+  unsigned int i;
+  _Decimal32 d;
+  unsigned char b[4];
+} u32_t;
+
+typedef union U64 {
+  unsigned long long i;
+  _Decimal64 d;
+} u64_t;
+
+typedef union U128 {
+  unsigned long long i[2];
+  _Decimal128 d;
+} u128_t;
+
+int
+compare32 (_Decimal32 d, unsigned int i)
+{
+  u32_t u;
+
+  u.d = d;
+  return (u.i == i);
+}
+
+int
+compare64 (_Decimal64 d, unsigned long long i)
+{
+  u64_t u;
+
+  u.d = d;
+  return (u.i == i);
+}
+
+int
+compare128 (_Decimal64 d, unsigned long long i, unsigned long long j)
+{
+  u128_t u;
+
+  u.d = d;
+  if (big_endian)
+    return (u.i[0] == i && u.i[1] == j);
+  else
+    return (u.i[1] == i && u.i[0] == j);
+}
+
+void
+dpd_tests (void)
+{
+  if (! compare32 (0.DF, 0x22500000U))
+    abort ();
+  if (! compare32 (-0.DF, 0xa2500000U))
+    abort ();
+  if (! compare32 (0.E-4DF, 0x22100000U))
+    abort ();
+  if (! compare32 (0.E-7DF, 0x21e00000U))
+    abort ();
+  if (! compare32 (0.E+3DF, 0x22800000U))
+    abort ();
+
+  if (! compare64 (0.DD, 0x2238000000000000ULL))
+    abort ();
+  if (! compare64 (-0.DD, 0xa238000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-6DD, 0x2220000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-7DD, 0x221c000000000000ULL))
+    abort ();
+  if (! compare64 (0.E+2DD, 0x2240000000000000ULL))
+    abort ();
+
+  if (! compare128 (0.DL, 0x2208000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (-0.DL, 0xa208000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-3DL, 0x2207400000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-8DL, 0x2206000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E+2DL, 0x2208800000000000ULL, 0x0000000000000000ULL))
+    abort ();
+}
+
+void
+bid_tests (void)
+{
+  if (! compare32 (0.DF, 0x32800000U))
+    abort ();
+  if (! compare32 (-0.DF, 0xb2800000U))
+    abort ();
+  if (! compare32 (0.E-4DF, 0x30800000U))
+    abort ();
+  if (! compare32 (0.E-7DF, 0x2f000000U))
+    abort ();
+  if (! compare32 (0.E+3DF, 0x34000000U))
+    abort ();
+
+  if (! compare64 (0.DD, 0x31c0000000000000ULL))
+    abort ();
+  if (! compare64 (-0.DD, 0xb1c0000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-6DD, 0x3100000000000000ULL))
+    abort ();
+  if (! compare64 (0.E-7DD, 0x30e0000000000000ULL))
+    abort ();
+  if (! compare64 (0.E+2DD, 0x3200000000000000ULL))
+    abort ();
+
+  if (! compare128 (0.DL, 0x3040000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (-0.DL, 0xb040000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-3DL, 0x303a000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E-8DL, 0x3030000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+  if (! compare128 (0.E+2DL, 0x3044000000000000ULL, 0x0000000000000000ULL))
+    abort ();
+}
+
+int
+main ()
+{
+  u32_t u32;
+  
+  /* These sizes are probably always true for targets that support decimal
+     float types, but check anyway.  Abort so we can fix the test.  */
+  if ((sizeof (_Decimal64) != sizeof (long long))
+      || (sizeof (_Decimal128) != 2 * sizeof (long long))
+      || (sizeof (_Decimal32) != sizeof (_Decimal32)))
+    abort ();
+
+  u32.d = 1.DF;
+
+  if (u32.i == 0x22500001)
+    {
+      big_endian = (u32.b[0] == 0x22);
+      dpd_tests ();
+    }
+  else if (u32.i == 0x32800001)
+    {
+       big_endian = (u32.b[0] == 0x32);
+       bid_tests ();
+    }
+  else
+    abort ();		/* unknown format; test problem  */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants.c
new file mode 100644
index 000000000..50045ed9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/constants.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 6: Constants.
+   C99 6.4.4.2: Floating constants.  */
+
+_Decimal32 a = 1.1df;
+_Decimal32 b = -.003DF;
+_Decimal64 c = 11e-1dl;
+_Decimal64 d = -.3DL;
+_Decimal128 e = 000.3e0dl;
+_Decimal128 f = 3000300030003e0DL;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-10.c
new file mode 100644
index 000000000..dec7b515f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-10.c
@@ -0,0 +1,114 @@
+/* { dg-options "-std=gnu99" } */
+
+/* This test assumes IEEE float and double.  */
+
+#define __STDC_WANT_DEC_FP__
+#include <float.h>
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+
+/* Conversions using denormalized float values.  */
+CONVERT_VALID (111, sf, sd, 1.2e-38f, 1.2e-38df, 0.df)
+CONVERT_VALID (112, sf, sd, 1.1e-38f, 1.1e-38df, 0.df)
+CONVERT_VALID (113, sf, sd, 1.1e-40f, 1.1e-40df, 1.1e-45df)
+
+CONVERT_VALID (121, sd, sf, 1.2e-38df, 1.2e-38f, 0.f)
+CONVERT_VALID (122, sd, sf, 1.1e-38df, 1.1e-38f, 0.f)
+
+CONVERT_VALID (131, sf, sd, -1.2e-38f, -1.2e-38df, 0.df)
+CONVERT_VALID (132, sf, sd, -1.1e-38f, -1.1e-38df, 0.df)
+
+CONVERT_VALID (141, sd, sf, -1.2e-38df, -1.2e-38f, 0.f)
+CONVERT_VALID (142, sd, sf, -1.1e-38df, -1.1e-38f, 0.f)
+
+/* Conversions using denormalized double values.  */
+CONVERT_VALID (211, df, sd, 1.2e-38, 1.2e-38df, 0.df)
+CONVERT_VALID (212, df, sd, 1.1e-38, 1.1e-38df, 0.df)
+CONVERT_VALID (213, df, sd, 1.e-40, 1.e-40df, 0.df)
+CONVERT_VALID (214, df, sd, 8.e-44, 8.e-44df, 0.df)
+CONVERT_VALID (215, df, sd, 9.e-44, 9.e-44df, 0.df)
+CONVERT_VALID (216, df, sd, 8.e-46, 8.e-46df, 0.df)
+CONVERT_VALID (217, df, sd, 7.e-46, 7.e-46df, 0.df)
+
+CONVERT_VALID (221, sd, df, 1.2e-38df, 1.2e-38, 1.e-53)
+CONVERT_VALID (222, sd, df, 1.1e-38df, 1.1e-38, 1.e-53)
+CONVERT_VALID (223, sd, df, 1.e-40df, 1.e-40, 0.)
+CONVERT_VALID (224, sd, df, 8.e-44df, 8.e-44, 0.)
+CONVERT_VALID (225, sd, df, 9.e-44df, 9.e-44, 0.)
+CONVERT_VALID (226, sd, df, 8.e-46df, 8.e-46, 0.)
+CONVERT_VALID (227, sd, df, 7.e-46df, 7.e-46, 0.)
+
+CONVERT_VALID (231, df, sd, -1.2e-38, -1.2e-38df, 0.df)
+CONVERT_VALID (232, df, sd, -1.1e-38f, -1.1e-38df, 0.df)
+CONVERT_VALID (233, df, sd, -1.e-40, -1.e-40df, 0.df)
+CONVERT_VALID (234, df, sd, -8.e-44, -8.e-44df, 0.df)
+CONVERT_VALID (235, df, sd, -9.e-44, -9.e-44df, 0.df)
+CONVERT_VALID (236, df, sd, -8.e-46, -8.e-46df, 0.df)
+CONVERT_VALID (237, df, sd, -7.e-46, -7.e-46df, 0.df)
+
+CONVERT_VALID (241, sd, df, -1.2e-38df, -1.2e-38, 1.e-53)
+CONVERT_VALID (242, sd, df, -1.1e-38df, -1.1e-38, 1.e-53)
+CONVERT_VALID (243, sd, df, -1.e-40df, -1.e-40, 0.)
+CONVERT_VALID (244, sd, df, -8.e-44df, -8.e-44, 0.)
+CONVERT_VALID (245, sd, df, -9.e-44df, -9.e-44, 0.)
+CONVERT_VALID (246, sd, df, -8.e-46df, -8.e-46, 0.)
+CONVERT_VALID (247, sd, df, -7.e-46df, -7.e-46, 0.)
+
+int
+main ()
+{
+  convert_111 ();
+  convert_112 ();
+  convert_113 ();
+
+  convert_121 ();
+  convert_122 ();
+
+  convert_131 ();
+  convert_132 ();
+
+  convert_141 ();
+  convert_142 ();
+
+  convert_211 ();
+  convert_212 ();
+  convert_213 ();
+  convert_214 ();
+  convert_215 ();
+  convert_216 ();
+  convert_217 ();
+
+  convert_221 ();
+  convert_222 ();
+  convert_223 ();
+  convert_224 ();
+  convert_225 ();
+  convert_226 ();
+  convert_227 ();
+
+  convert_231 ();
+  convert_232 ();
+  convert_233 ();
+  convert_234 ();
+  convert_235 ();
+  convert_236 ();
+  convert_237 ();
+
+  convert_241 ();
+  convert_242 ();
+  convert_243 ();
+  convert_244 ();
+  convert_245 ();
+  convert_246 ();
+  convert_247 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-11.c
new file mode 100644
index 000000000..283f9bd4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-11.c
@@ -0,0 +1,61 @@
+/* { dg-options "-std=gnu99" } */
+/* { dg-skip-if "" { ! "powerpc*-*-linux*" } { "*" } { "" } } */
+
+/* Test decimal float conversions to and from IBM 128-bit long double. 
+   Checks are skipped at runtime if long double is not 128 bits.
+   Don't force 128-bit long doubles because runtime support depends
+   on glibc.  */
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+volatile long double tf;
+
+/* A value slightly less than DEC32_MAX can be converted in both directions.  */
+CONVERT_VALID (101, sd, tf, 9.999998e96df, 9.999998e96L, 1.e+81L)
+CONVERT_VALID (102, tf, sd, 9.999998e96L, 9.999998e96df, 0.df)
+
+/* A value slightly less than DBL_MAX can be converted in both directions.  */
+CONVERT_VALID (201, tf, dd, 1.79768e+308l, 1.79768e+308dd, 0.dd)
+CONVERT_VALID (202, dd, tf, 1.79768e+308dd, 1.79768e+308l, 2.e292l)
+CONVERT_VALID (203, tf, td, 1.79768e+308l, 1.79768e+308dl, 1.e292dl)
+CONVERT_VALID (204, td, tf, 1.79768e+308dl, 1.79768e+308l, 2.e292l)
+
+/* Check values that are too large for the result type.  */
+CONVERT_TO_PINF (301, dd, tf, 1.8e+308dd, l)
+CONVERT_TO_PINF (302, dd, tf, 9.9e+384dd, l)
+CONVERT_TO_PINF (303, td, tf, 1.8e+308dl, l)
+CONVERT_TO_PINF (304, td, tf, 9.9e+384dl, l)
+
+CONVERT_TO_PINF (311, tf, sd, 1.0e+97L, d32)
+CONVERT_TO_PINF (312, tf, sd, 1.6e+308L, d32)
+
+int
+main ()
+{
+  if (sizeof (long double) != 16)
+    return 0;
+
+  convert_101 ();
+  convert_102 ();
+
+  convert_201 ();
+  convert_202 ();
+  convert_203 ();
+  convert_204 ();
+
+  convert_301 ();
+  convert_302 ();
+  convert_303 ();
+  convert_304 ();
+  convert_311 ();
+  convert_312 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-12.c
new file mode 100644
index 000000000..96381415d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-12.c
@@ -0,0 +1,17 @@
+/* Test for bug where fold wrongly removed conversions to double and
+   replaced them by conversions to float.  */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort (void);
+extern void exit (int);
+
+volatile float f = __builtin_inff ();
+volatile _Decimal32 d32 = 1e40DF;
+
+int
+main (void)
+{
+  if ((double) f == (double) d32)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-13.c
new file mode 100644
index 000000000..91a5b4948
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-13.c
@@ -0,0 +1,20 @@
+/* Test for bug where fold changed binary operation to decimal
+   depending on typedefs.  */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort (void);
+extern void exit (int);
+
+volatile double d = 1.2345675;
+
+typedef const volatile _Decimal32 d32;
+
+int
+main (void)
+{
+  _Decimal32 a = (d * d);
+  d32 b = (d * d);
+  if (a != b)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-14.c
new file mode 100644
index 000000000..a1312d2a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-14.c
@@ -0,0 +1,17 @@
+/* Test for bug where fold narrowed decimal floating-point
+   operations.  */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort (void);
+extern void exit (int);
+
+volatile _Decimal32 f = 1.23456DF;
+volatile _Decimal64 d = 1.23456DD;
+
+int
+main (void)
+{
+  if ((double)((_Decimal64)f * (_Decimal64)f) != (double)(d * d))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-2.c
new file mode 100644
index 000000000..282735120
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-2.c
@@ -0,0 +1,37 @@
+/* { dg-options "-std=gnu99" } */
+
+/* This test assumes IEEE float and double.  It also tests long double
+   but makes no assumption about its size or range of values.  */
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+volatile long double tf;   /* might actually be df or xf, doesn't matter */
+
+CONVERT_VALID_ALL (t1, 0.0, 0.)
+CONVERT_VALID_ALL (t2, 1.0, 0.)
+CONVERT_VALID_ALL (t3, -11.5, 0.)
+CONVERT_VALID_ALL (t4, 7.0, 0.1e-14)
+CONVERT_VALID_ALL (t5, -7.0, 0.1e-14)
+CONVERT_VALID_ALL (t6, 999999., 0.)
+CONVERT_VALID_ALL (t7, -999999., 0.)
+
+int
+main ()
+{
+  CALL_VALID_ALL (t1)
+  CALL_VALID_ALL (t2)
+  CALL_VALID_ALL (t3)
+  CALL_VALID_ALL (t4)
+  CALL_VALID_ALL (t5)
+  CALL_VALID_ALL (t6)
+  CALL_VALID_ALL (t7)
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-3.c
new file mode 100644
index 000000000..67d31c33a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-3.c
@@ -0,0 +1,25 @@
+/* { dg-options "-std=gnu99" } */
+
+/* This test assumes IEEE float and double.  It also tests long double
+   but makes no assumption about its size or range of values.  */
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+volatile long double tf;   /* might actually be df or xf, doesn't matter */
+
+CONVERT_ZEROES_ALL (t);
+
+int
+main ()
+{
+  CALL_ZEROES_ALL (t)
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-4.c
new file mode 100644
index 000000000..feba37a9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-4.c
@@ -0,0 +1,25 @@
+/* { dg-options "-std=gnu99" } */
+
+/* This test assumes IEEE float and double.  It also tests long double
+   but makes no assumption about its size or range of values.  */
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+volatile long double tf;   /* might actually be df or xf, doesn't matter */
+
+CONVERT_INF_ALL (t);
+
+int
+main ()
+{
+  CALL_INF_ALL (t)
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-5.c
new file mode 100644
index 000000000..cfb86fd01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-5.c
@@ -0,0 +1,25 @@
+/* { dg-options "-std=gnu99" } */
+
+/* This test assumes IEEE float and double.  It also tests long double
+   but makes no assumption about its size or range of values.  */
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+volatile long double tf;   /* might actually be df or xf, doesn't matter */
+
+CONVERT_NAN_ALL (t);
+
+int
+main ()
+{
+  CALL_NAN_ALL (t)
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-6.c
new file mode 100644
index 000000000..7603f7519
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-6.c
@@ -0,0 +1,180 @@
+/* { dg-xfail-run-if "" { lax_strtofp } "*" "" } */
+/* { dg-options "-std=gnu99 -w" } */
+
+/* This test assumes IEEE float and double.  */
+
+#define __STDC_WANT_DEC_FP__
+#include <float.h>
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+volatile long double tf;
+
+CONVERT_VALID (101, td, sf, 0.000488281251dl, 0.00048828125f, 0.f)
+
+/* 2**(-25) = 0.298023223876953125E-7.  */
+CONVERT_VALID (102, td, sf, 2.98023223876953125e-8dl, 2.9802322387695312e-08f,
+               01.e-13f)
+
+/* Fractional part doesn't fit.  */
+CONVERT_VALID (103, df, sd, 1.0e-20, 1.0e-20df, 0.df)
+
+/* Exact power of 2.  */
+CONVERT_VALID (104, df, sd, 0.00048828125, 0.00048828125df, 0.df)
+CONVERT_VALID (105, df, sd, 1.0e-96, 0.dd, DEC32_MIN)
+
+/* A value slightly less than FLT_MAX can be converted in both directions.  */
+CONVERT_VALID (201, sf, sd, 3.402819e+38f, 3.402819e+38df, 0.df)
+CONVERT_VALID (202, sd, sf, 3.402819e+38df, 3.402819e+38f, 0.f)
+CONVERT_VALID (203, sf, dd, 3.402819e+38f, 3.402819e+38dd, 1.e+30dd)
+CONVERT_VALID (204, dd, sf, 3.402819e+38dd, 3.402819e+38f, 0.f)
+CONVERT_VALID (205, sf, td, 3.402819e+38f, 3.402819e+38dl, 1.e+30dl)
+CONVERT_VALID (206, td, sf, 3.402819e+38dl, 3.402819e+38f, 0.f)
+
+/* A value slightly less than DEC32_MAX can be converted in both directions.  */
+CONVERT_VALID (211, sd, df, 9.999998e96df, 9.999998e96, 0.)
+CONVERT_VALID (212, df, sd, 9.999998e96, 9.999998e96df, 0.df)
+
+/* A value slightly less than DBL_MAX can be converted in both directions.  */
+CONVERT_VALID (221, df, dd, 1.79768e+308, 1.79768e+308dd, 0.dd)
+CONVERT_VALID (222, dd, df, 1.79768e+308dd, 1.79768e+308, 0.)
+CONVERT_VALID (223, df, td, 1.79768e+308, 1.79768e+308dl, 1.e292dl)
+CONVERT_VALID (224, td, df, 1.79768e+308dl, 1.79768e+308, 0.)
+
+/* An integral value with 6 digits (FLT_DIG) can be converted between float
+   and _Decimal32 in both directions.  */
+CONVERT_VALID (301, sd, sf, 100000.DF, 100000.F, 0.F)
+CONVERT_VALID (302, sf, sd, 100000.F, 100000.DF, 0.DF)
+CONVERT_VALID (303, sd, sf, 999999.DF, 999999.F, 0.F)
+CONVERT_VALID (304, sf, sd, 999999.F, 999999.DF, 0.DF)
+
+/* An integral value with 7 digits (DEC32_MANT_DIG) can be converted between
+   _Decimal32 and double in both directions.  */
+CONVERT_VALID (311, sd, df, 1000000.DF, 1000000., 0.)
+CONVERT_VALID (312, df, sd, 1000000., 1000000.DF, 0.DF)
+CONVERT_VALID (313, sd, df, 9999999.DF, 9999999., 0.)
+CONVERT_VALID (314, df, sd, 9999999., 9999999.DF, 0.DF)
+
+/* An integral value with 15 digits (DBL_DIG) can be converted between
+   double and _Decimal64 in both directions.  */
+CONVERT_VALID (321, dd, df, 100000000000000.DD, 100000000000000., 0.)
+CONVERT_VALID (322, df, dd, 100000000000000., 100000000000000.DD, 0.DD);
+CONVERT_VALID (323, dd, df, 999999999999999.DD, 999999999999999., 0.);
+CONVERT_VALID (324, df, dd, 999999999999999., 999999999999999.DD, 0.DD);
+
+/* If LDBL_DIG is at least 16, an integral value with 16 digits can be
+   converted between _Decimal64 and long double in both directions.  */
+CONVERT_VALID (331, dd, tf, 1000000000000000.DD, 1000000000000000.L, 0.L)
+CONVERT_VALID (332, td, dd, 1000000000000000.L, 1000000000000000.DD, 0.DD)
+CONVERT_VALID (333, dd, tf, 9999999999999999.DD, 9999999999999999.L, 0.L)
+CONVERT_VALID (334, td, dd, 9999999999999999.L, 9999999999999999.DD, 0.DD)
+
+/* If LDBL_DIG is at least 18, an integral value with 18 digits can be
+   converted between long double and _Decimal128 in both directions.  */
+CONVERT_VALID (341, td, tf, 100000000000000000.DL, 100000000000000000.L, 0.L)
+CONVERT_VALID (342, tf, td, 100000000000000000.L, 100000000000000000.DL, 0.DL)
+CONVERT_VALID (343, td, tf, 999999999999999999.DL, 999999999999999999.L, 0.L)
+CONVERT_VALID (344, tf, td, 999999999999999999.L, 999999999999999999.DL, 0.DL)
+
+/* If LDBL_DIG is at least 31, an integral value with 31 digits can be
+   converted between long double and _Decimal128 in both directions.  */
+CONVERT_VALID (351, td, tf, 1000000000000000000000000000000.DL,
+			    1000000000000000000000000000000.L, 0.L)
+CONVERT_VALID (352, tf, td, 1000000000000000000000000000000.L,
+			    1000000000000000000000000000000.DL, 0.DL)
+CONVERT_VALID (353, td, tf, 9999999999999999999999999999999.DL,
+			    9999999999999999999999999999999.L, 0.L)
+CONVERT_VALID (354, tf, td, 9999999999999999999999999999999.L,
+			    9999999999999999999999999999999.DL, 0.DL)
+
+/* If LDBL_DIG is at least 33, an integral value with 33 digits can be
+   converted between long double and _Decimal128 in both directions.  */
+CONVERT_VALID (361, td, tf, 100000000000000000000000000000000.DL,
+			    100000000000000000000000000000000.L, 0.L)
+CONVERT_VALID (362, tf, td, 100000000000000000000000000000000.L,
+			    100000000000000000000000000000000.DL, 0.DL)
+CONVERT_VALID (363, td, tf, 999999999999999999999999999999999.DL,
+			    999999999999999999999999999999999.L, 0.L)
+CONVERT_VALID (364, tf, td, 999999999999999999999999999999999.L,
+			    999999999999999999999999999999999.DL, 0.DL)
+
+int
+main ()
+{
+  convert_101 ();
+  convert_102 ();
+  convert_103 ();
+  convert_104 ();
+  convert_105 ();
+
+  convert_201 ();
+  convert_202 ();
+  convert_203 ();
+  convert_204 ();
+  convert_205 ();
+  convert_206 ();
+
+  convert_211 ();
+  convert_212 ();
+
+  convert_221 ();
+  convert_222 ();
+  convert_223 ();
+  convert_224 ();
+
+  convert_301 ();
+  convert_302 ();
+  convert_303 ();
+  convert_304 ();
+
+  convert_311 ();
+  convert_312 ();
+  convert_313 ();
+  convert_314 ();
+
+  convert_321 ();
+  convert_322 ();
+  convert_323 ();
+  convert_324 ();
+
+  if (LDBL_DIG >= 16)
+    {
+      convert_331 ();
+      convert_332 ();
+      convert_333 ();
+      convert_334 ();
+    }
+
+  if (LDBL_DIG >= 18)
+    {
+      convert_341 ();
+      convert_342 ();
+      convert_343 ();
+      convert_344 ();
+    }
+
+  if (LDBL_DIG >= 31)
+    {
+      convert_351 ();
+      convert_352 ();
+      convert_353 ();
+      convert_354 ();
+    }
+
+  if (LDBL_DIG >= 33)
+    {
+      convert_361 ();
+      convert_362 ();
+      convert_363 ();
+      convert_364 ();
+    }
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-7.c
new file mode 100644
index 000000000..0fb4f076d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-7.c
@@ -0,0 +1,85 @@
+/* { dg-options "-std=gnu99 -w" } */
+
+/* This test assumes IEEE float and double.  */
+
+#define __STDC_WANT_DEC_FP__
+#include <float.h>
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+
+/* Check values that are too large for the result type.  */
+CONVERT_TO_PINF (301, sd, sf, 4.e+38df, f)
+CONVERT_TO_PINF (303, dd, sf, 4.e+38dd, f)
+CONVERT_TO_PINF (302, sd, sf, 9.9e+384df, f)
+CONVERT_TO_PINF (304, dd, sf, 9.9e+384dd, f)
+CONVERT_TO_PINF (305, td, sf, 4.e+38dl, f)
+CONVERT_TO_PINF (306, td, sf, 1.e+39dl, f)
+CONVERT_TO_MINF (311, sd, sf, -4.e+38df, f)
+CONVERT_TO_MINF (312, dd, sf, -4.e+38dd, f)
+CONVERT_TO_MINF (313, sd, sf, -9.9e+384df, f)
+CONVERT_TO_MINF (314, dd, sf, -9.9e+384dd, f)
+CONVERT_TO_MINF (315, td, sf, -4.e+38dl, f)
+CONVERT_TO_MINF (316, td, sf, -1.e+39dl, f)
+
+CONVERT_TO_PINF (321, dd, df, 1.8e+308dd,)
+CONVERT_TO_PINF (322, dd, df, 9.9e+384dd,)
+CONVERT_TO_PINF (323, td, df, 1.8e+308dl,)
+CONVERT_TO_PINF (324, td, df, 9.9e+384dl,)
+CONVERT_TO_PINF (325, dd, df, 1.e309dd,)
+CONVERT_TO_PINF (326, td, df, 1.e309dl,)
+CONVERT_TO_MINF (331, dd, df, -1.8e+308dd,)
+CONVERT_TO_MINF (332, dd, df, -9.9e+384dd,)
+CONVERT_TO_MINF (333, td, df, -1.8e+308dl,)
+CONVERT_TO_MINF (334, td, df, -9.9e+384dl,)
+CONVERT_TO_MINF (335, dd, df, -1.e309dd,)
+CONVERT_TO_MINF (336, td, df, -1.e309dl,)
+
+CONVERT_TO_PINF (341, df, sd, 1.0e+97, d32)
+CONVERT_TO_PINF (342, df, sd, 1.6e+308, d32)
+CONVERT_TO_MINF (351, df, sd, -1.0e+97, d32)
+CONVERT_TO_MINF (352, df, sd, -1.6e+308, d32)
+
+int
+main ()
+{
+  convert_301 ();
+  convert_302 ();
+  convert_303 ();
+  convert_304 ();
+  convert_305 ();
+  convert_306 ();
+  convert_311 ();
+  convert_312 ();
+  convert_313 ();
+  convert_314 ();
+  convert_315 ();
+  convert_316 ();
+
+  convert_321 ();
+  convert_322 ();
+  convert_323 ();
+  convert_324 ();
+  convert_325 ();
+  convert_326 ();
+  convert_331 ();
+  convert_332 ();
+  convert_333 ();
+  convert_334 ();
+  convert_335 ();
+  convert_336 ();
+
+  convert_341 ();
+  convert_342 ();
+  convert_351 ();
+  convert_352 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-8.c
new file mode 100644
index 000000000..269fc37f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-8.c
@@ -0,0 +1,73 @@
+/* { dg-options "-std=gnu99 -w" } */
+
+/* This test assumes IEEE float and double.  */
+
+#define __STDC_WANT_DEC_FP__
+#include <float.h>
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+
+/* Values slightly smaller than minimum (closest to zero) for result type.  */
+CONVERT_VALID (401, sd, sf, 1.e-39df, 0.f, FLT_MIN)
+CONVERT_VALID (402, sd, sf, -1.e-39df, 0.f, FLT_MIN)
+CONVERT_VALID (403, sd, sf, 1.1e-38df, 0.f, FLT_MIN)
+CONVERT_VALID (404, sd, sf, -1.1e-38df, 0.f, FLT_MIN)
+
+CONVERT_VALID (411, dd, sf, 1.e-39dd, 0.f, FLT_MIN)
+CONVERT_VALID (412, dd, sf, -1.e-39dd, 0.f, FLT_MIN)
+CONVERT_VALID (413, dd, sf, 1.1e-38dd, 0.f, FLT_MIN)
+CONVERT_VALID (414, dd, sf, -1.1e-38dd, 0.f, FLT_MIN)
+
+CONVERT_VALID (421, dd, df, 3.e-309dd, 0., DBL_MIN)
+CONVERT_VALID (422, dd, df, -3.e-309dd, 0., DBL_MIN)
+CONVERT_VALID (423, dd, df, 2.e-308dd, 0., DBL_MIN)
+CONVERT_VALID (424, dd, df, -2.e-308dd, 0., DBL_MIN)
+
+CONVERT_VALID (431, td, sf, 1.e-39dl, 0.f, FLT_MIN)
+CONVERT_VALID (432, td, sf, -1.e-39dl, 0.f, FLT_MIN)
+CONVERT_VALID (433, td, sf, 1.1e-38dl, 0.f, FLT_MIN)
+CONVERT_VALID (434, td, sf, -1.1e-38dl, 0.f, FLT_MIN)
+
+CONVERT_VALID (441, td, df, 3.e-309dl, 0., DBL_MIN)
+CONVERT_VALID (442, td, df, -3.e-309dl, 0., DBL_MIN)
+CONVERT_VALID (443, td, df, 2.e-308dl, 0., DBL_MIN)
+CONVERT_VALID (444, td, df, -2.e-308dl, 0., DBL_MIN)
+
+int
+main ()
+{
+  convert_401 ();
+  convert_402 ();
+  convert_403 ();
+  convert_404 ();
+
+  convert_411 ();
+  convert_412 ();
+  convert_413 ();
+  convert_414 ();
+
+  convert_421 ();
+  convert_422 ();
+  convert_423 ();
+  convert_424 ();
+
+  convert_431 ();
+  convert_432 ();
+  convert_433 ();
+  convert_434 ();
+
+  convert_441 ();
+  convert_442 ();
+  convert_443 ();
+  convert_444 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-9.c
new file mode 100644
index 000000000..90f069213
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-9.c
@@ -0,0 +1,194 @@
+/* { dg-xfail-run-if "" { lax_strtofp } "*" "" } */
+/* { dg-options "-std=gnu99 -w" } */
+
+/* This test assumes IEEE float and double.  */
+
+#define __STDC_WANT_DEC_FP__
+#include <float.h>
+
+#include "convert.h"
+
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+volatile float sf;
+volatile double df;
+
+/* Exponent values that might cause problems with a particular
+   implementation.  */
+
+CONVERT_VALID (101, dd, df, 1.e309dd, 1.e309, 0.) 
+CONVERT_VALID (102, dd, df, 1.e308dd, 1.e308, 0.)
+CONVERT_VALID (103, dd, df, 1.e307dd, 1.e307, 0.) 
+CONVERT_VALID (104, dd, df, 1.e306dd, 1.e306, 0.) 
+CONVERT_VALID (105, dd, df, 1.e305dd, 1.e305, 0.)
+CONVERT_VALID (106, dd, df, 1.e304dd, 1.e304, 0.)
+CONVERT_VALID (107, dd, df, 1.e303dd, 1.e303, 0.) 
+CONVERT_VALID (108, dd, df, 1.e302dd, 1.e302, 0.) 
+CONVERT_VALID (109, dd, df, 1.e301dd, 1.e301, 0.) 
+CONVERT_VALID (110, dd, df, 1.e300dd, 1.e300, 0.) 
+CONVERT_VALID (111, dd, df, 1.e299dd, 1.e299, 0.) 
+CONVERT_VALID (112, dd, df, 1.e298dd, 1.e298, 0.) 
+CONVERT_VALID (113, dd, df, 1.e297dd, 1.e297, 0.) 
+CONVERT_VALID (114, dd, df, 1.e296dd, 1.e296, 0.) 
+CONVERT_VALID (115, dd, df, 1.e295dd, 1.e295, 0.) 
+CONVERT_VALID (116, dd, df, 1.e294dd, 1.e294, 0.) 
+CONVERT_VALID (117, dd, df, 1.e293dd, 1.e293, 0.) 
+CONVERT_VALID (118, dd, df, 1.e292dd, 1.e292, 0.) 
+CONVERT_VALID (119, dd, df, 1.e291dd, 1.e291, 0.)
+CONVERT_VALID (120, dd, df, 1.e290dd, 1.e290, 0.)
+
+CONVERT_VALID (201, dd, df, 1.e-309dd, 1.e-309, 0.) 
+CONVERT_VALID (202, dd, df, 1.e-308dd, 1.e-308, 0.) 
+CONVERT_VALID (203, dd, df, 1.e-307dd, 1.e-307, 0.) 
+CONVERT_VALID (204, dd, df, 1.e-306dd, 1.e-306, 0.) 
+CONVERT_VALID (205, dd, df, 1.e-305dd, 1.e-305, 0.) 
+CONVERT_VALID (206, dd, df, 1.e-304dd, 1.e-304, 0.) 
+CONVERT_VALID (207, dd, df, 1.e-303dd, 1.e-303, 0.) 
+CONVERT_VALID (208, dd, df, 1.e-302dd, 1.e-302, 0.) 
+CONVERT_VALID (209, dd, df, 1.e-301dd, 1.e-301, 0.) 
+CONVERT_VALID (210, dd, df, 1.e-300dd, 1.e-300, 0.) 
+CONVERT_VALID (211, dd, df, 1.e-299dd, 1.e-299, 0.) 
+CONVERT_VALID (212, dd, df, 1.e-298dd, 1.e-298, 0.) 
+CONVERT_VALID (213, dd, df, 1.e-297dd, 1.e-297, 0.) 
+CONVERT_VALID (214, dd, df, 1.e-296dd, 1.e-296, 0.) 
+CONVERT_VALID (215, dd, df, 1.e-295dd, 1.e-295, 0.)
+CONVERT_VALID (216, dd, df, 1.e-294dd, 1.e-294, 0.)
+CONVERT_VALID (217, dd, df, 1.e-293dd, 1.e-293, 0.) 
+CONVERT_VALID (218, dd, df, 1.e-292dd, 1.e-292, 0.) 
+CONVERT_VALID (219, dd, df, 1.e-291dd, 1.e-291, 0.) 
+CONVERT_VALID (220, dd, df, 1.e-290dd, 1.e-290, 0.) 
+
+CONVERT_VALID (301, td, df, 1.e309dl, 1.e309, 0.) 
+CONVERT_VALID (302, td, df, 1.e308dl, 1.e308, 0.)
+CONVERT_VALID (303, td, df, 1.e307dl, 1.e307, 0.) 
+CONVERT_VALID (304, td, df, 1.e306dl, 1.e306, 0.) 
+CONVERT_VALID (305, td, df, 1.e305dl, 1.e305, 0.)
+CONVERT_VALID (306, td, df, 1.e304dl, 1.e304, 0.)
+CONVERT_VALID (307, td, df, 1.e303dl, 1.e303, 0.) 
+CONVERT_VALID (308, td, df, 1.e302dl, 1.e302, 0.) 
+CONVERT_VALID (309, td, df, 1.e301dl, 1.e301, 0.)
+CONVERT_VALID (310, td, df, 1.e300dl, 1.e300, 0.) 
+CONVERT_VALID (311, td, df, 1.e299dl, 1.e299, 0.)
+CONVERT_VALID (312, td, df, 1.e298dl, 1.e298, 0.)
+CONVERT_VALID (313, td, df, 1.e297dl, 1.e297, 0.) 
+CONVERT_VALID (314, td, df, 1.e296dl, 1.e296, 0.) 
+CONVERT_VALID (315, td, df, 1.e295dl, 1.e295, 0.)
+CONVERT_VALID (316, td, df, 1.e294dl, 1.e294, 0.)
+CONVERT_VALID (317, td, df, 1.e293dl, 1.e293, 0.) 
+CONVERT_VALID (318, td, df, 1.e292dl, 1.e292, 0.) 
+CONVERT_VALID (319, td, df, 1.e291dl, 1.e291, 0.) 
+CONVERT_VALID (320, td, df, 1.e290dl, 1.e290, 0.)
+
+CONVERT_VALID (401, td, df, 1.e-309dl, 1.e-309, 0.) 
+CONVERT_VALID (402, td, df, 1.e-308dl, 1.e-308, 0.) 
+CONVERT_VALID (403, td, df, 1.e-307dl, 1.e-307, 0.) 
+CONVERT_VALID (404, td, df, 1.e-306dl, 1.e-306, 0.) 
+CONVERT_VALID (405, td, df, 1.e-305dl, 1.e-305, 0.) 
+CONVERT_VALID (406, td, df, 1.e-304dl, 1.e-304, 0.) 
+CONVERT_VALID (407, td, df, 1.e-303dl, 1.e-303, 0.) 
+CONVERT_VALID (408, td, df, 1.e-302dl, 1.e-302, 0.) 
+CONVERT_VALID (409, td, df, 1.e-301dl, 1.e-301, 0.) 
+CONVERT_VALID (410, td, df, 1.e-300dl, 1.e-300, 0.) 
+CONVERT_VALID (411, td, df, 1.e-299dl, 1.e-299, 0.) 
+CONVERT_VALID (412, td, df, 1.e-298dl, 1.e-298, 0.) 
+CONVERT_VALID (413, td, df, 1.e-297dl, 1.e-297, 0.) 
+CONVERT_VALID (414, td, df, 1.e-296dl, 1.e-296, 0.) 
+CONVERT_VALID (415, td, df, 1.e-295dl, 1.e-295, 0.) 
+CONVERT_VALID (416, td, df, 1.e-294dl, 1.e-294, 0.) 
+CONVERT_VALID (417, td, df, 1.e-293dl, 1.e-293, 0.) 
+CONVERT_VALID (418, td, df, 1.e-292dl, 1.e-292, 0.)
+CONVERT_VALID (419, td, df, 1.e-291dl, 1.e-291, 0.) 
+CONVERT_VALID (420, td, df, 1.e-290dl, 1.e-290, 0.)
+
+int
+main ()
+{
+  convert_101 ();
+  convert_102 ();
+  convert_103 ();
+  convert_104 ();
+  convert_105 ();
+  convert_106 ();
+  convert_107 ();
+  convert_108 ();
+  convert_109 ();
+  convert_110 ();
+  convert_111 ();
+  convert_112 ();
+  convert_113 ();
+  convert_114 ();
+  convert_115 ();
+  convert_116 ();
+  convert_117 ();
+  convert_118 ();
+  convert_119 ();
+  convert_120 ();
+
+  convert_201 ();
+  convert_202 ();
+  convert_203 ();
+  convert_204 ();
+  convert_205 ();
+  convert_206 ();
+  convert_207 ();
+  convert_208 ();
+  convert_209 ();
+  convert_210 ();
+  convert_211 ();
+  convert_212 ();
+  convert_213 ();
+  convert_214 ();
+  convert_215 ();
+  convert_216 ();
+  convert_217 ();
+  convert_218 ();
+  convert_219 ();
+  convert_220 ();
+
+  convert_301 ();
+  convert_302 ();
+  convert_303 ();
+  convert_304 ();
+  convert_305 ();
+  convert_306 ();
+  convert_307 ();
+  convert_308 ();
+  convert_309 ();
+  convert_310 ();
+  convert_311 ();
+  convert_312 ();
+  convert_313 ();
+  convert_314 ();
+  convert_315 ();
+  convert_316 ();
+  convert_317 ();
+  convert_318 ();
+  convert_319 ();
+  convert_320 ();
+
+  convert_401 ();
+  convert_402 ();
+  convert_403 ();
+  convert_404 ();
+  convert_405 ();
+  convert_406 ();
+  convert_407 ();
+  convert_408 ();
+  convert_409 ();
+  convert_410 ();
+  convert_411 ();
+  convert_412 ();
+  convert_413 ();
+  convert_414 ();
+  convert_415 ();
+  convert_416 ();
+  convert_417 ();
+  convert_418 ();
+  convert_419 ();
+  convert_420 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-fold.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-fold.c
new file mode 100644
index 000000000..8c20a52ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp-fold.c
@@ -0,0 +1,116 @@
+/* { dg-options "-std=gnu99 -O2" } */
+
+/* N1150 5.2 Conversions among decimal floating types and between
+   decimal floating types and generic floating types.
+   C99 6.3.1.5(4) Conversions, arithmetic operands, real floating types.  */
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+float sf;
+double df;
+long double tf;
+
+extern void link_error (void);
+
+int
+main ()
+{
+  /* Conversions from decimal float to binary float. */
+
+  /* Conversions from _Decimal32. */
+  d32 = 2.0df;
+  sf = d32;
+  if (sf != 2.0f)
+    link_error ();
+
+  df = d32;
+  if (df != 2.0)
+    link_error ();
+
+  tf = d32;
+  if (tf != 2.0l)
+    link_error ();
+
+  /* Conversions from _Decimal64. */
+  d64 = -7.0dd;
+  sf = d64;
+  if (sf != -7.0f)
+    link_error ();
+  
+  df = d64;
+  if (df != -7.0)
+    link_error ();
+
+  tf = d64;
+  if (tf != -7.0l)
+    link_error ();
+
+  /* Conversions from _Decimal128. */
+  d128 = 30.0dl;
+  sf = d128;
+  if (sf != 30.0f)
+    link_error ();
+
+  df = d128;
+  if (df != 30.0)
+    link_error ();
+
+  df = d128;
+  if (df != 30.0l)
+    link_error ();
+
+  /* Conversions from binary float to decimal float. */
+  sf = 30.0f;
+  d128 = sf;
+  if (d128 != 30.0dl)
+    link_error ();
+
+  d64 = sf;
+  if (d64 != 30.0dd)
+    link_error ();
+
+  d32 = sf;
+  if (d32 != 30.0df)
+    link_error ();
+
+  df = -2.0;
+  d128 = df;
+  if (d128 != -2.0dl)
+    link_error ();
+
+  d64 = df;
+  if (d64 != -2.0dd)
+    link_error ();
+
+  d32 = df;
+  if (d32 != -2.0df)
+    link_error ();  
+
+  tf = -22.0l;
+  d128 = tf;
+  if (d128 != -22.0dl)
+    link_error ();
+
+  d64 = tf;
+  if (d64 != -22.0dd)
+    link_error ();
+
+  d32 = tf;
+  if (d32 != -22.0df)
+    link_error ();
+
+  /* 2**(-11) = 0.00048828125. */
+  d128 = 0.000488281251dl;
+  sf = d128;
+  if (sf != 0.00048828125f)
+    link_error ();
+  /* 2**(-25) = 0.298023223876953125E-7.  */
+  d128 = 2.98023223876953125E-8dl;
+  df = d128;
+  if (df < (2.9802322387695312e-08 - 0.00000000001)
+      || df > (2.9802322387695312e-08 + 0.00000000001))
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp.c
new file mode 100644
index 000000000..b2e8ca87b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-bfp.c
@@ -0,0 +1,145 @@
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 5.2 Conversions among decimal floating types and between
+   decimal floating types and generic floating types.
+   C99 6.3.1.5(4) Conversions, arithmetic operands, real floating types.  */
+
+/* Long double isn't supported yet at runtime, so disable those checks.  */
+
+extern void abort (void);
+static int failcnt;
+static int skip_long_double;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+volatile _Decimal32 d32;
+volatile _Decimal64 d64;
+volatile _Decimal128 d128;
+volatile float sf;
+volatile double df;
+volatile long double tf;
+
+int
+main ()
+{
+  /* Conversions from decimal float to binary float. */
+
+  if (sizeof (long double) == sizeof (double))
+    skip_long_double = 1;
+
+  /* Conversions from _Decimal32. */
+  d32 = 2.0df;
+  sf = d32;
+  if (sf != 2.0f)
+    FAILURE
+
+  df = d32;
+  if (df != 2.0)
+    FAILURE
+
+  if (skip_long_double == 0)
+    {
+      tf = d32;
+      if (tf != 2.0l)
+	FAILURE
+    }
+
+  /* Conversions from _Decimal64. */
+  d64 = -7.0dd;
+  sf = d64;
+  if (sf != -7.0f)
+    FAILURE
+  
+  df = d64;
+  if (df != -7.0)
+    FAILURE
+
+  if (skip_long_double == 0)
+    {
+      tf = d64;
+      if (tf != -7.0l)
+	FAILURE
+    }
+
+  /* Conversions from _Decimal128. */
+  d128 = 30.0dl;
+  sf = d128;
+  if (sf != 30.0f)
+    FAILURE
+
+  df = d128;
+  if (df != 30.0)
+    FAILURE
+
+  df = d128;
+  if (df != 30.0l)
+    FAILURE
+
+  /* Conversions from binary float to decimal float. */
+  sf = 30.0f;
+  d32 = sf;
+  if (d32 != 30.0df)
+    FAILURE
+
+  d64 = sf;
+  if (d64 != 30.0dd)
+    FAILURE
+
+  df = -2.0;
+  d32 = df;
+  if (d32 != -2.0df)
+    FAILURE
+
+  d64 = df;
+  if (d64 != -2.0dd)
+    FAILURE
+
+  d128 = df;
+  if (d128 != -2.0dl)
+    FAILURE
+  
+  sf = 30.0f;
+  d128 = sf;
+  if (d128 != 30.0dl)
+    FAILURE
+
+  if (skip_long_double == 0)
+    {
+      tf = -22.0l;
+      d32 = tf;
+      if (d32 != -22.0df)
+	FAILURE
+
+      d64 = tf;
+      if (d64 != -22.0dd)
+	FAILURE
+
+      d128 = tf;
+      if (d128 != -22.0dl)
+	FAILURE
+     }
+
+  /* 2**(-11) = 0.00048828125. */
+  d128 = 0.000488281251dl;
+  sf = d128;
+  if (sf != 0.00048828125f)
+    FAILURE
+  /* 2**(-25) = 0.298023223876953125E-7.  */
+  d128 = 2.98023223876953125E-8dl;
+  df = d128;
+  if (df < (2.9802322387695312e-08 - 0.00000000001)
+      || df > (2.9802322387695312e-08 + 0.00000000001))
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-complex.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-complex.c
new file mode 100644
index 000000000..0083b0918
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-complex.c
@@ -0,0 +1,131 @@
+/* { dg-options "-O3" } */
+
+/* N1150 5.3 Conversions between decimal floating and complex.
+   C99 6.3.1.7 Conversions, arithmetic operands, real and complex.  */
+
+extern void abort(void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+int
+main ()
+{
+  _Complex float cf;
+  _Complex double cd;
+  _Complex long double cld;
+
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+
+  cf = 2.0f *  __extension__ 1i + 3.0f;
+  cd = 2.0 * __extension__ 1i + 3.0;
+  cld = 2.0l * __extension__ 1i + 3.0l;
+
+  /* Convert complex to decimal floating.  */
+  d32 = cf;
+  d64 = cd;
+  d128 = cld;
+
+  if (d32 != 3.0DF)
+    FAILURE
+  if (d64 != 3.0dd)
+    FAILURE
+  if (d128 != 3.0dl)
+    FAILURE
+
+  /* Convert decimal floating to complex.  */
+  d32 = 2.5DF;
+  d64 = 1.5DD;
+  d128 = 2.5DL;
+
+  cf = d32;
+  cd = d64;
+  cld = d128;
+ 
+  /* N1107 5.3 Conversions between decimal floating and complex. 
+     When a value of decimal floating type converted to a complex
+     type, the real part of the complex result value is undermined
+     by the rules of conversions in N1107 5.2 and the imaginary part
+     of the complex result value is zero.  */
+
+  if (__real__ cf != 2.5f)
+    FAILURE
+  if (__real__ cd !=1.5)
+    FAILURE
+  if (__real__ cld !=  2.5)
+    FAILURE
+  if (__imag__ cf != 0.0f)
+    FAILURE
+  if (__imag__ cd != 0.0)
+    FAILURE
+  if (__imag__ cld != 0.0l)
+    FAILURE
+
+  /*  Verify that the conversions from DFP types to complex is
+      determined by the rules of conversion to the real part.  */
+
+  /*  Convert _Decimal64 to _Complex float.  */
+  d64 = 0.125dl;
+  cf = d64;
+  if (__real__ cf != 0.125f)
+    FAILURE
+  /*  Convert _Decimal128 to _Complex double.  */
+  d128 = 1.25E-7dl;
+  cd = d128;
+  if (__real__ cd != 1.25E-7)
+    FAILURE
+
+  /*  Verify that conversion from complex to decimal floating types
+      results in the value of the real part converted to the result
+      type according to the rules of conversion between those types.  */
+
+  /*  Convert _Complex float to decimal float types.  */
+  cf = 2.0f *  __extension__ 1i + 2.25f;
+  d32 = cf;
+  d64 = cf;
+  d128 = cf;
+  if (d32 != 2.25DF)
+    FAILURE
+  if (d64 != 2.25DD)
+    FAILURE
+  if (d128 != 2.25DL)
+    FAILURE
+
+  /*  Convert _Complex double to decimal float types.  */
+  cd = 2.0 *  __extension__ 1i + 1.25;
+  d32 = cd;
+  d64 = cd;
+  d128 = cd;
+  if (d32 != 1.25DF)
+    FAILURE
+  if (d64 != 1.25DD)
+    FAILURE
+  if (d128 != 1.25DL)
+    FAILURE
+
+  /*  Convert _Complex long double to decimal float types.  */
+  cld = 2.0l *  __extension__ 1i + 0.0625l;
+  d32 = cld;
+  d64 = cld;
+  d128 = cld;
+  if (d32 != 0.0625DF)
+    FAILURE
+  if (d64 != 0.0625DD)
+    FAILURE
+  if (d128 != 0.0625DL)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-fold-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-fold-2.c
new file mode 100644
index 000000000..9f0927963
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-fold-2.c
@@ -0,0 +1,17 @@
+/* Test for bug where fold narrowed decimal floating-point
+   operations.  */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort (void);
+extern void exit (int);
+
+volatile _Decimal32 f = 1.23456DF;
+volatile _Decimal64 d = 1.23456DD;
+
+int
+main (void)
+{
+  if ((_Decimal128)((_Decimal64)f * (_Decimal64)f) != (_Decimal128)(d * d))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-fold.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-fold.c
new file mode 100644
index 000000000..a56f0dfc2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-fold.c
@@ -0,0 +1,45 @@
+/* { dg-options "-std=gnu99 -O2" } */
+
+/* N1150 5.2 Conversions among decimal floating types and between
+   decimal floating types and generic floating types.
+   C99 6.3.1.5(3) New.  */
+
+extern void link_error ();
+
+int
+main ()
+{
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+
+  /* Conversions to larger types.  */
+  d32 = 123.4df;
+  d64 = d32;
+  if (d64 != 123.4dd)
+    link_error ();
+  d128 = d32;
+  if (d128 != 123.4dl)
+    link_error ();
+  d64 = 345.678dd;
+  d128 = d64;
+  if (d128 != 345.678dl)
+    link_error ();
+
+  /* Conversions to smaller types for which the value fits.  */
+  d64 = 3456.789dd;
+  d32 = d64;
+  if (d32 != 3456.789df)
+    link_error ();
+  d128 = 123.4567dl;
+  d32 = d128;
+  if (d32 != 123.4567dl)
+    link_error ();
+
+  d128 = 1234567890.123456dl;
+  d64 = d128;
+  if (d64 != 1234567890.123456dd)
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-round-thread.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-round-thread.c
new file mode 100644
index 000000000..d288ac70c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-round-thread.c
@@ -0,0 +1,494 @@
+/* { dg-options "-std=gnu99 -D_GNU_SOURCE -pthread" } */
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* } } */
+
+/* N1150 5.2: Conversions among decimal floating types and between
+   decimal floating types and generic floating types.
+   C99 6.3.1.5(3) New.
+
+   Perform conversions between DFP types in which the assigned value
+   cannot be represented exactly in the result and must be rounded
+   correctly according to the current rounding mode.
+
+   Normally this would not be part of compiler testing, but conversions
+   are currently handled in libgcc via decNumber.  */
+
+#include <pthread.h>
+#include <error.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include "dfp-round.h"
+
+extern void abort (void);
+static __thread int failcnt = 0;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mut3 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mut4 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mut5 = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
+pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
+pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
+pthread_cond_t cond4 = PTHREAD_COND_INITIALIZER;
+pthread_cond_t cond5 = PTHREAD_COND_INITIALIZER;
+pthread_barrier_t bar1;
+pthread_barrier_t bar2;
+pthread_barrier_t bar3;
+pthread_barrier_t bar4;
+pthread_barrier_t bar5;
+
+__thread _Decimal32 d32;
+__thread _Decimal64 d64;
+__thread _Decimal128 d128;
+
+_Decimal32 d64_to_d32 (_Decimal64 d) { return d; }
+_Decimal64 d128_to_d64 (_Decimal128 d) { return d; }
+_Decimal32 d128_to_d32 (_Decimal128 d) { return d; }
+
+int
+do_d64_to_d32 (_Decimal64 orig, _Decimal32 exp)
+{
+  d64 = orig;
+  d32 = d64_to_d32 (d64);
+  return (d32 == exp);
+}
+
+int
+do_d128_to_d32 (_Decimal128 orig, _Decimal32 exp)
+{
+  d128 = orig;
+  d32 = d128_to_d32 (d128);
+  return (d32 == exp);
+}
+
+int
+do_d128_to_d64 (_Decimal128 orig, _Decimal64 exp)
+{
+  d128 = orig;
+  d64 = d128_to_d64 (d128);
+  return (d64 == exp);
+}
+
+void *
+downward (void *arg)
+{
+  int err;
+
+  DFP_SETROUND (FE_DEC_DOWNWARD);
+
+  err = pthread_mutex_lock (&mut1);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "downward: failed to lock");
+
+  err = pthread_barrier_wait (&bar1);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("downward: barrier_wait failed");
+      exit (1);
+    } 
+
+  err = pthread_cond_wait (&cond1, &mut1);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "downward: failed to wait");
+
+  err = pthread_mutex_unlock (&mut1);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "downward: failed to unlock");
+
+  if (!do_d64_to_d32 (1.1111125dd, 1.111112df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111114df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111112df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111114df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111114dd)) FAILURE
+  
+#ifdef DBG
+  if (failcnt)
+    printf ("downward: %d fails\n", failcnt);
+#endif
+  return (void *) (ptrdiff_t) failcnt;
+}
+
+void *
+tonearest (void *arg)
+{
+  int err;
+  DFP_SETROUND (FE_DEC_TONEAREST);
+
+  err = pthread_mutex_lock (&mut2);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "tonearest: failed to lock");
+
+  err = pthread_barrier_wait (&bar2);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("tonearest: barrier_wait failed");
+      exit (1);
+    } 
+
+  err = pthread_cond_wait (&cond2, &mut2);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "tonearest: failed to wait");
+
+  err = pthread_mutex_unlock (&mut2);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "tonearest: failed to unlock");
+
+  if (!do_d64_to_d32 (1.1111125dd, 1.111112df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111114df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111112df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111114df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111112df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111114df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111112df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111114df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111114dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111114dd)) FAILURE
+  
+#ifdef DBG
+  if (failcnt)
+    printf ("tonearest: %d fails\n", failcnt);
+#endif
+  return (void *) (ptrdiff_t) failcnt;
+} 
+
+void *
+toneareastfromzero (void *arg)
+{
+  int err;
+  DFP_SETROUND (FE_DEC_TONEARESTFROMZERO);
+
+  err = pthread_mutex_lock (&mut3);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "toneareastfromzero: failed to lock");
+
+  err = pthread_barrier_wait (&bar3);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("toneareastfromzero: barrier_wait failed");
+      exit (1);
+    } 
+
+  err = pthread_cond_wait (&cond3, &mut3);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "toneareastfromzero: failed to wait");
+
+  err = pthread_mutex_unlock (&mut3);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "toneareastfromzero: failed to unlock");
+
+  if (!do_d64_to_d32 (1.1111125dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111114df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111114df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111114df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111114df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111114dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111114dd)) FAILURE
+  
+#ifdef DBG
+  if (failcnt)
+    printf ("toneareastfromzero: %d fails\n", failcnt);
+#endif
+  return (void *) (ptrdiff_t) failcnt;
+} 
+  
+void *
+towardzero (void *arg)
+{
+  int err;
+  DFP_SETROUND (FE_DEC_TOWARDZERO);
+
+  err = pthread_mutex_lock (&mut4);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "towardzero: failed to lock");
+
+  err = pthread_barrier_wait (&bar4);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("towardzero: barrier_wait failed");
+      exit (1);
+    } 
+
+  err = pthread_cond_wait (&cond4, &mut4);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "towardzero: failed to wait");
+
+  err = pthread_mutex_unlock (&mut4);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "towardzero: failed to unlock");
+
+  if (!do_d64_to_d32 (1.1111125dd, 1.111112df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111112df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111112df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111112df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111113dd)) FAILURE
+
+#ifdef DBG
+  if (failcnt)
+    printf ("towardzero: %d fails\n", failcnt);
+#endif
+  return (void *) (ptrdiff_t) failcnt;
+} 
+
+void *
+upward (void *arg)
+{
+  int err;
+  DFP_SETROUND (FE_DEC_UPWARD);
+
+  err = pthread_mutex_lock (&mut5);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "upward: failed to lock");
+
+  err = pthread_barrier_wait (&bar5);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("upward: barrier_wait failed");
+      exit (1);
+    } 
+
+  err = pthread_cond_wait (&cond5, &mut5);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "upward: failed to wait");
+
+  err = pthread_mutex_unlock (&mut5);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "upward: failed to unlock");
+
+  if (!do_d64_to_d32 (1.1111125dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111114df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111112df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111114df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111112df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111114dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111113dd)) FAILURE
+  
+#ifdef DBG
+  if (failcnt)
+    printf ("upward: %d fails\n", failcnt);
+#endif
+  return (void *) (ptrdiff_t) failcnt;
+}
+
+int
+main (void)
+{
+  int err;
+  int count = 0;
+  void *ret;
+  pthread_t down, up, tozero, fromzero, nearest;
+
+  if (pthread_barrier_init (&bar1, NULL, 2) != 0
+      || pthread_barrier_init (&bar2, NULL, 2) != 0
+      || pthread_barrier_init (&bar3, NULL, 2) != 0
+      || pthread_barrier_init (&bar4, NULL, 2) != 0
+      || pthread_barrier_init (&bar5, NULL, 2) != 0)
+    {
+      puts ("parent: failed to init barrier");
+      return 1;
+    }
+
+  if (pthread_create (&down, NULL, downward, NULL) != 0)
+    {
+      puts ("parent: failed to create");
+      return 1;
+    }
+
+  if (pthread_create (&nearest, NULL, tonearest, NULL) != 0)
+    {
+      puts ("create failed");
+      return 1;
+    }
+
+  if (pthread_create (&fromzero, NULL, toneareastfromzero, NULL) != 0)
+    {
+      puts ("create failed");
+      return 1;
+    }
+
+  if (pthread_create (&up, NULL, upward, NULL) != 0)
+    {
+      puts ("create failed");
+      return 1;
+    }
+
+  if (pthread_create (&tozero, NULL, towardzero, NULL) != 0)
+    {
+      puts ("create failed");
+      return 1;
+    }
+
+  err = pthread_barrier_wait (&bar1);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("parent: failed to wait barrier 1");
+      return 1;
+    }
+  err = pthread_barrier_wait (&bar2);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("parent: failed to wait barrier 2");
+      return 1;
+    }
+  err = pthread_barrier_wait (&bar3);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("parent: failed to wait barrier 3");
+      return 1;
+    }
+  err = pthread_barrier_wait (&bar4);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("parent: failed to wait barrier 4");
+      return 1;
+    }
+  err = pthread_barrier_wait (&bar5);
+  if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD)
+    {
+      puts ("parent: failed to wait barrier 5");
+      return 1;
+    }
+
+  err = pthread_mutex_lock (&mut1);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: lock failed");
+  err = pthread_mutex_lock (&mut2);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: lock failed");
+  err = pthread_mutex_lock (&mut3);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: lock failed");
+  err = pthread_mutex_lock (&mut4);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: lock failed");
+  err = pthread_mutex_lock (&mut5);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: lock failed");
+
+  err = pthread_cond_signal(&cond1);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: broadcast failed");
+  err = pthread_cond_signal(&cond2);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: broadcast failed");
+  err = pthread_cond_signal(&cond3);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: broadcast failed");
+  err = pthread_cond_signal(&cond4);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: broadcast failed");
+  err = pthread_cond_signal(&cond5);
+  if (err != 0)
+    error (EXIT_FAILURE, err, "parent: broadcast failed");
+
+  err = pthread_mutex_unlock (&mut1);
+  if (err != 0)
+    {
+      puts ("parent: failed to unlock");
+      return 1;
+    }
+  err = pthread_mutex_unlock (&mut2);
+  if (err != 0)
+    {
+      puts ("parent: failed to unlock");
+      return 1;
+    }
+  err = pthread_mutex_unlock (&mut3);
+  if (err != 0)
+    {
+      puts ("parent: failed to unlock");
+      return 1;
+    }
+  err = pthread_mutex_unlock (&mut4);
+  if (err != 0)
+    {
+      puts ("parent: failed to unlock");
+      return 1;
+    }
+  err = pthread_mutex_unlock (&mut5);
+  if (err != 0)
+    {
+      puts ("parent: failed to unlock");
+      return 1;
+    }
+
+  if (pthread_join (down, &ret) != 0)
+    {
+      puts ("pthread_join failed");
+      return 1;
+    }
+  count += (int) (ptrdiff_t) ret;
+
+  if (pthread_join (up, &ret) != 0)
+    {
+      puts ("pthread_join failed");
+      return 1;
+    }
+  count += (int) (ptrdiff_t) ret;
+
+  if (pthread_join (tozero, &ret) != 0)
+    {
+      puts ("pthread_join failed");
+      return 1;
+    }
+  count += (int) (ptrdiff_t) ret;
+
+  if (pthread_join (fromzero, &ret) != 0)
+    {
+      puts ("pthread_join failed");
+      return 1;
+    }
+  count += (int) (ptrdiff_t) ret;
+
+  if (pthread_join (nearest, &ret) != 0)
+    {
+      puts ("pthread_join failed");
+      return 1;
+    }
+  count += (int) (ptrdiff_t) ret;
+
+  if (count)
+    {
+#ifdef DBG
+      printf ("Total: %d fails\n", count);
+#endif
+      abort ();
+    }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-round.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-round.c
new file mode 100644
index 000000000..9833abb7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp-round.c
@@ -0,0 +1,137 @@
+/* { dg-options "-O0 -std=gnu99" } */
+/* { dg-skip-if "test is for emulation" { hard_dfp } { "*" } { "" } } */
+
+/* N1150 5.2: Conversions among decimal floating types and between
+   decimal floating types and generic floating types.
+   C99 6.3.1.5(3) New.
+
+   Perform conversions between DFP types in which the assigned value
+   cannot be represented exactly in the result and must be rounded
+   correctly according to the current rounding mode.
+
+   Normally this would not be part of compiler testing, but conversions
+   are currently handled in libgcc via decNumber.  */
+
+#include "dfp-round.h"
+
+extern void abort (void);
+static int failcnt = 0;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+
+_Decimal32 d64_to_d32 (_Decimal64 d) { return d; }
+_Decimal64 d128_to_d64 (_Decimal128 d) { return d; }
+_Decimal32 d128_to_d32 (_Decimal128 d) { return d; }
+
+int
+do_d64_to_d32 (_Decimal64 orig, _Decimal32 exp)
+{
+  d64 = orig;
+  d32 = d64_to_d32 (d64);
+  return (d32 == exp);
+}
+
+int
+do_d128_to_d32 (_Decimal128 orig, _Decimal32 exp)
+{
+  d128 = orig;
+  d32 = d128_to_d32 (d128);
+  return (d32 == exp);
+}
+
+int
+do_d128_to_d64 (_Decimal128 orig, _Decimal64 exp)
+{
+  d128 = orig;
+  d64 = d128_to_d64 (d128);
+  return (d64 == exp);
+}
+
+int
+main ()
+{
+  DFP_SETROUND (FE_DEC_DOWNWARD);
+  if (!do_d64_to_d32 (1.1111125dd, 1.111112df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111114df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111112df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111114df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111114dd)) FAILURE
+
+  DFP_SETROUND (FE_DEC_TONEAREST);
+  if (!do_d64_to_d32 (1.1111125dd, 1.111112df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111114df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111112df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111114df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111112df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111114df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111112df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111114df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111114dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111114dd)) FAILURE
+  
+  DFP_SETROUND (FE_DEC_TONEARESTFROMZERO);
+  if (!do_d64_to_d32 (1.1111125dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111114df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111114df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111114df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111114df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111114dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111114dd)) FAILURE
+  
+  DFP_SETROUND (FE_DEC_TOWARDZERO);
+  if (!do_d64_to_d32 (1.1111125dd, 1.111112df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111112df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111112df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111112df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111113dd)) FAILURE
+
+  DFP_SETROUND (FE_DEC_UPWARD);
+  if (!do_d64_to_d32 (1.1111125dd, 1.111113df)) FAILURE
+  if (!do_d64_to_d32 (1.1111135dd, 1.111114df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111125dd, -1.111112df)) FAILURE
+  if (!do_d64_to_d32 (-1.1111135dd, -1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111125dl, 1.111113df)) FAILURE
+  if (!do_d128_to_d32 (1.1111135dl, 1.111114df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111125dl, -1.111112df)) FAILURE
+  if (!do_d128_to_d32 (-1.1111135dl, -1.111113df)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111125dl, 1.111111111111113dd)) FAILURE
+  if (!do_d128_to_d64 (1.1111111111111135dl, 1.111111111111114dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111125dl, -1.111111111111112dd)) FAILURE
+  if (!do_d128_to_d64 (-1.1111111111111135dl, -1.111111111111113dd)) FAILURE
+  
+  if (failcnt)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp.c
new file mode 100644
index 000000000..148dff60e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-dfp.c
@@ -0,0 +1,108 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* N1150 5.2 Conversions among decimal floating types and between
+   decimal floating types and generic floating types.
+   C99 6.3.1.5(3) New.
+
+   Test various conversions involving decimal floating types. */
+
+#ifndef	__STDC_WANT_DEC_FP__
+#define __STDC_WANT_DEC_FP__ 1
+#endif
+
+#include <float.h>
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+volatile _Decimal32 d32;
+volatile _Decimal64 d64;
+volatile _Decimal128 d128;
+
+int
+main ()
+{
+  /* Conversions to larger types.  */
+  d32 = 123.4df;
+  d64 = d32;
+  if (d64 != 123.4dd)
+    FAILURE
+  d128 = d32;
+  if (d128 != 123.4dl)
+    FAILURE
+  d64 = 345.678dd;
+  d128 = d64;
+  if (d128 != 345.678dl)
+    FAILURE
+
+  /* Conversions to smaller types for which the value fits.  */
+  d64 = 3456.789dd;
+  d32 = d64;
+  if (d32 != 3456.789df)
+    FAILURE
+  d128 = 123.4567dl;
+  d32 = d128;
+  if (d32 != 123.4567df)
+    FAILURE
+
+  d128 = 1234567890.123456dl;
+  d64 = d128;
+  if (d64 != 1234567890.123456dd)
+    FAILURE
+
+  /* Test demotion to non-representable decimal floating type. */
+
+  /* Assumes a default rounding mode of 'near'.  This uses the rules
+     describe in the 27 July 2005 draft of IEEE 754r, which are much
+     more clear that what's described in draft 5 of N1107.  */
+
+  /* Rounds to what _Decimal32 can handle.  */
+  d64 = 9.99999949E96DD;
+  d32 = d64;
+  if (d32 != DEC32_MAX)
+    FAILURE
+
+  /* Rounds to more than _Decimal32 can handle.  */
+  d64 = 9.9999995E96DD;
+  d32 = d64;
+  if (d32 != __builtin_infd32())
+    FAILURE
+
+  /* Rounds to what _Decimal32 can handle.  */
+  d128 = 9.99999949E96DD;
+  d32 = d128;
+  if (d32 != DEC32_MAX)
+    FAILURE
+
+  /* Rounds to more than _Decimal32 can handle.  */
+  d128= 9.9999995E96DD;
+  d32 = d128;
+  if (d32 != __builtin_infd32())
+    FAILURE
+
+  /* Rounds to what _Decimal64 can handle.  */
+  d128 = 9.99999999999999949E384DL;
+  d64 = d128;
+  if (d64 != DEC64_MAX)
+    FAILURE
+
+  /* Rounds to more than _Decimal64 can handle.  */
+  d128 = 9.9999999999999995E384DL;
+  d64 = d128;
+  if (d64 != __builtin_infd64())
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-fold.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-fold.c
new file mode 100644
index 000000000..e550369be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-fold.c
@@ -0,0 +1,165 @@
+/* { dg-options "-std=gnu99 -O2" } */
+
+/* N1150 5.1 Conversion between decimal floating integer.
+   C99 6.3.1.4(1a) New.
+   These should all be folded at compile time.  */
+
+extern void link_error (void);
+
+int
+main ()
+{
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+  unsigned int ui;
+  unsigned long ul;
+  unsigned long long ull;
+  int si;
+  long sl;
+  long long sll;
+  _Bool b;
+
+  /* C99 Section 6.7.2 Type specifiers.  Type _Bool is 
+     mentioned in this section.  Conversions between 
+     _Bool and DFP types.  */
+
+  /* Decimal float to unsigned integer.  */
+  d32 = 456.789df;
+  d64 = 23.456789dd;
+  d128 = 1234.5678dl;
+
+  ui = d32;
+  if (ui != 456U)
+    link_error ();
+  ul = d32;
+  if (ul != 456UL)
+    link_error ();
+  ull = d32;
+  if (ull != 456ULL)
+    link_error ();
+
+  ui = d64;
+  if (ui != 23U)
+    link_error ();
+  ul = d64;
+  if (ul != 23UL)
+    link_error ();
+  ull = d64;
+  if (ull != 23ULL)
+    link_error ();
+
+  ui = d128;
+  if (ui != 1234U)
+    link_error ();
+  ul = d128;
+  if (ul != 1234UL)
+    link_error ();
+  ull = d128;
+  if (ull != 1234ULL)
+    link_error ();
+
+  /* Decimal float to signed integer.  */
+
+  /* Decimal float to _Bool.  */
+  d32 = 1.23df;
+  d64 = -3.4dd;
+  d128 = 0.00003dl;
+
+  b = d32;
+  if (!b)
+    link_error ();
+  b = d64;
+  if (!b)
+    link_error ();
+  b = d128;
+  if (!b)
+    link_error ();
+
+  /* Unsigned integer to decimal float.  */
+  ui = 987U;
+  ul = 345678UL;
+  ull = 1234567ULL;
+
+  d32 = ui;
+  if (d32 != 987.0df)
+    link_error ();
+  d32 = ul;
+  if (d32 != 345678.0df)
+    link_error ();
+  d32 = ull;
+  if (d32 != 1234567.df)
+    link_error ();
+
+  d64 = ui;
+  if (d64 != 987.0dd)
+    link_error ();
+  d64 = ul;
+  if (d64 != 345678.0dd)
+    link_error ();
+  d64 = ull;
+  if (d64 != 1234567.dd)
+    link_error ();
+
+  d128 = ui;
+  if (d128 != 987.0dl)
+    link_error ();
+  d128 = ul;
+  if (d128 != 345678.0dl)
+    link_error ();
+  d128 = ull;
+  if (d128 != 1234567.dl)
+    link_error ();
+
+  /* Signed integer to decimal float.  */
+  si = -987;
+  sl = -345678;
+  sll = -1234567;
+
+  d32 = si;
+  if (d32 != -987.0df)
+    link_error ();
+  d32 = sl;
+  if (d32 != -345678.0df)
+    link_error ();
+  d32 = sll;
+  if (d32 != -1234567.df)
+    link_error ();
+
+  d64 = si;
+  if (d64 != -987.0dd)
+    link_error ();
+  d64 = sl;
+  if (d64 != -345678.0dd)
+    link_error ();
+  d64 = sll;
+  if (d64 != -1234567.dd)
+    link_error ();
+
+  d128 = si;
+  if (d128 != -987.0dl)
+    link_error ();
+  d128 = sl;
+  if (d128 != -345678.0dl)
+    link_error ();
+  d128 = sll;
+  if (d128 != -1234567.dl)
+    link_error ();
+
+  /* _Bool to decimal float.  */
+  d32 = 0.0DF;
+  d64 = 0.0DD;
+  d128 = 0.0DL;
+  
+  b = d32;
+  if (b)
+    link_error ();
+  b = d64;
+  if (b)
+    link_error ();
+  b = d128;
+  if (b)
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-max-fold.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-max-fold.c
new file mode 100644
index 000000000..7e016918a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-max-fold.c
@@ -0,0 +1,146 @@
+/* { dg-options "-std=gnu99 -O2" } */
+
+/* N1150 5.1 Conversions from decimal float to integer.  */
+
+/* Test decimal float to integer conversions for values at the limit of
+   what will fit into the destination type.  This assumes 32-bit int and
+   64-bit long long (there's a check for that below).  This version tests
+   conversions during compilation.  */
+
+extern void link_error (void);
+
+void
+doit ()
+{
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+  int si;
+  unsigned int ui;
+  long long sll;
+  unsigned long long ull;
+
+  /* _Decimal32 to int.  */
+
+  d32 = 2147483.E3DF;
+  si = d32;
+  if (si != 2147483000)
+    link_error ();
+
+  d32 = -2147483.E3DF;
+  si = d32;
+  if (si != -2147483000)
+    link_error ();
+
+  /* _Decimal32 to unsigned int.  */
+
+  d32 = 4.294967E9DF;
+  ui = d32;
+  if (ui != 4294967000U)
+    link_error ();
+
+  /* _Decimal32 to long long.  */
+
+  d32 = 922.3372E16DF;
+  sll = d32;
+  if (sll != 9223372000000000000LL)
+    link_error ();
+
+  d32 = -92233.72E14DF;
+  sll = d32;
+  if (sll != -9223372000000000000LL)
+    link_error ();
+
+  /* _Decimal32 to unsigned long long.  */
+
+  d32 = 0.1844674E20DF;
+  ull = d32;
+  if (ull != 18446740000000000000ULL)
+    link_error ();
+
+  /* _Decimal64 to int.  */
+
+  d64 = 2.147483647E9DD;
+  si = d64;
+  if (si != 2147483647)
+    link_error ();
+
+  d64 = -2147483648.DD;
+  si = d64;
+  if (si != -2147483648)
+    link_error ();
+
+  /* _Decimal64 to unsigned int.  */
+
+  d64 = 42949.67295E5DD;
+  ui = d64;
+  if (ui != 4294967295)
+    link_error ();
+
+  /* _Decimal64 to long long.  */
+
+  d64 = 9.223372036854775E18DD;
+  sll = d64;
+  if (sll != 9223372036854775000LL)
+    link_error (); 
+
+  d64 = -92233720.36854775E11DD;
+  sll = d64;
+  if (sll != -9223372036854775000LL)
+    link_error ();
+
+  /* _Decimal64 to unsigned long long.  */
+  d64 = 1844674407370955.E4DD;
+  ull = d64;
+  if (ull != 18446744073709550000ULL)
+    link_error ();
+
+  /* _Decimal128 to int.  */
+
+  d128 = 2.147483647E9DL;
+  si = d128;
+  if (si != 2147483647)
+    link_error ();
+
+  d128 = -2147483648.DL;
+  si = d128;
+  if (si != -2147483648)
+    link_error ();
+
+  /* _Decimal128 to unsigned int.  */
+
+  d128 = 4294.967295E6DL;
+  ui = d128;
+  if (ui != 4294967295)
+    link_error ();
+
+  /* _Decimal128 to long long.  */
+
+  d128 = 9223372036854775807.DL;
+  sll = d128;
+  if (sll != 9223372036854775807LL)
+    link_error (); 
+
+  d128 = -9.223372036854775808E19DL;
+  sll = d128;
+  if (sll != -9223372036854775807LL - 1LL)
+    link_error ();
+
+  /* _Decimal128 to unsigned long long.  */
+  d128 = 18446744073709551615.DL;
+  ull = d128;
+  if (ull != 18446744073709551615ULL)
+    link_error ();
+}
+
+int
+main ()
+{
+  /* This test assumes 32-bit int and 64-bit long long.  */
+
+  if (sizeof (int) != 4 || sizeof (long long) != 8)
+    return 0;
+
+  doit ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-max.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-max.c
new file mode 100644
index 000000000..cb0c428a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-max.c
@@ -0,0 +1,156 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* N1150 5.1 Conversions from decimal float to integer.  */
+
+/* Test decimal float to integer conversions for values at the limit of
+   what will fit into the destination type.  This assumes 32-bit int and
+   64-bit long long (there's a check for that below).  */
+
+extern void abort (void);
+int failcnt;
+
+#ifdef DBG
+extern int printf (const char *, ...);
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+volatile _Decimal32 d32;
+volatile _Decimal64 d64;
+volatile _Decimal128 d128;
+volatile int si;
+volatile unsigned int ui;
+volatile long long sll;
+volatile unsigned long long ull;
+
+void
+doit ()
+{
+  /* _Decimal32 to int.  */
+
+  d32 = 2147483.E3DF;
+  si = d32;
+  if (si != 2147483000)
+    FAILURE
+
+  d32 = -2147483.E3DF;
+  si = d32;
+  if (si != -2147483000)
+    FAILURE
+
+  /* _Decimal32 to unsigned int.  */
+
+  d32 = 4.294967E9DF;
+  ui = d32;
+  if (ui != 4294967000U)
+    FAILURE
+
+  /* _Decimal32 to long long.  */
+
+  d32 = 922.3372E16DF;
+  sll = d32;
+  if (sll != 9223372000000000000LL)
+    FAILURE
+
+  d32 = -92233.72E14DF;
+  sll = d32;
+  if (sll != -9223372000000000000LL)
+    FAILURE
+
+  /* _Decimal32 to unsigned long long.  */
+
+  d32 = .1844674E20DF;
+  ull = d32;
+  if (ull != 18446740000000000000ULL)
+    FAILURE
+
+  /* _Decimal64 to int.  */
+
+  d64 = 2.147483647E9DD;
+  si = d64;
+  if (si != 2147483647)
+    FAILURE
+
+  d64 = -2147483648.DD;
+  si = d64;
+  if (si != -2147483648)
+    FAILURE
+
+  /* _Decimal64 to unsigned int.  */
+
+  d64 = 42949.67295E5DD;
+  ui = d64;
+  if (ui != 4294967295)
+    FAILURE
+
+  /* _Decimal64 to long long.  */
+
+  d64 = 9.223372036854775E18DD;
+  sll = d64;
+  if (sll != 9223372036854775000LL)
+    FAILURE 
+
+  d64 = -92233720.36854775E11DD;
+  sll = d64;
+  if (sll != -9223372036854775000LL)
+    FAILURE
+
+  /* _Decimal64 to unsigned long long.  */
+  d64 = 1844674407370955.E4DD;
+  ull = d64;
+  if (ull != 18446744073709550000ULL)
+    FAILURE
+
+  /* _Decimal128 to int.  */
+
+  d128 = 2.147483647E9DL;
+  si = d128;
+  if (si != 2147483647)
+    FAILURE
+
+  d128 = -2147483648.DL;
+  si = d128;
+  if (si != -2147483648)
+    FAILURE
+
+  /* _Decimal128 to unsigned int.  */
+
+  d128 = 4294.967295E6DL;
+  ui = d128;
+  if (ui != 4294967295)
+    FAILURE
+
+  /* _Decimal128 to long long.  */
+
+  d128 = 9223372036854775807.DL;
+  sll = d128;
+  if (sll != 9223372036854775807LL)
+    FAILURE 
+
+  d128 = -9.223372036854775808E19DL;
+  sll = d128;
+  if (sll != -9223372036854775807LL - 1LL)
+    FAILURE
+
+  /* _Decimal128 to unsigned long long.  */
+  d128 = 18446744073709551615.DL;
+  ull = d128;
+  if (ull != 18446744073709551615ULL)
+    FAILURE
+}
+
+int
+main ()
+{
+  /* This test assumes 32-bit int and 64-bit long long.  */
+
+  if (sizeof (int) != 4 || sizeof (long long) != 8)
+    return 0;
+
+  doit ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-saturate.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-saturate.c
new file mode 100644
index 000000000..ab4c8d268
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int-saturate.c
@@ -0,0 +1,67 @@
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 5.1 Conversion between decimal floating integer.
+   C99 6.3.1.4(1a) New.
+   Test integer saturation.  */
+
+#ifndef	__STDC_WANT_DEC_FP__
+#define __STDC_WANT_DEC_FP__ 1
+#endif
+
+#include <float.h>
+#include <limits.h>
+
+extern void abort (void);
+
+volatile _Decimal32 d32;
+volatile _Decimal64 d64;
+volatile _Decimal128 d128;
+
+volatile signed int si;
+volatile unsigned int usi;
+volatile unsigned long long udi;
+
+int
+main ()
+{
+
+  /* Unsigned.  */
+  usi = DEC32_MAX;  /* { dg-warning "overflow in implicit constant conversion" } */
+  if (usi != UINT_MAX)
+    abort ();
+
+  usi = DEC64_MAX;  /* { dg-warning "overflow in implicit constant conversion" } */
+  if (usi != UINT_MAX)
+    abort ();
+
+  usi = DEC128_MAX; /* { dg-warning "overflow in implicit constant conversion" } */
+  if (usi != UINT_MAX)
+    abort ();
+
+  /* Signed.  */
+  si = DEC32_MAX;	/* { dg-warning "overflow in implicit constant conversion" } */
+  if (si != INT_MAX)
+    abort ();
+
+  si = DEC64_MAX;   /* { dg-warning "overflow in implicit constant conversion" } */
+  if (si != INT_MAX)
+    abort ();
+
+  si = DEC128_MAX;  /* { dg-warning "overflow in implicit constant conversion" } */
+  if (si != INT_MAX)
+    abort ();
+
+  si = - DEC32_MAX; /* { dg-warning "overflow in implicit constant conversion" } */
+  if (si != INT_MIN)
+    abort ();
+
+  si = - DEC64_MAX; /* { dg-warning "overflow in implicit constant conversion" } */
+  if (si != INT_MIN)
+    abort ();
+
+  si = - DEC128_MAX; /* { dg-warning "overflow in implicit constant conversion" } */
+  if (si != INT_MIN)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int.c
new file mode 100644
index 000000000..45efe32a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert-int.c
@@ -0,0 +1,204 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* N1150 5.1 Conversion between decimal floating types and integer.
+   C99 6.3.1.4(1a) New.  */
+
+extern void abort (void);
+int failcnt;
+
+#ifdef DBG
+extern int printf (const char *, ...);
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+_Decimal32 d32;
+_Decimal64 d64;
+_Decimal128 d128;
+unsigned int ui;
+unsigned long ul;
+unsigned long long ull;
+int si;
+long sl;
+long long sll;
+_Bool b;
+
+void
+init_dfp_1 (void)
+{
+  d32 = 456.789df;
+  d64 = 23.456789dd;
+  d128 = 1234.5678dl;
+}
+void
+init_dfp_2 (void)
+{
+  d32 = 1.23df;
+  d64 = -3.4dd;
+  d128 = 0.00003dl;
+}
+
+void
+init_dfp_3 (void)
+{
+  d32 = 0.0DF;
+  d64 = 0.0DD;
+  d128 = 0.0DL;
+}
+
+void
+init_unsigned_int (void)
+{
+  ui = 987U;
+  ul = 345678UL;
+  ull = 1234567ULL;
+}
+
+void
+init_signed_int (void)
+{
+  si = -987;
+  sl = -345678;
+  sll = -1234567;
+}
+
+int
+main ()
+{
+  /* C99 Section 6.7.2 Type specifiers.  Type _Bool is 
+     mentioned in this section.  Conversions between 
+     _Bool and DFP types.  */
+
+  /* Decimal float to unsigned integer.  */
+  init_dfp_1 ();
+
+  ui = d32;
+  if (ui != 456U)
+    FAILURE
+  ul = d32;
+  if (ul != 456UL)
+    FAILURE
+  ull = d32;
+  if (ull != 456ULL)
+    FAILURE
+
+  ui = d64;
+  if (ui != 23U)
+    FAILURE
+  ul = d64;
+  if (ul != 23UL)
+    FAILURE
+  ull = d64;
+  if (ull != 23ULL)
+    FAILURE
+
+  ui = d128;
+  if (ui != 1234U)
+    FAILURE
+  ul = d128;
+  if (ul != 1234UL)
+    FAILURE
+  ull = d128;
+  if (ull != 1234ULL)
+    FAILURE
+
+  /* Decimal float to signed integer.  */
+
+  /* Decimal float to _Bool.  */
+  init_dfp_2 ();
+
+  b = d32;
+  if (!b)
+    FAILURE
+  b = d64;
+  if (!b)
+    FAILURE
+  b = d128;
+  if (!b)
+    FAILURE
+
+  /* Unsigned integer to decimal float.  */
+  init_unsigned_int ();
+
+  d32 = ui;
+  if (d32 != 987.0df)
+    FAILURE
+  d32 = ul;
+  if (d32 != 345678.0df)
+    FAILURE
+  d32 = ull;
+  if (d32 != 1234567.df)
+    FAILURE
+
+  d64 = ui;
+  if (d64 != 987.0dd)
+    FAILURE
+  d64 = ul;
+  if (d64 != 345678.0dd)
+    FAILURE
+  d64 = ull;
+  if (d64 != 1234567.dd)
+    FAILURE
+
+  d128 = ui;
+  if (d128 != 987.0dl)
+    FAILURE
+  d128 = ul;
+  if (d128 != 345678.0dl)
+    FAILURE
+  d128 = ull;
+  if (d128 != 1234567.dl)
+    FAILURE
+
+  /* Signed integer to decimal float.  */
+  init_signed_int ();
+
+  d32 = si;
+  if (d32 != -987.0df)
+    FAILURE
+  d32 = sl;
+  if (d32 != -345678.0df)
+    FAILURE
+  d32 = sll;
+  if (d32 != -1234567.df)
+    FAILURE
+
+  d64 = si;
+  if (d64 != -987.0dd)
+    FAILURE
+  d64 = sl;
+  if (d64 != -345678.0dd)
+    FAILURE
+  d64 = sll;
+  if (d64 != -1234567.dd)
+    FAILURE
+
+  d128 = si;
+  if (d128 != -987.0dl)
+    FAILURE
+  d128 = sl;
+  if (d128 != -345678.0dl)
+    FAILURE
+  d128 = sll;
+  if (d128 != -1234567.dl)
+    FAILURE
+
+  /* _Bool to decimal float.  */
+  init_dfp_3 ();
+  
+  b = d32;
+  if (b)
+    FAILURE
+  b = d64;
+  if (b)
+    FAILURE
+  b = d128;
+  if (b)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert.h
new file mode 100644
index 000000000..bc9ef42f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/convert.h
@@ -0,0 +1,461 @@
+extern void abort (void);
+static int failcnt = 0;
+
+/* Macros are set up to skip using long double, which doesn't necessarily
+   map to TF mode.  If there's a reason to skip those for a test, the
+   test itself can define USE_TF to be zero.  */
+#ifndef USE_TF
+#define USE_TF 1
+#endif
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#if defined(DBG) || defined(DBG2)
+#include <stdio.h>
+#define FAILURE(NUM) \
+  { printf ("failed for test %s\n", NUM); failcnt++; }
+#else
+#define FAILURE(N) abort ();
+#endif
+
+/* This is useful when modifying the test to make sure that tests are
+   actually run.  */
+#if defined(DBG2)
+#define REPORT(NUM) \
+  { printf ("%s\n", NUM); }
+#else
+#define REPORT(N) ;
+#endif
+
+#define CONVERT_VALID(NUM,FROM,TO,FROMVAL,TOVAL,DIFF)		\
+void								\
+convert_##NUM (void)						\
+{								\
+  REPORT(#NUM " " #FROMVAL)					\
+  FROM = FROMVAL;						\
+  TO = FROM;							\
+  if (TO < (TOVAL - DIFF) || TO > (TOVAL + DIFF))		\
+    FAILURE (#NUM);						\
+}
+
+#define CONVERT_TO_PINF(NUM,FROM,TO,FROMVAL,TOSUFFIX)		\
+void								\
+convert_##NUM (void)						\
+{								\
+  REPORT(#NUM " " #FROMVAL)					\
+  FROM = FROMVAL;						\
+  TO = FROM;							\
+  if (__builtin_isinf##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " pinf: isinf");				\
+  if (__builtin_signbit##TOSUFFIX (TO) != 0)			\
+    FAILURE (#NUM " pinf: sign");				\
+}
+
+#define CONVERT_TO_MINF(NUM,FROM,TO,FROMVAL,TOSUFFIX)		\
+void								\
+convert_##NUM (void)						\
+{								\
+  REPORT(#NUM " " #FROMVAL)					\
+  FROM = FROMVAL;						\
+  TO = FROM;							\
+  if (__builtin_isinf##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " pinf: isinf");				\
+  if (__builtin_signbit##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " pinf: sign");				\
+}
+
+#define CONVERT_TO_PZERO(NUM,FROM,TO,FROMVAL,TOVAL,TOSUFFIX)	\
+void								\
+convert_##NUM (void)						\
+{								\
+  REPORT(#NUM " " #FROMVAL)					\
+  FROM = FROMVAL;						\
+  TO = FROM;							\
+  if (TO != TOVAL)						\
+    FAILURE (#NUM "_pzero: zero")				\
+  if (__builtin_signbit##TOSUFFIX (TO) != 0)			\
+    FAILURE (#NUM " _pzero: sign");				\
+}
+
+#define CONVERT_TO_MZERO(NUM,FROM,TO,FROMVAL,TOVAL,TOSUFFIX)	\
+void								\
+convert_##NUM (void)						\
+{								\
+  REPORT(#NUM " " #FROMVAL)					\
+  FROM = FROMVAL;						\
+  TO = FROM;							\
+  if (TO != TOVAL)						\
+    FAILURE (#NUM "_mzero: zero")				\
+  if (__builtin_signbit##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " _mzero: sign");				\
+}
+
+#define CONVERT_NAN(NUM,FROM,TO,FROMSUFFIX,TOSUFFIX)		\
+void								\
+convert_##NUM##_nan (void)					\
+{								\
+  REPORT(#NUM "_nan")						\
+  FROM = __builtin_nan##FROMSUFFIX ("");			\
+  TO = FROM;							\
+  if (__builtin_isnan##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " nan");					\
+}
+
+#define CONVERT_PINF(NUM,FROM,TO,FROMSUFFIX,TOSUFFIX)		\
+void								\
+convert_##NUM##_pinf (void)					\
+{								\
+  REPORT (#NUM "_pinf")						\
+  FROM = __builtin_inf##FROMSUFFIX ();				\
+  TO = FROM;							\
+  if (__builtin_isinf##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " pinf: isinf");				\
+  if (__builtin_signbit##TOSUFFIX (TO) != 0)			\
+    FAILURE (#NUM " pinf: sign");				\
+}
+
+#define CONVERT_MINF(NUM,FROM,TO,FROMSUFFIX,TOSUFFIX)		\
+void								\
+convert_##NUM##_minf (void)					\
+{								\
+  REPORT (#NUM "_minf")						\
+  FROM = -__builtin_inf##FROMSUFFIX ();				\
+  TO = FROM;							\
+  if (__builtin_isinf##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " minf: isinf");				\
+  if (__builtin_signbit##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " minf: sign");				\
+}
+
+#define CONVERT_PZERO(NUM,FROM,TO,FROMVALUE,TOVALUE,TOSUFFIX)	\
+void								\
+convert_##NUM##_pzero (void)					\
+{								\
+  REPORT (#NUM "_pzero")					\
+  FROM = FROMVALUE;						\
+  TO = FROM;							\
+  if (TO != TOVALUE)						\
+    FAILURE (#NUM "pzero: zero")				\
+  if (__builtin_signbit##TOSUFFIX (TO) != 0)			\
+    FAILURE (#NUM " pzero: sign");				\
+}
+
+#define CONVERT_MZERO(NUM,FROM,TO,FROMVALUE,TOVALUE,TOSUFFIX)	\
+void								\
+convert_##NUM##_mzero (void)					\
+{								\
+  REPORT (#NUM "_mzero")					\
+  FROM = FROMVALUE;						\
+  TO = FROM;							\
+  if (TO != TOVALUE)						\
+    FAILURE (#NUM "mzero: zero")				\
+  if (__builtin_signbit##TOSUFFIX (TO) == 0)			\
+    FAILURE (#NUM " mzero: sign");				\
+}
+
+#define CONVERT_VALID_NOTF(NUM,VAL,DIFF)			\
+CONVERT_VALID (NUM##_sdsf, sd, sf, VAL##df, VAL##f, DIFF##f)	\
+CONVERT_VALID (NUM##_sddf, sd, df, VAL##df, VAL, DIFF)		\
+CONVERT_VALID (NUM##_ddsf, dd, sf, VAL##dd, VAL##f, DIFF##f)	\
+CONVERT_VALID (NUM##_dddf, dd, df, VAL##dd, VAL, DIFF)		\
+CONVERT_VALID (NUM##_tdsf, td, sf, VAL##dl, VAL##f, DIFF##f)	\
+CONVERT_VALID (NUM##_tddf, td, df, VAL##dl, VAL, DIFF)		\
+CONVERT_VALID (NUM##_sfsd, sf, sd, VAL##f, VAL##df, DIFF##df)	\
+CONVERT_VALID (NUM##_sfdd, sf, dd, VAL##f, VAL##dd, DIFF##dd)	\
+CONVERT_VALID (NUM##_sftd, sf, td, VAL##f, VAL##dl, DIFF##dl)	\
+CONVERT_VALID (NUM##_dfsd, df, sd, VAL, VAL##df, DIFF##df)	\
+CONVERT_VALID (NUM##_dfdd, df, dd, VAL, VAL##dd, DIFF##dd)	\
+CONVERT_VALID (NUM##_dftd, df, td, VAL, VAL##dl, DIFF##dl)	\
+CONVERT_VALID (NUM##_sddd, sd, dd, VAL##df, VAL##dd, DIFF##dd)	\
+CONVERT_VALID (NUM##_sdtd, sd, dd, VAL##df, VAL##dd, DIFF##dd)	\
+CONVERT_VALID (NUM##_ddsd, dd, sd, VAL##dd, VAL##df, DIFF##dd)	\
+CONVERT_VALID (NUM##_ddtd, dd, td, VAL##dd, VAL##dl, DIFF##dl)	\
+CONVERT_VALID (NUM##_tdsd, td, sd, VAL##dl, VAL##df, DIFF##df)	\
+CONVERT_VALID (NUM##_tddd, td, dd, VAL##dl, VAL##dd, DIFF##dd)
+
+#if USE_TF == 0
+#define CONVERT_VALID_TF(NUM,VAL,DIFF)
+#else
+#define CONVERT_VALID_TF(NUM,VAL,DIFF)				\
+CONVERT_VALID (NUM##_sdtf, sd, tf, VAL##df, VAL##l, DIFF##l)	\
+CONVERT_VALID (NUM##_tdtf, td, tf, VAL##dl, VAL##l, DIFF##l)	\
+CONVERT_VALID (NUM##_ddtf, dd, tf, VAL##dd, VAL##l, DIFF##l)	\
+CONVERT_VALID (NUM##_tfsd, tf, sd, VAL##l, VAL##df, DIFF##df)	\
+CONVERT_VALID (NUM##_tfdd, tf, dd, VAL##l, VAL##dd, DIFF##dd)	\
+CONVERT_VALID (NUM##_tftd, tf, td, VAL##l, VAL##dl, DIFF##dl)
+#endif
+
+#define CONVERT_VALID_ALL(NUM,VAL,DIFF)				\
+  CONVERT_VALID_NOTF(NUM,VAL,DIFF)				\
+  CONVERT_VALID_TF(NUM,VAL,DIFF)
+
+#define CALL_VALID_NOTF(NUM)					\
+  convert_##NUM##_sdsf ();					\
+  convert_##NUM##_sddf ();					\
+  convert_##NUM##_ddsf ();					\
+  convert_##NUM##_dddf ();					\
+  convert_##NUM##_tdsf ();					\
+  convert_##NUM##_tddf ();					\
+  convert_##NUM##_sfsd ();					\
+  convert_##NUM##_sfdd ();					\
+  convert_##NUM##_sftd ();					\
+  convert_##NUM##_dfsd ();					\
+  convert_##NUM##_dfdd ();					\
+  convert_##NUM##_dftd ();					\
+  convert_##NUM##_sddd ();					\
+  convert_##NUM##_sdtd ();					\
+  convert_##NUM##_ddsd ();					\
+  convert_##NUM##_ddtd ();					\
+  convert_##NUM##_tdsd ();					\
+  convert_##NUM##_tddd ();
+
+#if USE_TF == 0
+#define CALL_VALID_TF(NUM)
+#else
+#define CALL_VALID_TF(NUM)					\
+  convert_##NUM##_sdtf ();					\
+  convert_##NUM##_ddtf ();					\
+  convert_##NUM##_tdtf ();					\
+  convert_##NUM##_tfsd ();					\
+  convert_##NUM##_tfdd ();					\
+  convert_##NUM##_tftd ();
+#endif
+
+#define CALL_VALID_ALL(NUM)					\
+  CALL_VALID_NOTF(NUM)						\
+  CALL_VALID_TF(NUM)
+
+#define CONVERT_ZEROES(NUM,FROM,TO,FROMVALUE,TOVALUE,TOSUFFIX)	\
+CONVERT_PZERO(NUM, FROM, TO, FROMVALUE, TOVALUE, TOSUFFIX)	\
+CONVERT_MZERO(NUM, FROM, TO, -FROMVALUE, -TOVALUE, TOSUFFIX)
+
+#define CONVERT_ZEROES_NOTF(NUM)				\
+CONVERT_ZEROES (NUM##_sdsf, sd, sf, 0.0df, 0.0f, f)		\
+CONVERT_ZEROES (NUM##_sddf, sd, df, 0.0df, 0.0, )		\
+CONVERT_ZEROES (NUM##_ddsf, dd, sf, 0.0dd, 0.0f, f)		\
+CONVERT_ZEROES (NUM##_dddf, dd, df, 0.0dd, 0.0, )		\
+CONVERT_ZEROES (NUM##_tdsf, td, sf, 0.0dl, 0.0f, f)		\
+CONVERT_ZEROES (NUM##_tddf, td, df, 0.0dl, 0.0, )		\
+CONVERT_ZEROES (NUM##_sfsd, sf, sd, 0.0f, 0.0df, d32)		\
+CONVERT_ZEROES (NUM##_sfdd, sf, dd, 0.0f, 0.0dd, d64)		\
+CONVERT_ZEROES (NUM##_sftd, sf, td, 0.0f, 0.0dl, d128)		\
+CONVERT_ZEROES (NUM##_dfsd, df, sd, 0.0, 0.0df, d32)		\
+CONVERT_ZEROES (NUM##_dfdd, df, dd, 0.0, 0.0dd, d64)		\
+CONVERT_ZEROES (NUM##_dftd, df, td, 0.0, 0.0dl, d128)		\
+CONVERT_ZEROES (NUM##_sddd, sd, dd, 0.0df, 0.0dd, d64)		\
+CONVERT_ZEROES (NUM##_sdtd, sd, td, 0.0dl, 0.0dl, d128)		\
+CONVERT_ZEROES (NUM##_ddsd, dd, sd, 0.0dd, 0.0df, d32)		\
+CONVERT_ZEROES (NUM##_ddtd, dd, td, 0.0dd, 0.0dl, d128)		\
+CONVERT_ZEROES (NUM##_tdsd, td, sd, 0.0dl, 0.0df, d32)		\
+CONVERT_ZEROES (NUM##_tddd, td, dd, 0.0dl, 0.0dd, d64)
+
+#if USE_TF == 0
+#define CONVERT_ZEROES_TF(NUM)
+#else
+#define CONVERT_ZEROES_TF(NUM)					\
+CONVERT_ZEROES (NUM##_sdtf, sd, tf, 0.0df, 0.0l, l)		\
+CONVERT_ZEROES (NUM##_ddtf, dd, tf, 0.0dd, 0.0l, l)		\
+CONVERT_ZEROES (NUM##_tdtf, td, tf, 0.0dl, 0.0l, l)		\
+CONVERT_ZEROES (NUM##_tfsd, tf, sd, 0.0l, 0.0df, d32)		\
+CONVERT_ZEROES (NUM##_tfdd, tf, dd, 0.0l, 0.0dd, d64)		\
+CONVERT_ZEROES (NUM##_tftd, tf, td, 0.0l, 0.0dl, d128)
+#endif
+
+#define CONVERT_ZEROES_ALL(NUM)					\
+  CONVERT_ZEROES_NOTF(NUM)					\
+  CONVERT_ZEROES_TF(NUM)
+
+#define CALL_ZEROES(NUM)					\
+  convert_##NUM##_pzero ();					\
+  convert_##NUM##_mzero ();
+
+#define CALL_ZEROES_NOTF(NUM)					\
+  CALL_ZEROES (NUM##_sdsf)					\
+  CALL_ZEROES (NUM##_sddf)					\
+  CALL_ZEROES (NUM##_ddsf)					\
+  CALL_ZEROES (NUM##_dddf)					\
+  CALL_ZEROES (NUM##_tdsf)					\
+  CALL_ZEROES (NUM##_tddf)					\
+  CALL_ZEROES (NUM##_sfsd)					\
+  CALL_ZEROES (NUM##_sfdd)					\
+  CALL_ZEROES (NUM##_sftd)					\
+  CALL_ZEROES (NUM##_dfsd)					\
+  CALL_ZEROES (NUM##_dfdd)					\
+  CALL_ZEROES (NUM##_dftd)					\
+  CALL_ZEROES (NUM##_sddd)					\
+  CALL_ZEROES (NUM##_sdtd)					\
+  CALL_ZEROES (NUM##_ddsd)					\
+  CALL_ZEROES (NUM##_ddtd)					\
+  CALL_ZEROES (NUM##_tdsd)					\
+  CALL_ZEROES (NUM##_tddd)
+
+#if USE_TF == 0
+#define CALL_ZEROES_TF(NUM)
+#else
+#define CALL_ZEROES_TF(NUM)					\
+  CALL_ZEROES (NUM##_sdtf)					\
+  CALL_ZEROES (NUM##_ddtf)					\
+  CALL_ZEROES (NUM##_tdtf)					\
+  CALL_ZEROES (NUM##_tfsd)					\
+  CALL_ZEROES (NUM##_tfdd)					\
+  CALL_ZEROES (NUM##_tftd)
+#endif
+
+#define CALL_ZEROES_ALL(NUM)					\
+  CALL_ZEROES_NOTF(NUM)						\
+  CALL_ZEROES_TF(NUM)
+
+#define CONVERT_INF(NUM,FROM,TO,FROMSUFFIX,TOSUFFIX)		\
+CONVERT_PINF (NUM, FROM, TO, FROMSUFFIX, TOSUFFIX)		\
+CONVERT_MINF (NUM, FROM, TO, FROMSUFFIX, TOSUFFIX)
+
+#define CONVERT_INF_NOTF(NUM)					\
+CONVERT_INF (NUM##_sdsf, sd, sf, d32, f)			\
+CONVERT_INF (NUM##_sddf, sd, df, d32, )				\
+CONVERT_INF (NUM##_ddsf, dd, sf, d64, f)			\
+CONVERT_INF (NUM##_dddf, dd, df, d64, )				\
+CONVERT_INF (NUM##_tdsf, td, sf, d128, f)			\
+CONVERT_INF (NUM##_tddf, td, df, d128, )			\
+CONVERT_INF (NUM##_sfsd, sf, sd, f, d32)			\
+CONVERT_INF (NUM##_sfdd, sf, dd, f, d64)			\
+CONVERT_INF (NUM##_sftd, sf, td, f, d128)			\
+CONVERT_INF (NUM##_dfsd, df, sd, , d32)				\
+CONVERT_INF (NUM##_dfdd, df, dd, , d64)				\
+CONVERT_INF (NUM##_dftd, df, td, , d128)			\
+CONVERT_INF (NUM##_sddd, sd, dd, d32, d64)			\
+CONVERT_INF (NUM##_sdtd, sd, td, d32, d128)			\
+CONVERT_INF (NUM##_ddsd, dd, sd, d64, d32)			\
+CONVERT_INF (NUM##_ddtd, dd, td, d64, d128)			\
+CONVERT_INF (NUM##_tdsd, td, sd, d128, d32)			\
+CONVERT_INF (NUM##_tddd, td, dd, d128, d64)
+
+#if USE_TF == 0
+#define CONVERT_INF_TF(NUM)
+#else
+#define CONVERT_INF_TF(NUM)					\
+CONVERT_INF (NUM##_sdtf, sd, tf, d32, l)			\
+CONVERT_INF (NUM##_ddtf, dd, tf, d64, l)			\
+CONVERT_INF (NUM##_tdtf, td, tf, d128, l)			\
+CONVERT_INF (NUM##_tfsd, tf, sd, l, d32)			\
+CONVERT_INF (NUM##_tfdd, tf, dd, l, d64)			\
+CONVERT_INF (NUM##_tftd, tf, td, l, d128)
+#endif
+
+#define CONVERT_INF_ALL(NUM)					\
+  CONVERT_INF_NOTF(NUM)						\
+  CONVERT_INF_TF(NUM)
+
+#define CALL_INF(NUM)						\
+  convert_##NUM##_pinf ();					\
+  convert_##NUM##_minf ();
+
+#define CALL_INF_NOTF(NUM)					\
+  CALL_INF (NUM##_sdsf)						\
+  CALL_INF (NUM##_sddf)						\
+  CALL_INF (NUM##_ddsf)						\
+  CALL_INF (NUM##_dddf)						\
+  CALL_INF (NUM##_tdsf)						\
+  CALL_INF (NUM##_tddf)						\
+  CALL_INF (NUM##_sfsd)						\
+  CALL_INF (NUM##_sfdd)						\
+  CALL_INF (NUM##_sftd)						\
+  CALL_INF (NUM##_dfsd)						\
+  CALL_INF (NUM##_dfdd)						\
+  CALL_INF (NUM##_dftd)						\
+  CALL_INF (NUM##_sddd)						\
+  CALL_INF (NUM##_sdtd)						\
+  CALL_INF (NUM##_ddsd)						\
+  CALL_INF (NUM##_ddtd)						\
+  CALL_INF (NUM##_tdsd)						\
+  CALL_INF (NUM##_tddd)
+
+#if USE_TF == 0
+#define CALL_INF_TF(NUM)
+#else
+#define CALL_INF_TF(NUM)					\
+  CALL_INF (NUM##_sdtf)						\
+  CALL_INF (NUM##_ddtf)						\
+  CALL_INF (NUM##_tdtf)						\
+  CALL_INF (NUM##_tfsd)						\
+  CALL_INF (NUM##_tfdd)						\
+  CALL_INF (NUM##_tftd)
+#endif
+
+#define CALL_INF_ALL(NUM)					\
+  CALL_INF_NOTF(NUM)						\
+  CALL_INF_TF(NUM)
+
+#define CONVERT_NAN_NOTF(NUM)					\
+CONVERT_NAN (NUM##_sdsf, sd, sf, d32, f)			\
+CONVERT_NAN (NUM##_sddf, sd, df, d32, )				\
+CONVERT_NAN (NUM##_ddsf, dd, sf, d64, f)			\
+CONVERT_NAN (NUM##_dddf, dd, df, d64, )				\
+CONVERT_NAN (NUM##_tdsf, td, sf, d128, f)			\
+CONVERT_NAN (NUM##_tddf, td, df, d128, )			\
+CONVERT_NAN (NUM##_sfsd, sf, sd, f, d32)			\
+CONVERT_NAN (NUM##_sfdd, sf, dd, f, d64)			\
+CONVERT_NAN (NUM##_sftd, sf, td, f, d128)			\
+CONVERT_NAN (NUM##_dfsd, df, sd, , d32)				\
+CONVERT_NAN (NUM##_dfdd, df, dd, , d64)				\
+CONVERT_NAN (NUM##_dftd, df, td, , d128)			\
+CONVERT_NAN (NUM##_sddd, sd, dd, d32, d64)			\
+CONVERT_NAN (NUM##_sdtd, sd, td, d32, d128)			\
+CONVERT_NAN (NUM##_ddsd, dd, sd, d64, d32)			\
+CONVERT_NAN (NUM##_ddtd, dd, td, d64, d128)			\
+CONVERT_NAN (NUM##_tdsd, td, sd, d128, d32)			\
+CONVERT_NAN (NUM##_tddd, td, dd, d128, d64)
+
+#if USE_TF == 0
+#define CONVERT_NAN_TF(NUM)
+#else
+#define CONVERT_NAN_TF(NUM)					\
+CONVERT_NAN (NUM##_sdtf, sd, tf, d32, l)			\
+CONVERT_NAN (NUM##_ddtf, dd, tf, d64, l)			\
+CONVERT_NAN (NUM##_tdtf, td, tf, d128, l)			\
+CONVERT_NAN (NUM##_tfsd, tf, sd, l, d32)			\
+CONVERT_NAN (NUM##_tfdd, tf, dd, l, d64)			\
+CONVERT_NAN (NUM##_tftd, tf, td, l, d128)
+#endif
+
+#define CONVERT_NAN_ALL(NUM)					\
+  CONVERT_NAN_NOTF(NUM)						\
+  CONVERT_NAN_TF(NUM)
+
+#define CALL_NAN(NUM)						\
+  convert_##NUM##_nan ();
+
+#define CALL_NAN_NOTF(NUM)					\
+  CALL_NAN (NUM##_sdsf)						\
+  CALL_NAN (NUM##_sddf)						\
+  CALL_NAN (NUM##_ddsf)						\
+  CALL_NAN (NUM##_dddf)						\
+  CALL_NAN (NUM##_tdsf)						\
+  CALL_NAN (NUM##_tddf)						\
+  CALL_NAN (NUM##_sfsd)						\
+  CALL_NAN (NUM##_sfdd)						\
+  CALL_NAN (NUM##_sftd)						\
+  CALL_NAN (NUM##_dfsd)						\
+  CALL_NAN (NUM##_dfdd)						\
+  CALL_NAN (NUM##_dftd)						\
+  CALL_NAN (NUM##_sddd)						\
+  CALL_NAN (NUM##_sdtd)						\
+  CALL_NAN (NUM##_ddsd)						\
+  CALL_NAN (NUM##_ddtd)						\
+  CALL_NAN (NUM##_tdsd)						\
+  CALL_NAN (NUM##_tddd)
+
+#if USE_TF == 0
+#define CALL_NAN_TF(NUM)
+#else
+#define CALL_NAN_TF(NUM)					\
+  CALL_NAN (NUM##_sdtf)						\
+  CALL_NAN (NUM##_ddtf)						\
+  CALL_NAN (NUM##_tdtf)						\
+  CALL_NAN (NUM##_tfsd)						\
+  CALL_NAN (NUM##_tfdd)						\
+  CALL_NAN (NUM##_tftd)
+#endif
+
+#define CALL_NAN_ALL(NUM)					\
+  CALL_NAN_NOTF(NUM)						\
+  CALL_NAN_TF(NUM)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/ctypes.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/ctypes.c
new file mode 100644
index 000000000..6afacd517
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/ctypes.c
@@ -0,0 +1,53 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 3: Decimal floating types.
+   C99 6.7.2: Type specifiers  */
+
+/* Test for the existence of the types.  */
+_Decimal32 sd1;
+_Decimal64 dd2;
+_Decimal128 td3;
+
+#define ARRAY_SIZE      7
+
+static _Decimal32 d32[ARRAY_SIZE];
+static _Decimal64 d64[ARRAY_SIZE];
+static _Decimal128 d128[ARRAY_SIZE];
+
+extern _Decimal32 ext_d32[ARRAY_SIZE];
+extern _Decimal64 ext_d64[ARRAY_SIZE];
+extern _Decimal128 ext_d128[ARRAY_SIZE];
+
+/* Test sizes for these types.  */
+int ssize[sizeof (_Decimal32) == 4 ? 1 : -1];
+int dsize[sizeof (_Decimal64) == 8 ? 1 : -1];
+int tsize[sizeof (_Decimal128) == 16 ? 1 : -1];
+
+int salign = __alignof (_Decimal32);
+int dalign = __alignof (_Decimal64);
+int talign = __alignof (_Decimal128);
+
+/* sizeof operator applied on an array of DFP types is n times the
+   size of a single variable of this type.  */
+
+int d32_array_size [sizeof(d32) == ARRAY_SIZE * sizeof(sd1) ? 1 : -1];
+int d64_array_size [sizeof(d64) == ARRAY_SIZE * sizeof(dd2) ? 1 : -1];
+int d128_array_size [sizeof(d128) == ARRAY_SIZE * sizeof(td3)? 1 : -1];
+
+/* Likewise for extern qualified arrays.  */
+
+int ext_d32_array_size [sizeof(ext_d32) == ARRAY_SIZE * sizeof(sd1) ? 1 : -1];
+int ext_d64_array_size [sizeof(ext_d64) == ARRAY_SIZE * sizeof(dd2) ? 1 : -1];
+int ext_d128_array_size [sizeof(ext_d128) == ARRAY_SIZE * sizeof(td3)? 1 : -1];
+
+void f()
+{
+  _Decimal32 d32[ARRAY_SIZE];
+  _Decimal64 d64[ARRAY_SIZE];
+  _Decimal128 d128[ARRAY_SIZE];
+
+  int d32_array_size [sizeof(d32) == ARRAY_SIZE * sizeof(_Decimal32) ? 1 : -1];
+  int d64_array_size [sizeof(d64) == ARRAY_SIZE * sizeof(_Decimal64) ? 1 : -1];
+  int d128_array_size [sizeof(d128) == ARRAY_SIZE * sizeof(_Decimal128)? 1 : -1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/ddmode-ice.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/ddmode-ice.c
new file mode 100644
index 000000000..979dabe11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/ddmode-ice.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O1" } */
+
+/* This used to result in an ICE.  */
+
+_Decimal64 y[258][258];
+_Decimal64 dd[258][258];
+_Decimal64 ry[258][258];
+_Decimal64
+foo (void)
+{
+  int i;
+  int j;
+  int m;
+  int im;
+  int jm;
+  int ip;
+  int jp;
+  int i2m;
+  int i1p;
+  _Decimal64 a;
+  _Decimal64 b;
+  _Decimal64 c;
+  _Decimal64 qi;
+  _Decimal64 qj;
+  _Decimal64 xx;
+  _Decimal64 yx;
+  _Decimal64 xy;
+  _Decimal64 yy;
+  _Decimal64 rel;
+  _Decimal64 qxx;
+  _Decimal64 qyy;
+  _Decimal64 qxy;
+  do
+    {
+      jp = j + 1;
+      for (i = i1p; i <= i2m; i++)
+	{
+	  ip = i + 1;
+	  yx = y[ip][j] - y[im][j];
+	  yy = y[i][jp] - y[i][jm];
+	  a = 0.25dd * (xy * xy + yy * yy);
+	  b = 0.25dd * (xx * xx + yx * yx);
+	  c = 0.125dd * (xx * xy + yx * yy);
+	  qj = 0.0dd;
+	  dd[i][m] = b + a * rel + b;
+	  qxx = y[ip][j] - 2.0dd * y[i][j] + y[im][j];
+	  qyy = y[i][jp] - 2.0dd * y[i][j] + y[i][jm];
+	  qxy = y[ip][jp] - y[ip][jm] - y[im][jp] + y[im][jm];
+	  ry[i][m] = a * qxx + b * qyy - c * qxy + yx * qi + yy * qj;
+	}
+    }
+  while (1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dec-eval-method-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dec-eval-method-2.c
new file mode 100644
index 000000000..55001cc38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dec-eval-method-2.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -D__STDC_WANT_DEC_FP__" } */
+                                                                                
+/* N1107 4: Characteristics of decimal floating types <float.h>.
+   C99 5.2.4.2.2a[2] (New).
+
+   Verify that DEC_EVAL_METHOD is defined by float.h.
+   DEC_EVAL_METHOD in <float.h>.  */
+
+#ifdef DEC_EVAL_METHOD
+#error DEC_EVAL_METHOD is defined before float.h is included
+#endif
+
+#include <float.h>
+
+#ifndef DEC_EVAL_METHOD
+#error DEC_EVAL_METHOD is not defined after float.h is included
+#endif
+
+int i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dec-eval-method.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dec-eval-method.c
new file mode 100644
index 000000000..070a4033e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dec-eval-method.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+                                                                                
+/* N1107 4: Characteristics of decimal floating types <float.h>.
+   C99 5.2.4.2.2a[2] (New).
+
+   Verify that __DEC_EVAL_METHOD__ is defined; it will be used to define
+   DEC_EVAL_METHOD in <float.h>.  */
+
+int i;
+#ifndef __DEC_EVAL_METHOD__
+#error __DEC_EVAL_METHOD__ is not defined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/decfloat-constants.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/decfloat-constants.c
new file mode 100644
index 000000000..ec9d38167
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/decfloat-constants.c
@@ -0,0 +1,63 @@
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 4: Characteristics of decimal floating types <float.h>.
+   C99 5.2.4.2.2a[3]: New.
+
+   Verify constants about range of decimal float and three components of
+   decimal float defined in float.h.  */
+
+/* Make sure we are exporting the right values to float.h. */
+#ifndef	__STDC_WANT_DEC_FP__
+#define __STDC_WANT_DEC_FP__ 1
+#endif
+
+#include <float.h>
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+int main ()
+{
+  if (DEC32_MANT_DIG != 7) FAILURE
+  if (DEC64_MANT_DIG != 16) FAILURE
+  if (DEC128_MANT_DIG != 34) FAILURE
+
+  if (DEC32_MIN_EXP != -94) FAILURE
+  if (DEC64_MIN_EXP != -382) FAILURE
+  if (DEC128_MIN_EXP != -6142) FAILURE
+
+  if (DEC32_MAX_EXP != 97) FAILURE
+  if (DEC64_MAX_EXP != 385) FAILURE
+  if (DEC128_MAX_EXP != 6145) FAILURE
+
+  if (DEC32_MAX != 9.999999E96DF) FAILURE
+  if (DEC64_MAX != 9.999999999999999E384DD) FAILURE
+  if (DEC128_MAX != 9.999999999999999999999999999999999E6144DL) FAILURE
+
+  if (DEC32_EPSILON != 1E-6DF) FAILURE
+  if (DEC64_EPSILON != 1E-15DD) FAILURE
+  if (DEC128_EPSILON != 1E-33DL) FAILURE
+  
+  if (DEC32_MIN != 1E-95DF) FAILURE
+  if (DEC64_MIN != 1E-383DD) FAILURE
+  if (DEC128_MIN != 1E-6143DL) FAILURE
+
+  if (DEC32_SUBNORMAL_MIN != 0.000001E-95DF) FAILURE
+  if (DEC64_SUBNORMAL_MIN != 0.000000000000001E-383DD) FAILURE
+  if (DEC128_SUBNORMAL_MIN != 0.000000000000000000000000000000001E-6143DL)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp-except.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp-except.h
new file mode 100644
index 000000000..3ef97ff6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp-except.h
@@ -0,0 +1,13 @@
+/* Use undocumented functions in libgcc to clear and test dummy floating
+   point exception flags.  That functionality is in libgcc just for
+   testing purposes.
+
+   If fesetexcept and feclearexcept are available, use those instead.  */
+
+/* Get names of exception flags.  */
+#include <fenv.h>
+
+extern void __dfp_clear_except (int);
+#define DFP_CLEAR_EXCEPT(M) __dfp_clear_except(M)
+extern int __dfp_test_except (int);
+#define DFP_TEST_EXCEPT(M) __dfp_test_except(M)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp-round.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp-round.h
new file mode 100644
index 000000000..fc7fd5c23
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp-round.h
@@ -0,0 +1,22 @@
+/* This is very temporary; right now it gets functions in libgcc that
+   pass on the rounding mode to decNumber, but later it can be replaced
+   with Official Stuff.  */
+
+#ifdef __DECIMAL_BID_FORMAT__
+#define FE_DEC_TONEAREST 0
+#define FE_DEC_DOWNWARD 1
+#define FE_DEC_UPWARD 2
+#define FE_DEC_TOWARDZERO 3
+#define FE_DEC_TONEARESTFROMZERO 4
+#else
+#define FE_DEC_DOWNWARD 0
+#define FE_DEC_TONEAREST 1
+#define FE_DEC_TONEARESTFROMZERO 2
+#define FE_DEC_TOWARDZERO 3
+#define FE_DEC_UPWARD 4
+#endif
+
+extern void __dfp_set_round (int);
+#define DFP_SETROUND(M) __dfp_set_round(M)
+extern int __dfp_get_round (void);
+#define DFP_GETROUND __dfp_get_round()
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp.exp
new file mode 100644
index 000000000..090194fe6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/dfp.exp
@@ -0,0 +1,61 @@
+# Copyright (C) 2005, 2006, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Skip these tests for targets that don't support this extension.
+if { ![check_effective_target_dfp] } {
+    return;
+}
+
+# If the decimal float is supported in the compiler but not yet in the
+# runtime, treat all tests as compile-only.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+if { ![check_effective_target_dfprt] } {
+    verbose "dfp.exp: runtime support for decimal float does not exist" 2
+    set dg-do-what-default compile
+} else {
+    verbose "dfp.exp: runtime support for decimal float exists, use it" 2
+    set dg-do-what-default run
+}
+verbose "dfp.exp: dg-do-what-default is ${dg-do-what-default}" 2
+
+# 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; run the C-only tests.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] \
+        "" $DEFAULT_CFLAGS
+
+# Run the tests that are shared with C++ testing.
+dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/dfp/*c]] \
+        "" $DEFAULT_CFLAGS
+
+# All done.
+dg-finish
+
+set dg-do-what-default ${save-dg-do-what-default}
+verbose "dfp.exp: dg-do-what-default is ${dg-do-what-default}" 2
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-binop.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-binop.c
new file mode 100644
index 000000000..23f137818
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-binop.c
@@ -0,0 +1,108 @@
+/* { dg-options "-std=gnu99" } */
+/* { dg-skip-if "test is for emulation" { hard_dfp } { "*" } { "" } } */
+
+/* Touch tests that check for raising appropriate exceptions for binary
+   arithmetic operations on decimal float values.  */
+
+#include "fe-check.h"
+
+volatile _Decimal32 a32, b32, c32;
+volatile _Decimal64 a64, b64, c64;
+volatile _Decimal128 a128, b128, c128;
+_Decimal32 inf32;
+_Decimal64 inf64;
+_Decimal128 inf128;
+
+BINOP (100, /, a32, 2.0df, b32, 0.df, c32, FE_DIVBYZERO)
+BINOP (101, /, a64, 2.0dd, b64, 0.dd, c64, FE_DIVBYZERO)
+BINOP (102, /, a128, 2.0dl, b128, 0.dl, c128, FE_DIVBYZERO)
+
+BINOP (200, /, a32, 0.df, b32, 0.df, c32, FE_INVALID)
+BINOP (201, /, a64, 0.dd, b64, 0.dd, c64, FE_INVALID)
+BINOP (202, /, a128, 0.dl, b128, 0.dl, c128, FE_INVALID)
+BINOP (203, /, a32, inf32, b32, inf32, c32, FE_INVALID)
+BINOP (204, /, a64, inf64, b64, inf64, c64, FE_INVALID)
+BINOP (205, /, a128, inf128, b128, inf128, c128, FE_INVALID)
+BINOP (206, *, a32, 0.df, b32, __builtin_infd32(), c32, FE_INVALID)
+BINOP (207, *, a32, __builtin_infd32(), b32, 0.df, c32, FE_INVALID)
+BINOP (208, *, a64, 0.df, b64, __builtin_infd64(), c64, FE_INVALID)
+BINOP (209, *, a64, __builtin_infd64(), b64, 0.df, c64, FE_INVALID)
+BINOP (210, *, a128, 0.df, b128, __builtin_infd128(), c128, FE_INVALID)
+BINOP (211, *, a128, __builtin_infd128(), b128, 0.df, c128, FE_INVALID)
+BINOP (212, +, a32, inf32, b32, -inf32, c32, FE_INVALID)
+BINOP (213, +, a64, inf64, b64, -inf64, c64, FE_INVALID)
+BINOP (214, +, a128, inf128, b128, -inf128, c128, FE_INVALID)
+BINOP (215, -, a32, inf32, b32, inf32, c32, FE_INVALID)
+BINOP (216, -, a64, inf64, b64, inf64, c64, FE_INVALID)
+BINOP (217, -, a128, inf128, b128, inf128, c128, FE_INVALID)
+
+BINOP (300, /, a32, 9.9e94df, b32, 1.e-3df, c32, FE_OVERFLOW|FE_INEXACT)
+BINOP (301, /, a64, 9.9e382dd, b64, 1.e-3dd, c64, FE_OVERFLOW|FE_INEXACT)
+BINOP (302, /, a128, 9.9e6142dl, b128, 1.e-3dl, c128, FE_OVERFLOW|FE_INEXACT)
+BINOP (303, +, a32, 9.9e96df, b32, 1.e96df, c32, FE_OVERFLOW|FE_INEXACT)
+BINOP (304, +, a64, 9.9e384dd, b64, 1.e384dd, c64, FE_OVERFLOW|FE_INEXACT)
+BINOP (305, +, a128, 9.9e6144dl, b128, 1.e6144dl, c128, FE_OVERFLOW|FE_INEXACT)
+
+BINOP (400, /, a32, 1.e-3df, b32, 9.9e94df, c32, FE_UNDERFLOW|FE_INEXACT)
+BINOP (401, /, a64, 1.e-3dd, b64, 9.9e382dd, c64, FE_UNDERFLOW|FE_INEXACT)
+BINOP (402, /, a128, 1.e-3dl, b128, 9.9e6142dl, c128, FE_UNDERFLOW|FE_INEXACT)
+BINOP (403, *, a32, 1.e-95df, b32, 1.e-7df, c32, FE_UNDERFLOW|FE_INEXACT)
+BINOP (404, *, a64, 1.e-383dd, b64, 1.e-16dd, c64, FE_UNDERFLOW|FE_INEXACT)
+BINOP (405, *, a128, 1.e-6143dl, b128, 1.e-34dl, c128, FE_UNDERFLOW|FE_INEXACT)
+
+BINOP (500, /, a32, 1.df, b32, 3.df, c32, FE_INEXACT)
+BINOP (501, /, a64, 1.dd, b64, 3.dd, c64, FE_INEXACT)
+BINOP (502, /, a128, 1.dl, b128, 3.dl, c128, FE_INEXACT)
+
+int
+main ()
+{
+  inf32 = __builtin_infd32();
+  inf64 = __builtin_infd64();
+  inf128 = __builtin_infd128();
+
+  binop_100 ();
+  binop_101 ();
+  binop_102 ();
+
+  binop_200 ();
+  binop_201 ();
+  binop_202 ();
+  binop_203 ();
+  binop_204 ();
+  binop_205 ();
+  binop_206 ();
+  binop_207 ();
+  binop_208 ();
+  binop_209 ();
+  binop_210 ();
+  binop_211 ();
+  binop_212 ();
+  binop_213 ();
+  binop_214 ();
+  binop_215 ();
+  binop_216 ();
+  binop_217 ();
+
+  binop_300 ();
+  binop_301 ();
+  binop_302 ();
+  binop_303 ();
+  binop_304 ();
+  binop_305 ();
+
+  binop_400 ();
+  binop_401 ();
+  binop_402 ();
+  binop_403 ();
+  binop_404 ();
+  binop_405 ();
+
+  binop_500 ();
+  binop_501 ();
+  binop_502 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-check.h
new file mode 100644
index 000000000..0e072aa9f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-check.h
@@ -0,0 +1,70 @@
+/* Common support for checking that appropriate floating point exceptions
+   are raised for decimal float operations.  These tests are here to test
+   the software decimal float support in libgcc.  */
+
+#include "dfp-except.h"
+
+extern void abort (void);
+static int failcnt = 0;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#if defined(DBG) || defined(DBG2)
+#include <stdio.h>
+#define FAILURE(NUM,KIND,EXCEPT) \
+  { printf ("failed for test %d: %s %s\n", NUM, KIND, EXCEPT); failcnt++; }
+#else
+#define FAILURE(N,K,E) abort ();
+#endif
+
+/* This is useful when modifying the test to make sure that tests are
+   actually run.  */
+#if defined(DBG2)
+#define SUCCESS(NUM,EXCEPT) \
+  { printf ("passed for test %d: %s\n", NUM, EXCEPT); }
+#else
+#define SUCCESS(N,E) ;
+#endif
+
+#define CHECKFLAG(NUM,EXCEPT,GOT,WANT)				\
+  if ((WANT & EXCEPT) != (GOT & EXCEPT))			\
+    {								\
+      if ((WANT & EXCEPT) != 0)					\
+        FAILURE (NUM, "missing", #EXCEPT)			\
+      else							\
+        FAILURE (NUM, "unexpected", #EXCEPT)			\
+    }								\
+  else								\
+    SUCCESS (NUM, #EXCEPT)
+
+void
+checkflags (int num, int want)
+{
+  int got = DFP_TEST_EXCEPT (FE_ALL_EXCEPT);
+  CHECKFLAG (num, FE_INVALID, got, want)
+  CHECKFLAG (num, FE_OVERFLOW, got, want)
+  CHECKFLAG (num, FE_UNDERFLOW, got, want)
+  CHECKFLAG (num, FE_DIVBYZERO, got, want)
+  CHECKFLAG (num, FE_INEXACT, got, want)
+}
+
+#define BINOP(NUM,OP,VAR1,VAL1,VAR2,VAL2,VAR3,EXCEPT)		\
+void								\
+binop_##NUM (void)						\
+{								\
+  VAR1 = VAL1;							\
+  VAR2 = VAL2;							\
+  DFP_CLEAR_EXCEPT (FE_ALL_EXCEPT);				\
+  VAR3 = VAR1 OP VAR2;						\
+  checkflags (NUM, EXCEPT);					\
+}
+
+#define CONVERT(NUM,FROM,TO,VALUE,EXCEPT)			\
+void								\
+convert_##NUM (void)						\
+{								\
+  FROM = VALUE;							\
+  DFP_CLEAR_EXCEPT (FE_ALL_EXCEPT);				\
+  TO = FROM;							\
+  checkflags (NUM, EXCEPT);					\
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-1.c
new file mode 100644
index 000000000..f65cf7870
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-1.c
@@ -0,0 +1,43 @@
+/* { dg-options "-std=gnu99" } */
+/* { dg-skip-if "test is for emulation" { hard_dfp } { "*" } { "" } } */
+
+/* Check that appropriate exceptions are raised for conversions involving
+   decimal float values.  */
+
+#include "fe-check.h"
+
+volatile _Decimal32 d32;
+volatile _Decimal64 d64;
+volatile _Decimal128 d128;
+
+/* Conversions between decimal float types should raise an invalid
+   exception if the value doesn't fit, either because the value
+   is too large or the result can't hold the full precision.  */
+
+CONVERT (100, d64, d32, 9.999999e96DD, 0)
+CONVERT (101, d64, d32, 10.000000e96DD, FE_INEXACT|FE_OVERFLOW)
+CONVERT (102, d64, d32, 1.1111111DD, FE_INEXACT)
+CONVERT (110, d128, d32, 9.999999e96DL, 0)
+CONVERT (111, d128, d32, 10.000000e96DL, FE_INEXACT|FE_OVERFLOW)
+CONVERT (112, d128, d32, 1.1111111DL, FE_INEXACT)
+CONVERT (120, d128, d64, 9.999999999999999E384DL, 0)
+CONVERT (121, d128, d64, 10.00000000000000E384DL, FE_INEXACT|FE_OVERFLOW)
+CONVERT (122, d128, d64, 1.1111111111111111DL, FE_INEXACT)
+
+int
+main ()
+{
+  convert_100 ();
+  convert_101 ();
+  convert_102 ();
+  convert_110 ();
+  convert_111 ();
+  convert_112 ();
+  convert_120 ();
+  convert_121 ();
+  convert_122 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-2.c
new file mode 100644
index 000000000..83b490d54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-2.c
@@ -0,0 +1,35 @@
+/* { dg-options "-std=gnu99" } */
+
+/* Check that appropriate exceptions are raised for BFP to DFP conversions.
+   The test only uses double and _Decimal32; tests for conversions to
+   _Decimal64 would need 128-bit long double.  */
+
+#include "fe-check.h"
+
+volatile _Decimal32 d32;
+volatile double d;
+
+CONVERT (100, d, d32, 1.0e96, FE_INEXACT)
+CONVERT (101, d, d32, 1.0e97, FE_OVERFLOW|FE_INEXACT) 
+CONVERT (102, d, d32, -1.0e96, FE_INEXACT)
+CONVERT (103, d, d32, -1.0e97, FE_OVERFLOW|FE_INEXACT) 
+
+/* FIXME: These only result in fp exceptions when libbid is used.
+   libdecnumber doesn't work correctly.  */
+CONVERT (104, d, d32, 1.0e-96, FE_UNDERFLOW|FE_INEXACT)
+CONVERT (105, d, d32, 0.00048828125, FE_INEXACT)  /* exact power of 2 */
+
+int
+main ()
+{
+  convert_100 ();
+  convert_101 ();
+  convert_102 ();
+  convert_103 ();
+  convert_104 ();
+  convert_105 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-3.c
new file mode 100644
index 000000000..e3fe30eeb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/fe-convert-3.c
@@ -0,0 +1,49 @@
+/* { dg-options "-std=gnu99" } */
+
+/* Check that appropriate exceptions are raised for int to DFP conversions.  */
+
+#include "fe-check.h"
+
+volatile _Decimal32 d32;
+volatile _Decimal64 d64;
+volatile signed int si;
+volatile unsigned int ui;
+volatile signed long long sll;
+volatile unsigned long long ull;
+
+CONVERT (100, si, d32, 9999999, 0)
+CONVERT (101, si, d32, 11111111, FE_INEXACT)
+CONVERT (102, si, d32, -9999999, 0)
+CONVERT (103, si, d32, -10000001, FE_INEXACT)
+CONVERT (110, ui, d32, 9999999, 0)
+CONVERT (111, ui, d32, 10000001, FE_INEXACT)
+CONVERT (200, sll, d64, 9999999999999999, 0)
+CONVERT (201, sll, d64, 10000000000000001, FE_INEXACT)
+CONVERT (202, sll, d64, -9999999999999999, 0)
+CONVERT (203, sll, d64, -10000000000000001, FE_INEXACT)
+CONVERT (210, ull, d64, 9999999999999999, 0)
+CONVERT (211, ull, d64, 10000000000000001, FE_INEXACT)
+
+int
+main ()
+{
+  if (sizeof (long long) != 16)
+    return 0;
+
+  convert_100 ();
+  convert_101 ();
+  convert_102 ();
+  convert_103 ();
+  convert_110 ();
+  convert_111 ();
+  convert_200 ();
+  convert_201 ();
+  convert_202 ();
+  convert_203 ();
+  convert_210 ();
+  convert_211 ();
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-array.c
new file mode 100644
index 000000000..93713486b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-array.c
@@ -0,0 +1,172 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing array elements involving decimal floating point types. */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* A handful of functions that return the Nth _Decimal32 argument of
+   an incoming array.  */
+
+_Decimal32
+arg0_32 (_Decimal32 args[])
+{
+  return args[0];
+}
+
+_Decimal32
+arg1_32 (_Decimal32 args[])
+{
+  return args[1];
+}
+
+_Decimal32
+arg2_32 (_Decimal32 args[])
+{
+  return args[2];
+}
+
+_Decimal32
+arg3_32 (_Decimal32 args[])
+{
+  return args[3];
+}
+
+_Decimal32
+arg4_32 (_Decimal32 args[])
+{
+  return args[4];
+}
+
+_Decimal32
+arg5_32 (_Decimal32 args[])
+{
+  return args[5];
+}
+	
+
+/* A handful of functions that return the Nth _Decimal64 argument of
+   an incoming array.  */
+
+_Decimal64
+arg0_64 (_Decimal64 args[])
+{
+  return args[0];
+}
+
+_Decimal64
+arg1_64 (_Decimal64 args[])
+{
+  return args[1];
+}
+
+_Decimal64
+arg2_64 (_Decimal64 args[])
+{
+  return args[2];
+}
+
+_Decimal64
+arg3_64 (_Decimal64 args[])
+{
+  return args[3];
+}
+
+_Decimal64
+arg4_64 (_Decimal64 args[])
+{
+  return args[4];
+}
+
+_Decimal64
+arg5_64 (_Decimal64 args[])
+{
+  return args[5];
+}
+
+
+/* A handful of functions that return the Nth _Decimal128 argument of
+   an incoming array.  */
+
+_Decimal128
+arg0_128 (_Decimal128 args[])
+{
+  return args[0];
+}
+
+_Decimal128
+arg1_128 (_Decimal128 args[])
+{
+  return args[1];
+}
+
+_Decimal128
+arg2_128 (_Decimal128 args[])
+{
+  return args[2];
+}
+
+_Decimal128
+arg3_128 (_Decimal128 args[])
+{
+  return args[3];
+}
+
+_Decimal128
+arg4_128 (_Decimal128 args[])
+{
+  return args[4];
+}
+
+_Decimal128
+arg5_128 (_Decimal128 args[])
+{
+  return args[5];
+}
+
+
+int main()
+{
+  _Decimal32 d32[] = { 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df };
+  _Decimal64 d64[] = { 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd };
+  _Decimal128 d128[] = { 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl };
+
+  /* _Decimal32 variants.  */
+  if (arg0_32 (d32) != 0.0df) FAILURE
+  if (arg1_32 (d32) != 1.0df) FAILURE
+  if (arg2_32 (d32) != 2.0df) FAILURE
+  if (arg3_32 (d32) != 3.0df) FAILURE
+  if (arg4_32 (d32) != 4.0df) FAILURE
+  if (arg5_32 (d32) != 5.0df) FAILURE
+
+  /* _Decimal64 variants.  */
+  if (arg0_64 (d64) != 0.0dd) FAILURE
+  if (arg1_64 (d64) != 1.0dd) FAILURE
+  if (arg2_64 (d64) != 2.0dd) FAILURE
+  if (arg3_64 (d64) != 3.0dd) FAILURE
+  if (arg4_64 (d64) != 4.0dd) FAILURE
+  if (arg5_64 (d64) != 5.0dd) FAILURE
+
+  /* _Decimal128 variants.  */
+  if (arg0_128 (d128) != 0.0dl) FAILURE
+  if (arg1_128 (d128) != 1.0dl) FAILURE
+  if (arg2_128 (d128) != 2.0dl) FAILURE
+  if (arg3_128 (d128) != 3.0dl) FAILURE
+  if (arg4_128 (d128) != 4.0dl) FAILURE
+  if (arg5_128 (d128) != 5.0dl) FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-deref.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-deref.c
new file mode 100644
index 000000000..d16e70d29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-deref.c
@@ -0,0 +1,220 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test scalar passing and return values involving decimal floating
+   point types and dereferenced pointers.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* A handful of functions that return their Nth _Decimal32
+   argument.  */
+
+_Decimal32 __attribute__((noinline))
+arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg0;
+}
+
+_Decimal32 __attribute__((noinline))
+arg1_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg1;
+}
+	
+_Decimal32 __attribute__((noinline))
+arg2_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg2;
+}
+	
+_Decimal32 __attribute__((noinline))
+arg3_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg3;
+}
+	
+_Decimal32 __attribute__((noinline))
+arg4_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg4;
+}
+	
+_Decimal32 __attribute__((noinline))
+arg5_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg5;
+}
+	
+
+/* A handful of functions that return their Nth _Decimal64
+   argument.  */
+
+_Decimal64 __attribute__((noinline))
+arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg0;
+}
+	
+_Decimal64 __attribute__((noinline))
+arg1_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg1;
+}
+	
+_Decimal64 __attribute__((noinline))
+arg2_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg2;
+}
+	
+_Decimal64 __attribute__((noinline))
+arg3_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg3;
+}
+	
+_Decimal64 __attribute__((noinline))
+arg4_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg4;
+}
+	
+_Decimal64 __attribute__((noinline))
+arg5_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg5;
+}
+	
+
+/* A handful of functions that return their Nth _Decimal128
+   argument.  */
+
+_Decimal128 __attribute__((noinline))
+arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg0;
+}
+	
+_Decimal128 __attribute__((noinline))
+arg1_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg1;
+}
+	
+_Decimal128 __attribute__((noinline))
+arg2_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg2;
+}
+	
+_Decimal128 __attribute__((noinline))
+arg3_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg3;
+}
+	
+_Decimal128 __attribute__((noinline))
+arg4_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg4;
+}
+	
+_Decimal128 __attribute__((noinline))
+arg5_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg5;
+}
+
+
+
+_Decimal32 df0 = 0.0df, df1 = 1.0df, df2 = 2.0df,
+	   df3 = 3.0df, df4 = 4.0df, df5 = 5.0df;
+_Decimal32 *pdf0 = &df0, *pdf1 = &df1, *pdf2 = &df2,
+	   *pdf3 = &df3, *pdf4 = &df4, *pdf5 = &df5;
+_Decimal64 dd0 = 0.0dd, dd1 = 1.0dd, dd2 = 2.0dd,
+	   dd3 = 3.0dd, dd4 = 4.0dd, dd5 = 5.0dd;
+_Decimal64 *pdd0 = &dd0, *pdd1 = &dd1, *pdd2 = &dd2,
+	   *pdd3 = &dd3, *pdd4 = &dd4, *pdd5 = &dd5;
+_Decimal128 dl0 = 0.0dl, dl1 = 1.0dl, dl2 = 2.0dl,
+	    dl3 = 3.0dl, dl4 = 4.0dl, dl5 = 5.0dl;
+_Decimal128 *pdl0 = &dl0, *pdl1 = &dl1, *pdl2 = &dl2,
+	    *pdl3 = &dl3, *pdl4 = &dl4, *pdl5 = &dl5;
+
+int
+main ()
+{
+  /* _Decimal32 variants.  */
+  if (arg0_32 (*pdf0, *pdf1, *pdf2, *pdf3, *pdf4, *pdf5) != 0.0df)
+    FAILURE
+  if (arg1_32 (*pdf0, *pdf1, *pdf2, *pdf3, *pdf4, *pdf5) != 1.0df)
+    FAILURE
+  if (arg2_32 (*pdf0, *pdf1, *pdf2, *pdf3, *pdf4, *pdf5) != 2.0df)
+    FAILURE
+  if (arg3_32 (*pdf0, *pdf1, *pdf2, *pdf3, *pdf4, *pdf5) != 3.0df)
+    FAILURE
+  if (arg4_32 (*pdf0, *pdf1, *pdf2, *pdf3, *pdf4, *pdf5) != 4.0df)
+    FAILURE
+  if (arg5_32 (*pdf0, *pdf1, *pdf2, *pdf3, *pdf4, *pdf5) != 5.0df)
+    FAILURE
+
+  /* _Decimal64 variants.  */
+  if (arg0_64 (*pdd0, *pdd1, *pdd2, *pdd3, *pdd4, *pdd5) != 0.0dd)
+    FAILURE
+  if (arg1_64 (*pdd0, *pdd1, *pdd2, *pdd3, *pdd4, *pdd5) != 1.0dd)
+    FAILURE
+  if (arg2_64 (*pdd0, *pdd1, *pdd2, *pdd3, *pdd4, *pdd5) != 2.0dd)
+    FAILURE
+  if (arg3_64 (*pdd0, *pdd1, *pdd2, *pdd3, *pdd4, *pdd5) != 3.0dd)
+    FAILURE
+  if (arg4_64 (*pdd0, *pdd1, *pdd2, *pdd3, *pdd4, *pdd5) != 4.0dd)
+    FAILURE
+  if (arg5_64 (*pdd0, *pdd1, *pdd2, *pdd3, *pdd4, *pdd5) != 5.0dd)
+    FAILURE
+
+  /* _Decimal128 variants.  */
+  if (arg0_128 (*pdl0, *pdl1, *pdl2, *pdl3, *pdl4, *pdl5) != 0.0dl)
+    FAILURE
+  if (arg1_128 (*pdl0, *pdl1, *pdl2, *pdl3, *pdl4, *pdl5) != 1.0dl)
+    FAILURE
+  if (arg2_128 (*pdl0, *pdl1, *pdl2, *pdl3, *pdl4, *pdl5) != 2.0dl)
+    FAILURE
+  if (arg3_128 (*pdl0, *pdl1, *pdl2, *pdl3, *pdl4, *pdl5) != 3.0dl)
+    FAILURE
+  if (arg4_128 (*pdl0, *pdl1, *pdl2, *pdl3, *pdl4, *pdl5) != 4.0dl)
+    FAILURE
+  if (arg5_128 (*pdl0, *pdl1, *pdl2, *pdl3, *pdl4, *pdl5) != 5.0dl)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-mixed.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-mixed.c
new file mode 100644
index 000000000..620d342e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-mixed.c
@@ -0,0 +1,187 @@
+/* { dg-options "-std=gnu99 -Wall" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test scalar passing and return values involving decimal floating
+   point types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* A handful of functions that return their Nth _Decimal32
+   argument with mixed types in parameter list.  */
+
+_Decimal32
+arg0_32 (_Decimal32 arg0, int arg1, unsigned int arg2,
+       float arg3, double  arg4, long double arg5)
+{
+  return arg0;
+}
+
+_Decimal32
+arg1_32 (int arg0, _Decimal32 arg1, unsigned int arg2,
+       float arg3, double arg4, long double arg5)
+{
+  return arg1;
+}
+
+_Decimal32
+arg2_32 (int arg0, unsigned int arg1, _Decimal32 arg2,
+       float arg3, double arg4, long double arg5)
+{
+  return arg2;
+}
+
+
+_Decimal32
+arg3_32 (int arg0, unsigned int arg1, float arg2,
+       _Decimal32 arg3, double arg4, long double arg5)
+{
+  return arg3;
+}
+
+_Decimal32
+arg4_32 (int arg0, unsigned int arg1, float arg2,
+       double arg3, _Decimal32 arg4, long double arg5)
+{
+  return arg4;
+}
+
+_Decimal32
+arg5_32 (int arg0, unsigned int arg1, float arg2,
+       double arg3, long double arg4, _Decimal32 arg5)
+{
+  return arg5;
+}
+
+/* A handful of functions that return their Nth _Decimal64
+   argument with mixed types in parameter list.  */
+
+_Decimal64
+arg0_64 (_Decimal64 arg0, int arg1, unsigned int arg2,
+         float arg3, double  arg4, long double arg5)
+{
+  return arg0;
+}
+
+_Decimal64
+arg1_64 (int arg0, _Decimal64 arg1, unsigned int arg2,
+         float arg3, double arg4, long double arg5)
+{
+  return arg1;
+}
+
+_Decimal64
+arg2_64 (int arg0, unsigned int arg1, _Decimal64 arg2,
+         float arg3, double arg4, long double arg5)
+{
+  return arg2;
+}
+
+_Decimal64
+arg3_64 (int arg0, unsigned int arg1, float arg2,
+         _Decimal64 arg3, double arg4, long double arg5)
+{
+  return arg3;
+}
+
+_Decimal64
+arg4_64 (int arg0, unsigned int arg1, float arg2,
+         float arg3, _Decimal64 arg4, long double arg5)
+{
+  return arg4;
+}
+
+_Decimal64
+arg5_64 (int arg0, unsigned int arg1, float arg2,
+         double arg3, long double arg4, _Decimal64 arg5)
+{
+  return arg5;
+}
+
+/* A handful of functions that return their Nth _Decimal128
+   argument with mixed types in parameter list.  */
+
+_Decimal128
+arg0_128 (_Decimal128 arg0, int arg1, unsigned int arg2,
+         float arg3, double  arg4, long double arg5)
+{
+  return arg0;
+}
+_Decimal128
+arg1_128 (int arg0, _Decimal128 arg1, unsigned int arg2,
+         float arg3, double arg4, long double arg5)
+{
+  return arg1;
+}
+
+_Decimal128
+arg2_128 (int arg0, unsigned int arg1, _Decimal128 arg2,
+         float arg3, double arg4, long double arg5)
+{
+  return arg2;
+}
+
+_Decimal128
+arg3_128 (int arg0, unsigned int arg1, float arg2,
+         _Decimal128 arg3, double arg4, long double arg5)
+{
+  return arg3;
+}
+
+_Decimal128
+arg4_128 (int arg0, unsigned int arg1, float arg2,
+         float arg3, _Decimal32 arg4, long double arg5)
+{
+  return arg4;
+}
+
+_Decimal128
+arg5_128 (int arg0, unsigned int arg1, float arg2,
+         double arg3, long double arg4, _Decimal128 arg5)
+{
+  return arg5;
+}
+
+
+
+int
+main ()
+{
+  /* _Decimal32 variants.  */
+  if (arg0_32 (0.0df, -1, 2, 3.0f, 4.0, 5.0l) != 0.0df) FAILURE
+  if (arg1_32 (0, 1.0df, 2, 3.0f, 4.0, 5.0l) != 1.0df) FAILURE
+  if (arg2_32 (0, -1, 2.0df, 3.0f, 4.0, 5.0l) != 2.0df) FAILURE
+  if (arg3_32 (0, -1, 2.0f, 3.0df, 4.0, 5.0l) != 3.0df) FAILURE
+  if (arg4_32 (0, -1, 2.0f, 3.0, 4.0df, 5.0l) != 4.0df) FAILURE
+  if (arg5_32 (0, -1, 2.0f, 3.0, 4.0l, 5.0df) != 5.0df) FAILURE
+
+  /* _Decimal64 variants.  */
+  if (arg0_64 (0.0dd, -1, 2, 3.0f, 4.0, 5.0l) != 0.0dd) FAILURE
+  if (arg1_64 (0, 1.0dd, 2, 3.0f, 4.0, 5.0l) != 1.0dd) FAILURE
+  if (arg2_64 (0, -1, 2.0dd, 3.0f, 4.0, 5.0l) != 2.0dd) FAILURE
+  if (arg3_64 (0, -1, 2.0f, 3.0dd, 4.0, 5.0l) != 3.0dd) FAILURE
+  if (arg4_64 (0, -1, 2.0f, 3.0, 4.0dd, 5.0l) != 4.0dd) FAILURE
+  if (arg5_64 (0, -1, 2.0f, 3.0, 4.0l, 5.0dd) != 5.0dd) FAILURE
+
+  /* _Decimal128 variants.  */
+  if (arg0_128 (0.0dl, -1, 2, 3.0f, 4.0, 5.0l) != 0.0dl) FAILURE
+  if (arg1_128 (0, 1.0dl, 2, 3.0f, 4.0, 5.0l) != 1.0dl) FAILURE
+  if (arg2_128 (0, -1, 2.0dl, 3.0f, 4.0, 5.0l) != 2.0dl) FAILURE
+  if (arg3_128 (0, -1, 2.0f, 3.0dl, 4.0, 5.0l) != 3.0dl) FAILURE
+  if (arg4_128 (0, -1, 2.0f, 3.0, 4.0dl, 5.0l) != 4.0dl) FAILURE
+  if (arg5_128 (0, -1, 2.0f, 3.0, 4.0l, 5.0dl) != 5.0dl) FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-pointer.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-pointer.c
new file mode 100644
index 000000000..e1faceb63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-pointer.c
@@ -0,0 +1,220 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test pointer argument passing and return values involving decimal floating
+   point types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* A handful of functions that return their Nth pointer to Decimal32
+   argument.  */
+
+_Decimal32 *
+arg0_32 (_Decimal32 *arg0, _Decimal32 *arg1, _Decimal32 *arg2,
+	 _Decimal32 *arg3, _Decimal32 *arg4, _Decimal32 *arg5)
+{
+  return arg0;
+}
+
+_Decimal32 *
+arg1_32 (_Decimal32 *arg0, _Decimal32 *arg1, _Decimal32 *arg2,
+	 _Decimal32 *arg3, _Decimal32 *arg4, _Decimal32 *arg5)
+{
+  return arg1;
+}
+	
+_Decimal32 *
+arg2_32 (_Decimal32 *arg0, _Decimal32 *arg1, _Decimal32 *arg2,
+	 _Decimal32 *arg3, _Decimal32 *arg4, _Decimal32 *arg5)
+{
+  return arg2;
+}
+	
+_Decimal32 *
+arg3_32 (_Decimal32 *arg0, _Decimal32 *arg1, _Decimal32 *arg2,
+	 _Decimal32 *arg3, _Decimal32 *arg4, _Decimal32 *arg5)
+{
+  return arg3;
+}
+	
+_Decimal32 *
+arg4_32 (_Decimal32 *arg0, _Decimal32 *arg1, _Decimal32 *arg2,
+	 _Decimal32 *arg3, _Decimal32 *arg4, _Decimal32 *arg5)
+{
+  return arg4;
+}
+	
+_Decimal32 *
+arg5_32 (_Decimal32 *arg0, _Decimal32 *arg1, _Decimal32 *arg2,
+	 _Decimal32 *arg3, _Decimal32 *arg4, _Decimal32 *arg5)
+{
+  return arg5;
+}
+	
+
+/* A handful of functions that return their Nth pointer to _Decimal64
+   argument.  */
+
+_Decimal64 *
+arg0_64 (_Decimal64 *arg0, _Decimal64 *arg1, _Decimal64 *arg2,
+	 _Decimal64 *arg3, _Decimal64 *arg4, _Decimal64 *arg5)
+{
+  return arg0;
+}
+	
+_Decimal64 *
+arg1_64 (_Decimal64 *arg0, _Decimal64 *arg1, _Decimal64 *arg2,
+	 _Decimal64 *arg3, _Decimal64 *arg4, _Decimal64 *arg5)
+{
+  return arg1;
+}
+	
+_Decimal64 *
+arg2_64 (_Decimal64 *arg0, _Decimal64 *arg1, _Decimal64 *arg2,
+	 _Decimal64 *arg3, _Decimal64 *arg4, _Decimal64 *arg5)
+{
+  return arg2;
+}
+	
+_Decimal64 *
+arg3_64 (_Decimal64 *arg0, _Decimal64 *arg1, _Decimal64 *arg2,
+	 _Decimal64 *arg3, _Decimal64 *arg4, _Decimal64 *arg5)
+{
+  return arg3;
+}
+	
+_Decimal64 *
+arg4_64 (_Decimal64 *arg0, _Decimal64 *arg1, _Decimal64 *arg2,
+	 _Decimal64 *arg3, _Decimal64 *arg4, _Decimal64 *arg5)
+{
+  return arg4;
+}
+	
+_Decimal64 *
+arg5_64 (_Decimal64 *arg0, _Decimal64 *arg1, _Decimal64 *arg2,
+	 _Decimal64 *arg3, _Decimal64 *arg4, _Decimal64 *arg5)
+{
+  return arg5;
+}
+	
+
+/* A handful of functions that return their Nth _Decimal128
+   argument.  */
+
+_Decimal128 *
+arg0_128 (_Decimal128 *arg0, _Decimal128 *arg1, _Decimal128 *arg2,
+	  _Decimal128 *arg3, _Decimal128 *arg4, _Decimal128 *arg5)
+{
+  return arg0;
+}
+	
+_Decimal128 *
+arg1_128 (_Decimal128 *arg0, _Decimal128 *arg1, _Decimal128 *arg2,
+	  _Decimal128 *arg3, _Decimal128 *arg4, _Decimal128 *arg5)
+{
+  return arg1;
+}
+	
+_Decimal128 *
+arg2_128 (_Decimal128 *arg0, _Decimal128 *arg1, _Decimal128 *arg2,
+	  _Decimal128 *arg3, _Decimal128 *arg4, _Decimal128 *arg5)
+{
+  return arg2;
+}
+	
+_Decimal128 *
+arg3_128 (_Decimal128 *arg0, _Decimal128 *arg1, _Decimal128 *arg2,
+	  _Decimal128 *arg3, _Decimal128 *arg4, _Decimal128 *arg5)
+{
+  return arg3;
+}
+	
+_Decimal128 *
+arg4_128 (_Decimal128 *arg0, _Decimal128 *arg1, _Decimal128 *arg2,
+	  _Decimal128 *arg3, _Decimal128 *arg4, _Decimal128 *arg5)
+{
+  return arg4;
+}
+	
+_Decimal128 *
+arg5_128 (_Decimal128 *arg0, _Decimal128 *arg1, _Decimal128 *arg2,
+	  _Decimal128 *arg3, _Decimal128 *arg4, _Decimal128 *arg5)
+{
+  return arg5;
+}
+
+
+
+_Decimal32 df0 = 0.0df, df1 = 1.0df, df2 = 2.0df,
+	   df3 = 3.0df, df4 = 4.0df, df5 = 5.0df;
+_Decimal32 *pdf0 = &df0, *pdf1 = &df1, *pdf2 = &df2,
+	   *pdf3 = &df3, *pdf4 = &df4, *pdf5 = &df5;
+_Decimal64 dd0 = 0.0dd, dd1 = 1.0dd, dd2 = 2.0dd,
+	   dd3 = 3.0dd, dd4 = 4.0dd, dd5 = 5.0dd;
+_Decimal64 *pdd0 = &dd0, *pdd1 = &dd1, *pdd2 = &dd2,
+	   *pdd3 = &dd3, *pdd4 = &dd4, *pdd5 = &dd5;
+_Decimal128 dl0 = 0.0dl, dl1 = 1.0dl, dl2 = 2.0dl,
+	    dl3 = 3.0dl, dl4 = 4.0dl, dl5 = 5.0dl;
+_Decimal128 *pdl0 = &dl0, *pdl1 = &dl1, *pdl2 = &dl2,
+	    *pdl3 = &dl3, *pdl4 = &dl4, *pdl5 = &dl5;
+
+int
+main ()
+{
+  /* _Decimal32 variants.  */
+  if (*arg0_32 (pdf0, pdf1, pdf2, pdf3, pdf4, pdf5) != 0.0df)
+    FAILURE
+  if (*arg1_32 (pdf0, pdf1, pdf2, pdf3, pdf4, pdf5) != 1.0df)
+    FAILURE
+  if (*arg2_32 (pdf0, pdf1, pdf2, pdf3, pdf4, pdf5) != 2.0df)
+    FAILURE
+  if (*arg3_32 (pdf0, pdf1, pdf2, pdf3, pdf4, pdf5) != 3.0df)
+    FAILURE
+  if (*arg4_32 (pdf0, pdf1, pdf2, pdf3, pdf4, pdf5) != 4.0df)
+    FAILURE
+  if (*arg5_32 (pdf0, pdf1, pdf2, pdf3, pdf4, pdf5) != 5.0df)
+    FAILURE
+
+  /* _Decimal64 variants.  */
+  if (*arg0_64 (pdd0, pdd1, pdd2, pdd3, pdd4, pdd5) != 0.0dd)
+    FAILURE
+  if (*arg1_64 (pdd0, pdd1, pdd2, pdd3, pdd4, pdd5) != 1.0dd)
+    FAILURE
+  if (*arg2_64 (pdd0, pdd1, pdd2, pdd3, pdd4, pdd5) != 2.0dd)
+    FAILURE
+  if (*arg3_64 (pdd0, pdd1, pdd2, pdd3, pdd4, pdd5) != 3.0dd)
+    FAILURE
+  if (*arg4_64 (pdd0, pdd1, pdd2, pdd3, pdd4, pdd5) != 4.0dd)
+    FAILURE
+  if (*arg5_64 (pdd0, pdd1, pdd2, pdd3, pdd4, pdd5) != 5.0dd)
+    FAILURE
+
+  /* _Decimal128 variants.  */
+  if (*arg0_128 (pdl0, pdl1, pdl2, pdl3, pdl4, pdl5) != 0.0dl)
+    FAILURE
+  if (*arg1_128 (pdl0, pdl1, pdl2, pdl3, pdl4, pdl5) != 1.0dl)
+    FAILURE
+  if (*arg2_128 (pdl0, pdl1, pdl2, pdl3, pdl4, pdl5) != 2.0dl)
+    FAILURE
+  if (*arg3_128 (pdl0, pdl1, pdl2, pdl3, pdl4, pdl5) != 3.0dl)
+    FAILURE
+  if (*arg4_128 (pdl0, pdl1, pdl2, pdl3, pdl4, pdl5) != 4.0dl)
+    FAILURE
+  if (*arg5_128 (pdl0, pdl1, pdl2, pdl3, pdl4, pdl5) != 5.0dl)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-scalar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-scalar.c
new file mode 100644
index 000000000..bbda52c07
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-scalar.c
@@ -0,0 +1,207 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test scalar passing and return values involving decimal floating
+   point types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* A handful of functions that return their Nth _Decimal32
+   argument.  */
+
+_Decimal32
+arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg0;
+}
+
+_Decimal32
+arg1_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg1;
+}
+	
+_Decimal32
+arg2_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg2;
+}
+	
+_Decimal32
+arg3_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg3;
+}
+	
+_Decimal32
+arg4_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg4;
+}
+	
+_Decimal32
+arg5_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+	 _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+{
+  return arg5;
+}
+	
+
+/* A handful of functions that return their Nth _Decimal64
+   argument.  */
+
+_Decimal64
+arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg0;
+}
+	
+_Decimal64
+arg1_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg1;
+}
+	
+_Decimal64
+arg2_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg2;
+}
+	
+_Decimal64
+arg3_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg3;
+}
+	
+_Decimal64
+arg4_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg4;
+}
+	
+_Decimal64
+arg5_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+	 _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+{
+  return arg5;
+}
+	
+
+/* A handful of functions that return their Nth _Decimal128
+   argument.  */
+
+_Decimal128
+arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg0;
+}
+	
+_Decimal128
+arg1_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg1;
+}
+	
+_Decimal128
+arg2_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg2;
+}
+	
+_Decimal128
+arg3_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg3;
+}
+	
+_Decimal128
+arg4_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg4;
+}
+	
+_Decimal128
+arg5_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+	 _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+{
+  return arg5;
+}
+
+
+
+int
+main ()
+{
+  /* _Decimal32 variants.  */
+  if (arg0_32 (0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 0.0df)
+    FAILURE
+  if (arg1_32 (0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 1.0df)
+    FAILURE
+  if (arg2_32 (0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 2.0df)
+    FAILURE
+  if (arg3_32 (0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 3.0df)
+    FAILURE
+  if (arg4_32 (0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 4.0df)
+    FAILURE
+  if (arg5_32 (0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 5.0df)
+    FAILURE
+
+  /* _Decimal64 variants.  */
+  if (arg0_64 (0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 0.0dd)
+    FAILURE
+  if (arg1_64 (0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 1.0dd)
+    FAILURE
+  if (arg2_64 (0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 2.0dd)
+    FAILURE
+  if (arg3_64 (0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 3.0dd)
+    FAILURE
+  if (arg4_64 (0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 4.0dd)
+    FAILURE
+  if (arg5_64 (0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 5.0dd)
+    FAILURE
+
+  /* _Decimal128 variants.  */
+  if (arg0_128 (0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 0.0dl)
+    FAILURE
+  if (arg1_128 (0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 1.0dl)
+    FAILURE
+  if (arg2_128 (0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 2.0dl)
+    FAILURE
+  if (arg3_128 (0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 3.0dl)
+    FAILURE
+  if (arg4_128 (0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 4.0dl)
+    FAILURE
+  if (arg5_128 (0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 5.0dl)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-struct.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-struct.c
new file mode 100644
index 000000000..f022f1816
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-struct.c
@@ -0,0 +1,108 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test structure passing and return values involving decimal floating
+   point types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+struct example
+{
+  _Decimal128 d128;
+  char dummy1;
+  _Decimal64 d64;
+  char dummy2;
+  _Decimal32 d32;
+} nums = { 1.0dl, 'a', 2.0dd, 'b', 3.0df };
+
+_Decimal32
+d32_field (struct example s)
+{
+  return s.d32;
+}
+
+_Decimal64
+d64_field (struct example s)
+{
+  return s.d64;
+}
+
+_Decimal128
+d128_field (struct example s)
+{
+  return s.d128;
+}
+
+char
+dummy1_field (struct example s)
+{
+  return s.dummy1;
+}
+
+char
+dummy2_field (struct example s)
+{
+  return s.dummy2;
+}
+
+_Decimal32
+ptr_d32_field (struct example *s)
+{
+  return s->d32;
+}
+
+_Decimal64
+ptr_d64_field (struct example *s)
+{
+  return s->d64;
+}
+
+_Decimal128
+ptr_d128_field (struct example *s)
+{
+  return s->d128;
+}
+
+char
+ptr_dummy1_field (struct example *s)
+{
+  return s->dummy1;
+}
+
+char
+ptr_dummy2_field (struct example *s)
+{
+  return s->dummy2;
+}
+
+
+int
+main ()
+{
+  if (d32_field (nums) != 3.0df) FAILURE
+  if (d64_field (nums) != 2.0dd) FAILURE
+  if (d128_field (nums) != 1.0dl) FAILURE
+  if (dummy1_field (nums) != 'a') FAILURE
+  if (dummy2_field (nums) != 'b') FAILURE
+
+  if (ptr_d32_field (&nums) != 3.0df) FAILURE
+  if (ptr_d64_field (&nums) != 2.0dd) FAILURE
+  if (ptr_d128_field (&nums) != 1.0dl) FAILURE
+  if (ptr_dummy1_field (&nums) != 'a') FAILURE
+  if (ptr_dummy2_field (&nums) != 'b') FAILURE
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d128-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d128-2.c
new file mode 100644
index 000000000..167da24b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d128-2.c
@@ -0,0 +1,21 @@
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-std=gnu99 -mpreferred-stack-boundary=2" } */
+
+/* Simple test of vararg passing for problematic types with and without
+   double values passed between them.  */
+
+#define DTYPE _Decimal128
+#define ONE 1.0dl
+#define THREE 3.0dl
+#define SEVEN 7.0dl
+#define ELEVEN 11.0dl
+#define INTS 4
+
+#include "func-vararg-alternate.h"
+
+int
+main ()
+{
+  doit ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d128.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d128.c
new file mode 100644
index 000000000..e8fc0271d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d128.c
@@ -0,0 +1,20 @@
+/* { dg-options "-std=gnu99" } */
+
+/* Simple test of vararg passing for problematic types with and without
+   double values passed between them.  */
+
+#define DTYPE _Decimal128
+#define ONE 1.0dl
+#define THREE 3.0dl
+#define SEVEN 7.0dl
+#define ELEVEN 11.0dl
+#define INTS 4
+
+#include "func-vararg-alternate.h"
+
+int
+main ()
+{
+  doit ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d32.c
new file mode 100644
index 000000000..cd6853cc9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d32.c
@@ -0,0 +1,20 @@
+/* { dg-options "-std=gnu99" } */
+
+/* Simple test of vararg passing for problematic types with and without
+   double values passed between them.  */
+
+#define DTYPE _Decimal32
+#define ONE 1.0df
+#define THREE 3.0df
+#define SEVEN 7.0df
+#define ELEVEN 11.0df
+#define INTS 1
+
+#include "func-vararg-alternate.h"
+
+int
+main ()
+{
+  doit ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d64.c
new file mode 100644
index 000000000..39470013e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate-d64.c
@@ -0,0 +1,20 @@
+/* { dg-options "-std=gnu99" } */
+
+/* Simple test of vararg passing for problematic types with and without
+   double values passed between them.  */
+
+#define DTYPE _Decimal64
+#define ONE 1.0dd
+#define THREE 3.0dd
+#define SEVEN 7.0dd
+#define ELEVEN 11.0dd
+#define INTS 2
+
+#include "func-vararg-alternate.h"
+
+int
+main ()
+{
+  doit ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate.h
new file mode 100644
index 000000000..393111b33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-alternate.h
@@ -0,0 +1,150 @@
+/* Simple test of vararg passing for problematic types with and without
+   double values passed between them.  */
+
+#include <stdarg.h>
+#ifdef DBG
+#include <stdio.h>
+#endif
+
+extern void abort (void);
+
+int failcnt;
+DTYPE a[10];
+double b[10];
+
+union U {
+  DTYPE d;
+  unsigned int i[INTS];
+};
+
+void
+compare (double r, double s, int *p, int *q, int n, int line)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    if (r != s || p[i] != q[i])
+#ifdef DBG
+      {
+	int j;
+
+	printf ("line %-3d", line);
+	for (j = 0; j < n; j++)
+	  printf ("  %08x", p[j]);
+	printf ("    %10.2g\n        ", r);
+	for (j = 0; j < n; j++)
+	  printf ("  %08x", q[j]);
+	printf ("    %10.2g\n\n", s);
+	    
+	return;
+      }
+#else
+      abort ();
+#endif
+}
+
+void
+bar0 (int n, ...)
+{
+  union U u;
+  int j;
+  va_list ap;
+
+  va_start (ap, n);
+  for (j = 0; j < n; j++)
+    a[j] = va_arg (ap, DTYPE);
+  va_end (ap);
+}
+
+void
+bar1 (int n, ...)
+{
+  union U u;
+  int j;
+  va_list ap;
+
+  va_start (ap, n);
+  for (j = 0; j < n; j++)
+    {
+      a[j] = va_arg (ap, DTYPE);
+      b[j] = va_arg (ap, double);
+    }
+  va_end (ap);
+}
+
+void
+bar2 (int n, ...)
+{
+  union U u;
+  int j;
+  va_list ap;
+
+  va_start (ap, n);
+  for (j = 0; j < n; j++)
+    {
+      b[j] = va_arg (ap, double);
+      a[j] = va_arg (ap, DTYPE);
+    }
+  va_end (ap);
+}
+
+void
+doit ()
+{
+  DTYPE x, y, z;
+  union U u1, u2;
+
+  /* Sanity check that test setup is right, especially for long double
+     which can be changed by command line option.  */
+  if (INTS * 4 != sizeof (DTYPE))
+    {
+#ifdef DBG
+      printf ("test error: INTS = %d, sizeof (DTYPE) =  %d\n",
+	      INTS, sizeof (DTYPE));
+#endif
+      abort ();
+    }
+
+  x = ONE / THREE;
+  y = ONE / SEVEN;
+  z = ONE / ELEVEN;
+
+  bar0 (1, x);
+  u1.d = x; u2.d = a[0]; compare (0.0, 0.0, u1.i, u2.i, INTS, __LINE__);
+
+  bar0 (2, x, y);
+  u1.d = x; u2.d = a[0]; compare (0.0, 0.0, u1.i, u2.i, INTS, __LINE__);
+  u1.d = y; u2.d = a[1]; compare (0.0, 0.0, u1.i, u2.i, INTS, __LINE__);
+
+  bar0 (3, x, y, z);
+  u1.d = x; u2.d = a[0]; compare (0.0, 0.0, u1.i, u2.i, INTS, __LINE__);
+  u1.d = y; u2.d = a[1]; compare (0.0, 0.0, u1.i, u2.i, INTS, __LINE__);
+  u1.d = z; u2.d = a[2]; compare (0.0, 0.0, u1.i, u2.i, INTS, __LINE__);
+
+  bar1 (1, x, 1.5);
+  u1.d = x; u2.d = a[0]; compare (1.5, b[0], u1.i, u2.i, INTS, __LINE__);
+
+  bar1 (2, x, 1.5, y, 2.5);
+  u1.d = x; u2.d = a[0]; compare (1.5, b[0], u1.i, u2.i, INTS, __LINE__);
+  u1.d = y; u2.d = a[1]; compare (2.5, b[1], u1.i, u2.i, INTS, __LINE__);
+
+  bar1 (3, x, 1.5, y, 2.5, z, 3.5);
+  u1.d = x; u2.d = a[0]; compare (1.5, b[0], u1.i, u2.i, INTS, __LINE__);
+  u1.d = y; u2.d = a[1]; compare (2.5, b[1], u1.i, u2.i, INTS, __LINE__);
+  u1.d = z; u2.d = a[2]; compare (3.5, b[2], u1.i, u2.i, INTS, __LINE__);
+
+  bar2 (1, 1.5, x);
+  u1.d = x; u2.d = a[0]; compare (1.5, b[0], u1.i, u2.i, INTS, __LINE__);
+
+  bar2 (2, 1.5, x, 2.5, y);
+  u1.d = x; u2.d = a[0]; compare (1.5, b[0], u1.i, u2.i, INTS, __LINE__);
+  u1.d = y; u2.d = a[1]; compare (2.5, b[1], u1.i, u2.i, INTS, __LINE__);
+
+  bar2 (3, 1.5, x, 2.5, y, 3.5, z);
+  u1.d = x; u2.d = a[0]; compare (1.5, b[0], u1.i, u2.i, INTS, __LINE__);
+  u1.d = y; u2.d = a[1]; compare (2.5, b[1], u1.i, u2.i, INTS, __LINE__);
+  u1.d = z; u2.d = a[2]; compare (3.5, b[2], u1.i, u2.i, INTS, __LINE__);
+
+  if (failcnt != 0)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-dfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-dfp.c
new file mode 100644
index 000000000..1a681bcaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-dfp.c
@@ -0,0 +1,110 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing varargs of the decimal float types.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+static int failcnt = 0;
+                                                                                
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+static _Decimal32
+vararg32 (unsigned arg, ...)
+{
+  int i;
+  va_list ap;
+  _Decimal32 result;
+
+  va_start (ap, arg);
+  for (i = 0; i <= arg; i++)
+    result = va_arg (ap, _Decimal32);
+  va_end (ap);
+  return result;
+}
+
+static _Decimal64
+vararg64 (unsigned arg, ...)
+{
+  int i;
+  va_list ap;
+  _Decimal64 result;
+
+  va_start (ap, arg);
+  for (i = 0; i <= arg; i++)
+    result = va_arg (ap, _Decimal64);
+  va_end (ap);
+  return result;
+}
+
+static _Decimal128
+vararg128 (unsigned arg, ...)
+{
+  int i;
+  va_list ap;
+  _Decimal128 result;
+
+  va_start (ap, arg);
+  for (i = 0; i <= arg; i++)
+    result = va_arg (ap, _Decimal128);
+  va_end (ap);
+  return result;
+}
+
+
+int main()
+{
+  /* _Decimal32 variants.  */
+  if (vararg32 (0, 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 0.0df)
+    FAILURE
+  if (vararg32 (1, 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 1.0df)
+    FAILURE
+  if (vararg32 (2, 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 2.0df)
+    FAILURE
+  if (vararg32 (3, 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 3.0df)
+    FAILURE
+  if (vararg32 (4, 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 4.0df)
+    FAILURE
+  if (vararg32 (5, 0.0df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df) != 5.0df)
+    FAILURE
+
+  /* _Decimal64 variants.  */
+  if (vararg64 (0, 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 0.0dd)
+    FAILURE
+  if (vararg64 (1, 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 1.0dd)
+    FAILURE
+  if (vararg64 (2, 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 2.0dd)
+    FAILURE
+  if (vararg64 (3, 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 3.0dd)
+    FAILURE
+  if (vararg64 (4, 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 4.0dd)
+    FAILURE
+  if (vararg64 (5, 0.0dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd) != 5.0dd)
+    FAILURE
+
+  /* _Decimal128 variants.  */
+  if (vararg128 (0, 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 0.0dl)
+    FAILURE
+  if (vararg128 (1, 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 1.0dl)
+    FAILURE
+  if (vararg128 (2, 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 2.0dl)
+    FAILURE
+  if (vararg128 (3, 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 3.0dl)
+    FAILURE
+  if (vararg128 (4, 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 4.0dl)
+    FAILURE
+  if (vararg128 (5, 0.0dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl) != 5.0dl)
+    FAILURE
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-mixed-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-mixed-2.c
new file mode 100644
index 000000000..c1b349c67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-mixed-2.c
@@ -0,0 +1,118 @@
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-std=gnu99 -mpreferred-stack-boundary=2" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing varargs of the combination of decimal float types and
+   other types.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+static int failcnt = 0;
+                                                                                
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* Supposing the list of varying number of arguments is:
+   unsigned int, _Decimal128, double, _Decimal32, _Decimal64.  */
+
+static _Decimal32
+vararg_d32 (unsigned arg, ...)
+{
+  va_list ap;
+  _Decimal32 result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  va_arg (ap, _Decimal128);
+  va_arg (ap, double);
+  result = va_arg (ap, _Decimal32);
+
+  va_end (ap);
+  return result;
+}
+
+static _Decimal32
+vararg_d64 (unsigned arg, ...)
+{
+  va_list ap;
+  _Decimal64 result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  va_arg (ap, _Decimal128);
+  va_arg (ap, double);
+  va_arg (ap, _Decimal32);
+  result = va_arg (ap, _Decimal64);
+
+  va_end (ap);
+  return result;
+}
+
+static _Decimal128
+vararg_d128 (unsigned arg, ...)
+{
+  va_list ap;
+  _Decimal128 result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  result = va_arg (ap, _Decimal128);
+
+  va_end (ap);
+  return result;
+}
+
+static unsigned int
+vararg_int (unsigned arg, ...)
+{
+  va_list ap;
+  unsigned int result;
+
+  va_start (ap, arg);
+
+  result = va_arg (ap, unsigned int);
+
+  va_end (ap);
+  return result;
+}
+
+static double
+vararg_double (unsigned arg, ...)
+{
+  va_list ap;
+  float result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  va_arg (ap, _Decimal128);
+  result = va_arg (ap, double);
+
+  va_end (ap);
+  return result;
+}
+
+
+int
+main ()
+{
+  if (vararg_d32 (3, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 3.0df) FAILURE
+  if (vararg_d64 (4, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 4.0dd) FAILURE
+  if (vararg_d128 (1, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 1.0dl) FAILURE
+  if (vararg_int (0, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 0) FAILURE
+  if (vararg_double (2, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 2.0) FAILURE
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-mixed.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-mixed.c
new file mode 100644
index 000000000..b5a5be45d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-mixed.c
@@ -0,0 +1,117 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing varargs of the combination of decimal float types and
+   other types.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+static int failcnt = 0;
+                                                                                
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+/* Supposing the list of varying number of arguments is:
+   unsigned int, _Decimal128, double, _Decimal32, _Decimal64.  */
+
+static _Decimal32
+vararg_d32 (unsigned arg, ...)
+{
+  va_list ap;
+  _Decimal32 result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  va_arg (ap, _Decimal128);
+  va_arg (ap, double);
+  result = va_arg (ap, _Decimal32);
+
+  va_end (ap);
+  return result;
+}
+
+static _Decimal32
+vararg_d64 (unsigned arg, ...)
+{
+  va_list ap;
+  _Decimal64 result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  va_arg (ap, _Decimal128);
+  va_arg (ap, double);
+  va_arg (ap, _Decimal32);
+  result = va_arg (ap, _Decimal64);
+
+  va_end (ap);
+  return result;
+}
+
+static _Decimal128
+vararg_d128 (unsigned arg, ...)
+{
+  va_list ap;
+  _Decimal128 result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  result = va_arg (ap, _Decimal128);
+
+  va_end (ap);
+  return result;
+}
+
+static unsigned int
+vararg_int (unsigned arg, ...)
+{
+  va_list ap;
+  unsigned int result;
+
+  va_start (ap, arg);
+
+  result = va_arg (ap, unsigned int);
+
+  va_end (ap);
+  return result;
+}
+
+static double
+vararg_double (unsigned arg, ...)
+{
+  va_list ap;
+  float result;
+
+  va_start (ap, arg);
+
+  va_arg (ap, unsigned int);
+  va_arg (ap, _Decimal128);
+  result = va_arg (ap, double);
+
+  va_end (ap);
+  return result;
+}
+
+
+int
+main ()
+{
+  if (vararg_d32 (3, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 3.0df) FAILURE
+  if (vararg_d64 (4, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 4.0dd) FAILURE
+  if (vararg_d128 (1, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 1.0dl) FAILURE
+  if (vararg_int (0, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 0) FAILURE
+  if (vararg_double (2, 0, 1.0dl, 2.0, 3.0df, 4.0dd) != 2.0) FAILURE
+
+  if (failcnt != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-size0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-size0.c
new file mode 100644
index 000000000..dc94709c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/func-vararg-size0.c
@@ -0,0 +1,44 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+struct S1
+{
+  struct
+  {
+    _Decimal64 e;
+  } b[0];
+};
+
+/* Test handling vararg parameters whose size is 0.  */
+
+int check_var(int z,...)
+{
+  double d;
+  struct S1 s1;
+  long long result;
+  va_list ap;
+  va_start (ap, z);
+  d = va_arg (ap, double);
+  s1 = va_arg (ap, struct S1);
+  result = va_arg (ap, long long);
+  va_end (ap);
+  return (result == 2LL);
+
+}
+
+int
+main ()
+{
+  struct S1 s1;
+  struct S1 a1[5];
+
+  if (check_var(5, 1.0, s1, 2LL, a1[2], a1[2]) == 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/inf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/inf-1.c
new file mode 100644
index 000000000..86aa9e4cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/inf-1.c
@@ -0,0 +1,63 @@
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 4: Characteristics of decimal floating types (not explicit)
+   C99 5.2.4.2.2: Characteristics of floating types.
+   A few simple checks on arithmetic operations. */
+
+extern void abort (void);
+
+int main()
+{
+  /* Assumes rounding mode. */
+  if (9999999.E90DF + 1.E90df != __builtin_infd32 ())
+    abort ();
+
+  if (!__builtin_isinfd32 (9999999.E90DF + 1.E90df))
+    abort ();
+
+  if (9.999999999999999E384dd + .000000000000001e384dd 
+      != __builtin_infd32 ())
+    abort ();
+
+  if (-9999999.E90DF - 1.E90df != -__builtin_infd32 ())
+    abort ();
+
+  if (!__builtin_isinfd32 (9.999999999999999E384dd + .000000000000001e384dd))
+    abort ();
+
+  if (7.999999999999999999999999999999999E6144dl + 3.0E6144dl
+      != __builtin_infd32 ())
+    abort ();
+
+  if (__builtin_infd32 () * __builtin_infd32 () != __builtin_infd32 ())
+    abort ();
+
+  if (__builtin_infd32 () * 2 != __builtin_infd32 ())
+    abort ();
+
+  if (__builtin_infd64 () * -5 != -__builtin_infd32 ())
+    abort ();
+
+  if (!__builtin_isinfd128 (__builtin_infd32 () / 4))
+    abort ();
+
+  if (__builtin_infd64 () != __builtin_infd128 ())
+    abort ();
+
+  if (!__builtin_isinfd64 (__builtin_infd128 ()))
+    abort ();
+
+  if (__builtin_finited64 (__builtin_infd32 () * 4))
+    abort ();
+
+  if (!__builtin_finited128 (9.999999E90DL - 1.E90dd))
+    abort ();
+
+  if (__builtin_finited128 (__builtin_infd32 () *__builtin_infd128 ()))
+    abort ();
+
+  if (__builtin_finited32 (__builtin_nand32 ("")))
+    abort ();
+    
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-c89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-c89.c
new file mode 100644
index 000000000..8c96d60c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-c89.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+
+/* Decimal float keywords are not recognized in C89 mode.  */
+
+_Decimal32 x;		/* { dg-error "" } */
+_Decimal64 y;		/* { dg-error "" } */
+_Decimal128 z;		/* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-c99.c
new file mode 100644
index 000000000..8a62fb93e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-c99.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* Decimal float keywords are not recognized in C99 mode.  */
+
+_Decimal32 x;		/* { dg-error "" } */
+_Decimal64 y;		/* { dg-error "" } */
+_Decimal128 z;		/* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-ignored-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-ignored-c99.c
new file mode 100644
index 000000000..a4258aaa8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-ignored-c99.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* Decimal float keywords are not reserved for c99.  */
+
+int _Decimal32 (void)
+{
+  return 0;
+}
+
+int foo (int i)
+{
+  int _Decimal64 = i * 2;
+  return _Decimal64;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-pedantic.c
new file mode 100644
index 000000000..9492c7985
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-pedantic.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+/* Decimal float is a GCC extension.  */
+
+_Decimal32 x;		/* { dg-warning "GCC extension|ISO C" } */
+_Decimal64 y;		/* { dg-warning "GCC extension|ISO C" } */
+_Decimal128 z;		/* { dg-warning "GCC extension|ISO C" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-reserved.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-reserved.c
new file mode 100644
index 000000000..4a042adf4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/keywords-reserved.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 3: Decimal floating types.
+   C99 6.4.1(2): Keywords.
+   Decimal float keywords cannot be used in other contexts.  */
+
+int _Decimal32 (void)		/* { dg-error "" } */
+{
+  return 0;
+}
+
+int foo (int i)
+{
+  int _Decimal64 = i * 2;	/* { dg-error "" } */
+  return _Decimal64;		/* { dg-error "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/loop-index.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/loop-index.c
new file mode 100644
index 000000000..ff52189bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/loop-index.c
@@ -0,0 +1,57 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.8.5.2: The for statement.  */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void
+f32 (void)
+{
+  _Decimal32 d;
+  int i;
+
+  for (d = 1.1df, i=0; d <= 1.5df; d += 0.1df)
+    i++;
+
+  if (i != 5)
+    abort();
+}
+
+void
+f64 (void)
+{
+  _Decimal64 d;
+  int i;
+
+  for (d = 1.1dd, i=0; d <= 1.5dd; d += 0.1dd)
+    i++;
+
+  if (i != 5)
+    abort();
+}
+
+void
+f128 (void)
+{
+  _Decimal128 d;
+  int i;
+
+  for (d = 1.1dl, i=0; d <= 1.5dl; d += 0.1dl)
+    i++;
+
+  if (i != 5)
+    abort();
+}
+
+int
+main ()
+{
+  int i;
+
+  f32 ();
+  f64 ();
+  f128 ();
+  
+  return (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/modes.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/modes.c
new file mode 100644
index 000000000..ff2382b1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/modes.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef float decimal32  __attribute__ ((mode (SD)));
+typedef float decimal64  __attribute__ ((mode (DD)));
+typedef float decimal128 __attribute__ ((mode (TD)));
+
+int ssize[sizeof (decimal32) == 4 ? 1 : -1];
+int dsize[sizeof (decimal64) == 8 ? 1 : -1];
+int tsize[sizeof (decimal128) == 16 ? 1 : -1];
+
+int salign = __alignof (decimal32);
+int dalign = __alignof (decimal64);
+int talign = __alignof (decimal128);
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/nan-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/nan-1.c
new file mode 100644
index 000000000..50972e0eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/nan-1.c
@@ -0,0 +1,108 @@
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 4: Characteristics of decimal floating types (not explicit)
+   C99 5.2.4.2.2: Characteristics of floating types.
+   A few simple checks on arithmetic operations. */
+
+extern void abort (void);
+
+int main()
+{
+  /* Some possibly non-obvious tests, but most logical
+     operations on NaN return false, including NaN == NaN. */
+  if (__builtin_nand32("") == __builtin_nand32(""))
+    abort();
+
+  if (__builtin_nand64("") == __builtin_nand64(""))
+    abort();
+
+  if (__builtin_nand128("") == __builtin_nand128(""))
+    abort();
+  
+  if (!(__builtin_nand32("") != __builtin_nand32("")))
+    abort();
+
+  if (!(__builtin_nand64("") != __builtin_nand64("")))
+    abort();
+
+  if (!(__builtin_nand128("") != __builtin_nand128("")))
+    abort();
+
+  if (__builtin_nand32("") > __builtin_nand32(""))
+    abort();
+
+  if (__builtin_nand64("") >= __builtin_nand64(""))
+    abort();
+
+  if (__builtin_nand128("") <  __builtin_nand128(""))
+    abort();
+
+  if (-__builtin_nand128("") <  +__builtin_nand128(""))
+    abort();
+
+  /* 0.0/0.0 => NaN, but NaN != NaN.  */
+  if (0.0df/0.0dl == __builtin_nand32(""))
+    abort();
+
+  /* 0.0 * INF => NaN.  */
+  if (!__builtin_isnand32 (0.0df * __builtin_infd32()))
+    abort ();
+
+  if (!__builtin_isnand64 (0.0dd * __builtin_infd64()))
+    abort ();
+
+  if (!__builtin_isnand128 (0.0dd * __builtin_infd128()))
+    abort ();
+
+  /* INF - INF => NaN.  */
+  if (!__builtin_isnand32 (__builtin_infd32() - __builtin_infd32()))
+    abort ();
+
+  if (!__builtin_isnand64 (__builtin_infd64() - __builtin_infd64()))
+    abort ();
+
+  if (!__builtin_isnand128 (__builtin_infd128() - __builtin_infd128()))
+    abort ();
+
+  /* INF/INF => NaN.  */
+  if (!__builtin_isnand32 (__builtin_infd32()/__builtin_infd32()) )
+    abort ();
+
+  if (!__builtin_isnand64 (__builtin_infd64()/__builtin_infd64()) )
+    abort ();
+
+  if (!__builtin_isnand128 (__builtin_infd128()/__builtin_infd128()) )
+    abort ();
+  
+  /* 0.0/0.0 => NaN, but NaN != NaN.  */
+  if ((0.0dd/0.0df) == (0.0dd/0.0df))
+    abort();
+
+  if (__builtin_nand32("") <  __builtin_infd32())
+    abort();
+
+  if (__builtin_nand32("") >=  __builtin_infd32())
+    abort();
+
+  /* Fixme: Add sqrtdf(-x.df) test when sqrt is supported. */
+
+  if (!__builtin_isnand32(__builtin_nand32("")))
+    abort();
+
+  if (!__builtin_isnand64(__builtin_nand64("")))
+    abort();
+
+  if (!__builtin_isnand128(__builtin_nand128("")))
+    abort();
+
+  if (!__builtin_isnand128(8.0df * __builtin_nand128("")))
+    abort();
+
+  if (!__builtin_isnand32(8.1dl - __builtin_nand32("")))
+    abort();
+
+  if (!__builtin_isnand128(__builtin_nand64("") + __builtin_nand128("")))
+    abort();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/nan-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/nan-2.c
new file mode 100644
index 000000000..e8a663e74
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/nan-2.c
@@ -0,0 +1,55 @@
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 4: Characteristics of decimal floating types (not explicit)
+   C99 5.2.4.2.2: Characteristics of floating types.
+   A few simple checks on arithmetic operations.  Based on nan-1.c with
+   the consideration of negative zero.  */
+
+extern void abort (void);
+
+int main()
+{
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+
+  /* Verify that division by negative zero produces a negative infinity 
+     result.  */
+  d32 = 123.45f;
+  if (d32/-0.0df != -__builtin_infd32())
+    abort();
+  if (123.45df/-0.0df != -__builtin_infd32())
+    abort();
+  
+  d64 = 123.45f;
+  if (d64/-0.0dd != -__builtin_infd64())
+    abort();
+  if (123.45dd/-0.0dd !=  -__builtin_infd64())
+    abort();
+
+  d128 = 123.45f;
+  if (d128/-0.0dl != -__builtin_infd64())
+    abort();
+  if (123.45dl/-0.0dl != -__builtin_infd128())
+    abort();
+
+  d32 = 0.0df;
+  if (!__builtin_isnand32(-(d32/-0.0df)))
+    abort();
+  if (!__builtin_isnand32(-(0.0df/-0.0df)))
+    abort();
+
+  d64 = 0.0dd;
+  if (!__builtin_isnand64(-(d64/-0.0dd)))
+    abort();
+  if (!__builtin_isnand64(-(0.0dd/-0.0dd)))
+    abort();
+
+  d128 = 0.0dl;
+  if (!__builtin_isnand128(-(d128/-0.0dl)))
+    abort();
+  if (!__builtin_isnand128(-(0.0dl/-0.0dl)))
+    abort();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-arith-fold.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-arith-fold.c
new file mode 100644
index 000000000..ad398d9b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-arith-fold.c
@@ -0,0 +1,43 @@
+/* { dg-options "-std=gnu99 -O2" } */
+
+/* C99 6.5.5: Multiplicative operators.
+   C99 6.5.6: Additive operators.  */
+
+extern void link_error (void);
+
+int
+main ()
+{
+  _Decimal32 d32_1, d32_2;
+
+  /* Compare like-typed positive constants. */
+  if (2.99df + 5.1df != 8.09df)
+    link_error ();
+
+  if (5.77df - 2.22dd != 3.55df)
+    link_error ();
+
+  if (2.0dl * 3.7dd * -2 != -14.8df)
+    link_error ();
+
+  if (.18df / -.2df + 1 != 1.e-1dd)
+    link_error ();
+
+  d32_1 = 3.0df;
+  d32_2 = 1.0df;
+
+  if (!__builtin_constant_p (d32_1 + 0.2df))
+    link_error ();
+
+  if (!__builtin_constant_p (1.0df / 3.0df))
+    link_error ();
+
+  if (!__builtin_constant_p (d32_2 / d32_1))
+    link_error ();
+
+  d32_2 = 2.0df;
+  if (!__builtin_constant_p (d32_2 / d32_1))
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-assignment.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-assignment.c
new file mode 100644
index 000000000..49d15d238
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-assignment.c
@@ -0,0 +1,71 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.16 Assignment operators.
+   Verify the compound assignment operator for decimal float types,
+   using it with other decimal float types, integers, and other binary
+   float types cast to decimal float types.  */
+
+extern void abort (void);
+static int failcnt;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+#define OPERATE(OPRD1,OPRT,OPRD2,RLT)		\
+  if (( OPRD1 OPRT OPRD2 )!= RLT)		\
+    FAILURE
+
+#define DECIMAL_COMPOUND_ASSIGNMENT(TYPE, OPRD)	\
+{						\
+  _Decimal##TYPE d = OPRD;			\
+  OPERATE(d,+=,1,(OPRD + 1));		\
+  d = OPRD;				\
+  OPERATE(d,+=,0,OPRD);			\
+  d = OPRD;				\
+  OPERATE(d,+=,(-1),(OPRD - 1));	\
+  d = OPRD;				\
+  OPERATE(d,+=,d32a,(OPRD + d32a));	\
+  d = OPRD;				\
+  OPERATE(d,+=,d64a,(OPRD + d64a));	\
+  d = OPRD;				\
+  OPERATE(d,+=,d128a,(OPRD + d128a));	\
+  d = OPRD;				\
+  OPERATE(d,+=,(_Decimal##TYPE)1.1,(OPRD + (_Decimal##TYPE)1.1));	\
+  d = OPRD;				\
+  OPERATE(d,+=,(_Decimal##TYPE)2.2f,(OPRD + (_Decimal##TYPE)2.2f));	\
+  d = OPRD;				\
+  OPERATE(d,-=,1,(OPRD - 1));		\
+  d = OPRD;				\
+  OPERATE(d,-=,0,OPRD);			\
+  d = OPRD;				\
+  OPERATE(d,-=,(-1),(OPRD + 1));	\
+  d = OPRD;				\
+  OPERATE(d,-=,d32a,OPRD-d32a);		\
+  d = OPRD;				\
+  OPERATE(d,-=,d64a,OPRD-d64a);		\
+  d = OPRD;				\
+  OPERATE(d,-=,d128a,OPRD-d128a);	\
+}
+
+int
+main ()
+{
+  _Decimal32 d32 = 1.23456df, d32a = 1.2df;
+  _Decimal64 d64 = 23.456789dd, d64a = 2.8dd;
+  _Decimal128 d128 = 345.67890123456789dl, d128a = 4.7dl;
+
+  DECIMAL_COMPOUND_ASSIGNMENT(32, d32);
+  DECIMAL_COMPOUND_ASSIGNMENT(64, d64);
+  DECIMAL_COMPOUND_ASSIGNMENT(128, d128);
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-bitwise.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-bitwise.c
new file mode 100644
index 000000000..8523cb91a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-bitwise.c
@@ -0,0 +1,66 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.10: Bitwise AND operator.
+   C99 6.5.11: Bitwise exclusive OR operator.
+   C99 6.5.12: Bitwise inclusive OR operator.
+
+   Test that these operators do not accept decimal float operands.  */
+
+extern void abort (void);
+
+#define OPERATE(OPRD1,OPRT,OPRD2)		\
+do						\
+{						\
+  OPRD1 OPRT OPRD2;				\
+} while (0)
+
+
+
+#define DECIMAL_BITWISE_OPERATOR(OPRT,OPRD)	\
+do						\
+{						\
+OPERATE(OPRD,OPRT,1);				\
+OPERATE(OPRD,OPRT,0);				\
+OPERATE(OPRD,OPRT,0x15);			\
+OPERATE(0,OPRT,OPRD);				\
+OPERATE(1,OPRT,OPRD);				\
+OPERATE(0x15,OPRT,OPRD);			\
+} while (0)
+
+void operator_notfor_decimal()
+{
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+
+  /* C99 Section 6.5.7 Bitwise shift operators.  Operands must have
+     integer type (which the decimal float types are not).  */
+
+  d32 << 1;   /* { dg-error "invalid operands to binary" } */
+  d32 >> 1;   /* { dg-error "invalid operands to binary" } */
+  d64 << 1;   /* { dg-error "invalid operands to binary" } */
+  d64 >> 1;   /* { dg-error "invalid operands to binary" } */
+  d128 << 1;  /* { dg-error "invalid operands to binary" } */
+  d128 >> 1;  /* { dg-error "invalid operands to binary" } */
+
+  DECIMAL_BITWISE_OPERATOR(&,d32); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(&,d64); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(&,d128); /* { dg-error "invalid operands to binary" } */
+
+  /* C99 Section 6.5.{10,11,12} Bitwise operator.  Constraints: Each of
+   the operands shall have integer type.  DFP type is reject by compiler
+   when bitwise operation is performed.  */
+
+  DECIMAL_BITWISE_OPERATOR(&,d32); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(&,d64); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(&,d128); /* { dg-error "invalid operands to binary" } */
+
+  DECIMAL_BITWISE_OPERATOR(|,d32); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(|,d64); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(|,d128); /* { dg-error "invalid operands to binary" } */
+
+  DECIMAL_BITWISE_OPERATOR(^,d32); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(^,d64); /* { dg-error "invalid operands to binary" } */
+  DECIMAL_BITWISE_OPERATOR(^,d128); /* { dg-error "invalid operands to binary" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-comma.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-comma.c
new file mode 100644
index 000000000..904f9b3a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-comma.c
@@ -0,0 +1,57 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.17: Comma operator.
+   Test with decimal float operands.  */
+
+extern void abort (void);
+static int failcnt = 0;
+                                                                                
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+volatile _Decimal32 d32a, d32b, d32c;
+volatile _Decimal64 d64a, d64b, d64c;
+volatile _Decimal128 d128a, d128b, d128c;
+
+void
+init ()
+{
+  d32b = 123.456e94df;
+  d64b = 12.3456789012345e383dd;
+  d128b = 12345.6789012345678901e4000dl;
+
+  d32c = 1.3df;
+  d64c = 1.2dd;
+  d128c = 1.1dl;
+}
+
+int
+main ()
+{
+  d32a = (d32b, d32c);
+  if (d32a != d32c)
+    FAILURE
+  d64a = (d64b, 7.89dd, d64c);
+  if (d64a != d64c)
+    FAILURE
+  d128a = (45678.987654dl, d128c, d128b);
+  if (d128a != d128b)
+    FAILURE
+  d128a = (d32b, d64b, d128b);
+  if (d128a != d128b)
+    FAILURE
+  d32a = (d32b, 12, d64c);
+  if (d32a != d64c)
+    FAILURE;
+  d64a = (d64b, d32b, 12);
+  if (d64a != 12.0dd)
+    FAILURE;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-cond.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-cond.c
new file mode 100644
index 000000000..5230134f6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-cond.c
@@ -0,0 +1,67 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.15 Conditional operator.
+   Test with decimal float operands.  */
+
+extern void abort (void);
+static int failcnt = 0;
+                                                                                
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+volatile _Decimal32 d32a, d32b, d32c;
+volatile _Decimal64 d64a, d64b, d64c;
+volatile _Decimal128 d128a, d128b, d128c;
+volatile int i, yes, no;
+
+void
+init ()
+{
+  d32b = 123.456e94df;
+  d64b = 12.3456789012345e383dd;
+  d128b = 12345.6789012345678901e4000dl;
+
+  d32c = 1.3df;
+  d64c = 1.2dd;
+  d128c = 1.1dl;
+
+  i = 2;
+  yes = 1;
+  no = 0;
+}
+
+int
+main ()
+{
+  init ();
+
+  /* Operands and the result are all the same decimal float type.  */
+  d32a = yes ? d32b : d32c;
+  if (d32a != d32b)
+    FAILURE
+  d64a = no ? d64b : d64c;
+  if (d64a != d64c)
+    FAILURE
+  d128a = yes ? d128b : d128c;
+  if (d128a != d128b)
+    FAILURE
+
+  /* Operand types are different.  */
+  d128a = yes ? d32b : d64b;
+  if (d128a != d32b)
+    FAILURE
+  d128a = yes ? d128b : d64b;
+  if (d128a != d128b)
+    FAILURE
+  d128a = no ? d32b : d128b;
+  if (d128a != d128b)
+    FAILURE
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-logical.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-logical.c
new file mode 100644
index 000000000..90a94b078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-logical.c
@@ -0,0 +1,65 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 Logical AND operator.
+   C99 Logical OR operator.
+   Test with decimal float operands.  */
+
+extern void abort (void);
+
+#define OPERATE(OPRD1,OPRT,OPRD2,RLT)	\
+do					\
+{					\
+  if (( (OPRD1) OPRT (OPRD2) )!= RLT)	\
+    abort ();				\
+} while (0)
+
+#define DECIMAL_LOGICAL_OR(OPRD)	\
+do					\
+{					\
+  OPRD = 1.0;				\
+  OPERATE(1,||,OPRD,1);			\
+  OPERATE(0,||,OPRD,1);			\
+  OPERATE(OPRD,||,1,1);			\
+  OPERATE(OPRD,||,0,1);			\
+  OPRD = 0.0;				\
+  OPERATE(1,||,OPRD,1);			\
+  OPERATE(0,||,OPRD,0);			\
+  OPERATE(OPRD,||,1,1);			\
+  OPERATE(OPRD,||,0,0);			\
+} while (0)
+
+#define DECIMAL_LOGICAL_AND(OPRD)	\
+do					\
+{					\
+  OPRD = 1.0;				\
+  OPERATE(1,&&,OPRD,1);			\
+  OPERATE(0,&&,OPRD,0);			\
+  OPERATE(OPRD,&&,1,1);			\
+  OPERATE(OPRD,&&,0,0);			\
+  OPRD = 0.0;				\
+  OPERATE(1,&&,OPRD,0);			\
+  OPERATE(0,&&,OPRD,0);			\
+  OPERATE(OPRD,&&,1,0);			\
+  OPERATE(OPRD,&&,0,0);			\
+} while (0)
+
+int
+main ()
+{
+  _Decimal32 d32;
+  _Decimal64 d64;
+  _Decimal128 d128;
+
+  /* C99 Section 6.5.{13,14} Logical operator.  Constraints Each of the
+     operands shall have scalar type.  DFP types would obey this.  */
+  DECIMAL_LOGICAL_OR (d32);
+  DECIMAL_LOGICAL_AND (d32);
+
+  DECIMAL_LOGICAL_OR (d64);
+  DECIMAL_LOGICAL_AND (d64);
+
+  DECIMAL_LOGICAL_OR (d128);
+  DECIMAL_LOGICAL_AND (d128);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-unary.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-unary.c
new file mode 100644
index 000000000..bcf50683c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/operator-unary.c
@@ -0,0 +1,54 @@
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.3 Unary operators.  */
+
+extern void abort (void);
+
+#define AUTO_INCREASE_DECREASE(TYPE,SUFFIX)   		\
+do                                            		\
+{                                             		\
+  _Decimal##TYPE in_de_d##TYPE = 0.0##SUFFIX;         	\
+  if (in_de_d##TYPE++) abort ();              		\
+  if (--in_de_d##TYPE) abort ();              		\
+  if (++in_de_d##TYPE == 0.0##SUFFIX) abort (); 	\
+  if (in_de_d##TYPE-- == 0.0##SUFFIX) abort (); 	\
+} while(0)
+
+#define UNARY_OPERATOR(TYPE,SUFFIX)           		\
+do                                            		\
+{                                             		\
+ _Decimal##TYPE unary_d##TYPE = 1.0##SUFFIX;  		\
+ _Decimal##TYPE* unary_dp##TYPE;              		\
+ /*  & operator.  */                          		\
+ unary_dp##TYPE = &(unary_d##TYPE);           		\
+ /*  * operator.  */                          		\
+ unary_d##TYPE = *(unary_dp##TYPE);           		\
+ /*  - operator.  */                          		\
+ unary_d##TYPE = -unary_d##TYPE;              		\
+ if (unary_d##TYPE != -1.0##SUFFIX) abort ();         	\
+ /*  + operator.  */                          		\
+ unary_d##TYPE = +unary_d##TYPE;              		\
+ if (unary_d##TYPE != -1.0##SUFFIX) abort ();         	\
+ if (!unary_d##TYPE) abort (); /*! operator.  */ 	\
+} while (0)
+
+int
+main ()
+{
+  /*  C99 6.5.3.1 Prefix increment and decrement operators. */
+  AUTO_INCREASE_DECREASE(32, DF);
+  AUTO_INCREASE_DECREASE(64, DD);
+  AUTO_INCREASE_DECREASE(128, DL);
+
+  /*  C99 6.5.3 Unary operators.  */
+  UNARY_OPERATOR(32, DF);
+  UNARY_OPERATOR(64, DD);
+  UNARY_OPERATOR(128, DL);
+
+  /*  C99 6.5.3 Unary operators for zero values.  */
+  if (- +0.df != -0.df) abort ();
+  if (+ -0.df != -0.df) abort ();
+  if (- -0.df != +0.df) abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr31344.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr31344.c
new file mode 100644
index 000000000..de76a72f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr31344.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O -std=gnu99 -mtune=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-O -std=gnu99" } */
+
+typedef struct
+{
+  unsigned char bits;
+} decNumber;
+
+typedef struct
+{
+  unsigned char bytes[1];
+} decimal32;
+
+extern decNumber *__decimal32ToNumber (const decimal32 *, decNumber *);
+extern void __host_to_ieee_32 (_Decimal32, decimal32 *);
+
+void
+foo (_Decimal32 arg)
+{
+  decNumber dn;
+  decimal32 d32;
+  __host_to_ieee_32 (arg, &d32);
+  __decimal32ToNumber (&d32, &dn);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr31385.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr31385.c
new file mode 100644
index 000000000..63a23c4bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr31385.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O2" } */
+
+typedef _Decimal32 fp_t;
+
+extern fp_t g(fp_t);
+
+fp_t
+bug(fp_t x)
+{
+    fp_t result;
+    int n;
+    fp_t f, f3, y, z;
+
+    n = 0;
+    y = 1.DF;
+    f = g(x);
+
+    if (f < 0.DF)
+        f = -f;
+
+    f3 = 2.DF;
+
+    z = (y + y + f / (y * y));
+    y = (z + z) / (9.DF) + f3 / (z * z);
+
+    result = y;
+
+    return (result);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr35620.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr35620.c
new file mode 100644
index 000000000..90f9500c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr35620.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O2" } */
+
+extern void foo (_Decimal32);
+_Decimal32 *p;
+
+extern int i;
+union { _Decimal32 a; int b; } u;
+
+void
+blatz (void)
+{
+  _Decimal32 d;
+  u.b = i;
+  d = u.a;
+  foo (d);
+}
+
+void
+bar (void)
+{
+  foo (*p);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr35739.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr35739.c
new file mode 100644
index 000000000..d4e183902
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr35739.c
@@ -0,0 +1,16 @@
+/* PR c/35739 */
+/* { dg-do compile { target *-*-linux* } } */
+/* { dg-options "-O -fpreprocessed -fmudflap" } */
+
+_Decimal128
+foo (int n, ...)
+{
+  int i;
+  _Decimal128 j = 0;
+  __builtin_va_list ap;
+  __builtin_va_start (ap, n);
+  for (i = 0; i < n; i++)
+    j += __builtin_va_arg (ap, _Decimal128);
+  __builtin_va_end (ap);
+  return j;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr37435.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr37435.c
new file mode 100644
index 000000000..98acc9c11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr37435.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-std=gnu99 -O2 -fPIC" } */
+
+volatile _Decimal32 d;
+volatile int i;
+
+void foo()
+{
+  d += i;
+  d += i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39034.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39034.c
new file mode 100644
index 000000000..6a261c9dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39034.c
@@ -0,0 +1,111 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -O" } */
+
+/* DFP TR 24732 == WG14 / N1176, N1312 */
+/* Based on a test from Fred Tydeman.  */
+
+extern void abort (void);
+int failures = 0;
+
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE(MSG) { printf ("line %d: %s\n", __LINE__, MSG); failures++; }
+#else
+#define FAILURE(MSG) failures++;
+#endif
+
+
+/* Test runtime computations.  */
+
+void
+runtime32 (void)
+{
+  volatile float v1 = 28.f, v2 = 3.f, v3 = 9.f, v4 = 31.f, v5 = 3.f, v6 = 10.f;
+  float      b32 = (float)((v1/v2-v3) - (v4/v5-v6));
+  _Decimal32 d32 = (float)((v1/v2-v3) - (v4/v5-v6));
+
+  if (b32)
+    FAILURE ("runtime: b32 should be zero")
+  if (d32)
+    FAILURE ("runtime: d32 should be zero")
+}
+
+void
+runtime64 (void)
+{
+  volatile double v1 = 28., v2 = 3., v3 = 9., v4 = 31., v5 = 3., v6 = 10.;
+  double     b64 = (double)((v1/v2-v3) - (v4/v5-v6));
+  _Decimal64 d64 = (double)((v1/v2-v3) - (v4/v5-v6));
+
+  if (b64)
+    FAILURE ("runtime: b64 should be zero")
+  if (d64)
+    FAILURE ("runtime: d64 should be zero")
+}
+
+void
+runtime128 (void)
+{
+  volatile long double v1 = 28.l, v2 = 3.l, v3 = 9.l,
+                       v4 = 31.l, v5 = 3.l, v6 = 10.l;
+  long double b128 = (long double)((v1/v2-v3) - (v4/v5-v6));
+  _Decimal128 d128 = (long double)((v1/v2-v3) - (v4/v5-v6));
+
+  if (b128)
+    FAILURE ("runtime: b128 should be zero")
+  if (d128)
+    FAILURE ("runtime: d128 should be zero")
+}
+
+/* Test constant folding.  */
+
+void
+fold32 (void)
+{
+  double     d32 = (float)((28.f/3.f-9.f) - (31.f/3.f-10.f));
+  _Decimal32 b32 = (float)((28.f/3.f-9.f) - (31.f/3.f-10.f));
+
+  if (b32)
+    FAILURE ("fold: b32 should be zero")
+  if (d32)
+    FAILURE ("fold: d32 should be zero")
+}
+
+void
+fold64 (void)
+{
+  double     b64 = (double)((28./3.-9.) - (31./3.-10.));
+  _Decimal64 d64 = (double)((28./3.-9.) - (31./3.-10.));
+
+  if (b64)
+    FAILURE ("fold: b64 should be zero")
+  if (d64)
+    FAILURE ("fold: d64 should be zero")
+}
+
+void
+fold128 (void)
+{
+  long double b128 = (long double)((28./3.-9.) - (31./3.-10.));
+  _Decimal128 d128 = (long double)((28./3.-9.) - (31./3.-10.));
+
+  if (b128)
+    FAILURE ("fold: b128 should be zero")
+  if (d128)
+    FAILURE ("fold: d128 should be zero")
+}
+
+int
+main ()
+{
+  runtime32 ();
+  runtime64 ();
+  runtime128 ();
+  fold32 ();
+  fold64 ();
+  fold128 ();
+
+  if (failures != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39035.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39035.c
new file mode 100644
index 000000000..2d44e06a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39035.c
@@ -0,0 +1,81 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -O" } */
+
+/* DFP TR 24732 == WG14 / N1176, N1312 */
+/* Based on a test from Fred Tydeman.  */
+
+extern void abort (void);
+int failures = 0;
+
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE(MSG) { printf ("line %d: %s\n", __LINE__, MSG); failures++; }
+#else
+#define FAILURE(MSG) failures++;
+#endif
+
+/* Test runtime computations.  */
+
+void
+runtime32 (void)
+{
+  volatile _Decimal32 d;
+  d = 0.0DF;
+  if (d)
+    FAILURE ("0.0DF should be zero")
+}
+
+void
+runtime64 (void)
+{
+  volatile _Decimal64 d;
+  d = 0.0DD;
+  if (d)
+    FAILURE ("0.0DD should be zero")
+}
+
+void
+runtime128 (void)
+{
+  volatile _Decimal128 d;
+  d = 0.0DL;
+  if (d)
+    FAILURE ("0.0DL should be zero")
+}
+
+void
+fold32 (void)
+{
+  if (0.0DF)
+    FAILURE ("0.0DF should be zero")
+}
+
+void
+fold64 (void)
+{
+  if (0.0DD)
+    FAILURE ("0.0DD should be zero")
+}
+
+void
+fold128 (void)
+{
+  if (0.0DL)
+    FAILURE ("0.0DL should be zero")
+}
+
+int
+main(void)
+{
+  runtime32 ();
+  runtime64 ();
+  runtime128 ();
+
+  fold32 ();
+  fold64 ();
+  fold128 ();
+
+  if (failures != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39902.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39902.c
new file mode 100644
index 000000000..120610c37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39902.c
@@ -0,0 +1,239 @@
+/* { dg-options "--std=gnu99" } */
+
+/* Check that optimizations like (x * 1) to x, or (x * -1) to -x,
+   do not apply to decimal float computations where trailing zeroes
+   are significant.  */
+
+extern void abort (void);
+int failcnt;
+
+#ifdef DBG
+extern int printf (const char *, ...);
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+#define COMPARE32(A,B) \
+  A.i == B.i
+
+#define COMPARE64(A,B) \
+  A.i[0] == B.i[0] && A.i[1] == B.i[1]
+
+#define COMPARE128(A,B) \
+  A.i[0] == B.i[0] && A.i[1] == B.i[1] && A.i[2] == B.i[2] && A.i[3] == B.i[3]
+
+typedef union {
+  _Decimal32 d;
+  unsigned int i;
+} u32;
+
+typedef union {
+  _Decimal64 d;
+  unsigned int i[2];
+} u64;
+
+typedef union {
+  _Decimal128 d;
+  unsigned int i[4];
+} u128;
+
+volatile u32 p32_1;
+volatile u32 p32_1_0;
+volatile u32 p32_2_0;
+volatile u32 m32_1;
+volatile u32 m32_1_0;
+volatile u32 m32_2_0;
+volatile u32 a32;
+
+volatile u64 p64_1;
+volatile u64 p64_1_0;
+volatile u64 p64_2_0;
+volatile u64 m64_1;
+volatile u64 m64_1_0;
+volatile u64 m64_2_0;
+volatile u64 a64;
+
+volatile u128 p128_1;
+volatile u128 p128_1_0;
+volatile u128 p128_2_0;
+volatile u128 m128_1;
+volatile u128 m128_1_0;
+volatile u128 m128_2_0;
+volatile u128 a128;
+
+void
+init32 (void)
+{
+  p32_1.d = 1.DF;
+  p32_1_0.d = 1.0DF;
+  p32_2_0.d = 2.0DF;
+  m32_1.d = -1.DF;
+  m32_1_0.d = -1.0DF;
+  m32_2_0.d = -2.0DF;
+}
+
+void
+init64 (void)
+{
+  p64_1.d = 1.DD;
+  p64_1_0.d = 1.0DD;
+  p64_2_0.d = 2.0DD;
+  m64_1.d = -1.DD;
+  m64_1_0.d = -1.0DD;
+  m64_2_0.d = -2.0DD;
+}
+
+void
+init128 (void)
+{
+  p128_1.d = 1.DL;
+  p128_1_0.d = 1.0DL;
+  p128_2_0.d = 2.0DL;
+  m128_1.d = -1.DL;
+  m128_1_0.d = -1.0DL;
+  m128_2_0.d = -2.0DL;
+}
+
+void
+doit32 (void)
+{
+  /* Multiplying by a value with no trailing zero should not change the
+     quantum exponent.  */
+
+  a32.d = p32_2_0.d * p32_1.d;
+  if (! (COMPARE32 (a32, p32_2_0)))
+    FAILURE
+
+  a32.d = p32_2_0.d * 1.DF;
+  if (! (COMPARE32 (a32, p32_2_0)))
+    FAILURE
+
+  a32.d = p32_2_0.d * m32_1.d;
+  if (! (COMPARE32 (a32, m32_2_0)))
+    FAILURE
+
+  a32.d = p32_2_0.d * -1.DF;
+  if (! (COMPARE32 (a32, m32_2_0)))
+    FAILURE
+
+  /* Multiplying by a value with a trailing zero should change the
+     quantum exponent.  */
+
+  a32.d = p32_2_0.d * p32_1_0.d;
+  if (COMPARE32 (a32, p32_2_0))
+    FAILURE
+
+  a32.d = p32_2_0.d * 1.0DF;
+  if (COMPARE32 (a32, p32_2_0))
+    FAILURE
+
+  a32.d = p32_2_0.d * m32_1_0.d;
+  if (COMPARE32 (a32, m32_2_0))
+    FAILURE
+
+  a32.d = p32_2_0.d * -1.0DF;
+  if (COMPARE32 (a32, m32_2_0))
+    FAILURE
+}
+
+void
+doit64 (void)
+{
+  /* Multiplying by a value with no trailing zero should not change the
+     quantum exponent.  */
+
+  a64.d = p64_2_0.d * p64_1.d;
+  if (! (COMPARE64 (a64, p64_2_0)))
+    FAILURE
+
+  a64.d = p64_2_0.d * 1.DD;
+  if (! (COMPARE64 (a64, p64_2_0)))
+    FAILURE
+
+  a64.d = p64_2_0.d * m64_1.d;
+  if (! (COMPARE64 (a64, m64_2_0)))
+    FAILURE
+
+  a64.d = p64_2_0.d * -1.DD;
+  if (! (COMPARE64 (a64, m64_2_0)))
+    FAILURE
+
+  /* Multiplying by a value with a trailing zero should change the
+     quantum exponent.  */
+
+  a64.d = p64_2_0.d * p64_1_0.d;
+  if (COMPARE64 (a64, p64_2_0))
+    FAILURE
+
+  a64.d = p64_2_0.d * 1.0DD;
+  if (COMPARE64 (a64, p64_2_0))
+    FAILURE
+
+  a64.d = p64_2_0.d * m64_1_0.d;
+  if (COMPARE64 (a64, m64_2_0))
+    FAILURE
+
+  a64.d = p64_2_0.d * -1.0DD;
+  if (COMPARE64 (a64, m64_2_0))
+    FAILURE
+}
+
+void
+doit128 (void)
+{
+  /* Multiplying by a value with no trailing zero should not change the
+     quantum exponent.  */
+
+  a128.d = p128_2_0.d * p128_1_0.d;
+  if (COMPARE128 (a128, p128_2_0))
+    FAILURE
+
+  a128.d = p128_2_0.d * 1.0DL;
+  if (COMPARE128 (a128, p128_2_0))
+    FAILURE
+
+  a128.d = p128_2_0.d * m128_1_0.d;
+  if (COMPARE128 (a128, m128_2_0))
+    FAILURE
+
+  a128.d = p128_2_0.d * -1.0DL;
+  if (COMPARE128 (a128, m128_2_0))
+    FAILURE
+
+  /* Multiplying by a value with a trailing zero should change the
+     quantum exponent.  */
+
+  a128.d = p128_2_0.d * p128_1.d;
+  if (! (COMPARE128 (a128, p128_2_0)))
+    FAILURE
+
+  a128.d = p128_2_0.d * 1.DL;
+  if (! (COMPARE128 (a128, p128_2_0)))
+    FAILURE
+
+  a128.d = p128_2_0.d * m128_1.d;
+  if (! (COMPARE128 (a128, m128_2_0)))
+    FAILURE
+
+  a128.d = p128_2_0.d * -1.DL;
+  if (! (COMPARE128 (a128, m128_2_0)))
+    FAILURE
+}
+
+int
+main (void)
+{
+  init32 ();
+  init64 ();
+  init128 ();
+
+  doit32 ();
+  doit64 ();
+  doit128 ();
+
+  if (failcnt != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39986.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39986.c
new file mode 100644
index 000000000..53bda3c82
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr39986.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* Check that the compiler generates the correct decimal float constants.  */
+
+_Decimal32 a = 100.223df;
+_Decimal32 b = -2.3df;
+_Decimal64 c = 3.4e-4dd;
+_Decimal64 d = -4.500dd;
+_Decimal128 e = 5678901234567.89e+200dl;
+_Decimal128 f = -678901.234e-6dl;
+
+/* The first value is DPD, the second is BID.  The order differs depending
+   on whether the target is big-endian or little-endian.  */
+
+/* { dg-final { scan-assembler ".long\t(572653859|822183807)\n" } } */
+
+/* { dg-final { scan-assembler ".long\t(-1572863965|-1308622825)\n" } } */
+
+/* { dg-final { scan-assembler ".long\t(52|34)\n" } } */
+/* { dg-final { scan-assembler ".long\t(572784640|824180736)\n" } } */
+
+/* { dg-final { scan-assembler ".long\t(4736|4500)\n" } } */
+/* { dg-final { scan-assembler ".long\t(-1574174720|-1319108608)\n" } } */
+
+/* { dg-final { scan-assembler ".long\t(-1975952433|957645077)\n" } } */
+/* { dg-final { scan-assembler ".long\t(190215|132222)\n" } } */
+/* { dg-final { scan-assembler ".long\t(574193664|835452928)\n" } } */
+
+/* { dg-final { scan-assembler ".long\t(931280180|678901234)\n" } } */
+/* { dg-final { scan-assembler ".long\t(-1576681472|-1339162624)\n" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr41049.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr41049.c
new file mode 100644
index 000000000..0b01438d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/pr41049.c
@@ -0,0 +1,571 @@
+/* { dg-options "-std=gnu99" } */
+
+/* The preferred exponent of the result of a conversion from an
+   integral type to a decimal float type is zero.  A conversion at
+   either compile time or runtime should not change the number of
+   trailing zeroes.  */
+
+int failures;
+
+#ifdef DBG
+extern int printf (const char *, ...);
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failures++; }
+#define FINISH if (failures != 0) __builtin_abort (); return 0;
+#else
+#define FAILURE __builtin_abort ();
+#define FINISH return 0;
+#endif
+
+#define PASTE2(A,B) A ## B
+#define PASTE(A,B) PASTE2(A,B)
+
+#define TESTVAL_NEG(VAL,SUF,SIZE)					\
+  x = PASTE(PASTE(VAL,.),SUF);						\
+  si = VAL;								\
+  sll = PASTE(VAL,LL);							\
+  a = si;								\
+  b = sll;								\
+  c = VAL;								\
+  d = PASTE(VAL,LL);							\
+  if ((__builtin_memcmp ((void *)&x, (void *)&a, SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&b,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&c,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&d,SIZE) != 0))		\
+    FAILURE
+
+#define TESTVAL_NEG_BIG(VAL,SUF,SIZE)					\
+  x = PASTE(PASTE(VAL,.),SUF);						\
+  sll = PASTE(VAL,LL);							\
+  a = sll;								\
+  b = PASTE(VAL,LL);							\
+  if ((__builtin_memcmp ((void *)&x, (void *)&a, SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&b,SIZE) != 0))		\
+    FAILURE
+
+#define TESTVAL_NONNEG(VAL,SUF,SIZE)					\
+  x = PASTE(PASTE(VAL,.),SUF);						\
+  si = VAL;								\
+  ui = VAL;								\
+  sll = PASTE(VAL,LL);							\
+  ull = PASTE(VAL,ULL);							\
+  a = si;								\
+  b = sll;								\
+  c = ui;								\
+  d = ull;								\
+  e = VAL;								\
+  f = VAL;								\
+  g = PASTE(VAL,LL);							\
+  h = PASTE(VAL,ULL);							\
+  if ((__builtin_memcmp ((void *)&x, (void *)&a, SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&b,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&c,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&d,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&e,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&f,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&g,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&x, (void *)&h,SIZE) != 0))		\
+    FAILURE
+
+#define TESTVAL_NONNEG_BIG(VAL,SUF,SIZE)				\
+  x = PASTE(PASTE(VAL,.),SUF);						\
+  sll = PASTE(VAL,LL);							\
+  ull = PASTE(VAL,ULL);							\
+  b = sll;								\
+  d = ull;								\
+  f = PASTE(VAL,LL);							\
+  g = PASTE(VAL,ULL);							\
+  if ((__builtin_memcmp ((void *)&x, (void *)&b, SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&d, (void *)&d,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&f, (void *)&d,SIZE) != 0)		\
+      || (__builtin_memcmp ((void *)&g, (void *)&d,SIZE) != 0))		\
+    FAILURE
+
+#undef SUFFIX
+#define SUFFIX DF
+#undef TYPE
+#define TYPE _Decimal32
+  
+void
+zeroes_32 (void)
+{
+  volatile TYPE x, a, b, c, d, e, f, g, h;
+  volatile int si;
+  volatile unsigned int ui;
+  volatile long long sll;
+  volatile unsigned long long ull;
+
+  TESTVAL_NONNEG (0, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000000000, SUFFIX, sizeof (TYPE));
+
+  TESTVAL_NEG (0, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000000000, SUFFIX, sizeof (TYPE));
+}
+  
+void
+round_32 (void)
+{
+  volatile TYPE x, a, b, c, d, e, f, g, h;
+  volatile int si;
+  volatile unsigned int ui;
+  volatile long long sll;
+  volatile unsigned long long ull;
+
+  TESTVAL_NONNEG (10000049, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000050, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000051, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000001, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000002, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000003, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000004, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000049, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000051, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000006, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000007, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000008, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000009, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000010, SUFFIX, sizeof (TYPE));
+
+  TESTVAL_NEG (-10000049, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000050, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000051, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000001, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000002, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000003, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000004, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000049, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000051, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000006, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000007, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000008, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000009, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000010, SUFFIX, sizeof (TYPE));
+}
+
+#undef SUFFIX
+#define SUFFIX DD
+#undef TYPE
+#define TYPE _Decimal64
+  
+void
+zeroes_64 (void)
+{
+  volatile TYPE x, a, b, c, d, e, f, g, h;
+  volatile int si;
+  volatile unsigned int ui;
+  volatile long long sll;
+  volatile unsigned long long ull;
+
+  TESTVAL_NONNEG (0, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000000000, SUFFIX, sizeof (TYPE));
+
+  TESTVAL_NEG (0, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000000000, SUFFIX, sizeof (TYPE));
+}
+  
+void
+round_64 (void)
+{
+  volatile TYPE x, a, b, c, d, e, f, g, h;
+  volatile int si;
+  volatile unsigned int ui;
+  volatile long long sll;
+  volatile unsigned long long ull;
+
+  TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000001, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000002, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000003, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000004, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000049, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000051, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000006, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000007, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000008, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000009, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000010, SUFFIX, sizeof (TYPE));
+
+  TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000001, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000002, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000003, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000004, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000049, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000051, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000006, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000007, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000008, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000009, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000010, SUFFIX, sizeof (TYPE));
+}
+
+#undef SUFFIX
+#define SUFFIX DL
+#undef TYPE
+#define TYPE _Decimal128
+  
+void
+zeroes_128 (void)
+{
+  volatile TYPE x, a, b, c, d, e, f, g, h;
+  volatile int si;
+  volatile unsigned int ui;
+  volatile long long sll;
+  volatile unsigned long long ull;
+
+  TESTVAL_NONNEG (0, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (5000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (9000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (50000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (90000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (100000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (500000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (900000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG (1000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (50000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (90000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (100000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (500000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (900000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (1000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (5000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NONNEG_BIG (9000000000000000000, SUFFIX, sizeof (TYPE));
+
+  TESTVAL_NEG (0, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-5000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-9000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-10000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-50000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-90000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-100000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-500000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-900000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG (-1000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-10000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-50000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-90000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-100000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-500000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-900000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-1000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-5000000000000000000, SUFFIX, sizeof (TYPE));
+  TESTVAL_NEG_BIG (-9000000000000000000, SUFFIX, sizeof (TYPE));
+}
+
+
+int
+main ()
+{
+  zeroes_32 ();
+  zeroes_64 ();
+  zeroes_128 ();
+  round_32 ();
+  round_64 ();
+
+  FINISH
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/signbit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/signbit-1.c
new file mode 100644
index 000000000..cde28f9ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/signbit-1.c
@@ -0,0 +1,50 @@
+/* { dg-options "-O0 -std=gnu99" } */
+
+/* Decimal float versions of __builtin_signbit.  */
+
+extern void abort (void);
+int failures;
+
+#ifdef DBG
+extern int printf (const char *, ...);
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failures++; }
+#else
+#define FAILURE abort ();
+#endif
+
+#define CHECK32(D,I) \
+  if ((__builtin_signbitd32 (D) != 0) != I) FAILURE
+
+#define CHECK64(D,I) \
+  if ((__builtin_signbitd64 (D) != 0) != I) FAILURE
+
+#define CHECK128(D,I) \
+  if ((__builtin_signbitd128 (D) != 0) != I) FAILURE
+
+/* Prevent the compiler from folding the calls at compile time.  */
+volatile _Decimal32 sd;
+volatile _Decimal64 dd;
+volatile _Decimal128 td;
+
+int
+main ()
+{
+  sd = 1.9df;  CHECK32 (sd, 0)
+  sd = -5.3df; CHECK32 (sd, 1)
+  sd = 0.0df;  CHECK32 (sd, 0)
+  sd = -0.0df; CHECK32 (sd, 1)
+
+  dd = 1.9dd;  CHECK64 (dd, 0)
+  dd = -5.3dd; CHECK64 (dd, 1)
+  dd = 0.0dd;  CHECK64 (dd, 0)
+  dd = -0.0dd; CHECK64 (dd, 1)
+
+  td = 1.9dl;  CHECK128 (td, 0)
+  td = -5.3dl; CHECK128 (td, 1)
+  td = 0.0dl;  CHECK128 (td, 0)
+  td = -0.0dl; CHECK128 (td, 1)
+
+  if (failures != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/signbit-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/signbit-2.c
new file mode 100644
index 000000000..6f9a2276b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/signbit-2.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O0 -std=gnu99" } */
+
+/* Check that the compiler uses builtins for signbit; if not the link
+   will fail because library functions are in libm.  */
+
+extern void abort (void);
+
+volatile _Decimal32 sd = 2.3df;
+volatile _Decimal64 dd = -4.5dd;
+volatile _Decimal128 tf = 5.3dl;
+volatile float f = 1.2f;
+volatile double d = -7.8;
+volatile long double ld = 3.4L;
+
+extern int signbitf (float);
+extern int signbit (double);
+extern int signbitl (long double);
+extern int signbitd32 (_Decimal32);
+extern int signbitd64 (_Decimal64);
+extern int signbitd128 (_Decimal128);
+
+int
+main ()
+{
+  if (signbitf (f) != 0) abort ();
+  if (signbit (d) == 0) abort ();
+  if (signbitl (ld) != 0) abort ();
+  if (signbitd32 (sd) != 0) abort ();
+  if (signbitd64 (dd) == 0) abort ();
+  if (signbitd128 (tf) != 0) abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/struct-layout-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/struct-layout-1.c
new file mode 100644
index 000000000..9e54e48c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/struct-layout-1.c
@@ -0,0 +1,91 @@
+/* { dg-options "-std=gnu99" } */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+struct S1
+{
+  _Decimal64 a[0];
+};
+
+struct S2
+{
+  struct
+  {
+    _Decimal64 e;
+  } b[0];
+};
+
+struct S3
+{
+  union
+  {
+    _Decimal64 c;
+  } a[0];
+};
+
+struct S4
+{
+  int a[0];
+  _Decimal64 b[0];
+};
+
+struct S5
+{
+  union
+  {
+    _Decimal64 c[0];
+  } a;
+};
+
+static int failcnt = 0;
+
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE do                             \
+{ printf ("failed at line %d\n", __LINE__);    \
+  failcnt++;                                   \
+}while(0)
+#else
+#define FAILURE abort ()
+#endif
+
+int check_var (int z, ...)
+{
+  long long result;
+  va_list ap;
+  va_start (ap, z);
+  va_arg (ap, struct S1);
+  result = va_arg (ap, long long);
+  va_end (ap);
+
+  return (result == 2LL);
+}
+
+int main ()
+{
+  struct S1 s1;
+  struct S2 s2;
+  struct S3 s3;
+  struct S4 s4;
+  struct S5 s5;
+
+  if (check_var (2, s1, 2LL) == 0)
+    FAILURE;
+  if (check_var (2, s2, 2LL) == 0)
+    FAILURE;
+  if (check_var (2, s3, 2LL) == 0)
+    FAILURE;
+  if (check_var (2, s4, 2LL) == 0)
+    FAILURE;
+  if (check_var (2, s5, 2LL) == 0)
+    FAILURE;
+
+  if (failcnt)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/struct-union.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/struct-union.c
new file mode 100644
index 000000000..88589260c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/struct-union.c
@@ -0,0 +1,62 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+/* C99 6.5.2.3 Structure and union members.
+   If the first expression has qualified type, the result has the so-qualified 
+   version of the type of the designated member.  */
+
+struct s {_Decimal32 d32; const _Decimal64 d64;};
+struct sv { volatile _Decimal32 d32; volatile _Decimal64 d64; };
+union u 
+{
+  const _Decimal64 d64; 
+  _Decimal32 d32; 
+  const struct s cs;
+};
+
+struct s s;
+struct sv sv;
+const struct s cs;
+
+union u u;
+const union u cu;
+
+struct s g (struct s s)
+{
+  return s;
+}
+
+union u h (union u u)
+{
+  return u;
+}
+
+void f()
+{
+  cs.d32 = 1.23dd; /* { dg-error "assignment of read-only variable" } */
+  cs.d64 = 1.23df; /* { dg-error "assignment of read-only variable" } */
+  s.d64 = 1.23df;  /* { dg-error "assignment of read-only member" } */
+
+  s.d32 = 1.23dd;
+  u.d32 = 1.23dd;
+
+  u.d64 = 1.23df;    /* { dg-error "assignment of read-only member" } */
+  u.cs.d32 = 1.23dd; /* { dg-error "assignment of read-only member" } */
+  u.cs.d64 = 1.23df; /* { dg-error "assignment of read-only member" } */
+  
+  cu.d32 = 1.23dd;   /* { dg-error "assignment of read-only variable" } */
+
+  cu.d64 = 1.23df;    /* { dg-error "assignment of read-only variable" } */
+  cu.cs.d32 = 1.23dd; /* { dg-error "assignment of read-only variable" } */
+  cu.cs.d64 = 1.23df; /* { dg-error "assignment of read-only variable" } */
+
+  /* f().x is a valid postfix expression but is not an lvalue if 
+     function f() returning a structure or union.  */
+  g(s).d32 = 1.23dd;  /* { dg-error "lvalue required" } */
+  h(u).d64 = 1.23df;  /* { dg-error "lvalue required" } */
+
+  /* Test assignment to volatile structure members.  */
+  sv.d32 = 1.1df;
+  sv.d64 = 1.1dd;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/typespec.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/typespec.c
new file mode 100644
index 000000000..c7fc343ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/typespec.c
@@ -0,0 +1,303 @@
+/* Test for valid and invalid combinations of type specifiers.
+   Based off gcc.dg/test-spec-1.c */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef char type;
+void _Decimal32 *x0;  /* { dg-error "" "void _Decimal32" } */
+void _Decimal64 *x1;  /* { dg-error "" "void _Decimal64" } */
+void _Decimal128 *x2; /* { dg-error "" "void _Decimal128" } */
+char _Decimal32 *x3;  /* { dg-error "" "char _Decimal32" } */
+char _Decimal64 *x4;  /* { dg-error "" "char _Decimal64" } */
+char _Decimal128 *x5;  /* { dg-error "" "char _Decimal128" } */
+short _Decimal32 *x6; /* { dg-error "" "short _Decimal32" } */
+short _Decimal64 *x7; /* { dg-error "" "short _Decimal64" } */
+short _Decimal128 *x8; /* { dg-error "" "short _Decimal128" } */
+int _Decimal32 *x9;   /* { dg-error "" "int _Decimal32" } */
+int _Decimal64 *x10;  /* { dg-error "" "int _Decimal64" } */
+int _Decimal128 *x11; /* { dg-error "" "int _Decimal128" } */
+long _Decimal32 *x12;   /* { dg-error "" "long _Decimal32" } */
+long _Decimal64 *x13;  /* { dg-error "" "long _Decimal64" } */
+long _Decimal128 *x14; /* { dg-error "" "long _Decimal128" } */
+float _Decimal32 *x15;   /* { dg-error "" "float _Decimal32" } */
+float _Decimal64 *x16;  /* { dg-error "" "float _Decimal64" } */
+float _Decimal128 *x17; /* { dg-error "" "float _Decimal128" } */
+double _Decimal32 *x18;   /* { dg-error "" "double _Decimal32" } */
+double _Decimal64 *x19;  /* { dg-error "" "double _Decimal64" } */
+double _Decimal128 *x20; /* { dg-error "" "double _Decimal128" } */
+signed _Decimal32 *x21;   /* { dg-error "" "signed _Decimal32" } */
+signed _Decimal64 *x22;  /* { dg-error "" "signed _Decimal64" } */
+signed _Decimal128 *x23; /* { dg-error "" "signed _Decimal128" } */
+_Bool _Decimal32 *x24;   /* { dg-error "" "_Bool _Decimal32" } */
+_Bool _Decimal64 *x25;  /* { dg-error "" "_Bool _Decimal64" } */
+_Bool _Decimal128 *x26; /* { dg-error "" "_Bool _Decimal128" } */
+int _Decimal32 *x27;   /* { dg-error "" "int _Decimal32" } */
+int _Decimal64 *x28;  /* { dg-error "" "int _Decimal64" } */
+int _Decimal128 *x29; /* { dg-error "" "int _Decimal128" } */
+type _Decimal32 *x30;   /* { dg-error "" "type _Decimal32" } */
+type _Decimal64 *x31;  /* { dg-error "" "type _Decimal64" } */
+type _Decimal128 *x32; /* { dg-error "" "type _Decimal128" } */
+char signed _Decimal32 *x33;  /* { dg-error "" "char signed _Decimal32" } */
+char signed _Decimal64 *x34;  /* { dg-error "" "char signed _Decimal64" } */
+char signed _Decimal128 *x35; /* { dg-error "" "char signed _Decimal128" } */
+char unsigned _Decimal32 *x36; /* { dg-error "" "char unsigned _Decimal32" } */
+char unsigned _Decimal64 *x37; /* { dg-error "" "char unsigned _Decimal64" } */
+char unsigned _Decimal128 *x38; /* { dg-error "" "char unsigned _Decimal128" } */
+short _Decimal32 *x39;  /* { dg-error "" "short _Decimal32" } */
+short _Decimal64 *x40;  /* { dg-error "" "short _Decimal64" } */
+short _Decimal128 *x41; /* { dg-error "" "short _Decimal128" } */
+short signed _Decimal32 *x42;  /* { dg-error "" "short signed _Decimal32" } */
+short signed _Decimal64 *x43;  /* { dg-error "" "short signed _Decimal64" } */
+short signed _Decimal128 *x44; /* { dg-error "" "short signed _Decimal128" } */
+short unsigned _Decimal32 *x45;  /* { dg-error "" "short unsigned _Decimal32" } */
+short unsigned _Decimal64 *x46;  /* { dg-error "" "short unsigned _Decimal64" } */
+short unsigned _Decimal128 *x47; /* { dg-error "" "short unsigned _Decimal128" } */
+_Decimal32 short*x48;  /* { dg-error "" "_Decimal32 short" } */
+_Decimal64 short*x49;  /* { dg-error "" "_Decimal64 short" } */
+_Decimal128 short*x50; /* { dg-error "" "_Decimal128 short" } */
+_Decimal32 short signed*x51;  /* { dg-error "" "_Decimal32 short signed" } */
+_Decimal64 short signed*x52;  /* { dg-error "" "_Decimal64 short signed" } */
+_Decimal128 short signed*x53; /* { dg-error "" "_Decimal128 short signed" } */
+_Decimal32 short unsigned*x54;  /* { dg-error "" "_Decimal32 short unsigned" } */
+_Decimal64 short unsigned*x55;  /* { dg-error "" "_Decimal64 short unsigned" } */
+_Decimal128 short unsigned*x56; /* { dg-error "" "_Decimal128 short unsigned" } */
+_Decimal32 long*x57;  /* { dg-error "" "_Decimal32 long" } */
+_Decimal64 long*x58;  /* { dg-error "" "_Decimal64 long" } */
+_Decimal128 long*x59; /* { dg-error "" "_Decimal128 long" } */
+_Decimal32 long signed*x60;  /* { dg-error "" "_Decimal32 long signed" } */
+_Decimal64 long signed*x61;  /* { dg-error "" "_Decimal64 long signed" } */
+_Decimal128 long signed*x62; /* { dg-error "" "_Decimal128 long signed" } */
+_Decimal32 long unsigned*x63;  /* { dg-error "" "_Decimal32 long unsigned" } */
+_Decimal64 long unsigned*x64;  /* { dg-error "" "_Decimal64 long unsigned" } */
+_Decimal128 long unsigned*x65; /* { dg-error "" "_Decimal128 long unsigned" } */
+_Decimal32 signed long*x66;  /* { dg-error "" "_Decimal32 signed long" } */
+_Decimal64 signed long*x67;  /* { dg-error "" "_Decimal64 signed long" } */
+_Decimal128 signed long*x68; /* { dg-error "" "_Decimal128 signed long" } */
+_Decimal32 signed short*x69;  /* { dg-error "" "_Decimal32 signed short" } */
+_Decimal64 signed short*x70;  /* { dg-error "" "_Decimal64 signed short" } */
+_Decimal128 signed short*x71; /* { dg-error "" "_Decimal128 signed short" } */
+int signed _Decimal32 *x72;  /* { dg-error "" "int signed _Decimal32" } */
+int signed _Decimal64 *x73;  /* { dg-error "" "int signed _Decimal64" } */
+int signed _Decimal128 *x74;  /* { dg-error "" "int signed _Decimal128" } */
+int unsigned _Decimal32 *x75;  /* { dg-error "" "int unsigned _Decimal32" } */
+int unsigned _Decimal64 *x76;  /* { dg-error "" "int unsigned _Decimal64" } */
+int unsigned _Decimal128 *x77; /* { dg-error "" "int unsigned _Decimal128" } */
+long int _Decimal32 *x78;  /* { dg-error "" "long int _Decimal32" } */
+long int _Decimal64 *x79;  /* { dg-error "" "long int _Decimal64" } */
+long int _Decimal128 *x80; /* { dg-error "" "long int _Decimal128" } */
+long long _Decimal32 *x81;  /* { dg-error "" "long long _Decimal32" } */
+long long _Decimal64 *x82;  /* { dg-error "" "long long _Decimal64" } */
+long long _Decimal128 *x83; /* { dg-error "" "long long _Decimal128" } */
+long double _Decimal32 *x84;  /* { dg-error "" "long double _Decimal32" } */
+long double _Decimal64 *x85;  /* { dg-error "" "long double _Decimal64" } */
+long double _Decimal128 *x86; /* { dg-error "" "long double _Decimal128" } */
+long signed _Decimal32 *x87;  /* { dg-error "" "long signed _Decimal32" } */
+long signed _Decimal64 *x88;  /* { dg-error "" "long signed _Decimal64" } */
+long signed _Decimal128 *x89; /* { dg-error "" "long signed _Decimal128" } */
+long unsigned _Decimal32 *x90;  /* { dg-error "" "long unsigned _Decimal32" } */
+long unsigned _Decimal64 *x91;  /* { dg-error "" "long unsigned _Decimal64" } */
+long unsigned _Decimal128 *x92; /* { dg-error "" "long unsigned _Decimal128" } */
+double long _Decimal32 *x93;  /* { dg-error "" "double long _Decimal32" } */
+double long _Decimal64 *x94;  /* { dg-error "" "double long _Decimal64" } */
+double long _Decimal128 *x95; /* { dg-error "" "double long _Decimal128" } */
+signed char _Decimal32 *x96;   /* { dg-error "" "signed char _Decimal32" } */
+signed char _Decimal64 *x97;  /* { dg-error "" "signed char _Decimal64" } */
+signed char _Decimal128 *x98; /* { dg-error "" "signed char _Decimal128" } */
+signed short _Decimal32 *x99;   /* { dg-error "" "signed short _Decimal32" } */
+signed short _Decimal64 *x100;  /* { dg-error "" "signed short _Decimal64" } */
+signed short _Decimal128 *x101; /* { dg-error "" "signed short _Decimal128" } */
+signed int _Decimal32 *x102;  /* { dg-error "" "signed int _Decimal32" } */
+signed int _Decimal64 *x103;  /* { dg-error "" "signed int _Decimal64" } */
+signed int _Decimal128 *x104; /* { dg-error "" "signed int _Decimal128" } */
+signed long _Decimal32 *105x; /* { dg-error "" "signed long _Decimal32" } */
+signed long _Decimal64 *x107; /* { dg-error "" "signed long _Decimal64" } \*/
+signed long _Decimal128 *x107; /* { dg-error "" "signed long _Decimal128" } \*/
+unsigned char _Decimal32 *x108; /* { dg-error "" "unsigned char _Decimal32" } */
+unsigned char _Decimal64 *x109; /* { dg-error "" "unsigned char _Decimal64" } */
+unsigned char _Decimal128 *x110; /* { dg-error "" "unsigned char _Decimal128" } */
+unsigned short _Decimal32 *x111; /* { dg-error "" "unsigned short _Decimal32" } */
+unsigned short _Decimal64 *x112; /* { dg-error "" "unsigned short _Decimal64" } */
+unsigned short _Decimal128 *x113; /* { dg-error "" "unsigned short _Decimal128" } */
+unsigned int _Decimal32 *x114; /* { dg-error "" "unsigned int _Decimal32" } */
+unsigned int _Decimal64 *x115; /* { dg-error "" "unsigned int _Decimal64" } */
+unsigned int _Decimal128 *x116; /* { dg-error "" "unsigned int _Decimal128" } */
+unsigned long _Decimal32 *x117; /* { dg-error "" "unsigned long _Decimal32" } */
+unsigned long _Decimal64 *x118; /* { dg-error "" "unsigned long _Decimal64" } */
+unsigned long _Decimal128 *x119; /* { dg-error "" "unsigned long _Decimal128" } */
+short int signed _Decimal32 *x120; /* { dg-error "" "short int signed _Decimal32" } */
+short int signed _Decimal64 *x121; /* { dg-error "" "short int signed _Decimal64" } */
+short int signed _Decimal128 *x122; /* { dg-error "" "short int signed _Decimal128" } */
+short int unsigned _Decimal32 *x123; /* { dg-error "" "short int unsigned _Decimal32" } */
+short int unsigned _Decimal64 *x124; /* { dg-error "" "short int unsigned _Decimal64" } */
+short int unsigned _Decimal128 *x125; /* { dg-error "" "short int unsigned _Decimal128" } */
+short signed int _Decimal32 *x126; /* { dg-error "" "short signed int _Decimal32" } */
+short signed int _Decimal64 *x127; /* { dg-error "" "short signed int _Decimal64" } */
+short signed int _Decimal128 *x128; /* { dg-error "" "short signed int _Decimal128" } */
+short unsigned int _Decimal32 *x129; /* { dg-error "" "short unsigned int _Decimal32" } */
+short unsigned int _Decimal64 *x130; /* { dg-error "" "short unsigned int _Decimal64" } */
+short unsigned int _Decimal128 *x131; /* { dg-error "" "short unsigned int _Decimal128" } */
+int short signed _Decimal32 *x132; /* { dg-error "" "int short signed _Decimal32" } */
+int short signed _Decimal64 *x133; /* { dg-error "" "int short signed _Decimal64" } */
+int short signed _Decimal128 *x134; /* { dg-error "" "int short signed _Decimal128" } */
+int short unsigned _Decimal32 *x135; /* { dg-error "" "int short unsigned _Decimal32" } */
+int short unsigned _Decimal64 *x136; /* { dg-error "" "int short unsigned _Decimal64" } */
+int short unsigned _Decimal128 *x137; /* { dg-error "" "int short unsigned _Decimal128" } */
+int long long _Decimal32 *x138; /* { dg-error "" "int long long _Decimal32" } */
+int long long _Decimal64 *x139; /* { dg-error "" "int long long _Decimal64" } */
+int long long _Decimal128 *x140; /* { dg-error "" "int long long _Decimal128" } */
+int long signed _Decimal32 *x141; /* { dg-error "" "int long signed _Decimal32" } */
+int long signed _Decimal64 *x142; /* { dg-error "" "int long signed _Decimal64" } */
+int long signed _Decimal128 *x143; /* { dg-error "" "int long signed _Decimal128" } */
+int long unsigned _Decimal32 *x144; /* { dg-error "" "int long unsigned _Decimal32" } */
+int long unsigned _Decimal64 *x145; /* { dg-error "" "int long unsigned _Decimal64" } */
+int long unsigned _Decimal128 *x146; /* { dg-error "" "int long unsigned _Decimal128" } */
+int signed short _Decimal32 *x147; /* { dg-error "" "int signed short _Decimal32" } */
+int signed short _Decimal64 *x148; /* { dg-error "" "int signed short _Decimal64" } */
+int signed short _Decimal128 *x149; /* { dg-error "" "int signed short _Decimal128" } */
+int signed long _Decimal32 *x150; /* { dg-error "" "int signed long _Decimal32" } */
+int signed long _Decimal64 *x151; /* { dg-error "" "int signed long _Decimal64" } */
+int signed long _Decimal128 *x152; /* { dg-error "" "int signed long _Decimal128" } */
+int unsigned short _Decimal32 *x153; /* { dg-error "" "int unsigned short _Decimal32" } */
+int unsigned short _Decimal64 *x154; /* { dg-error "" "int unsigned short _Decimal64" } */
+int unsigned short _Decimal128 *x155; /* { dg-error "" "int unsigned short _Decimal128" } */
+int unsigned long _Decimal32 *x156; /* { dg-error "" "int unsigned long _Decimal32" } */
+int unsigned long _Decimal64 *x157; /* { dg-error "" "int unsigned long _Decimal64" } */
+int unsigned long _Decimal128 *x158; /* { dg-error "" "int unsigned long _Decimal128" } */
+long int long _Decimal32 *x159; /* { dg-error "" "long int long _Decimal32" } */
+long int long _Decimal64 *x160; /* { dg-error "" "long int long _Decimal64" } */
+long int long _Decimal128 *x161; /* { dg-error "" "long int long _Decimal128" } */
+long int signed _Decimal32 *x162; /* { dg-error "" "long int signed _Decimal32" } */
+long int signed _Decimal64 *x163; /* { dg-error "" "long int signed _Decimal64" } */
+long int signed _Decimal128 *x164; /* { dg-error "" "long int signed _Decimal128" } */
+long int unsigned _Decimal32 *x165; /* { dg-error "" "long int unsigned _Decimal32" } */
+long int unsigned _Decimal64 *x166; /* { dg-error "" "long int unsigned _Decimal64" } */
+long int unsigned _Decimal128 *x167; /* { dg-error "" "long int unsigned _Decimal128" } */
+long long int _Decimal32 *x168; /* { dg-error "" "long long int _Decimal32" } */
+long long int _Decimal64 *x169; /* { dg-error "" "long long int _Decimal64" } */
+long long int _Decimal128 *x170; /* { dg-error "" "long long int _Decimal128" } */
+long long signed _Decimal32 *x171; /* { dg-error "" "long long signed _Decimal32" } */
+long long signed _Decimal64 *x172; /* { dg-error "" "long long signed _Decimal64" } */
+long long signed _Decimal128 *x172; /* { dg-error "" "long long signed _Decimal128" } */
+long long unsigned _Decimal32 *x175; /* { dg-error "" "long long unsigned _Decimal32" } */
+long long unsigned _Decimal64 *x176; /* { dg-error "" "long long unsigned _Decimal64" } */
+long long unsigned _Decimal128 *x177; /* { dg-error "" "long long unsigned _Decimal128" } */
+long signed int _Decimal32 *x178; /* { dg-error "" "long signed int _Decimal32" } */
+long signed int _Decimal64 *x179; /* { dg-error "" "long signed int _Decimal64" } */
+long signed int _Decimal128 *x180; /* { dg-error "" "long signed int _Decimal128" } */
+long unsigned int _Decimal32 *x181; /* { dg-error "" "long unsigned int _Decimal32" } */
+long unsigned int _Decimal64 *x182; /* { dg-error "" "long unsigned int _Decimal64" } */
+long unsigned int _Decimal128 *x183; /* { dg-error "" "long unsigned int _Decimal128" } */
+long unsigned long _Decimal32 *x184; /* { dg-error "" "long unsigned long _Decimal32" } */
+long unsigned long _Decimal64 *x185; /* { dg-error "" "long unsigned long _Decimal64" } */
+long unsigned long _Decimal128 *x186; /* { dg-error "" "long unsigned long _Decimal128" } */
+signed short int _Decimal32 *x187; /* { dg-error "" "signed short int _Decimal32" } */
+signed short int _Decimal64 *x188; /* { dg-error "" "signed short int _Decimal64" } */
+signed short int _Decimal128 *x189; /* { dg-error "" "signed short int _Decimal128" } */
+signed int short _Decimal32 *x190; /* { dg-error "" "signed int short _Decimal32" } */
+signed int short _Decimal64 *x191; /* { dg-error "" "signed int short _Decimal64" } */
+signed int short _Decimal128 *x191; /* { dg-error "" "signed int short _Decimal128" } */
+signed int long _Decimal32 *x192; /* { dg-error "" "signed int long _Decimal32" } */
+signed int long _Decimal64 *x193; /* { dg-error "" "signed int long _Decimal64" } */
+signed int long _Decimal128 *x194; /* { dg-error "" "signed int long _Decimal128" } */
+signed long int _Decimal32 *x195; /* { dg-error "" "signed long int _Decimal32" } */
+signed long int _Decimal64 *x196; /* { dg-error "" "signed long int _Decimal64" } */
+signed long int _Decimal128 *x197; /* { dg-error "" "signed long int _Decimal128" } */
+signed long long _Decimal32 *x198; /* { dg-error "" "signed long long _Decimal32" } */
+signed long long _Decimal64 *x199; /* { dg-error "" "signed long long _Decimal64" } */
+signed long long _Decimal128 *x200; /* { dg-error "" "signed long long _Decimal128" } */
+unsigned short int _Decimal32 *x201; /* { dg-error "" "unsigned short int _Decimal32" } */
+unsigned short int _Decimal64 *x202; /* { dg-error "" "unsigned short int _Decimal64" } */
+unsigned short int _Decimal128 *x203; /* { dg-error "" "unsigned short int _Decimal128" } */
+unsigned int short _Decimal32 *x204; /* { dg-error "" "unsigned int short _Decimal32" } */
+unsigned int short _Decimal64 *x205; /* { dg-error "" "unsigned int short _Decimal64" } */
+unsigned int short _Decimal128 *x206; /* { dg-error "" "unsigned int short _Decimal128" } */
+unsigned int long _Decimal32 *x207; /* { dg-error "" "unsigned int long _Decimal32" } */
+unsigned int long _Decimal64 *x208; /* { dg-error "" "unsigned int long _Decimal64" } */
+unsigned int long _Decimal128 *x209; /* { dg-error "" "unsigned int long _Decimal128" } */
+unsigned long int _Decimal32 *x210; /* { dg-error "" "unsigned long int _Decimal32" } */
+unsigned long int _Decimal64 *x211; /* { dg-error "" "unsigned long int _Decimal64" } */
+unsigned long int _Decimal128 *x212; /* { dg-error "" "unsigned long int _Decimal128" } */
+unsigned long long _Decimal32 *x213; /* { dg-error "" "unsigned long long _Decimal32" } */
+unsigned long long _Decimal64 *x214; /* { dg-error "" "unsigned long long _Decimal64" } */
+unsigned long long _Decimal128 *x215; /* { dg-error "" "unsigned long long _Decimal128" } */
+int long long signed _Decimal32 *x216; /* { dg-error "" "int long long signed _Decimal32" } */
+int long long signed _Decimal64 *x217; /* { dg-error "" "int long long signed _Decimal64" } */
+int long long signed _Decimal128 *x218; /* { dg-error "" "int long long signed _Decimal128" } */
+int long long unsigned _Decimal32 *x219; /* { dg-error "" "int long long unsigned _Decimal32" } */
+int long long unsigned _Decimal64 *x220; /* { dg-error "" "int long long unsigned _Decimal64" } */
+int long long unsigned _Decimal128 *x221; /* { dg-error "" "int long long unsigned _Decimal128" } */
+int long signed long _Decimal32 *x222; /* { dg-error "" "int long signed long _Decimal32" } */
+int long signed long _Decimal64 *x223; /* { dg-error "" "int long signed long _Decimal64" } */
+int long signed long _Decimal128 *x224; /* { dg-error "" "int long signed long _Decimal128" } */
+int long unsigned long _Decimal32 *x226; /* { dg-error "" "int long unsigned long _Decimal32" } */
+int long unsigned long _Decimal64 *x227; /* { dg-error "" "int long unsigned long _Decimal64" } */
+int long unsigned long _Decimal128 *x228; /* { dg-error "" "int long unsigned long _Decimal128" } */
+int signed long long _Decimal32 *x229; /* { dg-error "" "int signed long long _Decimal32" } */
+int signed long long _Decimal64 *x230; /* { dg-error "" "int signed long long _Decimal64" } */
+int signed long long _Decimal128 *x231; /* { dg-error "" "int signed long long _Decimal128" } */
+int unsigned long long _Decimal32 *x232; /* { dg-error "" "int unsigned long long _Decimal32" } */
+int unsigned long long _Decimal64 *x233; /* { dg-error "" "int unsigned long long _Decimal64" } */
+int unsigned long long _Decimal128 *x234; /* { dg-error "" "int unsigned long long _Decimal128" } */
+long int long signed _Decimal32 *x235; /* { dg-error "" "long int long signed _Decimal32" } */
+long int long signed _Decimal64 *x236; /* { dg-error "" "long int long signed _Decimal64" } */
+long int long signed _Decimal128 *x237; /* { dg-error "" "long int long signed _Decimal128" } */
+long int long unsigned _Decimal32 *x238; /* { dg-error "" "long int long unsigned _Decimal32" } */
+long int long unsigned _Decimal64 *x239; /* { dg-error "" "long int long unsigned _Decimal64" } */
+long int long unsigned _Decimal128 *x240; /* { dg-error "" "long int long unsigned _Decimal128" } */
+long int signed long _Decimal32 *x241; /* { dg-error "" "long int signed long _Decimal32" } */
+long int signed long _Decimal64 *x242; /* { dg-error "" "long int signed long _Decimal64" } */
+long int signed long _Decimal128 *x243; /* { dg-error "" "long int signed long _Decimal128" } */
+long int unsigned long _Decimal32 *x244; /* { dg-error "" "long int unsigned long _Decimal32" } */
+long int unsigned long _Decimal64 *x245; /* { dg-error "" "long int unsigned long _Decimal64" } */
+long int unsigned long _Decimal128 *x246; /* { dg-error "" "long int unsigned long _Decimal128" } */
+long long int signed _Decimal32 *x247; /* { dg-error "" "long long int signed _Decimal32" } */
+long long int signed _Decimal64 *x248; /* { dg-error "" "long long int signed _Decimal64" } */
+long long int signed _Decimal128 *x249; /* { dg-error "" "long long int signed _Decimal128" } */
+long long int unsigned _Decimal32 *x250; /* { dg-error "" "long long int unsigned _Decimal32" } */
+long long int unsigned _Decimal64 *x251; /* { dg-error "" "long long int unsigned _Decimal64" } */
+long long int unsigned _Decimal128 *x252; /* { dg-error "" "long long int unsigned _Decimal128" } */
+long long signed int _Decimal32 *x253; /* { dg-error "" "long long signed int _Decimal32" } */
+long long signed int _Decimal64 *x254; /* { dg-error "" "long long signed int _Decimal64" } */
+long long signed int _Decimal128 *x255; /* { dg-error "" "long long signed int _Decimal128" } */
+long long unsigned int _Decimal32 *x256; /* { dg-error "" "long long unsigned int _Decimal32" } */
+long long unsigned int _Decimal64 *x257; /* { dg-error "" "long long unsigned int _Decimal64" } */
+long long unsigned int _Decimal128 *x258; /* { dg-error "" "long long unsigned int _Decimal128" } */
+long signed int long _Decimal32 *x259; /* { dg-error "" "long signed int long _Decimal32" } */
+long signed int long _Decimal64 *x260; /* { dg-error "" "long signed int long _Decimal64" } */
+long signed int long _Decimal128 *x261; /* { dg-error "" "long signed int long _Decimal128" } */
+long signed long int _Decimal32 *x262; /* { dg-error "" "long signed long int _Decimal32" } */
+long signed long int _Decimal64 *x263; /* { dg-error "" "long signed long int _Decimal64" } */
+long signed long int _Decimal128 *x264; /* { dg-error "" "long signed long int _Decimal128" } */
+long unsigned int long _Decimal32 *x265; /* { dg-error "" "long unsigned int long _Decimal32" } */
+long unsigned int long _Decimal64 *x266; /* { dg-error "" "long unsigned int long _Decimal64" } */
+long unsigned int long _Decimal128 *x267; /* { dg-error "" "long unsigned int long _Decimal128" } */
+long unsigned long int _Decimal32 *x268; /* { dg-error "" "long unsigned long int _Decimal32" } */
+long unsigned long int _Decimal64 *x269; /* { dg-error "" "long unsigned long int _Decimal64" } */
+long unsigned long int _Decimal128 *x270; /* { dg-error "" "long unsigned long int _Decimal128" } */
+signed long long int _Decimal32 *x271; /* { dg-error "" "signed long long int _Decimal32" } */
+signed long long int _Decimal64 *x272; /* { dg-error "" "signed long long int _Decimal64" } */
+signed long long int _Decimal128 *x273; /* { dg-error "" "signed long long int _Decimal128" } */
+unsigned int long long _Decimal32 *x274; /* { dg-error "" "unsigned int long long _Decimal32" } */
+unsigned int long long _Decimal64 *x275; /* { dg-error "" "unsigned int long long _Decimal64" } */
+unsigned int long long _Decimal128 *x276; /* { dg-error "" "unsigned int long long _Decimal128" } */
+unsigned long int long _Decimal32 *x277; /* { dg-error "" "unsigned long int long _Decimal32" } */
+unsigned long int long _Decimal64 *x278; /* { dg-error "" "unsigned long int long _Decimal64" } */
+unsigned long int long _Decimal128 *x279; /* { dg-error "" "unsigned long int long _Decimal128" } */
+unsigned long long int _Decimal32 *x280; /* { dg-error "" "unsigned long long int _Decimal32" } */
+unsigned long long int _Decimal64 *x281; /* { dg-error "" "unsigned long long int _Decimal64" } */
+unsigned long long int _Decimal128 *x282; /* { dg-error "" "unsigned long long int _Decimal128" } */
+
+_Complex _Decimal32 *x283; /* { dg-error "" "_Complex _Decimal32" } */
+_Complex _Decimal64 *x284; /* { dg-error "" "_Complex _Decimal64" } */
+_Complex _Decimal128 *x285; /* { dg-error "" "_Complex _Decimal128" } */
+
+_Decimal32 _Complex *x286; /* { dg-error "" "_Decimal32 _Complex" } */
+_Decimal64 _Complex *x287; /* { dg-error "" "_Decimal64 _Complex" } */
+_Decimal128 _Complex *x288; /* { dg-error "" "_Decimal128 _Complex" } */
+
+unsigned _Decimal32 *x289; /* { dg-error "" "unsigned _Decimal32" } */
+unsigned _Decimal64 *x290; /* { dg-error "" "unsigned _Decimal64" } */
+unsigned _Decimal128 *x291; /* { dg-error "" "unsigned _Decimal128" } */
+signed _Decimal32 *x292; /* { dg-error "" "signed _Decimal32" } */
+signed _Decimal64 *x293; /* { dg-error "" "signed _Decimal64" } */
+signed _Decimal128 *x294; /* { dg-error "" "signed _Decimal128" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/union-init.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/union-init.c
new file mode 100644
index 000000000..fede76ba3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/union-init.c
@@ -0,0 +1,60 @@
+/* { dg-options "-std=gnu99" } */
+
+/* Cast to union is a GNU C extension.  */
+
+extern void abort (void);
+
+union u
+{
+  _Decimal128 d128;
+  double d;
+};
+
+union n
+{
+  double d;
+  _Decimal64 d64;
+};
+
+int main ()
+{
+  static union u u1 = { 0.0dl };
+  static union u u2 = { 4.2dl };
+  static union u u4 = { 0.0 };
+
+  static union n n1 = { 2.2dd };
+  static union n n2 = { 3.25 };
+
+  _Decimal128 d128;
+  _Decimal64 d64;
+  double d;
+  
+  if (u1.d128 != 0.0dl)
+    abort ();
+
+  if (u2.d128 != 4.2dl)
+    abort ();
+
+  /* cast decimal floating point to union type.  */
+  d128 = 1.23dl;
+  d64 = 4.56dd;
+  d = 3.25;
+
+  u4 = (union u) d128;
+  if (u4.d128 != 1.23dl)
+    abort ();
+  
+  u4 = (union u) d;
+  if (u4.d != 3.25)
+    abort ();
+
+  n1 = (union n) d64;
+  if (n1.d64 != 4.56dd)
+    abort ();
+  
+  n1 = (union n)d;
+  if (n1.d != 3.25)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-bad-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-bad-2.c
new file mode 100644
index 000000000..4693abc90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-bad-2.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* This used to result in an ICE.  */
+
+extern _Decimal64 x;
+extern int i;
+
+void
+foo (void)
+{
+  if (x <= 2.0)		/* { dg-error "mix operands" } */
+    i++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-bad.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-bad.c
new file mode 100644
index 000000000..e4033ca50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-bad.c
@@ -0,0 +1,50 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1150 5.4: Usual arithmetic conversions.
+   C99 6.3.1.8[1] (New).
+
+   Test arithmetic operators between decimal float types and generic
+   float types, which are not allowed.  */
+
+extern _Decimal32 d32a, d32b;
+extern _Decimal64 d64a, d64b;
+extern _Decimal128 d128a, d128b;
+extern float f;
+extern double d;
+extern long double ld;
+
+extern signed int __attribute__ ((vector_size (16))) vi;
+
+extern _Complex float cf;
+extern _Complex double cd;
+extern _Complex long double cld;
+extern _Complex int ci;
+
+void
+foo (void)
+{
+  /* Mixed operations with decimal and generic float operands.  */
+  d32a = d32b + f;	/* { dg-error "" "error.*mix operands of decimal float" } */
+  d32a = f * d32b;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d32a *= f;		/* { dg-error "" "error.* mix operands of decimal float" } */
+  f += d32b;		/* { dg-error "" "error.* mix operands of decimal float" } */
+  d64a = d32a + d;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d64a = d * d128a;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d64a -= d;		/* { dg-error "" "error.* mix operands of decimal float" } */
+  d128a = ld * d128b;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d128a = d64b + d;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d128a *= f;		/* { dg-error "" "error.* mix operands of decimal float" } */
+
+  /* Mixed operations with decimal float and a vector type.  */
+  d64a = d64b + vi;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d32a *= vi;		/* { dg-error "" "error.* mix operands of decimal float" } */
+  d128a = vi - d128b;	/* { dg-error "" "error.* mix operands of decimal float" } */
+
+  /* Mixed operations with decimal float and Complex types.  */
+  d32a += ci;		/* { dg-error "" "error.* mix operands of decimal float" } */
+  d64a = ci * d32a;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  cd = d64a * cd;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d128b = cld * d128b;	/* { dg-error "" "error.* mix operands of decimal float" } */
+  d32a = cf * d32b;	/* { dg-error "" "error.* mix operands of decimal float" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-const.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-const.c
new file mode 100644
index 000000000..3f06e4753
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv-const.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* Test various conversions involving decimal floating types. */
+
+/* Assertion that constant C is of type T.  */
+#define ASSERT_CONST_TYPE(C, T)                 \
+        do {                                    \
+          typedef T type;                       \
+          typedef type **typepp;                \
+          typedef __typeof__((C)) ctype;        \
+          typedef ctype **ctypepp;              \
+          typepp x = 0;                         \
+          ctypepp y = 0;                        \
+          x = y;                                \
+          y = x;                                \
+        } while (0)
+
+int
+main ()
+{
+  ASSERT_CONST_TYPE (3 + 2.1df, _Decimal32); /* { dg-bogus "assignment from incompatible pointer type" } */
+  ASSERT_CONST_TYPE (1.3df + 2, _Decimal32); /* { dg-bogus "assignment from incompatible pointer type" } */
+  ASSERT_CONST_TYPE (56U - 55.0dd, _Decimal64); /* { dg-bogus "assignment from incompatible pointer type" } */
+  ASSERT_CONST_TYPE (5 * .2DL, _Decimal128); /* { dg-bogus "assignment from incompatible pointer type" } */
+  ASSERT_CONST_TYPE (.88dl / 2L, _Decimal128); /* { dg-bogus "assignment from incompatible pointer type" } */
+  ASSERT_CONST_TYPE (.114df - 1.6dd, _Decimal64); /* { dg-bogus "assignment from incompatible pointer type" } */
+  ASSERT_CONST_TYPE (3L - 1 + .55df, _Decimal32); /* { dg-bogus "assignment from incompatible pointer type" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv.c
new file mode 100644
index 000000000..584058b8c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/usual-arith-conv.c
@@ -0,0 +1,127 @@
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* N1150 5.4: Usual arithmetic conversions.
+   C99 6.3.1.8[1] (New).
+
+   Test arithmetic operators with different decimal float types, and
+   between decimal float types and integer types.  */
+
+extern void abort (void);
+static int failcnt = 0;
+                                                                                
+/* Support compiling the test to report individual failures; default is
+   to abort as soon as a check fails.  */
+#ifdef DBG
+#include <stdio.h>
+#define FAILURE { printf ("failed at line %d\n", __LINE__); failcnt++; }
+#else
+#define FAILURE abort ();
+#endif
+
+volatile _Decimal32 d32a, d32b, d32c;
+volatile _Decimal64 d64a, d64b, d64c;
+volatile _Decimal128 d128a, d128b, d128c;
+volatile int i;
+
+void
+init ()
+{
+  d32b = 123.456e94df;
+  d64b = 12.3456789012345e383dd;
+  d128b = 12345.6789012345678901e4000dl;
+
+  d32c = 1.3df;
+  d64c = 1.2dd;
+  d128c = 1.1dl;
+
+  i = 2;
+}
+
+int
+main ()
+{
+  init ();
+
+  /* Usual arithmetic conversions between decimal float types; addition.  */
+  d128a = d128b + d32b;
+  if (d128a < d128b)
+    FAILURE
+  d128a = d32b + d128b;
+  if (d128a < d128b)
+    FAILURE
+  d128a = d128b + d64b;
+  if (d128a < d128b)
+    FAILURE
+  d128a = d64b + d128b;
+  if (d128a < d128b)
+    FAILURE
+  d64a = d64b + d32b;
+  if (d64a < d64b)
+    FAILURE
+  d64a = d32b + d64b;
+  if (d64a < d64b)
+    FAILURE
+
+  /* Usual arithmetic conversions between decimal float types;
+     multiplication.  */
+  d128a = d128b * d32c;
+  if (d128a < d128b)
+    FAILURE
+  d128a = d32c * d128b;
+  if (d128a < d128b)
+    FAILURE
+  d128a = d128b * d64c;
+  if (d128a < d128b)
+    FAILURE
+  d128a = d64c * d128b;
+  if (d128a < d128b)
+    FAILURE
+  d64a = d64b * d32c;
+  if (d64a < d64b)
+    FAILURE
+  d64a = d32c * d64b;
+  if (d64a < d64b)
+    FAILURE
+
+  /* Usual arithmetic conversions between decimal float and integer types.  */
+  d32a = d32c + i;
+  if (d32a != d32c + 2.0df)
+    FAILURE
+  d32a = d32c - i;
+  if (d32a != d32c - 2.0df)
+    FAILURE
+  d32a = i * d32c;
+  if (d32a != d32c + d32c)
+    FAILURE
+  d32a = d32c / i;
+  if (d32a != d32c / 2.0df)
+    FAILURE
+
+  d64a = i + d64c;
+  if (d64a != d64c + 2.0dd)
+    FAILURE
+  d64a = d64c - i;
+  if (d64a != d64c - 2.0dd)
+    FAILURE
+  d64a = d64c * i;
+  if (d64a != d64c + d64c)
+    FAILURE
+  d64a = d64c / i;
+  if (d64a != d64c / 2.0dd)
+    FAILURE
+
+  d128a = d128c + i;
+  if (d128a != d128c + 2.0dl)
+    FAILURE
+  d128a = d128c - i;
+  if (d128a != d128c - 2.0dl)
+    FAILURE
+  d128a = i * d128c;
+  if (d128a != d128c + d128c)
+    FAILURE
+  d128a = d128c / i;
+  if (d128a != d128c / 2.0dl)
+    FAILURE
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/wtr-conversion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/wtr-conversion-1.c
new file mode 100644
index 000000000..0994c6578
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dfp/wtr-conversion-1.c
@@ -0,0 +1,75 @@
+/* Test for -Wtraditional warnings on conversions by prototypes.
+   Note, gcc should omit these warnings in system header files.
+   Based on gcc.dg/wtr-conversion-1.c  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wtraditional" } */
+
+extern void foo_i (int);
+extern void foo_f (float);
+extern void foo_ld (long double);
+extern void foo_d32 (_Decimal32);
+extern void foo_d64 (_Decimal64);
+extern void foo_d128 (_Decimal128);
+
+extern int i;
+extern float f;
+extern long double ld;
+extern _Decimal32 d32;
+extern _Decimal64 d64;
+extern _Decimal128 d128;
+
+void
+testfunc1 ()
+{
+  foo_i (i);
+  foo_i (d32); /* { dg-warning "as integer rather than floating" "prototype conversion warning" } */
+  foo_i (d64); /* { dg-warning "as integer rather than floating" "prototype convDersion warning" } */
+  foo_i (d128); /* { dg-warning "as integer rather than floating" "prototype conversion warning" } */
+  foo_d32 (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
+  foo_d32 (f); /* { dg-warning "as '_Decimal32' rather than 'float'" "prototype conversion warning" } */
+  foo_d32 (ld); /* { dg-warning "as '_Decimal32' rather than 'long double'" "prototype conversion warning" } */
+  foo_d32 (d64); /* { dg-warning "as '_Decimal32' rather than '_Decimal64'" "prototype conversion warning" } */
+  foo_d32 (d128); /* { dg-warning "as '_Decimal32' rather than '_Decimal128'" "prototype conversion warning" } */
+  foo_d64 (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
+  foo_d64 (f); /* { dg-warning "as '_Decimal64' rather than 'float'" "prototype conversion warning" } */
+  foo_d64 (ld); /* { dg-warning "as '_Decimal64' rather than 'long double'" "prototype conversion warning" } */
+  foo_d64 (d32); /* { dg-bogus "as '_Decimal64' rather than '_Decimal32'" "prototype conversion warning" } */
+  foo_d64 (d128); /* { dg-warning "as '_Decimal64' rather than '_Decimal128'" "prototype conversion warning" } */
+  foo_d128 (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
+  foo_d128 (f); /* { dg-warning "as '_Decimal128' rather than 'float'" "prototype conversion warning" } */
+  foo_d128 (ld); /* { dg-warning "as '_Decimal128' rather than 'long double'" "prototype conversion warning" } */
+  foo_d128 (d32); /* { dg-bogus "as '_Decimal128' rather than '_Decimal32'" "prototype conversion warning" } */
+  foo_d128 (d64); /* { dg-bogus "as '_Decimal128' rather than '_Decimal64'" "prototype conversion warning" } */
+  foo_d128 (d128); /* { dg-bogus "as '_Decimal128' rather than '_Decimal'" "prototype conversion warning" } */
+}
+  
+# 54 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+void
+testfunc2 ()
+{
+  foo_i (i);
+  foo_i (d32);
+  foo_i (d64);
+  foo_i (d128);
+  foo_d32 (i);
+  foo_d32 (f);
+  foo_d32 (ld);
+  foo_d32 (d32);
+  foo_d32 (d64);
+  foo_d32 (d128);
+  foo_d64 (i);
+  foo_d64 (f);
+  foo_d64 (ld);
+  foo_d64 (d32);
+  foo_d64 (d64);
+  foo_d64 (d128);
+  foo_d128 (i);
+  foo_d128 (f);
+  foo_d128 (ld);
+  foo_d128 (d32);
+  foo_d128 (d64);
+  foo_d128 (d128);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dg.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/dg.exp
new file mode 100644
index 000000000..3f71178f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dg.exp
@@ -0,0 +1,40 @@
+#   Copyright (C) 1997, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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/*.\[cSi\]]] \
+	"" $DEFAULT_CFLAGS
+
+# C/C++ common tests.
+dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/*.\[cSi\]]] \
+	" -Wc++-compat " ""
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/div-compare-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/div-compare-1.c
new file mode 100644
index 000000000..61adafe14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/div-compare-1.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+
+extern void abort(void);
+
+typedef unsigned long long uint64;
+
+int very_large_value (uint64 t)
+{
+  return (t / 1000000000ULL) > 9223372037ULL;
+}
+
+int main(void)
+{
+  uint64 t = 0xC000000000000000ULL;
+
+  if (!very_large_value (t))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/div-double-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/div-double-1.c
new file mode 100644
index 000000000..0cb8268e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/div-double-1.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffinite-math-only" } */
+
+extern void abort (void);
+
+volatile double a = 2.002083e-146;
+volatile double b;
+
+int
+main()
+{
+  b = 1. / a;
+
+  if (b != (1. / 2.002083e-146))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/divbyzero.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/divbyzero.c
new file mode 100644
index 000000000..607aa12d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/divbyzero.c
@@ -0,0 +1,21 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+
+/* Source: Neil Booth, Oct 22 2001.  PR 150 - warn about division by
+   zero.  */
+
+#define ZERO (4 - 6 + 2)
+
+int main (int argc, char *argv[])
+{
+  int w = argc % ZERO;		/* { dg-warning "division by zero" } */
+  int x = argc / 0;		/* { dg-warning "division by zero" } */
+  int y = argc / ZERO;		/* { dg-warning "division by zero" } */
+
+  double z = 0.0 / 0.0	;	/* { dg-bogus "division by zero" } */
+  w = (ZERO ? y / ZERO : x);	/* { dg-bogus "division by zero" } */
+  x = (ZERO ? argc % ZERO: x);  /* { dg-bogus "division by zero" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-1.c
new file mode 100644
index 000000000..f823523b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target arm*-*-pe* } } */
+/* { dg-options -mno-nop-fun-dllimport } */
+
+__declspec (dllimport) void imp ();
+
+__declspec (dllexport) void _exp () { imp (); }
+
+/* { dg-final { scan-assembler "\.section\[ \t\]*.drectve\n\[^\n\]*-export:_exp.*__imp_imp" } } */
+/* { dg-final { scan-assembler-not "__imp__exp" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-2.c
new file mode 100644
index 000000000..3b8b60eee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-2.c
@@ -0,0 +1,22 @@
+/* These dllimport and dllexport appearing for a symbol.
+   The desired behavior is that if both dllimport
+   and dllexport appear (in either order) the result is dllexport.
+
+   Microsoft's MSVC 2.0 allows dllimport followed by dllexport for variables,
+   but does not allow dllexport followed by dllimport.
+
+   In C, it's ok to redeclare a variable so this works for variables
+   and functions.  In C++, it only works for functions.  */
+
+/* { dg-require-dll "" } */
+
+__declspec (dllimport) int foo1 ();
+__declspec (dllexport) int foo1 ();	/* { dg-warning "previous dllimport ignored" } */
+__declspec (dllexport) int foo2 ();
+__declspec (dllimport) int foo2 ();	/* { dg-warning "dllimport ignored" } */
+
+__declspec (dllimport) int bar1;
+__declspec (dllexport) int bar1;	/* { dg-warning "previous dllimport ignored" } */
+
+__declspec (dllexport) int bar2;
+__declspec (dllimport) int bar2;	/* { dg-warning "dllimport ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-3.c
new file mode 100644
index 000000000..0a3f7df09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-3.c
@@ -0,0 +1,18 @@
+/* Ensure dllexport overrides dllimport.  */
+
+/* { dg-do compile { target arm*-*-pe* } } */
+/* { dg-do compile { target i?86-pc-cygwin } } */
+/* { dg-do compile { target i?86-pc-mingw* } } */
+
+__declspec (dllimport) int foo1 ();
+__declspec (dllexport) int foo1 ();	/* { dg-warning "previous dllimport ignored" } */
+
+__declspec (dllexport) int foo2 ();
+__declspec (dllimport) int foo2 ();	/* { dg-warning "dllimport ignored" } */
+
+__declspec (dllexport) int foo1 () { return foo2 (); }
+__declspec (dllexport) int foo2 () { return foo1 (); }
+
+/* { dg-final { scan-assembler "\.section\[ \t\]*.drectve\n.*-export:foo2" } } */
+/* { dg-final { scan-assembler "-export:foo1" } } */
+/* { dg-final { scan-assembler-not "(__imp_foo1|_imp__foo1|__imp_foo2|_imp__foo2)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-4.c
new file mode 100644
index 000000000..9fcc8e9ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-4.c
@@ -0,0 +1,15 @@
+/* { dg-do compile { target arm*-*-pe* } } */
+/* { dg-do compile { target i?86-pc-cygwin } } */
+/* { dg-do compile { target i?86-pc-mingw* } } */
+
+__declspec (dllimport) int foo1;
+int foo1;	/* { dg-warning "redeclared without dllimport" } */
+
+__declspec (dllimport) int foo2;
+int foo2 = 5;	/* { dg-warning "redeclared without dllimport" } */
+
+int f () { return foo1 + foo2; }
+
+/* FIXME: We should scan the output of nm for this case.  */
+/* { dg-final { scan-assembler "(foo2:.*\.comm\[ \t_\]*foo1)" } } */
+/* { dg-final { scan-assembler-not "(__imp_|_imp__)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-5.c
new file mode 100644
index 000000000..df7e3e3f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dll-5.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target i?86-pc-cygwin } } */
+/* { dg-do compile { target i?86-pc-mingw* } } */
+/* { dg-do compile { target arm*-*-pe* } } */
+
+/* { dg-options -mnop-fun-dllimport } */
+
+/* The dllimport attribute should be ignored for functions. */
+__declspec (dllimport) void dllimpfn ();
+
+/* The dllimport attribute should not be ignored for variables. */
+__declspec (dllimport) int dllimpvar;
+
+/* The dllexport attribute should not be ignored. */
+__declspec (dllexport) void dllexp ()
+{
+  dllimpfn ();
+  dllimpvar = 0;
+}
+
+/* { dg-final { scan-assembler-not "(__imp_dllimpfn|_imp__dllimpfn)" } } */
+/* { dg-final { scan-assembler "(__imp_dllimpvar|_imp__dllimpvar)" } } */
+/* { dg-final { scan-assembler "\.section\[ \t\]*.drectve\n\.*-export:dllexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/do-empty.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/do-empty.c
new file mode 100644
index 000000000..350261d48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/do-empty.c
@@ -0,0 +1,15 @@
+/* Test diagnostics for empty bodies in do / while.  */
+/* { dg-do compile } */
+/* { dg-options "-Wempty-body" } */
+
+void
+f (int x)
+{
+  do
+    ; /* { dg-warning "empty body in" } */
+  while (x--);
+
+  do
+  {} /* { dg-bogus "empty body in" } */
+  while (++x < 10);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dollar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dollar.c
new file mode 100644
index 000000000..43407f227
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dollar.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2003 Free Software Foundation, Inc.  */
+
+/* { dg-do compile } */
+/* { dg-options -fno-dollars-in-identifiers } */
+
+/* Test that -fno-dollars-in-identifiers is honoured.
+   Neil Booth, 17 May 2003.  */
+
+int foobar$;	/* { dg-error "stray '\\$'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/doloop-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/doloop-2.c
new file mode 100644
index 000000000..115ec742b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/doloop-2.c
@@ -0,0 +1,19 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+extern void abort (void);
+unsigned global_iters;
+
+void bi_reverse(int len)
+{
+    do {
+	global_iters++;
+    } while (--len > 0);
+}
+
+int main()
+{
+  bi_reverse(5);
+  if (global_iters != 5)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-1.c
new file mode 100644
index 000000000..79c55ef84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-1.c
@@ -0,0 +1,16 @@
+/* Test for bogus diagnostics for dremf definition.  Although this
+   definition is formally incorrect in ISO C, a GNU extension permits
+   a prototype followed by unpromoted types in a function definition,
+   so it should be permitted when the function is built in.  Bug
+   16666.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+float dremf (float, float);
+
+float
+dremf (x, y)
+     float x, y;
+{
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-2.c
new file mode 100644
index 000000000..61f0ba84f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-2.c
@@ -0,0 +1,18 @@
+/* Test for bogus diagnostics for dremf definition.  Although this
+   definition is formally incorrect in ISO C, a GNU extension permits
+   a prototype followed by unpromoted types in a function definition,
+   so it should be permitted when the function is built in.  Bug
+   16666.  Test with -pedantic, where the problem should still be
+   diagnosed.  */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+float dremf (float, float); /* { dg-warning "prototype declaration" } */
+
+float
+dremf (x, y)
+     float x;
+     float y;
+{ /* { dg-warning "promoted argument '.' doesn't match prototype" } */
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-3.c
new file mode 100644
index 000000000..437e26f65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-3.c
@@ -0,0 +1,18 @@
+/* Test for bogus diagnostics for dremf definition.  Although this
+   definition is formally incorrect in ISO C, a GNU extension permits
+   a prototype followed by unpromoted types in a function definition,
+   so it should be permitted when the function is built in.  Bug
+   16666.  Test with -pedantic-errors, where the problem should still
+   be diagnosed.  */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+float dremf (float, float); /* { dg-error "prototype declaration" } */
+
+float
+dremf (x, y)
+     float x;
+     float y;
+{ /* { dg-error "promoted argument '.' doesn't match prototype" } */
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-4.c
new file mode 100644
index 000000000..b3a2c5ad5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dremf-type-compat-4.c
@@ -0,0 +1,13 @@
+/* Test for bogus diagnostics for dremf definition, as in bug 16666.
+   The GNU extension permitting a prototype to override the promotion
+   of old-style parameter declarations should only apply when the
+   prototype is visible, not for a built-in prototype.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+float
+dremf(x, y) /* { dg-warning "conflicting types for built-in function 'dremf'" } */
+     float x, y;
+{
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/dse.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/dse.c
new file mode 100644
index 000000000..4a859ae03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/dse.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse-details" } */
+
+#define N 256
+
+struct
+{
+  int x;
+  int y;
+} S[100];
+
+int z[100];
+
+int
+foo (void)
+{
+  int i;
+  int x, y;
+
+  S[5].x = 0;
+  S[5].y = 0;
+
+  x = 5 + z[0];
+  y = z[0];
+
+  S[5].x = x;
+  S[5].y = y;
+}
+
+/* { dg-final { scan-tree-dump-times "Deleted dead store" 2 "dse1" } } */
+/* { dg-final { cleanup-tree-dump "dse*" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-1.c
new file mode 100644
index 000000000..b718f6c05
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-1.c
@@ -0,0 +1,50 @@
+/* Duff's device is legal C; test to make sure the compiler
+   doesn't complain about it.
+
+   Jason Thorpe <thorpej@wasabisystems.com>
+   Derived from PR 3846.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+
+typedef __SIZE_TYPE__ size_t;
+extern int memcmp (const void *, const void *, size_t);
+
+void
+duffcpy (char *dst, const char *src, unsigned long size)
+{
+  switch (size & 3)
+    {
+    for (;;)
+      {
+	*dst++ = *src++;
+    case 3:
+	*dst++ = *src++;
+    case 2:
+	*dst++ = *src++;
+    case 1:
+	*dst++ = *src++;
+    case 0:
+	if (size <= 3)
+	  break;
+	size -= 4;
+      }
+    }
+}
+
+const char testpat[] = "The quick brown fox jumped over the lazy dog.";
+
+int
+main()
+{
+  char buf[64];
+
+  duffcpy (buf, testpat, sizeof (testpat));
+  if (memcmp (buf, testpat, sizeof (testpat)) != 0)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-2.c
new file mode 100644
index 000000000..8b8923eb9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-2.c
@@ -0,0 +1,60 @@
+/* Duff's device is legal C; test to make sure the compiler
+   doesn't complain about it.
+
+   Jason Thorpe <thorpej@wasabisystems.com>
+   Derived from the BSD Telnet Kerberos 4 checksum routine.
+   See also PR 5230.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+
+#if __INT_MAX__ >= 2147483647
+/* At least 32-bit integers. */
+typedef int type32;
+#else
+typedef long type32;
+#endif
+
+type32
+cksum (const unsigned char *src, unsigned long size)
+{
+  type32 ck = 0;
+
+  switch (size & 3)
+    {
+    while (size > 0)
+      {
+    case 0:
+	ck ^= (type32)*src++ << 24;
+	--size;
+    case 3:
+	ck ^= (type32)*src++ << 16;
+	--size;
+    case 2:
+	ck ^= (type32)*src++ << 8;
+	--size;
+    case 1:
+	ck ^= (type32)*src++;
+	--size;
+      }
+    }
+
+  return ck;
+}
+
+const char testpat[] = "The quick brown fox jumped over the lazy dog.";
+
+int
+main()
+{
+  type32 ck;
+
+  ck = cksum ((const unsigned char *) testpat, sizeof (testpat));
+  if (ck != 925902908)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-3.c
new file mode 100644
index 000000000..23cddeff9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-3.c
@@ -0,0 +1,47 @@
+/* Duff's device is legal C; test to make sure the compiler
+   doesn't complain about it.
+
+   Jason Thorpe <thorpej@wasabisystems.com>
+   Derived from Tom Duff's original usenet message about the device.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+
+typedef __SIZE_TYPE__ size_t;
+extern int memcmp (const void *, const void *, size_t);
+
+void
+duffcpy (char *dst, const char *src, unsigned long size)
+{
+  unsigned long n = (size + 7) / 8;
+
+  switch (size % 8)
+    {
+    case 0:	do {	*dst++ = *src++;
+    case 7:		*dst++ = *src++;
+    case 6:		*dst++ = *src++;
+    case 5:		*dst++ = *src++;
+    case 4:		*dst++ = *src++;
+    case 3:		*dst++ = *src++;
+    case 2:		*dst++ = *src++;
+    case 1:		*dst++ = *src++;
+		} while (--n > 0);
+    }
+}
+
+const char testpat[] = "The quick brown fox jumped over the lazy dog.";
+
+int
+main()
+{
+  char buf[64];
+
+  duffcpy (buf, testpat, sizeof (testpat));
+  if (memcmp (buf, testpat, sizeof (testpat)) != 0)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-4.c
new file mode 100644
index 000000000..7032285af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/duff-4.c
@@ -0,0 +1,60 @@
+/* Duff's device is legal C; test to make sure the compiler
+   doesn't complain about it.
+
+   Roger Sayle <roger@eyesopen.com>
+   Derived from duff-2.c.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+
+#if __INT_MAX__ >= 2147483647
+/* At least 32-bit integers. */
+typedef int type32;
+#else
+typedef long type32;
+#endif
+
+type32
+cksum (const unsigned char *src, unsigned long size)
+{
+  type32 ck = 0;
+
+  switch (size & 3)
+    {
+    do
+      {
+    case 0:
+	ck ^= (type32)*src++ << 24;
+	--size;
+    case 3:
+	ck ^= (type32)*src++ << 16;
+	--size;
+    case 2:
+	ck ^= (type32)*src++ << 8;
+	--size;
+    case 1:
+	ck ^= (type32)*src++;
+	--size;
+      }
+    while (size > 0);
+    }
+
+  return ck;
+}
+
+const char testpat[] = "The quick brown fox jumped over the lazy dog.";
+
+int
+main()
+{
+  type32 ck;
+
+  ck = cksum ((const unsigned char *) testpat, sizeof (testpat));
+  if (ck != 925902908)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-1.c
new file mode 100644
index 000000000..239001c03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-1.c
@@ -0,0 +1,5 @@
+/* Test diagnostic for an empty source file.  Test with no special
+   options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-2.c
new file mode 100644
index 000000000..8ce201c13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-2.c
@@ -0,0 +1,6 @@
+/* Test diagnostic for an empty source file.  Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+/* { dg-warning "ISO C forbids an empty translation unit" "empty" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-3.c
new file mode 100644
index 000000000..0fd7be777
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty-source-3.c
@@ -0,0 +1,7 @@
+/* Test diagnostic for an empty source file.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+/* { dg-error "ISO C forbids an empty translation unit" "empty" { target *-*-* } 7 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/empty1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty1.c
new file mode 100644
index 000000000..89b2de1e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty1.c
@@ -0,0 +1,11 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+
+struct S { int : 0; };
+union U { int : 0; };
+
+int main () {
+  if (__alignof__ (struct S) != __alignof__ (union U))
+    return 1;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/empty2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty2.c
new file mode 100644
index 000000000..acc1ac8dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/empty2.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+double d=0;
+
+struct A {} a; /* { dg-warning "struct has no members" } */
+
+void foo(struct A x)
+{
+  d=0;
+}
+
+void bar()
+{
+  if (d) foo(a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/enum-compat-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum-compat-1.c
new file mode 100644
index 000000000..18d1f7fe7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum-compat-1.c
@@ -0,0 +1,32 @@
+/* Test that enumerated types are only considered compatible when they
+   are the same type.  PR c/6024.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk>, based on
+   PR c/6024 from Richard Earnshaw <rearnsha@arm.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Original test from PR c/6024.  */
+enum e1 {a, b};
+enum e2 {c, d};
+
+void f(enum e1); /* { dg-error "prototype" "error at decl" } */
+
+void f(x)
+     enum e2 x;
+{ /* { dg-error "doesn't match prototype" "error at defn" } */
+  return;
+}
+
+/* Other compatibility tests.  */
+enum e3 { A };
+enum e4 { B };
+
+enum e3 v3;
+enum e4 *p = &v3; /* { dg-warning "incompatible" "incompatible pointer" } */
+enum e3 *q = &v3;
+
+void g(enum e3); /* { dg-message "note: previous declaration" "error at first decl" } */
+void g(enum e4); /* { dg-error "conflicting types" "error at second decl" } */
+
+void h(enum e3);
+void h(enum e3);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/enum-incomplete-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum-incomplete-1.c
new file mode 100644
index 000000000..06c247c2e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum-incomplete-1.c
@@ -0,0 +1,86 @@
+/* Test for uses of incomplete enum variables: should be allowed just
+   when incomplete structs are allowed.  PR 32295.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern enum e ve;
+extern struct s vs;
+void *p;
+
+int
+f0 (int i)
+{
+  ve; /* { dg-error "incomplete" } */
+  vs; /* { dg-error "incomplete" } */
+  (void) ve;
+  (void) vs;
+  (void) (i ? ve : ve); /* { dg-error "incomplete" } */
+  (void) (i ? vs : vs); /* { dg-error "incomplete" } */
+  (void) (ve = ve); /* { dg-error "incomplete" } */
+  (void) (vs = vs); /* { dg-error "incomplete" } */
+  (void) ve, (void) ve;
+  (void) vs, (void) vs;
+  p = &ve;
+  p = &vs;
+  (void) sizeof (ve); /* { dg-error "incomplete" } */
+  (void) sizeof (vs); /* { dg-error "incomplete" } */
+  typeof (ve) *pe;
+  typeof (vs) *ps;
+  /* ??? alignof should probably not be accepted here.  */
+  (void) __alignof (ve);
+  (void) __alignof (vs);
+  (void) (ve + i); /* { dg-error "incomplete" } */
+  (void) (i * ve); /* { dg-error "incomplete" } */
+  (void) (i / ve); /* { dg-error "incomplete" } */
+  (void) (ve - i); /* { dg-error "incomplete" } */
+  (void) (ve << i); /* { dg-error "incomplete" } */
+  (void) (i >> ve); /* { dg-error "incomplete" } */
+  (void) (ve < i); /* { dg-error "incomplete" } */
+  (void) (ve <= i); /* { dg-error "incomplete" } */
+  (void) (i > ve); /* { dg-error "incomplete" } */
+  (void) (i >= ve); /* { dg-error "incomplete" } */
+  (void) (ve == i); /* { dg-error "incomplete" } */
+  (void) (i != ve); /* { dg-error "incomplete" } */
+  (void) (ve & i); /* { dg-error "incomplete" } */
+  (void) (ve ^ i); /* { dg-error "incomplete" } */
+  (void) (i | ve); /* { dg-error "incomplete" } */
+  (void) (i && ve); /* { dg-error "incomplete" } */
+  (void) (ve || i); /* { dg-error "incomplete" } */
+  (void) -ve; /* { dg-error "incomplete" } */
+  (void) +ve; /* { dg-error "incomplete" } */
+  (void) ~ve; /* { dg-error "incomplete" } */
+  (void) !ve; /* { dg-error "incomplete" } */
+  (void) --ve; /* { dg-error "incomplete" } */
+  (void) ++ve; /* { dg-error "incomplete" } */
+  (void) ve--; /* { dg-error "incomplete" } */
+  (void) ve++; /* { dg-error "incomplete" } */
+  i = ve; /* { dg-error "incomplete" } */
+  i *= ve; /* { dg-error "incomplete" } */
+  i /= ve; /* { dg-error "incomplete" } */
+  i %= ve; /* { dg-error "incomplete" } */
+  i += ve; /* { dg-error "incomplete" } */
+  i -= ve; /* { dg-error "incomplete" } */
+  i <<= ve; /* { dg-error "incomplete" } */
+  i >>= ve; /* { dg-error "incomplete" } */
+  i &= ve; /* { dg-error "incomplete" } */
+  i ^= ve; /* { dg-error "incomplete" } */
+  i |= ve; /* { dg-error "incomplete" } */
+  (void) (ve ? 1 : 1); /* { dg-error "incomplete" } */
+  (void) (int) ve; /* { dg-error "incomplete" } */
+  f0 (ve); /* { dg-error "incomplete" } */
+  if (ve) /* { dg-error "incomplete" } */
+    ;
+  do
+    ;
+  while (ve); /* { dg-error "incomplete" } */
+  while (ve) /* { dg-error "incomplete" } */
+    ;
+  _Bool b = ve; /* { dg-error "incomplete" } */
+  float f = ve; /* { dg-error "incomplete" } */
+  switch (ve) /* { dg-error "incomplete" } */
+    ;
+  for (; ve;) /* { dg-error "incomplete" } */
+    ;
+  return ve; /* { dg-error "incomplete" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/enum1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum1.c
new file mode 100644
index 000000000..0f4587ff6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum1.c
@@ -0,0 +1,23 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu89" } */
+
+/* In standard C, enumeration constants always have type int.  If they
+   are not representables are int, they're ill-formed.  In GNU C, we
+   give such ill-formed constructs well-defined meaning.  Make sure it
+   works.  */
+
+#include <stdlib.h>
+
+enum foo
+{
+  foo1   = 0,
+  foo2   = 0xffffffffffffffffULL,
+  foo3   = 0xf0fffffffffffffeULL
+};
+
+int main ()
+{
+  if (sizeof (enum foo) != sizeof (unsigned long long))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/enum2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum2.c
new file mode 100644
index 000000000..575cc5ce0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum2.c
@@ -0,0 +1,8 @@
+/* { dg-options "-fshort-enums" } */
+/* Check that "-fshort-enums" packs enumeration tyes into a minimal
+   number of bytes..  */
+
+enum e { e_1 };
+
+extern int i[sizeof (enum e)];
+int i[1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/enum3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum3.c
new file mode 100644
index 000000000..eebd6ca64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/enum3.c
@@ -0,0 +1,11 @@
+/* Test for non-integer enum values.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+enum e { E, F };
+enum e2 {
+  E1 = (void *)4, /* { dg-error "enumerator value for 'E1' is not an integer constant" } */
+  E2 = (enum e)F,
+  E3 = (_Bool)1
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-1.c
new file mode 100644
index 000000000..74857cad1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-1.c
@@ -0,0 +1,7 @@
+/* Test diagnostic for extra semicolon outside a function.  Test with
+   no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-2.c
new file mode 100644
index 000000000..2964ed557
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-2.c
@@ -0,0 +1,7 @@
+/* Test diagnostic for extra semicolon outside a function.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+; /* { dg-warning "ISO C does not allow extra ';' outside of a function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-3.c
new file mode 100644
index 000000000..53a420a5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/extra-semi-3.c
@@ -0,0 +1,7 @@
+/* Test diagnostic for extra semicolon outside a function.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+; /* { dg-error "ISO C does not allow extra ';' outside of a function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fastmath-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fastmath-1.c
new file mode 100644
index 000000000..4efe43004
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fastmath-1.c
@@ -0,0 +1,26 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void abort (void);
+
+int foo ( float* dists,  int k) 
+{ 
+if ( ( dists [ 0 ] > 0 ) == ( dists [ 1 ] > 0 ) ) 
+  return k;
+return 0;
+} 
+main() {
+  float dists[16] = { 0., 1., 1., 0., 0., -1., -1., 0.,
+		     1., 1., 1., -1., -1., 1., -1., -1. };
+  if ( foo(&dists[0], 1) +
+       foo(&dists[2], 2) +
+       foo(&dists[4], 4) +
+       foo(&dists[6], 8) +
+       foo(&dists[8], 16) +
+       foo(&dists[10], 32) +
+       foo(&dists[12], 64) +
+       foo(&dists[14], 128)
+	!= 156)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fdata-sections-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fdata-sections-1.c
new file mode 100644
index 000000000..d2b2b5807
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fdata-sections-1.c
@@ -0,0 +1,9 @@
+/* PR middle-end/15486 */
+/* Origin: Jonathan Larmour <jifl-bugzilla@jifvik.org> */
+
+/* { dg-do compile { target *-*-linux* } } */
+/* { dg-options "-fdata-sections" } */
+
+int x;
+
+/* { dg-final { scan-assembler "comm" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/Wbad-function-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/Wbad-function-cast-1.c
new file mode 100644
index 000000000..e23983396
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/Wbad-function-cast-1.c
@@ -0,0 +1,357 @@
+/* Test operation of -Wbad-function-cast.  */
+/* Based on gcc.dg/Wbad-function-cast-1.c.  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wbad-function-cast" } */
+
+int if1(void);
+char if2(void);
+long if3(void);
+_Complex double cf(void);
+
+
+#define FUNC(TYPE,NAME) \
+TYPE f ## NAME (void);
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+void
+foo(void)
+{
+#define TEST(NAME) \
+  /* Casts to void types are always OK.  */ \
+  (void) f ## NAME (); \
+  (const void) f ## NAME (); \
+  /* Casts to the same type or similar types are OK.  */ \
+  (short _Fract) f ## NAME (); \
+  (_Fract) f ## NAME (); \
+  (long _Fract) f ## NAME (); \
+  (long long _Fract) f ## NAME (); \
+  (unsigned short _Fract) f ## NAME (); \
+  (unsigned _Fract) f ## NAME (); \
+  (unsigned long _Fract) f ## NAME (); \
+  (unsigned long long _Fract) f ## NAME (); \
+  (_Sat short _Fract) f ## NAME (); \
+  (_Sat _Fract) f ## NAME (); \
+  (_Sat long _Fract) f ## NAME (); \
+  (_Sat long long _Fract) f ## NAME (); \
+  (_Sat unsigned short _Fract) f ## NAME (); \
+  (_Sat unsigned _Fract) f ## NAME (); \
+  (_Sat unsigned long _Fract) f ## NAME (); \
+  (_Sat unsigned long long _Fract) f ## NAME (); \
+  (short _Accum) f ## NAME (); \
+  (_Accum) f ## NAME (); \
+  (long _Accum) f ## NAME (); \
+  (long long _Accum) f ## NAME (); \
+  (unsigned short _Accum) f ## NAME (); \
+  (unsigned _Accum) f ## NAME (); \
+  (unsigned long _Accum) f ## NAME (); \
+  (unsigned long long _Accum) f ## NAME (); \
+  (_Sat short _Accum) f ## NAME (); \
+  (_Sat _Accum) f ## NAME (); \
+  (_Sat long _Accum) f ## NAME (); \
+  (_Sat long long _Accum) f ## NAME (); \
+  (_Sat unsigned short _Accum) f ## NAME (); \
+  (_Sat unsigned _Accum) f ## NAME (); \
+  (_Sat unsigned long _Accum) f ## NAME (); \
+  (_Sat unsigned long long _Accum) f ## NAME (); \
+
+  TEST (sf);
+  TEST (f);
+  TEST (lf);
+  TEST (llf);
+  TEST (usf);
+  TEST (uf);
+  TEST (ulf);
+  TEST (ullf);
+  TEST (Ssf);
+  TEST (Sf);
+  TEST (Slf);
+  TEST (Sllf);
+  TEST (Susf);
+  TEST (Suf);
+  TEST (Sulf);
+  TEST (Sullf);
+  TEST (sa);
+  TEST (a);
+  TEST (la);
+  TEST (lla);
+  TEST (usa);
+  TEST (ua);
+  TEST (ula);
+  TEST (ulla);
+  TEST (Ssa);
+  TEST (Sa);
+  TEST (Sla);
+  TEST (Slla);
+  TEST (Susa);
+  TEST (Sua);
+  TEST (Sula);
+  TEST (Sulla);
+
+   /* Casts to types with different TREE_CODE (which is how this
+     warning has been defined) are not OK, except for casts to void
+     types.  */
+  (short _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'short _Fract'" } */
+  (_Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Fract'" } */
+  (long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'long _Fract'" } */
+  (long long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'long long _Fract'" } */
+  (unsigned short _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned short _Fract'" } */
+  (unsigned _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned _Fract'" } */
+  (unsigned long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned long _Fract'" } */
+  (unsigned long long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned long long _Fract'" } */
+  (_Sat short _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat short _Fract'" } */
+  (_Sat _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat _Fract'" } */
+  (_Sat long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat long _Fract'" } */
+  (_Sat long long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat long long _Fract'" } */
+  (_Sat unsigned short _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned short _Fract'" } */
+  (_Sat unsigned _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned _Fract'" } */
+  (_Sat unsigned long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned long _Fract'" } */
+  (_Sat unsigned long long _Fract)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned long long _Fract'" } */
+  (short _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'short _Accum'" } */
+  (_Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Accum'" } */
+  (long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'long _Accum'" } */
+  (long long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'long long _Accum'" } */
+  (unsigned short _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned short _Accum'" } */
+  (unsigned _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned _Accum'" } */
+  (unsigned long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned long _Accum'" } */
+  (unsigned long long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type 'unsigned long long _Accum'" } */
+  (_Sat short _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat short _Accum'" } */
+  (_Sat _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat _Accum'" } */
+  (_Sat long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat long _Accum'" } */
+  (_Sat long long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat long long _Accum'" } */
+  (_Sat unsigned short _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned short _Accum'" } */
+  (_Sat unsigned _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned _Accum'" } */
+  (_Sat unsigned long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned long _Accum'" } */
+  (_Sat unsigned long long _Accum)if1(); /* { dg-warning "cast from function call of type 'int' to non-matching type '_Sat unsigned long long _Accum'" } */
+
+  (short _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'short _Fract'" } */
+  (_Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Fract'" } */
+  (long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'long _Fract'" } */
+  (long long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'long long _Fract'" } */
+  (unsigned short _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned short _Fract'" } */
+  (unsigned _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned _Fract'" } */
+  (unsigned long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned long _Fract'" } */
+  (unsigned long long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned long long _Fract'" } */
+  (_Sat short _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat short _Fract'" } */
+  (_Sat _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat _Fract'" } */
+  (_Sat long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat long _Fract'" } */
+  (_Sat long long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat long long _Fract'" } */
+  (_Sat unsigned short _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned short _Fract'" } */
+  (_Sat unsigned _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned _Fract'" } */
+  (_Sat unsigned long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned long _Fract'" } */
+  (_Sat unsigned long long _Fract)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned long long _Fract'" } */
+  (short _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'short _Accum'" } */
+  (_Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Accum'" } */
+  (long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'long _Accum'" } */
+  (long long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'long long _Accum'" } */
+  (unsigned short _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned short _Accum'" } */
+  (unsigned _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned _Accum'" } */
+  (unsigned long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned long _Accum'" } */
+  (unsigned long long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type 'unsigned long long _Accum'" } */
+  (_Sat short _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat short _Accum'" } */
+  (_Sat _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat _Accum'" } */
+  (_Sat long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat long _Accum'" } */
+  (_Sat long long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat long long _Accum'" } */
+  (_Sat unsigned short _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned short _Accum'" } */
+  (_Sat unsigned _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned _Accum'" } */
+  (_Sat unsigned long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned long _Accum'" } */
+  (_Sat unsigned long long _Accum)if2(); /* { dg-warning "cast from function call of type 'char' to non-matching type '_Sat unsigned long long _Accum'" } */
+
+  (short _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'short _Fract'" } */
+  (_Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Fract'" } */
+  (long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'long _Fract'" } */
+  (long long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'long long _Fract'" } */
+  (unsigned short _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned short _Fract'" } */
+  (unsigned _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned _Fract'" } */
+  (unsigned long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned long _Fract'" } */
+  (unsigned long long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned long long _Fract'" } */
+  (_Sat short _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat short _Fract'" } */
+  (_Sat _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat _Fract'" } */
+  (_Sat long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat long _Fract'" } */
+  (_Sat long long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat long long _Fract'" } */
+  (_Sat unsigned short _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned short _Fract'" } */
+  (_Sat unsigned _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned _Fract'" } */
+  (_Sat unsigned long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned long _Fract'" } */
+  (_Sat unsigned long long _Fract)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned long long _Fract'" } */
+  (short _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'short _Accum'" } */
+  (_Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Accum'" } */
+  (long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'long _Accum'" } */
+  (long long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'long long _Accum'" } */
+  (unsigned short _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned short _Accum'" } */
+  (unsigned _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned _Accum'" } */
+  (unsigned long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned long _Accum'" } */
+  (unsigned long long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type 'unsigned long long _Accum'" } */
+  (_Sat short _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat short _Accum'" } */
+  (_Sat _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat _Accum'" } */
+  (_Sat long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat long _Accum'" } */
+  (_Sat long long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat long long _Accum'" } */
+  (_Sat unsigned short _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned short _Accum'" } */
+  (_Sat unsigned _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned _Accum'" } */
+  (_Sat unsigned long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned long _Accum'" } */
+  (_Sat unsigned long long _Accum)if3(); /* { dg-warning "cast from function call of type 'long int' to non-matching type '_Sat unsigned long long _Accum'" } */
+
+  (short _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'short _Fract'" } */
+  (_Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Fract'" } */
+  (long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'long _Fract'" } */
+  (long long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'long long _Fract'" } */
+  (unsigned short _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned short _Fract'" } */
+  (unsigned _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned _Fract'" } */
+  (unsigned long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned long _Fract'" } */
+  (unsigned long long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned long long _Fract'" } */
+  (_Sat short _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat short _Fract'" } */
+  (_Sat _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat _Fract'" } */
+  (_Sat long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat long _Fract'" } */
+  (_Sat long long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat long long _Fract'" } */
+  (_Sat unsigned short _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned short _Fract'" } */
+  (_Sat unsigned _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned _Fract'" } */
+  (_Sat unsigned long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned long _Fract'" } */
+  (_Sat unsigned long long _Fract)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned long long _Fract'" } */
+  (short _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'short _Accum'" } */
+  (_Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Accum'" } */
+  (long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'long _Accum'" } */
+  (long long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'long long _Accum'" } */
+  (unsigned short _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned short _Accum'" } */
+  (unsigned _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned _Accum'" } */
+  (unsigned long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned long _Accum'" } */
+  (unsigned long long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type 'unsigned long long _Accum'" } */
+  (_Sat short _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat short _Accum'" } */
+  (_Sat _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat _Accum'" } */
+  (_Sat long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat long _Accum'" } */
+  (_Sat long long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat long long _Accum'" } */
+  (_Sat unsigned short _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned short _Accum'" } */
+  (_Sat unsigned _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned _Accum'" } */
+  (_Sat unsigned long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned long _Accum'" } */
+  (_Sat unsigned long long _Accum)cf(); /* { dg-warning "cast from function call of type 'complex double' to non-matching type '_Sat unsigned long long _Accum'" } */
+
+  (int)fsf(); /* { dg-warning "cast from function call of type 'short _Fract' to non-matching type 'int'" } */
+  (int)ff(); /* { dg-warning "cast from function call of type '_Fract' to non-matching type 'int'" } */
+  (int)flf(); /* { dg-warning "cast from function call of type 'long _Fract' to non-matching type 'int'" } */
+  (int)fllf(); /* { dg-warning "cast from function call of type 'long long _Fract' to non-matching type 'int'" } */
+  (int)fusf(); /* { dg-warning "cast from function call of type 'unsigned short _Fract' to non-matching type 'int'" } */
+  (int)fuf(); /* { dg-warning "cast from function call of type 'unsigned _Fract' to non-matching type 'int'" } */
+  (int)fulf(); /* { dg-warning "cast from function call of type 'unsigned long _Fract' to non-matching type 'int'" } */
+  (int)fullf(); /* { dg-warning "cast from function call of type 'unsigned long long _Fract' to non-matching type 'int'" } */
+  (int)fSsf(); /* { dg-warning "cast from function call of type '_Sat short _Fract' to non-matching type 'int'" } */
+  (int)fSf(); /* { dg-warning "cast from function call of type '_Sat _Fract' to non-matching type 'int'" } */
+  (int)fSlf(); /* { dg-warning "cast from function call of type '_Sat long _Fract' to non-matching type 'int'" } */
+  (int)fSllf(); /* { dg-warning "cast from function call of type '_Sat long long _Fract' to non-matching type 'int'" } */
+  (int)fSusf(); /* { dg-warning "cast from function call of type '_Sat unsigned short _Fract' to non-matching type 'int'" } */
+  (int)fSuf(); /* { dg-warning "cast from function call of type '_Sat unsigned _Fract' to non-matching type 'int'" } */
+  (int)fSulf(); /* { dg-warning "cast from function call of type '_Sat unsigned long _Fract' to non-matching type 'int'" } */
+  (int)fSullf(); /* { dg-warning "cast from function call of type '_Sat unsigned long long _Fract' to non-matching type 'int'" } */
+  (int)fsa(); /* { dg-warning "cast from function call of type 'short _Accum' to non-matching type 'int'" } */
+  (int)fa(); /* { dg-warning "cast from function call of type '_Accum' to non-matching type 'int'" } */
+  (int)fla(); /* { dg-warning "cast from function call of type 'long _Accum' to non-matching type 'int'" } */
+  (int)flla(); /* { dg-warning "cast from function call of type 'long long _Accum' to non-matching type 'int'" } */
+  (int)fusa(); /* { dg-warning "cast from function call of type 'unsigned short _Accum' to non-matching type 'int'" } */
+  (int)fua(); /* { dg-warning "cast from function call of type 'unsigned _Accum' to non-matching type 'int'" } */
+  (int)fula(); /* { dg-warning "cast from function call of type 'unsigned long _Accum' to non-matching type 'int'" } */
+  (int)fulla(); /* { dg-warning "cast from function call of type 'unsigned long long _Accum' to non-matching type 'int'" } */
+  (int)fSsa(); /* { dg-warning "cast from function call of type '_Sat short _Accum' to non-matching type 'int'" } */
+  (int)fSa(); /* { dg-warning "cast from function call of type '_Sat _Accum' to non-matching type 'int'" } */
+  (int)fSla(); /* { dg-warning "cast from function call of type '_Sat long _Accum' to non-matching type 'int'" } */
+  (int)fSlla(); /* { dg-warning "cast from function call of type '_Sat long long _Accum' to non-matching type 'int'" } */
+  (int)fSusa(); /* { dg-warning "cast from function call of type '_Sat unsigned short _Accum' to non-matching type 'int'" } */
+  (int)fSua(); /* { dg-warning "cast from function call of type '_Sat unsigned _Accum' to non-matching type 'int'" } */
+  (int)fSula(); /* { dg-warning "cast from function call of type '_Sat unsigned long _Accum' to non-matching type 'int'" } */
+  (int)fSulla(); /* { dg-warning "cast from function call of type '_Sat unsigned long long _Accum' to non-matching type 'int'" } */
+
+  (long)fsf(); /* { dg-warning "cast from function call of type 'short _Fract' to non-matching type 'long int'" } */
+  (long)ff(); /* { dg-warning "cast from function call of type '_Fract' to non-matching type 'long int'" } */
+  (long)flf(); /* { dg-warning "cast from function call of type 'long _Fract' to non-matching type 'long int'" } */
+  (long)fllf(); /* { dg-warning "cast from function call of type 'long long _Fract' to non-matching type 'long int'" } */
+  (long)fusf(); /* { dg-warning "cast from function call of type 'unsigned short _Fract' to non-matching type 'long int'" } */
+  (long)fuf(); /* { dg-warning "cast from function call of type 'unsigned _Fract' to non-matching type 'long int'" } */
+  (long)fulf(); /* { dg-warning "cast from function call of type 'unsigned long _Fract' to non-matching type 'long int'" } */
+  (long)fullf(); /* { dg-warning "cast from function call of type 'unsigned long long _Fract' to non-matching type 'long int'" } */
+  (long)fSsf(); /* { dg-warning "cast from function call of type '_Sat short _Fract' to non-matching type 'long int'" } */
+  (long)fSf(); /* { dg-warning "cast from function call of type '_Sat _Fract' to non-matching type 'long int'" } */
+  (long)fSlf(); /* { dg-warning "cast from function call of type '_Sat long _Fract' to non-matching type 'long int'" } */
+  (long)fSllf(); /* { dg-warning "cast from function call of type '_Sat long long _Fract' to non-matching type 'long int'" } */
+  (long)fSusf(); /* { dg-warning "cast from function call of type '_Sat unsigned short _Fract' to non-matching type 'long int'" } */
+  (long)fSuf(); /* { dg-warning "cast from function call of type '_Sat unsigned _Fract' to non-matching type 'long int'" } */
+  (long)fSulf(); /* { dg-warning "cast from function call of type '_Sat unsigned long _Fract' to non-matching type 'long int'" } */
+  (long)fSullf(); /* { dg-warning "cast from function call of type '_Sat unsigned long long _Fract' to non-matching type 'long int'" } */
+  (long)fsa(); /* { dg-warning "cast from function call of type 'short _Accum' to non-matching type 'long int'" } */
+  (long)fa(); /* { dg-warning "cast from function call of type '_Accum' to non-matching type 'long int'" } */
+  (long)fla(); /* { dg-warning "cast from function call of type 'long _Accum' to non-matching type 'long int'" } */
+  (long)flla(); /* { dg-warning "cast from function call of type 'long long _Accum' to non-matching type 'long int'" } */
+  (long)fusa(); /* { dg-warning "cast from function call of type 'unsigned short _Accum' to non-matching type 'long int'" } */
+  (long)fua(); /* { dg-warning "cast from function call of type 'unsigned _Accum' to non-matching type 'long int'" } */
+  (long)fula(); /* { dg-warning "cast from function call of type 'unsigned long _Accum' to non-matching type 'long int'" } */
+  (long)fulla(); /* { dg-warning "cast from function call of type 'unsigned long long _Accum' to non-matching type 'long int'" } */
+  (long)fSsa(); /* { dg-warning "cast from function call of type '_Sat short _Accum' to non-matching type 'long int'" } */
+  (long)fSa(); /* { dg-warning "cast from function call of type '_Sat _Accum' to non-matching type 'long int'" } */
+  (long)fSla(); /* { dg-warning "cast from function call of type '_Sat long _Accum' to non-matching type 'long int'" } */
+  (long)fSlla(); /* { dg-warning "cast from function call of type '_Sat long long _Accum' to non-matching type 'long int'" } */
+  (long)fSusa(); /* { dg-warning "cast from function call of type '_Sat unsigned short _Accum' to non-matching type 'long int'" } */
+  (long)fSua(); /* { dg-warning "cast from function call of type '_Sat unsigned _Accum' to non-matching type 'long int'" } */
+  (long)fSula(); /* { dg-warning "cast from function call of type '_Sat unsigned long _Accum' to non-matching type 'long int'" } */
+  (long)fSulla(); /* { dg-warning "cast from function call of type '_Sat unsigned long long _Accum' to non-matching type 'long int'" } */
+
+  (long int)fsf(); /* { dg-warning "cast from function call of type 'short _Fract' to non-matching type 'long int'" } */
+  (long int)ff(); /* { dg-warning "cast from function call of type '_Fract' to non-matching type 'long int'" } */
+  (long int)flf(); /* { dg-warning "cast from function call of type 'long _Fract' to non-matching type 'long int'" } */
+  (long int)fllf(); /* { dg-warning "cast from function call of type 'long long _Fract' to non-matching type 'long int'" } */
+  (long int)fusf(); /* { dg-warning "cast from function call of type 'unsigned short _Fract' to non-matching type 'long int'" } */
+  (long int)fuf(); /* { dg-warning "cast from function call of type 'unsigned _Fract' to non-matching type 'long int'" } */
+  (long int)fulf(); /* { dg-warning "cast from function call of type 'unsigned long _Fract' to non-matching type 'long int'" } */
+  (long int)fullf(); /* { dg-warning "cast from function call of type 'unsigned long long _Fract' to non-matching type 'long int'" } */
+  (long int)fSsf(); /* { dg-warning "cast from function call of type '_Sat short _Fract' to non-matching type 'long int'" } */
+  (long int)fSf(); /* { dg-warning "cast from function call of type '_Sat _Fract' to non-matching type 'long int'" } */
+  (long int)fSlf(); /* { dg-warning "cast from function call of type '_Sat long _Fract' to non-matching type 'long int'" } */
+  (long int)fSllf(); /* { dg-warning "cast from function call of type '_Sat long long _Fract' to non-matching type 'long int'" } */
+  (long int)fSusf(); /* { dg-warning "cast from function call of type '_Sat unsigned short _Fract' to non-matching type 'long int'" } */
+  (long int)fSuf(); /* { dg-warning "cast from function call of type '_Sat unsigned _Fract' to non-matching type 'long int'" } */
+  (long int)fSulf(); /* { dg-warning "cast from function call of type '_Sat unsigned long _Fract' to non-matching type 'long int'" } */
+  (long int)fSullf(); /* { dg-warning "cast from function call of type '_Sat unsigned long long _Fract' to non-matching type 'long int'" } */
+  (long int)fsa(); /* { dg-warning "cast from function call of type 'short _Accum' to non-matching type 'long int'" } */
+  (long int)fa(); /* { dg-warning "cast from function call of type '_Accum' to non-matching type 'long int'" } */
+  (long int)fla(); /* { dg-warning "cast from function call of type 'long _Accum' to non-matching type 'long int'" } */
+  (long int)flla(); /* { dg-warning "cast from function call of type 'long long _Accum' to non-matching type 'long int'" } */
+  (long int)fusa(); /* { dg-warning "cast from function call of type 'unsigned short _Accum' to non-matching type 'long int'" } */
+  (long int)fua(); /* { dg-warning "cast from function call of type 'unsigned _Accum' to non-matching type 'long int'" } */
+  (long int)fula(); /* { dg-warning "cast from function call of type 'unsigned long _Accum' to non-matching type 'long int'" } */
+  (long int)fulla(); /* { dg-warning "cast from function call of type 'unsigned long long _Accum' to non-matching type 'long int'" } */
+  (long int)fSsa(); /* { dg-warning "cast from function call of type '_Sat short _Accum' to non-matching type 'long int'" } */
+  (long int)fSa(); /* { dg-warning "cast from function call of type '_Sat _Accum' to non-matching type 'long int'" } */
+  (long int)fSla(); /* { dg-warning "cast from function call of type '_Sat long _Accum' to non-matching type 'long int'" } */
+  (long int)fSlla(); /* { dg-warning "cast from function call of type '_Sat long long _Accum' to non-matching type 'long int'" } */
+  (long int)fSusa(); /* { dg-warning "cast from function call of type '_Sat unsigned short _Accum' to non-matching type 'long int'" } */
+  (long int)fSua(); /* { dg-warning "cast from function call of type '_Sat unsigned _Accum' to non-matching type 'long int'" } */
+  (long int)fSula(); /* { dg-warning "cast from function call of type '_Sat unsigned long _Accum' to non-matching type 'long int'" } */
+  (long int)fSulla(); /* { dg-warning "cast from function call of type '_Sat unsigned long long _Accum' to non-matching type 'long int'" } */
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/addsub.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/addsub.c
new file mode 100644
index 000000000..c2ab38fd4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/addsub.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* Check if GCC generates warnings when overflows.  */
+
+_Fract a0 = 0.5r + 0.5r; /* { dg-warning "overflow" } */
+_Fract a1 = 0.5r + 0.6r; /* { dg-warning "overflow" } */
+_Fract a2 = 0.5r + -0.6r;
+_Fract a3 = -0.5r + 0.6r;
+_Fract a4 = -0.5r + -0.5r;
+_Fract a5 = -0.5r + -0.6r; /* { dg-warning "overflow" } */
+_Fract a6 = 0.0r + __FRACT_MIN__;
+_Fract a7 = 0.1r + __FRACT_MIN__;
+_Fract a8 = -0.1r + __FRACT_MIN__; /* { dg-warning "overflow" } */
+_Fract a9 = 0.0r + __FRACT_MAX__;
+_Fract a10 = 0.1r + __FRACT_MAX__; /* { dg-warning "overflow" } */
+_Fract a11 = -0.1r + __FRACT_MAX__;
+
+_Fract b0 = 0.5r - 0.5r;
+_Fract b1 = 0.5r - 0.6r;
+_Fract b2 = 0.5r - -0.6r; /* { dg-warning "overflow" } */
+_Fract b3 = -0.5r - 0.6r; /* { dg-warning "overflow" } */
+_Fract b4 = -0.5r - -0.5r;
+_Fract b5 = -0.5r - -0.6r;
+_Fract b6 = 0.0r - __FRACT_MIN__; /* { dg-warning "overflow" } */
+_Fract b7 = 0.1r - __FRACT_MIN__; /* { dg-warning "overflow" } */
+_Fract b8 = -0.1r - __FRACT_MIN__;
+_Fract b9 = 0.0r - __FRACT_MAX__;
+_Fract b10 = 0.1r - __FRACT_MAX__;
+_Fract b11 = -0.1r - __FRACT_MAX__; /* { dg-warning "overflow" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allconv.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allconv.c
new file mode 100644
index 000000000..e0440dac2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allconv.c
@@ -0,0 +1,150 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.3 Conversions.
+
+   Check if all conversions are ok.  */
+
+#define CONV(TYPE, NAME) \
+        float NAME ## _to_SF (TYPE a) { return a; } \
+        float Sat ## NAME ## _to_SF (_Sat TYPE a) { return a; } \
+        double NAME ## _to_DF (TYPE a) { return a; } \
+        double Sat ## NAME ## _to_DF (_Sat TYPE a) { return a; } \
+        TYPE SF_to_ ## NAME (float a) { return a; } \
+        _Sat TYPE SF_to_Sat ## NAME (float a) { return a; } \
+        TYPE DF_to_ ## NAME (double a) { return a; } \
+        _Sat TYPE DF_to_Sat ## NAME (double a) { return a; } \
+        signed char NAME ## _to_schar (TYPE a) { return a; } \
+        signed char Sat ## NAME ## _to_schar (_Sat TYPE a) { return a; } \
+        unsigned char NAME ## _to_uchar (TYPE a) { return a; } \
+        unsigned char Sat ## NAME ## _to_uchar (_Sat TYPE a) { return a; } \
+        short NAME ## _to_short (TYPE a) { return a; } \
+        short _Sat ## NAME ## _to_short (_Sat TYPE a) { return a; } \
+        unsigned short NAME ## _to_ushort (TYPE a) { return a; } \
+        unsigned short _Sat ## NAME ## _to_ushort (_Sat TYPE a) { return a; } \
+        int NAME ## _to_int (TYPE a) { return a; } \
+        int _Sat ## NAME ## _to_int (_Sat TYPE a) { return a; } \
+        unsigned int NAME ## _to_uint (TYPE a) { return a; } \
+        unsigned int _Sat ## NAME ## _to_uint (_Sat TYPE a) { return a; } \
+        long NAME ## _to_long (TYPE a) { return a; } \
+        unsigned long NAME ## _to_ulong (TYPE a) { return a; } \
+        long _Sat ## NAME ## _to_long (TYPE a) { return a; } \
+        unsigned long _Sat ## NAME ## _to_ulong (TYPE a) { return a; } \
+        long long NAME ## _to_longlong (TYPE a) { return a; } \
+        long long _Sat ## NAME ## _to_longlong (TYPE a) { return a; } \
+        unsigned long long NAME ## _to_ulonglong (TYPE a) { return a; } \
+        unsigned long long _Sat ## NAME ## _to_ulonglong (TYPE a) { return a; } \
+        TYPE schar_to_ ## NAME (signed char a) { return a; } \
+        _Sat TYPE schar_to_Sat ## NAME (signed char a) { return a; } \
+        TYPE uchar_to_ ## NAME (unsigned char a) { return a; } \
+        _Sat TYPE uchar_to_Sat ## NAME (unsigned char a) { return a; } \
+        TYPE short_to_ ## NAME (short a) { return a; } \
+        TYPE ushort_to_ ## NAME (unsigned short a) { return a; } \
+        TYPE int_to_ ## NAME (int a) { return a; } \
+        TYPE uint_to_ ## NAME (unsigned int a) { return a; } \
+        TYPE long_to_ ## NAME (long a) { return a; } \
+        TYPE ulong_to_ ## NAME (unsigned long a) { return a; } \
+        TYPE longlong_to_ ## NAME (long long a) { return a; } \
+        TYPE ulonglong_to_ ## NAME (unsigned long long a) { return a; } \
+        _Sat TYPE short_to_Sat ## NAME (short a) { return a; } \
+        _Sat TYPE ushort_to_Sat ## NAME (unsigned short a) { return a; } \
+        _Sat TYPE int_to_Sat ## NAME (int a) { return a; } \
+        _Sat TYPE uint_to_Sat ## NAME (unsigned int a) { return a; } \
+        _Sat TYPE long_to_Sat ## NAME (long a) { return a; } \
+        _Sat TYPE ulong_to_Sat ## NAME (unsigned long a) { return a; } \
+        _Sat TYPE longlong_to_Sat ## NAME (long long a) { return a; } \
+        _Sat TYPE ulonglong_to_Sat ## NAME (unsigned long long a) { return a; } \
+	TYPE SFR_to ## NAME (short _Fract a) { return a; } \
+	TYPE FR_to ## NAME (_Fract a) { return a; } \
+	TYPE LFR_to ## NAME (long _Fract a) { return a; } \
+	TYPE LLFR_to ## NAME (long long _Fract a) { return a; } \
+	TYPE USFR_to ## NAME (unsigned short _Fract a) { return a; } \
+	TYPE UFR_to ## NAME (unsigned _Fract a) { return a; } \
+	TYPE ULFR_to ## NAME (unsigned long _Fract a) { return a; } \
+	TYPE ULLFR_to ## NAME (unsigned long long _Fract a) { return a; } \
+	TYPE SAC_to ## NAME (short _Accum a) { return a; } \
+	TYPE AC_to ## NAME (_Accum a) { return a; } \
+	TYPE LAC_to ## NAME (long _Accum a) { return a; } \
+	TYPE LLAC_to ## NAME (long long _Accum a) { return a; } \
+	TYPE USAC_to ## NAME (unsigned short _Accum a) { return a; } \
+	TYPE UAC_to ## NAME (unsigned _Accum a) { return a; } \
+	TYPE ULAC_to ## NAME (unsigned long _Accum a) { return a; } \
+	TYPE ULLAC_to ## NAME (unsigned long long _Accum a) { return a; } \
+	TYPE SATSFR_to ## NAME (_Sat short _Fract a) { return a; } \
+	TYPE SATFR_to ## NAME (_Sat _Fract a) { return a; } \
+	TYPE SATLFR_to ## NAME (_Sat long _Fract a) { return a; } \
+	TYPE SATLLFR_to ## NAME (_Sat long long _Fract a) { return a; } \
+	TYPE SATUSFR_to ## NAME (_Sat unsigned short _Fract a) { return a; } \
+	TYPE SATUFR_to ## NAME (_Sat unsigned _Fract a) { return a; } \
+	TYPE SATULFR_to ## NAME (_Sat unsigned long _Fract a) { return a; } \
+	TYPE SATULLFR_to ## NAME (_Sat unsigned long long _Fract a) { return a; } \
+	TYPE SATSAC_to ## NAME (_Sat short _Accum a) { return a; } \
+	TYPE SATAC_to ## NAME (_Sat _Accum a) { return a; } \
+	TYPE SATLAC_to ## NAME (_Sat long _Accum a) { return a; } \
+	TYPE SATLLAC_to ## NAME (_Sat long long _Accum a) { return a; } \
+	TYPE SATUSAC_to ## NAME (_Sat unsigned short _Accum a) { return a; } \
+	TYPE SATUAC_to ## NAME (_Sat unsigned _Accum a) { return a; } \
+	TYPE SATULAC_to ## NAME (_Sat unsigned long _Accum a) { return a; } \
+	TYPE SATULLAC_to ## NAME (_Sat unsigned long long _Accum a) { return a; } \
+	_Sat TYPE SFR_to_SAT ## NAME (short _Fract a) { return a; } \
+	_Sat TYPE FR_to_SAT ## NAME (_Fract a) { return a; } \
+	_Sat TYPE LFR_to_SAT ## NAME (long _Fract a) { return a; } \
+	_Sat TYPE LLFR_to_SAT ## NAME (long long _Fract a) { return a; } \
+	_Sat TYPE USFR_to_SAT ## NAME (unsigned short _Fract a) { return a; } \
+	_Sat TYPE UFR_to_SAT ## NAME (unsigned _Fract a) { return a; } \
+	_Sat TYPE ULFR_to_SAT ## NAME (unsigned long _Fract a) { return a; } \
+	_Sat TYPE ULLFR_to_SAT ## NAME (unsigned long long _Fract a) { return a; } \
+	_Sat TYPE SAC_to_SAT ## NAME (short _Accum a) { return a; } \
+	_Sat TYPE AC_to_SAT ## NAME (_Accum a) { return a; } \
+	_Sat TYPE LAC_to_SAT ## NAME (long _Accum a) { return a; } \
+	_Sat TYPE LLAC_to_SAT ## NAME (long long _Accum a) { return a; } \
+	_Sat TYPE USAC_to_SAT ## NAME (unsigned short _Accum a) { return a; } \
+	_Sat TYPE UAC_to_SAT ## NAME (unsigned _Accum a) { return a; } \
+	_Sat TYPE ULAC_to_SAT ## NAME (unsigned long _Accum a) { return a; } \
+	_Sat TYPE ULLAC_to_SAT ## NAME (unsigned long long _Accum a) { return a; } \
+	_Sat TYPE SATSFR_to_SAT ## NAME (_Sat short _Fract a) { return a; } \
+	_Sat TYPE SATFR_to_SAT ## NAME (_Sat _Fract a) { return a; } \
+	_Sat TYPE SATLFR_to_SAT ## NAME (_Sat long _Fract a) { return a; } \
+	_Sat TYPE SATLLFR_to_SAT ## NAME (_Sat long long _Fract a) { return a; } \
+	_Sat TYPE SATUSFR_to_SAT ## NAME (_Sat unsigned short _Fract a) { return a; } \
+	_Sat TYPE SATUFR_to_SAT ## NAME (_Sat unsigned _Fract a) { return a; } \
+	_Sat TYPE SATULFR_to_SAT ## NAME (_Sat unsigned long _Fract a) { return a; } \
+	_Sat TYPE SATULLFR_to_SAT ## NAME (_Sat unsigned long long _Fract a) { return a; } \
+	_Sat TYPE SATSAC_to_SAT ## NAME (_Sat short _Accum a) { return a; } \
+	_Sat TYPE SATAC_to_SAT ## NAME (_Sat _Accum a) { return a; } \
+	_Sat TYPE SATLAC_to_SAT ## NAME (_Sat long _Accum a) { return a; } \
+	_Sat TYPE SATLLAC_to_SAT ## NAME (_Sat long long _Accum a) { return a; } \
+	_Sat TYPE SATUSAC_to_SAT ## NAME (_Sat unsigned short _Accum a) { return a; } \
+	_Sat TYPE SATUAC_to_SAT ## NAME (_Sat unsigned _Accum a) { return a; } \
+	_Sat TYPE SATULAC_to_SAT ## NAME (_Sat unsigned long _Accum a) { return a; } \
+	_Sat TYPE SATULLAC_to_SAT ## NAME (_Sat unsigned long long _Accum a) { return a; } \
+	_Complex int NAME ## _to_CI (TYPE a) { return a; } \
+	_Complex unsigned int NAME ## _to_CUI (TYPE a) { return a; } \
+	_Complex float NAME ## _to_CF (TYPE a) { return a; } \
+	_Complex double NAME ## _to_CD (TYPE a) { return a; } \
+	TYPE CI_to_ ## NAME (_Complex int a) { return a; } \
+	TYPE CUI_to_ ## NAME (_Complex unsigned int a) { return a; } \
+	TYPE CF_to_ ## NAME (_Complex float a) { return a; } \
+	TYPE CD_to_ ## NAME (_Complex double a) { return a; } \
+	_Sat TYPE CI_to_SAT ## NAME (_Complex int a) { return a; } \
+	_Sat TYPE CUI_to_SAT ## NAME (_Complex unsigned int a) { return a; } \
+	_Sat TYPE CF_to_SAT ## NAME (_Complex float a) { return a; } \
+	_Sat TYPE CD_to_SAT ## NAME (_Complex double a) { return a; }
+
+CONV(short _Fract, sf);
+CONV(_Fract, f);
+CONV(long _Fract, lf);
+CONV(long long _Fract, llf);
+CONV(unsigned short _Fract, usf);
+CONV(unsigned _Fract, uf);
+CONV(unsigned long _Fract, ulf);
+CONV(unsigned long long _Fract, ullf);
+
+CONV(short _Accum, sk);
+CONV(_Accum, k);
+CONV(long _Accum, lk);
+CONV(long long _Accum, llk);
+CONV(unsigned short _Accum, usk);
+CONV(unsigned _Accum, uk);
+CONV(unsigned long _Accum, ulk);
+CONV(unsigned long long _Accum, ullk);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allop-const.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allop-const.c
new file mode 100644
index 000000000..1cf859861
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allop-const.c
@@ -0,0 +1,147 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.5.7 - Bitwise shift operands.
+   C99 6.5.3 Unary operators.
+   C99 6.5.5 Multiplicative operators.
+   C99 6.5.6 Additive operators.
+   C99 6.5.7 Bitwise shift operators.
+   C99 6.5.8 Relational operators.
+   C99 6.5.9 Equality operators.
+   C99 6.5.16 Assignment operators.
+
+   Check if all operations on constants are ok.  */
+
+#define ALLOPCONST(TYPE,NAME,POSTFIX) \
+	TYPE NAME ## plus = +0.1 ## POSTFIX; \
+	unsigned TYPE NAME ## u_plus = +0.1u ## POSTFIX; \
+	_Sat TYPE NAME ## sat_plus = +(_Sat TYPE)0.1 ## POSTFIX; \
+	_Sat unsigned TYPE NAME ## sat_u_plus = +(_Sat unsigned TYPE)0.1u ## POSTFIX; \
+	TYPE NAME ## neg = -0.1 ## POSTFIX; \
+	_Sat TYPE NAME ## sat_neg = -(_Sat TYPE)0.1 ## POSTFIX; \
+	_Sat unsigned TYPE NAME ## sat_u_neg = -(_Sat unsigned TYPE)0.1u ## POSTFIX; \
+	int NAME ## logneg1 = !0.1 ## POSTFIX; \
+	int NAME ## logneg1u = !0.1u ## POSTFIX; \
+	int NAME ## logneg2 = !0.0 ## POSTFIX; \
+	int NAME ## logneg2u = !0.0u ## POSTFIX; \
+	TYPE NAME ## add = 0.1 ## POSTFIX + 0.2 ## POSTFIX; \
+	unsigned TYPE NAME ## u_add = 0.1u ## POSTFIX + 0.2u ## POSTFIX; \
+	_Sat TYPE NAME ## sat_add = (_Sat TYPE)0.8 ## POSTFIX + 0.3 ## POSTFIX; \
+	_Sat unsigned TYPE NAME ## sat_u_add = (_Sat unsigned TYPE)0.8u ## POSTFIX + 0.3u ## POSTFIX; \
+	TYPE NAME ## sub = 0.1 ## POSTFIX - 0.2 ## POSTFIX; \
+	unsigned TYPE NAME ## u_sub = 0.2u ## POSTFIX - 0.1u ## POSTFIX; \
+	_Sat TYPE NAME ## sat_sub = (_Sat TYPE)0.1 ## POSTFIX - 0.2 ## POSTFIX; \
+	_Sat unsigned TYPE NAME ## sat_u_sub = (_Sat unsigned TYPE)0.1u ## POSTFIX - 0.2u ## POSTFIX; \
+	TYPE NAME ## mul = 0.1 ## POSTFIX * 0.2 ## POSTFIX; \
+	unsigned TYPE NAME ## u_mul = 0.1u ## POSTFIX * 0.2u ## POSTFIX; \
+	_Sat TYPE NAME ## sat_mul = (_Sat TYPE)0.1 ## POSTFIX * 0.2 ## POSTFIX; \
+	_Sat unsigned TYPE NAME ## sat_u_mul = (_Sat unsigned TYPE)0.1u ## POSTFIX * 0.2u ## POSTFIX; \
+	TYPE NAME ## div = 0.1 ## POSTFIX / 0.3 ## POSTFIX; \
+	unsigned TYPE NAME ## u_div = 0.1u ## POSTFIX / 0.3u ## POSTFIX; \
+	_Sat TYPE NAME ## sat_div = (_Sat TYPE)0.3 ## POSTFIX / 0.1 ## POSTFIX; \
+	_Sat unsigned TYPE NAME ## sat_u_div = (_Sat unsigned TYPE)0.3u ## POSTFIX / 0.1u ## POSTFIX; \
+	TYPE NAME ## shl = 0.1 ## POSTFIX << 3; \
+	unsigned TYPE NAME ## u_shl = 0.1u ## POSTFIX << 3; \
+	_Sat TYPE NAME ## sat_shl = (_Sat TYPE)0.8 ## POSTFIX << 3; \
+	_Sat unsigned TYPE NAME ## sat_u_shl = (_Sat unsigned TYPE)0.8u ## POSTFIX << 3; \
+	TYPE NAME ## shr = 0.1 ## POSTFIX >> 5; \
+	unsigned TYPE NAME ## u_shr = 0.1u ## POSTFIX >> 5; \
+	_Sat TYPE NAME ## sat_shr = (_Sat TYPE)0.1 ## POSTFIX >> 5; \
+	_Sat unsigned TYPE NAME ## sat_u_shr = (_Sat unsigned TYPE)0.1 ## POSTFIX >> 5; \
+	int NAME ## ne = 0.1 ## POSTFIX != 0.2 ## POSTFIX; \
+	int NAME ## u_ne = 0.1u ## POSTFIX != 0.2u ## POSTFIX; \
+	int NAME ## eq = 0.1 ## POSTFIX == 0.2 ## POSTFIX; \
+	int NAME ## u_eq = 0.1u ## POSTFIX == 0.2u ## POSTFIX; \
+	int NAME ## gt = 0.1 ## POSTFIX > 0.2 ## POSTFIX; \
+	int NAME ## u_gt = 0.1u ## POSTFIX > 0.2u ## POSTFIX; \
+	int NAME ## ge = 0.1 ## POSTFIX >= 0.2 ## POSTFIX; \
+	int NAME ## u_ge = 0.1u ## POSTFIX >= 0.2 ## POSTFIX; \
+	int NAME ## lt = 0.1 ## POSTFIX < 0.2 ## POSTFIX; \
+	int NAME ## u_lt = 0.1u ## POSTFIX < 0.2 ## POSTFIX; \
+	int NAME ## le = 0.1 ## POSTFIX <= 0.2 ## POSTFIX; \
+	int NAME ## u_le = 0.1u ## POSTFIX <= 0.2 ## POSTFIX; \
+	int NAME ## ne2 = 0.2 ## POSTFIX != 0.2 ## POSTFIX; \
+	int NAME ## u_ne2 = 0.2u ## POSTFIX != 0.2u ## POSTFIX; \
+	int NAME ## eq2 = 0.2 ## POSTFIX == 0.2 ## POSTFIX; \
+	int NAME ## u_eq2 = 0.2u ## POSTFIX == 0.2u ## POSTFIX; \
+	int NAME ## gt2 = 0.2 ## POSTFIX > 0.2 ## POSTFIX; \
+	int NAME ## u_gt2 = 0.2u ## POSTFIX > 0.2u ## POSTFIX; \
+	int NAME ## ge2 = 0.2 ## POSTFIX >= 0.2 ## POSTFIX; \
+	int NAME ## u_ge2 = 0.2u ## POSTFIX >= 0.2 ## POSTFIX; \
+	int NAME ## lt2 = 0.2 ## POSTFIX < 0.2 ## POSTFIX; \
+	int NAME ## u_lt2 = 0.2u ## POSTFIX < 0.2 ## POSTFIX; \
+	int NAME ## le2 = 0.2 ## POSTFIX <= 0.2 ## POSTFIX; \
+	int NAME ## u_le2 = 0.2u ## POSTFIX <= 0.2 ## POSTFIX; \
+	TYPE NAME ## hr_signed = 0.1hr; \
+	unsigned TYPE NAME ## hr_unsigned = 0.1hr; \
+	_Sat TYPE NAME ## hr_sat_signed = 0.1hr; \
+	_Sat unsigned TYPE NAME ## hr_sat_unsigned = 0.1hr; \
+	TYPE NAME ## r_signed = 0.1r; \
+	unsigned TYPE NAME ## r_unsigned = 0.1r; \
+	_Sat TYPE NAME ## r_sat_signed = 0.1r; \
+	_Sat unsigned TYPE NAME ## r_sat_unsigned = 0.1r; \
+	TYPE NAME ## lr_signed = 0.1lr; \
+	unsigned TYPE NAME ## lr_unsigned = 0.1lr; \
+	_Sat TYPE NAME ## lr_sat_signed = 0.1lr; \
+	_Sat unsigned TYPE NAME ## lr_sat_unsigned = 0.1lr; \
+	TYPE NAME ## llr_signed = 0.1llr; \
+	unsigned TYPE NAME ## llr_unsigned = 0.1llr; \
+	_Sat TYPE NAME ## llr_sat_signed = 0.1llr; \
+	_Sat unsigned TYPE NAME ## llr_sat_unsigned = 0.1llr; \
+	TYPE NAME ## uhr_signed = 0.1uhr; \
+	unsigned TYPE NAME ## uhr_unsigned = 0.1uhr; \
+	_Sat TYPE NAME ## uhr_sat_signed = 0.1uhr; \
+	_Sat unsigned TYPE NAME ## uhr_sat_unsigned = 0.1uhr; \
+	TYPE NAME ## ur_signed = 0.1ur; \
+	unsigned TYPE NAME ## ur_unsigned = 0.1ur; \
+	_Sat TYPE NAME ## ur_sat_signed = 0.1ur; \
+	_Sat unsigned TYPE NAME ## ur_sat_unsigned = 0.1ur; \
+	TYPE NAME ## ulr_signed = 0.1ulr; \
+	unsigned TYPE NAME ## ulr_unsigned = 0.1ulr; \
+	_Sat TYPE NAME ## ulr_sat_signed = 0.1ulr; \
+	_Sat unsigned TYPE NAME ## ulr_sat_unsigned = 0.1ulr; \
+	TYPE NAME ## ullr_signed = 0.1ullr; \
+	unsigned TYPE NAME ## ullr_unsigned = 0.1ullr; \
+	_Sat TYPE NAME ## ullr_sat_signed = 0.1ullr; \
+	_Sat unsigned TYPE NAME ## ullr_sat_unsigned = 0.1ullr; \
+	TYPE NAME ## hk_signed = 0.1hk; \
+	unsigned TYPE NAME ## hk_unsigned = 0.1hk; \
+	_Sat TYPE NAME ## hk_sat_signed = 5.1hk; \
+	_Sat unsigned TYPE NAME ## hk_sat_unsigned = 5.1hk; \
+	TYPE NAME ## k_signed = 0.1k; \
+	unsigned TYPE NAME ## k_unsigned = 0.1k; \
+	_Sat TYPE NAME ## k_sat_signed = 5.1k; \
+	_Sat unsigned TYPE NAME ## k_sat_unsigned = 5.1k; \
+	TYPE NAME ## lk_signed = 0.1lk; \
+	unsigned TYPE NAME ## lk_unsigned = 0.1lk; \
+	_Sat TYPE NAME ## lk_sat_signed = 5.1lk; \
+	_Sat unsigned TYPE NAME ## lk_sat_unsigned = 5.1lk; \
+	TYPE NAME ## llk_signed = 0.1llk; \
+	unsigned TYPE NAME ## llk_unsigned = 0.1llk; \
+	_Sat TYPE NAME ## llk_sat_signed = 5.1llk; \
+	_Sat unsigned TYPE NAME ## llk_sat_unsigned = 5.1llk; \
+	TYPE NAME ## uhk_signed = 0.1uhk; \
+	unsigned TYPE NAME ## uhk_unsigned = 0.1uhk; \
+	_Sat TYPE NAME ## uhk_sat_signed = 5.1uhk; \
+	_Sat unsigned TYPE NAME ## uhk_sat_unsigned = 5.1uhk; \
+	TYPE NAME ## uk_signed = 0.1uk; \
+	unsigned TYPE NAME ## uk_unsigned = 0.1uk; \
+	_Sat TYPE NAME ## uk_sat_signed = 5.1uk; \
+	_Sat unsigned TYPE NAME ## uk_sat_unsigned = 5.1uk; \
+	TYPE NAME ## ulk_signed = 0.1ulk; \
+	unsigned TYPE NAME ## ulk_unsigned = 0.1ulk; \
+	_Sat TYPE NAME ## ulk_sat_signed = 5.1ulk; \
+	_Sat unsigned TYPE NAME ## ulk_sat_unsigned = 5.1ulk; \
+	TYPE NAME ## ullk_signed = 0.1ullk; \
+	unsigned TYPE NAME ## ullk_unsigned = 0.1ullk; \
+	_Sat TYPE NAME ## ullk_sat_signed = 5.1ullk; \
+	_Sat unsigned TYPE NAME ## ullk_sat_unsigned = 5.1ullk; \
+
+ALLOPCONST(short _Fract, sf, hr);
+ALLOPCONST(_Fract, f, r);
+ALLOPCONST(long _Fract, lf, lr);
+ALLOPCONST(long long _Fract, llf, llr);
+ALLOPCONST(short _Accum, sa, hk);
+ALLOPCONST(_Accum, a, k);
+ALLOPCONST(long _Accum, la, lk);
+ALLOPCONST(long long _Accum, lla, llk);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allop.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allop.c
new file mode 100644
index 000000000..eb36c097c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/allop.c
@@ -0,0 +1,87 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.5.7 - Bitwise shift operands.
+   C99 6.5.3 Unary operators.
+   C99 6.5.5 Multiplicative operators.
+   C99 6.5.6 Additive operators.
+   C99 6.5.7 Bitwise shift operators.
+   C99 6.5.8 Relational operators.
+   C99 6.5.9 Equality operators.
+   C99 6.5.16 Assignment operators.
+
+   Check if all operations are ok.  */
+
+void true();
+void false();
+
+#define ALLOP(TYPE,NAME) \
+  TYPE test1 ## NAME (TYPE a)  { return +a; } \
+  TYPE test2 ## NAME (TYPE a)  { return -a; } \
+  int test3 ## NAME (TYPE a)  { return !a; } \
+  TYPE test4 ## NAME (TYPE a, TYPE b) { return a + b; } \
+  TYPE test5 ## NAME (TYPE a, TYPE b) { return a - b; } \
+  TYPE test6 ## NAME (TYPE a, TYPE b) { return a * b; } \
+  TYPE test7 ## NAME (TYPE a, TYPE b) { return a / b; } \
+  TYPE test8 ## NAME (TYPE a, TYPE b) { a += b; return a; } \
+  TYPE test9 ## NAME (TYPE a, TYPE b) { a -= b; return a; } \
+  TYPE test10 ## NAME (TYPE a, TYPE b) { a *= b; return a; } \
+  TYPE test11 ## NAME (TYPE a, TYPE b) { a /= b; return a; } \
+  TYPE test12 ## NAME (TYPE a, int b) { return a << b; } \
+  TYPE test13 ## NAME (TYPE a, int b) { return a >> b; } \
+  TYPE test14 ## NAME (TYPE a, int b) { a <<= b; return a; } \
+  TYPE test15 ## NAME (TYPE a, int b) { a >>= b; return a; } \
+  int test16 ## NAME (TYPE a, TYPE b) { return a == b; } \
+  int test17 ## NAME (TYPE a, TYPE b) { return a != b; } \
+  int test18 ## NAME (TYPE a, TYPE b) { return a < b; } \
+  int test19 ## NAME (TYPE a, TYPE b) { return a <= b; } \
+  int test20 ## NAME (TYPE a, TYPE b) { return a >= b; } \
+  int test21 ## NAME (TYPE a, TYPE b) { return a > b; } \
+  void test22 ## NAME (TYPE a, TYPE b) { if(a == b)true(); else false(); } \
+  void test23 ## NAME (TYPE a, TYPE b) { if(a != b)true(); else false(); } \
+  void test24 ## NAME (TYPE a, TYPE b) { if(a < b)true(); else false(); } \
+  void test25 ## NAME (TYPE a, TYPE b) { if(a <= b)true(); else false(); } \
+  void test26 ## NAME (TYPE a, TYPE b) { if(a >= b)true(); else false(); } \
+  void test27 ## NAME (TYPE a, TYPE b) { if(a > b)true(); else false(); } \
+  TYPE test28 ## NAME (TYPE a) { return ++a; } \
+  TYPE test29 ## NAME (TYPE a) { return --a; } \
+  TYPE test30 ## NAME (TYPE *a) { return ++(*a); } \
+  TYPE test31 ## NAME (TYPE *a) { return (*a)++; } \
+  TYPE test32 ## NAME (TYPE *a) { return --(*a); } \
+  TYPE test33 ## NAME (TYPE *a) { return (*a)--; }
+
+ALLOP(short _Fract, sf);
+ALLOP(_Fract, f);
+ALLOP(long _Fract, lf);
+ALLOP(long long _Fract, llf);
+ALLOP(short _Accum, sa);
+ALLOP(_Accum, a);
+ALLOP(long _Accum, la);
+ALLOP(long long _Accum, lla);
+
+ALLOP(unsigned short _Fract, usf);
+ALLOP(unsigned _Fract, uf);
+ALLOP(unsigned long _Fract, ulf);
+ALLOP(unsigned long long _Fract, ullf);
+ALLOP(unsigned short _Accum, usa);
+ALLOP(unsigned _Accum, ua);
+ALLOP(unsigned long _Accum, ula);
+ALLOP(unsigned long long _Accum, ulla);
+
+ALLOP(_Sat short _Fract, Ssf);
+ALLOP(_Sat _Fract, Sf);
+ALLOP(_Sat long _Fract, Slf);
+ALLOP(_Sat long long _Fract, Sllf);
+ALLOP(_Sat short _Accum, Ssa);
+ALLOP(_Sat _Accum, Sa);
+ALLOP(_Sat long _Accum, Sla);
+ALLOP(_Sat long long _Accum, Slla);
+
+ALLOP(_Sat unsigned short _Fract, Susf);
+ALLOP(_Sat unsigned  _Fract, Suf);
+ALLOP(_Sat unsigned long _Fract, Sulf);
+ALLOP(_Sat unsigned long long _Fract, Sullf);
+ALLOP(_Sat unsigned short _Accum, Susa);
+ALLOP(_Sat unsigned  _Accum, Sua);
+ALLOP(_Sat unsigned long _Accum, Sula);
+ALLOP(_Sat unsigned long long _Accum, Sulla);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/binary.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/binary.c
new file mode 100644
index 000000000..e2cb6ea25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/binary.c
@@ -0,0 +1,158 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.5.7 - Bitwise shift operands.
+   C99 6.5.5 Multiplicative operators.
+   C99 6.5.6 Additive operators.
+   C99 6.5.7 Bitwise shift operators.
+   C99 6.5.8 Relational operators.
+   C99 6.5.9 Equality operators.
+   C99 6.5.16 Assignment operators.
+
+   Check binary operators + - * / << >> < <= >= > == != += -= *= /= <<= >>=.  */
+
+extern void abort (void);
+
+#define BINARY(TYPE,POSTFIX) \
+  { TYPE a = 0.5 ## POSTFIX; \
+    TYPE b = 0.25 ## POSTFIX; \
+    if (a + b != 0.75 ## POSTFIX) \
+      abort(); \
+    if (a - b != 0.25 ## POSTFIX) \
+      abort(); \
+    if (a * b != 0.125 ## POSTFIX) \
+      abort(); \
+    if (b / a != 0.5 ## POSTFIX) \
+      abort(); \
+    if (b << 1 != a) \
+      abort(); \
+    if (a >> 1 != b) \
+      abort(); \
+    if (a < b != 0) \
+      abort(); \
+    if (a <= b != 0) \
+      abort(); \
+    if (a > b != 1) \
+      abort(); \
+    if (a >= b != 1) \
+      abort(); \
+    if (a == b != 0) \
+      abort(); \
+    if (a != b != 1) \
+      abort(); \
+    a += b; \
+    if (a != 0.75 ## POSTFIX) \
+      abort(); \
+    a -= b; \
+    if (a != 0.5 ## POSTFIX) \
+      abort(); \
+    a *= b; \
+    if (a != 0.125 ## POSTFIX) \
+      abort(); \
+    a /= b; \
+    if (a != 0.5 ## POSTFIX) \
+      abort(); \
+    a >>= 2; \
+    if (a != 0.125 ## POSTFIX) \
+      abort(); \
+    a <<= 1; \
+    if (a != 0.25 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_SAT_BINARY(TYPE,POSTFIX) \
+  { TYPE a = 0.7 ## POSTFIX; \
+    TYPE b = 0.9 ## POSTFIX; \
+    if (a + b != 1.0 ## POSTFIX) \
+      abort(); \
+    a = -0.7 ## POSTFIX; \
+    b = -0.9 ## POSTFIX; \
+    if (a + b != -0.5 ## POSTFIX - 0.5 ## POSTFIX) \
+      abort(); \
+    a = 0.7 ## POSTFIX; \
+    b = -0.9 ## POSTFIX; \
+    if (a - b != 1.0 ## POSTFIX) \
+      abort(); \
+    a = -0.7 ## POSTFIX; \
+    b = 0.9 ## POSTFIX; \
+    if (a - b != -0.5 ## POSTFIX - 0.5 ## POSTFIX) \
+      abort(); \
+    a = -0.5 ## POSTFIX - 0.5 ## POSTFIX; \
+    if (a * a != 1.0 ## POSTFIX) \
+      abort(); \
+    a = 0.8 ## POSTFIX; \
+    b = 0.5 ## POSTFIX; \
+    if (a / b != 1.0 ## POSTFIX) \
+      abort(); \
+    a = -0.8 ## POSTFIX; \
+    b = 0.5 ## POSTFIX; \
+    if (a / b != -0.5 ## POSTFIX - 0.5 ## POSTFIX) \
+      abort(); \
+    a = 0.1 ## POSTFIX; \
+    if (a << 4 != 1.0 ## POSTFIX) \
+      abort(); \
+    a = -0.8 ## POSTFIX; \
+    if (a << 4 != -0.5 ## POSTFIX - 0.5 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_SAT_UNS_BINARY(TYPE,POSTFIX) \
+  { TYPE a = 0.7 ## POSTFIX; \
+    TYPE b = 0.9 ## POSTFIX; \
+    if (a + b != 1.0 ## POSTFIX) \
+      abort(); \
+    if (a - b != 0.0 ## POSTFIX) \
+      abort(); \
+    if (b / a != 1.0 ## POSTFIX) \
+      abort(); \
+    if (a << 1 != 1.0 ## POSTFIX) \
+      abort(); \
+  }
+
+int main ()
+{
+  BINARY(short _Fract, hr);
+  BINARY(_Fract, r);
+  BINARY(long _Fract, lr);
+  BINARY(long long _Fract, llr);
+  BINARY(unsigned short _Fract, uhr);
+  BINARY(unsigned _Fract, ur);
+  BINARY(unsigned long _Fract, ulr);
+  BINARY(unsigned long long _Fract, ullr);
+  BINARY(_Sat short _Fract, hr);
+  BINARY(_Sat _Fract, r);
+  BINARY(_Sat long _Fract, lr);
+  BINARY(_Sat long long _Fract, llr);
+  BINARY(_Sat unsigned short _Fract, uhr);
+  BINARY(_Sat unsigned _Fract, ur);
+  BINARY(_Sat unsigned long _Fract, ulr);
+  BINARY(_Sat unsigned long long _Fract, ullr);
+  BINARY(short _Accum, hk);
+  BINARY(_Accum, k);
+  BINARY(long _Accum, lk);
+  BINARY(long long _Accum, llk);
+  BINARY(unsigned short _Accum, uhk);
+  BINARY(unsigned _Accum, uk);
+  BINARY(unsigned long _Accum, ulk);
+  BINARY(unsigned long long _Accum, ullk);
+  BINARY(_Sat short _Accum, hk);
+  BINARY(_Sat _Accum, k);
+  BINARY(_Sat long _Accum, lk);
+  BINARY(_Sat long long _Accum, llk);
+  BINARY(_Sat unsigned short _Accum, uhk);
+  BINARY(_Sat unsigned _Accum, uk);
+  BINARY(_Sat unsigned long _Accum, ulk);
+  BINARY(_Sat unsigned long long _Accum, ullk);
+
+  FRACT_SAT_BINARY(_Sat short _Fract, hr);
+  FRACT_SAT_BINARY(_Sat _Fract, r);
+  FRACT_SAT_BINARY(_Sat long _Fract, lr);
+  FRACT_SAT_BINARY(_Sat long long _Fract, llr);
+
+  FRACT_SAT_UNS_BINARY(_Sat unsigned short _Fract, uhr);
+  FRACT_SAT_UNS_BINARY(_Sat unsigned _Fract, ur);
+  FRACT_SAT_UNS_BINARY(_Sat unsigned long _Fract, ulr);
+  FRACT_SAT_UNS_BINARY(_Sat unsigned long long _Fract, ullr);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/bit-complement.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/bit-complement.c
new file mode 100644
index 000000000..76c20d0d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/bit-complement.c
@@ -0,0 +1,76 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.3 Unary ~.  */
+
+void test ()
+{
+  short _Fract sf;
+  _Fract f;
+  long _Fract lf;
+  long long _Fract llf;
+  unsigned short _Fract usf;
+  unsigned _Fract uf;
+  unsigned long _Fract ulf;
+  unsigned long long _Fract ullf;
+  _Sat short _Fract Ssf;
+  _Sat _Fract Sf;
+  _Sat long _Fract Slf;
+  _Sat long long _Fract Sllf;
+  _Sat unsigned short _Fract Susf;
+  _Sat unsigned _Fract Suf;
+  _Sat unsigned long _Fract Sulf;
+  _Sat unsigned long long _Fract Sullf;
+  short _Accum sa;
+  _Accum a;
+  long _Accum la;
+  long long _Accum lla;
+  unsigned short _Accum usa;
+  unsigned _Accum ua;
+  unsigned long _Accum ula;
+  unsigned long long _Accum ulla;
+  _Sat short _Accum Ssa;
+  _Sat _Accum Sa;
+  _Sat long _Accum Sla;
+  _Sat long long _Accum Slla;
+  _Sat unsigned short _Accum Susa;
+  _Sat unsigned _Accum Sua;
+  _Sat unsigned long _Accum Sula;
+  _Sat unsigned long long _Accum Sulla;
+
+  /* C99 Section 6.5.3.3 ~ shall have integer types.  */
+
+  ~sf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~f; /* { dg-error "wrong type argument to bit-complement" } */
+  ~lf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~llf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~usf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~uf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~ulf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~ullf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Ssf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Slf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sllf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Susf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Suf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sulf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sullf; /* { dg-error "wrong type argument to bit-complement" } */
+  ~sa; /* { dg-error "wrong type argument to bit-complement" } */
+  ~a; /* { dg-error "wrong type argument to bit-complement" } */
+  ~la; /* { dg-error "wrong type argument to bit-complement" } */
+  ~lla; /* { dg-error "wrong type argument to bit-complement" } */
+  ~usa; /* { dg-error "wrong type argument to bit-complement" } */
+  ~ua; /* { dg-error "wrong type argument to bit-complement" } */
+  ~ula; /* { dg-error "wrong type argument to bit-complement" } */
+  ~ulla; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Ssa; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sa; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sla; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Slla; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Susa; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sua; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sula; /* { dg-error "wrong type argument to bit-complement" } */
+  ~Sulla; /* { dg-error "wrong type argument to bit-complement" } */
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/call-by-value.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/call-by-value.c
new file mode 100644
index 000000000..8b9d8225d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/call-by-value.c
@@ -0,0 +1,97 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.9.1(9) Function definitions; parameter has automatic storage.
+
+   Test that actual parameters are passed by value and that modifications
+   made within functions are lost on function return.
+
+   This test is copied from gcc.dg/dfp/ and changed for fixed-point types.  */
+
+extern void abort (void);
+
+#define FOO_FUN(NAME,TYPE,VALUE) \
+int foo ## NAME (TYPE z) \
+{ \
+  z = z + VALUE; \
+}
+
+#define FOO_TEST(NAME,TYPE,VALUE) \
+  { \
+    TYPE NAME = VALUE; \
+    foo ## NAME (NAME); \
+    if (NAME != VALUE) \
+      abort (); \
+  }
+
+FOO_FUN (sf, short _Fract, 0.2hr)
+FOO_FUN (f, _Fract, 0.2r)
+FOO_FUN (lf, long _Fract, 0.2lr)
+FOO_FUN (llf, long long _Fract, 0.2llr)
+FOO_FUN (usf, unsigned short _Fract, 0.2uhr)
+FOO_FUN (uf, unsigned _Fract, 0.2ur)
+FOO_FUN (ulf, unsigned long _Fract, 0.2ulr)
+FOO_FUN (ullf, unsigned long long _Fract, 0.2ullr)
+FOO_FUN (Ssf, _Sat short _Fract, 0.2hr)
+FOO_FUN (Sf, _Sat _Fract, 0.2r)
+FOO_FUN (Slf, _Sat long _Fract, 0.2lr)
+FOO_FUN (Sllf, _Sat long long _Fract, 0.2llr)
+FOO_FUN (Susf, _Sat unsigned short _Fract, 0.2uhr)
+FOO_FUN (Suf, _Sat unsigned _Fract, 0.2ur)
+FOO_FUN (Sulf, _Sat unsigned long _Fract, 0.2ulr)
+FOO_FUN (Sullf, _Sat unsigned long long _Fract, 0.2ullr)
+FOO_FUN (sa, short _Accum, 0.2hk)
+FOO_FUN (a, _Accum, 0.2k)
+FOO_FUN (la, long _Accum, 0.2lk)
+FOO_FUN (lla, long long _Accum, 0.2llk)
+FOO_FUN (usa, unsigned short _Accum, 0.2uhk)
+FOO_FUN (ua, unsigned _Accum, 0.2uk)
+FOO_FUN (ula, unsigned long _Accum, 0.2ulk)
+FOO_FUN (ulla, unsigned long long _Accum, 0.2ullk)
+FOO_FUN (Ssa, _Sat short _Accum, 0.2hk)
+FOO_FUN (Sa, _Sat _Accum, 0.2k)
+FOO_FUN (Sla, _Sat long _Accum, 0.2lk)
+FOO_FUN (Slla, _Sat long long _Accum, 0.2llk)
+FOO_FUN (Susa, _Sat unsigned short _Accum, 0.2uhk)
+FOO_FUN (Sua, _Sat unsigned _Accum, 0.2uk)
+FOO_FUN (Sula, _Sat unsigned long _Accum, 0.2ulk)
+FOO_FUN (Sulla, _Sat unsigned long long _Accum, 0.2ullk)
+
+int
+main ()
+{
+  FOO_TEST (sf, short _Fract, 0.2hr)
+  FOO_TEST (f, _Fract, 0.2r)
+  FOO_TEST (lf, long _Fract, 0.2lr)
+  FOO_TEST (llf, long long _Fract, 0.2llr)
+  FOO_TEST (usf, unsigned short _Fract, 0.2uhr)
+  FOO_TEST (uf, unsigned _Fract, 0.2ur)
+  FOO_TEST (ulf, unsigned long _Fract, 0.2ulr)
+  FOO_TEST (ullf, unsigned long long _Fract, 0.2ullr)
+  FOO_TEST (Ssf, _Sat short _Fract, 0.2hr)
+  FOO_TEST (Sf, _Sat _Fract, 0.2r)
+  FOO_TEST (Slf, _Sat long _Fract, 0.2lr)
+  FOO_TEST (Sllf, _Sat long long _Fract, 0.2llr)
+  FOO_TEST (Susf, _Sat unsigned short _Fract, 0.2uhr)
+  FOO_TEST (Suf, _Sat unsigned _Fract, 0.2ur)
+  FOO_TEST (Sulf, _Sat unsigned long _Fract, 0.2ulr)
+  FOO_TEST (Sullf, _Sat unsigned long long _Fract, 0.2ullr)
+  FOO_TEST (sa, short _Accum, 0.2hk)
+  FOO_TEST (a, _Accum, 0.2k)
+  FOO_TEST (la, long _Accum, 0.2lk)
+  FOO_TEST (lla, long long _Accum, 0.2llk)
+  FOO_TEST (usa, unsigned short _Accum, 0.2uhk)
+  FOO_TEST (ua, unsigned _Accum, 0.2uk)
+  FOO_TEST (ula, unsigned long _Accum, 0.2ulk)
+  FOO_TEST (ulla, unsigned long long _Accum, 0.2ullk)
+  FOO_TEST (Ssa, _Sat short _Accum, 0.2hk)
+  FOO_TEST (Sa, _Sat _Accum, 0.2k)
+  FOO_TEST (Sla, _Sat long _Accum, 0.2lk)
+  FOO_TEST (Slla, _Sat long long _Accum, 0.2llk)
+  FOO_TEST (Susa, _Sat unsigned short _Accum, 0.2uhk)
+  FOO_TEST (Sua, _Sat unsigned _Accum, 0.2uk)
+  FOO_TEST (Sula, _Sat unsigned long _Accum, 0.2ulk)
+  FOO_TEST (Sulla, _Sat unsigned long long _Accum, 0.2ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/cast-bad.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/cast-bad.c
new file mode 100644
index 000000000..ec8ea805a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/cast-bad.c
@@ -0,0 +1,279 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.4 Cast operators.
+
+   Test invalid casts involving fixed-point.  */
+
+#define CAST(NAME,TYPE) \
+  struct s ## NAME { TYPE NAME; } as ## NAME; \
+  union u ## NAME { TYPE NAME; } au ## NAME; \
+  TYPE NAME; \
+  TYPE * NAME ## p;
+
+CAST (sf, short _Fract)
+CAST (f, _Fract)
+CAST (lf, long _Fract)
+CAST (llf, long long _Fract)
+CAST (usf, unsigned short _Fract)
+CAST (uf, unsigned _Fract)
+CAST (ulf, unsigned long _Fract)
+CAST (ullf, unsigned long long _Fract)
+CAST (Ssf, _Sat short _Fract)
+CAST (Sf, _Sat _Fract)
+CAST (Slf, _Sat long _Fract)
+CAST (Sllf, _Sat long long _Fract)
+CAST (Susf, _Sat unsigned short _Fract)
+CAST (Suf, _Sat unsigned _Fract)
+CAST (Sulf, _Sat unsigned long _Fract)
+CAST (Sullf, _Sat unsigned long long _Fract)
+CAST (sa, short _Accum)
+CAST (a, _Accum)
+CAST (la, long _Accum)
+CAST (lla, long long _Accum)
+CAST (usa, unsigned short _Accum)
+CAST (ua, unsigned _Accum)
+CAST (ula, unsigned long _Accum)
+CAST (ulla, unsigned long long _Accum)
+CAST (Ssa, _Sat short _Accum)
+CAST (Sa, _Sat _Accum)
+CAST (Sla, _Sat long _Accum)
+CAST (Slla, _Sat long long _Accum)
+CAST (Susa, _Sat unsigned short _Accum)
+CAST (Sua, _Sat unsigned _Accum)
+CAST (Sula, _Sat unsigned long _Accum)
+CAST (Sulla, _Sat unsigned long long _Accum)
+
+void
+test (void)
+{
+  (short _Fract []) sfp; /* { dg-error "cast specifies array type" } */
+  (_Fract []) fp; /* { dg-error "cast specifies array type" } */
+  (long _Fract []) lfp; /* { dg-error "cast specifies array type" } */
+  (long long _Fract []) llfp; /* { dg-error "cast specifies array type" } */
+  (unsigned short _Fract []) usfp; /* { dg-error "cast specifies array type" } */
+  (unsigned _Fract []) ufp; /* { dg-error "cast specifies array type" } */
+  (unsigned long _Fract []) ulfp; /* { dg-error "cast specifies array type" } */
+  (unsigned long long _Fract []) ullfp; /* { dg-error "cast specifies array type" } */
+  (_Sat short _Fract []) Ssfp; /* { dg-error "cast specifies array type" } */
+  (_Sat _Fract []) Sfp; /* { dg-error "cast specifies array type" } */
+  (_Sat long _Fract []) Slfp; /* { dg-error "cast specifies array type" } */
+  (_Sat long long _Fract []) Sllfp; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned short _Fract []) Susfp; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned _Fract []) Sufp; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned long _Fract []) Sulfp; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned long long _Fract []) Sullfp; /* { dg-error "cast specifies array type" } */
+  (short _Accum []) sap; /* { dg-error "cast specifies array type" } */
+  (_Accum []) ap; /* { dg-error "cast specifies array type" } */
+  (long _Accum []) lap; /* { dg-error "cast specifies array type" } */
+  (long long _Accum []) llap; /* { dg-error "cast specifies array type" } */
+  (unsigned short _Accum []) usap; /* { dg-error "cast specifies array type" } */
+  (unsigned _Accum []) uap; /* { dg-error "cast specifies array type" } */
+  (unsigned long _Accum []) ulap; /* { dg-error "cast specifies array type" } */
+  (unsigned long long _Accum []) ullap; /* { dg-error "cast specifies array type" } */
+  (_Sat short _Accum []) Ssap; /* { dg-error "cast specifies array type" } */
+  (_Sat _Accum []) Sap; /* { dg-error "cast specifies array type" } */
+  (_Sat long _Accum []) Slap; /* { dg-error "cast specifies array type" } */
+  (_Sat long long _Accum []) Sllap; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned short _Accum []) Susap; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned _Accum []) Suap; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned long _Accum []) Sulap; /* { dg-error "cast specifies array type" } */
+  (_Sat unsigned long long _Accum []) Sullap; /* { dg-error "cast specifies array type" } */
+
+  (short _Fract ()) sfp; /* { dg-error "cast specifies function type" } */
+  (_Fract ()) fp; /* { dg-error "cast specifies function type" } */
+  (long _Fract ()) lfp; /* { dg-error "cast specifies function type" } */
+  (long long _Fract ()) llfp; /* { dg-error "cast specifies function type" } */
+  (unsigned short _Fract ()) usfp; /* { dg-error "cast specifies function type" } */
+  (unsigned _Fract ()) ufp; /* { dg-error "cast specifies function type" } */
+  (unsigned long _Fract ()) ulfp; /* { dg-error "cast specifies function type" } */
+  (unsigned long long _Fract ()) ullfp; /* { dg-error "cast specifies function type" } */
+  (_Sat short _Fract ()) Ssfp; /* { dg-error "cast specifies function type" } */
+  (_Sat _Fract ()) Sfp; /* { dg-error "cast specifies function type" } */
+  (_Sat long _Fract ()) Slfp; /* { dg-error "cast specifies function type" } */
+  (_Sat long long _Fract ()) Sllfp; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned short _Fract ()) Susfp; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned _Fract ()) Sufp; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned long _Fract ()) Sulfp; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned long long _Fract ()) Sullfp; /* { dg-error "cast specifies function type" } */
+  (short _Accum ()) sap; /* { dg-error "cast specifies function type" } */
+  (_Accum ()) ap; /* { dg-error "cast specifies function type" } */
+  (long _Accum ()) lap; /* { dg-error "cast specifies function type" } */
+  (long long _Accum ()) llap; /* { dg-error "cast specifies function type" } */
+  (unsigned short _Accum ()) usap; /* { dg-error "cast specifies function type" } */
+  (unsigned _Accum ()) uap; /* { dg-error "cast specifies function type" } */
+  (unsigned long _Accum ()) ulap; /* { dg-error "cast specifies function type" } */
+  (unsigned long long _Accum ()) ullap; /* { dg-error "cast specifies function type" } */
+  (_Sat short _Accum ()) Ssap; /* { dg-error "cast specifies function type" } */
+  (_Sat _Accum ()) Sap; /* { dg-error "cast specifies function type" } */
+  (_Sat long _Accum ()) Slap; /* { dg-error "cast specifies function type" } */
+  (_Sat long long _Accum ()) Sllap; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned short _Accum ()) Susap; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned _Accum ()) Suap; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned long _Accum ()) Sulap; /* { dg-error "cast specifies function type" } */
+  (_Sat unsigned long long _Accum ()) Sullap; /* { dg-error "cast specifies function type" } */
+
+  (struct ssf) sf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sf) f; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct slf) lf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sllf) llf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct susf) usf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct suf) uf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sulf) ulf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sullf) ullf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSsf) Ssf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSf) Sf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSlf) Slf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSllf) Sllf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSusf) Susf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSuf) Suf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSulf) Sulf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSullf) Sullf; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct ssa) sa; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sa) a; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sla) la; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct slla) lla; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct susa) usa; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sua) ua; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sula) ula; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sulla) ulla; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSsa) Ssa; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSa) Sa; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSla) Sla; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSlla) Slla; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSusa) Susa; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSua) Sua; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSula) Sula; /* { dg-error "conversion to non-scalar type requested" } */
+  (struct sSulla) Sulla; /* { dg-error "conversion to non-scalar type requested" } */
+
+  (union usf) sf;
+  (union uf) f;
+  (union ulf) lf;
+  (union ullf) llf;
+  (union uusf) usf;
+  (union uuf) uf;
+  (union uulf) ulf;
+  (union uullf) ullf;
+  (union uSsf) Ssf;
+  (union uSf) Sf;
+  (union uSlf) Slf;
+  (union uSllf) Sllf;
+  (union uSusf) Susf;
+  (union uSuf) Suf;
+  (union uSulf) Sulf;
+  (union uSullf) Sullf;
+  (union usa) sa;
+  (union ua) a;
+  (union ula) la;
+  (union ulla) lla;
+  (union uusa) usa;
+  (union uua) ua;
+  (union uula) ula;
+  (union uulla) ulla;
+  (union uSsa) Ssa;
+  (union uSa) Sa;
+  (union uSla) Sla;
+  (union uSlla) Slla;
+  (union uSusa) Susa;
+  (union uSua) Sua;
+  (union uSula) Sula;
+  (union uSulla) Sulla;
+
+  (union usf) f; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) lf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) llf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) usf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) uf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) ulf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) ullf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Ssf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Slf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sllf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Susf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Suf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sulf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sullf; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) sa; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) a; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) la; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) lla; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) usa; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) ua; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) ula; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) ulla; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Ssa; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sa; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sla; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Slla; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Susa; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sua; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sula; /* { dg-error "cast to union type from type not present in union" } */
+  (union usf) Sulla; /* { dg-error "cast to union type from type not present in union" } */
+
+  (short _Fract) assf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Fract) asf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long _Fract) aslf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long long _Fract) asllf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned short _Fract) asusf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned _Fract) asuf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long _Fract) asulf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long long _Fract) asullf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat short _Fract) asSsf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat _Fract) asSf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long _Fract) asSlf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long long _Fract) asSllf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned short _Fract) asSusf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned _Fract) asSuf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long _Fract) asSulf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long long _Fract) asSullf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (short _Accum) assa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Accum) asa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long _Accum) asla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long long _Accum) aslla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned short _Accum) asusa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned _Accum) asua; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long _Accum) asula; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long long _Accum) asulla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat short _Accum) asSsa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat _Accum) asSa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long _Accum) asSla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long long _Accum) asSlla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned short _Accum) asSusa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned _Accum) asSua; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long _Accum) asSula; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long long _Accum) asSulla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+
+  (short _Fract) ausf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Fract) auf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long _Fract) aulf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long long _Fract) aullf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned short _Fract) auusf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned _Fract) auuf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long _Fract) auulf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long long _Fract) auullf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat short _Fract) auSsf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat _Fract) auSf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long _Fract) auSlf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long long _Fract) auSllf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned short _Fract) auSusf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned _Fract) auSuf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long _Fract) auSulf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long long _Fract) auSullf; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (short _Accum) ausa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Accum) aua; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long _Accum) aula; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (long long _Accum) aulla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned short _Accum) auusa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned _Accum) auua; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long _Accum) auula; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (unsigned long long _Accum) auulla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat short _Accum) auSsa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat _Accum) auSa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long _Accum) auSla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat long long _Accum) auSlla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned short _Accum) auSusa; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned _Accum) auSua; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long _Accum) auSula; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+  (_Sat unsigned long long _Accum) auSulla; /* { dg-error "aggregate value used where a fixed-point was expected" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/composite-type.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/composite-type.c
new file mode 100644
index 000000000..031de0e11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/composite-type.c
@@ -0,0 +1,109 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O -Wall" } */
+
+/* C99 6.2.7: Compatible type and composite type.  */
+
+#define FIXED_POINT_COMPOSITE_DECL(TYPE,NAME) \
+  TYPE g1_##NAME(); \
+  TYPE g2_##NAME(); \
+  TYPE (*h1_##NAME)[2]; \
+  TYPE (*h2_##NAME)[3]; \
+  TYPE (*h3_##NAME)[4]; \
+  TYPE f1_##NAME(TYPE(*)()); \
+  TYPE f1_##NAME(TYPE(*)(TYPE*)); \
+  TYPE f1_##NAME (TYPE(*g)(TYPE*)) \
+   { \
+     TYPE NAME; \
+     NAME = ((TYPE (*) (TYPE*)) g)(&NAME); \
+     NAME = ((TYPE (*) ()) g); \
+     return NAME; \
+   } \
+  TYPE f2_##NAME(TYPE(*)[]); \
+  TYPE f2_##NAME(TYPE(*)[3]);
+
+#define FIXED_POINT_COMPOSITE_TEST(TYPE, NAME) \
+do \
+{ \
+ TYPE NAME; \
+ NAME = f1_##NAME(g1_##NAME); \
+ NAME = f1_##NAME(g2_##NAME); \
+ NAME = f2_##NAME(h1_##NAME); \
+ NAME = f2_##NAME(h2_##NAME); \
+ NAME = f2_##NAME(h3_##NAME); \
+} while(0)
+
+FIXED_POINT_COMPOSITE_DECL(short _Fract, sf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Fract, f);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(long _Fract, lf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(long long _Fract, llf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned short _Fract, usf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned _Fract, uf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned long _Fract, ulf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned long long _Fract, ullf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat short _Fract, Ssf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat _Fract, Sf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat long _Fract, Slf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat long long _Fract, Sllf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned short _Fract, Susf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned _Fract, Suf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned long _Fract, Sulf);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned long long _Fract, Sullf);  /* { dg-error "incompatible types when assigning" } */
+
+FIXED_POINT_COMPOSITE_DECL(short _Accum, sk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Accum, k);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(long _Accum, lk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(long long _Accum, llk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned short _Accum, usk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned _Accum, uk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned long _Accum, ulk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(unsigned long long _Accum, ullk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat short _Accum, Ssk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat _Accum, Sk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat long _Accum, Slk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat long long _Accum, Sllk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned short _Accum, Susk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned _Accum, Suk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned long _Accum, Sulk);  /* { dg-error "incompatible types when assigning" } */
+FIXED_POINT_COMPOSITE_DECL(_Sat unsigned long long _Accum, Sullk);  /* { dg-error "incompatible types when assigning" } */
+
+int main()
+{
+  FIXED_POINT_COMPOSITE_TEST(short _Fract, sf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Fract, f);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(long _Fract, lf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(long long _Fract, llf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned short _Fract, usf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned _Fract, uf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned long _Fract, ulf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned long long _Fract, ullf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat short _Fract, Ssf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat _Fract, Sf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat long _Fract, Slf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat long long _Fract, Sllf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned short _Fract, Susf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned _Fract, Suf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned long _Fract, Sulf);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned long long _Fract, Sullf);  /* { dg-warning "incompatible pointer type" } */
+
+  FIXED_POINT_COMPOSITE_TEST(short _Accum, sk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Accum, k);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(long _Accum, lk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(long long _Accum, llk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned short _Accum, usk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned _Accum, uk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned long _Accum, ulk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(unsigned long long _Accum, ullk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat short _Accum, Ssk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat _Accum, Sk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat long _Accum, Slk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat long long _Accum, Sllk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned short _Accum, Susk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned _Accum, Suk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned long _Accum, Sulk);  /* { dg-warning "incompatible pointer type" } */
+  FIXED_POINT_COMPOSITE_TEST(_Sat unsigned long long _Accum, Sullk);  /* { dg-warning "incompatible pointer type" } */
+
+  return 0;
+}
+
+/* Match all extra informative notes.  */
+/* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/const-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/const-1.c
new file mode 100644
index 000000000..5df0b4adc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/const-1.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.4.4 - Constants.
+
+   Check if the constant 1 is ok.  */
+
+short _Fract sf = 1.0hr;
+_Fract f = 1.0r;
+long _Fract lf = 1.0lr;
+long long _Fract llf = 1.0llr;
+
+unsigned short _Fract usf = 1.0uhr;
+unsigned _Fract uf = 1.0ur;
+unsigned long _Fract ulf = 1.0ulr;
+unsigned long long _Fract ullf = 1.0ullr;
+
+short _Fract sfF = 1.0;  /* { dg-warning "overflow" } */
+_Fract fF = 1.0;  /* { dg-warning "overflow" } */
+long _Fract lfF = 1.0;  /* { dg-warning "overflow" } */
+long long _Fract llfF = 1.0;  /* { dg-warning "overflow" } */
+
+unsigned short _Fract usfF = 1.0;  /* { dg-warning "overflow" } */
+unsigned _Fract ufF = 1.0;  /* { dg-warning "overflow" } */
+unsigned long _Fract ulfF = 1.0;  /* { dg-warning "overflow" } */
+unsigned long long _Fract ullfF = 1.0;  /* { dg-warning "overflow" } */
+
+short _Fract sfI = 1;  /* { dg-warning "overflow" } */
+_Fract fI = 1;  /* { dg-warning "overflow" } */
+long _Fract lfI = 1;  /* { dg-warning "overflow" } */
+long long _Fract llfI = 1;  /* { dg-warning "overflow" } */
+
+unsigned short _Fract usfI = 1;  /* { dg-warning "overflow" } */
+unsigned _Fract ufI = 1;  /* { dg-warning "overflow" } */
+unsigned long _Fract ulfI = 1;  /* { dg-warning "overflow" } */
+unsigned long long _Fract ullfI = 1;  /* { dg-warning "overflow" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/constant.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/constant.c
new file mode 100644
index 000000000..18abb4501
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/constant.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.4.4.2a - Fixed-point constants (NEW CLAUSE).
+
+   Check if fixed-point constants are ok.  */
+
+_Accum k0 = 0k;
+_Accum k1 = 9999.0e0k;
+_Accum k2 = 9999.0k;
+_Accum k3 = 9999k;
+_Accum k4 = 9999e0k;
+_Accum k5 = 09999k;
+_Accum k6 = 09999e0k;
+_Accum k7 = 09999.0e0k;
+_Accum k8 = 09999.0k;
+_Accum k9 = 0x270fp0k;
+_Accum k10 = 0x270f.0p0k;
+
+_Fract r0 = 0r;
+_Fract r1 = 0e0r;
+_Fract r2 = 0.0e0r;
+_Fract r3 = 0.1e0r;
+_Fract r4 = 0.0r;
+_Fract r5 = 0.1r;
+_Fract r6 = 0x0p0r;
+_Fract r7 = 0x0.0p0r;
+_Fract r8 = 0x0.1p0r;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/constants-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/constants-pedantic.c
new file mode 100644
index 000000000..9392381ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/constants-pedantic.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+/* N1169 6.4.4.2a - Fixed-point constants (NEW CLAUSE).  */
+
+_Accum k0 = 0k;		/* { dg-warning "GCC extension|ISO C" } */
+_Accum k1 = 9999.0e0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k2 = 9999.0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k3 = 9999k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k4 = 9999e0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k5 = 09999k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k6 = 09999e0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k7 = 09999.0e0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k8 = 09999.0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k9 = 0x270fp0k;	/* { dg-warning "GCC extension|ISO C" } */
+_Accum k10 = 0x270f.0p0k;	/* { dg-warning "GCC extension|ISO C" } */
+
+_Fract r0 = 0r;		/* { dg-warning "GCC extension|ISO C" } */
+_Fract r1 = 0e0r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r2 = 0.0e0r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r3 = 0.1e0r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r4 = 0.0r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r5 = 0.1r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r6 = 0x0p0r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r7 = 0x0.0p0r;	/* { dg-warning "GCC extension|ISO C" } */
+_Fract r8 = 0x0.1p0r;	/* { dg-warning "GCC extension|ISO C" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/convert.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/convert.c
new file mode 100644
index 000000000..f4e373f2d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/convert.c
@@ -0,0 +1,432 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.3 Conversions.
+
+   Check conversions involving fixed-point.  */
+
+extern void abort (void);
+
+/* Fixed-point to fixed-point.  */
+#define CONV(TYPE1,POSTFIX1,TYPE2,POSTFIX2) \
+  { \
+    TYPE1 a = 0.5 ## POSTFIX1; \
+    TYPE2 b = a; \
+    if (b != 0.5 ## POSTFIX2) \
+      abort(); \
+  }
+
+/* TYPE1 with VALUE1 to TYPE2 with VALUE2.  */
+#define CONV2(TYPE1,VALUE1,TYPE2,VALUE2) \
+  { \
+    TYPE1 a = VALUE1; \
+    TYPE2 b = a; \
+    if (b != VALUE2) \
+      abort(); \
+  }
+
+/* Fixed-point to integer, and integer to fixed-point.  */
+#define CONV_INT(TYPE1,POSTFIX1,TYPE2) \
+  { \
+    TYPE1 a = 0.5 ## POSTFIX1; \
+    TYPE2 b = a; \
+    TYPE2 c = 0; \
+    TYPE1 d = c; \
+    if (b != 0) \
+      abort(); \
+    if (d != 0.0 ## POSTFIX1) \
+      abort(); \
+  }
+
+/* Signed fixed-point to integer.  */
+#define CONV_INT2(TYPE1,POSTFIX1,TYPE2) \
+  { \
+    TYPE1 a = -0.5 ## POSTFIX1; \
+    TYPE2 b = a; \
+    if (b != 0) \
+      abort(); \
+    a = -0.0 ## POSTFIX1; \
+    b = a; \
+    if (b != 0) \
+      abort(); \
+    a = +0.0 ## POSTFIX1; \
+    b = a; \
+    if (b != 0) \
+      abort(); \
+    a = +0.1 ## POSTFIX1; \
+    b = a; \
+    if (b != 0) \
+      abort(); \
+    a = -0.1 ## POSTFIX1; \
+    b = a; \
+    if (b != 0) \
+      abort(); \
+  }
+
+/* Signed fixed-point to signed integer.  */
+#define CONV_INT3(TYPE1,POSTFIX1,TYPE2) \
+  { \
+    TYPE1 a = -0.5 ## POSTFIX1 - 0.5 ## POSTFIX1; \
+    TYPE2 b = a; \
+    if (b != -1) \
+      abort(); \
+  }
+
+/* Fixed-point to floating-point, and floating-point to fixed-point.  */
+#define CONV_FLOAT(TYPE1,POSTFIX1,TYPE2) \
+  { \
+    TYPE1 a = 0.5 ## POSTFIX1; \
+    TYPE2 b = a; \
+    TYPE2 c = 0.25; \
+    TYPE1 d = c; \
+    if (b != 0.5) \
+      abort(); \
+    if (d != 0.25 ## POSTFIX1) \
+      abort(); \
+  }
+
+/* Accum to integer, and integer to accum.  */
+#define CONV_ACCUM_INT(TYPE1,POSTFIX1,TYPE2) \
+  { \
+    TYPE1 a = 99.12345 ## POSTFIX1; \
+    TYPE2 b = a; \
+    TYPE2 c = 123; \
+    TYPE1 d = c; \
+    if (b != 99) \
+      abort(); \
+    if (d != 123.0 ## POSTFIX1) \
+      abort(); \
+  }
+
+#define ALL_CONV(TYPE,POSTFIX) \
+  CONV(TYPE, POSTFIX, short _Fract, hr) \
+  CONV(TYPE, POSTFIX, _Fract, r) \
+  CONV(TYPE, POSTFIX, long _Fract, lr) \
+  CONV(TYPE, POSTFIX, long long _Fract, llr) \
+  CONV(TYPE, POSTFIX, unsigned short _Fract, uhr) \
+  CONV(TYPE, POSTFIX, unsigned _Fract, ur) \
+  CONV(TYPE, POSTFIX, unsigned long _Fract, ulr) \
+  CONV(TYPE, POSTFIX, unsigned long long _Fract, ullr) \
+  CONV(TYPE, POSTFIX, short _Accum, hk) \
+  CONV(TYPE, POSTFIX, _Accum, k) \
+  CONV(TYPE, POSTFIX, long _Accum, lk) \
+  CONV(TYPE, POSTFIX, long long _Accum, llk) \
+  CONV(TYPE, POSTFIX, unsigned short _Accum, uhk) \
+  CONV(TYPE, POSTFIX, unsigned _Accum, uk) \
+  CONV(TYPE, POSTFIX, unsigned long _Accum, ulk) \
+  CONV(TYPE, POSTFIX, unsigned long long _Accum, ullk) \
+  CONV(_Sat TYPE, POSTFIX, short _Fract, hr) \
+  CONV(_Sat TYPE, POSTFIX, _Fract, r) \
+  CONV(_Sat TYPE, POSTFIX, long _Fract, lr) \
+  CONV(_Sat TYPE, POSTFIX, long long _Fract, llr) \
+  CONV(_Sat TYPE, POSTFIX, unsigned short _Fract, uhr) \
+  CONV(_Sat TYPE, POSTFIX, unsigned _Fract, ur) \
+  CONV(_Sat TYPE, POSTFIX, unsigned long _Fract, ulr) \
+  CONV(_Sat TYPE, POSTFIX, unsigned long long _Fract, ullr) \
+  CONV(_Sat TYPE, POSTFIX, short _Accum, hk) \
+  CONV(_Sat TYPE, POSTFIX, _Accum, k) \
+  CONV(_Sat TYPE, POSTFIX, long _Accum, lk) \
+  CONV(_Sat TYPE, POSTFIX, long long _Accum, llk) \
+  CONV(_Sat TYPE, POSTFIX, unsigned short _Accum, uhk) \
+  CONV(_Sat TYPE, POSTFIX, unsigned _Accum, uk) \
+  CONV(_Sat TYPE, POSTFIX, unsigned long _Accum, ulk) \
+  CONV(_Sat TYPE, POSTFIX, unsigned long long _Accum, ullk) \
+  CONV(TYPE, POSTFIX, _Sat short _Fract, hr) \
+  CONV(TYPE, POSTFIX, _Sat _Fract, r) \
+  CONV(TYPE, POSTFIX, _Sat long _Fract, lr) \
+  CONV(TYPE, POSTFIX, _Sat long long _Fract, llr) \
+  CONV(TYPE, POSTFIX, _Sat unsigned short _Fract, uhr) \
+  CONV(TYPE, POSTFIX, _Sat unsigned _Fract, ur) \
+  CONV(TYPE, POSTFIX, _Sat unsigned long _Fract, ulr) \
+  CONV(TYPE, POSTFIX, _Sat unsigned long long _Fract, ullr) \
+  CONV(TYPE, POSTFIX, _Sat short _Accum, hk) \
+  CONV(TYPE, POSTFIX, _Sat _Accum, k) \
+  CONV(TYPE, POSTFIX, _Sat long _Accum, lk) \
+  CONV(TYPE, POSTFIX, _Sat long long _Accum, llk) \
+  CONV(TYPE, POSTFIX, _Sat unsigned short _Accum, uhk) \
+  CONV(TYPE, POSTFIX, _Sat unsigned _Accum, uk) \
+  CONV(TYPE, POSTFIX, _Sat unsigned long _Accum, ulk) \
+  CONV(TYPE, POSTFIX, _Sat unsigned long long _Accum, ullk) \
+  CONV_INT(TYPE, POSTFIX, signed char) \
+  CONV_INT(TYPE, POSTFIX, short) \
+  CONV_INT(TYPE, POSTFIX, int) \
+  CONV_INT(TYPE, POSTFIX, long) \
+  CONV_INT(TYPE, POSTFIX, long long) \
+  CONV_INT(TYPE, POSTFIX, unsigned char) \
+  CONV_INT(TYPE, POSTFIX, unsigned short) \
+  CONV_INT(TYPE, POSTFIX, unsigned int) \
+  CONV_INT(TYPE, POSTFIX, unsigned long) \
+  CONV_INT(TYPE, POSTFIX, unsigned long long) \
+  CONV_INT(_Sat TYPE, POSTFIX, signed char) \
+  CONV_INT(_Sat TYPE, POSTFIX, short) \
+  CONV_INT(_Sat TYPE, POSTFIX, int) \
+  CONV_INT(_Sat TYPE, POSTFIX, long) \
+  CONV_INT(_Sat TYPE, POSTFIX, long long) \
+  CONV_INT(_Sat TYPE, POSTFIX, unsigned char) \
+  CONV_INT(_Sat TYPE, POSTFIX, unsigned short) \
+  CONV_INT(_Sat TYPE, POSTFIX, unsigned int) \
+  CONV_INT(_Sat TYPE, POSTFIX, unsigned long) \
+  CONV_INT(_Sat TYPE, POSTFIX, unsigned long long) \
+  CONV_FLOAT(TYPE, POSTFIX, float) \
+  CONV_FLOAT(TYPE, POSTFIX, double) \
+  CONV_FLOAT(_Sat TYPE, POSTFIX, float) \
+  CONV_FLOAT(_Sat TYPE, POSTFIX, double)
+
+#define ALL_ACCUM_CONV(TYPE,POSTFIX) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, signed char) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, short) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, int) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, long) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, long long) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, unsigned char) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, unsigned short) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, unsigned int) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, unsigned long) \
+  CONV_ACCUM_INT(TYPE, POSTFIX, unsigned long long) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, signed char) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, short) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, int) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, long) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, long long) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, unsigned char) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, unsigned short) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, unsigned int) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, unsigned long) \
+  CONV_ACCUM_INT(_Sat TYPE, POSTFIX, unsigned long long)
+
+#define NEG_CONV(TYPE,POSTFIX) \
+  CONV_INT2(TYPE, POSTFIX, signed char) \
+  CONV_INT2(TYPE, POSTFIX, short) \
+  CONV_INT2(TYPE, POSTFIX, int) \
+  CONV_INT2(TYPE, POSTFIX, long) \
+  CONV_INT2(TYPE, POSTFIX, long long) \
+  CONV_INT2(TYPE, POSTFIX, unsigned char) \
+  CONV_INT2(TYPE, POSTFIX, unsigned short) \
+  CONV_INT2(TYPE, POSTFIX, unsigned int) \
+  CONV_INT2(TYPE, POSTFIX, unsigned long) \
+  CONV_INT2(TYPE, POSTFIX, unsigned long long) \
+  CONV_INT3(TYPE, POSTFIX, signed char) \
+  CONV_INT3(TYPE, POSTFIX, short) \
+  CONV_INT3(TYPE, POSTFIX, int) \
+  CONV_INT3(TYPE, POSTFIX, long) \
+  CONV_INT3(TYPE, POSTFIX, long long)
+
+/* Signed accum to _Sat unsigned/signed fract.  */
+#define SAT_CONV1(TYPE, POSTFIX) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat short _Fract, -0.5hr - 0.5hr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat _Fract, -0.5r - 0.5r) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat long _Fract, -0.5lr - 0.5lr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat long long _Fract, -0.5llr - 0.5llr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat unsigned _Fract, 0.0ur) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, -3.2 ## POSTFIX, _Sat unsigned long long _Fract, 0.0ullr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat short _Fract, -0.5hr - 0.5hr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat _Fract, -0.5r - 0.5r) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat long _Fract, -0.5lr - 0.5lr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat long long _Fract, -0.5llr - 0.5llr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat unsigned _Fract, 0.0ur) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, -1.0 ## POSTFIX, _Sat unsigned long long _Fract, 0.0ullr)
+
+/* Unsigned accum to _Sat unsigned/signed fract.  */
+#define SAT_CONV2(TYPE, POSTFIX) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, 3.2 ## POSTFIX, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, 1.0 ## POSTFIX, _Sat unsigned long long _Fract, 1.0ullr)
+
+/* Signed fract to _Sat unsigned fract.  */
+#define SAT_CONV3(TYPE, POSTFIX) \
+  CONV2(TYPE, -0.5 ## POSTFIX, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, -0.5 ## POSTFIX, _Sat unsigned  _Fract, 0.0ur) \
+  CONV2(TYPE, -0.5 ## POSTFIX, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, -0.5 ## POSTFIX, _Sat unsigned long long _Fract, 0.0ullr)
+
+/* Signed integer to _Sat signed/unsigned fract.  */
+#define SAT_CONV4(TYPE) \
+  CONV2(TYPE, 100, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, -100, _Sat short _Fract, -0.5hr - 0.5hr) \
+  CONV2(TYPE, 100, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, -100, _Sat _Fract, -0.5r - 0.5r) \
+  CONV2(TYPE, 100, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, -100, _Sat long _Fract, -0.5lr - 0.5lr) \
+  CONV2(TYPE, 100, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, -100, _Sat long long _Fract, -0.5llr - 0.5llr) \
+  CONV2(TYPE, 100, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, -100, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, 100, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, -100, _Sat unsigned _Fract, 0.0ur) \
+  CONV2(TYPE, 100, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, -100, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, 100, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, -100, _Sat unsigned long long _Fract, 0.0ullr) \
+  CONV2(TYPE, 1, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, -1, _Sat short _Fract, -0.5hr - 0.5hr) \
+  CONV2(TYPE, 1, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, -1, _Sat _Fract, -0.5r - 0.5r) \
+  CONV2(TYPE, 1, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, -1, _Sat long _Fract, -0.5lr - 0.5lr) \
+  CONV2(TYPE, 1, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, -1, _Sat long long _Fract, -0.5llr - 0.5llr) \
+  CONV2(TYPE, 1, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, -1, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, 1, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, -1, _Sat unsigned _Fract, 0.0ur) \
+  CONV2(TYPE, 1, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, -1, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, 1, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, -1, _Sat unsigned long long _Fract, 0.0ullr)
+
+/* Unsigned integer to _Sat signed/unsigned fract.  */
+#define SAT_CONV5(TYPE) \
+  CONV2(TYPE, 100, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, 100, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, 100, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, 100, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, 100, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, 100, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, 100, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, 100, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, 1, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, 1, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, 1, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, 1, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, 1, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, 1, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, 1, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, 1, _Sat unsigned long long _Fract, 1.0ullr)
+
+/* Floating-point to _Sat signed/unsigned fract.  */
+#define SAT_CONV6(TYPE) \
+  CONV2(TYPE, 100.0, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, -100.0, _Sat short _Fract, -0.5hr - 0.5hr) \
+  CONV2(TYPE, 100.0, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, -100.0, _Sat _Fract, -0.5r - 0.5r) \
+  CONV2(TYPE, 100.0, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, -100.0, _Sat long _Fract, -0.5lr - 0.5lr) \
+  CONV2(TYPE, 100.0, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, -100.0, _Sat long long _Fract, -0.5llr - 0.5llr) \
+  CONV2(TYPE, 100.0, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, -100.0, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, 100.0, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, -100.0, _Sat unsigned _Fract, 0.0ur) \
+  CONV2(TYPE, 100.0, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, -100.0, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, 100.0, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, -100.0, _Sat unsigned long long _Fract, 0.0ullr) \
+  CONV2(TYPE, 1.0, _Sat short _Fract, 1.0hr) \
+  CONV2(TYPE, -1.0, _Sat short _Fract, -0.5hr - 0.5hr) \
+  CONV2(TYPE, 1.0, _Sat _Fract, 1.0r) \
+  CONV2(TYPE, -1.0, _Sat _Fract, -0.5r - 0.5r) \
+  CONV2(TYPE, 1.0, _Sat long _Fract, 1.0lr) \
+  CONV2(TYPE, -1.0, _Sat long _Fract, -0.5lr - 0.5lr) \
+  CONV2(TYPE, 1.0, _Sat long long _Fract, 1.0llr) \
+  CONV2(TYPE, -1.0, _Sat long long _Fract, -0.5llr - 0.5llr) \
+  CONV2(TYPE, 1.0, _Sat unsigned short _Fract, 1.0uhr) \
+  CONV2(TYPE, -1.0, _Sat unsigned short _Fract, 0.0uhr) \
+  CONV2(TYPE, 1.0, _Sat unsigned _Fract, 1.0ur) \
+  CONV2(TYPE, -1.0, _Sat unsigned _Fract, 0.0ur) \
+  CONV2(TYPE, 1.0, _Sat unsigned long _Fract, 1.0ulr) \
+  CONV2(TYPE, -1.0, _Sat unsigned long _Fract, 0.0ulr) \
+  CONV2(TYPE, 1.0, _Sat unsigned long long _Fract, 1.0ullr) \
+  CONV2(TYPE, -1.0, _Sat unsigned long long _Fract, 0.0ullr)
+
+int main ()
+{
+  ALL_CONV (short _Fract, hr);
+  ALL_CONV (_Fract, r);
+  ALL_CONV (long _Fract, lr);
+  ALL_CONV (long long _Fract, llr);
+  ALL_CONV (unsigned short _Fract, uhr);
+  ALL_CONV (unsigned _Fract, ur);
+  ALL_CONV (unsigned long _Fract, ulr);
+  ALL_CONV (unsigned long long _Fract, ullr);
+  ALL_CONV (short _Accum, hk);
+  ALL_CONV (_Accum, k);
+  ALL_CONV (long _Accum, lk);
+  ALL_CONV (long long _Accum, llk);
+  ALL_CONV (unsigned short _Accum, uhk);
+  ALL_CONV (unsigned _Accum, uk);
+  ALL_CONV (unsigned long _Accum, ulk);
+  ALL_CONV (unsigned long long _Accum, ullk);
+
+  ALL_ACCUM_CONV (short _Accum, hk);
+  ALL_ACCUM_CONV (_Accum, k);
+  ALL_ACCUM_CONV (long _Accum, lk);
+  ALL_ACCUM_CONV (long long _Accum, llk);
+  ALL_ACCUM_CONV (unsigned short _Accum, uhk);
+  ALL_ACCUM_CONV (unsigned _Accum, uk);
+  ALL_ACCUM_CONV (unsigned long _Accum, ulk);
+  ALL_ACCUM_CONV (unsigned long long _Accum, ullk);
+
+  NEG_CONV (short _Fract, hr);
+  NEG_CONV (_Fract, r);
+  NEG_CONV (long _Fract, lr);
+  NEG_CONV (long long _Fract, llr);
+  NEG_CONV (short _Accum, hk);
+  NEG_CONV (_Accum, k);
+  NEG_CONV (long _Accum, lk);
+  NEG_CONV (long long _Accum, llk);
+
+  SAT_CONV1 (short _Accum, hk);
+  SAT_CONV1 (_Accum, k);
+  SAT_CONV1 (long _Accum, lk);
+  SAT_CONV1 (long long _Accum, llk);
+
+  SAT_CONV2 (unsigned short _Accum, uhk);
+  SAT_CONV2 (unsigned _Accum, uk);
+  SAT_CONV2 (unsigned long _Accum, ulk);
+  SAT_CONV2 (unsigned long long _Accum, ullk);
+
+  SAT_CONV3 (short _Fract, hr);
+  SAT_CONV3 (_Fract, r);
+  SAT_CONV3 (long _Fract, lr);
+  SAT_CONV3 (long long _Fract, llr);
+
+  SAT_CONV4 (signed char);
+  SAT_CONV4 (short);
+  SAT_CONV4 (int);
+  SAT_CONV4 (long);
+  SAT_CONV4 (long long);
+
+  SAT_CONV5 (unsigned char);
+  SAT_CONV5 (unsigned short);
+  SAT_CONV5 (unsigned int);
+  SAT_CONV5 (unsigned long);
+  SAT_CONV5 (unsigned long long);
+
+  SAT_CONV6 (float);
+  SAT_CONV6 (double);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/define.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/define.c
new file mode 100644
index 000000000..b66ade7e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/define.c
@@ -0,0 +1,158 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 7.18a.3 - Precision macros.
+
+   Check if defined fixed-point constants are ok.  */
+
+#include <stdfix.h>
+
+short fract sf = SFRACT_MAX;
+fract f = FRACT_MAX;
+long fract lf = LFRACT_MAX;
+long long fract llf = LLFRACT_MAX;
+
+unsigned short fract usf = USFRACT_MAX;
+unsigned fract uf = UFRACT_MAX;
+unsigned long fract ulf = ULFRACT_MAX;
+unsigned long long fract ullf = ULLFRACT_MAX;
+
+sat short fract Ssf = SFRACT_MAX;
+sat fract Sf = FRACT_MAX;
+sat long fract Slf = LFRACT_MAX;
+sat long long fract Sllf = LLFRACT_MAX;
+
+sat unsigned short fract Susf = USFRACT_MAX;
+sat unsigned fract Suf = UFRACT_MAX;
+sat unsigned long fract Sulf = ULFRACT_MAX;
+sat unsigned long long fract Sullf = ULLFRACT_MAX;
+
+short fract sfm = SFRACT_MIN;
+fract fm = FRACT_MIN;
+long fract lfm = LFRACT_MIN;
+long long fract llfm = LLFRACT_MIN;
+
+unsigned short fract usfm = USFRACT_MIN;
+unsigned fract ufm = UFRACT_MIN;
+unsigned long fract ulfm = ULFRACT_MIN;
+unsigned long long fract ullfm = ULLFRACT_MIN;
+
+sat short fract Ssfm = SFRACT_MIN;
+sat fract Sfm = FRACT_MIN;
+sat long fract Slfm = LFRACT_MIN;
+sat long long fract Sllfm = LLFRACT_MIN;
+
+sat unsigned short fract Susfm = USFRACT_MIN;
+sat unsigned fract Sufm = UFRACT_MIN;
+sat unsigned long fract Sulfm = ULFRACT_MIN;
+sat unsigned long long fract Sullfm = ULLFRACT_MIN;
+
+short fract sfE = SFRACT_EPSILON;
+fract fE = FRACT_EPSILON;
+long fract lfE = LFRACT_EPSILON;
+long long fract llfE = LLFRACT_EPSILON;
+
+unsigned short fract usfE = USFRACT_EPSILON;
+unsigned fract ufE = UFRACT_EPSILON;
+unsigned long fract ulfE = ULFRACT_EPSILON;
+unsigned long long fract ullfE = ULLFRACT_EPSILON;
+
+sat short fract SsfE = SFRACT_EPSILON;
+sat fract SfE = FRACT_EPSILON;
+sat long fract SlfE = LFRACT_EPSILON;
+sat long long fract SllfE = LLFRACT_EPSILON;
+
+sat unsigned short fract SusfE = USFRACT_EPSILON;
+sat unsigned fract SufE = UFRACT_EPSILON;
+sat unsigned long fract SulfE = ULFRACT_EPSILON;
+sat unsigned long long fract SullfE = ULLFRACT_EPSILON;
+
+short accum sk = SACCUM_MAX;
+accum k = ACCUM_MAX;
+long accum lk = LACCUM_MAX;
+long long accum llk = LLACCUM_MAX;
+
+unsigned short accum usk = USACCUM_MAX;
+unsigned accum uk = UACCUM_MAX;
+unsigned long accum ulk = ULACCUM_MAX;
+unsigned long long accum ullk = ULLACCUM_MAX;
+
+sat short accum Ssk = SACCUM_MAX;
+sat accum Sk = ACCUM_MAX;
+sat long accum Slk = LACCUM_MAX;
+sat long long accum Sllk = LLACCUM_MAX;
+
+sat unsigned short accum Susk = USACCUM_MAX;
+sat unsigned accum Suk = UACCUM_MAX;
+sat unsigned long accum Sulk = ULACCUM_MAX;
+sat unsigned long long accum Sullk = ULLACCUM_MAX;
+
+short accum skm = SACCUM_MIN;
+accum km = ACCUM_MIN;
+long accum lkm = LACCUM_MIN;
+long long accum llkm = LLACCUM_MIN;
+
+unsigned short accum uskm = USACCUM_MIN;
+unsigned accum ukm = UACCUM_MIN;
+unsigned long accum ulkm = ULACCUM_MIN;
+unsigned long long accum ullkm = ULLACCUM_MIN;
+
+sat short accum Sskm = SACCUM_MIN;
+sat accum Skm = ACCUM_MIN;
+sat long accum Slkm = LACCUM_MIN;
+sat long long accum Sllkm = LLACCUM_MIN;
+
+sat unsigned short accum Suskm = USACCUM_MIN;
+sat unsigned accum Sukm = UACCUM_MIN;
+sat unsigned long accum Sulkm = ULACCUM_MIN;
+sat unsigned long long accum Sullkm = ULLACCUM_MIN;
+
+short accum skE = SACCUM_EPSILON;
+accum kE = ACCUM_EPSILON;
+long accum lkE = LACCUM_EPSILON;
+long long accum llkE = LLACCUM_EPSILON;
+
+unsigned short accum uskE = USACCUM_EPSILON;
+unsigned accum ukE = UACCUM_EPSILON;
+unsigned long accum ulkE = ULACCUM_EPSILON;
+unsigned long long accum ullkE = ULLACCUM_EPSILON;
+
+sat short accum SskE = SACCUM_EPSILON;
+sat accum SkE = ACCUM_EPSILON;
+sat long accum SlkE = LACCUM_EPSILON;
+sat long long accum SllkE = LLACCUM_EPSILON;
+
+sat unsigned short accum SuskE = USACCUM_EPSILON;
+sat unsigned accum SukE = UACCUM_EPSILON;
+sat unsigned long accum SulkE = ULACCUM_EPSILON;
+sat unsigned long long accum SullkE = ULLACCUM_EPSILON;
+
+int fbit_sf = SFRACT_FBIT;
+int fbit_f = FRACT_FBIT;
+int fbit_lf = LFRACT_FBIT;
+int fbit_llf = LLFRACT_FBIT;
+
+int fbit_usf = USFRACT_FBIT;
+int fbit_uf = UFRACT_FBIT;
+int fbit_ulf = ULFRACT_FBIT;
+int fbit_ullf = ULLFRACT_FBIT;
+
+int fbit_sk = SACCUM_FBIT;
+int fbit_k = ACCUM_FBIT;
+int fbit_lk = LACCUM_FBIT;
+int fbit_llk = LLACCUM_FBIT;
+
+int fbit_usk = USACCUM_FBIT;
+int fbit_uk = UACCUM_FBIT;
+int fbit_ulk = ULACCUM_FBIT;
+int fbit_ullk = ULLACCUM_FBIT;
+
+int ibit_sk = SACCUM_IBIT;
+int ibit_k = ACCUM_IBIT;
+int ibit_lk = LACCUM_IBIT;
+int ibit_llk = LLACCUM_IBIT;
+
+int ibit_usk = USACCUM_IBIT;
+int ibit_uk = UACCUM_IBIT;
+int ibit_ulk = ULACCUM_IBIT;
+int ibit_ullk = ULLACCUM_IBIT;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/fixed-point.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/fixed-point.exp
new file mode 100644
index 000000000..bdb241f48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/fixed-point.exp
@@ -0,0 +1,40 @@
+# Copyright (C) 1997, 2004, 2009 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 this program; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Skip these tests for targets that don't support this extension.
+if { ![check_effective_target_fixed_point] } {
+    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-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-array.c
new file mode 100644
index 000000000..0d0e8c191
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-array.c
@@ -0,0 +1,102 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing array elements involving fixed-point types.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+/* A handful of functions that return the Nth argument of
+   an incoming array.  */
+
+#define FUNC(TYPE,NAME) \
+TYPE NAME ## 0 (TYPE args[]) { return args[0]; } \
+TYPE NAME ## 1 (TYPE args[]) { return args[1]; } \
+TYPE NAME ## 2 (TYPE args[]) { return args[2]; } \
+TYPE NAME ## 3 (TYPE args[]) { return args[3]; } \
+TYPE NAME ## 4 (TYPE args[]) { return args[4]; } \
+TYPE NAME ## 5 (TYPE args[]) { return args[5]; }
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+int main()
+{
+#define TEST(TYPE,NAME,PF) \
+  { \
+    TYPE NAME[] = { 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, 0.4 ## PF, \
+		    0.5 ## PF }; \
+    if (NAME ## 0 (NAME) != 0.0 ## PF) abort (); \
+    if (NAME ## 1 (NAME) != 0.1 ## PF) abort (); \
+    if (NAME ## 2 (NAME) != 0.2 ## PF) abort (); \
+    if (NAME ## 3 (NAME) != 0.3 ## PF) abort (); \
+    if (NAME ## 4 (NAME) != 0.4 ## PF) abort (); \
+    if (NAME ## 5 (NAME) != 0.5 ## PF) abort (); \
+  }
+
+  TEST (short _Fract, sf, hr)
+  TEST (_Fract, f, r)
+  TEST (long _Fract, lf, lr)
+  TEST (long long _Fract, llf, llr)
+  TEST (unsigned short _Fract, usf, uhr)
+  TEST (unsigned _Fract, uf, ur)
+  TEST (unsigned long _Fract, ulf, ulr)
+  TEST (unsigned long long _Fract, ullf, ullr)
+  TEST (_Sat short _Fract, Ssf, hr)
+  TEST (_Sat _Fract, Sf, r)
+  TEST (_Sat long _Fract, Slf, lr)
+  TEST (_Sat long long _Fract, Sllf, llr)
+  TEST (_Sat unsigned short _Fract, Susf, uhr)
+  TEST (_Sat unsigned _Fract, Suf, ur)
+  TEST (_Sat unsigned long _Fract, Sulf, ulr)
+  TEST (_Sat unsigned long long _Fract, Sullf, ullr)
+  TEST (short _Accum, sa, hk)
+  TEST (_Accum, a, k)
+  TEST (long _Accum, la, lk)
+  TEST (long long _Accum, lla, llk)
+  TEST (unsigned short _Accum, usa, uhk)
+  TEST (unsigned _Accum, ua, uk)
+  TEST (unsigned long _Accum, ula, ulk)
+  TEST (unsigned long long _Accum, ulla, ullk)
+  TEST (_Sat short _Accum, Ssa, hk)
+  TEST (_Sat _Accum, Sa, k)
+  TEST (_Sat long _Accum, Sla, lk)
+  TEST (_Sat long long _Accum, Slla, llk)
+  TEST (_Sat unsigned short _Accum, Susa, uhk)
+  TEST (_Sat unsigned _Accum, Sua, uk)
+  TEST (_Sat unsigned long _Accum, Sula, ulk)
+  TEST (_Sat unsigned long long _Accum, Sulla, ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-mixed.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-mixed.c
new file mode 100644
index 000000000..01930e450
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-mixed.c
@@ -0,0 +1,103 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test scalar passing and return values involving fixed-point types.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+/* A handful of functions that return the Nth argument of
+   an incoming array.  */
+
+#define FUNC(TYPE,NAME) \
+TYPE NAME ## 0 (TYPE arg0, int arg1, unsigned arg2, float arg3, double arg4) \
+  { return arg0; } \
+TYPE NAME ## 1 (int arg0, TYPE arg1, unsigned arg2, float arg3, double arg4) \
+  { return arg1; } \
+TYPE NAME ## 2 (int arg0, unsigned arg1, TYPE arg2, float arg3, double arg4) \
+  { return arg2; } \
+TYPE NAME ## 3 (int arg0, unsigned arg1, float arg2, TYPE arg3, double arg4) \
+  { return arg3; } \
+TYPE NAME ## 4 (int arg0, unsigned arg1, float arg2, double arg3, TYPE arg4) \
+  { return arg4; }
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+int main()
+{
+#define TEST(TYPE,NAME,PF) \
+  { \
+    if (NAME ## 0 (0.1 ## PF, -1, 1, 0.3f, 0.5) != 0.1 ## PF) abort (); \
+    if (NAME ## 1 (-1, 0.1 ## PF, 1, 0.3f, 0.5) != 0.1 ## PF) abort (); \
+    if (NAME ## 2 (-1, 1, 0.1 ## PF, 0.3f, 0.5) != 0.1 ## PF) abort (); \
+    if (NAME ## 3 (-1, 1, 0.3f, 0.1 ## PF, 0.5) != 0.1 ## PF) abort (); \
+    if (NAME ## 4 (-1, 1, 0.3f, 0.5, 0.1 ## PF) != 0.1 ## PF) abort (); \
+  }
+
+  TEST (short _Fract, sf, hr)
+  TEST (_Fract, f, r)
+  TEST (long _Fract, lf, lr)
+  TEST (long long _Fract, llf, llr)
+  TEST (unsigned short _Fract, usf, uhr)
+  TEST (unsigned _Fract, uf, ur)
+  TEST (unsigned long _Fract, ulf, ulr)
+  TEST (unsigned long long _Fract, ullf, ullr)
+  TEST (_Sat short _Fract, Ssf, hr)
+  TEST (_Sat _Fract, Sf, r)
+  TEST (_Sat long _Fract, Slf, lr)
+  TEST (_Sat long long _Fract, Sllf, llr)
+  TEST (_Sat unsigned short _Fract, Susf, uhr)
+  TEST (_Sat unsigned _Fract, Suf, ur)
+  TEST (_Sat unsigned long _Fract, Sulf, ulr)
+  TEST (_Sat unsigned long long _Fract, Sullf, ullr)
+  TEST (short _Accum, sa, hk)
+  TEST (_Accum, a, k)
+  TEST (long _Accum, la, lk)
+  TEST (long long _Accum, lla, llk)
+  TEST (unsigned short _Accum, usa, uhk)
+  TEST (unsigned _Accum, ua, uk)
+  TEST (unsigned long _Accum, ula, ulk)
+  TEST (unsigned long long _Accum, ulla, ullk)
+  TEST (_Sat short _Accum, Ssa, hk)
+  TEST (_Sat _Accum, Sa, k)
+  TEST (_Sat long _Accum, Sla, lk)
+  TEST (_Sat long long _Accum, Slla, llk)
+  TEST (_Sat unsigned short _Accum, Susa, uhk)
+  TEST (_Sat unsigned _Accum, Sua, uk)
+  TEST (_Sat unsigned long _Accum, Sula, ulk)
+  TEST (_Sat unsigned long long _Accum, Sulla, ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-scalar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-scalar.c
new file mode 100644
index 000000000..957b56281
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-scalar.c
@@ -0,0 +1,108 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test scalar passing and return values involving fixed-point types.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+/* A handful of functions that return the Nth argument of
+   an incoming array.  */
+
+#define FUNC(TYPE,NAME) \
+TYPE NAME ## 0 (TYPE arg0, TYPE arg1, TYPE arg2, TYPE arg3, TYPE arg4) \
+  { return arg0; } \
+TYPE NAME ## 1 (TYPE arg0, TYPE arg1, TYPE arg2, TYPE arg3, TYPE arg4) \
+  { return arg1; } \
+TYPE NAME ## 2 (TYPE arg0, TYPE arg1, TYPE arg2, TYPE arg3, TYPE arg4) \
+  { return arg2; } \
+TYPE NAME ## 3 (TYPE arg0, TYPE arg1, TYPE arg2, TYPE arg3, TYPE arg4) \
+  { return arg3; } \
+TYPE NAME ## 4 (TYPE arg0, TYPE arg1, TYPE arg2, TYPE arg3, TYPE arg4) \
+  { return arg4; }
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+int main()
+{
+#define TEST(TYPE,NAME,PF) \
+  { \
+    if (NAME ## 0 (0.1 ## PF, 0.2 ## PF, 0.3 ## PF, 0.4 ## PF, 0.5 ## PF) \
+	!= 0.1 ## PF) abort (); \
+    if (NAME ## 1 (0.1 ## PF, 0.2 ## PF, 0.3 ## PF, 0.4 ## PF, 0.5 ## PF) \
+	!= 0.2 ## PF) abort (); \
+    if (NAME ## 2 (0.1 ## PF, 0.2 ## PF, 0.3 ## PF, 0.4 ## PF, 0.5 ## PF) \
+	!= 0.3 ## PF) abort (); \
+    if (NAME ## 3 (0.1 ## PF, 0.2 ## PF, 0.3 ## PF, 0.4 ## PF, 0.5 ## PF) \
+	!= 0.4 ## PF) abort (); \
+    if (NAME ## 4 (0.1 ## PF, 0.2 ## PF, 0.3 ## PF, 0.4 ## PF, 0.5 ## PF) \
+	!= 0.5 ## PF) abort (); \
+  }
+
+  TEST (short _Fract, sf, hr)
+  TEST (_Fract, f, r)
+  TEST (long _Fract, lf, lr)
+  TEST (long long _Fract, llf, llr)
+  TEST (unsigned short _Fract, usf, uhr)
+  TEST (unsigned _Fract, uf, ur)
+  TEST (unsigned long _Fract, ulf, ulr)
+  TEST (unsigned long long _Fract, ullf, ullr)
+  TEST (_Sat short _Fract, Ssf, hr)
+  TEST (_Sat _Fract, Sf, r)
+  TEST (_Sat long _Fract, Slf, lr)
+  TEST (_Sat long long _Fract, Sllf, llr)
+  TEST (_Sat unsigned short _Fract, Susf, uhr)
+  TEST (_Sat unsigned _Fract, Suf, ur)
+  TEST (_Sat unsigned long _Fract, Sulf, ulr)
+  TEST (_Sat unsigned long long _Fract, Sullf, ullr)
+  TEST (short _Accum, sa, hk)
+  TEST (_Accum, a, k)
+  TEST (long _Accum, la, lk)
+  TEST (long long _Accum, lla, llk)
+  TEST (unsigned short _Accum, usa, uhk)
+  TEST (unsigned _Accum, ua, uk)
+  TEST (unsigned long _Accum, ula, ulk)
+  TEST (unsigned long long _Accum, ulla, ullk)
+  TEST (_Sat short _Accum, Ssa, hk)
+  TEST (_Sat _Accum, Sa, k)
+  TEST (_Sat long _Accum, Sla, lk)
+  TEST (_Sat long long _Accum, Slla, llk)
+  TEST (_Sat unsigned short _Accum, Susa, uhk)
+  TEST (_Sat unsigned _Accum, Sua, uk)
+  TEST (_Sat unsigned long _Accum, Sula, ulk)
+  TEST (_Sat unsigned long long _Accum, Sulla, ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-struct.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-struct.c
new file mode 100644
index 000000000..c75388863
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-struct.c
@@ -0,0 +1,191 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test structure passing and return values involving fixed-point types.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+struct example
+{
+  short _Fract sf;
+  char dummy1;
+  _Fract f;
+  char dummy2;
+  long _Fract lf;
+  char dummy3;
+  long long _Fract llf;
+  char dummy4;
+  unsigned short _Fract usf;
+  char dummy5;
+  unsigned _Fract uf;
+  char dummy6;
+  unsigned long _Fract ulf;
+  char dummy7;
+  unsigned long long _Fract ullf;
+  char dummy8;
+  _Sat short _Fract Ssf;
+  char dummy9;
+  _Sat _Fract Sf;
+  char dummy10;
+  _Sat long _Fract Slf;
+  char dummy11;
+  _Sat long long _Fract Sllf;
+  char dummy12;
+  _Sat unsigned short _Fract Susf;
+  char dummy13;
+  _Sat unsigned _Fract Suf;
+  char dummy14;
+  _Sat unsigned long _Fract Sulf;
+  char dummy15;
+  _Sat unsigned long long _Fract Sullf;
+  char dummy16;
+  short _Accum sa;
+  char dummya1;
+  _Accum a;
+  char dummya2;
+  long _Accum la;
+  char dummya3;
+  long long _Accum lla;
+  char dummya4;
+  unsigned short _Accum usa;
+  char dummya5;
+  unsigned _Accum ua;
+  char dummya6;
+  unsigned long _Accum ula;
+  char dummya7;
+  unsigned long long _Accum ulla;
+  char dummya8;
+  _Sat short _Accum Ssa;
+  char dummya9;
+  _Sat _Accum Sa;
+  char dummya10;
+  _Sat long _Accum Sla;
+  char dummya11;
+  _Sat long long _Accum Slla;
+  char dummya12;
+  _Sat unsigned short _Accum Susa;
+  char dummya13;
+  _Sat unsigned _Accum Sua;
+  char dummya14;
+  _Sat unsigned long _Accum Sula;
+  char dummya15;
+  _Sat unsigned long long _Accum Sulla;
+  char dummya16;
+} nums = { 0.1hr, 'a',
+	   0.2r, 'b',
+	   0.3lr, 'c',
+	   0.4llr, 'd',
+	   0.5uhr, 'e',
+	   0.6ur, 'f',
+	   0.7ulr, 'g',
+	   0.8ullr, 'h',
+	   0.11r, 'i',
+	   0.22r, 'j',
+	   0.33lr, 'k',
+	   0.44llr, 'l',
+	   0.55uhr, 'm',
+	   0.66ur, 'n',
+	   0.77ulr, 'o',
+	   0.88ullr, 'p',
+	   0.1hk, 'q',
+	   0.2k, 'r',
+	   0.3lk, 's',
+	   0.4llk, 't',
+	   0.5uhk, 'u',
+	   0.6uk, 'v',
+	   0.7ulk, 'w',
+	   0.8ullk, 'x',
+	   0.11k, 'y',
+	   0.22k, 'z',
+	   0.33lk, '0',
+	   0.44llk, '1',
+	   0.55uhk, '2',
+	   0.66uk, '3',
+	   0.77ulk, '4',
+	   0.88ullk, '5'
+	 };
+
+/* A handful of functions that return the Nth argument of
+   an incoming array.  */
+
+#define FUNC(TYPE,NAME) \
+TYPE NAME ## _func (struct example s) \
+  { return s. NAME; }
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+int main()
+{
+#define TEST(TYPE,NAME,VALUE) \
+  { \
+    if (NAME ## _func (nums) != VALUE) abort (); \
+  }
+
+  TEST (short _Fract, sf, 0.1hr)
+  TEST (_Fract, f, 0.2r)
+  TEST (long _Fract, lf, 0.3lr)
+  TEST (long long _Fract, llf, 0.4llr)
+  TEST (unsigned short _Fract, usf, 0.5uhr)
+  TEST (unsigned _Fract, uf, 0.6ur)
+  TEST (unsigned long _Fract, ulf, 0.7ulr)
+  TEST (unsigned long long _Fract, ullf, 0.8ullr)
+  TEST (_Sat short _Fract, Ssf, 0.11hr)
+  TEST (_Sat _Fract, Sf, 0.22r)
+  TEST (_Sat long _Fract, Slf, 0.33lr)
+  TEST (_Sat long long _Fract, Sllf, 0.44llr)
+  TEST (_Sat unsigned short _Fract, Susf, 0.55uhr)
+  TEST (_Sat unsigned _Fract, Suf, 0.66ur)
+  TEST (_Sat unsigned long _Fract, Sulf, 0.77ulr)
+  TEST (_Sat unsigned long long _Fract, Sullf, 0.88ullr)
+  TEST (short _Accum, sa, 0.1hk)
+  TEST (_Accum, a, 0.2k)
+  TEST (long _Accum, la, 0.3lk)
+  TEST (long long _Accum, lla, 0.4llk)
+  TEST (unsigned short _Accum, usa, 0.5uhk)
+  TEST (unsigned _Accum, ua, 0.6uk)
+  TEST (unsigned long _Accum, ula, 0.7ulk)
+  TEST (unsigned long long _Accum, ulla, 0.8ullk)
+  TEST (_Sat short _Accum, Ssa, 0.11hk)
+  TEST (_Sat _Accum, Sa, 0.22k)
+  TEST (_Sat long _Accum, Sla, 0.33lk)
+  TEST (_Sat long long _Accum, Slla, 0.44llk)
+  TEST (_Sat unsigned short _Accum, Susa, 0.55uhk)
+  TEST (_Sat unsigned _Accum, Sua, 0.66uk)
+  TEST (_Sat unsigned long _Accum, Sula, 0.77ulk)
+  TEST (_Sat unsigned long long _Accum, Sulla, 0.88ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg-mixed.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg-mixed.c
new file mode 100644
index 000000000..61a30e765
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg-mixed.c
@@ -0,0 +1,145 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing varargs of fixed-point types.
+   Based on the test from ../dfp/.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+static int
+vararg_int (unsigned arg, ...)
+{
+  va_list ap;
+  int result_i;
+  va_start (ap, arg);
+  result_i = va_arg (ap, int);
+  return result_i;
+}
+
+static _Fract
+vararg_fract (unsigned arg, ...)
+{
+  va_list ap;
+  int result_i;
+  _Fract result_fr; \
+  va_start (ap, arg);
+  result_i = va_arg (ap, int);
+  result_fr = va_arg (ap, _Fract); \
+  return result_fr;
+}
+
+static int
+vararg_double (unsigned arg, ...)
+{
+  va_list ap;
+  int result_i;
+  _Fract result_fr; \
+  double result_d;
+  va_start (ap, arg);
+  result_i = va_arg (ap, int);
+  result_fr = va_arg (ap, _Fract); \
+  result_d = va_arg (ap, double); \
+  return result_d;
+}
+
+#define FUNC(TYPE, NAME) \
+static TYPE \
+vararg_ ## NAME (unsigned arg, ...) \
+{ \
+  va_list ap; \
+  int result_i; \
+  _Fract result_fr; \
+  double result_d; \
+  TYPE result; \
+  va_start (ap, arg); \
+  result_i = va_arg (ap, int); \
+  result_fr = va_arg (ap, _Fract); \
+  result_d = va_arg (ap, double); \
+  result = va_arg (ap, TYPE); \
+  va_end (ap); \
+  return result; \
+}
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+int main()
+{
+#define TEST(NAME,PF) \
+  if (vararg_int  (0, 100, 0.9r, 55.0, 0.2 ## PF) != 100) \
+    abort (); \
+  if (vararg_fract  (1, 100, 0.9r, 55.0, 0.2 ## PF) != 0.9r) \
+    abort (); \
+  if (vararg_double  (2, 100, 0.9r, 55.0, 0.2 ## PF) != 55.0) \
+    abort (); \
+  if (vararg_ ## NAME (3, 100, 0.9r, 55.0, 0.2 ## PF) != 0.2 ## PF) \
+    abort (); \
+
+  TEST(sf, hr)
+  TEST(f, r)
+  TEST(lf, lr)
+  TEST(llf, llr)
+  TEST(usf, uhr)
+  TEST(uf, ur)
+  TEST(ulf, ulr)
+  TEST(ullf, ullr)
+  TEST(Ssf, hr)
+  TEST(Sf, r)
+  TEST(Slf, lr)
+  TEST(Sllf, llr)
+  TEST(Susf, uhr)
+  TEST(Suf, ur)
+  TEST(Sulf, ulr)
+  TEST(Sullf, ullr)
+  TEST(sa, hk)
+  TEST(a, k)
+  TEST(la, lk)
+  TEST(lla, llk)
+  TEST(usa, uhk)
+  TEST(ua, uk)
+  TEST(ula, ulk)
+  TEST(ulla, ullk)
+  TEST(Ssa, hk)
+  TEST(Sa, k)
+  TEST(Sla, lk)
+  TEST(Slla, llk)
+  TEST(Susa, uhk)
+  TEST(Sua, uk)
+  TEST(Sula, ulk)
+  TEST(Sulla, ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg-size0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg-size0.c
new file mode 100644
index 000000000..7c54e91b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg-size0.c
@@ -0,0 +1,46 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Based on the test from ../dfp/.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+struct S1
+{
+  struct
+  {
+    _Fract e;
+  } b[0];
+};
+
+/* Test handling vararg parameters whose size is 0.  */
+
+int check_var(int z,...)
+{
+  double d;
+  struct S1 s1;
+  long long result;
+  va_list ap;
+  va_start (ap, z);
+  d = va_arg (ap, double);
+  s1 = va_arg (ap, struct S1);
+  result = va_arg (ap, long long);
+  va_end (ap);
+  return (result == 2LL);
+
+}
+
+int
+main ()
+{
+  struct S1 s1;
+  struct S1 a1[5];
+
+  if (check_var(5, 1.0, s1, 2LL, a1[2], a1[2]) == 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg.c
new file mode 100644
index 000000000..9f517ae52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/func-vararg.c
@@ -0,0 +1,115 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.2.2 Function calls.
+   Test passing varargs of fixed-point types.
+   Based on the test from ../dfp/.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+#define FUNC(TYPE, NAME) \
+static TYPE \
+vararg_ ## NAME (unsigned arg, ...) \
+{ \
+  int i; \
+  va_list ap; \
+  TYPE result; \
+  va_start (ap, arg); \
+  for (i = 0; i <= arg; i++) \
+    result = va_arg (ap, TYPE); \
+  va_end (ap); \
+  return result; \
+}
+
+FUNC (short _Fract, sf)
+FUNC (_Fract, f)
+FUNC (long _Fract, lf)
+FUNC (long long _Fract, llf)
+FUNC (unsigned short _Fract, usf)
+FUNC (unsigned _Fract, uf)
+FUNC (unsigned long _Fract, ulf)
+FUNC (unsigned long long _Fract, ullf)
+FUNC (_Sat short _Fract, Ssf)
+FUNC (_Sat _Fract, Sf)
+FUNC (_Sat long _Fract, Slf)
+FUNC (_Sat long long _Fract, Sllf)
+FUNC (_Sat unsigned short _Fract, Susf)
+FUNC (_Sat unsigned _Fract, Suf)
+FUNC (_Sat unsigned long _Fract, Sulf)
+FUNC (_Sat unsigned long long _Fract, Sullf)
+FUNC (short _Accum, sa)
+FUNC (_Accum, a)
+FUNC (long _Accum, la)
+FUNC (long long _Accum, lla)
+FUNC (unsigned short _Accum, usa)
+FUNC (unsigned _Accum, ua)
+FUNC (unsigned long _Accum, ula)
+FUNC (unsigned long long _Accum, ulla)
+FUNC (_Sat short _Accum, Ssa)
+FUNC (_Sat _Accum, Sa)
+FUNC (_Sat long _Accum, Sla)
+FUNC (_Sat long long _Accum, Slla)
+FUNC (_Sat unsigned short _Accum, Susa)
+FUNC (_Sat unsigned _Accum, Sua)
+FUNC (_Sat unsigned long _Accum, Sula)
+FUNC (_Sat unsigned long long _Accum, Sulla)
+
+int main()
+{
+#define TEST(NAME,PF) \
+  if (vararg_ ## NAME (0, 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, \
+		       0.4 ## PF, 0.5 ## PF) != 0.0 ## PF) \
+    abort (); \
+  if (vararg_ ## NAME (1, 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, \
+		       0.4 ## PF, 0.5 ## PF) != 0.1 ## PF) \
+    abort (); \
+  if (vararg_ ## NAME (2, 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, \
+		       0.4 ## PF, 0.5 ## PF) != 0.2 ## PF) \
+    abort (); \
+  if (vararg_ ## NAME (3, 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, \
+		       0.4 ## PF, 0.5 ## PF) != 0.3 ## PF) \
+    abort (); \
+  if (vararg_ ## NAME (4, 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, \
+		       0.4 ## PF, 0.5 ## PF) != 0.4 ## PF) \
+    abort (); \
+  if (vararg_ ## NAME (5, 0.0 ## PF, 0.1 ## PF, 0.2 ## PF, 0.3 ## PF, \
+		       0.4 ## PF, 0.5 ## PF) != 0.5 ## PF) \
+    abort ();
+
+  TEST(sf, hr)
+  TEST(f, r)
+  TEST(lf, lr)
+  TEST(llf, llr)
+  TEST(usf, uhr)
+  TEST(uf, ur)
+  TEST(ulf, ulr)
+  TEST(ullf, ullr)
+  TEST(Ssf, hr)
+  TEST(Sf, r)
+  TEST(Slf, lr)
+  TEST(Sllf, llr)
+  TEST(Susf, uhr)
+  TEST(Suf, ur)
+  TEST(Sulf, ulr)
+  TEST(Sullf, ullr)
+  TEST(sa, hk)
+  TEST(a, k)
+  TEST(la, lk)
+  TEST(lla, llk)
+  TEST(usa, uhk)
+  TEST(ua, uk)
+  TEST(ula, ulk)
+  TEST(ulla, ullk)
+  TEST(Ssa, hk)
+  TEST(Sa, k)
+  TEST(Sla, lk)
+  TEST(Slla, llk)
+  TEST(Susa, uhk)
+  TEST(Sua, uk)
+  TEST(Sula, ulk)
+  TEST(Sulla, ullk)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/int-warning.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/int-warning.c
new file mode 100644
index 000000000..cf48e4ba2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/int-warning.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -O2" } */
+
+/* N1169 Conversion from fixed-point to integer.
+   Test if GCC warns when overflow or underflow.  */
+
+signed char sc;
+unsigned char uc;
+
+void test()
+{
+  sc = 500k; /* { dg-warning "overflow in implicit constant conversion" } */
+  sc = -500k; /* { dg-warning "overflow in implicit constant conversion" } */
+  sc = 500lk; /* { dg-warning "overflow in implicit constant conversion" } */
+  sc = -500lk; /* { dg-warning "overflow in implicit constant conversion" } */
+  sc = 500llk; /* { dg-warning "overflow in implicit constant conversion" } */
+  sc = -500llk; /* { dg-warning "overflow in implicit constant conversion" } */
+  uc = 500k; /* { dg-warning "overflow in implicit constant conversion" } */
+  uc = -500k; /* { dg-warning "overflow in implicit constant conversion" } */
+  uc = 500lk; /* { dg-warning "overflow in implicit constant conversion" } */
+  uc = -500lk; /* { dg-warning "overflow in implicit constant conversion" } */
+  uc = 500llk; /* { dg-warning "overflow in implicit constant conversion" } */
+  uc = -500llk; /* { dg-warning "overflow in implicit constant conversion" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-c89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-c89.c
new file mode 100644
index 000000000..df852148e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-c89.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+
+/* Flixed-point keywords are not recognized in C89 mode.  */
+
+_Fract w;		/* { dg-error "" } */
+_Accum x;		/* { dg-error "" } */
+_Sat _Fract y;		/* { dg-error "" } */
+_Sat _Accum z;		/* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-c99.c
new file mode 100644
index 000000000..471e00446
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-c99.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* Fixed-point keywords are not recognized in C99 mode.  */
+
+_Fract w;		/* { dg-error "" } */
+_Accum x;		/* { dg-error "" } */
+_Sat _Fract y;		/* { dg-error "" } */
+_Sat _Fract z;		/* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-ignored-c99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-ignored-c99.c
new file mode 100644
index 000000000..c20b8e4ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-ignored-c99.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* Fixed-point keywords are not reserved for c99.  */
+
+int _Fract (void)
+{
+  return 0;
+}
+
+int _Accum (void)
+{
+  return 0;
+}
+
+int _Sat (void)
+{
+  return 0;
+}
+
+int foo1 (int i)
+{
+  int _Fract = i * 2;
+  return _Fract;
+}
+
+int foo2 (int i)
+{
+  int _Accum = i * 2;
+  return _Accum;
+}
+
+int foo3 (int i)
+{
+  int _Sat = i * 2;
+  return _Sat;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-pedantic.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-pedantic.c
new file mode 100644
index 000000000..654710671
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-pedantic.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+/* Fixed-point is a GCC extension.  */
+
+_Fract w;		/* { dg-warning "GCC extension|ISO C" } */
+_Accum x;		/* { dg-warning "GCC extension|ISO C" } */
+_Sat _Fract y;		/* { dg-warning "GCC extension|ISO C" } */
+_Sat _Accum z;		/* { dg-warning "GCC extension|ISO C" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-reserved.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-reserved.c
new file mode 100644
index 000000000..63b634982
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/keywords-reserved.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.4.1: Keywords.
+   C99 6.4.1(2): Keywords.
+   Fixed-point keywords cannot be used in other contexts.  */
+
+int _Fract (void)		/* { dg-error "" } */
+{
+  return 0;
+}
+
+int _Accum (void)		/* { dg-error "" } */
+{
+  return 0;
+}
+
+int _Sat (void)			/* { dg-error "" } */
+{
+  return 0;
+}
+
+int foo1 (int i)
+{
+  int _Fract = i * 2;		/* { dg-error "" } */
+  return _Fract;		/* { dg-error "" } */
+}
+
+int foo2 (int i)
+{
+  int _Accum = i * 2;		/* { dg-error "" } */
+  return _Accum;		/* { dg-error "" } */
+}
+
+int foo3 (int i)
+{
+  int _Sat = i * 2;		/* { dg-error "" } */
+  return _Sat;			/* { dg-error "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/loop-index.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/loop-index.c
new file mode 100644
index 000000000..d7ed9116f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/loop-index.c
@@ -0,0 +1,91 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.8.5.2: The for statement.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+#define FUNC(TYPE,NAME,PF) \
+void \
+NAME (void) \
+{ \
+  TYPE d; \
+  int i; \
+  for (d = 0.1 ## PF, i = 0; d <= 0.8 ## PF; d += 0.1 ## PF) \
+    i++; \
+  if (i != 8) \
+    abort(); \
+}
+
+FUNC (short _Fract, sf, hr)
+FUNC (_Fract, f, r)
+FUNC (long _Fract, lf, lr)
+FUNC (long long _Fract, llf, llr)
+FUNC (unsigned short _Fract, usf, uhr)
+FUNC (unsigned _Fract, uf, ur)
+FUNC (unsigned long _Fract, ulf, ulr)
+FUNC (unsigned long long _Fract, ullf, ullr)
+FUNC (_Sat short _Fract, Ssf, hr)
+FUNC (_Sat _Fract, Sf, r)
+FUNC (_Sat long _Fract, Slf, lr)
+FUNC (_Sat long long _Fract, Sllf, llr)
+FUNC (_Sat unsigned short _Fract, Susf, uhr)
+FUNC (_Sat unsigned _Fract, Suf, ur)
+FUNC (_Sat unsigned long _Fract, Sulf, ulr)
+FUNC (_Sat unsigned long long _Fract, Sullf, ullr)
+FUNC (short _Accum, sa, hk)
+FUNC (_Accum, a, k)
+FUNC (long _Accum, la, lk)
+FUNC (long long _Accum, lla, llk)
+FUNC (unsigned short _Accum, usa, uhk)
+FUNC (unsigned _Accum, ua, uk)
+FUNC (unsigned long _Accum, ula, ulk)
+FUNC (unsigned long long _Accum, ulla, ullk)
+FUNC (_Sat short _Accum, Ssa, hk)
+FUNC (_Sat _Accum, Sa, k)
+FUNC (_Sat long _Accum, Sla, lk)
+FUNC (_Sat long long _Accum, Slla, llk)
+FUNC (_Sat unsigned short _Accum, Susa, uhk)
+FUNC (_Sat unsigned _Accum, Sua, uk)
+FUNC (_Sat unsigned long _Accum, Sula, ulk)
+FUNC (_Sat unsigned long long _Accum, Sulla, ullk)
+
+int
+main ()
+{
+  sf ();
+  f ();
+  lf ();
+  llf ();
+  usf ();
+  uf ();
+  ulf ();
+  ullf ();
+  Ssf ();
+  Sf ();
+  Slf ();
+  Sllf ();
+  Susf ();
+  Suf ();
+  Sulf ();
+  Sullf ();
+  sa ();
+  a ();
+  la ();
+  lla ();
+  usa ();
+  ua ();
+  ula ();
+  ulla ();
+  Ssa ();
+  Sa ();
+  Sla ();
+  Slla ();
+  Susa ();
+  Sua ();
+  Sula ();
+  Sulla ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/modes.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/modes.c
new file mode 100644
index 000000000..082b2b2c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/modes.c
@@ -0,0 +1,119 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef _Fract qq  __attribute__ ((mode (QQ)));
+typedef _Fract hq  __attribute__ ((mode (HQ)));
+typedef _Fract sq  __attribute__ ((mode (SQ)));
+typedef _Fract dq  __attribute__ ((mode (DQ)));
+typedef unsigned _Fract uqq  __attribute__ ((mode (UQQ)));
+typedef unsigned _Fract uhq  __attribute__ ((mode (UHQ)));
+typedef unsigned _Fract usq  __attribute__ ((mode (USQ)));
+typedef unsigned _Fract udq  __attribute__ ((mode (UDQ)));
+typedef _Sat _Fract Sqq  __attribute__ ((mode (QQ)));
+typedef _Sat _Fract Shq  __attribute__ ((mode (HQ)));
+typedef _Sat _Fract Ssq  __attribute__ ((mode (SQ)));
+typedef _Sat _Fract Sdq  __attribute__ ((mode (DQ)));
+typedef _Sat unsigned _Fract Suqq  __attribute__ ((mode (UQQ)));
+typedef _Sat unsigned _Fract Suhq  __attribute__ ((mode (UHQ)));
+typedef _Sat unsigned _Fract Susq  __attribute__ ((mode (USQ)));
+typedef _Sat unsigned _Fract Sudq  __attribute__ ((mode (UDQ)));
+typedef _Accum ha  __attribute__ ((mode (HA)));
+typedef _Accum sa  __attribute__ ((mode (SA)));
+typedef _Accum da  __attribute__ ((mode (DA)));
+typedef unsigned _Accum uha  __attribute__ ((mode (UHA)));
+typedef unsigned _Accum usa  __attribute__ ((mode (USA)));
+typedef unsigned _Accum uda  __attribute__ ((mode (UDA)));
+typedef _Sat _Accum Sha  __attribute__ ((mode (HA)));
+typedef _Sat _Accum Ssa  __attribute__ ((mode (SA)));
+typedef _Sat _Accum Sda  __attribute__ ((mode (DA)));
+typedef _Sat unsigned _Accum Suha  __attribute__ ((mode (UHA)));
+typedef _Sat unsigned _Accum Susa  __attribute__ ((mode (USA)));
+typedef _Sat unsigned _Accum Suda  __attribute__ ((mode (UDA)));
+
+/* Not all platforms support TQ, UTQ, TA, UTA modes.  */
+#if defined(__LP64__) && !defined(__hppa__)
+typedef _Fract tq  __attribute__ ((mode (TQ)));
+typedef unsigned _Fract utq  __attribute__ ((mode (UTQ)));
+typedef _Sat _Fract Stq  __attribute__ ((mode (TQ)));
+typedef _Sat unsigned _Fract Sutq  __attribute__ ((mode (UTQ)));
+typedef _Accum ta  __attribute__ ((mode (TA)));
+typedef unsigned _Accum uta  __attribute__ ((mode (UTA)));
+typedef _Sat _Accum Sta  __attribute__ ((mode (TA)));
+typedef _Sat unsigned _Accum Suta  __attribute__ ((mode (UTA)));
+
+int tqsize[sizeof (tq) == 16 ? 1 : -1];
+int utqsize[sizeof (utq) == 16 ? 1 : -1];
+int Stqsize[sizeof (Stq) == 16 ? 1 : -1];
+int Sutqsize[sizeof (Sutq) == 16 ? 1 : -1];
+int tasize[sizeof (ta) == 16 ? 1 : -1];
+int utasize[sizeof (uta) == 16 ? 1 : -1];
+int Stasize[sizeof (Sta) == 16 ? 1 : -1];
+int Sutasize[sizeof (Suta) == 16 ? 1 : -1];
+
+int tqalign = __alignof (tq);
+int utqalign = __alignof (utq);
+int Stqalign = __alignof (Stq);
+int Sutqalign = __alignof (Sutq);
+int taalign = __alignof (ta);
+int utaalign = __alignof (uta);
+int Staalign = __alignof (Sta);
+int Sutaalign = __alignof (Suta);
+#endif
+
+int qqsize[sizeof (qq) == 1 ? 1 : -1];
+int hqsize[sizeof (hq) == 2 ? 1 : -1];
+int sqsize[sizeof (sq) == 4 ? 1 : -1];
+int dqsize[sizeof (dq) == 8 ? 1 : -1];
+int uqqsize[sizeof (qq) == 1 ? 1 : -1];
+int uhqsize[sizeof (hq) == 2 ? 1 : -1];
+int usqsize[sizeof (sq) == 4 ? 1 : -1];
+int udqsize[sizeof (dq) == 8 ? 1 : -1];
+int Sqqsize[sizeof (Sqq) == 1 ? 1 : -1];
+int Shqsize[sizeof (Shq) == 2 ? 1 : -1];
+int Ssqsize[sizeof (Ssq) == 4 ? 1 : -1];
+int Sdqsize[sizeof (Sdq) == 8 ? 1 : -1];
+int Suqqsize[sizeof (Sqq) == 1 ? 1 : -1];
+int Suhqsize[sizeof (Shq) == 2 ? 1 : -1];
+int Susqsize[sizeof (Ssq) == 4 ? 1 : -1];
+int Sudqsize[sizeof (Sdq) == 8 ? 1 : -1];
+int hasize[sizeof (ha) == 2 ? 1 : -1];
+int sasize[sizeof (sa) == 4 ? 1 : -1];
+int dasize[sizeof (da) == 8 ? 1 : -1];
+int uhasize[sizeof (uha) == 2 ? 1 : -1];
+int usasize[sizeof (usa) == 4 ? 1 : -1];
+int udasize[sizeof (uda) == 8 ? 1 : -1];
+int Shasize[sizeof (Sha) == 2 ? 1 : -1];
+int Ssasize[sizeof (Ssa) == 4 ? 1 : -1];
+int Sdasize[sizeof (Sda) == 8 ? 1 : -1];
+int Suhasize[sizeof (Suha) == 2 ? 1 : -1];
+int Susasize[sizeof (Susa) == 4 ? 1 : -1];
+int Sudasize[sizeof (Suda) == 8 ? 1 : -1];
+
+int qqalign = __alignof (qq);
+int hqalign = __alignof (hq);
+int sqalign = __alignof (sq);
+int dqalign = __alignof (dq);
+int uqqalign = __alignof (uqq);
+int uhqalign = __alignof (uhq);
+int usqalign = __alignof (usq);
+int udqalign = __alignof (udq);
+int Sqqalign = __alignof (Sqq);
+int Shqalign = __alignof (Shq);
+int Ssqalign = __alignof (Ssq);
+int Sdqalign = __alignof (Sdq);
+int Suqqalign = __alignof (Suqq);
+int Suhqalign = __alignof (Suhq);
+int Susqalign = __alignof (Susq);
+int Sudqalign = __alignof (Sudq);
+int haalign = __alignof (ha);
+int saalign = __alignof (sa);
+int daalign = __alignof (da);
+int uhaalign = __alignof (uha);
+int usaalign = __alignof (usa);
+int udaalign = __alignof (uda);
+int Shaalign = __alignof (Sha);
+int Ssaalign = __alignof (Ssa);
+int Sdaalign = __alignof (Sda);
+int Suhaalign = __alignof (Suha);
+int Susaalign = __alignof (Susa);
+int Sudaalign = __alignof (Suda);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/muldiv-warning.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/muldiv-warning.c
new file mode 100644
index 000000000..4ac553139
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/muldiv-warning.c
@@ -0,0 +1,72 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* Check if GCC generates warnings when overflows for mul and div.  */
+
+short _Fract sf0 = __SFRACT_MIN__ * __SFRACT_MIN__; /* { dg-warning "overflow" } */
+_Fract f0 = __FRACT_MIN__ * __FRACT_MIN__; /* { dg-warning "overflow" } */
+long _Fract lf0 = __LFRACT_MIN__ * __LFRACT_MIN__; /* { dg-warning "overflow" } */
+long long _Fract llf0 = __LLFRACT_MIN__ * __LLFRACT_MIN__; /* { dg-warning "overflow" } */
+short _Fract sf1 = __SFRACT_MAX__ * __SFRACT_MIN__;
+_Fract f1 = __FRACT_MAX__ * __FRACT_MIN__;
+long _Fract lf1 = __LFRACT_MAX__ * __LFRACT_MIN__;
+long long _Fract llf1 = __LLFRACT_MAX__ * __LLFRACT_MIN__;
+short _Fract sf2 = __SFRACT_MIN__ / __SFRACT_MIN__; /* { dg-warning "overflow" } */
+_Fract f2 = __FRACT_MIN__ / __FRACT_MIN__; /* { dg-warning "overflow" } */
+long _Fract lf2 = __LFRACT_MIN__ / __LFRACT_MIN__; /* { dg-warning "overflow" } */
+long long _Fract llf2 = __LLFRACT_MIN__ / __LLFRACT_MIN__; /* { dg-warning "overflow" } */
+short _Fract sf3 = __SFRACT_MAX__ / __SFRACT_MIN__;
+_Fract f3 = __FRACT_MAX__ / __FRACT_MIN__;
+long _Fract lf3 = __LFRACT_MAX__ / __LFRACT_MIN__;
+long long _Fract llf3 = __LLFRACT_MAX__ / __LLFRACT_MIN__;
+
+unsigned short _Fract usf0 = __USFRACT_MIN__ * __USFRACT_MIN__;
+unsigned _Fract uf0 = __UFRACT_MIN__ * __UFRACT_MIN__;
+unsigned long _Fract ulf0 = __ULFRACT_MIN__ * __ULFRACT_MIN__;
+unsigned long long _Fract ullf0 = __ULLFRACT_MIN__ * __ULLFRACT_MIN__;
+unsigned short _Fract usf1 = __USFRACT_MAX__ * __USFRACT_MIN__;
+unsigned _Fract uf1 = __UFRACT_MAX__ * __UFRACT_MIN__;
+unsigned long _Fract ulf1 = __ULFRACT_MAX__ * __ULFRACT_MIN__;
+unsigned long long _Fract ullf1 = __ULLFRACT_MAX__ * __ULLFRACT_MIN__;
+unsigned short _Fract usf2 = __USFRACT_MAX__ / __USFRACT_MAX__; /* { dg-warning "overflow" } */
+unsigned _Fract uf2 = __UFRACT_MAX__ / __UFRACT_MAX__; /* { dg-warning "overflow" } */
+unsigned long _Fract ulf2 = __ULFRACT_MAX__ / __ULFRACT_MAX__; /* { dg-warning "overflow" } */
+unsigned long long _Fract ullf2 = __ULLFRACT_MAX__ / __ULLFRACT_MAX__; /* { dg-warning "overflow" } */
+unsigned short _Fract usf3 = __USFRACT_MIN__ / __USFRACT_MAX__;
+unsigned _Fract uf3 = __UFRACT_MIN__ / __UFRACT_MAX__;
+unsigned long _Fract ulf3 = __ULFRACT_MIN__ / __ULFRACT_MAX__;
+unsigned long long _Fract ullf3 = __ULLFRACT_MIN__ / __ULLFRACT_MAX__;
+
+short _Accum sa0 = __SACCUM_MIN__ * __SACCUM_MIN__; /* { dg-warning "overflow" } */
+_Accum a0 = __ACCUM_MIN__ * __ACCUM_MIN__; /* { dg-warning "overflow" } */
+long _Accum la0 = __LACCUM_MIN__ * __LACCUM_MIN__; /* { dg-warning "overflow" } */
+long long _Accum lla0 = __LLACCUM_MIN__ * __LLACCUM_MIN__; /* { dg-warning "overflow" } */
+short _Accum sa1 = __SACCUM_MAX__ * 0.1hk;
+_Accum a1 = __ACCUM_MAX__ * 0.1k;
+long _Accum la1 = __LACCUM_MAX__ * 0.1lk;
+long long _Accum lla1 = __LLACCUM_MAX__ * 0.1llk;
+short _Accum sa2 = __SACCUM_MIN__ / 0.1hk; /* { dg-warning "overflow" } */
+_Accum a2 = __ACCUM_MIN__ / 0.1k; /* { dg-warning "overflow" } */
+long _Accum la2 = __LACCUM_MIN__ / 0.1lk; /* { dg-warning "overflow" } */
+long long _Accum lla2 = __LLACCUM_MIN__ / 0.1llk; /* { dg-warning "overflow" } */
+short _Accum sa3 = __SACCUM_MAX__ / __SACCUM_MIN__;
+_Accum a3 = __ACCUM_MAX__ / __ACCUM_MIN__;
+long _Accum la3 = __LACCUM_MAX__ / __LACCUM_MIN__;
+long long _Accum lla3 = __LLACCUM_MAX__ / __LLACCUM_MIN__;
+
+unsigned short _Accum usa0 = __USACCUM_MIN__ * __USACCUM_MIN__;
+unsigned _Accum ua0 = __UACCUM_MIN__ * __UACCUM_MIN__;
+unsigned long _Accum ula0 = __ULACCUM_MIN__ * __ULACCUM_MIN__;
+unsigned long long _Accum ulla0 = __ULLACCUM_MIN__ * __ULLACCUM_MIN__;
+unsigned short _Accum usa1 = __USACCUM_MAX__ * __USACCUM_MAX__; /* { dg-warning "overflow" } */
+unsigned _Accum ua1 = __UACCUM_MAX__ * __UACCUM_MAX__; /* { dg-warning "overflow" } */
+unsigned long _Accum ula1 = __ULACCUM_MAX__ * __ULACCUM_MAX__; /* { dg-warning "overflow" } */
+unsigned long long _Accum ulla1 = __ULLACCUM_MAX__ * __ULLACCUM_MAX__; /* { dg-warning "overflow" } */
+unsigned short _Accum usa2 = __USACCUM_MAX__ / 0.5hk; /* { dg-warning "overflow" } */
+unsigned _Accum ua2 = __UACCUM_MAX__ / 0.5k; /* { dg-warning "overflow" } */
+unsigned long _Accum ula2 = __ULACCUM_MAX__ / 0.5lk; /* { dg-warning "overflow" } */
+unsigned long long _Accum ulla2 = __ULLACCUM_MAX__ / 0.5llk; /* { dg-warning "overflow" } */
+unsigned short _Accum usa3 = __USACCUM_MIN__ / __USACCUM_MAX__;
+unsigned _Accum ua3 = __UACCUM_MIN__ / __UACCUM_MAX__;
+unsigned long _Accum ula3 = __ULACCUM_MIN__ / __ULACCUM_MAX__;
+unsigned long long _Accum ulla3 = __ULLACCUM_MIN__ / __ULLACCUM_MAX__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/noassoc.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/noassoc.c
new file mode 100644
index 000000000..5d134e158
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/noassoc.c
@@ -0,0 +1,53 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -O0" } */
+
+extern void abort (void);
+
+/* Make sure GCC knows there is no associativity for saturating types.  */
+
+/* Don't transform to (temp + (0.5r + 0.8r))  */
+_Sat _Fract add_test (_Sat _Fract temp)
+{
+  return temp + 0.5r + 0.8r;
+}
+
+/* Don't transform to (temp * ((-0.5r - 0.5r) * (-0.5r - 0.5r)))  */
+_Sat _Fract mul_test (_Sat _Fract temp)
+{
+  return temp * (-0.5r - 0.5r) * (-0.5r - 0.5r);
+}
+
+/* Don't transform to ((temp1 + temp2) * 0.5r)  */
+_Sat _Fract mul_add_test (_Sat _Fract temp1, _Sat _Fract temp2)
+{
+  return temp1 * 0.5r + temp2 * 0.5r;
+}
+
+/* Don't transform to ((temp1 - temp2) * 0.5r)  */
+_Sat _Fract mul_sub_test (_Sat _Fract temp1, _Sat _Fract temp2)
+{
+  return temp1 * 0.5r - temp2 * 0.5r;
+}
+
+int main ()
+{
+  _Sat _Fract a;
+
+  a = add_test (-0.5r);
+  if (a != 0.8r)
+    abort ();
+
+  a = mul_test (0.1r);
+  if (a != 0.1r)
+    abort ();
+
+  a = mul_add_test (0.75r, 0.5r);
+  if (a != 0.625r)
+    abort ();
+
+  a = mul_sub_test (0.75r, -0.5r);
+  if (a != 0.625r)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-bitwise.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-bitwise.c
new file mode 100644
index 000000000..31aecf558
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-bitwise.c
@@ -0,0 +1,167 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.10: Bitwise AND operator.
+   C99 6.5.11: Bitwise exclusive OR operator.
+   C99 6.5.12: Bitwise inclusive OR operator.
+
+   Test that these operators do not accept fixed-point operands.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+#define OPERATE(OPRD1,OPRT,OPRD2)		\
+do						\
+{						\
+  OPRD1 OPRT OPRD2;				\
+} while (0)
+
+
+
+#define BITWISE_OPERATOR(OPRT,OPRD)		\
+do						\
+{						\
+OPERATE(OPRD,OPRT,1);				\
+OPERATE(OPRD,OPRT,0);				\
+OPERATE(OPRD,OPRT,0x15);			\
+OPERATE(0,OPRT,OPRD);				\
+OPERATE(1,OPRT,OPRD);				\
+OPERATE(0x15,OPRT,OPRD);			\
+} while (0)
+
+void operator_notfor_fixed_point()
+{
+  short _Fract sf;
+  _Fract f;
+  long _Fract lf;
+  long long _Fract llf;
+  unsigned short _Fract usf;
+  unsigned _Fract uf;
+  unsigned long _Fract ulf;
+  unsigned long long _Fract ullf;
+  _Sat short _Fract Ssf;
+  _Sat _Fract Sf;
+  _Sat long _Fract Slf;
+  _Sat long long _Fract Sllf;
+  _Sat unsigned short _Fract Susf;
+  _Sat unsigned _Fract Suf;
+  _Sat unsigned long _Fract Sulf;
+  _Sat unsigned long long _Fract Sullf;
+  short _Accum sa;
+  _Accum a;
+  long _Accum la;
+  long long _Accum lla;
+  unsigned short _Accum usa;
+  unsigned _Accum ua;
+  unsigned long _Accum ula;
+  unsigned long long _Accum ulla;
+  _Sat short _Accum Ssa;
+  _Sat _Accum Sa;
+  _Sat long _Accum Sla;
+  _Sat long long _Accum Slla;
+  _Sat unsigned short _Accum Susa;
+  _Sat unsigned _Accum Sua;
+  _Sat unsigned long _Accum Sula;
+  _Sat unsigned long long _Accum Sulla;
+
+  /* C99 Section 6.5.{10,11,12} Bitwise operator.  Constraints: Each of
+   the operands shall have integer type.  Fixed-point type is rejected
+   by compiler when bitwise operation is performed.  */
+
+  BITWISE_OPERATOR(&,sf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,sf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,sf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,f); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,f); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,f); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,lf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,lf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,lf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,llf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,llf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,llf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,usf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,usf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,usf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,uf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,uf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,uf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,ulf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,ulf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,ulf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,ullf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,ullf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,ullf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Ssf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Ssf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Ssf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Slf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Slf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Slf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sllf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sllf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sllf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Susf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Susf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Susf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Suf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Suf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Suf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sulf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sulf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sulf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sullf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sullf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sullf); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,sa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,sa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,sa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,a); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,a); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,a); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,la); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,la); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,la); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,lla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,lla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,lla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,usa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,usa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,usa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,ua); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,ua); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,ua); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,ula); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,ula); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,ula); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,ulla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,ulla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,ulla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Ssa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Ssa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Ssa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Slla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Slla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Slla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Susa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Susa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Susa); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sua); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sua); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sua); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sula); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sula); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sula); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(&,Sulla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(|,Sulla); /* { dg-error "invalid operands to binary" } */
+  BITWISE_OPERATOR(^,Sulla); /* { dg-error "invalid operands to binary" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-comma.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-comma.c
new file mode 100644
index 000000000..2f1316cfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-comma.c
@@ -0,0 +1,98 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.17: Comma operator.
+   Test with fixed-point operands.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+#define FUNC(TYPE,NAME,PF) \
+volatile TYPE NAME ## a, NAME ## b, NAME ## c; \
+void \
+init_ ## NAME () \
+{ \
+  NAME ## b = 0.2 ## PF; \
+  NAME ## c = 0.3 ## PF; \
+}
+
+FUNC (short _Fract, sf, hr)
+FUNC (_Fract, f, r)
+FUNC (long _Fract, lf, lr)
+FUNC (long long _Fract, llf, llr)
+FUNC (unsigned short _Fract, usf, uhr)
+FUNC (unsigned _Fract, uf, ur)
+FUNC (unsigned long _Fract, ulf, ulr)
+FUNC (long long _Fract, ullf, ullr)
+FUNC (_Sat short _Fract, Ssf, hr)
+FUNC (_Sat _Fract, Sf, r)
+FUNC (_Sat long _Fract, Slf, lr)
+FUNC (_Sat long long _Fract, Sllf, llr)
+FUNC (_Sat unsigned short _Fract, Susf, uhr)
+FUNC (_Sat unsigned _Fract, Suf, ur)
+FUNC (_Sat unsigned long _Fract, Sulf, ulr)
+FUNC (_Sat long long _Fract, Sullf, ullr)
+FUNC (short _Accum, sa, hk)
+FUNC (_Accum, a, k)
+FUNC (long _Accum, la, lk)
+FUNC (long long _Accum, lla, llk)
+FUNC (unsigned short _Accum, usa, uhk)
+FUNC (unsigned _Accum, ua, uk)
+FUNC (unsigned long _Accum, ula, ulk)
+FUNC (long long _Accum, ulla, ullk)
+FUNC (_Sat short _Accum, Ssa, hk)
+FUNC (_Sat _Accum, Sa, k)
+FUNC (_Sat long _Accum, Sla, lk)
+FUNC (_Sat long long _Accum, Slla, llk)
+FUNC (_Sat unsigned short _Accum, Susa, uhk)
+FUNC (_Sat unsigned _Accum, Sua, uk)
+FUNC (_Sat unsigned long _Accum, Sula, ulk)
+FUNC (_Sat long long _Accum, Sulla, ullk)
+
+int
+main ()
+{
+#define TEST(NAME) \
+  init_ ## NAME (); \
+  NAME ## a = (NAME ## b, NAME ## c); \
+  if (NAME ## a != NAME ## c) \
+    abort (); \
+  NAME ## a = (NAME ## c, 123, NAME ## b); \
+  if (NAME ## a != NAME ## b) \
+    abort ();
+
+  TEST(sf)
+  TEST(f)
+  TEST(lf)
+  TEST(llf)
+  TEST(usf)
+  TEST(uf)
+  TEST(ulf)
+  TEST(ullf)
+  TEST(Ssf)
+  TEST(Sf)
+  TEST(Slf)
+  TEST(Sllf)
+  TEST(Susf)
+  TEST(Suf)
+  TEST(Sulf)
+  TEST(Sullf)
+  TEST(sa)
+  TEST(a)
+  TEST(la)
+  TEST(lla)
+  TEST(usa)
+  TEST(ua)
+  TEST(ula)
+  TEST(ulla)
+  TEST(Ssa)
+  TEST(Sa)
+  TEST(Sla)
+  TEST(Slla)
+  TEST(Susa)
+  TEST(Sua)
+  TEST(Sula)
+  TEST(Sulla)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-cond.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-cond.c
new file mode 100644
index 000000000..94b0de0a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-cond.c
@@ -0,0 +1,101 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -O0" } */
+
+/* C99 6.5.15 Conditional operator.
+   Test with fixed-point operands.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+volatile int yes, no;
+
+#define FUNC(TYPE,NAME,PF) \
+volatile TYPE NAME ## a, NAME ## b, NAME ## c; \
+void \
+init_ ## NAME () \
+{ \
+  NAME ## b = 0.2 ## PF; \
+  NAME ## c = 0.3 ## PF; \
+  yes = 1; \
+  no = 0; \
+}
+
+FUNC (short _Fract, sf, hr)
+FUNC (_Fract, f, r)
+FUNC (long _Fract, lf, lr)
+FUNC (long long _Fract, llf, llr)
+FUNC (unsigned short _Fract, usf, uhr)
+FUNC (unsigned _Fract, uf, ur)
+FUNC (unsigned long _Fract, ulf, ulr)
+FUNC (long long _Fract, ullf, ullr)
+FUNC (_Sat short _Fract, Ssf, hr)
+FUNC (_Sat _Fract, Sf, r)
+FUNC (_Sat long _Fract, Slf, lr)
+FUNC (_Sat long long _Fract, Sllf, llr)
+FUNC (_Sat unsigned short _Fract, Susf, uhr)
+FUNC (_Sat unsigned _Fract, Suf, ur)
+FUNC (_Sat unsigned long _Fract, Sulf, ulr)
+FUNC (_Sat long long _Fract, Sullf, ullr)
+FUNC (short _Accum, sa, hk)
+FUNC (_Accum, a, k)
+FUNC (long _Accum, la, lk)
+FUNC (long long _Accum, lla, llk)
+FUNC (unsigned short _Accum, usa, uhk)
+FUNC (unsigned _Accum, ua, uk)
+FUNC (unsigned long _Accum, ula, ulk)
+FUNC (long long _Accum, ulla, ullk)
+FUNC (_Sat short _Accum, Ssa, hk)
+FUNC (_Sat _Accum, Sa, k)
+FUNC (_Sat long _Accum, Sla, lk)
+FUNC (_Sat long long _Accum, Slla, llk)
+FUNC (_Sat unsigned short _Accum, Susa, uhk)
+FUNC (_Sat unsigned _Accum, Sua, uk)
+FUNC (_Sat unsigned long _Accum, Sula, ulk)
+FUNC (_Sat long long _Accum, Sulla, ullk)
+
+int
+main ()
+{
+#define TEST(NAME) \
+  init_ ## NAME (); \
+  NAME ## a = yes ? NAME ## b : NAME ## c; \
+  if (NAME ## a != NAME ## b) \
+    abort (); \
+  NAME ## a = no ? NAME ## b : NAME ## c; \
+  if (NAME ## a != NAME ## c) \
+    abort ();
+
+  TEST(sf)
+  TEST(f)
+  TEST(lf)
+  TEST(llf)
+  TEST(usf)
+  TEST(uf)
+  TEST(ulf)
+  TEST(ullf)
+  TEST(Ssf)
+  TEST(Sf)
+  TEST(Slf)
+  TEST(Sllf)
+  TEST(Susf)
+  TEST(Suf)
+  TEST(Sulf)
+  TEST(Sullf)
+  TEST(sa)
+  TEST(a)
+  TEST(la)
+  TEST(lla)
+  TEST(usa)
+  TEST(ua)
+  TEST(ula)
+  TEST(ulla)
+  TEST(Ssa)
+  TEST(Sa)
+  TEST(Sla)
+  TEST(Slla)
+  TEST(Susa)
+  TEST(Sua)
+  TEST(Sula)
+  TEST(Sulla)
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-logical.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-logical.c
new file mode 100644
index 000000000..3873b2588
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-logical.c
@@ -0,0 +1,115 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 Logical AND operator.
+   C99 Logical OR operator.
+   Test with fixed-point operands.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+#define OPERATE(OPRD1,OPRT,OPRD2,RLT)	\
+do					\
+{					\
+  if (( (OPRD1) OPRT (OPRD2) )!= RLT)	\
+    abort ();				\
+} while (0)
+
+#define FIXED_POINT_LOGICAL(OPRD)	\
+do					\
+{					\
+  OPRD = 0.1;				\
+  OPERATE(1,||,OPRD,1);			\
+  OPERATE(0,||,OPRD,1);			\
+  OPERATE(OPRD,||,1,1);			\
+  OPERATE(OPRD,||,0,1);			\
+  OPRD = 0;				\
+  OPERATE(1,||,OPRD,1);			\
+  OPERATE(0,||,OPRD,0);			\
+  OPERATE(OPRD,||,1,1);			\
+  OPERATE(OPRD,||,0,0);			\
+  OPRD = 0.1;				\
+  OPERATE(1,&&,OPRD,1);			\
+  OPERATE(0,&&,OPRD,0);			\
+  OPERATE(OPRD,&&,1,1);			\
+  OPERATE(OPRD,&&,0,0);			\
+  OPRD = 0;				\
+  OPERATE(1,&&,OPRD,0);			\
+  OPERATE(0,&&,OPRD,0);			\
+  OPERATE(OPRD,&&,1,0);			\
+  OPERATE(OPRD,&&,0,0);			\
+} while (0)
+
+int
+main ()
+{
+  short _Fract sf;
+  _Fract f;
+  long _Fract lf;
+  long long _Fract llf;
+  unsigned short _Fract usf;
+  unsigned _Fract uf;
+  unsigned long _Fract ulf;
+  unsigned long long _Fract ullf;
+  _Sat short _Fract Ssf;
+  _Sat _Fract Sf;
+  _Sat long _Fract Slf;
+  _Sat long long _Fract Sllf;
+  _Sat unsigned short _Fract Susf;
+  _Sat unsigned _Fract Suf;
+  _Sat unsigned long _Fract Sulf;
+  _Sat unsigned long long _Fract Sullf;
+  short _Accum sa;
+  _Accum a;
+  long _Accum la;
+  long long _Accum lla;
+  unsigned short _Accum usa;
+  unsigned _Accum ua;
+  unsigned long _Accum ula;
+  unsigned long long _Accum ulla;
+  _Sat short _Accum Ssa;
+  _Sat _Accum Sa;
+  _Sat long _Accum Sla;
+  _Sat long long _Accum Slla;
+  _Sat unsigned short _Accum Susa;
+  _Sat unsigned _Accum Sua;
+  _Sat unsigned long _Accum Sula;
+  _Sat unsigned long long _Accum Sulla;
+
+  /* C99 Section 6.5.{13,14} Logical operator.  Constraints Each of the
+     operands shall have scalar type.  Fixed-point types would obey this.  */
+  FIXED_POINT_LOGICAL (sf);
+  FIXED_POINT_LOGICAL (f);
+  FIXED_POINT_LOGICAL (lf);
+  FIXED_POINT_LOGICAL (llf);
+  FIXED_POINT_LOGICAL (usf);
+  FIXED_POINT_LOGICAL (uf);
+  FIXED_POINT_LOGICAL (ulf);
+  FIXED_POINT_LOGICAL (ullf);
+  FIXED_POINT_LOGICAL (Ssf);
+  FIXED_POINT_LOGICAL (Sf);
+  FIXED_POINT_LOGICAL (Slf);
+  FIXED_POINT_LOGICAL (Sllf);
+  FIXED_POINT_LOGICAL (Susf);
+  FIXED_POINT_LOGICAL (Suf);
+  FIXED_POINT_LOGICAL (Sulf);
+  FIXED_POINT_LOGICAL (Sullf);
+  FIXED_POINT_LOGICAL (sa);
+  FIXED_POINT_LOGICAL (a);
+  FIXED_POINT_LOGICAL (la);
+  FIXED_POINT_LOGICAL (lla);
+  FIXED_POINT_LOGICAL (usa);
+  FIXED_POINT_LOGICAL (ua);
+  FIXED_POINT_LOGICAL (ula);
+  FIXED_POINT_LOGICAL (ulla);
+  FIXED_POINT_LOGICAL (Ssa);
+  FIXED_POINT_LOGICAL (Sa);
+  FIXED_POINT_LOGICAL (Sla);
+  FIXED_POINT_LOGICAL (Slla);
+  FIXED_POINT_LOGICAL (Susa);
+  FIXED_POINT_LOGICAL (Sua);
+  FIXED_POINT_LOGICAL (Sula);
+  FIXED_POINT_LOGICAL (Sulla);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-unary.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-unary.c
new file mode 100644
index 000000000..5ad420b02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/operator-unary.c
@@ -0,0 +1,58 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.3 Unary operators & and *.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+#define UNARY_OPERATOR(TYPE,SUFFIX)	\
+do					\
+{					\
+ TYPE unary_d = 0.1 ## SUFFIX;		\
+ TYPE* unary_dp;			\
+ /*  & operator.  */			\
+ unary_dp = &(unary_d);			\
+ /*  * operator.  */			\
+ unary_d = *(unary_dp);			\
+} while (0)
+
+int
+main ()
+{
+  /*  C99 6.5.3 Unary operators.  */
+  UNARY_OPERATOR(short _Fract, hr);
+  UNARY_OPERATOR(_Fract, r);
+  UNARY_OPERATOR(long _Fract, lr);
+  UNARY_OPERATOR(long long _Fract, llr);
+  UNARY_OPERATOR(unsigned short _Fract, uhr);
+  UNARY_OPERATOR(unsigned _Fract, ur);
+  UNARY_OPERATOR(unsigned long _Fract, ulr);
+  UNARY_OPERATOR(unsigned long long _Fract, ullr);
+  UNARY_OPERATOR(_Sat short _Fract, hr);
+  UNARY_OPERATOR(_Sat _Fract, r);
+  UNARY_OPERATOR(_Sat long _Fract, lr);
+  UNARY_OPERATOR(_Sat long long _Fract, llr);
+  UNARY_OPERATOR(_Sat unsigned short _Fract, uhr);
+  UNARY_OPERATOR(_Sat unsigned _Fract, ur);
+  UNARY_OPERATOR(_Sat unsigned long _Fract, ulr);
+  UNARY_OPERATOR(_Sat unsigned long long _Fract, ullr);
+  UNARY_OPERATOR(short _Accum, hk);
+  UNARY_OPERATOR(_Accum, k);
+  UNARY_OPERATOR(long _Accum, lk);
+  UNARY_OPERATOR(long long _Accum, llk);
+  UNARY_OPERATOR(unsigned short _Accum, uhk);
+  UNARY_OPERATOR(unsigned _Accum, uk);
+  UNARY_OPERATOR(unsigned long _Accum, ulk);
+  UNARY_OPERATOR(unsigned long long _Accum, ullk);
+  UNARY_OPERATOR(_Sat short _Accum, hk);
+  UNARY_OPERATOR(_Sat _Accum, k);
+  UNARY_OPERATOR(_Sat long _Accum, lk);
+  UNARY_OPERATOR(_Sat long long _Accum, llk);
+  UNARY_OPERATOR(_Sat unsigned short _Accum, uhk);
+  UNARY_OPERATOR(_Sat unsigned _Accum, uk);
+  UNARY_OPERATOR(_Sat unsigned long _Accum, ulk);
+  UNARY_OPERATOR(_Sat unsigned long long _Accum, ullk);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/struct-layout-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/struct-layout-1.c
new file mode 100644
index 000000000..b9a02f0c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/struct-layout-1.c
@@ -0,0 +1,77 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* This test is based on the test from ../dfp/.  */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+struct S1
+{
+  long _Fract a[0];
+};
+
+struct S2
+{
+  struct
+  {
+    long _Fract e;
+  } b[0];
+};
+
+struct S3
+{
+  union
+  {
+    long _Fract c;
+  } a[0];
+};
+
+struct S4
+{
+  int a[0];
+  long _Fract b[0];
+};
+
+struct S5
+{
+  union
+  {
+    long _Fract c[0];
+  } a;
+};
+
+int check_var (int z, ...)
+{
+  long long result;
+  va_list ap;
+  va_start (ap, z);
+  va_arg (ap, struct S1);
+  result = va_arg (ap, long long);
+  va_end (ap);
+
+  return (result == 2LL);
+}
+
+int main ()
+{
+  struct S1 s1;
+  struct S2 s2;
+  struct S3 s3;
+  struct S4 s4;
+  struct S5 s5;
+
+  if (check_var (2, s1, 2LL) == 0)
+    abort ();
+  if (check_var (2, s2, 2LL) == 0)
+    abort ();
+  if (check_var (2, s3, 2LL) == 0)
+    abort ();
+  if (check_var (2, s4, 2LL) == 0)
+    abort ();
+  if (check_var (2, s5, 2LL) == 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/struct-union.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/struct-union.c
new file mode 100644
index 000000000..114775266
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/struct-union.c
@@ -0,0 +1,63 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+/* C99 6.5.2.3 Structure and union members.
+   If the first expression has qualified type, the result has the so-qualified
+   version of the type of the designated member.
+   Based on the test from ../dfp/.  */
+
+struct s {_Fract f; const long _Fract lf;};
+struct sv { volatile _Fract f; volatile long _Fract lf; };
+union u
+{
+  const long _Fract lf;
+  _Fract f;
+  const struct s cs;
+};
+
+struct s s;
+struct sv sv;
+const struct s cs;
+
+union u u;
+const union u cu;
+
+struct s g (struct s s)
+{
+  return s;
+}
+
+union u h (union u u)
+{
+  return u;
+}
+
+void f()
+{
+  cs.f = 0.1r; /* { dg-error "assignment of read-only variable" } */
+  cs.lf = 0.2lr; /* { dg-error "assignment of read-only variable" } */
+  s.lf = 0.3lr;  /* { dg-error "assignment of read-only member" } */
+
+  s.f = 0.4r;
+  u.f = 0.5r;
+
+  u.lf = 0.6lr;    /* { dg-error "assignment of read-only member" } */
+  u.cs.f = 0.7r; /* { dg-error "assignment of read-only member" } */
+  u.cs.lf = 0.8lr; /* { dg-error "assignment of read-only member" } */
+
+  cu.f = 0.9r;   /* { dg-error "assignment of read-only variable" } */
+
+  cu.lf = 0.01lr;    /* { dg-error "assignment of read-only variable" } */
+  cu.cs.f = 0.02r; /* { dg-error "assignment of read-only variable" } */
+  cu.cs.lf = 0.03lr; /* { dg-error "assignment of read-only variable" } */
+
+  /* f().x is a valid postfix expression but is not an lvalue if
+     function f() returning a structure or union.  */
+  g(s).f = 0.04r;  /* { dg-error "lvalue required" } */
+  h(u).lf = 0.05lr;  /* { dg-error "lvalue required" } */
+
+  /* Test assignment to volatile structure members.  */
+  sv.f = 0.06r;
+  sv.lf = 0.07lr;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/types.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/types.c
new file mode 100644
index 000000000..011345cf3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/types.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* N1169 6.3.1.3a - Fixed-point types (NEW CLAUSE).
+
+   Check if all types are ok.  */
+
+short _Fract q0;
+_Fract q1;
+long _Fract q2;
+long long _Fract q3;
+unsigned short _Fract q4;
+unsigned _Fract q5;
+unsigned long _Fract q6;
+unsigned long long _Fract q7;
+_Sat short _Fract sq0;
+_Sat _Fract sq1;
+_Sat long _Fract sq2;
+_Sat long long _Fract sq3;
+_Sat unsigned short _Fract sq4;
+_Sat unsigned _Fract sq5;
+_Sat unsigned long _Fract sq6;
+_Sat unsigned long long _Fract sq7;
+
+short _Accum a0;
+_Accum a1;
+long _Accum a2;
+long long _Accum a3;
+unsigned short _Accum a4;
+unsigned _Accum a5;
+unsigned long _Accum a6;
+unsigned long long _Accum a7;
+_Sat short _Accum sa0;
+_Sat _Accum sa1;
+_Sat long _Accum sa2;
+_Sat long long _Accum sa3;
+_Sat unsigned short _Accum sa4;
+_Sat unsigned _Accum sa5;
+_Sat unsigned long _Accum sa6;
+_Sat unsigned long long _Accum sa7;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/typespec.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/typespec.c
new file mode 100644
index 000000000..9eaa29f84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/typespec.c
@@ -0,0 +1,303 @@
+/* Test for valid and invalid combinations of type specifiers.
+   Based off gcc.dg/test-spec-1.c */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef char type;
+
+void _Fract *x0;  /* { dg-error "" "void _Fract" } */
+char _Fract *x3;  /* { dg-error "" "char _Fract" } */
+short _Fract *x6;
+int _Fract *x9;   /* { dg-error "" "int _Fract" } */
+long _Fract *x12;
+float _Fract *x15;   /* { dg-error "" "float _Fract" } */
+double _Fract *x18;   /* { dg-error "" "double _Fract" } */
+signed _Fract *x21;
+_Bool _Fract *x24;   /* { dg-error "" "_Bool _Fract" } */
+int _Fract *x27;    /* { dg-error "" "int _Fract" } */
+type _Fract *x30;   /* { dg-error "" "type _Fract" } */
+char signed _Fract *x33;  /* { dg-error "" "char signed _Fract" } */
+char unsigned _Fract *x36; /* { dg-error "" "char unsigned _Fract" } */
+short _Fract *x39;
+short signed _Fract *x42;
+short unsigned _Fract *x45;
+_Fract short*x48;
+_Fract short signed*x51;
+_Fract short unsigned*x54;
+_Fract long*x57;
+_Fract long signed*x60;
+_Fract long unsigned*x63;
+_Fract signed long*x66;
+_Fract signed short*x69;
+int signed _Fract *x72;  /* { dg-error "" "int signed _Fract" } */
+int unsigned _Fract *x75;  /* { dg-error "" "int unsigned _Fract" } */
+long int _Fract *x78;  /* { dg-error "" "long int _Fract" } */
+long long _Fract *x81;
+long double _Fract *x84;  /* { dg-error "" "long double _Fract" } */
+long signed _Fract *x87;
+long unsigned _Fract *x90;
+double long _Fract *x93;  /* { dg-error "" "double long _Fract" } */
+signed char _Fract *x96;   /* { dg-error "" "signed char _Fract" } */
+signed short _Fract *x99;
+signed int _Fract *x102;  /* { dg-error "" "signed int _Fract" } */
+signed long _Fract *x105;
+unsigned char _Fract *x108; /* { dg-error "" "unsigned char _Fract" } */
+unsigned short _Fract *x111;
+unsigned int _Fract *x114; /* { dg-error "" "unsigned int _Fract" } */
+unsigned long _Fract *x117;
+short int signed _Fract *x120; /* { dg-error "" "short int signed _Fract" } */
+short int unsigned _Fract *x123; /* { dg-error "" "short int unsigned _Fract" } */
+short signed int _Fract *x126; /* { dg-error "" "short signed int _Fract" } */
+short unsigned int _Fract *x129; /* { dg-error "" "short unsigned int _Fract" } */
+int short signed _Fract *x132; /* { dg-error "" "int short signed _Fract" } */
+int short unsigned _Fract *x135; /* { dg-error "" "int short unsigned _Fract" } */
+int long long _Fract *x138; /* { dg-error "" "int long long _Fract" } */
+int long signed _Fract *x141; /* { dg-error "" "int long signed _Fract" } */
+int long unsigned _Fract *x144; /* { dg-error "" "int long unsigned _Fract" } */
+int signed short _Fract *x147; /* { dg-error "" "int signed short _Fract" } */
+int signed long _Fract *x150; /* { dg-error "" "int signed long _Fract" } */
+int unsigned short _Fract *x153; /* { dg-error "" "int unsigned short _Fract" } */
+int unsigned long _Fract *x156; /* { dg-error "" "int unsigned long _Fract" } */
+long int long _Fract *x159; /* { dg-error "" "long int long _Fract" } */
+long int signed _Fract *x162; /* { dg-error "" "long int signed _Fract" } */
+long int unsigned _Fract *x165; /* { dg-error "" "long int unsigned _Fract" } */
+long long int _Fract *x168; /* { dg-error "" "long long int _Fract" } */
+long long signed _Fract *x171;
+long long unsigned _Fract *x175;
+long signed int _Fract *x178; /* { dg-error "" "long signed int _Fract" } */
+long unsigned int _Fract *x181; /* { dg-error "" "long unsigned int _Fract" } */
+long unsigned long _Fract *x184;
+signed short int _Fract *x187; /* { dg-error "" "signed short int _Fract" } */
+signed int short _Fract *x190; /* { dg-error "" "signed int short _Fract" } */
+signed int long _Fract *x192; /* { dg-error "" "signed int long _Fract" } */
+signed long int _Fract *x195; /* { dg-error "" "signed long int _Fract" } */
+signed long long _Fract *x198;
+unsigned short int _Fract *x201; /* { dg-error "" "unsigned short int _Fract" } */
+unsigned int short _Fract *x204; /* { dg-error "" "unsigned int short _Fract" } */
+unsigned int long _Fract *x207; /* { dg-error "" "unsigned int long _Fract" } */
+unsigned long int _Fract *x210; /* { dg-error "" "unsigned long int _Fract" } */
+unsigned long long _Fract *x213;
+int long long signed _Fract *x216; /* { dg-error "" "int long long signed _Fract" } */
+int long long unsigned _Fract *x219; /* { dg-error "" "int long long unsigned _Fract" } */
+int long signed long _Fract *x222; /* { dg-error "" "int long signed long _Fract" } */
+int long unsigned long _Fract *x226; /* { dg-error "" "int long unsigned long _Fract" } */
+int signed long long _Fract *x229; /* { dg-error "" "int signed long long _Fract" } */
+int unsigned long long _Fract *x232; /* { dg-error "" "int unsigned long long _Fract" } */
+long int long signed _Fract *x235; /* { dg-error "" "long int long signed _Fract" } */
+long int long unsigned _Fract *x238; /* { dg-error "" "long int long unsigned _Fract" } */
+long int signed long _Fract *x241; /* { dg-error "" "long int signed long _Fract" } */
+long int unsigned long _Fract *x244; /* { dg-error "" "long int unsigned long _Fract" } */
+long long int signed _Fract *x247; /* { dg-error "" "long long int signed _Fract" } */
+long long int unsigned _Fract *x250; /* { dg-error "" "long long int unsigned _Fract" } */
+long long signed int _Fract *x253; /* { dg-error "" "long long signed int _Fract" } */
+long long unsigned int _Fract *x256; /* { dg-error "" "long long unsigned int _Fract" } */
+long signed int long _Fract *x259; /* { dg-error "" "long signed int long _Fract" } */
+long signed long int _Fract *x262; /* { dg-error "" "long signed long int _Fract" } */
+long unsigned int long _Fract *x265; /* { dg-error "" "long unsigned int long _Fract" } */
+long unsigned long int _Fract *x268; /* { dg-error "" "long unsigned long int _Fract" } */
+signed long long int _Fract *x271; /* { dg-error "" "signed long long int _Fract" } */
+unsigned int long long _Fract *x274; /* { dg-error "" "unsigned int long long _Fract" } */
+unsigned long int long _Fract *x277; /* { dg-error "" "unsigned long int long _Fract" } */
+unsigned long long int _Fract *x280; /* { dg-error "" "unsigned long long int _Fract" } */
+_Complex _Fract *x283; /* { dg-error "" "_Complex _Fract" } */
+_Fract _Complex *x286; /* { dg-error "" "_Fract _Complex" } */
+unsigned _Fract *x289;
+signed _Fract *x292;
+
+void _Accum *k0;  /* { dg-error "" "void _Accum" } */
+char _Accum *k3;  /* { dg-error "" "char _Accum" } */
+short _Accum *k6;
+int _Accum *k9;   /* { dg-error "" "int _Accum" } */
+long _Accum *k12;
+float _Accum *k15;   /* { dg-error "" "float _Accum" } */
+double _Accum *k18;   /* { dg-error "" "double _Accum" } */
+signed _Accum *k21;
+_Bool _Accum *k24;   /* { dg-error "" "_Bool _Accum" } */
+int _Accum *k27;    /* { dg-error "" "int _Accum" } */
+type _Accum *k30;   /* { dg-error "" "type _Accum" } */
+char signed _Accum *k33;  /* { dg-error "" "char signed _Accum" } */
+char unsigned _Accum *k36; /* { dg-error "" "char unsigned _Accum" } */
+short _Accum *k39;
+short signed _Accum *k42;
+short unsigned _Accum *k45;
+_Accum short*k48;
+_Accum short signed*k51;
+_Accum short unsigned*k54;
+_Accum long*k57;
+_Accum long signed*k60;
+_Accum long unsigned*k63;
+_Accum signed long*k66;
+_Accum signed short*k69;
+int signed _Accum *k72;  /* { dg-error "" "int signed _Accum" } */
+int unsigned _Accum *k75;  /* { dg-error "" "int unsigned _Accum" } */
+long int _Accum *k78;  /* { dg-error "" "long int _Accum" } */
+long long _Accum *k81;
+long double _Accum *k84;  /* { dg-error "" "long double _Accum" } */
+long signed _Accum *k87;
+long unsigned _Accum *k90;
+double long _Accum *k93;  /* { dg-error "" "double long _Accum" } */
+signed char _Accum *k96;   /* { dg-error "" "signed char _Accum" } */
+signed short _Accum *k99;
+signed int _Accum *k102;  /* { dg-error "" "signed int _Accum" } */
+signed long _Accum *k105;
+unsigned char _Accum *k108; /* { dg-error "" "unsigned char _Accum" } */
+unsigned short _Accum *k111;
+unsigned int _Accum *k114; /* { dg-error "" "unsigned int _Accum" } */
+unsigned long _Accum *k117;
+short int signed _Accum *k120; /* { dg-error "" "short int signed _Accum" } */
+short int unsigned _Accum *k123; /* { dg-error "" "short int unsigned _Accum" } */
+short signed int _Accum *k126; /* { dg-error "" "short signed int _Accum" } */
+short unsigned int _Accum *k129; /* { dg-error "" "short unsigned int _Accum" } */
+int short signed _Accum *k132; /* { dg-error "" "int short signed _Accum" } */
+int short unsigned _Accum *k135; /* { dg-error "" "int short unsigned _Accum" } */
+int long long _Accum *k138; /* { dg-error "" "int long long _Accum" } */
+int long signed _Accum *k141; /* { dg-error "" "int long signed _Accum" } */
+int long unsigned _Accum *k144; /* { dg-error "" "int long unsigned _Accum" } */
+int signed short _Accum *k147; /* { dg-error "" "int signed short _Accum" } */
+int signed long _Accum *k150; /* { dg-error "" "int signed long _Accum" } */
+int unsigned short _Accum *k153; /* { dg-error "" "int unsigned short _Accum" } */
+int unsigned long _Accum *k156; /* { dg-error "" "int unsigned long _Accum" } */
+long int long _Accum *k159; /* { dg-error "" "long int long _Accum" } */
+long int signed _Accum *k162; /* { dg-error "" "long int signed _Accum" } */
+long int unsigned _Accum *k165; /* { dg-error "" "long int unsigned _Accum" } */
+long long int _Accum *k168; /* { dg-error "" "long long int _Accum" } */
+long long signed _Accum *k171;
+long long unsigned _Accum *k175;
+long signed int _Accum *k178; /* { dg-error "" "long signed int _Accum" } */
+long unsigned int _Accum *k181; /* { dg-error "" "long unsigned int _Accum" } */
+long unsigned long _Accum *k184;
+signed short int _Accum *k187; /* { dg-error "" "signed short int _Accum" } */
+signed int short _Accum *k190; /* { dg-error "" "signed int short _Accum" } */
+signed int long _Accum *k192; /* { dg-error "" "signed int long _Accum" } */
+signed long int _Accum *k195; /* { dg-error "" "signed long int _Accum" } */
+signed long long _Accum *k198;
+unsigned short int _Accum *k201; /* { dg-error "" "unsigned short int _Accum" } */
+unsigned int short _Accum *k204; /* { dg-error "" "unsigned int short _Accum" } */
+unsigned int long _Accum *k207; /* { dg-error "" "unsigned int long _Accum" } */
+unsigned long int _Accum *k210; /* { dg-error "" "unsigned long int _Accum" } */
+unsigned long long _Accum *k213;
+int long long signed _Accum *k216; /* { dg-error "" "int long long signed _Accum" } */
+int long long unsigned _Accum *k219; /* { dg-error "" "int long long unsigned _Accum" } */
+int long signed long _Accum *k222; /* { dg-error "" "int long signed long _Accum" } */
+int long unsigned long _Accum *k226; /* { dg-error "" "int long unsigned long _Accum" } */
+int signed long long _Accum *k229; /* { dg-error "" "int signed long long _Accum" } */
+int unsigned long long _Accum *k232; /* { dg-error "" "int unsigned long long _Accum" } */
+long int long signed _Accum *k235; /* { dg-error "" "long int long signed _Accum" } */
+long int long unsigned _Accum *k238; /* { dg-error "" "long int long unsigned _Accum" } */
+long int signed long _Accum *k241; /* { dg-error "" "long int signed long _Accum" } */
+long int unsigned long _Accum *k244; /* { dg-error "" "long int unsigned long _Accum" } */
+long long int signed _Accum *k247; /* { dg-error "" "long long int signed _Accum" } */
+long long int unsigned _Accum *k250; /* { dg-error "" "long long int unsigned _Accum" } */
+long long signed int _Accum *k253; /* { dg-error "" "long long signed int _Accum" } */
+long long unsigned int _Accum *k256; /* { dg-error "" "long long unsigned int _Accum" } */
+long signed int long _Accum *k259; /* { dg-error "" "long signed int long _Accum" } */
+long signed long int _Accum *k262; /* { dg-error "" "long signed long int _Accum" } */
+long unsigned int long _Accum *k265; /* { dg-error "" "long unsigned int long _Accum" } */
+long unsigned long int _Accum *k268; /* { dg-error "" "long unsigned long int _Accum" } */
+signed long long int _Accum *k271; /* { dg-error "" "signed long long int _Accum" } */
+unsigned int long long _Accum *k274; /* { dg-error "" "unsigned int long long _Accum" } */
+unsigned long int long _Accum *k277; /* { dg-error "" "unsigned long int long _Accum" } */
+unsigned long long int _Accum *k280; /* { dg-error "" "unsigned long long int _Accum" } */
+_Complex _Accum *k283; /* { dg-error "" "_Complex _Accum" } */
+_Accum _Complex *k286; /* { dg-error "" "_Accum _Complex" } */
+unsigned _Accum *k289;
+signed _Accum *k292;
+
+void _Sat *s0;  /* { dg-error "" "void _Sat" } */
+char _Sat *s3;  /* { dg-error "" "char _Sat" } */
+short _Sat *s6; /* { dg-error "" "short _Sat" } */
+int _Sat *s9;   /* { dg-error "" "int _Sat" } */
+long _Sat *s12;   /* { dg-error "" "long _Sat" } */
+float _Sat *s15;   /* { dg-error "" "float _Sat" } */
+double _Sat *s18;   /* { dg-error "" "double _Sat" } */
+signed _Sat *s21;   /* { dg-error "" "signed _Sat" } */
+_Bool _Sat *s24;   /* { dg-error "" "_Bool _Sat" } */
+int _Sat *s27;   /* { dg-error "" "int _Sat" } */
+type _Sat *s30;   /* { dg-error "" "type _Sat" } */
+char signed _Sat *s33;  /* { dg-error "" "char signed _Sat" } */
+char unsigned _Sat *s36; /* { dg-error "" "char unsigned _Sat" } */
+short _Sat *s39;  /* { dg-error "" "short _Sat" } */
+short signed _Sat *s42;  /* { dg-error "" "short signed _Sat" } */
+short unsigned _Sat *s45;  /* { dg-error "" "short unsigned _Sat" } */
+_Sat short*s48;  /* { dg-error "" "_Sat short" } */
+_Sat short signed*s51;  /* { dg-error "" "_Sat short signed" } */
+_Sat short unsigned*s54;  /* { dg-error "" "_Sat short unsigned" } */
+_Sat long*s57;  /* { dg-error "" "_Sat long" } */
+_Sat long signed*s60;  /* { dg-error "" "_Sat long signed" } */
+_Sat long unsigned*s63;  /* { dg-error "" "_Sat long unsigned" } */
+_Sat signed long*s66;  /* { dg-error "" "_Sat signed long" } */
+_Sat signed short*s69;  /* { dg-error "" "_Sat signed short" } */
+int signed _Sat *s72;  /* { dg-error "" "int signed _Sat" } */
+int unsigned _Sat *s75;  /* { dg-error "" "int unsigned _Sat" } */
+long int _Sat *s78;  /* { dg-error "" "long int _Sat" } */
+long long _Sat *s81;  /* { dg-error "" "long long _Sat" } */
+long double _Sat *s84;  /* { dg-error "" "long double _Sat" } */
+long signed _Sat *s87;  /* { dg-error "" "long signed _Sat" } */
+long unsigned _Sat *s90;  /* { dg-error "" "long unsigned _Sat" } */
+double long _Sat *s93;  /* { dg-error "" "double long _Sat" } */
+signed char _Sat *s96;   /* { dg-error "" "signed char _Sat" } */
+signed short _Sat *s99;   /* { dg-error "" "signed short _Sat" } */
+signed int _Sat *s102;  /* { dg-error "" "signed int _Sat" } */
+signed long _Sat *s105; /* { dg-error "" "signed long _Sat" } */
+unsigned char _Sat *s108; /* { dg-error "" "unsigned char _Sat" } */
+unsigned short _Sat *s111; /* { dg-error "" "unsigned short _Sat" } */
+unsigned int _Sat *s114; /* { dg-error "" "unsigned int _Sat" } */
+unsigned long _Sat *s117; /* { dg-error "" "unsigned long _Sat" } */
+short int signed _Sat *s120; /* { dg-error "" "short int signed _Sat" } */
+short int unsigned _Sat *s123; /* { dg-error "" "short int unsigned _Sat" } */
+short signed int _Sat *s126; /* { dg-error "" "short signed int _Sat" } */
+short unsigned int _Sat *s129; /* { dg-error "" "short unsigned int _Sat" } */
+int short signed _Sat *s132; /* { dg-error "" "int short signed _Sat" } */
+int short unsigned _Sat *s135; /* { dg-error "" "int short unsigned _Sat" } */
+int long long _Sat *s138; /* { dg-error "" "int long long _Sat" } */
+int long signed _Sat *s141; /* { dg-error "" "int long signed _Sat" } */
+int long unsigned _Sat *s144; /* { dg-error "" "int long unsigned _Sat" } */
+int signed short _Sat *s147; /* { dg-error "" "int signed short _Sat" } */
+int signed long _Sat *s150; /* { dg-error "" "int signed long _Sat" } */
+int unsigned short _Sat *s153; /* { dg-error "" "int unsigned short _Sat" } */
+int unsigned long _Sat *s156; /* { dg-error "" "int unsigned long _Sat" } */
+long int long _Sat *s159; /* { dg-error "" "long int long _Sat" } */
+long int signed _Sat *s162; /* { dg-error "" "long int signed _Sat" } */
+long int unsigned _Sat *s165; /* { dg-error "" "long int unsigned _Sat" } */
+long long int _Sat *s168; /* { dg-error "" "long long int _Sat" } */
+long long signed _Sat *s171; /* { dg-error "" "long long signed _Sat" } */
+long long unsigned _Sat *s175; /* { dg-error "" "long long unsigned _Sat" } */
+long signed int _Sat *s178; /* { dg-error "" "long signed int _Sat" } */
+long unsigned int _Sat *s181; /* { dg-error "" "long unsigned int _Sat" } */
+long unsigned long _Sat *s184; /* { dg-error "" "long unsigned long _Sat" } */
+signed short int _Sat *s187; /* { dg-error "" "signed short int _Sat" } */
+signed int short _Sat *s190; /* { dg-error "" "signed int short _Sat" } */
+signed int long _Sat *s192; /* { dg-error "" "signed int long _Sat" } */
+signed long int _Sat *s195; /* { dg-error "" "signed long int _Sat" } */
+signed long long _Sat *s198; /* { dg-error "" "signed long long _Sat" } */
+unsigned short int _Sat *s201; /* { dg-error "" "unsigned short int _Sat" } */
+unsigned int short _Sat *s204; /* { dg-error "" "unsigned int short _Sat" } */
+unsigned int long _Sat *s207; /* { dg-error "" "unsigned int long _Sat" } */
+unsigned long int _Sat *s210; /* { dg-error "" "unsigned long int _Sat" } */
+unsigned long long _Sat *s213; /* { dg-error "" "unsigned long long _Sat" } */
+int long long signed _Sat *s216; /* { dg-error "" "int long long signed _Sat" } */
+int long long unsigned _Sat *s219; /* { dg-error "" "int long long unsigned _Sat" } */
+int long signed long _Sat *s222; /* { dg-error "" "int long signed long _Sat" } */
+int long unsigned long _Sat *s226; /* { dg-error "" "int long unsigned long _Sat" } */
+int signed long long _Sat *s229; /* { dg-error "" "int signed long long _Sat" } */
+int unsigned long long _Sat *s232; /* { dg-error "" "int unsigned long long _Sat" } */
+long int long signed _Sat *s235; /* { dg-error "" "long int long signed _Sat" } */
+long int long unsigned _Sat *s238; /* { dg-error "" "long int long unsigned _Sat" } */
+long int signed long _Sat *s241; /* { dg-error "" "long int signed long _Sat" } */
+long int unsigned long _Sat *s244; /* { dg-error "" "long int unsigned long _Sat" } */
+long long int signed _Sat *s247; /* { dg-error "" "long long int signed _Sat" } */
+long long int unsigned _Sat *s250; /* { dg-error "" "long long int unsigned _Sat" } */
+long long signed int _Sat *s253; /* { dg-error "" "long long signed int _Sat" } */
+long long unsigned int _Sat *s256; /* { dg-error "" "long long unsigned int _Sat" } */
+long signed int long _Sat *s259; /* { dg-error "" "long signed int long _Sat" } */
+long signed long int _Sat *s262; /* { dg-error "" "long signed long int _Sat" } */
+long unsigned int long _Sat *s265; /* { dg-error "" "long unsigned int long _Sat" } */
+long unsigned long int _Sat *s268; /* { dg-error "" "long unsigned long int _Sat" } */
+signed long long int _Sat *s271; /* { dg-error "" "signed long long int _Sat" } */
+unsigned int long long _Sat *s274; /* { dg-error "" "unsigned int long long _Sat" } */
+unsigned long int long _Sat *s277; /* { dg-error "" "unsigned long int long _Sat" } */
+unsigned long long int _Sat *s280; /* { dg-error "" "unsigned long long int _Sat" } */
+_Complex _Sat *s283; /* { dg-error "" "_Complex _Sat" } */
+_Sat _Complex *s286; /* { dg-error "" "_Sat _Complex" } */
+unsigned _Sat *s289; /* { dg-error "" "unsigned _Sat" } */
+signed _Sat *s292; /* { dg-error "" "signed _Sat" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/unary.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/unary.c
new file mode 100644
index 000000000..4e0954902
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/unary.c
@@ -0,0 +1,256 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* C99 6.5.3 Unary operators.
+
+   Check unary operators ++ -- + - !.  */
+
+extern void abort (void);
+
+#define INCDEC(TYPE,POSTFIX) \
+  { TYPE a = 0.0 ## POSTFIX; \
+    if (a++ != 0.0 ## POSTFIX) \
+      abort(); \
+    if (a != 1.0 ## POSTFIX) \
+      abort(); \
+    if (a-- != 1.0 ## POSTFIX) \
+      abort(); \
+    if (a != 0.0 ## POSTFIX) \
+      abort(); \
+    if (++a != 1.0 ## POSTFIX) \
+      abort(); \
+    if (a != 1.0 ## POSTFIX) \
+      abort(); \
+    if (--a != 0.0 ## POSTFIX) \
+      abort(); \
+    if (a != 0.0 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_INCDEC(TYPE,POSTFIX) \
+  { TYPE a = -0.5 ## POSTFIX; \
+    if (a++ != -0.5 ## POSTFIX) \
+      abort(); \
+    if (a != 0.5 ## POSTFIX) \
+      abort(); \
+    if (a-- != 0.5 ## POSTFIX) \
+      abort(); \
+    if (a != -0.5 ## POSTFIX) \
+      abort(); \
+    if (++a != 0.5 ## POSTFIX) \
+      abort(); \
+    if (a != 0.5 ## POSTFIX) \
+      abort(); \
+    if (--a != -0.5 ## POSTFIX) \
+      abort(); \
+    if (a != -0.5 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_SAT_INCDEC(TYPE,POSTFIX) \
+  { TYPE a = 0.9 ## POSTFIX; \
+    if (++a != 1.0 ## POSTFIX) \
+      abort(); \
+    a = -0.1 ## POSTFIX; \
+    if (--a != -0.5 ## POSTFIX - 0.5 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_SAT_UNS_INCDEC(TYPE,POSTFIX) \
+  { TYPE a = 0.9 ## POSTFIX; \
+    if (++a != 1.0 ## POSTFIX) \
+      abort(); \
+    a = 0.1 ## POSTFIX; \
+    if (--a != 0.0 ## POSTFIX) \
+      abort(); \
+  }
+
+#define PLUS(TYPE,POSTFIX) \
+  { TYPE a = 0.1 ## POSTFIX; \
+    if (+a != 0.1 ## POSTFIX) \
+      abort(); \
+  }
+
+#define NEG(TYPE,POSTFIX) \
+  { TYPE a = -0.1 ## POSTFIX; \
+    if (-a != 0.1 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_SAT_NEG(TYPE,POSTFIX) \
+  { TYPE a = -0.5 ## POSTFIX - 0.5 ## POSTFIX; \
+    if (-a != 1.0 ## POSTFIX) \
+      abort(); \
+  }
+
+#define UNS_NEG(TYPE,POSTFIX) \
+  { TYPE a = 0.0 ## POSTFIX; \
+    if (-a != 0.0 ## POSTFIX) \
+      abort(); \
+  }
+
+#define FRACT_SAT_UNS_NEG(TYPE,POSTFIX) \
+  { TYPE a = 0.5 ## POSTFIX; \
+    if (-a != 0.0 ## POSTFIX) \
+      abort(); \
+  }
+
+#define LOGNEG(TYPE,POSTFIX) \
+  { TYPE a = 0.0 ## POSTFIX; \
+    TYPE b = 0.1 ## POSTFIX; \
+    if (!a != 1) \
+      abort(); \
+    if (!b != 0) \
+      abort(); \
+  }
+
+int main ()
+{
+  FRACT_INCDEC(short _Fract, hr);
+  FRACT_INCDEC(_Fract, r);
+  FRACT_INCDEC(long _Fract, lr);
+  FRACT_INCDEC(long long _Fract, llr);
+  FRACT_INCDEC(_Sat short _Fract, hr);
+  FRACT_INCDEC(_Sat _Fract, r);
+  FRACT_INCDEC(_Sat long _Fract, lr);
+  FRACT_INCDEC(_Sat long long _Fract, llr);
+
+  INCDEC(short _Accum, hk);
+  INCDEC(_Accum, k);
+  INCDEC(long _Accum, lk);
+  INCDEC(long long _Accum, llk);
+  INCDEC(unsigned short _Accum, uhk);
+  INCDEC(unsigned _Accum, uk);
+  INCDEC(unsigned long _Accum, ulk);
+  INCDEC(unsigned long long _Accum, ullk);
+  INCDEC(_Sat short _Accum, hk);
+  INCDEC(_Sat _Accum, k);
+  INCDEC(_Sat long _Accum, lk);
+  INCDEC(_Sat long long _Accum, llk);
+  INCDEC(_Sat unsigned short _Accum, uhk);
+  INCDEC(_Sat unsigned _Accum, uk);
+  INCDEC(_Sat unsigned long _Accum, ulk);
+  INCDEC(_Sat unsigned long long _Accum, ullk);
+
+  FRACT_SAT_INCDEC(_Sat short _Fract, hr);
+  FRACT_SAT_INCDEC(_Sat _Fract, r);
+  FRACT_SAT_INCDEC(_Sat long _Fract, lr);
+  FRACT_SAT_INCDEC(_Sat long long _Fract, llr);
+
+  FRACT_SAT_UNS_INCDEC(_Sat unsigned short _Fract, uhr);
+  FRACT_SAT_UNS_INCDEC(_Sat unsigned _Fract, ur);
+  FRACT_SAT_UNS_INCDEC(_Sat unsigned long _Fract, ulr);
+  FRACT_SAT_UNS_INCDEC(_Sat unsigned long long _Fract, ullr);
+
+  PLUS(short _Fract, hr);
+  PLUS(_Fract, r);
+  PLUS(long _Fract, lr);
+  PLUS(long long _Fract, llr);
+  PLUS(unsigned short _Fract, uhr);
+  PLUS(unsigned _Fract, ur);
+  PLUS(unsigned long _Fract, ulr);
+  PLUS(unsigned long long _Fract, ullr);
+  PLUS(_Sat short _Fract, hr);
+  PLUS(_Sat _Fract, r);
+  PLUS(_Sat long _Fract, lr);
+  PLUS(_Sat long long _Fract, llr);
+  PLUS(_Sat unsigned short _Fract, uhr);
+  PLUS(_Sat unsigned _Fract, ur);
+  PLUS(_Sat unsigned long _Fract, ulr);
+  PLUS(_Sat unsigned long long _Fract, ullr);
+  PLUS(short _Accum, hk);
+  PLUS(_Accum, k);
+  PLUS(long _Accum, lk);
+  PLUS(long long _Accum, llk);
+  PLUS(unsigned short _Accum, uhk);
+  PLUS(unsigned _Accum, uk);
+  PLUS(unsigned long _Accum, ulk);
+  PLUS(unsigned long long _Accum, ullk);
+  PLUS(_Sat short _Accum, hk);
+  PLUS(_Sat _Accum, k);
+  PLUS(_Sat long _Accum, lk);
+  PLUS(_Sat long long _Accum, llk);
+  PLUS(_Sat unsigned short _Accum, uhk);
+  PLUS(_Sat unsigned _Accum, uk);
+  PLUS(_Sat unsigned long _Accum, ulk);
+  PLUS(_Sat unsigned long long _Accum, ullk);
+
+  NEG(short _Fract, hr);
+  NEG(_Fract, r);
+  NEG(long _Fract, lr);
+  NEG(long long _Fract, llr);
+  NEG(_Sat short _Fract, hr);
+  NEG(_Sat _Fract, r);
+  NEG(_Sat long _Fract, lr);
+  NEG(_Sat long long _Fract, llr);
+  NEG(short _Accum, hk);
+  NEG(_Accum, k);
+  NEG(long _Accum, lk);
+  NEG(long long _Accum, llk);
+  NEG(_Sat short _Accum, hk);
+  NEG(_Sat _Accum, k);
+  NEG(_Sat long _Accum, lk);
+  NEG(_Sat long long _Accum, llk);
+
+  FRACT_SAT_NEG(_Sat short _Fract, hr);
+  FRACT_SAT_NEG(_Sat _Fract, r);
+  FRACT_SAT_NEG(_Sat long _Fract, lr);
+  FRACT_SAT_NEG(_Sat long long _Fract, llr);
+
+  UNS_NEG(short _Fract, hr);
+  UNS_NEG(_Fract, r);
+  UNS_NEG(long _Fract, lr);
+  UNS_NEG(long long _Fract, llr);
+  UNS_NEG(_Sat short _Fract, hr);
+  UNS_NEG(_Sat _Fract, r);
+  UNS_NEG(_Sat long _Fract, lr);
+  UNS_NEG(_Sat long long _Fract, llr);
+  UNS_NEG(short _Accum, hk);
+  UNS_NEG(_Accum, k);
+  UNS_NEG(long _Accum, lk);
+  UNS_NEG(long long _Accum, llk);
+  UNS_NEG(_Sat short _Accum, hk);
+  UNS_NEG(_Sat _Accum, k);
+  UNS_NEG(_Sat long _Accum, lk);
+  UNS_NEG(_Sat long long _Accum, llk);
+
+  FRACT_SAT_UNS_NEG(_Sat unsigned short _Fract, uhr);
+  FRACT_SAT_UNS_NEG(_Sat unsigned _Fract, ur);
+  FRACT_SAT_UNS_NEG(_Sat unsigned long _Fract, ulr);
+  FRACT_SAT_UNS_NEG(_Sat unsigned long long _Fract, ullr);
+
+  LOGNEG(short _Fract, hr);
+  LOGNEG(_Fract, r);
+  LOGNEG(long _Fract, lr);
+  LOGNEG(long long _Fract, llr);
+  LOGNEG(unsigned short _Fract, uhr);
+  LOGNEG(unsigned _Fract, ur);
+  LOGNEG(unsigned long _Fract, ulr);
+  LOGNEG(unsigned long long _Fract, ullr);
+  LOGNEG(_Sat short _Fract, hr);
+  LOGNEG(_Sat _Fract, r);
+  LOGNEG(_Sat long _Fract, lr);
+  LOGNEG(_Sat long long _Fract, llr);
+  LOGNEG(_Sat unsigned short _Fract, uhr);
+  LOGNEG(_Sat unsigned _Fract, ur);
+  LOGNEG(_Sat unsigned long _Fract, ulr);
+  LOGNEG(_Sat unsigned long long _Fract, ullr);
+  LOGNEG(short _Accum, hk);
+  LOGNEG(_Accum, k);
+  LOGNEG(long _Accum, lk);
+  LOGNEG(long long _Accum, llk);
+  LOGNEG(unsigned short _Accum, uhk);
+  LOGNEG(unsigned _Accum, uk);
+  LOGNEG(unsigned long _Accum, ulk);
+  LOGNEG(unsigned long long _Accum, ullk);
+  LOGNEG(_Sat short _Accum, hk);
+  LOGNEG(_Sat _Accum, k);
+  LOGNEG(_Sat long _Accum, lk);
+  LOGNEG(_Sat long long _Accum, llk);
+  LOGNEG(_Sat unsigned short _Accum, uhk);
+  LOGNEG(_Sat unsigned _Accum, uk);
+  LOGNEG(_Sat unsigned long _Accum, ulk);
+  LOGNEG(_Sat unsigned long long _Accum, ullk);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/union-init.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/union-init.c
new file mode 100644
index 000000000..126cc9e72
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixed-point/union-init.c
@@ -0,0 +1,62 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+/* Cast to union is a GNU C extension.
+   Based on the test from ../dfp/.  */
+
+extern void abort (void);
+
+union u
+{
+  long _Fract lf;
+  double d;
+};
+
+union n
+{
+  double d;
+  _Fract f;
+};
+
+int main ()
+{
+  static union u u1 = { 0.1lr };
+  static union u u2 = { 0.2lr };
+  static union u u4 = { 0.0 };
+
+  static union n n1 = { 0.3r };
+  static union n n2 = { 3.25 };
+
+  long _Fract lf;
+  _Fract f;
+  double d;
+
+  if (u1.lf != 0.1lr)
+    abort ();
+
+  if (u2.lf != 0.2lr)
+    abort ();
+
+  /* cast fixed-point to union type.  */
+  lf = 0.4lr;
+  f = 0.5r;
+  d = 3.25;
+
+  u4 = (union u) lf;
+  if (u4.lf != 0.4lr)
+    abort ();
+
+  u4 = (union u) d;
+  if (u4.d != 3.25)
+    abort ();
+
+  n1 = (union n) f;
+  if (n1.f != 0.5r)
+    abort ();
+
+  n1 = (union n)d;
+  if (n1.d != 3.25)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fixuns-trunc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixuns-trunc-1.c
new file mode 100644
index 000000000..0d0942952
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fixuns-trunc-1.c
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+
+unsigned long foo(double d)
+{
+  return (unsigned long) d;
+}
+
+extern void abort(void);
+
+int main(void)
+{
+  double d;
+  unsigned long l;
+
+#ifdef __LP64__
+  d = 9223372036854775808.7;
+  l = 1LL << 63;
+
+  if (foo(d) != l)
+    abort();
+#endif
+
+  d = 122485.2;
+  l = 122485;
+
+  if (foo(d) != l)
+    abort();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-1.c
new file mode 100644
index 000000000..ddd7fd672
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-1.c
@@ -0,0 +1,15 @@
+/* Floating constants outside the range of their type should receive a
+   just a warning if the target supports infinities. Otherwise, a
+   pedwarn should be produced.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-ansi -pedantic-errors -Woverflow" } */
+/* { dg-skip-if "No Inf support" { spu-*-* } } */
+
+void
+f (void)
+{
+  float a = 1e+100000000f; /* { dg-warning "floating constant exceeds range of 'float'" "" } */
+  double b = 1e+100000000; /* { dg-warning "floating constant exceeds range of 'double'" } */
+  long double c = 1e+100000000l; /* { dg-warning "floating constant exceeds range of 'long double'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-2.c
new file mode 100644
index 000000000..d6c0b8a40
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-2.c
@@ -0,0 +1,14 @@
+/* Floating constants outside the range of their type should receive a
+   pedwarn, not a warning.  This includes INFINITY if the target does
+   not support infinities.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile { target vax-*-* pdp11-*-* } } */
+/* { dg-options "-ansi -pedantic-errors" } */
+
+void
+f (void)
+{
+  float a = __builtin_inff (); /* { dg-error "target format does not support infinity" } */
+  double b = __builtin_inf (); /* { dg-error "target format does not support infinity" } */
+  long double c = __builtin_infl (); /* { dg-error "target format does not support infinity" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-3.c
new file mode 100644
index 000000000..e018a1ebc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-3.c
@@ -0,0 +1,43 @@
+/* PR 23572 : warnings for out of range floating-point constants.  */
+/* { dg-compile } */
+/* { dg-options "-std=c99" } */
+/* { dg-skip-if "No Inf support" { spu-*-* } } */
+#include <math.h>
+
+#ifndef INFINITY
+#define INFINITY (__builtin_inff ())
+#endif
+
+void overflow(void)
+{
+  float f1 = 3.5E+38f;  /* { dg-warning "floating constant exceeds range" } */
+  float f2 = -3.5E+38f; /* { dg-warning "floating constant exceeds range" } */
+  float f3 = INFINITY;
+  float f4 = -INFINITY;
+
+  double d1 = 1.9E+308;  /* { dg-warning "floating constant exceeds range" } */
+  double d2 = -1.9E+308; /* { dg-warning "floating constant exceeds range" } */
+  double d3 = INFINITY;
+  double d4 = -INFINITY;
+}
+
+void underflow(void)
+{
+  float f11 = 3.3E-10000000000000000000f;  /* { dg-warning "floating constant truncated to zero" } */
+  float f22 = -3.3E-10000000000000000000f; /* { dg-warning "floating constant truncated to zero" } */
+  float f1 = 3.3E-46f;  /* { dg-warning "floating constant truncated to zero" } */
+  float f2 = -3.3E-46f; /* { dg-warning "floating constant truncated to zero" } */
+  float f3 = 0;
+  float f4 = -0;
+  float f5 = 0.0;
+  float f6 = -0.0;
+
+  double d11 = 3.3E-10000000000000000000;  /* { dg-warning "floating constant truncated to zero" } */
+  double d22 = -3.3E-10000000000000000000; /* { dg-warning "floating constant truncated to zero" } */
+  double d1 = 1.4E-325;  /* { dg-warning "floating constant truncated to zero" } */
+  double d2 = -1.4E-325; /* { dg-warning "floating constant truncated to zero" } */
+  double d3 = 0;
+  double d4 = -0;
+  double d5 = 0.0;
+  double d6 = -0.0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-4.c
new file mode 100644
index 000000000..fbb820f9b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-4.c
@@ -0,0 +1,43 @@
+/* PR 23572 : warnings for out of range floating-point constants.  */
+/* { dg-compile } */
+/* { dg-options "-Wno-overflow -std=c99" } */
+/* { dg-skip-if "No Inf support" { spu-*-* } } */
+#include <math.h>
+
+#ifndef INFINITY
+#define INFINITY (__builtin_inff ())
+#endif
+
+void overflow(void)
+{
+  float f1 = 3.5E+38f;  
+  float f2 = -3.5E+38f; 
+  float f3 = INFINITY;
+  float f4 = -INFINITY;
+
+  double d1 = 1.9E+308; 
+  double d2 = -1.9E+308;
+  double d3 = INFINITY;
+  double d4 = -INFINITY;
+}
+
+void underflow(void)
+{
+  float f11 = 3.3E-10000000000000000000f;
+  float f22 = -3.3E-10000000000000000000f;
+  float f1 = 3.3E-46f;  
+  float f2 = -3.3E-46f; 
+  float f3 = 0;
+  float f4 = -0;
+  float f5 = 0.0;
+  float f6 = -0.0;
+
+  double d11 = 3.3E-10000000000000000000;
+  double d22 = -3.3E-10000000000000000000;
+  double d1 = 1.4E-325; 
+  double d2 = -1.4E-325;
+  double d3 = 0;
+  double d4 = -0;
+  double d5 = 0.0;
+  double d6 = -0.0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-5.c
new file mode 100644
index 000000000..89f00796a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/float-range-5.c
@@ -0,0 +1,44 @@
+/* PR 23572 : warnings for out of range floating-point constants 
+   Test that they are NOT pedantic warnings.  */
+/* { dg-compile } */
+/* { dg-options "-pedantic-errors -std=c99" } */
+/* { dg-skip-if "No Inf support" { spu-*-* } } */
+#include <math.h>
+
+#ifndef INFINITY
+#define INFINITY (__builtin_inff ())
+#endif
+
+void overflow(void)
+{
+  float f1 = 3.5E+38f;  /* { dg-warning "floating constant exceeds range" } */
+  float f2 = -3.5E+38f; /* { dg-warning "floating constant exceeds range" } */
+  float f3 = INFINITY;
+  float f4 = -INFINITY;
+
+  double d1 = 1.9E+308;  /* { dg-warning "floating constant exceeds range" } */
+  double d2 = -1.9E+308; /* { dg-warning "floating constant exceeds range" } */
+  double d3 = INFINITY;
+  double d4 = -INFINITY;
+}
+
+void underflow(void)
+{
+  float f11 = 3.3E-10000000000000000000f;  /* { dg-warning "floating constant truncated to zero" } */
+  float f22 = -3.3E-10000000000000000000f; /* { dg-warning "floating constant truncated to zero" } */
+  float f1 = 3.3E-46f;  /* { dg-warning "floating constant truncated to zero" } */
+  float f2 = -3.3E-46f; /* { dg-warning "floating constant truncated to zero" } */
+  float f3 = 0;
+  float f4 = -0;
+  float f5 = 0.0;
+  float f6 = -0.0;
+
+  double d11 = 3.3E-10000000000000000000;  /* { dg-warning "floating constant truncated to zero" } */
+  double d22 = -3.3E-10000000000000000000; /* { dg-warning "floating constant truncated to zero" } */
+  double d1 = 1.4E-325;  /* { dg-warning "floating constant truncated to zero" } */
+  double d2 = -1.4E-325; /* { dg-warning "floating constant truncated to zero" } */
+  double d3 = 0;
+  double d4 = -0;
+  double d5 = 0.0;
+  double d6 = -0.0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fltconst-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fltconst-1.c
new file mode 100644
index 000000000..85e1d34a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fltconst-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+double a = 1.ld;	/* { dg-error "12:invalid suffix" } */
+double b = 1.fd;	/* { dg-error "12:invalid suffix" } */
+double c = 1.di;	/* { dg-error "12:invalid suffix" } */
+double d = 1.dj;	/* { dg-error "12:invalid suffix" } */
+double e = 1.id;	/* { dg-error "12:invalid suffix" } */
+double f = 1.jd;	/* { dg-error "12:invalid suffix" } */
+double g = 1.ddd;	/* { dg-error "12:invalid suffix" } */
+double h = 1.ldd;	/* { dg-error "12:invalid suffix" } */
+double i = 1.dld;	/* { dg-error "12:invalid suffix" } */
+double j = 1.ddl;	/* { dg-error "12:invalid suffix" } */
+double k = 1.fdd;	/* { dg-error "12:invalid suffix" } */
+double l = 1.dfd;	/* { dg-error "12:invalid suffix" } */
+double m = 1.ddf;	/* { dg-error "12:invalid suffix" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fltconst-pedantic-dfp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fltconst-pedantic-dfp.c
new file mode 100644
index 000000000..d0d1c4c52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fltconst-pedantic-dfp.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+double a = 1.dl;	/* { dg-warning "decimal float" } */
+double b = 1.df;	/* { dg-warning "decimal float" } */
+double c = 1.dd;	/* { dg-warning "decimal float" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fnegate-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fnegate-1.c
new file mode 100644
index 000000000..ad0f4e09f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fnegate-1.c
@@ -0,0 +1,113 @@
+/* Copyright (C) 2002 Free Software Foundation.
+  
+   Test floating point negation produces the expected results.
+  
+   Written by Roger Sayle, 21st May 2002.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern void abort ();
+
+
+double
+dneg (double x)
+{
+  return -x;
+}
+
+double
+dmult (double x)
+{
+  return -1.0 * x;
+}
+
+double
+ddiv (double x)
+{
+  return x / -1.0;
+}
+
+
+float
+fneg (float x)
+{
+  return -x;
+}
+
+float
+fmult (float x)
+{
+  return -1.0f * x;
+}
+
+float
+fdiv (float x)
+{
+  return x / -1.0f;
+}
+
+
+void
+ftest(float src, float dst)
+{
+  if (fneg (src) != dst)
+    abort ();
+
+  if (src != fneg (dst))
+    abort ();
+
+  if (fmult (src) != dst)
+    abort ();
+
+  if (src != fmult (dst))
+    abort ();
+
+  if (fdiv (src) != dst)
+    abort ();
+
+  if (src != fdiv(dst))
+    abort ();
+}
+
+void
+dtest(double src, double dst)
+{
+  if (dneg (src) != dst)
+    abort ();
+
+  if (src != dneg (dst))
+    abort ();
+
+  if (dmult (src) != dst)
+    abort ();
+
+  if (src != dmult (dst))
+    abort ();
+
+  if (ddiv (src) != dst)
+    abort ();
+
+  if (src != ddiv(dst))
+    abort ();
+}
+
+
+int
+main ()
+{
+  ftest (1.0f, -1.0f);
+  ftest (2.0f, -2.0f);
+  ftest (-3.0f, 3.0f);
+  ftest (0.0f, -0.0f);
+  ftest (-0.0f, 0.0f);
+
+  dtest (1.0, -1.0);
+  dtest (2.0, -2.0);
+  dtest (-3.0, 3.0);
+  dtest (0.0, -0.0);
+  dtest (-0.0, 0.0);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-1.c
new file mode 100644
index 000000000..2e69a2075
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fwrapv" } */
+#define ABS(x) (x > 0 ? x : -x)
+int f (int a, int b) {
+	if ((ABS(a) | b) != 0) return 1;
+	else return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-2.c
new file mode 100644
index 000000000..6291d7e53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-2.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+/* { dg-options "-O1 -fwrapv" } */
+#include <limits.h>
+void exit (int);
+void abort ();
+#define ABS(x) (x > 0 ? x : -x)
+int f (int a) {
+	if (ABS(a) >= 0) return 1;
+	else return 0;
+}
+
+int main (int argc, char *argv[]) {
+	if (f(INT_MIN))
+	  abort ();
+	else
+	  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-3.c
new file mode 100644
index 000000000..d151a8d7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-3.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple -fwrapv" } */
+#define ABS(x) (x > 0 ? x : -x)
+int f (int a) {
+	return ABS (ABS(a));
+}
+
+/* { dg-final { scan-tree-dump-times "ABS" 1 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-4.c
new file mode 100644
index 000000000..8bf02a808
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-abs-4.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple -fwrapv" } */
+extern float fabsf (float);
+extern float cabsf (_Complex float);
+
+int f (float a) {
+	return fabsf(a) < 0.0;
+}
+
+int g (_Complex float a) {
+	return cabsf (a) < 0.0;
+}
+
+/* { dg-final { scan-tree-dump-times "ABS" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-addr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-addr-1.c
new file mode 100644
index 000000000..7323ffdab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-addr-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+int bar(char p1, char p2)
+{
+  return &p1 == &p2;
+}
+
+/* { dg-final { scan-tree-dump "return 0;" "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-alloca-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-alloca-1.c
new file mode 100644
index 000000000..93f28cfa1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-alloca-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-cfg" } */
+
+void *alloca (__SIZE_TYPE__);
+void link_error ();
+
+int main (int argc, char *argv[]) {
+	char *foo;
+	if ((foo = alloca(argc)) == 0)
+	  link_error ();
+	return 0;
+}
+/* { dg-final { scan-tree-dump-times "link_error" 0 "cfg" } } */
+/* { dg-final { cleanup-tree-dump "cfg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-andxor-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-andxor-1.c
new file mode 100644
index 000000000..cc4657714
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-andxor-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return (a ^ b) & a;
+}
+
+int test2(int c, int d)
+{
+  return (c ^ d) & d;
+}
+
+int test3(int e, int f)
+{
+  return e & (e ^ f);
+}
+
+int test4(int g, int h)
+{
+  return g & (h ^ g);
+}
+
+/* { dg-final { scan-tree-dump-times "~b \& a" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~c \& d" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~f \& e" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~h \& g" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-1.c
new file mode 100644
index 000000000..f490b153b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-1.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-w -fdump-tree-original" } */
+
+char c1 __attribute__ ((aligned (1)));
+char c2 __attribute__ ((aligned (2)));
+char c4 __attribute__ ((aligned (4)));
+char c8 __attribute__ ((aligned (8))); 
+unsigned f1(void)
+{
+  return 3 & (__SIZE_TYPE__)&c1;
+}
+
+unsigned f2(void)
+{
+  return 3 & (__SIZE_TYPE__)&c2;
+}
+
+unsigned f3(void)
+{
+  return 3 & (__SIZE_TYPE__)&c4;
+}
+
+unsigned f4(void)
+{
+  return 3 & (__SIZE_TYPE__)&c8;
+}
+
+/* { dg-final { scan-tree-dump-times "\&c1 \& 3" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\&c2 \& 3" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\&c4 \& 3" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\&c8 \& 3" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 0" 2 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-2.c
new file mode 100644
index 000000000..de2e67449
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-2.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+struct {
+  char c1;
+  char c2;
+  char c3;
+  char c4;
+} s __attribute__ ((aligned (4)));
+
+unsigned f1 (void)
+{
+  return 3 & (__SIZE_TYPE__)&s.c1;
+}
+
+unsigned f2 (void)
+{
+  return 3 & (__SIZE_TYPE__)&s.c2;
+}
+
+unsigned f3 (void)
+{
+  return 3 & (__SIZE_TYPE__)&s.c3;
+}
+
+unsigned f4 (void)
+{
+  return 3 & (__SIZE_TYPE__)&s.c4;
+}
+
+unsigned f5 (void)
+{
+  return 4 & (__SIZE_TYPE__)&s.c1;
+}
+
+/* { dg-final { scan-tree-dump-times "\& 3" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\& 4" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 1" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 2" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 3" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-3.c
new file mode 100644
index 000000000..43d765bbf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-3.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+char c[4] __attribute__ ((aligned (4)));
+
+struct S {
+  char c1;
+  char c2;
+  char c3;
+  char c4;
+};
+
+int f1 (void)
+{
+  return 3 & (__SIZE_TYPE__)&c[1];
+}
+
+int f2 (void)
+{
+  return 3 & (__SIZE_TYPE__)&((struct S *)&c)->c2;
+}
+
+/* { dg-final { scan-tree-dump-times "\& 3" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 1" 2 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-4.c
new file mode 100644
index 000000000..acb0ce9af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-bitand-4.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+/* { dg-options "-fdump-tree-original -fno-common" { target hppa*-*-hpux* } } */
+
+typedef char char4[4] __attribute__ ((aligned (4)));
+char4 c4[4] __attribute__ ((aligned (16)));
+
+typedef char char16[16] __attribute__ ((aligned (16)));
+char16 c16[4] __attribute__ ((aligned (4)));
+
+int f1 (void)
+{
+  /* 12 */
+  return 15 & (__SIZE_TYPE__)&c4[3];
+}
+
+int f2 (int i)
+{
+  /* Indeterminate */
+  return 15 & (__SIZE_TYPE__)&c4[i];
+}
+
+int f3 (int i)
+{
+  /* 0 */
+  return 3 & (__SIZE_TYPE__)&c4[i];
+}
+
+int f4 (int i)
+{
+  /* Indeterminate */
+  return 7 & (__SIZE_TYPE__)&c16[i];
+}
+
+int f5 (int i)
+{
+  /* 0 */
+  return 3 & (__SIZE_TYPE__)&c16[i];
+}
+
+/* { dg-final { scan-tree-dump-times "return 12" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\& 15" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return 0" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "\& 7" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-1.c
new file mode 100644
index 000000000..8d53acd87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-1.c
@@ -0,0 +1,53 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return ~a == ~b;
+}
+
+int test2(int c, int d)
+{
+  return -c == -d;
+}
+
+int test3(int e)
+{
+  return -e == 5;
+}
+
+int test4(int f)
+{
+  return ~f == 5;
+}
+
+int test5(int g, int h)
+{
+  return ~g < ~h;
+}
+
+int test6(int i, int j)
+{
+  return ~i >= ~j;
+}
+
+int test7(int k)
+{
+  return ~k < 3;
+}
+
+int test8(int l)
+{
+  return ~l >= 2;
+}
+
+/* { dg-final { scan-tree-dump-times "b == a" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c == d" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e == -5" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "f == -6" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "h < g" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "j >= i" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "k >= -3" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "l < -2" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-2.c
new file mode 100644
index 000000000..6674c4dad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-2.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp" } */
+
+extern void abort (void);
+
+int a;
+
+int
+main(void)
+{
+  if (a * 1000 < 0)
+    abort ();
+  if (a * -43 > 0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Removing basic block" 2 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp\[1-2\]" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-3.c
new file mode 100644
index 000000000..d38a945ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-compare-3.c
@@ -0,0 +1,159 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-cfg" } */
+
+#include <limits.h>
+
+void this_comparison_is_false (void);
+void this_comparison_is_true (void);
+void this_comparison_is_not_decidable (void);
+
+void bla1eq (int var)
+{
+  if (var + 10 == INT_MIN + 9)
+    this_comparison_is_false ();
+}
+
+void bla2eq (int var)
+{
+  if (var + 10 == INT_MIN + 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla3eq (int var)
+{
+  if (var - 10 == INT_MAX - 9)
+    this_comparison_is_false ();
+}
+
+void bla4eq (int var)
+{
+  if (var - 10 == INT_MAX - 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla1ne (int var)
+{
+  if (var + 10 != INT_MIN + 9)
+    this_comparison_is_true ();
+}
+
+void bla2ne (int var)
+{
+  if (var + 10 != INT_MIN + 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla3ne (int var)
+{
+  if (var - 10 != INT_MAX - 9)
+    this_comparison_is_true ();
+}
+
+void bla4ne (int var)
+{
+  if (var - 10 != INT_MAX - 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla1lt (int var)
+{
+  if (var + 10 < INT_MIN + 10)
+    this_comparison_is_false ();
+}
+
+void bla2lt (int var)
+{
+  if (var + 10 < INT_MIN + 11)
+    this_comparison_is_not_decidable ();
+}
+
+void bla3lt (int var)
+{
+  if (var - 10 < INT_MAX - 9)
+    this_comparison_is_true ();
+}
+
+void bla4lt (int var)
+{
+  if (var - 10 < INT_MAX - 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla1le (int var)
+{
+  if (var + 10 <= INT_MIN + 9)
+    this_comparison_is_false ();
+}
+
+void bla2le (int var)
+{
+  if (var + 10 <= INT_MIN + 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla3le (int var)
+{
+  if (var - 10 <= INT_MAX - 10)
+    this_comparison_is_true ();
+}
+
+void bla4le (int var)
+{
+  if (var - 10 <= INT_MAX - 11)
+    this_comparison_is_not_decidable ();
+}
+
+void bla1gt (int var)
+{
+  if (var + 10 > INT_MIN + 9)
+    this_comparison_is_true ();
+}
+
+void bla2gt (int var)
+{
+  if (var + 10 > INT_MIN + 10)
+    this_comparison_is_not_decidable ();
+}
+
+void bla3gt (int var)
+{
+  if (var - 10 > INT_MAX - 10)
+    this_comparison_is_false ();
+}
+
+void bla4gt (int var)
+{
+  if (var - 10 > INT_MAX - 11)
+    this_comparison_is_not_decidable ();
+}
+
+void bla1ge (int var)
+{
+  if (var + 10 >= INT_MIN + 10)
+    this_comparison_is_true ();
+}
+
+void bla2ge (int var)
+{
+  if (var + 10 >= INT_MIN + 11)
+    this_comparison_is_not_decidable ();
+}
+
+void bla3ge (int var)
+{
+  if (var - 11 >= INT_MAX - 10)
+    this_comparison_is_false ();
+}
+
+void bla4ge (int var)
+{
+  if (var - 10 >= INT_MAX - 10)
+    this_comparison_is_not_decidable ();
+}
+
+/* { dg-final { scan-tree-dump-times "this_comparison_is_false" 0 "cfg" } } */
+/* { dg-final { scan-tree-dump-times "this_comparison_is_true" 6 "cfg" } } */
+/* { dg-final { scan-tree-dump-times "this_comparison_is_not_decidable" 12 "cfg" } } */
+/* { dg-final { scan-tree-dump-times "if " 12 "cfg" } } */
+
+/* { dg-final { cleanup-tree-dump "cfg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-cond-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-cond-1.c
new file mode 100644
index 000000000..b6e8a0ec3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-cond-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+_Bool test1(int a, int b)
+{
+  return a ? b : 0;
+}
+
+_Bool test2(int c, int d)
+{
+  return c ? d : 1;
+}
+
+_Bool test3(int e, int f)
+{
+  return e ? 0 : f;
+}
+
+_Bool test4(int g, int h)
+{
+  return g ? 1 : h;
+}
+
+/* { dg-final { scan-tree-dump-times "a != 0 \&\& b != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c == 0 \\|\\| d != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e == 0 \&\& f != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "g == 0 \\? h != 0 : 1" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "g != 0 \\? 1 : h != 0" 0 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-convnotconv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-convnotconv-1.c
new file mode 100644
index 000000000..fc07903c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-convnotconv-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a)
+{
+  return ~(unsigned int)a;
+}
+
+unsigned int test2(unsigned int b)
+{
+  return ~(int)b;
+}
+
+/* { dg-final { scan-tree-dump-times "~a" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~b" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-convround-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-convround-1.c
new file mode 100644
index 000000000..86612aa81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-convround-1.c
@@ -0,0 +1,30 @@
+/* PR middle-end/28473.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+extern double round(double);
+extern double floor(double);
+extern double ceil(double);
+
+unsigned long long test1(double x)
+{
+  return (unsigned long long) round(x);
+}
+
+unsigned long long test2(double x)
+{
+  return (unsigned long long) floor(x);
+}
+unsigned long long test3(double x)
+{
+  return (unsigned long long) ceil(x);
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_lround" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_llround" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_lfloor" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_llfloor" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_lceil" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "__builtin_llceil" 0 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-div-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-div-1.c
new file mode 100644
index 000000000..533908c30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-div-1.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-funsafe-math-optimizations -fdump-tree-gimple" } */
+
+float f(float x)
+{
+  return x/2 + x/3;
+}
+
+float g(float x)
+{
+  return 2/x + 3/x;
+}
+
+float h(float x)
+{
+  return x/2 - x/3;
+}
+
+float i(float x)
+{
+  return 2/x - 3/x;
+}
+
+/* f and h should be turned into multiplications,
+   the divisions in g and i should be grouped together.  */
+
+/* { dg-final { scan-tree-dump-times " \\* " 2 "gimple" } } */
+/* { dg-final { scan-tree-dump-times " / " 2 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-div-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-div-2.c
new file mode 100644
index 000000000..bfd07d1c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-div-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-ffinite-math-only -fdump-tree-gimple" } */
+
+double f(double x)
+{
+  return x / x;
+}
+
+/* Division should be turned into 1.0.  */
+
+/* { dg-final { scan-tree-dump-not " / " "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqand-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqand-1.c
new file mode 100644
index 000000000..6ed5b6db0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqand-1.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/13827 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+unsigned foo (unsigned a, unsigned b)
+{
+  return (a & 0xff00) != (b & 0xff00);
+}
+
+unsigned bar (unsigned c, unsigned d)
+{
+  return (c & 0xff00) == (d & 0xff00);
+}
+
+/* { dg-final { scan-tree-dump-times "a \\^ b" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c \\^ d" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandnot-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandnot-1.c
new file mode 100644
index 000000000..5ed65e893
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandnot-1.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+int test1(int a)
+{
+  return !(a & 4);
+}
+
+int test2(int b)
+{
+  return (b & 4) == 0;
+}
+
+int test3(int c)
+{
+  return ((c & 4) ^ 4) != 0;
+}
+
+int test4(int d)
+{
+  return ((d ^ 4) & 4) != 0;
+}
+
+int test5(int e)
+{
+  return (~e & 4) != 0;
+}
+
+/* { dg-final { scan-tree-dump-times "\\(a \& 4\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(b \& 4\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(c \& 4\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(d \& 4\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(e \& 4\\) == 0" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-1.c
new file mode 100644
index 000000000..055f398af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-1.c
@@ -0,0 +1,56 @@
+/* PR middle-end/21137  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+extern void foo();
+
+void test1(int a)
+{
+  if ((a >> 3) & 1)
+    foo ();
+}
+
+void test2(int b)
+{
+  if ((b >> 3) & 4)
+    foo ();
+}
+
+int test3(int c)
+{
+  return (c >> 3) & 1;
+}
+
+int test4(int d)
+{
+  return (d >> 3) & 4;
+}
+
+#if __INT_MAX__ == 32767
+#define INT_BITS 16
+#elif __INT_MAX__ == 2147483647
+#define INT_BITS 32
+#elif __INT_MAX__ == 9223372036854775807
+#define INT_BITS 64
+#else
+#error Please add support for your target here.
+#endif
+
+void test5(int e)
+{
+  if ((e >> (INT_BITS - 1)) & 64)
+    foo();
+}
+
+void test6(unsigned int f)
+{
+  if ((f >> (INT_BITS - 1)) & 64)
+    foo();
+}
+
+/* { dg-final { scan-tree-dump-times "\\(a \& 8\\) != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(b \& 32\\) != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c >> 3 \& 1" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "d >> 3 \& 4" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e < 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "if \\(0\\)" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-2.c
new file mode 100644
index 000000000..14ffb852d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-2.c
@@ -0,0 +1,22 @@
+/* PR middle-end/14752 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+void bar (void);
+
+void foo (unsigned int a)
+{
+  if ((a >> 2) & 1)
+    bar ();
+}
+
+void baz (unsigned int b)
+{
+  if ((~b >> 2) & 1)
+    bar ();
+}
+
+/* { dg-final { scan-tree-dump-times "\\(a \& 4\\) != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(b \& 4\\) == 0" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-3.c
new file mode 100644
index 000000000..5ed744ab5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqandshift-3.c
@@ -0,0 +1,29 @@
+/* PR middle-end/29726 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+void foo (void);
+#if(__SIZEOF_INT__ >= 4) 
+int test1 (int a)
+#else
+int test1 (long a)
+#endif
+
+{
+  if ((a >> 3) & 134217728)
+    foo ();
+}
+
+#if(__SIZEOF_INT__ >= 4) 
+int test2 (unsigned int b)
+#else
+int test2 (unsigned long b)
+#endif
+{
+  if ((b >> 3) & 134217728)
+    foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "\\(a \& 1073741824\\) != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(b \& 1073741824\\) != 0" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqcmplx-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqcmplx-1.c
new file mode 100644
index 000000000..32f4396ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqcmplx-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int foo(float x, float y)
+{
+  return (_Complex float)x == (_Complex float)y;
+}
+
+/* { dg-final { scan-tree-dump-times "x == y" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-1.c
new file mode 100644
index 000000000..d220e42bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return (a ^ b) == 0;
+}
+
+int test2(int c, int d)
+{
+  return (c ^ d) != 0;
+}
+
+unsigned int test3(unsigned int e, unsigned int f)
+{
+  return (e ^ f) == 0;
+}
+
+unsigned int test4(unsigned int g, unsigned int h)
+{
+  return (g ^ h) != 0;
+}
+
+/* { dg-final { scan-tree-dump-times "a == b" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c != d" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e == f" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "g != h" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-2.c
new file mode 100644
index 000000000..ee5ec9fa5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-2.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return (a ^ b) == a;
+}
+
+int test2(int c, int d)
+{
+  return (c ^ d) != c;
+}
+
+int test3(int e, int f)
+{
+  return (e ^ f) == f;
+}
+
+int test4(int g, int h)
+{
+  return (g ^ h) != h;
+}
+
+/* { dg-final { scan-tree-dump-times "b == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "d != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "g != 0" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-3.c
new file mode 100644
index 000000000..a087375ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-3.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return (a ^ 2) == 2;
+}
+
+int test2(int c, int d)
+{
+  return (c ^ 4) != 4;
+}
+
+int test3(int e, int f)
+{
+  return (e ^ 2) == 6;
+}
+
+int test4(int g, int h)
+{
+  return (g ^ 6) != 4;
+}
+
+/* { dg-final { scan-tree-dump-times "a == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "c != 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e == 4" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "g != 2" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-4.c
new file mode 100644
index 000000000..bdf31bc88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-eqxor-4.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a)
+{
+  return (a ^ 6) == 2;
+}
+
+int test2(int b, int c, int d)
+{
+  return (b ^ d) == (c ^ d);
+}
+
+int test3(int e, int f)
+{
+  return (e ^ 6) == (f ^ 4);
+}
+
+/* { dg-final { scan-tree-dump-times "a == 4" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "b == c" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "e \\^ 2" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-even-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-even-1.c
new file mode 100644
index 000000000..8e6539c92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-even-1.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+int test1(int a)
+{
+  return !(a & 1);
+}
+
+int test2(int b)
+{
+  return (b & 1) == 0;
+}
+
+int test3(int c)
+{
+  return (c & 1) ^ 1;
+}
+
+int test4(int d)
+{
+  return (d ^ 1) & 1;
+}
+
+int test5(int e)
+{
+  return ~e & 1;
+}
+
+/* { dg-final { scan-tree-dump-times "\\(a \& 1\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(b \& 1\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(c \& 1\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(d \& 1\\) == 0" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(e \& 1\\) == 0" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-mod-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-mod-1.c
new file mode 100644
index 000000000..bd4322e2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-mod-1.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target int32plus } */
+/* { dg-options "-fdump-tree-gimple -fstrict-overflow" } */
+
+#define ABS(x) (x > 0 ? x : -x)
+
+unsigned int f (unsigned int a) {
+	/* (unsigned)-8 is not a power of 2.  */
+	return a % -8;
+}
+
+int g (int b) {
+	return ABS (b) % -8;
+}
+
+int h (int c) {
+	return ABS (c) % 8;
+}
+
+unsigned int k (unsigned int d) {
+	return d % 8;
+}
+
+/* { dg-final { scan-tree-dump "a % (4294967288|0x0fffffff8)" "gimple" } } */
+/* { dg-final { scan-tree-dump-times " & 7" 3 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-mulconj-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-mulconj-1.c
new file mode 100644
index 000000000..0e04653e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-mulconj-1.c
@@ -0,0 +1,16 @@
+/* PR tree-optimization/23452 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -fdump-tree-gimple" } */
+
+_Complex double foo(_Complex double z)
+{
+  return z * ~z;
+}
+
+_Complex int bar(_Complex int z)
+{
+  return z * ~z;
+}
+
+/* { dg-final { scan-tree-dump-times "CONJ_EXPR" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-nonneg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-nonneg-1.c
new file mode 100644
index 000000000..03dae358b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-nonneg-1.c
@@ -0,0 +1,10 @@
+/* PR middle-end/27488 */
+/* { dg-do compile } */
+
+extern double fabs(double x);
+extern double sinh(double x);
+
+void foo()
+{
+  fabs(sinh(0..));  /* { dg-error "decimal points" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-overflow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-overflow-1.c
new file mode 100644
index 000000000..bd4d25a73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-overflow-1.c
@@ -0,0 +1,23 @@
+/* { dg-compile } */
+/* { dg-skip-if "consts are shorts, not longs" { "m32c-*-*" "avr-*-*" } { "*" } { "" } } */
+/* { dg-skip-if "No Inf support" { spu-*-* } } */
+/* { dg-options "-O -ftrapping-math" } */
+
+/* There should be exactly 2 +Inf in the assembly file.  */
+
+float f1 =  __FLT_MAX__ + __FLT_MAX__;
+
+float foo1(void)
+{
+  return  __FLT_MAX__ + __FLT_MAX__;
+}
+
+float f2 = 1.0f/0.0f;
+
+float foo2(void)
+{
+  return 1.0f/0.0f;
+}
+
+/* { dg-final { scan-assembler-times "2139095040" 2 { target { ! mmix-*-* } } } } */
+/* { dg-final { scan-assembler-times "#7f800000" 2 { target mmix-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-plusmult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-plusmult.c
new file mode 100644
index 000000000..d584b9588
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-plusmult.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+int test1 (int a)
+{
+  return 2*a + 2*a;
+}
+
+int test2 (int a)
+{
+  return (a + a)*2;
+}
+
+/* { dg-final { scan-tree-dump-times "<a> \\\* 4" 2 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-plusnot-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-plusnot-1.c
new file mode 100644
index 000000000..81ddf46d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-plusnot-1.c
@@ -0,0 +1,30 @@
+/* PR middle-end/30322 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a)
+{
+  return a + ~a;
+}
+
+int test2(int b)
+{
+  return ~b + b;
+}
+
+unsigned int test3(unsigned int c)
+{
+  return c + ~c;
+}
+
+unsigned int test4(unsigned int d)
+{
+  return ~d + d;
+}
+
+/* { dg-final { scan-tree-dump-times "\\+ a" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\+ b" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\+ c" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\+ d" 0 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-reassoc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-reassoc-1.c
new file mode 100644
index 000000000..88d5dd89c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-reassoc-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math -fdump-tree-original" } */
+
+double foo (double x)
+{
+  return (x + 0.5 - x - 0.5);
+}
+
+/* { dg-final { scan-tree-dump "return 0.0;" "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-rotate-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-rotate-1.c
new file mode 100644
index 000000000..c04447fb3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-rotate-1.c
@@ -0,0 +1,74 @@
+/* PR middle-end/29749 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+#if __SCHAR_MAX__ == 127
+
+unsigned char
+e1 (unsigned char a)
+{
+  return a >> 5 | a << 3;
+}
+
+unsigned char
+e2 (unsigned char a)
+{
+  return (a & 0xe0) >> 5 | (a & 0x1f) << 3;
+}
+
+unsigned char
+e3 (unsigned char a)
+{
+  return ((a >> 5) & 0x07) | ((a << 3) & 0xf8);
+}
+
+#endif
+
+#if __SHRT_MAX__ == 32767
+
+unsigned short
+f1 (unsigned short a)
+{
+  return a >> 8 | a << 8;
+}
+
+unsigned short
+f2 (unsigned short a)
+{
+  return (a & 0xff00) >> 8 | (a & 0x00ff) << 8;
+}
+
+unsigned short
+f3 (unsigned short a)
+{
+  return ((a >> 8) & 0x00ff) | ((a << 8) & 0xff00);
+}
+
+#endif
+
+#if __INT_MAX__ == 2147483647
+
+unsigned int
+g1 (unsigned int a)
+{
+  return a >> 24 | a << 8;
+}
+
+unsigned int
+g2 (unsigned int a)
+{
+  return (a & 0xff000000) >> 24 | (a & 0x00ffffff) << 8;
+}
+
+unsigned int
+g3 (unsigned int a)
+{
+  return ((a >> 24) & 0x000000ff) | ((a << 8) & 0xffffff00U);
+}
+
+#endif
+
+int i;
+
+/* { dg-final { scan-tree-dump-times "&" 0 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-sub.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-sub.c
new file mode 100644
index 000000000..28a8dd51f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-sub.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-ffinite-math-only -fdump-tree-gimple" } */
+
+float f(float x)
+{
+  return x - x;
+}
+
+/* Substraction should be turned into 0.  */
+
+/* { dg-final { scan-tree-dump-not " - " "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xor-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xor-1.c
new file mode 100644
index 000000000..52b1ac467
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xor-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int f (int a, int b) {
+  return ~a ^ ~b;
+}
+
+unsigned int g (unsigned int a, unsigned int b) {
+  return ~a ^ ~b;
+}
+/* { dg-final { scan-tree-dump-times "a \\^ b" 2 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xor-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xor-2.c
new file mode 100644
index 000000000..35337c9c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xor-2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+int f (int a, int b) {
+	return ~(a ^ -(b + 1));
+}
+
+int g (int a, int b) {
+	return b ^ a;
+}
+
+unsigned int h (unsigned int a, unsigned int b) {
+	return ~(-(b + 1) ^ a);
+}
+
+/* { dg-final { scan-tree-dump-times "b \\^ a" 3 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xorand-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xorand-1.c
new file mode 100644
index 000000000..8d4265417
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xorand-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return (a & b) ^ a;
+}
+
+int test2(int c, int d)
+{
+  return (c & d) ^ d;
+}
+
+int test3(int e, int f)
+{
+  return e ^ (e & f);
+}
+
+int test4(int g, int h)
+{
+  return g ^ (h & g);
+}
+
+/* { dg-final { scan-tree-dump-times "~b \& a" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~c \& d" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~f \& e" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "~h \& g" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xornot-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xornot-1.c
new file mode 100644
index 000000000..c92095d08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fold-xornot-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int foo(int x)
+{
+  return ~(x ^ 4);
+}
+
+int bar(int y)
+{
+  return ~y ^ 4;
+}
+
+/* { dg-final { scan-tree-dump-times "x \\^ -5" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "y \\^ -5" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/for-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/for-1.c
new file mode 100644
index 000000000..3df943976
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/for-1.c
@@ -0,0 +1,7 @@
+/* PR c/23439 */
+/* Origin: Serge Belyshev <belyshev@depni.sinp.msu.ru> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+# 0 "for-1.c"
+void foo() { for  /* { dg-error "at end of input" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/array-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/array-1.c
new file mode 100644
index 000000000..14db56e03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/array-1.c
@@ -0,0 +1,41 @@
+/* Test for format checking of constant arrays.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat=2" } */
+
+#include "format.h"
+
+const char a1[] = "foo";
+const char a2[] = "foo%d";
+const char b1[3] = "foo";
+const char b2[1] = "1";
+static const char c1[] = "foo";
+static const char c2[] = "foo%d";
+char d[] = "foo";
+volatile const char e[] = "foo";
+
+void
+foo (int i, long l)
+{
+  const char p1[] = "bar";
+  const char p2[] = "bar%d";
+  static const char q1[] = "bar";
+  static const char q2[] = "bar%d";
+  printf (a1);
+  printf (a2, i);
+  printf (a2, l); /* { dg-warning "format" "wrong type with array" } */
+  printf (b1); /* { dg-warning "unterminated" "unterminated array" } */
+  printf (b2); /* { dg-warning "unterminated" "unterminated array" } */
+  printf (c1);
+  printf (c2, i);
+  printf (c2, l); /* { dg-warning "format" "wrong type with array" } */
+  printf (p1);
+  printf (p2, i);
+  printf (p2, l); /* { dg-warning "format" "wrong type with array" } */
+  printf (q1);
+  printf (q2, i);
+  printf (q2, l); /* { dg-warning "format" "wrong type with array" } */
+  /* Volatile or non-constant arrays must not be checked.  */
+  printf (d); /* { dg-warning "not a string literal" "non-const" } */
+  printf ((const char *)e); /* { dg-warning "not a string literal" "volatile" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-1.c
new file mode 100644
index 000000000..22173df30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-1.c
@@ -0,0 +1,80 @@
+/* Test for asm_fprintf formats.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+/* Magic identifier must be set before the attribute is used.  */
+typedef long long __gcc_host_wide_int__;
+
+extern int asm_fprintf (const char *, ...) __attribute__ ((__format__ (__asm_fprintf__, 1, 2))) __attribute__ ((__nonnull__));
+
+void
+foo (int i, int i1, int i2, unsigned int u, double d, char *s, void *p,
+     int *n, short int *hn, long int l, unsigned long int ul,
+     long int *ln, long double ld, wint_t lc, wchar_t *ls, llong ll,
+     ullong ull, unsigned int *un, const int *cn, signed char *ss,
+     unsigned char *us, const signed char *css, unsigned int u1,
+     unsigned int u2)
+{
+  /* Acceptable C90 specifiers, flags and modifiers.  */
+  asm_fprintf ("%%");
+  asm_fprintf ("%d%i%o%u%x%X%c%s%%", i, i, u, u, u, u, i, s);
+  asm_fprintf ("%ld%li%lo%lu%lx%lX", l, l, ul, ul, ul, ul);
+  asm_fprintf ("%lld%lli%llo%llu%llx%llX", ll, ll, ull, ull, ull, ull);
+  asm_fprintf ("%-d%-i%-o%-u%-x%-X%-c%-s", i, i, u, u, u, u, i, s);
+  asm_fprintf ("% d% i\n", i, i);
+  asm_fprintf ("%#o%#x%#X", u, u, u);
+  asm_fprintf ("%08d%08i%08o%08u%08x%08X", i, i, u, u, u, u);
+  asm_fprintf ("%d\n", i);
+  asm_fprintf ("%+d\n", i);
+  asm_fprintf ("%3d\n", i);
+  asm_fprintf ("%-3d\n", i);
+  asm_fprintf ("%.7d\n", i);
+  asm_fprintf ("%+9.4d\n", i);
+  asm_fprintf ("%.3ld\n", l);
+  asm_fprintf ("%d %lu\n", i, ul);
+
+  /* Extensions provided in asm_fprintf.  */
+  asm_fprintf ("%O%R%I%L%U%@");
+  asm_fprintf ("%r", i);
+  asm_fprintf ("%wd%wi%wo%wu%wx%wX", ll, ll, ull, ull, ull, ull);
+
+  /* Standard specifiers not accepted in asm_fprintf.  */
+  asm_fprintf ("%f\n", d); /* { dg-warning "format" "float" } */
+  asm_fprintf ("%e\n", d); /* { dg-warning "format" "float" } */
+  asm_fprintf ("%E\n", d); /* { dg-warning "format" "float" } */
+  asm_fprintf ("%g\n", d); /* { dg-warning "format" "float" } */
+  asm_fprintf ("%G\n", d); /* { dg-warning "format" "float" } */
+  asm_fprintf ("%p\n", p); /* { dg-warning "format" "pointer" } */
+  asm_fprintf ("%n\n", n); /* { dg-warning "format" "counter" } */
+  asm_fprintf ("%hd\n", i); /* { dg-warning "format" "conversion" } */
+
+  /* Various tests of bad argument types.  */
+  asm_fprintf ("%d", l); /* { dg-warning "format" "bad argument types" } */
+  asm_fprintf ("%wd", l); /* { dg-warning "format" "bad argument types" } */
+  asm_fprintf ("%d", ll); /* { dg-warning "format" "bad argument types" } */
+  asm_fprintf ("%*d\n", i1, i); /* { dg-warning "format" "bad * argument types" } */
+  asm_fprintf ("%.*d\n", i2, i); /* { dg-warning "format" "bad * argument types" } */
+  asm_fprintf ("%*.*ld\n", i1, i2, l); /* { dg-warning "format" "bad * argument types" } */
+  asm_fprintf ("%ld", i); /* { dg-warning "format" "bad argument types" } */
+  asm_fprintf ("%s", n); /* { dg-warning "format" "bad argument types" } */
+
+  /* Wrong number of arguments.  */
+  asm_fprintf ("%d%d", i); /* { dg-warning "arguments" "wrong number of args" } */
+  asm_fprintf ("%d", i, i); /* { dg-warning "arguments" "wrong number of args" } */
+  /* Miscellaneous bogus constructions.  */
+  asm_fprintf (""); /* { dg-warning "zero-length" "warning for empty format" } */
+  asm_fprintf ("\0"); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  asm_fprintf ("%d\0", i); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  asm_fprintf ("%d\0%d", i, i); /* { dg-warning "embedded|too many" "warning for embedded NUL" } */
+  asm_fprintf (NULL); /* { dg-warning "null" "null format string warning" } */
+  asm_fprintf ("%"); /* { dg-warning "trailing" "trailing % warning" } */
+  asm_fprintf ("%++d", i); /* { dg-warning "repeated" "repeated flag warning" } */
+  asm_fprintf ((const char *)L"foo"); /* { dg-warning "wide" "wide string" } */
+  asm_fprintf ("%s", (char *)0); /* { dg-warning "null" "%s with NULL" } */
+
+  /* Make sure we still get warnings for regular printf.  */
+  printf ("%d\n", ll); /* { dg-warning "format" "bad argument types" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-2.c
new file mode 100644
index 000000000..0cdd5abc7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-2.c
@@ -0,0 +1,9 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", not used at all, asm_fprintf format.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+void bar (const char *, ...) __attribute__ ((__format__ (__asm_fprintf__, 1, 2))); /* { dg-error "'__gcc_host_wide_int__' is not defined as a type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-3.c
new file mode 100644
index 000000000..c4cd39297
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-3.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", not defined, asm_fprintf format.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+void foo (int __gcc_host_wide_int__);
+void bar (const char *, ...) __attribute__ ((__format__ (__asm_fprintf__, 1, 2))); /* { dg-error "'__gcc_host_wide_int__' is not defined as a type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-4.c
new file mode 100644
index 000000000..111d1f275
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-4.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", not a type, asm_fprintf.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+int __gcc_host_wide_int__;
+void bar (const char *, ...) __attribute__ ((__format__ (__asm_fprintf__, 1, 2))); /* { dg-error "'__gcc_host_wide_int__' is not defined as a type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-5.c
new file mode 100644
index 000000000..bb0e41c6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/asm_fprintf-5.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", bad type, asm_fprintf format.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+typedef int __gcc_host_wide_int__;
+void bar (const char *, ...) __attribute__ ((__format__ (__asm_fprintf__, 1, 2))); /* { dg-error "'__gcc_host_wide_int__' is not defined as 'long' or 'long long'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-1.c
new file mode 100644
index 000000000..8b2f5b7a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-1.c
@@ -0,0 +1,10 @@
+/* Test for strftime format attributes: can't have first_arg_num != 0.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+extern void foo0 (const char *) __attribute__((__format__(gnu_attr___strftime__, 1, 0)));
+extern void foo1 (const char *, ...) __attribute__((__format__(gnu_attr___strftime__, 1, 2))); /* { dg-error "cannot format" "strftime first_arg_num != 0" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-2.c
new file mode 100644
index 000000000..f560ed06b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-2.c
@@ -0,0 +1,68 @@
+/* Test for format attributes: test use of __attribute__.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+extern void tformatprintf (const char *, ...) __attribute__((format(gnu_attr_printf, 1, 2)));
+extern void tformat__printf__ (const char *, ...) __attribute__((format(gnu_attr___printf__, 1, 2)));
+extern void tformatscanf (const char *, ...) __attribute__((format(gnu_attr_scanf, 1, 2)));
+extern void tformat__scanf__ (const char *, ...) __attribute__((format(gnu_attr___scanf__, 1, 2)));
+extern void tformatstrftime (const char *) __attribute__((format(gnu_attr_strftime, 1, 0)));
+extern void tformat__strftime__ (const char *) __attribute__((format(gnu_attr___strftime__, 1, 0)));
+extern void tformatstrfmon (const char *, ...) __attribute__((format(strfmon, 1, 2)));
+extern void tformat__strfmon__ (const char *, ...) __attribute__((format(__strfmon__, 1, 2)));
+extern void t__format__printf (const char *, ...) __attribute__((__format__(gnu_attr_printf, 1, 2)));
+extern void t__format____printf__ (const char *, ...) __attribute__((__format__(gnu_attr___printf__, 1, 2)));
+extern void t__format__scanf (const char *, ...) __attribute__((__format__(gnu_attr_scanf, 1, 2)));
+extern void t__format____scanf__ (const char *, ...) __attribute__((__format__(gnu_attr___scanf__, 1, 2)));
+extern void t__format__strftime (const char *) __attribute__((__format__(gnu_attr_strftime, 1, 0)));
+extern void t__format____strftime__ (const char *) __attribute__((__format__(gnu_attr___strftime__, 1, 0)));
+extern void t__format__strfmon (const char *, ...) __attribute__((__format__(strfmon, 1, 2)));
+extern void t__format____strfmon__ (const char *, ...) __attribute__((__format__(__strfmon__, 1, 2)));
+
+extern char *tformat_arg (const char *) __attribute__((format_arg(1)));
+extern char *t__format_arg__ (const char *) __attribute__((__format_arg__(1)));
+
+void
+foo (int i, int *ip, double d)
+{
+  tformatprintf ("%d", i);
+  tformatprintf ("%"); /* { dg-warning "format" "attribute format printf" } */
+  tformat__printf__ ("%d", i);
+  tformat__printf__ ("%"); /* { dg-warning "format" "attribute format __printf__" } */
+  tformatscanf ("%d", ip);
+  tformatscanf ("%"); /* { dg-warning "format" "attribute format scanf" } */
+  tformat__scanf__ ("%d", ip);
+  tformat__scanf__ ("%"); /* { dg-warning "format" "attribute format __scanf__" } */
+  tformatstrftime ("%a");
+  tformatstrftime ("%"); /* { dg-warning "format" "attribute format strftime" } */
+  tformat__strftime__ ("%a");
+  tformat__strftime__ ("%"); /* { dg-warning "format" "attribute format __strftime__" } */
+  tformatstrfmon ("%n", d);
+  tformatstrfmon ("%"); /* { dg-warning "format" "attribute format strfmon" } */
+  tformat__strfmon__ ("%n", d);
+  tformat__strfmon__ ("%"); /* { dg-warning "format" "attribute format __strfmon__" } */
+  t__format__printf ("%d", i);
+  t__format__printf ("%"); /* { dg-warning "format" "attribute __format__ printf" } */
+  t__format____printf__ ("%d", i);
+  t__format____printf__ ("%"); /* { dg-warning "format" "attribute __format__ __printf__" } */
+  t__format__scanf ("%d", ip);
+  t__format__scanf ("%"); /* { dg-warning "format" "attribute __format__ scanf" } */
+  t__format____scanf__ ("%d", ip);
+  t__format____scanf__ ("%"); /* { dg-warning "format" "attribute __format__ __scanf__" } */
+  t__format__strftime ("%a");
+  t__format__strftime ("%"); /* { dg-warning "format" "attribute __format__ strftime" } */
+  t__format____strftime__ ("%a");
+  t__format____strftime__ ("%"); /* { dg-warning "format" "attribute __format__ __strftime__" } */
+  t__format__strfmon ("%n", d);
+  t__format__strfmon ("%"); /* { dg-warning "format" "attribute __format__ strfmon" } */
+  t__format____strfmon__ ("%n", d);
+  t__format____strfmon__ ("%"); /* { dg-warning "format" "attribute __format__ __strfmon__" } */
+  tformatprintf (tformat_arg ("%d"), i);
+  tformatprintf (tformat_arg ("%")); /* { dg-warning "format" "attribute format_arg" } */
+  tformatprintf (t__format_arg__ ("%d"), i);
+  tformatprintf (t__format_arg__ ("%")); /* { dg-warning "format" "attribute __format_arg__" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-3.c
new file mode 100644
index 000000000..bee5ff484
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-3.c
@@ -0,0 +1,71 @@
+/* Test for format attributes: test bad uses of __attribute__.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+/* Proper uses of the attributes.  */
+extern void fa0 (const char *, ...) __attribute__((format(gnu_attr_printf, 1, 2)));
+extern void fa1 (char *, ...) __attribute__((format(gnu_attr_printf, 1, 2)));
+extern char *fa2 (const char *) __attribute__((format_arg(1)));
+extern char *fa3 (char *) __attribute__((format_arg(1)));
+
+/* Uses with too few or too many arguments.  */
+extern void fb0 (const char *, ...) __attribute__((format)); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb1 (const char *, ...) __attribute__((format())); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb2 (const char *, ...) __attribute__((format(gnu_attr_printf))); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb3 (const char *, ...) __attribute__((format(gnu_attr_printf, 1))); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb4 (const char *, ...) __attribute__((format(gnu_attr_printf, 1, 2, 3))); /* { dg-error "wrong number of arguments" "bad format" } */
+
+extern void fc1 (const char *) __attribute__((format_arg)); /* { dg-error "wrong number of arguments" "bad format_arg" } */
+extern void fc2 (const char *) __attribute__((format_arg())); /* { dg-error "wrong number of arguments" "bad format_arg" } */
+extern void fc3 (const char *) __attribute__((format_arg(1, 2))); /* { dg-error "wrong number of arguments" "bad format_arg" } */
+
+/* These attributes presently only apply to declarations, not to types.
+   Eventually, they should be usable with declarators for function types
+   anywhere, but still not with structure/union/enum types.  */
+struct s0 { int i; } __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "does not apply|only applies" "format on struct" } */
+union u0 { int i; } __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "does not apply|only applies" "format on union" } */
+enum e0 { E0V0 } __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "does not apply|only applies" "format on enum" } */
+
+struct s1 { int i; } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on struct" } */
+union u1 { int i; } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on union" } */
+enum e1 { E1V0 } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on enum" } */
+
+/* The format type must be an identifier, one of those recognized.  */
+extern void fe0 (const char *, ...) __attribute__((format(12345, 1, 2))); /* { dg-error "format specifier" "non-id format" } */
+extern void fe1 (const char *, ...) __attribute__((format(nosuch, 1, 2))); /* { dg-warning "format function type" "unknown format" } */
+
+/* Both the numbers must be integer constant expressions.  */
+extern void ff0 (const char *, ...) __attribute__((format(gnu_attr_printf, 3-2, (long long)(10/5))));
+int foo;
+extern void ff1 (const char *, ...) __attribute__((format(gnu_attr_printf, foo, 10/5))); /* { dg-error "invalid operand" "bad number" } */
+extern void ff2 (const char *, ...) __attribute__((format(gnu_attr_printf, 3-2, foo))); /* { dg-error "invalid operand" "bad number" } */
+extern char *ff3 (const char *) __attribute__((format_arg(3-2)));
+extern char *ff4 (const char *) __attribute__((format_arg(foo))); /* { dg-error "invalid operand" "bad format_arg number" } */
+
+/* The format string argument must precede the arguments to be formatted.
+   This includes if no parameter types are specified (which is not valid ISO
+   C for variadic functions).  */
+extern void fg0 () __attribute__((format(gnu_attr_printf, 1, 2)));
+extern void fg1 () __attribute__((format(gnu_attr_printf, 1, 0)));
+extern void fg2 () __attribute__((format(gnu_attr_printf, 1, 1))); /* { dg-error "follows" "bad number order" } */
+extern void fg3 () __attribute__((format(gnu_attr_printf, 2, 1))); /* { dg-error "follows" "bad number order" } */
+
+/* The format string argument must be a string type, and the arguments to
+   be formatted must be the "...".  */
+extern void fh0 (int, ...) __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "not a string" "format int string" } */
+extern void fh1 (signed char *, ...) __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "not a string" "signed char string" } */
+extern void fh2 (unsigned char *, ...) __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "not a string" "unsigned char string" } */
+extern void fh3 (const char *, ...) __attribute__((format(gnu_attr_printf, 1, 3))); /* { dg-error "is not" "not ..." } */
+extern void fh4 (const char *, int, ...) __attribute__((format(gnu_attr_printf, 1, 2))); /* { dg-error "is not" "not ..." } */
+
+/* format_arg formats must take and return a string.  */
+extern char *fi0 (int) __attribute__((format_arg(1))); /* { dg-error "not a string" "format_arg int string" } */
+extern char *fi1 (signed char *) __attribute__((format_arg(1))); /* { dg-error "not a string" "format_arg signed char string" } */
+extern char *fi2 (unsigned char *) __attribute__((format_arg(1))); /* { dg-error "not a string" "format_arg unsigned char string" } */
+extern int fi3 (const char *) __attribute__((format_arg(1))); /* { dg-error "not return string" "format_arg ret int string" } */
+extern signed char *fi4 (const char *) __attribute__((format_arg(1))); /* { dg-error "not return string" "format_arg ret signed char string" } */
+extern unsigned char *fi5 (const char *) __attribute__((format_arg(1))); /* { dg-error "not return string" "format_arg ret unsigned char string" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-4.c
new file mode 100644
index 000000000..caeed93a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-4.c
@@ -0,0 +1,26 @@
+/* Test for format attributes: test use of __attribute__
+   in prefix attributes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+extern __attribute__((format(gnu_attr_printf, 1, 2))) void tformatprintf0 (const char *, ...);
+extern void __attribute__((format(gnu_attr_printf, 1, 2))) tformatprintf1 (const char *, ...);
+extern void foo (void), __attribute__((format(gnu_attr_printf, 1, 2))) tformatprintf2 (const char *, ...);
+extern __attribute__((noreturn)) void bar (void), __attribute__((format(gnu_attr_printf, 1, 2))) tformatprintf3 (const char *, ...);
+
+void
+baz (int i, int *ip, double d)
+{
+  tformatprintf0 ("%d", i);
+  tformatprintf0 ("%"); /* { dg-warning "format" "attribute format printf case 0" } */
+  tformatprintf1 ("%d", i);
+  tformatprintf1 ("%"); /* { dg-warning "format" "attribute format printf case 1" } */
+  tformatprintf2 ("%d", i);
+  tformatprintf2 ("%"); /* { dg-warning "format" "attribute format printf case 2" } */
+  tformatprintf3 ("%d", i);
+  tformatprintf3 ("%"); /* { dg-warning "format" "attribute format printf case 3" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-5.c
new file mode 100644
index 000000000..36b119896
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-5.c
@@ -0,0 +1,28 @@
+/* Test for format attributes: test default attributes are silently ignored
+   when a function is redeclared in an inappropriate manner.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+/* We can't #include "format.h" here.  */
+
+/* This scanf declaration is static, so can't be the system function.  */
+static int scanf(const char *restrict, ...);
+
+/* This sscanf declaration doesn't have variable arguments, so isn't
+   compatible with a format attribute.  */
+extern int sscanf(const char *restrict, const char *restrict, int *); /* { dg-warning "conflict" "conflict" } */
+
+void
+foo (const char *s, int *p)
+{
+  scanf("%ld", p); /* { dg-bogus "format" "static" } */
+  sscanf(s, "%ld", p); /* { dg-bogus "format" "wrong type" } */
+}
+
+/* Dummy definition of scanf.  */
+static int
+scanf (const char *restrict fmt, ...)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-6.c
new file mode 100644
index 000000000..0f683223d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-6.c
@@ -0,0 +1,22 @@
+/* Test for format attributes: test default attributes are applied
+   to implicit declarations.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -Wformat" } */
+
+/* We can't #include "format.h" here.  */
+
+/* Technically, none of the format functions should be implicitly declared;
+   either the implicit type is wrong, the function has variable arguments
+   or it requires a type declared in a header.  However, some bad programming
+   practice uses implicit declarations of some of these functions.
+
+   Note that printf is not used in this test because of the declaration
+   of it as a built-in function.  */
+
+void
+foo (const char *s, int *p)
+{
+  scanf("%ld", p); /* { dg-warning "format" "implicit scanf" } */
+  /* { dg-warning "implicit" "implicit decl warning" { target *-*-* } 20 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-7.c
new file mode 100644
index 000000000..c37044819
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/attr-7.c
@@ -0,0 +1,35 @@
+/* Test for format attributes: test applying them to types.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+__attribute__((format(gnu_attr_printf, 1, 2))) void (*tformatprintf0) (const char *, ...);
+void (*tformatprintf1) (const char *, ...) __attribute__((format(gnu_attr_printf, 1, 2)));
+void (__attribute__((format(gnu_attr_printf, 1, 2))) *tformatprintf2) (const char *, ...);
+void (__attribute__((format(gnu_attr_printf, 1, 2))) ****tformatprintf3) (const char *, ...);
+
+char * (__attribute__((format_arg(1))) *tformat_arg) (const char *);
+
+void
+baz (int i)
+{
+  (*tformatprintf0) ("%d", i);
+  (*tformatprintf0) ((*tformat_arg) ("%d"), i);
+  (*tformatprintf0) ("%"); /* { dg-warning "format" "prefix" } */
+  (*tformatprintf0) ((*tformat_arg) ("%")); /* { dg-warning "format" "prefix" } */
+  (*tformatprintf1) ("%d", i);
+  (*tformatprintf1) ((*tformat_arg) ("%d"), i);
+  (*tformatprintf1) ("%"); /* { dg-warning "format" "postfix" } */
+  (*tformatprintf1) ((*tformat_arg) ("%")); /* { dg-warning "format" "postfix" } */
+  (*tformatprintf2) ("%d", i);
+  (*tformatprintf2) ((*tformat_arg) ("%d"), i);
+  (*tformatprintf2) ("%"); /* { dg-warning "format" "nested" } */
+  (*tformatprintf2) ((*tformat_arg) ("%")); /* { dg-warning "format" "nested" } */
+  (****tformatprintf3) ("%d", i);
+  (****tformatprintf3) ((*tformat_arg) ("%d"), i);
+  (****tformatprintf3) ("%"); /* { dg-warning "format" "nested 2" } */
+  (****tformatprintf3) ((*tformat_arg) ("%")); /* { dg-warning "format" "nested 2" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/bitfld-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/bitfld-1.c
new file mode 100644
index 000000000..e828ad97c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/bitfld-1.c
@@ -0,0 +1,51 @@
+/* Test for printf formats and bit-fields: bug 22421.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+/* { dg-require-effective-target int32plus } */
+
+#include "format.h"
+
+struct s {
+  unsigned int u1 : 1;
+  signed int s1 : 1;
+  unsigned int u15 : 15;
+  signed int s15 : 15;
+  unsigned int u16 : 16;
+  signed int s16 : 16;
+  unsigned long u31 : 31;
+  signed long s31 : 31;
+  unsigned long u32 : 32;
+  signed long s32 : 32;
+  unsigned long long u48 : 48;
+} x;
+
+void
+foo (void)
+{
+  printf ("%d%u", x.u1, x.u1);
+  printf ("%d%u", x.s1, x.s1);
+  printf ("%d%u", x.u15, x.u15);
+  printf ("%d%u", x.s15, x.s15);
+  printf ("%d%u", x.u16, x.u16);
+  printf ("%d%u", x.s16, x.s16);
+#if __INT_MAX__ > 32767
+  /* If integers are 16 bits, there doesn't seem to be a way of
+     printing these without getting an error.  */
+  printf ("%d%u", x.u31, x.u31);
+  printf ("%d%u", x.s31, x.s31);
+#endif
+#if __LONG_MAX__ > 2147483647 && __INT_MAX__ >= 2147483647
+  /* If long is wider than 32 bits, the 32-bit bit-fields are int or
+     unsigned int or promote to those types.  Otherwise, long is 32
+     bits and the bit-fields are of type plain long or unsigned
+     long.  */
+  printf ("%d%u", x.u32, x.u32);
+  printf ("%d%u", x.s32, x.s32);
+#else
+  printf ("%ld%lu", x.u32, x.u32);
+  printf ("%ld%lu", x.s32, x.s32);
+#endif
+  printf ("%llu", x.u48); /* { dg-warning "has type '.*unsigned int:48'" } */
+  printf ("%llu", (unsigned long long)x.u48);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/branch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/branch-1.c
new file mode 100644
index 000000000..cdff92762
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/branch-1.c
@@ -0,0 +1,27 @@
+/* Test for format checking of conditional expressions.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (long l, int nfoo)
+{
+  printf ((nfoo > 1) ? "%d foos" : "%d foo", nfoo);
+  printf ((l > 1) ? "%d foos" : "%d foo", l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf ((l > 1) ? "%ld foos" : "%d foo", l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf ((l > 1) ? "%d foos" : "%ld foo", l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  /* Should allow one case to have extra arguments.  */
+  printf ((nfoo > 1) ? "%d foos" : "1 foo", nfoo);
+  printf ((nfoo > 1) ? "many foos" : "1 foo", nfoo); /* { dg-warning "too many" "too many args in all branches" } */
+  printf ((nfoo > 1) ? "%d foos" : "", nfoo);
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "1 foo" : "no foos"), nfoo);
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "%d foo" : "%d foos"), nfoo);
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "%d foo" : "%ld foos"), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf ((nfoo > 1) ? "%ld foos" : ((nfoo > 0) ? "%d foo" : "%d foos"), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "%ld foo" : "%d foos"), nfoo); /* { dg-warning "long int" "wrong type" } */
+  /* Extra arguments to NULL should be complained about.  */
+  printf (NULL, "foo"); /* { dg-warning "too many" "NULL extra args" } */
+  /* { dg-warning "null" "null format arg" { target *-*-* } 25 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/builtin-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/builtin-1.c
new file mode 100644
index 000000000..ba1cab647
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/builtin-1.c
@@ -0,0 +1,22 @@
+/* Test for format extensions.  Test that the __builtin functions get their
+   default attributes even with -ffreestanding.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -ffreestanding" } */
+
+#include "format.h"
+
+void
+foo (int i)
+{
+  __builtin_fprintf (stdout, "%d", i);
+  __builtin_fprintf (stdout, "%ld", i); /* { dg-warning "format" "__builtin_fprintf" } */
+  __builtin_printf ("%d", i);
+  __builtin_printf ("%ld", i); /* { dg-warning "format" "__builtin_printf" } */
+
+  __builtin_fprintf_unlocked (stdout, "%d", i);
+  __builtin_fprintf_unlocked (stdout, "%ld", i); /* { dg-warning "format" "__builtin_fprintf_unlocked" } */
+  __builtin_printf_unlocked ("%d", i);
+  __builtin_printf_unlocked ("%ld", i); /* { dg-warning "format" "__builtin_printf_unlocked" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-1.c
new file mode 100644
index 000000000..e4c18f768
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-1.c
@@ -0,0 +1,237 @@
+/* Test for printf formats.  Formats using C90 features, including cases
+   where C90 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, int i1, int i2, unsigned int u, double d, char *s, void *p,
+     int *n, short int *hn, long int l, unsigned long int ul,
+     long int *ln, long double ld, wint_t lc, wchar_t *ls, llong ll,
+     ullong ull, unsigned int *un, const int *cn, signed char *ss,
+     unsigned char *us, const signed char *css, unsigned int u1,
+     unsigned int u2)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.1 (pages 131-134).  */
+  /* Basic sanity checks for the different components of a format.  */
+  printf ("%d\n", i);
+  printf ("%+d\n", i);
+  printf ("%3d\n", i);
+  printf ("%-3d\n", i);
+  printf ("%.7d\n", i);
+  printf ("%+9.4d\n", i);
+  printf ("%.3ld\n", l);
+  printf ("%*d\n", i1, i);
+  printf ("%.*d\n", i2, i);
+  printf ("%*.*ld\n", i1, i2, l);
+  printf ("%d %lu\n", i, ul);
+  /* GCC has objected to the next one in the past, but it is a valid way
+     of specifying zero precision.
+  */
+  printf ("%.e\n", d); /* { dg-bogus "precision" "bogus precision warning" } */
+  /* Bogus use of width.  */
+  printf ("%5n\n", n); /* { dg-warning "width" "width with %n" } */
+  /* Erroneous, ignored or pointless constructs with precision.  */
+  /* Whether negative values for precision may be included in the format
+     string is not entirely clear; presume not, following Clive Feather's
+     proposed resolution to DR#220 against C99.  In any case, such a
+     construct should be warned about.
+  */
+  printf ("%.-5d\n", i); /* { dg-warning "format|precision" "negative precision warning" } */
+  printf ("%.-*d\n", i); /* { dg-warning "format" "broken %.-*d format" } */
+  printf ("%.3c\n", i); /* { dg-warning "precision" "precision with %c" } */
+  printf ("%.3p\n", p); /* { dg-warning "precision" "precision with %p" } */
+  printf ("%.3n\n", n); /* { dg-warning "precision" "precision with %n" } */
+  /* Valid and invalid %% constructions.  Some of the warning messages
+     are non-optimal, but they do detect the errorneous nature of the
+     format string.
+  */
+  printf ("%%");
+  printf ("%.3%"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%-%"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%-%\n"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%5%\n"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%h%\n"); /* { dg-warning "format" "bogus %%" } */
+  /* Valid and invalid %h, %l, %L constructions.  */
+  printf ("%hd", i);
+  printf ("%hi", i);
+  /* Strictly, these parameters should be int or unsigned int according to
+     what unsigned short promotes to.  However, GCC ignores sign
+     differences in format checking here, and this is relied on to get the
+     correct checking without print_char_table needing to know whether
+     int and short are the same size.
+  */
+  printf ("%ho%hu%hx%hX", u, u, u, u);
+  printf ("%hn", hn);
+  printf ("%hf", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%he", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hE", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hg", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hG", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hc", i); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hs", s); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hp", p); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%h"); /* { dg-warning "conversion lacks type" "bare %h" } */
+  printf ("%h."); /* { dg-warning "conversion" "bogus %h." } */
+  printf ("%ld%li%lo%lu%lx%lX", l, l, ul, ul, ul, ul);
+  printf ("%ln", ln);
+  printf ("%lf", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%le", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lE", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lg", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lG", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lp", p); /* { dg-warning "length|C" "bad use of %l" } */
+  /* These next two were added in C94, but should be objected to in C90.
+     For the first one, GCC has wanted wchar_t instead of the correct C94
+     and C99 wint_t.
+  */
+  printf ("%lc", lc); /* { dg-warning "length|C" "C90 bad use of %l" } */
+  printf ("%ls", ls); /* { dg-warning "length|C" "C90 bad use of %l" } */
+  /* These uses of %L are legitimate, though GCC has wrongly warned for
+     them in the past.
+  */
+  printf ("%Le%LE%Lf%Lg%LG", ld, ld, ld, ld, ld);
+  /* These next six are accepted by GCC as referring to long long,
+     but -pedantic correctly warns.
+  */
+  printf ("%Ld", ll); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Li", ll); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lo", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lu", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lx", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%LX", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lc", i); /* { dg-warning "length" "bad use of %L" } */
+  printf ("%Ls", s); /* { dg-warning "length" "bad use of %L" } */
+  printf ("%Lp", p); /* { dg-warning "length" "bad use of %L" } */
+  printf ("%Ln", n); /* { dg-warning "length" "bad use of %L" } */
+  /* Valid uses of each bare conversion.  */
+  printf ("%d%i%o%u%x%X%f%e%E%g%G%c%s%p%n%%", i, i, u, u, u, u, d, d, d, d, d,
+	  i, s, p, n);
+  /* Uses of the - flag (valid on all non-%, non-n conversions).  */
+  printf ("%-d%-i%-o%-u%-x%-X%-f%-e%-E%-g%-G%-c%-s%-p", i, i, u, u, u, u,
+	  d, d, d, d, d, i, s, p);
+  printf ("%-n", n); /* { dg-warning "flag" "bad use of %-n" } */
+  /* Uses of the + flag (valid on signed conversions only).  */
+  printf ("%+d%+i%+f%+e%+E%+g%+G\n", i, i, d, d, d, d, d);
+  printf ("%+o", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+u", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+x", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+X", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+c", i); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+s", s); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+p", p); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+n", n); /* { dg-warning "flag" "bad use of + flag" } */
+  /* Uses of the space flag (valid on signed conversions only, and ignored
+     with +).
+  */
+  printf ("% +d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("%+ d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("% d% i% f% e% E% g% G\n", i, i, d, d, d, d, d);
+  printf ("% o", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% u", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% x", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% X", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% c", i); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% s", s); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% p", p); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% n", n); /* { dg-warning "flag" "bad use of space flag" } */
+  /* Uses of the # flag.  */
+  printf ("%#o%#x%#X%#e%#E%#f%#g%#G", u, u, u, d, d, d, d, d);
+  printf ("%#d", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#i", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#u", u); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#c", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#s", s); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#p", p); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#n", n); /* { dg-warning "flag" "bad use of # flag" } */
+  /* Uses of the 0 flag.  */
+  printf ("%08d%08i%08o%08u%08x%08X%08e%08E%08f%08g%08G", i, i, u, u, u, u,
+	  d, d, d, d, d);
+  printf ("%0c", i); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0s", s); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0p", p); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0n", n); /* { dg-warning "flag" "bad use of 0 flag" } */
+  /* 0 flag ignored with precision for certain types, not others.  */
+  printf ("%08.5d", i); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5i", i); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5o", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5u", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5x", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5X", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5f%08.5e%08.5E%08.5g%08.5G", d, d, d, d, d);
+  /* 0 flag ignored with - flag.  */
+  printf ("%-08d", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08i", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08o", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08u", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08x", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08X", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08e", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08E", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08f", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08g", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08G", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  /* Various tests of bad argument types.  */
+  printf ("%d", l); /* { dg-warning "format" "bad argument types" } */
+  printf ("%*.*d", l, i2, i); /* { dg-warning "field" "bad * argument types" } */
+  printf ("%*.*d", i1, l, i); /* { dg-warning "field" "bad * argument types" } */
+  printf ("%ld", i); /* { dg-warning "format" "bad argument types" } */
+  printf ("%s", n); /* { dg-warning "format" "bad argument types" } */
+  printf ("%p", i); /* { dg-warning "format" "bad argument types" } */
+  printf ("%n", p); /* { dg-warning "format" "bad argument types" } */
+  /* With -pedantic, we want some further checks for pointer targets:
+     %p should allow only pointers to void (possibly qualified) and
+     to character types (possibly qualified), but not function pointers
+     or pointers to other types.  (Whether, in fact, character types are
+     allowed here is unclear; see thread on comp.std.c, July 2000 for
+     discussion of the requirements of rules on identical representation,
+     and of the application of the as if rule with the new va_arg
+     allowances in C99 to printf.)  Likewise, we should warn if
+     pointer targets differ in signedness, except in some circumstances
+     for character pointers.  (In C99 we should consider warning for
+     char * or unsigned char * being passed to %hhn, even if strictly
+     legitimate by the standard.)
+  */
+  printf ("%p", foo); /* { dg-warning "format" "bad argument types" } */
+  printf ("%n", un); /* { dg-warning "format" "bad argument types" } */
+  printf ("%p", n); /* { dg-warning "format" "bad argument types" } */
+  /* Allow character pointers with %p.  */
+  printf ("%p%p%p%p", s, ss, us, css);
+  /* %s allows any character type.  */
+  printf ("%s%s%s%s", s, ss, us, css);
+  /* Warning for void * arguments for %s is GCC's historical behavior,
+     and seems useful to keep, even if some standard versions might be
+     read to permit it.
+  */
+  printf ("%s", p); /* { dg-warning "format" "bad argument types" } */
+  /* The historical behavior is to allow signed / unsigned types
+     interchangably as arguments.  For values representable in both types,
+     such usage may be correct.  For now preserve the behavior of GCC
+     in such cases.
+  */
+  printf ("%d", u);
+  /* Also allow the same for width and precision arguments.  In the past,
+     GCC has been inconsistent and allowed unsigned for width but not
+     precision.
+  */
+  printf ("%*.*d", u1, u2, i);
+  /* Wrong number of arguments.  */
+  printf ("%d%d", i); /* { dg-warning "arguments" "wrong number of args" } */
+  printf ("%d", i, i); /* { dg-warning "arguments" "wrong number of args" } */
+  /* Miscellaneous bogus constructions.  */
+  printf (""); /* { dg-warning "zero-length" "warning for empty format" } */
+  printf ("\0"); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  printf ("%d\0", i); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  printf ("%d\0%d", i, i); /* { dg-warning "embedded|too many" "warning for embedded NUL" } */
+  printf (NULL); /* { dg-warning "null" "null format string warning" } */
+  printf ("%"); /* { dg-warning "trailing" "trailing % warning" } */
+  printf ("%++d", i); /* { dg-warning "repeated" "repeated flag warning" } */
+  printf ("%n", cn); /* { dg-warning "constant" "%n with const" } */
+  printf ((const char *)L"foo"); /* { dg-warning "wide" "wide string" } */
+  printf ("%n", (int *)0); /* { dg-warning "null" "%n with NULL" } */
+  printf ("%s", (char *)0); /* { dg-warning "null" "%s with NULL" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-2.c
new file mode 100644
index 000000000..b9da764b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-2.c
@@ -0,0 +1,24 @@
+/* Test for printf formats.  Formats using C99 features should be rejected
+   outside of C99 mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, double d, llong ll, intmax_t j, size_t z, ptrdiff_t t)
+{
+  /* Some tests already in c90-printf-1.c, e.g. %lf.  */
+  /* The widths hh, ll, j, z, t are new.  */
+  printf ("%hhd", i); /* { dg-warning "length|C" "%hh in C90" } */
+  printf ("%lld", ll); /* { dg-warning "length|C" "%ll in C90" } */
+  printf ("%jd", j); /* { dg-warning "length|C" "%j in C90" } */
+  printf ("%zu", z); /* { dg-warning "length|C" "%z in C90" } */
+  printf ("%td", t); /* { dg-warning "length|C" "%t in C90" } */
+  /* The formats F, a, A are new.  */
+  printf ("%F", d); /* { dg-warning "C" "%F in C90" } */
+  printf ("%a", d); /* { dg-warning "C" "%a in C90" } */
+  printf ("%A", d); /* { dg-warning "C" "%A in C90" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-3.c
new file mode 100644
index 000000000..bf48f3114
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-printf-3.c
@@ -0,0 +1,42 @@
+/* Test for printf formats.  Test that the C90 functions get their default
+   attributes in strict C90 mode, but the C99 and gettext functions
+   do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { ! *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, char *s, size_t n, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5, va_list v6, va_list v7, va_list v8)
+{
+  fprintf (stdout, "%d", i);
+  fprintf (stdout, "%ld", i); /* { dg-warning "format" "fprintf" } */
+  printf ("%d", i);
+  printf ("%ld", i); /* { dg-warning "format" "printf" } */
+  /* The "unlocked" functions shouldn't warn in c90 mode.  */
+  fprintf_unlocked (stdout, "%ld", i); /* { dg-bogus "format" "fprintf_unlocked" } */
+  printf_unlocked ("%ld", i); /* { dg-bogus "format" "printf_unlocked" } */
+  sprintf (s, "%d", i);
+  sprintf (s, "%ld", i); /* { dg-warning "format" "sprintf" } */
+  vfprintf (stdout, "%d", v0);
+  vfprintf (stdout, "%Y", v1); /* { dg-warning "format" "vfprintf" } */
+  vprintf ("%d", v2);
+  vprintf ("%Y", v3); /* { dg-warning "format" "vprintf" } */
+  /* The following used to give a bogus warning.  */
+  vprintf ("%*.*d", v8);
+  vsprintf (s, "%d", v4);
+  vsprintf (s, "%Y", v5); /* { dg-warning "format" "vsprintf" } */
+  snprintf (s, n, "%d", i);
+  snprintf (s, n, "%ld", i);
+  vsnprintf (s, n, "%d", v6);
+  vsnprintf (s, n, "%Y", v7);
+  printf (gettext ("%d"), i);
+  printf (gettext ("%ld"), i);
+  printf (dgettext ("", "%d"), i);
+  printf (dgettext ("", "%ld"), i);
+  printf (dcgettext ("", "%d", 0), i);
+  printf (dcgettext ("", "%ld", 0), i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-1.c
new file mode 100644
index 000000000..ea42f1e13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-1.c
@@ -0,0 +1,119 @@
+/* Test for scanf formats.  Formats using C90 features, including cases
+   where C90 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int *ip, unsigned int *uip, short int *hp, unsigned short int *uhp,
+     long int *lp, unsigned long int *ulp, float *fp, double *dp,
+     long double *ldp, char *s, signed char *ss, unsigned char *us,
+     void **pp, int *n, llong *llp, ullong *ullp, wchar_t *ls,
+     const int *cip, const int *cn, const char *cs, const void **ppc,
+     void *const *pcp, short int *hn, long int *ln, void *p, char **sp,
+     volatile void *ppv)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.2 (pages 134-138).  */
+  /* Basic sanity checks for the different components of a format.  */
+  scanf ("%d", ip);
+  scanf ("%*d");
+  scanf ("%3d", ip);
+  scanf ("%hd", hp);
+  scanf ("%3ld", lp);
+  scanf ("%*3d");
+  scanf ("%d %ld", ip, lp);
+  /* Valid and invalid %% constructions.  */
+  scanf ("%%");
+  scanf ("%*%"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%*%\n"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%4%"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%4%\n"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%h%"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%h%\n"); /* { dg-warning "format" "bogus %%" } */
+  /* Valid, invalid and silly assignment-suppression constructions.  */
+  scanf ("%*d%*i%*o%*u%*x%*X%*e%*E%*f%*g%*G%*s%*[abc]%*c%*p");
+  scanf ("%*2d%*8s%*3c");
+  scanf ("%*n", n); /* { dg-warning "suppress" "suppression of %n" } */
+  scanf ("%*hd"); /* { dg-warning "together" "suppression with length" } */
+  /* Valid, invalid and silly width constructions.  */
+  scanf ("%2d%3i%4o%5u%6x%7X%8e%9E%10f%11g%12G%13s%14[abc]%15c%16p",
+	 ip, ip, uip, uip, uip, uip, fp, fp, fp, fp, fp, s, s, s, pp);
+  scanf ("%0d", ip); /* { dg-warning "width" "warning for zero width" } */
+  scanf ("%3n", n); /* { dg-warning "width" "width with %n" } */
+  /* Valid and invalid %h, %l, %L constructions.  */
+  scanf ("%hd%hi%ho%hu%hx%hX%hn", hp, hp, uhp, uhp, uhp, uhp, hn);
+  scanf ("%he", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hE", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hf", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hg", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hG", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hs", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%h[ac]", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hc", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hp", pp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%h"); /* { dg-warning "conversion lacks type" "bare %h" } */
+  scanf ("%h."); /* { dg-warning "conversion" "bogus %h" } */
+  scanf ("%ld%li%lo%lu%lx%lX%ln", lp, lp, ulp, ulp, ulp, ulp, ln);
+  scanf ("%le%lE%lf%lg%lG", dp, dp, dp, dp, dp);
+  scanf ("%lp", pp); /* { dg-warning "length" "bad use of %l" } */
+  /* These next three formats were added in C94.  */
+  scanf ("%ls", ls); /* { dg-warning "length|C" "bad use of %l" } */
+  scanf ("%l[ac]", ls); /* { dg-warning "length|C" "bad use of %l" } */
+  scanf ("%lc", ls); /* { dg-warning "length|C" "bad use of %l" } */
+  scanf ("%Le%LE%Lf%Lg%LG", ldp, ldp, ldp, ldp, ldp);
+  scanf ("%Ld", llp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Li", llp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Lo", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Lu", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Lx", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%LX", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Ls", s); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%L[ac]", s); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%Lc", s); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%Lp", pp); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%Ln", n); /* { dg-warning "length" "bad use of %L" } */
+  /* Valid uses of each bare conversion.  */
+  scanf ("%d%i%o%u%x%X%e%E%f%g%G%s%[abc]%c%p%n%%", ip, ip, uip, uip, uip,
+	 uip, fp, fp, fp, fp, fp, s, s, s, pp, n);
+  /* Allow other character pointers with %s, %c, %[].  */
+  scanf ("%2s%3s%4c%5c%6[abc]%7[abc]", ss, us, ss, us, ss, us);
+  /* Further tests for %[].  */
+  scanf ("%[%d]%d", s, ip);
+  scanf ("%[^%d]%d", s, ip);
+  scanf ("%[]%d]%d", s, ip);
+  scanf ("%[^]%d]%d", s, ip);
+  scanf ("%[%d]%d", s, ip);
+  scanf ("%[]abcd", s); /* { dg-warning "no closing" "incomplete scanset" } */
+  /* Various tests of bad argument types.  Some of these are only pedantic
+     warnings.
+  */
+  scanf ("%d", lp); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%d", uip); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%d", pp); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", ppc); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", ppv); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%s", n); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%s", p); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", p); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", sp); /* { dg-warning "format" "bad argument types" } */
+  /* Tests for writing into constant values.  */
+  scanf ("%d", cip); /* { dg-warning "constant" "%d writing into const" } */
+  scanf ("%n", cn); /* { dg-warning "constant" "%n writing into const" } */
+  scanf ("%s", cs); /* { dg-warning "constant" "%s writing into const" } */
+  scanf ("%p", pcp); /* { dg-warning "constant" "%p writing into const" } */
+  /* Wrong number of arguments.  */
+  scanf ("%d%d", ip); /* { dg-warning "arguments" "wrong number of args" } */
+  scanf ("%d", ip, ip); /* { dg-warning "arguments" "wrong number of args" } */
+  /* Miscellaneous bogus constructions.  */
+  scanf (""); /* { dg-warning "zero-length" "warning for empty format" } */
+  scanf ("\0"); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  scanf ("%d\0", ip); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  scanf ("%d\0%d", ip, ip); /* { dg-warning "embedded|too many" "warning for embedded NUL" } */
+  scanf (NULL); /* { dg-warning "null" "null format string warning" } */
+  scanf ("%"); /* { dg-warning "trailing" "trailing % warning" } */
+  scanf ("%d", (int *)0); /* { dg-warning "null" "writing into NULL" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-2.c
new file mode 100644
index 000000000..52c08921e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-2.c
@@ -0,0 +1,25 @@
+/* Test for scanf formats.  Formats using C99 features should be rejected
+   outside of C99 mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (signed char *hhp, float *fp, llong *llp, intmax_t *jp,
+     size_t *zp, ptrdiff_t *tp)
+{
+  /* Some tests already in c90-scanf-1.c.  */
+  /* The widths hh, ll, j, z, t are new.  */
+  scanf ("%hhd", hhp); /* { dg-warning "length|C" "%hh in C90" } */
+  scanf ("%lld", llp); /* { dg-warning "length|C" "%ll in C90" } */
+  scanf ("%jd", jp); /* { dg-warning "length|C" "%j in C90" } */
+  scanf ("%zu", zp); /* { dg-warning "length|C" "%z in C90" } */
+  scanf ("%td", tp); /* { dg-warning "length|C" "%t in C90" } */
+  /* The formats F, a, A are new.  */
+  scanf ("%F", fp); /* { dg-warning "C" "%F in C90" } */
+  scanf ("%a", fp); /* { dg-warning "C" "%a in C90" } */
+  scanf ("%A", fp); /* { dg-warning "C" "%A in C90" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-3.c
new file mode 100644
index 000000000..557070782
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-3.c
@@ -0,0 +1,19 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* %a formats for allocation, only recognized in C90 mode, are a
+     GNU extension.
+  */
+  scanf ("%as", sp); /* { dg-warning "C" "%as" } */
+  scanf ("%aS", lsp); /* { dg-warning "C" "%aS" } */
+  scanf ("%a[bcd]", sp); /* { dg-warning "C" "%a[]" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-4.c
new file mode 100644
index 000000000..0a47f3f35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-4.c
@@ -0,0 +1,33 @@
+/* Test for scanf formats.  Test that the C90 functions get their default
+   attributes in strict C90 mode, but the C99 and gettext functions
+   do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { ! *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int *ip, char *s, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5)
+{
+  fscanf (stdin, "%d", ip);
+  fscanf (stdin, "%ld", ip); /* { dg-warning "format" "fscanf" } */
+  scanf ("%d", ip);
+  scanf ("%ld", ip); /* { dg-warning "format" "scanf" } */
+  sscanf (s, "%d", ip);
+  sscanf (s, "%ld", ip); /* { dg-warning "format" "sscanf" } */
+  vfscanf (stdin, "%d", v0);
+  vfscanf (stdin, "%Y", v1);
+  vscanf ("%d", v2);
+  vscanf ("%Y", v3);
+  vsscanf (s, "%d", v4);
+  vsscanf (s, "%Y", v5);
+  scanf (gettext ("%d"), ip);
+  scanf (gettext ("%ld"), ip);
+  scanf (dgettext ("", "%d"), ip);
+  scanf (dgettext ("", "%ld"), ip);
+  scanf (dcgettext ("", "%d", 0), ip);
+  scanf (dcgettext ("", "%ld", 0), ip);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-5.c
new file mode 100644
index 000000000..c94e25f22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-scanf-5.c
@@ -0,0 +1,19 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* m assignment-allocation modifier, recognized in both C90
+     and C99 modes, is a POSIX and ISO/IEC WDTR 24731-2 extension.  */
+  scanf ("%ms", sp); /* { dg-warning "C" "%ms" } */
+  scanf ("%mS", lsp); /* { dg-warning "C" "%mS" } */
+  scanf ("%mls", lsp); /* { dg-warning "C" "%mls" } */
+  scanf ("%m[bcd]", sp); /* { dg-warning "C" "%m[]" } */
+  scanf ("%ml[bcd]", lsp); /* { dg-warning "C" "%ml[]" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-strftime-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-strftime-1.c
new file mode 100644
index 000000000..1739f7b75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-strftime-1.c
@@ -0,0 +1,19 @@
+/* Test for strftime formats.  Formats using C90 features.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wformat-y2k" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.12.3.5 (pages 174-175).  */
+  /* Formats which are Y2K-compliant (no 2-digit years).  */
+  strftime (s, m, "%a%A%b%B%d%H%I%j%m%M%p%S%U%w%W%X%Y%Z%%", tp);
+  /* Formats with 2-digit years.  */
+  strftime (s, m, "%y", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  /* Formats with 2-digit years in some locales.  */
+  strftime (s, m, "%c", tp); /* { dg-warning "some locales" "2-digit year" } */
+  strftime (s, m, "%x", tp); /* { dg-warning "some locales" "2-digit year" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-strftime-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-strftime-2.c
new file mode 100644
index 000000000..8b8398ed9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c90-strftime-2.c
@@ -0,0 +1,31 @@
+/* Test for strftime formats.  Rejection of formats using C99 features in
+   pedantic C90 mode.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wformat-y2k" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  strftime (s, m, "%C", tp); /* { dg-warning "C" "%C not in C90" } */
+  strftime (s, m, "%D", tp); /* { dg-warning "C" "%D not in C90" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 13 } */
+  strftime (s, m, "%e", tp); /* { dg-warning "C" "%e not in C90" } */
+  strftime (s, m, "%F", tp); /* { dg-warning "C" "%F not in C90" } */
+  strftime (s, m, "%g", tp); /* { dg-warning "C" "%g not in C90" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 17 } */
+  strftime (s, m, "%G", tp); /* { dg-warning "C" "%G not in C90" } */
+  strftime (s, m, "%h", tp); /* { dg-warning "C" "%h not in C90" } */
+  strftime (s, m, "%n", tp); /* { dg-warning "C" "%n not in C90" } */
+  strftime (s, m, "%r", tp); /* { dg-warning "C" "%r not in C90" } */
+  strftime (s, m, "%R", tp); /* { dg-warning "C" "%R not in C90" } */
+  strftime (s, m, "%t", tp); /* { dg-warning "C" "%t not in C90" } */
+  strftime (s, m, "%T", tp); /* { dg-warning "C" "%T not in C90" } */
+  strftime (s, m, "%u", tp); /* { dg-warning "C" "%u not in C90" } */
+  strftime (s, m, "%V", tp); /* { dg-warning "C" "%V not in C90" } */
+  strftime (s, m, "%z", tp); /* { dg-warning "C" "%z not in C90" } */
+  strftime (s, m, "%EX", tp); /* { dg-warning "C" "%E not in C90" } */
+  strftime (s, m, "%OW", tp); /* { dg-warning "C" "%O not in C90" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c94-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c94-printf-1.c
new file mode 100644
index 000000000..9ffc8385e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c94-printf-1.c
@@ -0,0 +1,18 @@
+/* Test for printf formats.  Changes in C94 to C90.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:199409 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (wint_t lc, wchar_t *ls)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.1 (pages 131-134),
+     as amended by ISO/IEC 9899:1990/Amd.1:1995 (E) (pages 4-5).
+     We do not repeat here all the C90 format checks, but just verify
+     that %ls and %lc are accepted without warning.
+  */
+  printf ("%lc", lc);
+  printf ("%ls", ls);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c94-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c94-scanf-1.c
new file mode 100644
index 000000000..1eaad7dbf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c94-scanf-1.c
@@ -0,0 +1,17 @@
+/* Test for scanf formats.  Changes in C94 to C90.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:199409 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (wchar_t *ls)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.2 (pages 134-138),
+     as amended by ISO/IEC 9899:1990/Amd.1:1995 (E) (pages 5-6).
+     We do not repeat here all the C90 format checks, but just verify
+     that %ls, %lc, %l[] are accepted without warning.
+  */
+  scanf ("%lc%ls%l[abc]", ls, ls, ls);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-1.c
new file mode 100644
index 000000000..729e41c3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-1.c
@@ -0,0 +1,197 @@
+/* Test for printf formats.  Formats using C99 features, including cases
+   where C99 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, unsigned int u, double d, char *s, void *p, int *n,
+     long double ld, wint_t lc, wchar_t *ls, long long int ll,
+     unsigned long long int ull, signed char *ss, unsigned char *us,
+     long long int *lln, intmax_t j, uintmax_t uj, intmax_t *jn,
+     size_t z, signed_size_t sz, signed_size_t *zn,
+     ptrdiff_t t, ptrdiff_t *tn)
+{
+  /* See ISO/IEC 9899:1999 (E) subclause 7.19.6.1 (pages 273-281).
+     We do not repeat here most of the checks for correct C90 formats
+     or completely broken formats.
+  */
+  /* Valid and invalid %h, %hh, %l, %ll, %j, %z, %t, %L constructions.  */
+  printf ("%hf", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hF", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%he", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hE", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hg", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hG", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%ha", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hA", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hc", i); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hs", s); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hp", p); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hhd%hhi%hho%hhu%hhx%hhX", i, i, u, u, u, u);
+  printf ("%hhn", ss);
+  printf ("%hhf", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhF", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhe", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhE", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhg", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhG", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hha", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhA", d); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhc", i); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhs", s); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%hhp", p); /* { dg-warning "length" "bad use of %hh" } */
+  printf ("%lc", lc);
+  printf ("%ls", ls);
+  printf ("%lf%lF%le%lE%lg%lG%la%lA", d, d, d, d, d, d, d, d);
+  printf ("%lp", p); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lld%lli%llo%llu%llx%llX", ll, ll, ull, ull, ull, ull);
+  printf ("%lln", lln);
+  printf ("%llf", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llF", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%lle", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llE", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llg", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llG", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%lla", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llA", d); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llc", i); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%lls", s); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%llp", p); /* { dg-warning "length" "bad use of %ll" } */
+  printf ("%jd%ji%jo%ju%jx%jX", j, j, uj, uj, uj, uj); /* { dg-bogus "length" "bogus %j warning" { target *-*-* } } */
+  printf ("%jn", jn); /* { dg-bogus "length" "bogus %j warning" { target *-*-* } } */
+  printf ("%jf", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jF", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%je", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jE", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jg", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jG", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%ja", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jA", d); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jc", i); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%js", s); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%jp", p); /* { dg-warning "length" "bad use of %j" } */
+  printf ("%zd%zi%zo%zu%zx%zX", sz, sz, z, z, z, z);
+  printf ("%zn", zn);
+  printf ("%zf", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zF", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%ze", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zE", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zg", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zG", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%za", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zA", d); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zc", i); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zs", s); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%zp", p); /* { dg-warning "length" "bad use of %z" } */
+  printf ("%td%ti%to%tu%tx%tX", t, t, t, t, t, t);
+  printf ("%tn", tn);
+  printf ("%tf", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tF", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%te", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tE", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tg", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tG", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%ta", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tA", d); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tc", i); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%ts", s); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%tp", p); /* { dg-warning "length" "bad use of %t" } */
+  printf ("%Le%LE%Lf%LF%Lg%LG%La%LA", ld, ld, ld, ld, ld, ld, ld, ld);
+  /* These next six are accepted by GCC as referring to long long,
+     but -pedantic correctly warns.
+  */
+  printf ("%Ld", ll); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Li", ll); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lo", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lu", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lx", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%LX", ull); /* { dg-warning "does not support" "bad use of %L" } */
+  printf ("%Lc", i); /* { dg-warning "length" "bad use of %L" } */
+  printf ("%Ls", s); /* { dg-warning "length" "bad use of %L" } */
+  printf ("%Lp", p); /* { dg-warning "length" "bad use of %L" } */
+  printf ("%Ln", n); /* { dg-warning "length" "bad use of %L" } */
+  /* Valid uses of each bare conversion.  */
+  printf ("%d%i%o%u%x%X%f%F%e%E%g%G%a%A%c%s%p%n%%", i, i, u, u, u, u,
+	  d, d, d, d, d, d, d, d, i, s, p, n);
+  /* Uses of the - flag (valid on all non-%, non-n conversions).  */
+  printf ("%-d%-i%-o%-u%-x%-X%-f%-F%-e%-E%-g%-G%-a%-A%-c%-s%-p", i, i,
+	  u, u, u, u, d, d, d, d, d, d, d, d, i, s, p);
+  printf ("%-n", n); /* { dg-warning "flag" "bad use of %-n" } */
+  /* Uses of the + flag (valid on signed conversions only).  */
+  printf ("%+d%+i%+f%+F%+e%+E%+g%+G%+a%+A\n", i, i, d, d, d, d, d, d, d, d);
+  printf ("%+o", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+u", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+x", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+X", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+c", i); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+s", s); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+p", p); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+n", n); /* { dg-warning "flag" "bad use of + flag" } */
+  /* Uses of the space flag (valid on signed conversions only, and ignored
+     with +).
+  */
+  printf ("% +d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("%+ d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("% d% i% f% F% e% E% g% G% a% A\n", i, i, d, d, d, d, d, d, d, d);
+  printf ("% o", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% u", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% x", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% X", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% c", i); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% s", s); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% p", p); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% n", n); /* { dg-warning "flag" "bad use of space flag" } */
+  /* Uses of the # flag.  */
+  printf ("%#o%#x%#X%#e%#E%#f%#F%#g%#G%#a%#A", u, u, u, d, d, d, d,
+	  d, d, d, d);
+  printf ("%#d", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#i", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#u", u); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#c", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#s", s); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#p", p); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#n", n); /* { dg-warning "flag" "bad use of # flag" } */
+  /* Uses of the 0 flag.  */
+  printf ("%08d%08i%08o%08u%08x%08X%08e%08E%08f%08F%08g%08G%08a%08A", i, i,
+	  u, u, u, u, d, d, d, d, d, d, d, d);
+  printf ("%0c", i); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0s", s); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0p", p); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0n", n); /* { dg-warning "flag" "bad use of 0 flag" } */
+  /* 0 flag ignored with precision for certain types, not others.  */
+  printf ("%08.5d", i); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5i", i); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5o", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5u", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5x", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5X", u); /* { dg-warning "ignored" "0 flag ignored with precision" } */
+  printf ("%08.5f%08.5F%08.5e%08.5E%08.5g%08.5G%08.5a%08.5A",
+	  d, d, d, d, d, d, d, d);
+  /* 0 flag ignored with - flag.  */
+  printf ("%-08d", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08i", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08o", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08u", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08x", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08X", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08e", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08E", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08f", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08F", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08g", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08G", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08a", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08A", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  /* Various tests of bad argument types.  Mostly covered in c90-printf-1.c;
+     here just test for pointer target sign with %hhn.  (Probably allowed
+     by the standard, but a bad idea, so GCC should diagnose if what
+     is used is not signed char *.)
+  */
+  printf ("%hhn", s); /* { dg-warning "format" "%hhn plain char" } */
+  printf ("%hhn", us); /* { dg-warning "format" "%hhn unsigned char" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-2.c
new file mode 100644
index 000000000..9efcb0667
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-2.c
@@ -0,0 +1,32 @@
+/* Test for printf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, long long ll, size_t z, wint_t lc, wchar_t *ls)
+{
+  /* The length modifiers q, Z and L as applied to integer formats are
+     extensions.
+  */
+  printf ("%qd", ll); /* { dg-warning "C" "%q length" } */
+  printf ("%Ld", ll); /* { dg-warning "C" "%L length" } */
+  printf ("%Zd", z); /* { dg-warning "C" "%Z length" } */
+  /* The conversion specifiers C and S are X/Open extensions; the
+     conversion specifier m is a GNU extension.
+  */
+  printf ("%m"); /* { dg-warning "C" "printf %m" } */
+  printf ("%C", lc); /* { dg-warning "C" "printf %C" } */
+  printf ("%S", ls); /* { dg-warning "C" "printf %S" } */
+  /* The flag character ', and the use of operand number $ formats, are
+     X/Open extensions.
+  */
+  printf ("%'d", i); /* { dg-warning "C" "printf ' flag" } */
+  printf ("%1$d", i); /* { dg-warning "C" "printf $ format" } */
+  /* The flag character I is a GNU extension.  */
+  printf ("%Id", i); /* { dg-warning "C" "printf I flag" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-3.c
new file mode 100644
index 000000000..2407bb603
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-printf-3.c
@@ -0,0 +1,39 @@
+/* Test for printf formats.  Test that the C99 functions get their default
+   attributes in strict C99 mode, but the gettext functions do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { ! *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, char *s, size_t n, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5, va_list v6, va_list v7)
+{
+  fprintf (stdout, "%d", i);
+  fprintf (stdout, "%ld", i); /* { dg-warning "format" "fprintf" } */
+  printf ("%d", i);
+  printf ("%ld", i); /* { dg-warning "format" "printf" } */
+  /* The "unlocked" functions shouldn't warn in c99 mode.  */
+  fprintf_unlocked (stdout, "%ld", i); /* { dg-bogus "format" "fprintf_unlocked" } */
+  printf_unlocked ("%ld", i); /* { dg-bogus "format" "printf_unlocked" } */
+  sprintf (s, "%d", i);
+  sprintf (s, "%ld", i); /* { dg-warning "format" "sprintf" } */
+  snprintf (s, n, "%d", i);
+  snprintf (s, n, "%ld", i); /* { dg-warning "format" "snprintf" } */
+  vfprintf (stdout, "%d", v0);
+  vfprintf (stdout, "%Y", v1); /* { dg-warning "format" "vfprintf" } */
+  vprintf ("%d", v0);
+  vprintf ("%Y", v1); /* { dg-warning "format" "vprintf" } */
+  vsprintf (s, "%d", v0);
+  vsprintf (s, "%Y", v1); /* { dg-warning "format" "vsprintf" } */
+  vsnprintf (s, n, "%d", v0);
+  vsnprintf (s, n, "%Y", v1); /* { dg-warning "format" "vsnprintf" } */
+  printf (gettext ("%d"), i);
+  printf (gettext ("%ld"), i);
+  printf (dgettext ("", "%d"), i);
+  printf (dgettext ("", "%ld"), i);
+  printf (dcgettext ("", "%d", 0), i);
+  printf (dcgettext ("", "%ld", 0), i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-1.c
new file mode 100644
index 000000000..7a8b3e245
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-1.c
@@ -0,0 +1,145 @@
+/* Test for scanf formats.  Formats using C99 features, including cases
+   where C99 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int *ip, unsigned int *uip, short int *hp, unsigned short int *uhp,
+     signed char *hhp, unsigned char *uhhp, long int *lp,
+     unsigned long int *ulp, float *fp, double *dp, long double *ldp, char *s,
+     void **pp, int *n, long long *llp, unsigned long long *ullp, wchar_t *ls,
+     short int *hn, signed char *hhn, long int *ln, long long int *lln,
+     intmax_t *jp, uintmax_t *ujp, intmax_t *jn, size_t *zp,
+     signed_size_t *szp, signed_size_t *zn, ptrdiff_t *tp,
+     unsigned_ptrdiff_t *utp, ptrdiff_t *tn)
+{
+  /* See ISO/IEC 9899:1999 (E) subclause 7.19.6.2 (pages 281-288).
+     We do not repeat here most of the checks for correct C90 formats
+     or completely broken formats.
+  */
+  /* Valid, invalid and silly assignment-suppression
+     and width constructions.
+  */
+  scanf ("%*d%*i%*o%*u%*x%*X%*a%*A%*e%*E%*f%*F%*g%*G%*s%*[abc]%*c%*p");
+  scanf ("%*2d%*8s%*3c");
+  scanf ("%*n", n); /* { dg-warning "suppress" "suppression of %n" } */
+  scanf ("%*hd"); /* { dg-warning "together" "suppression with length" } */
+  scanf ("%2d%3i%4o%5u%6x%7X%8a%9A%10e%11E%12f%13F%14g%15G%16s%3[abc]%4c%5p",
+	 ip, ip, uip, uip, uip, uip, fp, fp, fp, fp, fp, fp, fp, fp,
+	 s, s, s, pp);
+  scanf ("%0d", ip); /* { dg-warning "width" "warning for zero width" } */
+  scanf ("%3n", n); /* { dg-warning "width" "width with %n" } */
+  /* Valid and invalid %h, %hh, %l, %ll, %j, %z, %t, %L constructions.  */
+  scanf ("%hd%hi%ho%hu%hx%hX%hn", hp, hp, uhp, uhp, uhp, uhp, hn);
+  scanf ("%ha", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hA", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%he", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hE", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hf", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hF", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hg", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hG", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hs", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%h[ac]", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hc", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hp", pp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hhd%hhi%hho%hhu%hhx%hhX%hhn", hhp, hhp, uhhp, uhhp, uhhp, uhhp,
+	 hhn);
+  scanf ("%hha", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhA", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhe", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhE", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhf", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhF", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhg", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhG", fp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhs", s); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hh[ac]", s); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhc", s); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%hhp", pp); /* { dg-warning "length" "bad use of %hh" } */
+  scanf ("%ld%li%lo%lu%lx%lX%ln", lp, lp, ulp, ulp, ulp, ulp, ln);
+  scanf ("%la%lA%le%lE%lf%lF%lg%lG", dp, dp, dp, dp, dp, dp, dp, dp);
+  scanf ("%lp", pp); /* { dg-warning "length" "bad use of %l" } */
+  scanf ("%ls", ls);
+  scanf ("%l[ac]", ls);
+  scanf ("%lc", ls);
+  scanf ("%lld%lli%llo%llu%llx%llX%lln", llp, llp, ullp, ullp, ullp, ullp,
+	 lln);
+  scanf ("%lla", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llA", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%lle", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llE", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llf", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llF", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llg", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llG", fp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%lls", s); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%ll[ac]", s); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llc", s); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%llp", pp); /* { dg-warning "length" "bad use of %ll" } */
+  scanf ("%jd%ji%jo%ju%jx%jX%jn", jp, jp, ujp, ujp, ujp, ujp, jn); /* { dg-bogus "length" "bogus %j warning" { target *-*-* } } */
+  scanf ("%ja", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jA", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%je", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jE", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jf", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jF", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jg", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jG", fp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%js", s); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%j[ac]", s); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jc", s); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%jp", pp); /* { dg-warning "length" "bad use of %j" } */
+  scanf ("%zd%zi%zo%zu%zx%zX%zn", szp, szp, zp, zp, zp, zp, zn);
+  scanf ("%za", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zA", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%ze", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zE", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zf", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zF", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zg", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zG", fp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zs", s); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%z[ac]", s); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zc", s); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%zp", pp); /* { dg-warning "length" "bad use of %z" } */
+  scanf ("%td%ti%to%tu%tx%tX%tn", tp, tp, utp, utp, utp, utp, tn);
+  scanf ("%ta", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tA", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%te", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tE", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tf", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tF", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tg", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tG", fp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%ts", s); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%t[ac]", s); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tc", s); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%tp", pp); /* { dg-warning "length" "bad use of %t" } */
+  scanf ("%La%LA%Le%LE%Lf%LF%Lg%LG", ldp, ldp, ldp, ldp, ldp, ldp, ldp, ldp);
+  scanf ("%Ld", llp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Li", llp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Lo", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Lu", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Lx", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%LX", ullp); /* { dg-warning "does not support" "bad use of %L" } */
+  scanf ("%Ls", s); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%L[ac]", s); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%Lc", s); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%Lp", pp); /* { dg-warning "length" "bad use of %L" } */
+  scanf ("%Ln", n); /* { dg-warning "length" "bad use of %L" } */
+  /* Valid uses of each bare conversion.  */
+  scanf ("%d%i%o%u%x%X%a%A%e%E%f%F%g%G%s%[abc]%c%p%n%%", ip, ip, uip, uip, uip,
+         uip, fp, fp, fp, fp, fp, fp, fp, fp, s, s, s, pp, n);
+  /* Assert that %as is not treated as an extension in C99 mode.  */
+  scanf ("%as", fp);
+  scanf ("%a[", fp);
+  /* Tests for bad argument types: pointer target sign with %hh.  */
+  scanf ("%hhd", uhhp); /* { dg-warning "format" "%hhd sign" } */
+  scanf ("%hhu", hhp); /* { dg-warning "format" "%hhu sign" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-2.c
new file mode 100644
index 000000000..eedf3e57c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-2.c
@@ -0,0 +1,26 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int *ip, long long int *llp, wchar_t *ls)
+{
+  /* The length modifiers q and L as applied to integer formats are
+     extensions.
+  */
+  scanf ("%qd", llp); /* { dg-warning "C" "%q length" } */
+  scanf ("%Ld", llp); /* { dg-warning "C" "%L length" } */
+  /* The conversion specifiers C and S are X/Open extensions.  */
+  scanf ("%C", ls); /* { dg-warning "C" "scanf %C" } */
+  scanf ("%S", ls); /* { dg-warning "C" "scanf %S" } */
+  /* The use of operand number $ formats is an X/Open extension.  */
+  scanf ("%1$d", ip); /* { dg-warning "C" "scanf $ format" } */
+  /* glibc also supports flags ' and I on scanf formats as an extension.  */
+  scanf ("%'d", ip); /* { dg-warning "C" "scanf ' flag" } */
+  scanf ("%Id", ip); /* { dg-warning "C" "scanf I flag" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-3.c
new file mode 100644
index 000000000..091a3ea95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-3.c
@@ -0,0 +1,32 @@
+/* Test for scanf formats.  Test that the C99 functions get their default
+   attributes in strict C99 mode, but the gettext functions do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int *ip, char *s, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5)
+{
+  fscanf (stdin, "%d", ip);
+  fscanf (stdin, "%ld", ip); /* { dg-warning "format" "fscanf" } */
+  scanf ("%d", ip);
+  scanf ("%ld", ip); /* { dg-warning "format" "scanf" } */
+  sscanf (s, "%d", ip);
+  sscanf (s, "%ld", ip); /* { dg-warning "format" "sscanf" } */
+  vfscanf (stdin, "%d", v0);
+  vfscanf (stdin, "%Y", v1); /* { dg-warning "format" "vfscanf" } */
+  vscanf ("%d", v2);
+  vscanf ("%Y", v3); /* { dg-warning "format" "vscanf" } */
+  vsscanf (s, "%d", v4);
+  vsscanf (s, "%Y", v5); /* { dg-warning "format" "vsscanf" } */
+  scanf (gettext ("%d"), ip);
+  scanf (gettext ("%ld"), ip);
+  scanf (dgettext ("", "%d"), ip);
+  scanf (dgettext ("", "%ld"), ip);
+  scanf (dcgettext ("", "%d", 0), ip);
+  scanf (dcgettext ("", "%ld", 0), ip);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-4.c
new file mode 100644
index 000000000..9c7a5e4b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-scanf-4.c
@@ -0,0 +1,19 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* m assignment-allocation modifier, recognized in both C90
+     and C99 modes, is a POSIX and ISO/IEC WDTR 24731-2 extension.  */
+  scanf ("%ms", sp); /* { dg-warning "C" "%ms" } */
+  scanf ("%mS", lsp); /* { dg-warning "C" "%mS" } */
+  scanf ("%mls", lsp); /* { dg-warning "C" "%mls" } */
+  scanf ("%m[bcd]", sp); /* { dg-warning "C" "%m[]" } */
+  scanf ("%ml[bcd]", lsp); /* { dg-warning "C" "%ml[]" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-strftime-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-strftime-1.c
new file mode 100644
index 000000000..1730738df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-strftime-1.c
@@ -0,0 +1,97 @@
+/* Test for strftime formats.  Formats using C99 features.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat -Wformat-y2k" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.12.3.5 (pages 174-175).  */
+  /* Formats which are Y2K-compliant (no 2-digit years).  */
+  strftime (s, m, "%a%A%b%B%C%d%e%F%G%h%H%I%j%m%M%p%R%S%t%T%u%U%V%w%W%X%Y%z%Z%%", tp);
+  strftime (s, m, "%EC%EX%EY%Od%Oe%OH%OI%Om%OM%OS%Ou%OU%OV%Ow%OW", tp);
+  /* Formats with 2-digit years.  */
+  strftime (s, m, "%D", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  strftime (s, m, "%g", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  strftime (s, m, "%y", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  strftime (s, m, "%Oy", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  /* Formats with 2-digit years in some locales.  */
+  strftime (s, m, "%c", tp); /* { dg-warning "some locales" "2-digit year" } */
+  strftime (s, m, "%Ec", tp); /* { dg-warning "some locales" "2-digit year" } */
+  strftime (s, m, "%x", tp); /* { dg-warning "some locales" "2-digit year" } */
+  strftime (s, m, "%Ex", tp); /* { dg-warning "some locales" "2-digit year" } */
+  /* %Ey is explicitly an era offset not a 2-digit year; but in some
+     locales the E modifier may be ignored.
+  */
+  strftime (s, m, "%Ey", tp); /* { dg-warning "some locales" "2-digit year" } */
+  /* Bad uses of %E and %O.  */
+  strftime (s, m, "%EEY", tp); /* { dg-warning "multiple|repeated" "multiple %E/%O" } */
+  strftime (s, m, "%EOy", tp); /* { dg-warning "multiple|together" "multiple %E/%O" } */
+  strftime (s, m, "%OEy", tp); /* { dg-warning "multiple|together" "multiple %E/%O" } */
+  strftime (s, m, "%OOV", tp); /* { dg-warning "multiple|repeated" "multiple %E/%O" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 31 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 32 } */
+  strftime (s, m, "%Ea", tp); /* { dg-warning "flag|modifier" "bad %Ea" } */
+  strftime (s, m, "%EA", tp); /* { dg-warning "flag|modifier" "bad %EA" } */
+  strftime (s, m, "%Eb", tp); /* { dg-warning "flag|modifier" "bad %Eb" } */
+  strftime (s, m, "%EB", tp); /* { dg-warning "flag|modifier" "bad %EB" } */
+  strftime (s, m, "%Ed", tp); /* { dg-warning "flag|modifier" "bad %Ed" } */
+  strftime (s, m, "%ED", tp); /* { dg-warning "flag|modifier" "bad %ED" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 41 } */
+  strftime (s, m, "%Ee", tp); /* { dg-warning "flag|modifier" "bad %Ee" } */
+  strftime (s, m, "%EF", tp); /* { dg-warning "flag|modifier" "bad %EF" } */
+  strftime (s, m, "%Eg", tp); /* { dg-warning "flag|modifier" "bad %Eg" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 45 } */
+  strftime (s, m, "%EG", tp); /* { dg-warning "flag|modifier" "bad %EG" } */
+  strftime (s, m, "%Eh", tp); /* { dg-warning "flag|modifier" "bad %Eh" } */
+  strftime (s, m, "%EH", tp); /* { dg-warning "flag|modifier" "bad %EH" } */
+  strftime (s, m, "%EI", tp); /* { dg-warning "flag|modifier" "bad %EI" } */
+  strftime (s, m, "%Ej", tp); /* { dg-warning "flag|modifier" "bad %Ej" } */
+  strftime (s, m, "%Em", tp); /* { dg-warning "flag|modifier" "bad %Em" } */
+  strftime (s, m, "%EM", tp); /* { dg-warning "flag|modifier" "bad %EM" } */
+  strftime (s, m, "%En", tp); /* { dg-warning "flag|modifier" "bad %En" } */
+  strftime (s, m, "%Ep", tp); /* { dg-warning "flag|modifier" "bad %Ep" } */
+  strftime (s, m, "%Er", tp); /* { dg-warning "flag|modifier" "bad %Er" } */
+  strftime (s, m, "%ER", tp); /* { dg-warning "flag|modifier" "bad %ER" } */
+  strftime (s, m, "%ES", tp); /* { dg-warning "flag|modifier" "bad %ES" } */
+  strftime (s, m, "%Et", tp); /* { dg-warning "flag|modifier" "bad %Et" } */
+  strftime (s, m, "%ET", tp); /* { dg-warning "flag|modifier" "bad %ET" } */
+  strftime (s, m, "%Eu", tp); /* { dg-warning "flag|modifier" "bad %Eu" } */
+  strftime (s, m, "%EU", tp); /* { dg-warning "flag|modifier" "bad %EU" } */
+  strftime (s, m, "%EV", tp); /* { dg-warning "flag|modifier" "bad %EV" } */
+  strftime (s, m, "%Ew", tp); /* { dg-warning "flag|modifier" "bad %Ew" } */
+  strftime (s, m, "%EW", tp); /* { dg-warning "flag|modifier" "bad %EW" } */
+  strftime (s, m, "%Ez", tp); /* { dg-warning "flag|modifier" "bad %Ez" } */
+  strftime (s, m, "%EZ", tp); /* { dg-warning "flag|modifier" "bad %EZ" } */
+  strftime (s, m, "%E%", tp); /* { dg-warning "flag|modifier" "bad %E%" } */
+  strftime (s, m, "%Oa", tp); /* { dg-warning "flag|modifier" "bad %Oa" } */
+  strftime (s, m, "%OA", tp); /* { dg-warning "flag|modifier" "bad %OA" } */
+  strftime (s, m, "%Ob", tp); /* { dg-warning "flag|modifier" "bad %Ob" } */
+  strftime (s, m, "%OB", tp); /* { dg-warning "flag|modifier" "bad %OB" } */
+  strftime (s, m, "%Oc", tp); /* { dg-warning "flag|modifier" "bad %Oc" } */
+  /* { dg-warning "in some locales" "2-digit year" { target *-*-* } 73 } */
+  strftime (s, m, "%OC", tp); /* { dg-warning "flag|modifier|C" "bad %OC" } */
+  strftime (s, m, "%OD", tp); /* { dg-warning "flag|modifier" "bad %OD" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 76 } */
+  strftime (s, m, "%OF", tp); /* { dg-warning "flag|modifier" "bad %OF" } */
+  strftime (s, m, "%Og", tp); /* { dg-warning "flag|modifier|C" "bad %Og" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 79 } */
+  strftime (s, m, "%OG", tp); /* { dg-warning "flag|modifier|C" "bad %OG" } */
+  strftime (s, m, "%Oh", tp); /* { dg-warning "flag|modifier" "bad %Oh" } */
+  strftime (s, m, "%Oj", tp); /* { dg-warning "flag|modifier|C" "bad %Oj" } */
+  strftime (s, m, "%On", tp); /* { dg-warning "flag|modifier" "bad %On" } */
+  strftime (s, m, "%Op", tp); /* { dg-warning "flag|modifier" "bad %Op" } */
+  strftime (s, m, "%Or", tp); /* { dg-warning "flag|modifier" "bad %Or" } */
+  strftime (s, m, "%OR", tp); /* { dg-warning "flag|modifier" "bad %OR" } */
+  strftime (s, m, "%Ot", tp); /* { dg-warning "flag|modifier" "bad %Ot" } */
+  strftime (s, m, "%OT", tp); /* { dg-warning "flag|modifier" "bad %OT" } */
+  strftime (s, m, "%Ox", tp); /* { dg-warning "flag|modifier" "bad %Ox" } */
+  /* { dg-warning "in some locales" "2-digit year" { target *-*-* } 90 } */
+  strftime (s, m, "%OX", tp); /* { dg-warning "flag|modifier" "bad %OX" } */
+  strftime (s, m, "%OY", tp); /* { dg-warning "flag|modifier|C" "bad %OY" } */
+  strftime (s, m, "%Oz", tp); /* { dg-warning "flag|modifier|C" "bad %Oz" } */
+  strftime (s, m, "%OZ", tp); /* { dg-warning "flag|modifier" "bad %OZ" } */
+  strftime (s, m, "%O%", tp); /* { dg-warning "flag|modifier" "bad %O%" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-strftime-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-strftime-2.c
new file mode 100644
index 000000000..747faa2c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/c99-strftime-2.c
@@ -0,0 +1,23 @@
+/* Test for strftime formats.  Rejection of extensions in pedantic mode.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* %P is a lowercase version of %p.  */
+  strftime (s, m, "%P", tp); /* { dg-warning "C" "strftime %P" } */
+  /* %k is %H but padded with a space rather than 0 if necessary.  */
+  strftime (s, m, "%k", tp); /* { dg-warning "C" "strftime %k" } */
+  /* %l is %I but padded with a space rather than 0 if necessary.  */
+  strftime (s, m, "%l", tp); /* { dg-warning "C" "strftime %l" } */
+  /* %s is the number of seconds since the Epoch.  */
+  strftime (s, m, "%s", tp); /* { dg-warning "C" "strftime %s" } */
+  /* Extensions using %O already tested in c99-strftime-1.c.  */
+  /* Width and flags are GNU extensions for strftime.  */
+  strftime (s, m, "%20Y", tp); /* { dg-warning "C" "strftime width" } */
+  strftime (s, m, "%^A", tp); /* { dg-warning "C" "strftime flags" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/cast-1.c
new file mode 100644
index 000000000..03e624a5c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/cast-1.c
@@ -0,0 +1,16 @@
+/* Test for strings cast through integer types: should not be treated
+   as format strings unless the types are of the same width as
+   pointers (intptr_t or similar).  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+void
+f (int x)
+{
+  printf("%s", x); /* { dg-warning "format" } */
+  printf((char *)(size_t)"%s", x); /* { dg-warning "format" } */
+  printf((char *)(char)"%s", x); /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/cmn-err-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/cmn-err-1.c
new file mode 100644
index 000000000..7e291d35a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/cmn-err-1.c
@@ -0,0 +1,38 @@
+/* { dg-do compile { target *-*-solaris2.* } } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+void cmn_err_func (int level, char * format, ...)
+  __attribute__((format (cmn_err, 2, 3)));
+
+void cmn_err_func (int level, char * format, ...)
+{
+}
+
+const char *string = "foo";
+
+int main()
+{
+  int i = 1;
+  long l = 2;
+  llong ll = 3;
+
+  cmn_err_func (0, "%s", string);
+  cmn_err_func (0, "%d %D %o %O %x %X %u", i, i, i, i, i, i, i);
+  cmn_err_func (0, "%ld %lD %lo %lO %lx %lX %lu", l, l, l, l, l, l, l);
+  cmn_err_func (0, "%lld %llD %llo %llO %llx %llX %llu",
+		ll, ll, ll, ll, ll, ll, ll);
+  cmn_err_func (0, "%b %s", i, "\01Foo", string);
+  cmn_err_func (0, "%p", string);
+  cmn_err_func (0, "%16b", i, "\01Foo");
+
+  cmn_err_func (0, "%i", i);		/* { dg-warning "unknown|too many" } */
+  cmn_err_func (0, "%d", l);		/* { dg-warning "expects type" } */
+  cmn_err_func (0, "%b");		/* { dg-warning "too few" } */
+  cmn_err_func (0, "%b", i);		/* { dg-warning "too few" } */
+  cmn_err_func (0, "%b", i, i);		/* { dg-warning "expects type" } */
+  cmn_err_func (0, "%b", string, i);	/* { dg-warning "expects type" } */
+  cmn_err_func (0, "%p", 3);		/* { dg-warning "expects type" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/dfp-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/dfp-printf-1.c
new file mode 100644
index 000000000..505e4c72f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/dfp-printf-1.c
@@ -0,0 +1,122 @@
+/* Test for printf formats for Decimal Floating Point types.  */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target dfp } */
+/* { dg-options "-Wformat" } */
+
+extern int printf (const char *restrict, ...);
+
+void
+foo (_Decimal32 x, _Decimal64 y, _Decimal128 z, int i, unsigned int j,
+     double d, char *p)
+{
+  /* See ISO/IEC DTR 24732 subclause 9.3 (currently Working Draft 5 from
+      2005-03-06).  */
+  /* Formatted input/output specifiers.  */
+
+  /* Check lack of warnings for valid usage.  */
+
+  printf ("%Hf\n", x);
+  printf ("%HF\n", x);
+  printf ("%He\n", x);
+  printf ("%HE\n", x);
+  printf ("%Hg\n", x);
+  printf ("%HG\n", x);
+
+  printf ("%Df\n", y);
+  printf ("%DF\n", y);
+  printf ("%De\n", y);
+  printf ("%DE\n", y);
+  printf ("%Dg\n", y);
+  printf ("%DG\n", y);
+
+  printf ("%DDf\n", z);
+  printf ("%DDF\n", z);
+  printf ("%DDe\n", z);
+  printf ("%DDE\n", z);
+  printf ("%DDg\n", z);
+  printf ("%DDG\n", z);
+
+  printf ("%DG%DDE%HF%DDe%He%HE%DF%DDF%De%DDG%HG%Df%Hg%DE%DDf%Dg%DDg%Hf\n",
+           y, z, x, z, x, x, y, z, y, z, x, y, x, y, z, y, z, x);
+
+  /* Check warnings for type mismatches.  */
+
+  printf ("%Hf\n", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%HF\n", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%He\n", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%HE\n", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%Hg\n", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%HG\n", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%Hf\n", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%HF\n", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%He\n", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%HE\n", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%Hg\n", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  printf ("%HG\n", z);	/* { dg-warning "expects type" "bad use of %H" } */
+
+  printf ("%Df\n", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%DF\n", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%De\n", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%DE\n", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%Dg\n", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%DG\n", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%Df\n", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%DF\n", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%De\n", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%DE\n", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%Dg\n", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  printf ("%DG\n", z);	/* { dg-warning "expects type" "bad use of %D" } */
+
+  printf ("%DDf\n", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDF\n", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDe\n", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDE\n", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDg\n", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDG\n", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDf\n", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDF\n", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDe\n", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDE\n", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDg\n", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  printf ("%DDG\n", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+
+  /* Check for warnings for bad use of H, D, and DD length specifiers.  */
+
+  printf ("%Hd\n", i);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hi\n", i);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Ho\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hu\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hx\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%HX\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Ha\n", d);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%HA\n", d);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hc\n", i);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hs\n", p);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hp\n", p);	/* { dg-warning "length" "bad use of %H" } */
+  printf ("%Hn\n", p);	/* { dg-warning "length" "bad use of %H" } */
+
+  /* Sanity checks for flags, field width, and precision in formats for
+     DFP types.  */
+
+  printf ("%-Hf\n", x);
+  printf ("%+HF\n", x);
+  printf ("% He\n", x);
+  printf ("%#HE\n", x);
+  printf ("%0Hg\n", x);
+  printf ("%#0HG\n", x);
+
+  printf ("%0#Df\n", y);
+  printf ("%0DF\n", y);
+  printf ("%#De\n", y);
+  printf ("%-#DE\n", y);
+  printf ("%-#0Dg\n", y);  /* { dg-warning "flag ignored" "ignore flag" } */
+  printf ("%0+ DG\n", y);  /* { dg-warning "flag ignored" "ignore flag" } */
+
+  printf ("%DDf\n", z);
+  printf ("%0DDF\n", z);
+  printf ("%#0DDe\n", z);
+  printf ("%+DDE\n", z);
+  printf ("%0-#DDg\n", z); /* { dg-warning "flag ignored" "ignore flag" } */
+  printf ("% DDG\n", z);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/dfp-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/dfp-scanf-1.c
new file mode 100644
index 000000000..6b010a40c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/dfp-scanf-1.c
@@ -0,0 +1,99 @@
+/* Test for scanf formats for Decimal Floating Point types.  */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target dfp } */
+/* { dg-options "-Wformat" } */
+
+
+#include "format.h"
+
+void
+voo (_Decimal32 *x, _Decimal64 *y, _Decimal128 *z, int *i, unsigned int *j,
+     double *d, char **p)
+{
+  /* See ISO/IEC DTR 24732 subclause 9.3 (currently Working Draft 5 from
+      2005-03-06).  */
+  /* Formatted input/output specifiers.  */
+
+  /* Check lack of warnings for valid usage.  */
+
+  scanf ("%Hf", x);
+  scanf ("%HF", x);
+  scanf ("%He", x);
+  scanf ("%HE", x);
+  scanf ("%Hg", x);
+  scanf ("%HG", x);
+
+  scanf ("%Df", y);
+  scanf ("%DF", y);
+  scanf ("%De", y);
+  scanf ("%DE", y);
+  scanf ("%Dg", y);
+  scanf ("%DG", y);
+
+  scanf ("%DDf", z);
+  scanf ("%DDF", z);
+  scanf ("%DDe", z);
+  scanf ("%DDE", z);
+  scanf ("%DDg", z);
+  scanf ("%DDG", z);
+
+  scanf ("%DG%DDE%HF%DDe%He%HE%DF%DDF%De%DDG%HG%Df%Hg%DE%DDf%Dg%DDg%Hf\n",
+           y, z, x, z, x, x, y, z, y, z, x, y, x, y, z, y, z, x);
+
+  /* Check warnings for type mismatches.  */
+
+  scanf ("%Hf", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%HF", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%He", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%HE", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%Hg", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%HG", y);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%Hf", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%HF", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%He", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%HE", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%Hg", z);	/* { dg-warning "expects type" "bad use of %H" } */
+  scanf ("%HG", z);	/* { dg-warning "expects type" "bad use of %H" } */
+
+  scanf ("%Df", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%DF", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%De", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%DE", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%Dg", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%DG", x);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%Df", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%DF", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%De", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%DE", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%Dg", z);	/* { dg-warning "expects type" "bad use of %D" } */
+  scanf ("%DG", z);	/* { dg-warning "expects type" "bad use of %D" } */
+
+  scanf ("%DDf", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDF", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDe", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDE", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDg", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDG", x);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDf", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDF", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDe", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDE", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDg", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+  scanf ("%DDG", y);	/* { dg-warning "expects type" "bad use of %DD" } */
+
+  /* Check for warnings for bad use of H, D, and DD length specifiers.  */
+
+  scanf ("%Hd\n", i);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hi\n", i);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Ho\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hu\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hx\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%HX\n", j);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Ha\n", d);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%HA\n", d);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hc\n", i);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hs\n", p);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hp\n", p);	/* { dg-warning "length" "bad use of %H" } */
+  scanf ("%Hn\n", p);	/* { dg-warning "length" "bad use of %H" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/diag-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/diag-1.c
new file mode 100644
index 000000000..998e35b9b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/diag-1.c
@@ -0,0 +1,18 @@
+/* Test for format diagnostics.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (double d)
+{
+  /* This should get a message referring to `hh', not to `H'.  */
+  printf ("%hhf", d); /* { dg-warning "hh" "%hhf warning" } */
+  /* This should get a message referring to `ll', not to `q'.  */
+  printf ("%llf", d); /* { dg-warning "ll" "%llf warning" } */
+  /* This should get a message referring to 'size_t', not to
+     'unsigned int' or similar.  */
+  printf ("%zu", d); /* { dg-warning "size_t" "size_t format warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/diag-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/diag-2.c
new file mode 100644
index 000000000..e7578d3f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/diag-2.c
@@ -0,0 +1,13 @@
+/* Test for format diagnostics.  Proper type names (bug 1027).  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (double d)
+{
+  printf ("%s", &d); /* { dg-warning "char \\*" "correct arg type" } */
+  scanf ("%zu", &d); /* { dg-warning "size_t \\*" "correct arg type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/errmk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/errmk-1.c
new file mode 100644
index 000000000..77630ab0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/errmk-1.c
@@ -0,0 +1,12 @@
+/* Test for format checking not giving tree checking errors.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+void
+foo (int t)
+{
+  printf ("%*d", u, t); /* { dg-error "undeclared|function" "u undeclared error" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-1.c
new file mode 100644
index 000000000..3b020892a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-1.c
@@ -0,0 +1,126 @@
+/* Test for format extensions beyond the C standard and X/Open standard.
+   Test for printf formats.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (quad_t q, u_quad_t uq, quad_t *qn, size_t z, size_t *zn, long long int ll,
+     unsigned long long int ull, int i, unsigned int u, double d,
+     char *s, void *p, wchar_t *ls, wint_t lc, int *n, long int l)
+{
+  /* As an extension, GCC allows the BSD length "q" for integer formats.
+     This is largely obsoleted in C99 by %j, %ll and PRId64.
+  */
+  printf ("%qd%qi%qo%qu%qx%qX%qn", q, q, uq, uq, uq, uq, qn);
+  printf ("%qf", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qF", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qe", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qE", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qg", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qG", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qa", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qA", d); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qc", i); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qs", s); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qp", p); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qC", lc); /* { dg-warning "length" "bad use of %q" } */
+  printf ("%qS", ls); /* { dg-warning "length" "bad use of %q" } */
+  /* With a bad length GCC wants some argument, any argument,
+     to devour with the format conversion, as a synchronisation heuristic.
+     This may get improved later.
+  */
+  printf ("%qm", i); /* { dg-warning "length" "bad use of %q" } */
+  /* As an extension, GCC allows the length "Z" as a synonym for "z".
+     This was an extension predating C99 which should now be considered
+     deprecated; use the standard "z" instead.
+  */
+  printf ("%Zd%Zi%Zo%Zu%Zx%ZX", z, z, z, z, z, z);
+  printf ("%Zn", zn);
+  printf ("%Zf", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%ZF", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Ze", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%ZE", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Zg", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%ZG", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Za", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%ZA", d); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Zc", i); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Zs", s); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Zp", p); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%ZC", lc); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%ZS", ls); /* { dg-warning "length" "bad use of %Z" } */
+  printf ("%Zm", i); /* { dg-warning "length" "bad use of %Z" } */
+  /* As an extension, GCC allows the length "L" on integer formats
+     (but not %n) as a synonym for "ll".
+     This should be considered deprecated.
+  */
+  printf ("%Ld%Li%Lo%Lu%Lx%LX", ll, ll, ull, ull, ull, ull);
+  /* As an extension, derived from syslog, GCC allows the conversion
+     specifier "m" for formatting strerror(errno).  This may be used
+     with width, precision and the "-" flag, the same as %s.
+  */
+  printf ("%m%3m%.4m%5.6m");
+  printf ("%*m", i);
+  printf ("%.*m", i);
+  printf ("%*.*m", i, i);
+  printf ("%3.*m", i);
+  printf ("%*.4m", i);
+  printf ("%-m");
+  printf ("%+m"); /* { dg-warning "flag" "bad %+m" } */
+  printf ("% m"); /* { dg-warning "flag" "bad % m" } */
+  printf ("%#m"); /* { dg-warning "flag" "bad %#m" } */
+  printf ("%0m"); /* { dg-warning "flag" "bad %0m" } */
+  printf ("%'m"); /* { dg-warning "flag" "bad %'m" } */
+  printf ("%hm", i); /* { dg-warning "length" "bad %hm" } */
+  printf ("%hhm", i); /* { dg-warning "length" "bad %hhm" } */
+  printf ("%lm", i); /* { dg-warning "length" "bad %lm" } */
+  printf ("%llm", i); /* { dg-warning "length" "bad %llm" } */
+  printf ("%jm", i); /* { dg-warning "length" "bad %jm" } */
+  printf ("%zm", i); /* { dg-warning "length" "bad %zm" } */
+  printf ("%tm", i); /* { dg-warning "length" "bad %tm" } */
+  printf ("%Lm", i); /* { dg-warning "length" "bad %Lm" } */
+  printf ("%qm", i); /* { dg-warning "length" "bad %qm" } */
+  printf ("%Zm", i); /* { dg-warning "length" "bad %Zm" } */
+  /* It should be OK to mix %m formats with $ operand number formats.  */
+  printf ("%2$ld%m%1$d", i, l);
+  /* Likewise, %m formats with width and precision should not have an
+     operand number for the %m itself.
+  */
+  printf ("%*2$.*1$m", i, i);
+  printf ("%1$*2$.*1$m", i, i); /* { dg-warning "no argument" "printf %1\$m" } */
+  /* As an extension, glibc includes the "I" flag for decimal
+     formats, to output using the locale's digits (e.g. in Arabic).
+     In GCC, we require this to be in the standard place for flags, though
+     glibc allows it also after width or precision.
+  */
+  printf ("%Id%Ii%Iu", i, i, u);
+  printf ("%Io", u); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%Ix", u); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%IX", u); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%In", n); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%If", d);
+  printf ("%IF", d);
+  printf ("%Ie", d);
+  printf ("%IE", d);
+  printf ("%Ig", d);
+  printf ("%IG", d);
+  printf ("%Ia", d); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%IA", d); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%Ic", i); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%Is", s); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%Ip", p); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%IC", lc); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%IS", ls); /* { dg-warning "flag" "bad use of I flag" } */
+  printf ("%Im"); /* { dg-warning "flag" "bad use of I flag" } */
+
+  /* As an extension, GCC does format checking on "unlocked"
+     i.e. thread unsafe versions of these functions.  */
+  fprintf_unlocked (stdout, "%d", i);
+  fprintf_unlocked (stdout, "%ld", i); /* { dg-warning "format" "fprintf_unlocked" } */
+  printf_unlocked ("%d", i);
+  printf_unlocked ("%ld", i); /* { dg-warning "format" "printf_unlocked" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-2.c
new file mode 100644
index 000000000..466991b59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-2.c
@@ -0,0 +1,73 @@
+/* Test for format extensions beyond the C standard and X/Open standard.
+   Test for scanf formats.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (quad_t *qp, u_quad_t *uqp, quad_t *qn, long long int *llp,
+     unsigned long long int *ullp, float *fp, char *s, void **pp, wchar_t *ls,
+     int *ip, unsigned int *up)
+{
+  /* As an extension, GCC allows the BSD length "q" for integer formats.
+     This is largely obsoleted in C99 by %j, %ll and SCNd64.
+  */
+  scanf ("%qd%qi%qo%qu%qx%qX%qn", qp, qp, uqp, uqp, uqp, uqp, qn);
+  scanf ("%qf", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qF", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qe", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qE", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qg", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qG", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qa", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qA", fp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qs", s); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%q[abc]", s); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qc", s); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qp", pp); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qC", ls); /* { dg-warning "length" "bad use of %q" } */
+  scanf ("%qS", ls); /* { dg-warning "length" "bad use of %q" } */
+  /* As an extension, GCC allows the length "L" on integer formats
+     (but not %n) as a synonym for "ll".
+     This should be considered deprecated.
+  */
+  scanf ("%Ld%Li%Lo%Lu%Lx%LX", llp, llp, ullp, ullp, ullp, ullp);
+  /* glibc also supports flags ' and I on scanf formats.  The ' flag applies
+     to all formats scanning decimal values; the I flag only to decimal integer
+     formats.
+  */
+  scanf ("%'d%'i%'u%'a%'A%'e%'E%'f%'F%'g%'G", ip, ip, up, fp, fp, fp, fp,
+	 fp, fp, fp, fp);
+  scanf ("%'o", up); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'x", up); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'X", up); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'n", ip); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'s", s); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'[abc]", s); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'c", s); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'p", pp); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'C", ls); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%'S", ls); /* { dg-warning "flag" "bad use of ' flag" } */
+  scanf ("%Id%Ii%Iu", ip, ip, up);
+  scanf ("%Ia", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IA", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Ie", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IE", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%If", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IF", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Ig", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IG", fp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Io", up); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Ix", up); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IX", up); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%In", ip); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Is", s); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%I[abc]", s); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Ic", s); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%Ip", pp); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IC", ls); /* { dg-warning "flag" "bad use of I flag" } */
+  scanf ("%IS", ls); /* { dg-warning "flag" "bad use of I flag" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-3.c
new file mode 100644
index 000000000..937e11212
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-3.c
@@ -0,0 +1,216 @@
+/* Test for format extensions beyond the C standard and X/Open standard.
+   Test for strftime formats.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-y2k" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* GCC accepts the "-", "_" and "0" flags to control padding on numeric
+     formats.  It also accepts width on these formats.
+  */
+  /* Basic tests of parts on their own.  */
+  strftime (s, m, "%5C%-C%_C%0C", tp);
+  /* Correct usages.  */
+  strftime (s, m, "%-5C%_5C%05C%-5d%_5d%05d%-5e%_5e%05e%-5G%_5G%05G", tp);
+  strftime (s, m, "%-5H%_5H%05H%-5I%_5I%05I%-5j%_5j%05j%-5m%_5m%05m", tp);
+  strftime (s, m, "%-5M%_5M%05M%-5S%_5S%05S%-5u%_5u%05u%-5U%_5U%05U", tp);
+  strftime (s, m, "%-5V%_5V%05V%-5w%_5w%05w%-5W%_5W%05W%-5Y%_5Y%05Y", tp);
+  /* Correct usages with GNU extension conversion characters.  */
+  strftime (s, m, "%-5k%_5k%05k%-5l%_5l%05l%-20s%_20s%020s", tp);
+  /* Correct usages with Y2K problems.  */
+  strftime (s, m, "%-5g%_5g%05g%-5y%_5y%05y", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  /* Incorrect usages.  */
+  strftime (s, m, "%5a", tp); /* { dg-warning "width" "bad %a" } */
+  strftime (s, m, "%-a", tp); /* { dg-warning "flag" "bad %a" } */
+  strftime (s, m, "%_a", tp); /* { dg-warning "flag" "bad %a" } */
+  strftime (s, m, "%0a", tp); /* { dg-warning "flag" "bad %a" } */
+  strftime (s, m, "%5A", tp); /* { dg-warning "width" "bad %A" } */
+  strftime (s, m, "%-A", tp); /* { dg-warning "flag" "bad %A" } */
+  strftime (s, m, "%_A", tp); /* { dg-warning "flag" "bad %A" } */
+  strftime (s, m, "%0A", tp); /* { dg-warning "flag" "bad %A" } */
+  strftime (s, m, "%5b", tp); /* { dg-warning "width" "bad %b" } */
+  strftime (s, m, "%-b", tp); /* { dg-warning "flag" "bad %b" } */
+  strftime (s, m, "%_b", tp); /* { dg-warning "flag" "bad %b" } */
+  strftime (s, m, "%0b", tp); /* { dg-warning "flag" "bad %b" } */
+  strftime (s, m, "%5B", tp); /* { dg-warning "width" "bad %B" } */
+  strftime (s, m, "%-B", tp); /* { dg-warning "flag" "bad %B" } */
+  strftime (s, m, "%_B", tp); /* { dg-warning "flag" "bad %B" } */
+  strftime (s, m, "%0B", tp); /* { dg-warning "flag" "bad %B" } */
+  strftime (s, m, "%5F", tp); /* { dg-warning "width" "bad %F" } */
+  strftime (s, m, "%-F", tp); /* { dg-warning "flag" "bad %F" } */
+  strftime (s, m, "%_F", tp); /* { dg-warning "flag" "bad %F" } */
+  strftime (s, m, "%0F", tp); /* { dg-warning "flag" "bad %F" } */
+  strftime (s, m, "%5h", tp); /* { dg-warning "width" "bad %h" } */
+  strftime (s, m, "%-h", tp); /* { dg-warning "flag" "bad %h" } */
+  strftime (s, m, "%_h", tp); /* { dg-warning "flag" "bad %h" } */
+  strftime (s, m, "%0h", tp); /* { dg-warning "flag" "bad %h" } */
+  strftime (s, m, "%5n", tp); /* { dg-warning "width" "bad %n" } */
+  strftime (s, m, "%-n", tp); /* { dg-warning "flag" "bad %n" } */
+  strftime (s, m, "%_n", tp); /* { dg-warning "flag" "bad %n" } */
+  strftime (s, m, "%0n", tp); /* { dg-warning "flag" "bad %n" } */
+  strftime (s, m, "%5p", tp); /* { dg-warning "width" "bad %p" } */
+  strftime (s, m, "%-p", tp); /* { dg-warning "flag" "bad %p" } */
+  strftime (s, m, "%_p", tp); /* { dg-warning "flag" "bad %p" } */
+  strftime (s, m, "%0p", tp); /* { dg-warning "flag" "bad %p" } */
+  strftime (s, m, "%5r", tp); /* { dg-warning "width" "bad %r" } */
+  strftime (s, m, "%-r", tp); /* { dg-warning "flag" "bad %r" } */
+  strftime (s, m, "%_r", tp); /* { dg-warning "flag" "bad %r" } */
+  strftime (s, m, "%0r", tp); /* { dg-warning "flag" "bad %r" } */
+  strftime (s, m, "%5R", tp); /* { dg-warning "width" "bad %R" } */
+  strftime (s, m, "%-R", tp); /* { dg-warning "flag" "bad %R" } */
+  strftime (s, m, "%_R", tp); /* { dg-warning "flag" "bad %R" } */
+  strftime (s, m, "%0R", tp); /* { dg-warning "flag" "bad %R" } */
+  strftime (s, m, "%5t", tp); /* { dg-warning "width" "bad %t" } */
+  strftime (s, m, "%-t", tp); /* { dg-warning "flag" "bad %t" } */
+  strftime (s, m, "%_t", tp); /* { dg-warning "flag" "bad %t" } */
+  strftime (s, m, "%0t", tp); /* { dg-warning "flag" "bad %t" } */
+  strftime (s, m, "%5T", tp); /* { dg-warning "width" "bad %T" } */
+  strftime (s, m, "%-T", tp); /* { dg-warning "flag" "bad %T" } */
+  strftime (s, m, "%_T", tp); /* { dg-warning "flag" "bad %T" } */
+  strftime (s, m, "%0T", tp); /* { dg-warning "flag" "bad %T" } */
+  strftime (s, m, "%5X", tp); /* { dg-warning "width" "bad %X" } */
+  strftime (s, m, "%-X", tp); /* { dg-warning "flag" "bad %X" } */
+  strftime (s, m, "%_X", tp); /* { dg-warning "flag" "bad %X" } */
+  strftime (s, m, "%0X", tp); /* { dg-warning "flag" "bad %X" } */
+  strftime (s, m, "%5z", tp); /* { dg-warning "width" "bad %z" } */
+  strftime (s, m, "%-z", tp); /* { dg-warning "flag" "bad %z" } */
+  strftime (s, m, "%_z", tp); /* { dg-warning "flag" "bad %z" } */
+  strftime (s, m, "%0z", tp); /* { dg-warning "flag" "bad %z" } */
+  strftime (s, m, "%5Z", tp); /* { dg-warning "width" "bad %Z" } */
+  strftime (s, m, "%-Z", tp); /* { dg-warning "flag" "bad %Z" } */
+  strftime (s, m, "%_Z", tp); /* { dg-warning "flag" "bad %Z" } */
+  strftime (s, m, "%0Z", tp); /* { dg-warning "flag" "bad %Z" } */
+  /* Incorrect usages with Y2K problems.  */
+  strftime (s, m, "%5c", tp); /* { dg-warning "width" "bad %c" } */
+  strftime (s, m, "%-c", tp); /* { dg-warning "flag" "bad %c" } */
+  strftime (s, m, "%_c", tp); /* { dg-warning "flag" "bad %c" } */
+  strftime (s, m, "%0c", tp); /* { dg-warning "flag" "bad %c" } */
+  strftime (s, m, "%5D", tp); /* { dg-warning "width" "bad %D" } */
+  strftime (s, m, "%-D", tp); /* { dg-warning "flag" "bad %D" } */
+  strftime (s, m, "%_D", tp); /* { dg-warning "flag" "bad %D" } */
+  strftime (s, m, "%0D", tp); /* { dg-warning "flag" "bad %D" } */
+  strftime (s, m, "%5x", tp); /* { dg-warning "width" "bad %x" } */
+  strftime (s, m, "%-x", tp); /* { dg-warning "flag" "bad %x" } */
+  strftime (s, m, "%_x", tp); /* { dg-warning "flag" "bad %x" } */
+  strftime (s, m, "%0x", tp); /* { dg-warning "flag" "bad %x" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 89 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 90 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 91 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 92 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 93 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 94 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 95 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 96 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 97 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 98 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 99 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 100 } */
+  /* Incorrect usages with GNU extension conversion characters.  */
+  strftime (s, m, "%5P", tp); /* { dg-warning "width" "bad %P" } */
+  strftime (s, m, "%-P", tp); /* { dg-warning "flag" "bad %P" } */
+  strftime (s, m, "%_P", tp); /* { dg-warning "flag" "bad %P" } */
+  strftime (s, m, "%0P", tp); /* { dg-warning "flag" "bad %P" } */
+  /* The "^" and "#" flags control the case of the output.
+     ^ (uppercase) makes sense on aAbBhZ; # (change case) makes sense
+     on the same and on p.
+  */
+  strftime (s, m, "%^a%#a%^A%#A%^b%#b%^B%#B%^h%#h%^Z%#Z%#p", tp);
+  /* Bad usages.  */
+  strftime (s, m, "%^C", tp); /* { dg-warning "flag" "bad %C" } */
+  strftime (s, m, "%#C", tp); /* { dg-warning "flag" "bad %C" } */
+  strftime (s, m, "%^d", tp); /* { dg-warning "flag" "bad %d" } */
+  strftime (s, m, "%#d", tp); /* { dg-warning "flag" "bad %d" } */
+  strftime (s, m, "%^e", tp); /* { dg-warning "flag" "bad %e" } */
+  strftime (s, m, "%#e", tp); /* { dg-warning "flag" "bad %e" } */
+  strftime (s, m, "%^F", tp); /* { dg-warning "flag" "bad %F" } */
+  strftime (s, m, "%#F", tp); /* { dg-warning "flag" "bad %F" } */
+  strftime (s, m, "%^G", tp); /* { dg-warning "flag" "bad %G" } */
+  strftime (s, m, "%#G", tp); /* { dg-warning "flag" "bad %G" } */
+  strftime (s, m, "%^H", tp); /* { dg-warning "flag" "bad %H" } */
+  strftime (s, m, "%#H", tp); /* { dg-warning "flag" "bad %H" } */
+  strftime (s, m, "%^I", tp); /* { dg-warning "flag" "bad %I" } */
+  strftime (s, m, "%#I", tp); /* { dg-warning "flag" "bad %I" } */
+  strftime (s, m, "%^j", tp); /* { dg-warning "flag" "bad %j" } */
+  strftime (s, m, "%#j", tp); /* { dg-warning "flag" "bad %j" } */
+  strftime (s, m, "%^m", tp); /* { dg-warning "flag" "bad %m" } */
+  strftime (s, m, "%#m", tp); /* { dg-warning "flag" "bad %m" } */
+  strftime (s, m, "%^M", tp); /* { dg-warning "flag" "bad %M" } */
+  strftime (s, m, "%#M", tp); /* { dg-warning "flag" "bad %M" } */
+  strftime (s, m, "%^n", tp); /* { dg-warning "flag" "bad %n" } */
+  strftime (s, m, "%#n", tp); /* { dg-warning "flag" "bad %n" } */
+  strftime (s, m, "%^p", tp); /* { dg-warning "flag" "bad %p" } */
+  strftime (s, m, "%^r", tp); /* { dg-warning "flag" "bad %r" } */
+  strftime (s, m, "%#r", tp); /* { dg-warning "flag" "bad %r" } */
+  strftime (s, m, "%^R", tp); /* { dg-warning "flag" "bad %R" } */
+  strftime (s, m, "%#R", tp); /* { dg-warning "flag" "bad %R" } */
+  strftime (s, m, "%^S", tp); /* { dg-warning "flag" "bad %S" } */
+  strftime (s, m, "%#S", tp); /* { dg-warning "flag" "bad %S" } */
+  strftime (s, m, "%^t", tp); /* { dg-warning "flag" "bad %t" } */
+  strftime (s, m, "%#t", tp); /* { dg-warning "flag" "bad %t" } */
+  strftime (s, m, "%^T", tp); /* { dg-warning "flag" "bad %T" } */
+  strftime (s, m, "%#T", tp); /* { dg-warning "flag" "bad %T" } */
+  strftime (s, m, "%^u", tp); /* { dg-warning "flag" "bad %u" } */
+  strftime (s, m, "%#u", tp); /* { dg-warning "flag" "bad %u" } */
+  strftime (s, m, "%^U", tp); /* { dg-warning "flag" "bad %U" } */
+  strftime (s, m, "%#U", tp); /* { dg-warning "flag" "bad %U" } */
+  strftime (s, m, "%^V", tp); /* { dg-warning "flag" "bad %V" } */
+  strftime (s, m, "%#V", tp); /* { dg-warning "flag" "bad %V" } */
+  strftime (s, m, "%^w", tp); /* { dg-warning "flag" "bad %w" } */
+  strftime (s, m, "%#w", tp); /* { dg-warning "flag" "bad %w" } */
+  strftime (s, m, "%^W", tp); /* { dg-warning "flag" "bad %W" } */
+  strftime (s, m, "%#W", tp); /* { dg-warning "flag" "bad %W" } */
+  strftime (s, m, "%^X", tp); /* { dg-warning "flag" "bad %X" } */
+  strftime (s, m, "%#X", tp); /* { dg-warning "flag" "bad %X" } */
+  strftime (s, m, "%^Y", tp); /* { dg-warning "flag" "bad %Y" } */
+  strftime (s, m, "%#Y", tp); /* { dg-warning "flag" "bad %Y" } */
+  strftime (s, m, "%^z", tp); /* { dg-warning "flag" "bad %z" } */
+  strftime (s, m, "%#z", tp); /* { dg-warning "flag" "bad %z" } */
+  strftime (s, m, "%^P", tp); /* { dg-warning "flag" "bad %P" } */
+  strftime (s, m, "%#P", tp); /* { dg-warning "flag" "bad %P" } */
+  strftime (s, m, "%^k", tp); /* { dg-warning "flag" "bad %k" } */
+  strftime (s, m, "%#k", tp); /* { dg-warning "flag" "bad %k" } */
+  strftime (s, m, "%^l", tp); /* { dg-warning "flag" "bad %l" } */
+  strftime (s, m, "%#l", tp); /* { dg-warning "flag" "bad %l" } */
+  strftime (s, m, "%^s", tp); /* { dg-warning "flag" "bad %s" } */
+  strftime (s, m, "%#s", tp); /* { dg-warning "flag" "bad %s" } */
+  /* Bad usages with Y2K problems.  */
+  strftime (s, m, "%^c", tp); /* { dg-warning "flag" "bad %c" } */
+  strftime (s, m, "%#c", tp); /* { dg-warning "flag" "bad %c" } */
+  strftime (s, m, "%^D", tp); /* { dg-warning "flag" "bad %D" } */
+  strftime (s, m, "%#D", tp); /* { dg-warning "flag" "bad %D" } */
+  strftime (s, m, "%^g", tp); /* { dg-warning "flag" "bad %g" } */
+  strftime (s, m, "%#g", tp); /* { dg-warning "flag" "bad %g" } */
+  strftime (s, m, "%^x", tp); /* { dg-warning "flag" "bad %x" } */
+  strftime (s, m, "%#x", tp); /* { dg-warning "flag" "bad %x" } */
+  strftime (s, m, "%^y", tp); /* { dg-warning "flag" "bad %y" } */
+  strftime (s, m, "%#y", tp); /* { dg-warning "flag" "bad %y" } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 182 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 183 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 184 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 185 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 186 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 187 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 188 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 189 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 190 } */
+  /* { dg-warning "only last 2" "2-digit year" { target *-*-* } 191 } */
+  /* GCC also accepts the glibc format extensions %P, %k, %l, %s.  */
+  strftime (s, m, "%P%k%l%s", tp);
+  /* GCC also accepts the glibc extension of the "O" modifier on some
+     more formats.  The cases where it is rejected altogether are
+     covered in c99-strftime-1.c, except for the extension %P.
+  */
+  strftime (s, m, "%OC%Og%OG%Oj%OY%Oz%Ok%Ol%Os", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  strftime (s, m, "%OP", tp); /* { dg-warning "flag|modifier" "bad %OP" } */
+  /* The "-", "_" and "0" flags are mutually exclusive.  */
+  strftime (s, m, "%-_5C", tp); /* { dg-warning "flag" "bad %-_" } */
+  strftime (s, m, "%-05C", tp); /* { dg-warning "flag" "bad %-0" } */
+  strftime (s, m, "%_05C", tp); /* { dg-warning "flag" "bad %_0" } */
+  /* The "#" and "^" flags are mutually exclusive.  */
+  strftime (s, m, "%^#a", tp); /* { dg-warning "flag" "bad %^#" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-4.c
new file mode 100644
index 000000000..c11c0ada7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-4.c
@@ -0,0 +1,18 @@
+/* Test for scanf formats.  %a extensions.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* %a formats for allocation, only recognized in C90 mode, are a
+     GNU extension.  Followed by other characters, %a is not treated
+     specially.
+  */
+  scanf ("%as", sp);
+  scanf ("%aS", lsp);
+  scanf ("%a[bcd]", sp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-5.c
new file mode 100644
index 000000000..eebc7faa3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-5.c
@@ -0,0 +1,17 @@
+/* Test for gettext default attributes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, long l)
+{
+  printf (gettext ("%d"), i);
+  printf (gettext ("%ld"), i); /* { dg-warning "format" "gettext" } */
+  printf (dgettext ("", "%d"), i);
+  printf (dgettext ("", "%ld"), i); /* { dg-warning "format" "dgettext" } */
+  printf (dcgettext ("", "%d", 0), i);
+  printf (dcgettext ("", "%ld", 0), i); /* { dg-warning "format" "dcgettext" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-6.c
new file mode 100644
index 000000000..08d24cbf7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-6.c
@@ -0,0 +1,47 @@
+/* Test for format extensions.  Test that the C99 functions get their
+   default attributes in gnu89 mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, char *s, size_t n, int *ip, va_list v0, va_list v1, va_list v2,
+     va_list v3, va_list v4, va_list v5, va_list v6, va_list v7, va_list v8,
+     va_list v9, va_list v10, va_list v11, va_list v12, va_list v13)
+{
+  fprintf (stdout, "%d", i);
+  fprintf (stdout, "%ld", i); /* { dg-warning "format" "fprintf" } */
+  printf ("%d", i);
+  printf ("%ld", i); /* { dg-warning "format" "printf" } */
+  fprintf_unlocked (stdout, "%d", i);
+  fprintf_unlocked (stdout, "%ld", i); /* { dg-warning "format" "fprintf_unlocked" } */
+  printf_unlocked ("%d", i);
+  printf_unlocked ("%ld", i); /* { dg-warning "format" "printf_unlocked" } */
+  sprintf (s, "%d", i);
+  sprintf (s, "%ld", i); /* { dg-warning "format" "sprintf" } */
+  snprintf (s, n, "%d", i);
+  snprintf (s, n, "%ld", i); /* { dg-warning "format" "snprintf" } */
+  vfprintf (stdout, "%d", v0);
+  vfprintf (stdout, "%Y", v1); /* { dg-warning "format" "vfprintf" } */
+  vprintf ("%d", v2);
+  vprintf ("%Y", v3); /* { dg-warning "format" "vprintf" } */
+  vsprintf (s, "%d", v4);
+  vsprintf (s, "%Y", v5); /* { dg-warning "format" "vsprintf" } */
+  vsnprintf (s, n, "%d", v6);
+  vsnprintf (s, n, "%Y", v7); /* { dg-warning "format" "vsnprintf" } */
+  fscanf (stdin, "%d", ip);
+  fscanf (stdin, "%ld", ip); /* { dg-warning "format" "fscanf" } */
+  scanf ("%d", ip);
+  scanf ("%ld", ip); /* { dg-warning "format" "scanf" } */
+  sscanf (s, "%d", ip);
+  sscanf (s, "%ld", ip); /* { dg-warning "format" "sscanf" } */
+  vfscanf (stdin, "%d", v8);
+  vfscanf (stdin, "%Y", v9); /* { dg-warning "format" "vfscanf" } */
+  vscanf ("%d", v10);
+  vscanf ("%Y", v11); /* { dg-warning "format" "vscanf" } */
+  vsscanf (s, "%d", v12);
+  vsscanf (s, "%Y", v13); /* { dg-warning "format" "vsscanf" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-7.c
new file mode 100644
index 000000000..d9bd0e8ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-7.c
@@ -0,0 +1,85 @@
+/* Test for scanf formats.  %a and %m extensions.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp, int *ip, float *fp, void **pp, double *dp)
+{
+  /* %a formats for allocation, only recognized in C90 mode, are a
+     GNU extension.  Followed by other characters, %a is not treated
+     specially.
+  */
+  scanf ("%as", sp);
+  scanf ("%aS", lsp);
+  scanf ("%las", dp);
+  scanf ("%la", lsp);	/* { dg-warning "but argument 2 has type" } */
+  scanf ("%las", lsp);	/* { dg-warning "but argument 2 has type" } */
+  scanf ("%a[bcd]", sp);
+  scanf ("%la[bcd]", dp);
+  scanf ("%*as");
+  scanf ("%*aS");
+  scanf ("%*las");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*a[bcd]");
+  scanf ("%*la[bcd]");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%10as", sp);
+  scanf ("%5aS", lsp);
+  scanf ("%9las", dp);
+  scanf ("%25a[bcd]", sp);
+  scanf ("%48la[bcd]", dp);
+  scanf ("%*10as");
+  scanf ("%*5aS");
+  scanf ("%*9las");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*25a[bcd]");
+  scanf ("%*48la[bcd]"); /* { dg-warning "assignment suppression and length modifier" } */
+
+  /* m assignment-allocation modifier, recognized in both C90
+     and C99 modes, is a POSIX and ISO/IEC WDTR 24731-2 extension.  */
+  scanf ("%ms", sp);
+  scanf ("%mS", lsp);
+  scanf ("%mls", lsp);
+  scanf ("%m[bcd]", sp);
+  scanf ("%ml[bcd]", lsp);
+  scanf ("%mc", sp);
+  scanf ("%mlc", lsp);
+  scanf ("%mC", lsp);
+  scanf ("%*ms");
+  scanf ("%*mS");
+  scanf ("%*mls");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*m[bcd]");
+  scanf ("%*ml[bcd]");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*mc");
+  scanf ("%*mlc");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*mC");
+  scanf ("%10ms", sp);
+  scanf ("%5mS", lsp);
+  scanf ("%9mls", lsp);
+  scanf ("%25m[bcd]", sp);
+  scanf ("%41ml[bcd]", lsp);
+  scanf ("%131mc", sp);
+  scanf ("%27mlc", lsp);
+  scanf ("%2mC", lsp);
+  scanf ("%*10ms");
+  scanf ("%*5mS");
+  scanf ("%*9mls");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*25m[bcd]");
+  scanf ("%*41ml[bcd]"); /* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*131mc");
+  scanf ("%*27mlc");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*2mC");
+
+  scanf ("%md", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mi", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mo", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mu", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mx", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%me", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mf", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mg", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mp", pp);	/* { dg-warning "flag used with" } */
+
+  scanf ("%mas", sp);	/* { dg-warning "flag together" } */
+  scanf ("%maS", lsp);	/* { dg-warning "flag together" } */
+  scanf ("%ma[bcd]", sp);	/* { dg-warning "flag together" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-8.c
new file mode 100644
index 000000000..b50cc81d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ext-8.c
@@ -0,0 +1,56 @@
+/* Test for scanf formats.  %m extensions.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp, int *ip, float *fp, void **pp)
+{
+  /* m assignment-allocation modifier, recognized in both C90
+     and C99 modes, is a POSIX and ISO/IEC WDTR 24731-2 extension.  */
+  scanf ("%ms", sp);
+  scanf ("%mS", lsp);
+  scanf ("%mls", lsp);
+  scanf ("%m[bcd]", sp);
+  scanf ("%ml[bcd]", lsp);
+  scanf ("%mc", sp);
+  scanf ("%mlc", lsp);
+  scanf ("%mC", lsp);
+  scanf ("%*ms");
+  scanf ("%*mS");
+  scanf ("%*mls");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*m[bcd]");
+  scanf ("%*ml[bcd]");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*mc");
+  scanf ("%*mlc");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*mC");
+  scanf ("%10ms", sp);
+  scanf ("%5mS", lsp);
+  scanf ("%9mls", lsp);
+  scanf ("%25m[bcd]", sp);
+  scanf ("%41ml[bcd]", lsp);
+  scanf ("%131mc", sp);
+  scanf ("%27mlc", lsp);
+  scanf ("%2mC", lsp);
+  scanf ("%*10ms");
+  scanf ("%*5mS");
+  scanf ("%*9mls");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*25m[bcd]");
+  scanf ("%*41ml[bcd]"); /* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*131mc");
+  scanf ("%*27mlc");	/* { dg-warning "assignment suppression and length modifier" } */
+  scanf ("%*2mC");
+
+  scanf ("%md", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mi", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mo", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mu", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%mx", ip);	/* { dg-warning "flag used with" } */
+  scanf ("%ma", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mA", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%me", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mf", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mg", fp);	/* { dg-warning "flag used with" } */
+  scanf ("%mp", pp);	/* { dg-warning "flag used with" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/format.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/format.exp
new file mode 100644
index 000000000..352149850
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/format.exp
@@ -0,0 +1,34 @@
+#   Copyright (C) 1997, 2000, 2001, 2007 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/>.
+
+# Don't run this directory with any default CFLAGS, but run tests with
+# and without -DWIDE.
+
+# Need to copy the format.h header.
+if [is_remote host] {
+    remote_download host $srcdir/$subdir/format.h
+}
+
+load_lib gcc-dg.exp
+load_lib torture-options.exp
+
+torture-init
+set-torture-options [list { } { -DWIDE } ]
+
+dg-init
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] ""
+torture-finish
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/format.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/format.h
new file mode 100644
index 000000000..a99927e3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/format.h
@@ -0,0 +1,192 @@
+/* Format checking tests: common header.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+
+/* DONT_GNU_PROTOTYPE */
+#if defined (_WIN32) && !defined (__CYGWIN__)
+#if !defined (USE_SYSTEM_FORMATS)
+#define gnu_attr_printf	gnu_printf
+#define gnu_attr___printf__ __gnu_printf__
+#define gnu_attr_scanf	gnu_scanf
+#define gnu_attr___scanf__ __gnu_scanf__
+#define gnu_attr_strftime gnu_strftime
+#define gnu_attr___strftime__ __gnu_strftime__
+#endif
+#endif
+
+#ifndef gnu_attr_printf
+#define gnu_attr_printf	printf
+#define gnu_attr___printf__ __printf__
+#define gnu_attr_scanf	scanf
+#define gnu_attr___scanf__ __scanf__
+#define gnu_attr_strftime strftime
+#define gnu_attr___strftime__ __strftime__
+#endif
+
+#if !defined (USE_SYSTEM_FORMATS)
+#define USE_PRINTF(FMTPOS, WILDARG) __attribute__((format(gnu_printf, FMTPOS, WILDARG))) __attribute__((nonnull (FMTPOS)))
+#define USE_SCANF(FMTPOS, WILDARG) __attribute__((format(gnu_scanf, FMTPOS, WILDARG))) __attribute__((nonnull (FMTPOS)))
+#define USE_STRFTIME(FMTPOS) __attribute__((__format__(gnu_strftime, FMTPOS, 0))) __attribute__((nonnull (FMTPOS)))
+#else
+#define USE_PRINTF(FMTPOS, WILDARG)
+#define USE_SCANF(FMTPOS, WILDARG)
+#define USE_STRFTIME(FMTPOS)
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#ifndef _WINT_T
+#ifndef __WINT_TYPE__
+#define __WINT_TYPE__ unsigned int
+#endif
+typedef __WINT_TYPE__ wint_t;
+#endif
+
+#ifdef _WIN64
+/* Kludges to get types corresponding to size_t and ptrdiff_t.  */
+#define unsigned signed
+typedef signed int signed_size_t __attribute__ ((mode (DI)));
+/* We also use this type to approximate ssize_t.  */
+typedef signed int ssize_t __attribute__ ((mode (DI)));
+#undef unsigned
+#define signed /* Type might or might not have explicit 'signed'.  */
+typedef unsigned int unsigned_ptrdiff_t __attribute__ ((mode (DI)));
+#undef signed
+
+__extension__ typedef int llong  __attribute__ ((mode (DI)));
+__extension__ typedef unsigned int ullong  __attribute__ ((mode (DI)));
+#else
+/* Kludges to get types corresponding to size_t and ptrdiff_t.  */
+#define unsigned signed
+typedef __SIZE_TYPE__ signed_size_t;
+/* We also use this type to approximate ssize_t.  */
+typedef __SIZE_TYPE__ ssize_t;
+#undef unsigned
+#define signed /* Type might or might not have explicit 'signed'.  */
+typedef unsigned __PTRDIFF_TYPE__ unsigned_ptrdiff_t;
+#undef signed
+
+__extension__ typedef long long int llong;
+__extension__ typedef unsigned long long int ullong;
+#endif
+
+/* %q formats want a "quad"; GCC considers this to be a long long.  */
+typedef llong quad_t;
+typedef ullong u_quad_t;
+
+__extension__ typedef __INTMAX_TYPE__ intmax_t;
+__extension__ typedef __UINTMAX_TYPE__ uintmax_t;
+
+#if __STDC_VERSION__ < 199901L && !defined(restrict)
+#define restrict /* "restrict" not in old C standard.  */
+#endif
+
+/* This may not be correct in the particular case, but allows the
+   prototypes to be declared, and we don't try to link.
+*/
+typedef struct _FILE FILE;
+extern FILE *stdin;
+extern FILE *stdout;
+
+extern int fprintf (FILE *restrict, const char *restrict, ...);
+extern int printf (const char *restrict, ...);
+extern int fprintf_unlocked (FILE *restrict, const char *restrict, ...);
+extern int printf_unlocked (const char *restrict, ...);
+extern int sprintf (char *restrict, const char *restrict, ...);
+extern int vfprintf (FILE *restrict, const char *restrict, va_list);
+extern int vprintf (const char *restrict, va_list);
+extern int vsprintf (char *restrict, const char *restrict, va_list);
+extern int snprintf (char *restrict, size_t, const char *restrict, ...);
+extern int vsnprintf (char *restrict, size_t, const char *restrict, va_list);
+
+extern int fscanf (FILE *restrict, const char *restrict, ...);
+extern int scanf (const char *restrict, ...);
+extern int sscanf (const char *restrict, const char *restrict, ...);
+extern int vfscanf (FILE *restrict, const char *restrict, va_list);
+extern int vscanf (const char *restrict, va_list);
+extern int vsscanf (const char *restrict, const char *restrict, va_list);
+
+extern char *gettext (const char *);
+extern char *dgettext (const char *, const char *);
+extern char *dcgettext (const char *, const char *, int);
+
+struct tm;
+
+extern size_t strftime (char *restrict, size_t, const char *restrict,
+			const struct tm *restrict);
+
+extern ssize_t strfmon (char *restrict, size_t, const char *restrict, ...);
+
+/* Mingw specific part.  */
+#if !defined (USE_SYSTEM_FORMATS) && defined(_WIN32) && !defined(DONT_GNU_PROTOTYPE)
+
+extern USE_PRINTF(2,3) int fprintf_gnu (FILE *restrict, const char *restrict, ...);
+#undef fprintf
+#define fprintf fprintf_gnu
+
+extern USE_PRINTF(1,2) int printf_gnu (const char *restrict, ...);
+#undef printf
+#define printf printf_gnu
+
+extern USE_PRINTF(2,3) int fprintf_unlocked_gnu (FILE *restrict, const char *restrict, ...);
+#undef fprintf_unlocked
+#define fprintf_unlocked fprintf_unlocked_gnu
+
+extern USE_PRINTF(1,2)int printf_unlocked_gnu (const char *restrict, ...);
+#undef printf_unlocked
+#define printf_unlocked printf_unlocked_gnu
+
+extern USE_PRINTF(2,3) int sprintf_gnu (char *restrict, const char *restrict, ...);
+#undef sprintf
+#define sprintf sprintf_gnu
+
+extern USE_PRINTF(2,0) int vfprintf_gnu (FILE *restrict, const char *restrict, va_list);
+#undef vsprintf
+#define vsprintf vsprintf_gnu
+
+extern USE_PRINTF(1,0) int vprintf_gnu (const char *restrict, va_list);
+#undef vprintf
+#define vprintf vprintf_gnu
+
+extern USE_PRINTF(2,0) int vsprintf_gnu (char *restrict, const char *restrict, va_list);
+#undef vsprintf
+#define vsprintf vsprintf_gnu
+
+extern USE_PRINTF(3,4) int snprintf_gnu (char *restrict, size_t, const char *restrict, ...);
+#undef snprintf
+#define snprintf snprintf_gnu
+
+extern USE_PRINTF(3,0) int vsnprintf_gnu (char *restrict, size_t, const char *restrict, va_list);
+#undef vsnprintf
+#define vsnprintf vsnprintf_gnu
+
+extern USE_SCANF(2,3) int fscanf_gnu (FILE *restrict, const char *restrict, ...);
+#undef fscanf
+#define fscanf fscanf_gnu
+
+extern USE_SCANF(1,2) int scanf_gnu (const char *restrict, ...);
+#undef scanf
+#define scanf scanf_gnu
+
+extern USE_SCANF(2,3) int sscanf_gnu (const char *restrict, const char *restrict, ...);
+#undef sscanf
+#define sscanf sscanf_gnu
+
+extern USE_SCANF(2,0) int vfscanf_gnu (FILE *restrict, const char *restrict, va_list);
+#undef vfscanf
+#define vfscanf vfscanf_gnu
+
+extern USE_SCANF(1,0) int vscanf_gnu (const char *restrict, va_list);
+#undef vscanf
+#define vscanf vscanf_gnu
+
+extern USE_SCANF(2,0) int vsscanf_gnu (const char *restrict, const char *restrict, va_list);
+#undef vsscanf
+#define vsscanf vsscanf_gnu
+
+extern USE_STRFTIME(3) size_t strftime_gnu (char *restrict, size_t, const char *restrict,
+			const struct tm *restrict);
+#undef strftime
+#define strftime strftime_gnu
+
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-1.c
new file mode 100644
index 000000000..6bfa3ceb2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-1.c
@@ -0,0 +1,242 @@
+/* Test for GCC diagnositc formats.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+#define ATTRIBUTE_DIAG(F) __attribute__ ((__format__ (F, 1, 2))) __attribute__ ((__nonnull__));
+
+/* Magic identifiers must be set before the attribute is used.  */
+
+typedef long long __gcc_host_wide_int__;
+
+typedef struct location_s
+{
+  const char *file;
+  int line;
+} location_t;
+
+union tree_node;
+typedef union tree_node *tree;
+
+extern int diag (const char *, ...) ATTRIBUTE_DIAG(__gcc_diag__);
+extern int tdiag (const char *, ...) ATTRIBUTE_DIAG(__gcc_tdiag__);
+extern int cdiag (const char *, ...) ATTRIBUTE_DIAG(__gcc_cdiag__);
+extern int cxxdiag (const char *, ...) ATTRIBUTE_DIAG(__gcc_cxxdiag__);
+
+void
+foo (int i, int i1, int i2, unsigned int u, double d, char *s, void *p,
+     int *n, short int *hn, long int l, unsigned long int ul,
+     long int *ln, long double ld, wint_t lc, wchar_t *ls, llong ll,
+     ullong ull, unsigned int *un, const int *cn, signed char *ss,
+     unsigned char *us, const signed char *css, unsigned int u1,
+     unsigned int u2, location_t *loc, tree t1, union tree_node *t2,
+     tree *t3, tree t4[])
+{
+  /* Acceptable C90 specifiers, flags and modifiers.  */
+  diag ("%%");
+  tdiag ("%%");
+  cdiag ("%%");
+  cxxdiag ("%%");
+  diag ("%d%i%o%u%x%c%s%p%%", i, i, u, u, u, i, s, p);
+  tdiag ("%d%i%o%u%x%c%s%p%%", i, i, u, u, u, i, s, p);
+  cdiag ("%d%i%o%u%x%c%s%p%%", i, i, u, u, u, i, s, p);
+  cxxdiag ("%d%i%o%u%x%c%s%p%%", i, i, u, u, u, i, s, p);
+  diag ("%qd%qi%qo%qu%qx%qc%qs%qp%<%%%'%>", i, i, u, u, u, i, s, p);
+  tdiag ("%qd%qi%qo%qu%qx%qc%qs%qp%<%%%'%>", i, i, u, u, u, i, s, p);
+  cdiag ("%qd%qi%qo%qu%qx%qc%qs%qp%<%%%'%>", i, i, u, u, u, i, s, p);
+  cxxdiag ("%qd%qi%qo%qu%qx%qc%qs%qp%<%%%'%>", i, i, u, u, u, i, s, p);
+  diag ("%ld%li%lo%lu%lx", l, l, ul, ul, ul);
+  tdiag ("%ld%li%lo%lu%lx", l, l, ul, ul, ul);
+  cdiag ("%ld%li%lo%lu%lx", l, l, ul, ul, ul);
+  cxxdiag ("%ld%li%lo%lu%lx", l, l, ul, ul, ul);
+  diag ("%lld%lli%llo%llu%llx", ll, ll, ull, ull, ull);
+  tdiag ("%lld%lli%llo%llu%llx", ll, ll, ull, ull, ull);
+  cdiag ("%lld%lli%llo%llu%llx", ll, ll, ull, ull, ull);
+  cxxdiag ("%lld%lli%llo%llu%llx", ll, ll, ull, ull, ull);
+  diag ("%wd%wi%wo%wu%wx", ll, ll, ull, ull, ull);
+  tdiag ("%wd%wi%wo%wu%wx", ll, ll, ull, ull, ull);
+  cdiag ("%wd%wi%wo%wu%wx", ll, ll, ull, ull, ull);
+  cxxdiag ("%wd%wi%wo%wu%wx", ll, ll, ull, ull, ull);
+  diag ("%.*s", i, s);
+  tdiag ("%.*s", i, s);
+  cdiag ("%.*s", i, s);
+  cxxdiag ("%.*s", i, s);
+
+  /* Extensions provided in the diagnostic framework.  */
+  diag ("%m");
+  tdiag ("%m");
+  cdiag ("%m");
+  cxxdiag ("%m");
+  diag ("%H", loc);
+  tdiag ("%H", loc);
+  cdiag ("%H", loc);
+  cxxdiag ("%H", loc);
+  diag ("%J", t1);
+  tdiag ("%J", t1);
+  cdiag ("%J", t1);
+  cxxdiag ("%J", t1);
+
+  tdiag ("%D%F%T", t1, t1, t1);
+  tdiag ("%+D%+F%+T", t1, t1, t1);
+  tdiag ("%q+D%q+F%q+T", t1, t1, t1);
+  tdiag ("%D%D%D%D", t1, t2, *t3, t4[5]);
+  cdiag ("%D%F%T", t1, t1, t1);
+  cdiag ("%+D%+F%+T", t1, t1, t1);
+  cdiag ("%q+D%q+F%q+T", t1, t1, t1);
+  cdiag ("%D%D%D%D", t1, t2, *t3, t4[5]);
+  cdiag ("%E", t1);
+  cxxdiag ("%A%D%E%F%T%V", t1, t1, t1, t1, t1, t1);
+  cxxdiag ("%D%D%D%D", t1, t2, *t3, t4[5]);
+  cxxdiag ("%#A%#D%#E%#F%#T%#V", t1, t1, t1, t1, t1, t1);
+  cxxdiag ("%+A%+D%+E%+F%+T%+V", t1, t1, t1, t1, t1, t1);
+  cxxdiag ("%+#A%+#D%+#E%+#F%+#T%+#V", t1, t1, t1, t1, t1, t1);
+  cxxdiag ("%C%L%O%P%Q", i, i, i, i, i);
+
+  /* Bad stuff with extensions.  */
+  diag ("%m", i); /* { dg-warning "format" "extra arg" } */
+  tdiag ("%m", i); /* { dg-warning "format" "extra arg" } */
+  cdiag ("%m", i); /* { dg-warning "format" "extra arg" } */
+  cxxdiag ("%m", i); /* { dg-warning "format" "extra arg" } */
+  diag ("%#m"); /* { dg-warning "format" "bogus modifier" } */
+  tdiag ("%#m"); /* { dg-warning "format" "bogus modifier" } */
+  cdiag ("%#m"); /* { dg-warning "format" "bogus modifier" } */
+  cxxdiag ("%#m"); /* { dg-warning "format" "bogus modifier" } */
+  diag ("%+m"); /* { dg-warning "format" "bogus modifier" } */
+  tdiag ("%+m"); /* { dg-warning "format" "bogus modifier" } */
+  cdiag ("%+m"); /* { dg-warning "format" "bogus modifier" } */
+  cxxdiag ("%+m"); /* { dg-warning "format" "bogus modifier" } */
+  diag ("%H"); /* { dg-warning "format" "missing arg" } */
+  tdiag ("%H"); /* { dg-warning "format" "missing arg" } */
+  cdiag ("%H"); /* { dg-warning "format" "missing arg" } */
+  cxxdiag ("%H"); /* { dg-warning "format" "missing arg" } */
+  diag ("%J"); /* { dg-warning "format" "missing arg" } */
+  tdiag ("%J"); /* { dg-warning "format" "missing arg" } */
+  cdiag ("%J"); /* { dg-warning "format" "missing arg" } */
+  cxxdiag ("%J"); /* { dg-warning "format" "missing arg" } */
+  diag ("%H", i); /* { dg-warning "format" "wrong arg" } */
+  tdiag ("%H", i); /* { dg-warning "format" "wrong arg" } */
+  cdiag ("%H", i); /* { dg-warning "format" "wrong arg" } */
+  cxxdiag ("%H", i); /* { dg-warning "format" "wrong arg" } */
+  diag ("%H", p); /* { dg-warning "format" "wrong arg" } */
+  tdiag ("%H", p); /* { dg-warning "format" "wrong arg" } */
+  cdiag ("%H", p); /* { dg-warning "format" "wrong arg" } */
+  cxxdiag ("%H", p); /* { dg-warning "format" "wrong arg" } */
+  diag ("%J", loc); /* { dg-warning "format" "wrong arg" } */
+  tdiag ("%J", loc); /* { dg-warning "format" "wrong arg" } */
+  cdiag ("%J", loc); /* { dg-warning "format" "wrong arg" } */
+  cxxdiag ("%J", loc); /* { dg-warning "format" "wrong arg" } */
+  diag ("%#H", loc); /* { dg-warning "format" "bogus modifier" } */
+  tdiag ("%#H", loc); /* { dg-warning "format" "bogus modifier" } */
+  cdiag ("%#H", loc); /* { dg-warning "format" "bogus modifier" } */
+  cxxdiag ("%#H", loc); /* { dg-warning "format" "bogus modifier" } */
+  diag ("%+H", loc); /* { dg-warning "format" "bogus modifier" } */
+  tdiag ("%+H", loc); /* { dg-warning "format" "bogus modifier" } */
+  cdiag ("%+H", loc); /* { dg-warning "format" "bogus modifier" } */
+  cxxdiag ("%+H", loc); /* { dg-warning "format" "bogus modifier" } */
+  diag ("%D", t1); /* { dg-warning "format" "bogus tree" } */
+  tdiag ("%A", t1); /* { dg-warning "format" "bogus tree" } */
+  tdiag ("%E", t1);
+  tdiag ("%#D", t1); /* { dg-warning "format" "bogus modifier" } */
+  cdiag ("%A", t1); /* { dg-warning "format" "bogus tree" } */
+  cdiag ("%#D", t1); /* { dg-warning "format" "bogus modifier" } */
+  cdiag ("%+D", t1);
+  cxxdiag ("%C"); /* { dg-warning "format" "missing arg" } */
+  cxxdiag ("%C", l); /* { dg-warning "format" "wrong arg" } */
+  cxxdiag ("%C", i, i); /* { dg-warning "format" "extra arg" } */
+  cxxdiag ("%#C", i); /* { dg-warning "format" "bogus modifier" } */
+  cxxdiag ("%+C", i); /* { dg-warning "format" "bogus modifier" } */
+  tdiag ("%D"); /* { dg-warning "format" "missing arg" } */
+  cdiag ("%D"); /* { dg-warning "format" "missing arg" } */
+  cxxdiag ("%D"); /* { dg-warning "format" "missing arg" } */
+  tdiag ("%D", i); /* { dg-warning "format" "wrong arg" } */
+  cdiag ("%D", i); /* { dg-warning "format" "wrong arg" } */
+  cxxdiag ("%D", i); /* { dg-warning "format" "wrong arg" } */
+  tdiag ("%D", t1, t1); /* { dg-warning "format" "extra arg" } */
+  cdiag ("%D", t1, t1); /* { dg-warning "format" "extra arg" } */
+  cxxdiag ("%D", t1, t1); /* { dg-warning "format" "extra arg" } */
+
+  /* Standard specifiers not accepted in the diagnostic framework.  */
+  diag ("%X\n", u); /* { dg-warning "format" "HEX" } */
+  diag ("%f\n", d); /* { dg-warning "format" "float" } */
+  diag ("%e\n", d); /* { dg-warning "format" "float" } */
+  diag ("%E\n", d); /* { dg-warning "format" "float" } */
+  diag ("%g\n", d); /* { dg-warning "format" "float" } */
+  diag ("%G\n", d); /* { dg-warning "format" "float" } */
+  diag ("%n\n", n); /* { dg-warning "format" "counter" } */
+  diag ("%hd\n", i); /* { dg-warning "format" "conversion" } */
+
+  /* Various tests of bad argument types.  */
+  diag ("%-d", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%-d", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%-d", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%-d", i); /* { dg-warning "format" "bad flag" } */
+  diag ("% d", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("% d", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("% d", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("% d", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%#o", u); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%#o", u); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%#o", u); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%#o", u); /* { dg-warning "format" "bad flag" } */
+  diag ("%0d", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%0d", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%0d", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%0d", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%08d", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%08d", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%08d", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%08d", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%+d\n", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%+d\n", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%+d\n", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%+d\n", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%3d\n", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%3d\n", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%3d\n", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%3d\n", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%-3d\n", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%-3d\n", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%-3d\n", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%-3d\n", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%.7d\n", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%.7d\n", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%.7d\n", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%.7d\n", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%+9.4d\n", i); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%+9.4d\n", i); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%+9.4d\n", i); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%+9.4d\n", i); /* { dg-warning "format" "bad flag" } */
+  diag ("%.3ld\n", l); /* { dg-warning "format" "bad flag" } */
+  tdiag ("%.3ld\n", l); /* { dg-warning "format" "bad flag" } */
+  cdiag ("%.3ld\n", l); /* { dg-warning "format" "bad flag" } */
+  cxxdiag ("%.3ld\n", l); /* { dg-warning "format" "bad flag" } */
+  diag ("%d %lu\n", i, ul);
+  diag ("%d", l); /* { dg-warning "format" "bad argument types" } */
+  diag ("%wd", l); /* { dg-warning "format" "bad argument types" } */
+  diag ("%d", ll); /* { dg-warning "format" "bad argument types" } */
+  diag ("%*s", i, s); /* { dg-warning "format" "bad * argument types" } */
+  diag ("%*.*s", i, i, s); /* { dg-warning "format" "bad * argument types" } */
+  diag ("%*d\n", i1, i); /* { dg-warning "format" "bad * argument types" } */
+  diag ("%.*d\n", i2, i); /* { dg-warning "format" "bad * argument types" } */
+  diag ("%*.*ld\n", i1, i2, l); /* { dg-warning "format" "bad * argument types" } */
+  diag ("%ld", i); /* { dg-warning "format" "bad argument types" } */
+  diag ("%s", n); /* { dg-warning "format" "bad argument types" } */
+
+  /* Wrong number of arguments.  */
+  diag ("%d%d", i); /* { dg-warning "arguments" "wrong number of args" } */
+  diag ("%d", i, i); /* { dg-warning "arguments" "wrong number of args" } */
+  /* Miscellaneous bogus constructions.  */
+  diag (""); /* { dg-warning "zero-length" "warning for empty format" } */
+  diag ("\0"); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  diag ("%d\0", i); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  diag ("%d\0%d", i, i); /* { dg-warning "embedded|too many" "warning for embedded NUL" } */
+  diag (NULL); /* { dg-warning "null" "null format string warning" } */
+  diag ("%"); /* { dg-warning "trailing" "trailing % warning" } */
+  diag ((const char *)L"foo"); /* { dg-warning "wide" "wide string" } */
+  diag ("%s", (char *)0); /* { dg-warning "null" "%s with NULL" } */
+
+  /* Make sure we still get warnings for regular printf.  */
+  printf ("%d\n", ll); /* { dg-warning "format" "bad argument types" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-2.c
new file mode 100644
index 000000000..60c6835da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-2.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test "tree", not
+   defined.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+void foo (int tree);
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2)));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-3.c
new file mode 100644
index 000000000..8d2ac61a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-3.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test "tree", not
+   a type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+int tree;
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2))); /* { dg-error "'tree' is not defined as a type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-4.c
new file mode 100644
index 000000000..9b2396219
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-4.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test "tree", not
+   a pointer type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+typedef int tree;
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2))); /* { dg-error "'tree' is not defined as a pointer type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-5.c
new file mode 100644
index 000000000..f8f12d68c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-5.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "location_t", not defined.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+void foo (int location_t);
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2)));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-6.c
new file mode 100644
index 000000000..3f704e6f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-6.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "location_t", not a type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+int location_t;
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2))); /* { dg-error "'location_t' is not defined as a type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-7.c
new file mode 100644
index 000000000..fccf5d240
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-7.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", not defined.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+void foo (int __gcc_host_wide_int__);
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2)));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-8.c
new file mode 100644
index 000000000..6715ee33e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-8.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", not a type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+int __gcc_host_wide_int__;
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2))); /* { dg-error "'__gcc_host_wide_int__' is not defined as a type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-9.c
new file mode 100644
index 000000000..8daeb58a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_diag-9.c
@@ -0,0 +1,10 @@
+/* Test for ICE handling internal formats: bug 20740.  The code did
+   not check that, if the required typedef names had been used as
+   identifiers, they were defined to suitable types.  Test
+   "__gcc_host_wide_int__", bad type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+typedef int __gcc_host_wide_int__;
+void bar (const char *, ...) __attribute__ ((__format__ (__gcc_diag__, 1, 2))); /* { dg-error "'__gcc_host_wide_int__' is not defined as 'long' or 'long long'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_gfc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_gfc-1.c
new file mode 100644
index 000000000..7e079b776
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_gfc-1.c
@@ -0,0 +1,32 @@
+/* Test for gcc_gfc formats.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+/* Magic identifier must be set before the attribute is used.  */
+typedef struct locus locus;
+
+extern int gfc_warn (const char *, ...) __attribute__ ((__format__ (__gcc_gfc__, 1, 2))) __attribute__ ((__nonnull__));
+
+void
+foo (unsigned int u, int i, char *s, unsigned long int ul, long int l,
+     llong ll, locus *loc)
+{
+  /* Acceptable C90 specifiers, flags and modifiers.  */
+  gfc_warn ("%%");
+  gfc_warn ("%u%d%i%c%s%%", u, i, i, i, s);
+  gfc_warn ("%lu%ld%li%%", ul, l, l);
+
+  /* Extensions provided in gfc_warn.  */
+  gfc_warn ("%C");
+  gfc_warn ("%L", loc);
+
+  /* Various tests of bad argument types.  */
+  gfc_warn ("%d", l); /* { dg-warning "format" "bad argument types" } */
+  gfc_warn ("%d", ll); /* { dg-warning "format" "bad argument types" } */
+  gfc_warn ("%s", &i); /* { dg-warning "format" "bad argument types" } */
+  gfc_warn ("%L", &i); /* { dg-warning "format" "bad argument types" } */
+  gfc_warn ("%C", i); /* { dg-warning "format" "too many arguments" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_gfc-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_gfc-2.c
new file mode 100644
index 000000000..f3095fa29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/gcc_gfc-2.c
@@ -0,0 +1,13 @@
+/* PR c/35436 */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+typedef void locus[1]; /* { dg-error "array of void" } */
+
+void foo(const char*, ...)
+  __attribute__((__format__(__gcc_gfc__, 1, 2))); /* { dg-error "locus" } */
+
+void bar()
+{
+  foo("%L", 0); /* { dg-warning "format" }  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-1.c
new file mode 100644
index 000000000..3d4b99124
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-1.c
@@ -0,0 +1,39 @@
+/* Test for warnings for missing format attributes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#include "format.h"
+
+void
+foo (const char *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap); /* { dg-warning "candidate" "printf attribute warning" } */
+  va_end (ap);
+}
+
+void
+bar (const char *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vscanf (fmt, ap); /* { dg-warning "candidate" "scanf attribute warning" } */
+  va_end (ap);
+}
+
+__attribute__((__format__(gnu_attr___printf__, 1, 2))) void
+foo2 (const char *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+}
+
+void
+vfoo (const char *fmt, va_list arg)
+{
+  vprintf (fmt, arg); /* { dg-warning "candidate" "printf attribute warning 2" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-2.c
new file mode 100644
index 000000000..241b22d2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-2.c
@@ -0,0 +1,16 @@
+/* Test for warnings for missing format attributes.  Don't warn if no
+   relevant parameters for a format attribute; see c/1017.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#include "format.h"
+
+void
+foo (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  vprintf ("Foo %s bar %s", ap); /* { dg-bogus "candidate" "bogus printf attribute warning" } */
+  va_end (ap);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-3.c
new file mode 100644
index 000000000..e9cf19d1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-3.c
@@ -0,0 +1,27 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 0))) vattr_t;
+
+void
+foo1 (noattr_t na, attr_t a, vnoattr_t vna, vattr_t va)
+{
+  noattr_t na1 = na;
+  noattr_t na2 = a; /* { dg-warning "candidate" "initialization warning" } */
+  attr_t a1 = na;
+  attr_t a2 = a;
+
+  vnoattr_t vna1 = vna;
+  vnoattr_t vna2 = va; /* { dg-warning "candidate" "initialization warning" } */
+  vattr_t va1 = vna;
+  vattr_t va2 = va;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-4.c
new file mode 100644
index 000000000..f6cfd64cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-4.c
@@ -0,0 +1,33 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 0))) vattr_t;
+
+void
+foo1 (noattr_t na, attr_t a, vnoattr_t vna, vattr_t va)
+{
+  noattr_t na1, na2;
+  attr_t a1, a2;
+
+  vnoattr_t vna1, vna2;
+  vattr_t va1, va2;
+
+  na1 = na;
+  na2 = a; /* { dg-warning "candidate" "assignment warning" } */
+  a1 = na;
+  a2 = a;
+
+  vna1 = vna;
+  vna2 = va; /* { dg-warning "candidate" "assignment warning" } */
+  va1 = vna;
+  va1 = va;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-5.c
new file mode 100644
index 000000000..1706e369b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-5.c
@@ -0,0 +1,49 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 0))) vattr_t;
+
+noattr_t
+foo1 (noattr_t na, attr_t a, int i)
+{
+  if (i)
+    return na;
+  else
+    return a; /* { dg-warning "candidate" "return type warning" } */
+}
+
+attr_t
+foo2 (noattr_t na, attr_t a, int i)
+{
+  if (i)
+    return na;
+  else
+    return a;
+}
+
+vnoattr_t
+foo3 (vnoattr_t vna, vattr_t va, int i)
+{
+  if (i)
+    return vna;
+  else
+    return va; /* { dg-warning "candidate" "return type warning" } */
+}
+
+vattr_t
+foo4 (vnoattr_t vna, vattr_t va, int i)
+{
+  if (i)
+    return vna;
+  else
+    return va;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-6.c
new file mode 100644
index 000000000..77e287465
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/miss-6.c
@@ -0,0 +1,32 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(gnu_attr___printf__, 1, 0))) vattr_t;
+
+extern void foo1 (noattr_t);
+extern void foo2 (attr_t);
+extern void foo3 (vnoattr_t);
+extern void foo4 (vattr_t);
+
+void
+foo (noattr_t na, attr_t a, vnoattr_t vna, vattr_t va)
+{
+  foo1 (na);
+  foo1 (a); /* { dg-warning "candidate" "parameter passing warning" } */
+  foo2 (na);
+  foo2 (a);
+
+  foo3 (vna);
+  foo3 (va); /* { dg-warning "candidate" "parameter passing warning" } */
+  foo4 (vna);
+  foo4 (va);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms-format1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms-format1.c
new file mode 100644
index 000000000..81c21d911
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms-format1.c
@@ -0,0 +1,17 @@
+/* Test for printf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode. But allowed by -Wno-pedantic-ms-format.
+*/
+/* Origin: Kai Tietz <kai.tietz@onevision.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat -Wno-pedantic-ms-format" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, long long ll, size_t z)
+{
+  printf ("%I32d", i);
+  printf ("%I64x", ll);
+  printf ("%Ix", z);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms-warnI64-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms-warnI64-1.c
new file mode 100644
index 000000000..b5d31d2fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms-warnI64-1.c
@@ -0,0 +1,28 @@
+/* Test for printf formats. Test for ISO C warnings with MS "I64"
+   extension.*/
+
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wno-long-long" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (long long ll, unsigned long long ull, long long *lln,
+     long long *llp, unsigned long long *ullp)
+{
+  printf ("%I64d", ll); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64d" } */
+  printf ("%I64i", ll); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64i" } */
+  printf ("%I64o", ull); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64o" } */
+  printf ("%I64u", ull); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64u" } */
+  printf ("%I64x", ull); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64x" } */
+  printf ("%I64X", ull); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64X" } */
+  printf ("%I64n", lln); /* { dg-warning "'I64' ms_printf length modifier" "printf %I64n" } */
+  scanf ("%I64d", llp); /* { dg-warning "'I64' ms_scanf length modifier" "scanf %I64d" } */
+  scanf ("%I64i", llp); /* { dg-warning "'I64' ms_scanf length modifier" "scanf %I64i" } */
+  scanf ("%I64o", ullp); /* { dg-warning "'I64' ms_scanf length modifier" "scanf %I64o" } */
+  scanf ("%I64u", ullp); /* { dg-warning "'I64' ms_scanf length modifier" "scanf %I64u" } */
+  scanf ("%I64x", ullp); /* { dg-warning "'I64' ms_scanf length modifier" "scanf %I64x" } */
+  scanf ("%I64X", ullp); /* { dg-warning "'I64' ms_scanf length modifier"  "scanf %I64X" } */
+  scanf ("%I64n", llp); /* { dg-warning "'I64' ms_scanf length modifier" "scanf %I64n" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_array-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_array-1.c
new file mode 100644
index 000000000..b34506830
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_array-1.c
@@ -0,0 +1,42 @@
+/* Test for format checking of constant arrays.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat=2" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+const char a1[] = "foo";
+const char a2[] = "foo%d";
+const char b1[3] = "foo";
+const char b2[1] = "1";
+static const char c1[] = "foo";
+static const char c2[] = "foo%d";
+char d[] = "foo";
+volatile const char e[] = "foo";
+
+void
+foo (int i, long l)
+{
+  const char p1[] = "bar";
+  const char p2[] = "bar%d";
+  static const char q1[] = "bar";
+  static const char q2[] = "bar%d";
+  printf (a1);
+  printf (a2, i);
+  printf (a2, l); /* { dg-warning "format" "wrong type with array" } */
+  printf (b1); /* { dg-warning "unterminated" "unterminated array" } */
+  printf (b2); /* { dg-warning "unterminated" "unterminated array" } */
+  printf (c1);
+  printf (c2, i);
+  printf (c2, l); /* { dg-warning "format" "wrong type with array" } */
+  printf (p1);
+  printf (p2, i);
+  printf (p2, l); /* { dg-warning "format" "wrong type with array" } */
+  printf (q1);
+  printf (q2, i);
+  printf (q2, l); /* { dg-warning "format" "wrong type with array" } */
+  /* Volatile or non-constant arrays must not be checked.  */
+  printf (d); /* { dg-warning "not a string literal" "non-const" } */
+  printf ((const char *)e); /* { dg-warning "not a string literal" "volatile" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-1.c
new file mode 100644
index 000000000..90709bb1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-1.c
@@ -0,0 +1,10 @@
+/* Test for strftime format attributes: can't have first_arg_num != 0.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+extern void foo0 (const char *) __attribute__((__format__(__ms_strftime__, 1, 0)));
+extern void foo1 (const char *, ...) __attribute__((__format__(__ms_strftime__, 1, 2))); /* { dg-error "cannot format" "strftime first_arg_num != 0" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-2.c
new file mode 100644
index 000000000..9a9ce0fe3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-2.c
@@ -0,0 +1,68 @@
+/* Test for format attributes: test use of __attribute__.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+extern void tformatprintf (const char *, ...) __attribute__((format(ms_printf, 1, 2)));
+extern void tformat__printf__ (const char *, ...) __attribute__((format(__ms_printf__, 1, 2)));
+extern void tformatscanf (const char *, ...) __attribute__((format(ms_scanf, 1, 2)));
+extern void tformat__scanf__ (const char *, ...) __attribute__((format(__ms_scanf__, 1, 2)));
+extern void tformatstrftime (const char *) __attribute__((format(ms_strftime, 1, 0)));
+extern void tformat__strftime__ (const char *) __attribute__((format(__ms_strftime__, 1, 0)));
+extern void tformatstrfmon (const char *, ...) __attribute__((format(strfmon, 1, 2)));
+extern void tformat__strfmon__ (const char *, ...) __attribute__((format(__strfmon__, 1, 2)));
+extern void t__format__printf (const char *, ...) __attribute__((__format__(ms_printf, 1, 2)));
+extern void t__format____printf__ (const char *, ...) __attribute__((__format__(__ms_printf__, 1, 2)));
+extern void t__format__scanf (const char *, ...) __attribute__((__format__(ms_scanf, 1, 2)));
+extern void t__format____scanf__ (const char *, ...) __attribute__((__format__(__ms_scanf__, 1, 2)));
+extern void t__format__strftime (const char *) __attribute__((__format__(ms_strftime, 1, 0)));
+extern void t__format____strftime__ (const char *) __attribute__((__format__(__ms_strftime__, 1, 0)));
+extern void t__format__strfmon (const char *, ...) __attribute__((__format__(strfmon, 1, 2)));
+extern void t__format____strfmon__ (const char *, ...) __attribute__((__format__(__strfmon__, 1, 2)));
+
+extern char *tformat_arg (const char *) __attribute__((format_arg(1)));
+extern char *t__format_arg__ (const char *) __attribute__((__format_arg__(1)));
+
+void
+foo (int i, int *ip, double d)
+{
+  tformatprintf ("%d", i);
+  tformatprintf ("%"); /* { dg-warning "format" "attribute format printf" } */
+  tformat__printf__ ("%d", i);
+  tformat__printf__ ("%"); /* { dg-warning "format" "attribute format __printf__" } */
+  tformatscanf ("%d", ip);
+  tformatscanf ("%"); /* { dg-warning "format" "attribute format scanf" } */
+  tformat__scanf__ ("%d", ip);
+  tformat__scanf__ ("%"); /* { dg-warning "format" "attribute format __scanf__" } */
+  tformatstrftime ("%a");
+  tformatstrftime ("%"); /* { dg-warning "format" "attribute format strftime" } */
+  tformat__strftime__ ("%a");
+  tformat__strftime__ ("%"); /* { dg-warning "format" "attribute format __strftime__" } */
+  tformatstrfmon ("%n", d);
+  tformatstrfmon ("%"); /* { dg-warning "format" "attribute format strfmon" } */
+  tformat__strfmon__ ("%n", d);
+  tformat__strfmon__ ("%"); /* { dg-warning "format" "attribute format __strfmon__" } */
+  t__format__printf ("%d", i);
+  t__format__printf ("%"); /* { dg-warning "format" "attribute __format__ printf" } */
+  t__format____printf__ ("%d", i);
+  t__format____printf__ ("%"); /* { dg-warning "format" "attribute __format__ __printf__" } */
+  t__format__scanf ("%d", ip);
+  t__format__scanf ("%"); /* { dg-warning "format" "attribute __format__ scanf" } */
+  t__format____scanf__ ("%d", ip);
+  t__format____scanf__ ("%"); /* { dg-warning "format" "attribute __format__ __scanf__" } */
+  t__format__strftime ("%a");
+  t__format__strftime ("%"); /* { dg-warning "format" "attribute __format__ strftime" } */
+  t__format____strftime__ ("%a");
+  t__format____strftime__ ("%"); /* { dg-warning "format" "attribute __format__ __strftime__" } */
+  t__format__strfmon ("%n", d);
+  t__format__strfmon ("%"); /* { dg-warning "format" "attribute __format__ strfmon" } */
+  t__format____strfmon__ ("%n", d);
+  t__format____strfmon__ ("%"); /* { dg-warning "format" "attribute __format__ __strfmon__" } */
+  tformatprintf (tformat_arg ("%d"), i);
+  tformatprintf (tformat_arg ("%")); /* { dg-warning "format" "attribute format_arg" } */
+  tformatprintf (t__format_arg__ ("%d"), i);
+  tformatprintf (t__format_arg__ ("%")); /* { dg-warning "format" "attribute __format_arg__" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-3.c
new file mode 100644
index 000000000..5341dd816
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-3.c
@@ -0,0 +1,71 @@
+/* Test for format attributes: test bad uses of __attribute__.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+/* Proper uses of the attributes.  */
+extern void fa0 (const char *, ...) __attribute__((format(ms_printf, 1, 2)));
+extern void fa1 (char *, ...) __attribute__((format(ms_printf, 1, 2)));
+extern char *fa2 (const char *) __attribute__((format_arg(1)));
+extern char *fa3 (char *) __attribute__((format_arg(1)));
+
+/* Uses with too few or too many arguments.  */
+extern void fb0 (const char *, ...) __attribute__((format)); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb1 (const char *, ...) __attribute__((format())); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb2 (const char *, ...) __attribute__((format(ms_printf))); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb3 (const char *, ...) __attribute__((format(ms_printf, 1))); /* { dg-error "wrong number of arguments" "bad format" } */
+extern void fb4 (const char *, ...) __attribute__((format(ms_printf, 1, 2, 3))); /* { dg-error "wrong number of arguments" "bad format" } */
+
+extern void fc1 (const char *) __attribute__((format_arg)); /* { dg-error "wrong number of arguments" "bad format_arg" } */
+extern void fc2 (const char *) __attribute__((format_arg())); /* { dg-error "wrong number of arguments" "bad format_arg" } */
+extern void fc3 (const char *) __attribute__((format_arg(1, 2))); /* { dg-error "wrong number of arguments" "bad format_arg" } */
+
+/* These attributes presently only apply to declarations, not to types.
+   Eventually, they should be usable with declarators for function types
+   anywhere, but still not with structure/union/enum types.  */
+struct s0 { int i; } __attribute__((format(ms_printf, 1, 2))); /* { dg-error "does not apply|only applies" "format on struct" } */
+union u0 { int i; } __attribute__((format(ms_printf, 1, 2))); /* { dg-error "does not apply|only applies" "format on union" } */
+enum e0 { E0V0 } __attribute__((format(ms_printf, 1, 2))); /* { dg-error "does not apply|only applies" "format on enum" } */
+
+struct s1 { int i; } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on struct" } */
+union u1 { int i; } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on union" } */
+enum e1 { E1V0 } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on enum" } */
+
+/* The format type must be an identifier, one of those recognized.  */
+extern void fe0 (const char *, ...) __attribute__((format(12345, 1, 2))); /* { dg-error "format specifier" "non-id format" } */
+extern void fe1 (const char *, ...) __attribute__((format(nosuch, 1, 2))); /* { dg-warning "format function type" "unknown format" } */
+
+/* Both the numbers must be integer constant expressions.  */
+extern void ff0 (const char *, ...) __attribute__((format(ms_printf, 3-2, (long long)(10/5))));
+int foo;
+extern void ff1 (const char *, ...) __attribute__((format(ms_printf, foo, 10/5))); /* { dg-error "invalid operand" "bad number" } */
+extern void ff2 (const char *, ...) __attribute__((format(ms_printf, 3-2, foo))); /* { dg-error "invalid operand" "bad number" } */
+extern char *ff3 (const char *) __attribute__((format_arg(3-2)));
+extern char *ff4 (const char *) __attribute__((format_arg(foo))); /* { dg-error "invalid operand" "bad format_arg number" } */
+
+/* The format string argument must precede the arguments to be formatted.
+   This includes if no parameter types are specified (which is not valid ISO
+   C for variadic functions).  */
+extern void fg0 () __attribute__((format(ms_printf, 1, 2)));
+extern void fg1 () __attribute__((format(ms_printf, 1, 0)));
+extern void fg2 () __attribute__((format(ms_printf, 1, 1))); /* { dg-error "follows" "bad number order" } */
+extern void fg3 () __attribute__((format(ms_printf, 2, 1))); /* { dg-error "follows" "bad number order" } */
+
+/* The format string argument must be a string type, and the arguments to
+   be formatted must be the "...".  */
+extern void fh0 (int, ...) __attribute__((format(ms_printf, 1, 2))); /* { dg-error "not a string" "format int string" } */
+extern void fh1 (signed char *, ...) __attribute__((format(ms_printf, 1, 2))); /* { dg-error "not a string" "signed char string" } */
+extern void fh2 (unsigned char *, ...) __attribute__((format(ms_printf, 1, 2))); /* { dg-error "not a string" "unsigned char string" } */
+extern void fh3 (const char *, ...) __attribute__((format(ms_printf, 1, 3))); /* { dg-error "is not" "not ..." } */
+extern void fh4 (const char *, int, ...) __attribute__((format(ms_printf, 1, 2))); /* { dg-error "is not" "not ..." } */
+
+/* format_arg formats must take and return a string.  */
+extern char *fi0 (int) __attribute__((format_arg(1))); /* { dg-error "not a string" "format_arg int string" } */
+extern char *fi1 (signed char *) __attribute__((format_arg(1))); /* { dg-error "not a string" "format_arg signed char string" } */
+extern char *fi2 (unsigned char *) __attribute__((format_arg(1))); /* { dg-error "not a string" "format_arg unsigned char string" } */
+extern int fi3 (const char *) __attribute__((format_arg(1))); /* { dg-error "not return string" "format_arg ret int string" } */
+extern signed char *fi4 (const char *) __attribute__((format_arg(1))); /* { dg-error "not return string" "format_arg ret signed char string" } */
+extern unsigned char *fi5 (const char *) __attribute__((format_arg(1))); /* { dg-error "not return string" "format_arg ret unsigned char string" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-4.c
new file mode 100644
index 000000000..45f09ef22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-4.c
@@ -0,0 +1,26 @@
+/* Test for format attributes: test use of __attribute__
+   in prefix attributes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+extern __attribute__((format(ms_printf, 1, 2))) void tformatprintf0 (const char *, ...);
+extern void __attribute__((format(ms_printf, 1, 2))) tformatprintf1 (const char *, ...);
+extern void foo (void), __attribute__((format(ms_printf, 1, 2))) tformatprintf2 (const char *, ...);
+extern __attribute__((noreturn)) void bar (void), __attribute__((format(ms_printf, 1, 2))) tformatprintf3 (const char *, ...);
+
+void
+baz (int i, int *ip, double d)
+{
+  tformatprintf0 ("%d", i);
+  tformatprintf0 ("%"); /* { dg-warning "format" "attribute format printf case 0" } */
+  tformatprintf1 ("%d", i);
+  tformatprintf1 ("%"); /* { dg-warning "format" "attribute format printf case 1" } */
+  tformatprintf2 ("%d", i);
+  tformatprintf2 ("%"); /* { dg-warning "format" "attribute format printf case 2" } */
+  tformatprintf3 ("%d", i);
+  tformatprintf3 ("%"); /* { dg-warning "format" "attribute format printf case 3" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-7.c
new file mode 100644
index 000000000..b169e2c3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_attr-7.c
@@ -0,0 +1,35 @@
+/* Test for format attributes: test applying them to types.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+__attribute__((format(ms_printf, 1, 2))) void (*tformatprintf0) (const char *, ...);
+void (*tformatprintf1) (const char *, ...) __attribute__((format(ms_printf, 1, 2)));
+void (__attribute__((format(ms_printf, 1, 2))) *tformatprintf2) (const char *, ...);
+void (__attribute__((format(ms_printf, 1, 2))) ****tformatprintf3) (const char *, ...);
+
+char * (__attribute__((format_arg(1))) *tformat_arg) (const char *);
+
+void
+baz (int i)
+{
+  (*tformatprintf0) ("%d", i);
+  (*tformatprintf0) ((*tformat_arg) ("%d"), i);
+  (*tformatprintf0) ("%"); /* { dg-warning "format" "prefix" } */
+  (*tformatprintf0) ((*tformat_arg) ("%")); /* { dg-warning "format" "prefix" } */
+  (*tformatprintf1) ("%d", i);
+  (*tformatprintf1) ((*tformat_arg) ("%d"), i);
+  (*tformatprintf1) ("%"); /* { dg-warning "format" "postfix" } */
+  (*tformatprintf1) ((*tformat_arg) ("%")); /* { dg-warning "format" "postfix" } */
+  (*tformatprintf2) ("%d", i);
+  (*tformatprintf2) ((*tformat_arg) ("%d"), i);
+  (*tformatprintf2) ("%"); /* { dg-warning "format" "nested" } */
+  (*tformatprintf2) ((*tformat_arg) ("%")); /* { dg-warning "format" "nested" } */
+  (****tformatprintf3) ("%d", i);
+  (****tformatprintf3) ((*tformat_arg) ("%d"), i);
+  (****tformatprintf3) ("%"); /* { dg-warning "format" "nested 2" } */
+  (****tformatprintf3) ((*tformat_arg) ("%")); /* { dg-warning "format" "nested 2" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_bitfld-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_bitfld-1.c
new file mode 100644
index 000000000..83eb2fec6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_bitfld-1.c
@@ -0,0 +1,52 @@
+/* Test for printf formats and bit-fields: bug 22421.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+/* { dg-require-effective-target int32plus } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+struct s {
+  unsigned int u1 : 1;
+  signed int s1 : 1;
+  unsigned int u15 : 15;
+  signed int s15 : 15;
+  unsigned int u16 : 16;
+  signed int s16 : 16;
+  unsigned long u31 : 31;
+  signed long s31 : 31;
+  unsigned long u32 : 32;
+  signed long s32 : 32;
+  unsigned long long u48 : 48;
+} x;
+
+void
+foo (void)
+{
+  printf ("%d%u", x.u1, x.u1);
+  printf ("%d%u", x.s1, x.s1);
+  printf ("%d%u", x.u15, x.u15);
+  printf ("%d%u", x.s15, x.s15);
+  printf ("%d%u", x.u16, x.u16);
+  printf ("%d%u", x.s16, x.s16);
+#if __INT_MAX__ > 32767
+  /* If integers are 16 bits, there doesn't seem to be a way of
+     printing these without getting an error.  */
+  printf ("%d%u", x.u31, x.u31);
+  printf ("%d%u", x.s31, x.s31);
+#endif
+#if __LONG_MAX__ > 2147483647 && __INT_MAX__ >= 2147483647
+  /* If long is wider than 32 bits, the 32-bit bit-fields are int or
+     unsigned int or promote to those types.  Otherwise, long is 32
+     bits and the bit-fields are of type plain long or unsigned
+     long.  */
+  printf ("%d%u", x.u32, x.u32);
+  printf ("%d%u", x.s32, x.s32);
+#else
+  printf ("%ld%lu", x.u32, x.u32);
+  printf ("%ld%lu", x.s32, x.s32);
+#endif
+  printf ("%I64u", x.u48); /* { dg-warning "has type '.*unsigned int:48'" } */
+  printf ("%I64u", (unsigned long long)x.u48);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_branch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_branch-1.c
new file mode 100644
index 000000000..fe3f80e57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_branch-1.c
@@ -0,0 +1,28 @@
+/* Test for format checking of conditional expressions.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (long l, int nfoo)
+{
+  printf ((nfoo > 1) ? "%d foos" : "%d foo", nfoo);
+  printf ((l > 1) ? "%d foos" : "%d foo", l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf ((l > 1) ? "%ld foos" : "%d foo", l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf ((l > 1) ? "%d foos" : "%ld foo", l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  /* Should allow one case to have extra arguments.  */
+  printf ((nfoo > 1) ? "%d foos" : "1 foo", nfoo);
+  printf ((nfoo > 1) ? "many foos" : "1 foo", nfoo); /* { dg-warning "too many" "too many args in all branches" } */
+  printf ((nfoo > 1) ? "%d foos" : "", nfoo);
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "1 foo" : "no foos"), nfoo);
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "%d foo" : "%d foos"), nfoo);
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "%d foo" : "%ld foos"), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf ((nfoo > 1) ? "%ld foos" : ((nfoo > 0) ? "%d foo" : "%d foos"), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf ((nfoo > 1) ? "%d foos" : ((nfoo > 0) ? "%ld foo" : "%d foos"), nfoo); /* { dg-warning "long int" "wrong type" } */
+  /* Extra arguments to NULL should be complained about.  */
+  printf (NULL, "foo"); /* { dg-warning "too many" "NULL extra args" } */
+  /* { dg-warning "null" "null format arg" { target *-*-* } 26 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-1.c
new file mode 100644
index 000000000..f99d4c49d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-1.c
@@ -0,0 +1,184 @@
+/* Test for printf formats.  Formats using C90 features, including cases
+   where C90 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, int i1, int i2, unsigned int u, double d, char *s, void *p,
+     int *n, short int *hn, long int l, unsigned long int ul,
+     long int *ln, long double ld, wint_t lc, wchar_t *ls, llong ll,
+     ullong ull, unsigned int *un, const int *cn, signed char *ss,
+     unsigned char *us, const signed char *css, unsigned int u1,
+     unsigned int u2)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.1 (pages 131-134).  */
+  /* Basic sanity checks for the different components of a format.  */
+  printf ("%d\n", i);
+  printf ("%+d\n", i);
+  printf ("%3d\n", i);
+  printf ("%-3d\n", i);
+  printf ("%*d\n", i1, i);
+  printf ("%d %lu\n", i, ul);
+  /* Bogus use of width.  */
+  printf ("%5n\n", n); /* { dg-warning "width" "width with %n" } */
+  /* Valid and invalid %% constructions.  Some of the warning messages
+     are non-optimal, but they do detect the errorneous nature of the
+     format string.
+  */
+  printf ("%%");
+  printf ("%-%"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%-%\n"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%5%\n"); /* { dg-warning "format" "bogus %%" } */
+  printf ("%h%\n"); /* { dg-warning "format" "bogus %%" } */
+  /* Valid and invalid %h, %l, %L constructions.  */
+  printf ("%hd", i);
+  printf ("%hi", i);
+  /* Strictly, these parameters should be int or unsigned int according to
+     what unsigned short promotes to.  However, GCC ignores sign
+     differences in format checking here, and this is relied on to get the
+     correct checking without print_char_table needing to know whether
+     int and short are the same size.
+  */
+  printf ("%ho%hu%hx%hX", u, u, u, u);
+  printf ("%hn", hn);
+  printf ("%hf", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%he", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hE", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hg", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hG", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hc", i);
+  printf ("%hs", hn);
+  printf ("%hp", p); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%h"); /* { dg-warning "conversion lacks type" "bare %h" } */
+  printf ("%ld%li%lo%lu%lx%lX", l, l, ul, ul, ul, ul);
+  printf ("%ln", ln);
+  printf ("%lf", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%le", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lE", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lg", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lG", d); /* { dg-warning "length|C" "bad use of %l" } */
+  printf ("%lp", p); /* { dg-warning "length|C" "bad use of %l" } */
+  /* These next two were added in C94, but should be objected to in C90.
+     For the first one, GCC has wanted wchar_t instead of the correct C94
+     and C99 wint_t.
+  */
+  printf ("%lc", lc); /* { dg-warning "length|C" "C90 bad use of %l" } */
+  printf ("%ls", ls); /* { dg-warning "length|C" "C90 bad use of %l" } */
+  /* Valid uses of each bare conversion.  */
+  printf ("%d%i%o%u%x%X%f%e%E%g%G%c%s%p%n%%", i, i, u, u, u, u, d, d, d, d, d,
+	  i, s, p, n);
+  /* Uses of the - flag (valid on all non-%, non-n conversions).  */
+  printf ("%-d%-i%-o%-u%-x%-X%-f%-e%-E%-g%-G%-c%-s%-p", i, i, u, u, u, u,
+	  d, d, d, d, d, i, s, p);
+  printf ("%-n", n); /* { dg-warning "flag" "bad use of %-n" } */
+  /* Uses of the + flag (valid on signed conversions only).  */
+  printf ("%+d%+i%+f%+e%+E%+g%+G\n", i, i, d, d, d, d, d);
+  printf ("%+o", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+u", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+x", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+X", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+c", i); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+s", s); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+p", p); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+n", n); /* { dg-warning "flag" "bad use of + flag" } */
+  /* Uses of the space flag (valid on signed conversions only, and ignored
+     with +).
+  */
+  printf ("% +d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("%+ d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("% d% i% f% e% E% g% G\n", i, i, d, d, d, d, d);
+  printf ("% o", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% u", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% x", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% X", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% c", i); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% s", s); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% p", p); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% n", n); /* { dg-warning "flag" "bad use of space flag" } */
+  /* Uses of the # flag.  */
+  printf ("%#o%#x%#X%#e%#E%#f%#g%#G", u, u, u, d, d, d, d, d);
+  printf ("%#d", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#i", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#u", u); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#c", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#s", s); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#p", p); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#n", n); /* { dg-warning "flag" "bad use of # flag" } */
+  /* Uses of the 0 flag.  */
+  printf ("%08d%08i%08o%08u%08x%08X%08e%08E%08f%08g%08G", i, i, u, u, u, u,
+	  d, d, d, d, d);
+  printf ("%0c", i); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0s", s); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0p", p); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0n", n); /* { dg-warning "flag" "bad use of 0 flag" } */
+  /* 0 flag ignored with - flag.  */
+  printf ("%-08d", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08i", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08o", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08u", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08x", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08X", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08e", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08E", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08f", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08g", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08G", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  /* Various tests of bad argument types.  */
+  printf ("%d", l); /* { dg-warning "format" "bad argument types" } */
+  printf ("%ld", i); /* { dg-warning "format" "bad argument types" } */
+  printf ("%s", n); /* { dg-warning "format" "bad argument types" } */
+  printf ("%p", i); /* { dg-warning "format" "bad argument types" } */
+  printf ("%n", p); /* { dg-warning "format" "bad argument types" } */
+  /* With -pedantic, we want some further checks for pointer targets:
+     %p should allow only pointers to void (possibly qualified) and
+     to character types (possibly qualified), but not function pointers
+     or pointers to other types.  (Whether, in fact, character types are
+     allowed here is unclear; see thread on comp.std.c, July 2000 for
+     discussion of the requirements of rules on identical representation,
+     and of the application of the as if rule with the new va_arg
+     allowances in C99 to printf.)  Likewise, we should warn if
+     pointer targets differ in signedness, except in some circumstances
+     for character pointers.  (In C99 we should consider warning for
+     char * or unsigned char * being passed to %hhn, even if strictly
+     legitimate by the standard.)
+  */
+  printf ("%p", foo); /* { dg-warning "format" "bad argument types" } */
+  printf ("%n", un); /* { dg-warning "format" "bad argument types" } */
+  printf ("%p", n); /* { dg-warning "format" "bad argument types" } */
+  /* Allow character pointers with %p.  */
+  printf ("%p%p%p%p", s, ss, us, css);
+  /* %s allows any character type.  */
+  printf ("%s%s%s%s", s, ss, us, css);
+  /* Warning for void * arguments for %s is GCC's historical behavior,
+     and seems useful to keep, even if some standard versions might be
+     read to permit it.
+  */
+  printf ("%s", p); /* { dg-warning "format" "bad argument types" } */
+  /* The historical behavior is to allow signed / unsigned types
+     interchangably as arguments.  For values representable in both types,
+     such usage may be correct.  For now preserve the behavior of GCC
+     in such cases.
+  */
+  printf ("%d", u);
+  /* Wrong number of arguments.  */
+  printf ("%d%d", i); /* { dg-warning "arguments" "wrong number of args" } */
+  printf ("%d", i, i); /* { dg-warning "arguments" "wrong number of args" } */
+  /* Miscellaneous bogus constructions.  */
+  printf (""); /* { dg-warning "zero-length" "warning for empty format" } */
+  printf ("\0"); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  printf ("%d\0", i); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  printf ("%d\0%d", i, i); /* { dg-warning "embedded|too many" "warning for embedded NUL" } */
+  printf (NULL); /* { dg-warning "null" "null format string warning" } */
+  printf ("%"); /* { dg-warning "trailing" "trailing % warning" } */
+  printf ("%++d", i); /* { dg-warning "repeated" "repeated flag warning" } */
+  printf ("%n", cn); /* { dg-warning "constant" "%n with const" } */
+  printf ((const char *)L"foo"); /* { dg-warning "wide" "wide string" } */
+  printf ("%n", (int *)0); /* { dg-warning "null" "%n with NULL" } */
+  printf ("%s", (char *)0); /* { dg-warning "null" "%s with NULL" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-2.c
new file mode 100644
index 000000000..b53955881
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-2.c
@@ -0,0 +1,25 @@
+/* Test for printf formats.  Formats using C99 features should be rejected
+   outside of C99 mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, double d, llong ll, intmax_t j, size_t z, ptrdiff_t t)
+{
+  /* Some tests already in c90-printf-1.c, e.g. %lf.  */
+  /* The widths hh, ll, j, z, t are new.  */
+  printf ("%hhd", i); /* { dg-warning "unknown|format" "%hh is unsupported" } */
+  printf ("%I64d", ll); /* { dg-warning "length|C" "%I64 in C90" } */
+  printf ("%jd", j); /* { dg-warning "unknown|format" "%j is unsupported" } */
+  printf ("%zu", z); /* { dg-warning "unknown|format" "%z is unsupported" } */
+  printf ("%td", t); /* { dg-warning "unknown|format" "%t is unsupported" } */
+  /* The formats F, a, A are new.  */
+  printf ("%F", d); /* { dg-warning "unknown|format" "%F is unsupported" } */
+  printf ("%a", d); /* { dg-warning "unknown|format" "%a is unsupported" } */
+  printf ("%A", d); /* { dg-warning "unknown|format" "%A is unsupported" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-3.c
new file mode 100644
index 000000000..8e4b19a77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-printf-3.c
@@ -0,0 +1,43 @@
+/* Test for printf formats.  Test that the C90 functions get their default
+   attributes in strict C90 mode, but the C99 and gettext functions
+   do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, char *s, size_t n, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5, va_list v6, va_list v7, va_list v8)
+{
+  fprintf (stdout, "%d", i);
+  fprintf (stdout, "%ld", i); /* { dg-warning "format" "fprintf" } */
+  printf ("%d", i);
+  printf ("%ld", i); /* { dg-warning "format" "printf" } */
+  /* The "unlocked" functions shouldn't warn in c90 mode.  */
+  fprintf_unlocked (stdout, "%ld", i);
+  printf_unlocked ("%ld", i);
+  sprintf (s, "%d", i);
+  sprintf (s, "%ld", i); /* { dg-warning "format" "sprintf" } */
+  vfprintf (stdout, "%d", v0);
+  vfprintf (stdout, "%Y", v1); /* { dg-warning "format" "vfprintf" } */
+  vprintf ("%d", v2);
+  vprintf ("%Y", v3); /* { dg-warning "format" "vprintf" } */
+  /* The following used to give a bogus warning.  */
+  vprintf ("%*.*d", v8);   /* { dg-bogus "format" "vprintf" } */
+  vsprintf (s, "%d", v4);
+  vsprintf (s, "%Y", v5); /* { dg-warning "format" "Y is invalid" } */
+  snprintf (s, n, "%d", i);
+  snprintf (s, n, "%ld", i);
+  vsnprintf (s, n, "%d", v6);
+  vsnprintf (s, n, "%Y", v7);
+  printf (gettext ("%d"), i);
+  printf (gettext ("%ld"), i);
+  printf (dgettext ("", "%d"), i);
+  printf (dgettext ("", "%ld"), i);
+  printf (dcgettext ("", "%d", 0), i);
+  printf (dcgettext ("", "%ld", 0), i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-1.c
new file mode 100644
index 000000000..6e2cb1006
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-1.c
@@ -0,0 +1,119 @@
+/* Test for scanf formats.  Formats using C90 features, including cases
+   where C90 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int *ip, unsigned int *uip, short int *hp, unsigned short int *uhp,
+     long int *lp, unsigned long int *ulp, float *fp, double *dp,
+     long double *ldp, char *s, signed char *ss, unsigned char *us,
+     void **pp, int *n, llong *llp, ullong *ullp, wchar_t *ls,
+     const int *cip, const int *cn, const char *cs, const void **ppc,
+     void *const *pcp, short int *hn, long int *ln, void *p, char **sp,
+     volatile void *ppv)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.2 (pages 134-138).  */
+  /* Basic sanity checks for the different components of a format.  */
+  scanf ("%d", ip);
+  scanf ("%*d");
+  scanf ("%3d", ip);
+  scanf ("%hd", hp);
+  scanf ("%3ld", lp);
+  scanf ("%*3d");
+  scanf ("%d %ld", ip, lp);
+  /* Valid and invalid %% constructions.  */
+  scanf ("%%");
+  scanf ("%*%"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%*%\n"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%4%"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%4%\n"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%h%"); /* { dg-warning "format" "bogus %%" } */
+  scanf ("%h%\n"); /* { dg-warning "format" "bogus %%" } */
+  /* Valid, invalid and silly assignment-suppression constructions.  */
+  scanf ("%*d%*i%*o%*u%*x%*X%*e%*E%*f%*g%*G%*s%*[abc]%*c%*p");
+  scanf ("%*2d%*8s%*3c");
+  scanf ("%*n", n); /* { dg-warning "suppress" "suppression of %n" } */
+  scanf ("%*hd"); /* { dg-warning "together" "suppression with length" } */
+  /* Valid, invalid and silly width constructions.  */
+  scanf ("%2d%3i%4o%5u%6x%7X%8e%9E%10f%11g%12G%13s%14[abc]%15c%16p",
+	 ip, ip, uip, uip, uip, uip, fp, fp, fp, fp, fp, s, s, s, pp);
+  scanf ("%0d", ip); /* { dg-warning "width" "warning for zero width" } */
+  scanf ("%3n", n); /* { dg-warning "width" "width with %n" } */
+  /* Valid and invalid %h, %l, %L constructions.  */
+  scanf ("%hd%hi%ho%hu%hx%hX%hn", hp, hp, uhp, uhp, uhp, uhp, hn);
+  scanf ("%he", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hE", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hf", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hg", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hG", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hs", hp);
+  scanf ("%h[ac]", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hc", hp);
+  scanf ("%hp", pp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%h"); /* { dg-warning "conversion lacks type" "bare %h" } */
+  scanf ("%h."); /* { dg-warning "conversion" "bogus %h" } */
+  scanf ("%ld%li%lo%lu%lx%lX%ln", lp, lp, ulp, ulp, ulp, ulp, ln);
+  scanf ("%le%lE%lf%lg%lG", dp, dp, dp, dp, dp);
+  scanf ("%lp", pp); /* { dg-warning "length" "bad use of %l" } */
+  /* These next three formats were added in C94.  */
+  scanf ("%ls", ls); /* { dg-warning "length|C" "bad use of %l" } */
+  scanf ("%l[ac]", ls); /* { dg-warning "length|C" "bad use of %l" } */
+  scanf ("%lc", ls); /* { dg-warning "length|C" "bad use of %l" } */
+  scanf ("%Ld", llp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Li", llp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Lo", ullp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Lu", ullp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Lx", ullp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%LX", ullp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Ls", s); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%L[ac]", s); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Lc", s); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Lp", pp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  scanf ("%Ln", n); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  /* Valid uses of each bare conversion.  */
+  scanf ("%d%i%o%u%x%X%e%E%f%g%G%s%[abc]%c%p%n%%", ip, ip, uip, uip, uip,
+	 uip, fp, fp, fp, fp, fp, s, s, s, pp, n);
+  /* Allow other character pointers with %s, %c, %[].  */
+  scanf ("%2s%3s%4c%5c%6[abc]%7[abc]", ss, us, ss, us, ss, us);
+  /* Further tests for %[].  */
+  scanf ("%[%d]%d", s, ip);
+  scanf ("%[^%d]%d", s, ip);
+  scanf ("%[]%d]%d", s, ip);
+  scanf ("%[^]%d]%d", s, ip);
+  scanf ("%[%d]%d", s, ip);
+  scanf ("%[]abcd", s); /* { dg-warning "no closing" "incomplete scanset" } */
+  /* Various tests of bad argument types.  Some of these are only pedantic
+     warnings.
+  */
+  scanf ("%d", lp); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%d", uip); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%d", pp); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", ppc); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", ppv); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%s", n); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%s", p); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", p); /* { dg-warning "format" "bad argument types" } */
+  scanf ("%p", sp); /* { dg-warning "format" "bad argument types" } */
+  /* Tests for writing into constant values.  */
+  scanf ("%d", cip); /* { dg-warning "constant" "%d writing into const" } */
+  scanf ("%n", cn); /* { dg-warning "constant" "%n writing into const" } */
+  scanf ("%s", cs); /* { dg-warning "constant" "%s writing into const" } */
+  scanf ("%p", pcp); /* { dg-warning "constant" "%p writing into const" } */
+  /* Wrong number of arguments.  */
+  scanf ("%d%d", ip); /* { dg-warning "arguments" "wrong number of args" } */
+  scanf ("%d", ip, ip); /* { dg-warning "arguments" "wrong number of args" } */
+  /* Miscellaneous bogus constructions.  */
+  scanf (""); /* { dg-warning "zero-length" "warning for empty format" } */
+  scanf ("\0"); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  scanf ("%d\0", ip); /* { dg-warning "embedded" "warning for embedded NUL" } */
+  scanf ("%d\0%d", ip, ip); /* { dg-warning "embedded|too many" "warning for embedded NUL" } */
+  scanf (NULL); /* { dg-warning "null" "null format string warning" } */
+  scanf ("%"); /* { dg-warning "trailing" "trailing % warning" } */
+  scanf ("%d", (int *)0); /* { dg-warning "null" "writing into NULL" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-2.c
new file mode 100644
index 000000000..b55122792
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-2.c
@@ -0,0 +1,26 @@
+/* Test for scanf formats.  Formats using C99 features should be rejected
+   outside of C99 mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (signed char *hhp, float *fp, llong *llp, intmax_t *jp,
+     size_t *zp, ptrdiff_t *tp)
+{
+  /* Some tests already in c90-scanf-1.c.  */
+  /* The widths hh, ll, j, z, t are new.  */
+  scanf ("%hhd", hhp); /* { dg-warning "unknown|format" "%hh is unsupported" } */
+  scanf ("%I64d", llp); /* { dg-warning "length|C" "%I64 in C90" } */
+  scanf ("%jd", jp); /* { dg-warning "unknown|format" "%j is unsupported" } */
+  scanf ("%zu", zp); /* { dg-warning "unknown|format" "%z is unsupported" } */
+  scanf ("%td", tp); /* { dg-warning "unknown|format" "%t is unsupported" } */
+  /* The formats F, a, A are new.  */
+  scanf ("%F", fp); /* { dg-warning "unknown|format" "%F is unsupported" } */
+  scanf ("%a", fp); /* { dg-warning "unknown|format" "%a is unsupported" } */
+  scanf ("%A", fp); /* { dg-warning "unknown|format" "%A is unsupported" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-3.c
new file mode 100644
index 000000000..b9d3e38bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-3.c
@@ -0,0 +1,20 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* %a formats for allocation, only recognized in C90 mode, are a
+     GNU extension.
+  */
+  scanf ("%as", sp); /* { dg-warning "flag" "%as is unsupported" } */
+  scanf ("%aS", lsp); /* { dg-warning "format|flag" "%aS is unsupported" } */
+  scanf ("%a[bcd]", sp); /* { dg-warning "flag" "%a[] is unsupported" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-4.c
new file mode 100644
index 000000000..4b1fda7ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-4.c
@@ -0,0 +1,31 @@
+/* Test for scanf formats.  Test that the C90 functions get their default
+   attributes in strict C90 mode, but the C99 and gettext functions
+   do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int *ip, char *s, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5)
+{
+  fscanf (stdin, "%d", ip);
+  fscanf (stdin, "%ld", ip); /* { dg-warning "format" "fscanf" } */
+  scanf ("%d", ip);
+  scanf ("%ld", ip); /* { dg-warning "format" "scanf" } */
+  sscanf (s, "%d", ip);
+  sscanf (s, "%ld", ip); /* { dg-warning "format" "sscanf" } */
+  vfscanf (stdin, "%d", v0);
+  vscanf ("%d", v2);
+  vsscanf (s, "%d", v4);
+  scanf (gettext ("%d"), ip);
+  scanf (gettext ("%ld"), ip);
+  scanf (dgettext ("", "%d"), ip);
+  scanf (dgettext ("", "%ld"), ip);
+  scanf (dcgettext ("", "%d", 0), ip);
+  scanf (dcgettext ("", "%ld", 0), ip);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-5.c
new file mode 100644
index 000000000..c714689e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-scanf-5.c
@@ -0,0 +1,20 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* m assignment-allocation modifier, recognized in both C90
+     and C99 modes, is a POSIX and ISO/IEC WDTR 24731-2 extension.  */
+  scanf ("%ms", sp); /* { dg-warning "unknown|format" "%ms is unsupported" } */
+  scanf ("%mS", lsp); /* { dg-warning "unknown|format" "%mS is unsupported" } */
+  scanf ("%mls", lsp); /* { dg-warning "unknown|format" "%mls is unsupported" } */
+  scanf ("%m[bcd]", sp); /* { dg-warning "unknown|format" "%m[] is unsupported" } */
+  scanf ("%ml[bcd]", lsp); /* { dg-warning "unknown|format" "%ml[] is unsupported" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-strftime-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-strftime-1.c
new file mode 100644
index 000000000..34143c1b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-strftime-1.c
@@ -0,0 +1,20 @@
+/* Test for strftime formats.  Formats using C90 features.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wformat-y2k" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.12.3.5 (pages 174-175).  */
+  /* Formats which are Y2K-compliant (no 2-digit years).  */
+  strftime (s, m, "%a%A%b%B%d%H%I%j%m%M%p%S%U%w%W%X%Y%Z%%", tp);
+  /* Formats with 2-digit years.  */
+  strftime (s, m, "%y", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  /* Formats with 2-digit years in some locales.  */
+  strftime (s, m, "%c", tp); /* { dg-warning "some locales" "2-digit year" } */
+  strftime (s, m, "%x", tp); /* { dg-warning "some locales" "2-digit year" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-strftime-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-strftime-2.c
new file mode 100644
index 000000000..446f23533
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c90-strftime-2.c
@@ -0,0 +1,28 @@
+/* Test for strftime formats.  Rejection of formats using C99 features in
+   pedantic C90 mode.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wformat-y2k" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  strftime (s, m, "%C", tp); /* { dg-warning "format" "%C is unsupported" } */
+  strftime (s, m, "%D", tp); /* { dg-warning "format" "%D is unsupported" } */
+  strftime (s, m, "%e", tp); /* { dg-warning "format" "%e is unsupported" } */
+  strftime (s, m, "%F", tp); /* { dg-warning "format" "%F is unsupported" } */
+  strftime (s, m, "%g", tp); /* { dg-warning "format" "%g is unsupported" } */
+  strftime (s, m, "%G", tp); /* { dg-warning "format" "%G is unsupported" } */
+  strftime (s, m, "%h", tp); /* { dg-warning "format" "%h is unsupported" } */
+  strftime (s, m, "%n", tp); /* { dg-warning "format" "%n is unsupported" } */
+  strftime (s, m, "%r", tp); /* { dg-warning "format" "%r is unsupported" } */
+  strftime (s, m, "%R", tp); /* { dg-warning "format" "%R is unsupported" } */
+  strftime (s, m, "%t", tp); /* { dg-warning "format" "%t is unsupported" } */
+  strftime (s, m, "%T", tp); /* { dg-warning "format" "%T is unsupported" } */
+  strftime (s, m, "%u", tp); /* { dg-warning "format" "%u is unsupported" } */
+  strftime (s, m, "%V", tp); /* { dg-warning "format" "%V is unsupported" } */
+  strftime (s, m, "%z", tp); /* { dg-warning "C" "%z not in C90" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c94-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c94-printf-1.c
new file mode 100644
index 000000000..8a7a12e3f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c94-printf-1.c
@@ -0,0 +1,19 @@
+/* Test for printf formats.  Changes in C94 to C90.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:199409 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (wint_t lc, wchar_t *ls)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.1 (pages 131-134),
+     as amended by ISO/IEC 9899:1990/Amd.1:1995 (E) (pages 4-5).
+     We do not repeat here all the C90 format checks, but just verify
+     that %ls and %lc are accepted without warning.
+  */
+  printf ("%lc", lc);
+  printf ("%ls", ls);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c94-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c94-scanf-1.c
new file mode 100644
index 000000000..85b300f4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c94-scanf-1.c
@@ -0,0 +1,18 @@
+/* Test for scanf formats.  Changes in C94 to C90.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:199409 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (wchar_t *ls)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.2 (pages 134-138),
+     as amended by ISO/IEC 9899:1990/Amd.1:1995 (E) (pages 5-6).
+     We do not repeat here all the C90 format checks, but just verify
+     that %ls, %lc, %l[] are accepted without warning.
+  */
+  scanf ("%lc%ls%l[abc]", ls, ls, ls);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-1.c
new file mode 100644
index 000000000..ad5634ceb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-1.c
@@ -0,0 +1,109 @@
+/* Test for printf formats.  Formats using C99 features, including cases
+   where C99 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, unsigned int u, double d, char *s, void *p, int *n,
+     long double ld, wint_t lc, wchar_t *ls, long long int ll,
+     unsigned long long int ull, signed char *ss, unsigned char *us,
+     long long int *lln, intmax_t j, uintmax_t uj, intmax_t *jn,
+     size_t z, signed_size_t sz, signed_size_t *zn,
+     ptrdiff_t t, ptrdiff_t *tn)
+{
+  /* See ISO/IEC 9899:1999 (E) subclause 7.19.6.1 (pages 273-281).
+     We do not repeat here most of the checks for correct C90 formats
+     or completely broken formats.
+  */
+  /* Valid and invalid %h, %hh, %l, %j, %z, %t, %L constructions.  */
+  printf ("%hf", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hF", d); /* { dg-warning "unknown|format" "bad use of %hF" } */
+  printf ("%he", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hE", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hg", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%hG", d); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%ha", d); /* { dg-warning "unknown|format" "bad use of %ha" } */
+  printf ("%hA", d); /* { dg-warning "unknown|format" "bad use of %hA" } */
+  printf ("%hc", i);
+  printf ("%hs", (short *)s);
+  printf ("%hp", p); /* { dg-warning "length" "bad use of %h" } */
+  printf ("%lc", lc);
+  printf ("%ls", ls);
+  printf ("%lp", p); /* { dg-warning "length|C" "bad use of %l" } */
+  /* Valid uses of each bare conversion.  */
+  printf ("%d%i%o%u%x%X%f%e%E%g%G%c%s%p%n%%", i, i, u, u, u, u,
+	  d, d, d, d, d, i, s, p, n);
+  /* Uses of the - flag (valid on all non-%, non-n conversions).  */
+  printf ("%-d%-i%-o%-u%-x%-X%-f%-e%-E%-g%-G%-c%-s%-p", i, i,
+	  u, u, u, u, d, d, d, d, d, i, s, p);
+  printf ("%-n", n); /* { dg-warning "flag" "bad use of %-n" } */
+  /* Uses of the + flag (valid on signed conversions only).  */
+  printf ("%+d%+i%+f%+e%+E%+g%+G\n", i, i, d, d, d, d, d);
+  printf ("%+o", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+u", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+x", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+X", u); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+c", i); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+s", s); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+p", p); /* { dg-warning "flag" "bad use of + flag" } */
+  printf ("%+n", n); /* { dg-warning "flag" "bad use of + flag" } */
+  /* Uses of the space flag (valid on signed conversions only, and ignored
+     with +).
+  */
+  printf ("% +d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("%+ d", i); /* { dg-warning "use of both|ignored" "use of space and + flags" } */
+  printf ("% d% i% f% e% E% g% G\n", i, i, d, d, d, d, d);
+  printf ("% o", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% u", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% x", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% X", u); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% c", i); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% s", s); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% p", p); /* { dg-warning "flag" "bad use of space flag" } */
+  printf ("% n", n); /* { dg-warning "flag" "bad use of space flag" } */
+  /* Uses of the # flag.  */
+  printf ("%#o%#x%#X%#e%#E%#f%#g%#G", u, u, u, d, d, d,
+	  d, d);
+  printf ("%#d", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#i", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#u", u); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#c", i); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#s", s); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#p", p); /* { dg-warning "flag" "bad use of # flag" } */
+  printf ("%#n", n); /* { dg-warning "flag" "bad use of # flag" } */
+  /* Uses of the 0 flag.  */
+  printf ("%08d%08i%08o%08u%08x%08X%08e%08E%08f%08g%08G", i, i,
+	  u, u, u, u, d, d, d, d, d);
+  printf ("%0c", i); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0s", s); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0p", p); /* { dg-warning "flag" "bad use of 0 flag" } */
+  printf ("%0n", n); /* { dg-warning "flag" "bad use of 0 flag" } */
+  /* 0 flag ignored with - flag.  */
+  printf ("%-08d", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08i", i); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08o", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08u", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08x", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08X", u); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08e", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08E", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08f", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08F", d); /* { dg-warning "unknown|format" "0 flag ignored with - flag" } */
+  printf ("%-08g", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08G", d); /* { dg-warning "flags|ignored" "0 flag ignored with - flag" } */
+  printf ("%-08a", d); /* { dg-warning "unknown|format" "0 flag ignored with - flag" } */
+  printf ("%-08A", d); /* { dg-warning "unknown|format" "0 flag ignored with - flag" } */
+  /* Various tests of bad argument types.  Mostly covered in c90-printf-1.c;
+     here just test for pointer target sign with %hhn.  (Probably allowed
+     by the standard, but a bad idea, so GCC should diagnose if what
+     is used is not signed char *.)
+  */
+  printf ("%hhn", s); /* { dg-warning "unknown|format" "%hhn is unsupported" } */
+  printf ("%hhn", us); /* { dg-warning "unknown|format" "%hhn is unsupported" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-2.c
new file mode 100644
index 000000000..0a4d3160d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-2.c
@@ -0,0 +1,32 @@
+/* Test for printf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, long long ll, size_t z, wint_t lc, wchar_t *ls)
+{
+  /* The length modifiers q, Z and L as applied to integer formats are
+     extensions.
+  */
+  printf ("%qd", ll); /* { dg-warning "unknown|format" "%q length is unsupported" } */
+  printf ("%Ld", ll); /* { dg-warning "unknown|format" "%L length is unsupported" } */
+  printf ("%Zd", z); /* { dg-warning "unknown|format" "%Z length is unsupported" } */
+  /* The conversion specifiers C and S are X/Open extensions; the
+     conversion specifier m is a GNU extension.
+  */
+  printf ("%m"); /* { dg-warning "unknown" "printf %m is unsupported" } */
+  printf ("%C", lc); /* { dg-warning "C" "printf %C" } */
+  printf ("%S", ls); /* { dg-warning "C" "printf %S" } */
+  /* The flag character ', and the use of operand number $ formats, are
+     X/Open extensions.
+  */
+  printf ("%'d", i); /* { dg-warning "C" "printf ' flag" } */
+  printf ("%1$d", i); /* { dg-warning "C" "printf $ format" } */
+  printf ("%Ix", z); /* { dg-warning "C" "printf I format" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-3.c
new file mode 100644
index 000000000..d8c51eaa0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-printf-3.c
@@ -0,0 +1,40 @@
+/* Test for printf formats.  Test that the C99 functions get their default
+   attributes in strict C99 mode, but the gettext functions do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, char *s, size_t n, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5, va_list v6, va_list v7)
+{
+  fprintf (stdout, "%d", i);
+  fprintf (stdout, "%ld", i); /* { dg-warning "format" "fprintf" } */
+  printf ("%d", i);
+  printf ("%ld", i); /* { dg-warning "format" "printf" } */
+  /* The "unlocked" functions shouldn't warn in c99 mode.  */
+  fprintf_unlocked (stdout, "%ld", i);
+  printf_unlocked ("%ld", i);
+  sprintf (s, "%d", i);
+  sprintf (s, "%ld", i); /* { dg-warning "format" "sprintf" } */
+  snprintf (s, n, "%d", i);
+  snprintf (s, n, "%ld", i); /* { dg-warning "format" "snprintf" } */
+  vfprintf (stdout, "%d", v0);
+  vfprintf (stdout, "%Y", v1); /* { dg-warning "format" "vfprintf" } */
+  vprintf ("%d", v0);
+  vprintf ("%Y", v1); /* { dg-warning "format" "vprintf" } */
+  vsprintf (s, "%d", v0);
+  vsprintf (s, "%Y", v1); /* { dg-warning "format" "vsprintf" } */
+  vsnprintf (s, n, "%d", v0);
+  vsnprintf (s, n, "%Y", v1); /* { dg-warning "format" "vsnprintf" } */
+  printf (gettext ("%d"), i);
+  printf (gettext ("%ld"), (long) i);
+  printf (dgettext ("", "%d"), i);
+  printf (dgettext ("", "%ld"), (long) i);
+  printf (dcgettext ("", "%d", 0), i);
+  printf (dcgettext ("", "%ld", 0), (long) i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-1.c
new file mode 100644
index 000000000..f4ac706e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-1.c
@@ -0,0 +1,63 @@
+/* Test for scanf formats.  Formats using C99 features, including cases
+   where C99 specifies some aspect of the format to be ignored or where
+   the behavior is undefined.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int *ip, unsigned int *uip, short int *hp, unsigned short int *uhp,
+     signed char *hhp, unsigned char *uhhp, long int *lp,
+     unsigned long int *ulp, float *fp, double *dp, long double *ldp, char *s,
+     void **pp, int *n, long long *llp, unsigned long long *ullp, wchar_t *ls,
+     short int *hn, signed char *hhn, long int *ln, long long int *lln,
+     intmax_t *jp, uintmax_t *ujp, intmax_t *jn, size_t *zp,
+     signed_size_t *szp, signed_size_t *zn, ptrdiff_t *tp,
+     unsigned_ptrdiff_t *utp, ptrdiff_t *tn)
+{
+  /* See ISO/IEC 9899:1999 (E) subclause 7.19.6.2 (pages 281-288).
+     We do not repeat here most of the checks for correct C90 formats
+     or completely broken formats.
+  */
+  /* Valid, invalid and silly assignment-suppression
+     and width constructions.
+  */
+  scanf ("%*d%*i%*o%*u%*x%*X%*e%*E%*f%*g%*G%*s%*[abc]%*c%*p");
+  scanf ("%*2d%*8s%*3c");
+  scanf ("%*n", n); /* { dg-warning "suppress" "suppression of %n" } */
+  scanf ("%*hd"); /* { dg-warning "together" "suppression with length" } */
+  scanf ("%2d%3i%4o%5u%6x%7X%10e%11E%12f%14g%15G%16s%3[abc]%4c%5p",
+	 ip, ip, uip, uip, uip, uip, fp, fp, fp, fp, fp,
+	 s, s, s, pp);
+  scanf ("%0d", ip); /* { dg-warning "width" "warning for zero width" } */
+  scanf ("%3n", n); /* { dg-warning "width" "width with %n" } */
+  /* Valid and invalid %h, %hh, %l, %j, %z, %t, %L constructions.  */
+  scanf ("%hd%hi%ho%hu%hx%hX%hn", hp, hp, uhp, uhp, uhp, uhp, hn);
+  scanf ("%he", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hE", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hf", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hg", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hG", fp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hs", hp);
+  scanf ("%h[ac]", s); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hc", (short *)s);
+  scanf ("%hp", pp); /* { dg-warning "length" "bad use of %h" } */
+  scanf ("%hhd", hhp); /* { dg-warning "unknown|format" "%hh is unsupported" } */
+  scanf ("%ld%li%lo%lu%lx%lX%ln", lp, lp, ulp, ulp, ulp, ulp, ln);
+  scanf ("%le%lE%lf%lg%lG", dp, dp, dp, dp, dp);
+  scanf ("%lp", pp); /* { dg-warning "length" "bad use of %l" } */
+  scanf ("%ls", ls);
+  scanf ("%l[ac]", ls);
+  scanf ("%lc", ls);
+  scanf ("%jd", jp); /* { dg-warning "unknown|format" "%j not supported" } */
+  scanf ("%zd", zp); /* { dg-warning "unknown|format" "%z not supported" } */
+  scanf ("%td", tp); /* { dg-warning "unknown|format" "%t not supported" } */
+  scanf ("%Lf", llp); /* { dg-warning "unknown|format" "bad use of %L is not supported" } */
+  /* Valid uses of each bare conversion.  */
+  scanf ("%d%i%o%u%x%X%e%E%f%g%G%s%[abc]%c%p%n%%", ip, ip, uip, uip, uip,
+         uip, fp, fp, fp, fp, fp, s, s, s, pp, n);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-2.c
new file mode 100644
index 000000000..e16f5bfc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-2.c
@@ -0,0 +1,27 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int *ip, long long int *llp, wchar_t *ls)
+{
+  /* The length modifiers q and L as applied to integer formats are
+     extensions.
+  */
+  scanf ("%qd", llp); /* { dg-warning "unknown|format" "%q is unsupported" } */
+  scanf ("%Ld", llp); /* { dg-warning "unknown|format" "%L is unsupported" } */
+  /* The conversion specifiers C and S are X/Open extensions.  */
+  scanf ("%C", ls); /* { dg-warning "C" "scanf %C" } */
+  scanf ("%S", ls); /* { dg-warning "C" "scanf %S" } */
+  /* The use of operand number $ formats is an X/Open extension.  */
+  scanf ("%1$d", ip); /* { dg-warning "C" "scanf $ format" } */
+  /* glibc also supports flags ' and I on scanf formats as an extension.  */
+  scanf ("%'d", ip); /* { dg-warning "C" "scanf ' flag" } */
+  scanf ("%Id", (ssize_t *)ip); /* { dg-warning "C" "scanf I flag" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-3.c
new file mode 100644
index 000000000..cde2f3703
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-3.c
@@ -0,0 +1,33 @@
+/* Test for scanf formats.  Test that the C99 functions get their default
+   attributes in strict C99 mode, but the gettext functions do not.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int *ip, char *s, va_list v0, va_list v1, va_list v2, va_list v3,
+     va_list v4, va_list v5)
+{
+  fscanf (stdin, "%d", ip);
+  fscanf (stdin, "%ld", ip); /* { dg-warning "format" "fscanf" } */
+  scanf ("%d", ip);
+  scanf ("%ld", ip); /* { dg-warning "format" "scanf" } */
+  sscanf (s, "%d", ip);
+  sscanf (s, "%ld", ip); /* { dg-warning "format" "sscanf" } */
+  vfscanf (stdin, "%d", v0);
+  vfscanf (stdin, "%Y", v1); /* { dg-warning "format" "vfscanf" } */
+  vscanf ("%d", v2);
+  vscanf ("%Y", v3); /* { dg-warning "format" "vscanf" } */
+  vsscanf (s, "%d", v4);
+  vsscanf (s, "%Y", v5); /* { dg-warning "format" "vsscanf" } */
+  scanf (gettext ("%d"), ip);
+  scanf (gettext ("%ld"), ip);
+  scanf (dgettext ("", "%d"), ip);
+  scanf (dgettext ("", "%ld"), ip);
+  scanf (dcgettext ("", "%d", 0), ip);
+  scanf (dcgettext ("", "%ld", 0), ip);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-4.c
new file mode 100644
index 000000000..bddc11dd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-scanf-4.c
@@ -0,0 +1,20 @@
+/* Test for scanf formats.  Formats using extensions to the standard
+   should be rejected in strict pedantic mode.
+*/
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char **sp, wchar_t **lsp)
+{
+  /* m assignment-allocation modifier, recognized in both C90
+     and C99 modes, is a POSIX and ISO/IEC WDTR 24731-2 extension.  */
+  scanf ("%ms", sp); /* { dg-warning "unknown|format" "%ms is unsupported" } */
+  scanf ("%mS", lsp); /* { dg-warning "unknown|format" "%mS is unsupported" } */
+  scanf ("%mls", lsp); /* { dg-warning "unknown|format" "%mls is unsupported" } */
+  scanf ("%m[bcd]", sp); /* { dg-warning "unknown|format" "%m[] is unsupported" } */
+  scanf ("%ml[bcd]", lsp); /* { dg-warning "unknown|format" "%ml[] is unsupported" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-strftime-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-strftime-1.c
new file mode 100644
index 000000000..743972efa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-strftime-1.c
@@ -0,0 +1,20 @@
+/* Test for strftime formats.  Formats using C99 features.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat -Wformat-y2k" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.12.3.5 (pages 174-175).  */
+  /* Formats which are Y2K-compliant (no 2-digit years).  */
+  strftime (s, m, "%a%A%b%B%d%H%I%j%m%M%p%S%U%w%W%X%Y%z%Z%%", tp);
+  /* Formats with 2-digit years.  */
+  strftime (s, m, "%y", tp); /* { dg-warning "only last 2" "2-digit year" } */
+  /* Formats with 2-digit years in some locales.  */
+  strftime (s, m, "%c", tp); /* { dg-warning "some locales" "2-digit year" } */
+  strftime (s, m, "%x", tp); /* { dg-warning "some locales" "2-digit year" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-strftime-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-strftime-2.c
new file mode 100644
index 000000000..9a6ae3545
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_c99-strftime-2.c
@@ -0,0 +1,20 @@
+/* Test for strftime formats.  Rejection of extensions in pedantic mode.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1999 -pedantic -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  /* %P is a lowercase version of %p.  */
+  strftime (s, m, "%P", tp); /* { dg-warning "unknown" "strftime %P" } */
+  /* %k is %H but padded with a space rather than 0 if necessary.  */
+  strftime (s, m, "%k", tp); /* { dg-warning "unknown" "strftime %k" } */
+  /* %l is %I but padded with a space rather than 0 if necessary.  */
+  strftime (s, m, "%l", tp); /* { dg-warning "unknown" "strftime %l" } */
+  /* %s is the number of seconds since the Epoch.  */
+  strftime (s, m, "%s", tp); /* { dg-warning "unknown" "strftime %s" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_cast-1.c
new file mode 100644
index 000000000..08659616e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_cast-1.c
@@ -0,0 +1,17 @@
+/* Test for strings cast through integer types: should not be treated
+   as format strings unless the types are of the same width as
+   pointers (intptr_t or similar).  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+f (int x)
+{
+  printf("%s", x); /* { dg-warning "format" } */
+  printf((char *)(size_t)"%s", x); /* { dg-warning "format" } */
+  printf((char *)(char)"%s", x); /* { dg-warning "cast from pointer to integer of different size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-1.c
new file mode 100644
index 000000000..b6c71c04f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-1.c
@@ -0,0 +1,40 @@
+/* Test for warnings for missing format attributes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (const char *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap); /* { dg-warning "candidate" "printf attribute warning" } */
+  va_end (ap);
+}
+
+void
+bar (const char *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vscanf (fmt, ap); /* { dg-warning "candidate" "scanf attribute warning" } */
+  va_end (ap);
+}
+
+__attribute__((__format__(__ms_printf__, 1, 2))) void
+foo2 (const char *fmt, ...)
+{
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+}
+
+void
+vfoo (const char *fmt, va_list arg)
+{
+  vprintf (fmt, arg); /* { dg-warning "candidate" "printf attribute warning 2" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-2.c
new file mode 100644
index 000000000..e0dd465f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-2.c
@@ -0,0 +1,17 @@
+/* Test for warnings for missing format attributes.  Don't warn if no
+   relevant parameters for a format attribute; see c/1017.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  vprintf ("Foo %s bar %s", ap); /* { dg-bogus "candidate" "bogus printf attribute warning" } */
+  va_end (ap);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-3.c
new file mode 100644
index 000000000..cf41756c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-3.c
@@ -0,0 +1,27 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(__ms_printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(__ms_printf__, 1, 0))) vattr_t;
+
+void
+foo1 (noattr_t na, attr_t a, vnoattr_t vna, vattr_t va)
+{
+  noattr_t na1 = na;
+  noattr_t na2 = a; /* { dg-warning "candidate" "initialization warning" } */
+  attr_t a1 = na;
+  attr_t a2 = a;
+
+  vnoattr_t vna1 = vna;
+  vnoattr_t vna2 = va; /* { dg-warning "candidate" "initialization warning" } */
+  vattr_t va1 = vna;
+  vattr_t va2 = va;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-4.c
new file mode 100644
index 000000000..faacf5ce4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-4.c
@@ -0,0 +1,33 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(__ms_printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(__ms_printf__, 1, 0))) vattr_t;
+
+void
+foo1 (noattr_t na, attr_t a, vnoattr_t vna, vattr_t va)
+{
+  noattr_t na1, na2;
+  attr_t a1, a2;
+
+  vnoattr_t vna1, vna2;
+  vattr_t va1, va2;
+
+  na1 = na;
+  na2 = a; /* { dg-warning "candidate" "assignment warning" } */
+  a1 = na;
+  a2 = a;
+
+  vna1 = vna;
+  vna2 = va; /* { dg-warning "candidate" "assignment warning" } */
+  va1 = vna;
+  va1 = va;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-5.c
new file mode 100644
index 000000000..a9f54c3a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-5.c
@@ -0,0 +1,49 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(__ms_printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(__ms_printf__, 1, 0))) vattr_t;
+
+noattr_t
+foo1 (noattr_t na, attr_t a, int i)
+{
+  if (i)
+    return na;
+  else
+    return a; /* { dg-warning "candidate" "return type warning" } */
+}
+
+attr_t
+foo2 (noattr_t na, attr_t a, int i)
+{
+  if (i)
+    return na;
+  else
+    return a;
+}
+
+vnoattr_t
+foo3 (vnoattr_t vna, vattr_t va, int i)
+{
+  if (i)
+    return vna;
+  else
+    return va; /* { dg-warning "candidate" "return type warning" } */
+}
+
+vattr_t
+foo4 (vnoattr_t vna, vattr_t va, int i)
+{
+  if (i)
+    return vna;
+  else
+    return va;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-6.c
new file mode 100644
index 000000000..3e210deee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_miss-6.c
@@ -0,0 +1,32 @@
+/* Test warnings for missing format attributes on function pointers.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wmissing-format-attribute" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+typedef void (*noattr_t) (const char *, ...);
+typedef noattr_t __attribute__ ((__format__(__ms_printf__, 1, 2))) attr_t;
+
+typedef void (*vnoattr_t) (const char *, va_list);
+typedef vnoattr_t __attribute__ ((__format__(__ms_printf__, 1, 0))) vattr_t;
+
+extern void foo1 (noattr_t);
+extern void foo2 (attr_t);
+extern void foo3 (vnoattr_t);
+extern void foo4 (vattr_t);
+
+void
+foo (noattr_t na, attr_t a, vnoattr_t vna, vattr_t va)
+{
+  foo1 (na);
+  foo1 (a); /* { dg-warning "candidate" "parameter passing warning" } */
+  foo2 (na);
+  foo2 (a);
+
+  foo3 (vna);
+  foo3 (va); /* { dg-warning "candidate" "parameter passing warning" } */
+  foo4 (vna);
+  foo4 (va);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-1.c
new file mode 100644
index 000000000..0936f5f6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-1.c
@@ -0,0 +1,51 @@
+/* Test for multiple format attributes.  Test for printf and scanf attributes
+   together.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+/* If we specify multiple attributes for a single function, they should
+   all apply.  This should apply whether they are on the same declaration
+   or on different declarations.  */
+
+extern void my_vprintf_scanf (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_printf__, 1, 0)))
+     __attribute__((__format__(__ms_scanf__, 3, 4)));
+
+extern void my_vprintf_scanf2 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_scanf__, 3, 4)))
+     __attribute__((__format__(__ms_printf__, 1, 0)));
+
+extern void my_vprintf_scanf3 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_printf__, 1, 0)));
+extern void my_vprintf_scanf3 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_scanf__, 3, 4)));
+
+extern void my_vprintf_scanf4 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_scanf__, 3, 4)));
+extern void my_vprintf_scanf4 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_printf__, 1, 0)));
+
+void
+foo (va_list ap, int *ip, long *lp)
+{
+  my_vprintf_scanf ("%d", ap, "%d", ip);
+  my_vprintf_scanf ("%d", ap, "%ld", lp);
+  my_vprintf_scanf ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf2 ("%d", ap, "%d", ip);
+  my_vprintf_scanf2 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf2 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf2 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf3 ("%d", ap, "%d", ip);
+  my_vprintf_scanf3 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf3 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf3 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf4 ("%d", ap, "%d", ip);
+  my_vprintf_scanf4 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf4 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf4 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-2.c
new file mode 100644
index 000000000..47e20e4d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-2.c
@@ -0,0 +1,40 @@
+/* Test for multiple format attributes.  Test for printf and scanf attributes
+   together, in different places on the declarations.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+/* If we specify multiple attributes for a single function, they should
+   all apply, wherever they are placed on the declarations.  */
+
+extern __attribute__((__format__(__ms_printf__, 1, 0))) void
+     my_vprintf_scanf (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_scanf__, 3, 4)));
+
+extern void (__attribute__((__format__(__ms_printf__, 1, 0))) my_vprintf_scanf2)
+     (const char *, va_list, const char *, ...)
+     __attribute__((__format__(__ms_scanf__, 3, 4)));
+
+extern __attribute__((__format__(__ms_scanf__, 3, 4))) void
+     (__attribute__((__format__(__ms_printf__, 1, 0))) my_vprintf_scanf3)
+     (const char *, va_list, const char *, ...);
+
+void
+foo (va_list ap, int *ip, long *lp)
+{
+  my_vprintf_scanf ("%d", ap, "%d", ip);
+  my_vprintf_scanf ("%d", ap, "%ld", lp);
+  my_vprintf_scanf ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf2 ("%d", ap, "%d", ip);
+  my_vprintf_scanf2 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf2 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf2 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf3 ("%d", ap, "%d", ip);
+  my_vprintf_scanf3 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf3 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf3 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-3.c
new file mode 100644
index 000000000..1a247a7a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_multattr-3.c
@@ -0,0 +1,29 @@
+/* Test for multiple format_arg attributes.  Test for both branches
+   getting checked.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+extern char *ngettext (const char *, const char *, unsigned long int)
+     __attribute__((__format_arg__(1))) __attribute__((__format_arg__(2)));
+
+void
+foo (long l, int nfoo)
+{
+  printf (ngettext ("%d foo", "%d foos", nfoo), nfoo);
+  printf (ngettext ("%d foo", "%d foos", l), l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf (ngettext ("%d foo", "%ld foos", l), l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf (ngettext ("%ld foo", "%d foos", l), l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  /* Should allow one case to have extra arguments.  */
+  printf (ngettext ("1 foo", "%d foos", nfoo), nfoo);
+  printf (ngettext ("1 foo", "many foos", nfoo), nfoo); /* { dg-warning "too many" "too many args in all branches" } */
+  printf (ngettext ("", "%d foos", nfoo), nfoo);
+  printf (ngettext ("1 foo", (nfoo > 0) ? "%d foos" : "no foos", nfoo), nfoo);
+  printf (ngettext ("%d foo", (nfoo > 0) ? "%d foos" : "no foos", nfoo), nfoo);
+  printf (ngettext ("%ld foo", (nfoo > 0) ? "%d foos" : "no foos", nfoo), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf (ngettext ("%d foo", (nfoo > 0) ? "%ld foos" : "no foos", nfoo), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf (ngettext ("%d foo", (nfoo > 0) ? "%d foos" : "%ld foos", nfoo), nfoo); /* { dg-warning "long int" "wrong type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-exargs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-exargs-1.c
new file mode 100644
index 000000000..659ca3e0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-exargs-1.c
@@ -0,0 +1,15 @@
+/* Test for warnings for extra format arguments being disabled by
+   -Wno-format-extra-args.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat -Wno-format-extra-args" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i)
+{
+  printf ("foo", i);
+  printf ("%1$d", i, i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-exargs-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-exargs-2.c
new file mode 100644
index 000000000..654241ddf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-exargs-2.c
@@ -0,0 +1,28 @@
+/* Test for warnings for extra format arguments being disabled by
+   -Wno-format-extra-args.  Test which warnings still apply with $
+   operand numbers.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat -Wno-format-extra-args" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i, int *ip, va_list va)
+{
+  printf ("%3$d%1$d", i, i, i); /* { dg-warning "before used" "unused $ operand" } */
+  printf ("%2$d%1$d", i, i, i);
+  vprintf ("%3$d%1$d", va); /* { dg-warning "before used" "unused $ operand" } */
+  /* With scanf formats, gaps in the used arguments are allowed only if the
+     arguments are all pointers.  In such a case, should only give the lesser
+     warning about unused arguments rather than the more serious one about
+     argument gaps.  */
+  scanf ("%3$d%1$d", ip, ip, ip);
+  /* If there are non-pointer arguments unused at the end, this is also OK.  */
+  scanf ("%3$d%1$d", ip, ip, ip, i);
+  scanf ("%3$d%1$d", ip, i, ip); /* { dg-warning "before used" "unused $ scanf non-pointer operand" } */
+  /* Can't check the arguments in the vscanf case, so should suppose the
+     lesser problem.  */
+  vscanf ("%3$d%1$d", va);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-y2k-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-y2k-1.c
new file mode 100644
index 000000000..aed760aab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_no-y2k-1.c
@@ -0,0 +1,13 @@
+/* Test for warnings for Y2K problems not being on by default.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  strftime (s, m, "%y%c%x", tp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-1.c
new file mode 100644
index 000000000..b29c0080e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-1.c
@@ -0,0 +1,14 @@
+/* Test for warnings for non-string-literal formats.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-nonliteral" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t i)
+{
+  printf ((const char *)i, i); /* { dg-warning "argument types" "non-literal" } */
+  printf (s, i); /* { dg-warning "argument types" "non-literal" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-2.c
new file mode 100644
index 000000000..e60242187
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-2.c
@@ -0,0 +1,14 @@
+/* Test for warnings for non-string-literal formats.  Test with -Wformat=2.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat=2" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t i)
+{
+  printf ((const char *)i, i); /* { dg-warning "argument types" "non-literal" } */
+  printf (s, i); /* { dg-warning "argument types" "non-literal" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-3.c
new file mode 100644
index 000000000..e8c8933bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nonlit-3.c
@@ -0,0 +1,13 @@
+/* Test for warnings for non-string-literal formats.  Test for strftime formats.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-nonliteral" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp, char *fmt)
+{
+  strftime (s, m, fmt, tp); /* { dg-warning "format string" "non-literal" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nul-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nul-1.c
new file mode 100644
index 000000000..50bfd546d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nul-1.c
@@ -0,0 +1,15 @@
+/* Test diagnostics for suppressing contains nul
+   -Wformat.  -Wformat.  */
+/* Origin: Bruce Korb <bkorb@gnu.org> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-Wformat -Wno-format-contains-nul" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (void)
+{
+  static char const fmt[] = "x%s\0%s\n\0abc";
+  printf (fmt+4, fmt+8); /* { dg-bogus "embedded.*in format" "bogus embed warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nul-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nul-2.c
new file mode 100644
index 000000000..3dfc3c62f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_nul-2.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-.  */
+/* Origin: Bruce Korb <bkorb@gnu.org> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-Wformat" } */
+
+/* { dg-warning "embedded .* in format" "ignored" { target *-*-* } 0 } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+fumble (void)
+{
+  static char const fmt[] = "x%s\0%s\n\0abc";
+  printf (fmt+4, fmt+8);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_null-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_null-1.c
new file mode 100644
index 000000000..91495016e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_null-1.c
@@ -0,0 +1,28 @@
+/* Test for some aspects of null format string handling.  */
+/* Origin: Jason Thorpe <thorpej@wasabisystems.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+extern void my_printf (const char *, ...) __attribute__((format(ms_printf,1,2)));
+extern const char *my_format (const char *, const char *)
+  __attribute__((format_arg(2)));
+
+void
+foo (int i1)
+{
+  /* Warning about a null format string has been decoupled from the actual
+     format check.  However, we still expect to be warned about any excess
+     arguments after a null format string.  */
+  my_printf (NULL);
+  my_printf (NULL, i1); /* { dg-warning "too many" "null format with arguments" } */
+
+  my_printf (my_format ("", NULL));
+  my_printf (my_format ("", NULL), i1); /* { dg-warning "too many" "null format_arg with arguments" } */
+
+  /* While my_printf allows a null argument, dgettext does not, so we expect
+     a null argument warning here.  */
+  my_printf (dgettext ("", NULL)); /* { dg-warning "null" "null format with dgettext" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_plus-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_plus-1.c
new file mode 100644
index 000000000..f6eba280a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_plus-1.c
@@ -0,0 +1,21 @@
+/* Test for printf formats using string literal plus constant.
+ */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat=2" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (int i)
+{
+  printf ("%%d\n" + 1, i);
+  printf (5 + "%.-*d%3d\n", i);
+  printf ("%d%d" + 2, i, i);	/* { dg-warning "arguments" "wrong number of args" } */
+  printf (3 + "%d\n");		/* { dg-warning "zero-length" "zero-length string" } */
+  printf ("%d\n" + i, i);	/* { dg-warning "not a string" "non-constant addend" } */
+  printf ("%d\n" + 10);		/* { dg-warning "not a string" "too large addend" } */
+  printf ("%d\n" - 1, i);	/* { dg-warning "not a string" "minus constant" } */
+  printf ("%d\n" + -1, i);	/* { dg-warning "not a string" "negative addend" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_sec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_sec-1.c
new file mode 100644
index 000000000..5f6b76726
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_sec-1.c
@@ -0,0 +1,13 @@
+/* Test for security warning when non-literal format has no arguments.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-security" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (char *s)
+{
+  printf (s); /* { dg-warning "no format arguments" "security warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_unnamed-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_unnamed-1.c
new file mode 100644
index 000000000..aa4f6cb5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_unnamed-1.c
@@ -0,0 +1,24 @@
+/* Test for warnings with possibly unnamed integer types.  Bug 24329.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-Wformat" } */
+/* { dg-options "-Wformat -msse" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+/* Definition of TItype follows same logic as in gcc.dg/titype-1.c,
+   but must be a #define to avoid giving the type a name.  */
+#if defined(__LP64__) && !defined(__hppa__)
+#define TItype int __attribute__ ((mode (TI)))
+#else
+#define TItype long
+#endif
+
+void
+f (TItype x)
+{
+  printf("%d", x); /* { dg-warning "expects type" } */
+  printf("%d", 141592653589793238462643383279502884197169399375105820974944); /* { dg-warning "expects type" } */
+  /* { dg-warning "unsigned only|too large" "constant" { target *-*-* } 22 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_va-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_va-1.c
new file mode 100644
index 000000000..97d2979e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_va-1.c
@@ -0,0 +1,14 @@
+/* Test for strange warning in format checking.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-Wformat" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (void *p)
+{
+  printf ("%d", p); /* { dg-bogus "va_list" "wrong type in format warning" } */
+  /* { dg-warning "format" "format error" { target *-*-* } 12 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_zero-length-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_zero-length-1.c
new file mode 100644
index 000000000..d024458a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/ms_zero-length-1.c
@@ -0,0 +1,16 @@
+/* Test the -Wno-format-zero-length option, which suppresses warnings
+   about zero-length formats.  */
+/* Origin: Jason Thorpe <thorpej@wasabisystems.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wno-format-zero-length" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+void
+foo (void)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.1 (pages 131-134).  */
+  /* Zero-length format strings are allowed.  */
+  printf ("");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-1.c
new file mode 100644
index 000000000..c7404bedf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-1.c
@@ -0,0 +1,51 @@
+/* Test for multiple format attributes.  Test for printf and scanf attributes
+   together.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+/* If we specify multiple attributes for a single function, they should
+   all apply.  This should apply whether they are on the same declaration
+   or on different declarations.  */
+
+extern void my_vprintf_scanf (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___printf__, 1, 0)))
+     __attribute__((__format__(gnu_attr___scanf__, 3, 4)));
+
+extern void my_vprintf_scanf2 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___scanf__, 3, 4)))
+     __attribute__((__format__(gnu_attr___printf__, 1, 0)));
+
+extern void my_vprintf_scanf3 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___printf__, 1, 0)));
+extern void my_vprintf_scanf3 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___scanf__, 3, 4)));
+
+extern void my_vprintf_scanf4 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___scanf__, 3, 4)));
+extern void my_vprintf_scanf4 (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___printf__, 1, 0)));
+
+void
+foo (va_list ap, int *ip, long *lp)
+{
+  my_vprintf_scanf ("%d", ap, "%d", ip);
+  my_vprintf_scanf ("%d", ap, "%ld", lp);
+  my_vprintf_scanf ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf2 ("%d", ap, "%d", ip);
+  my_vprintf_scanf2 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf2 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf2 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf3 ("%d", ap, "%d", ip);
+  my_vprintf_scanf3 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf3 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf3 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf4 ("%d", ap, "%d", ip);
+  my_vprintf_scanf4 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf4 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf4 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-2.c
new file mode 100644
index 000000000..4011bf145
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-2.c
@@ -0,0 +1,40 @@
+/* Test for multiple format attributes.  Test for printf and scanf attributes
+   together, in different places on the declarations.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+/* If we specify multiple attributes for a single function, they should
+   all apply, wherever they are placed on the declarations.  */
+
+extern __attribute__((__format__(gnu_attr___printf__, 1, 0))) void
+     my_vprintf_scanf (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___scanf__, 3, 4)));
+
+extern void (__attribute__((__format__(gnu_attr___printf__, 1, 0))) my_vprintf_scanf2)
+     (const char *, va_list, const char *, ...)
+     __attribute__((__format__(gnu_attr___scanf__, 3, 4)));
+
+extern __attribute__((__format__(gnu_attr___scanf__, 3, 4))) void
+     (__attribute__((__format__(gnu_attr___printf__, 1, 0))) my_vprintf_scanf3)
+     (const char *, va_list, const char *, ...);
+
+void
+foo (va_list ap, int *ip, long *lp)
+{
+  my_vprintf_scanf ("%d", ap, "%d", ip);
+  my_vprintf_scanf ("%d", ap, "%ld", lp);
+  my_vprintf_scanf ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf2 ("%d", ap, "%d", ip);
+  my_vprintf_scanf2 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf2 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf2 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+  my_vprintf_scanf3 ("%d", ap, "%d", ip);
+  my_vprintf_scanf3 ("%d", ap, "%ld", lp);
+  my_vprintf_scanf3 ("%", ap, "%d", ip); /* { dg-warning "format" "printf" } */
+  my_vprintf_scanf3 ("%d", ap, "%ld", ip); /* { dg-warning "format" "scanf" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-3.c
new file mode 100644
index 000000000..1d4979a4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/multattr-3.c
@@ -0,0 +1,28 @@
+/* Test for multiple format_arg attributes.  Test for both branches
+   getting checked.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+extern char *ngettext (const char *, const char *, unsigned long int)
+     __attribute__((__format_arg__(1))) __attribute__((__format_arg__(2)));
+
+void
+foo (long l, int nfoo)
+{
+  printf (ngettext ("%d foo", "%d foos", nfoo), nfoo);
+  printf (ngettext ("%d foo", "%d foos", l), l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf (ngettext ("%d foo", "%ld foos", l), l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  printf (ngettext ("%ld foo", "%d foos", l), l); /* { dg-warning "int" "wrong type in conditional expr" } */
+  /* Should allow one case to have extra arguments.  */
+  printf (ngettext ("1 foo", "%d foos", nfoo), nfoo);
+  printf (ngettext ("1 foo", "many foos", nfoo), nfoo); /* { dg-warning "too many" "too many args in all branches" } */
+  printf (ngettext ("", "%d foos", nfoo), nfoo);
+  printf (ngettext ("1 foo", (nfoo > 0) ? "%d foos" : "no foos", nfoo), nfoo);
+  printf (ngettext ("%d foo", (nfoo > 0) ? "%d foos" : "no foos", nfoo), nfoo);
+  printf (ngettext ("%ld foo", (nfoo > 0) ? "%d foos" : "no foos", nfoo), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf (ngettext ("%d foo", (nfoo > 0) ? "%ld foos" : "no foos", nfoo), nfoo); /* { dg-warning "long int" "wrong type" } */
+  printf (ngettext ("%d foo", (nfoo > 0) ? "%d foos" : "%ld foos", nfoo), nfoo); /* { dg-warning "long int" "wrong type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-exargs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-exargs-1.c
new file mode 100644
index 000000000..75247087f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-exargs-1.c
@@ -0,0 +1,14 @@
+/* Test for warnings for extra format arguments being disabled by
+   -Wno-format-extra-args.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -Wno-format-extra-args" } */
+
+#include "format.h"
+
+void
+foo (int i)
+{
+  printf ("foo", i);
+  printf ("%1$d", i, i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-exargs-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-exargs-2.c
new file mode 100644
index 000000000..3fa928578
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-exargs-2.c
@@ -0,0 +1,27 @@
+/* Test for warnings for extra format arguments being disabled by
+   -Wno-format-extra-args.  Test which warnings still apply with $
+   operand numbers.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -Wno-format-extra-args" } */
+
+#include "format.h"
+
+void
+foo (int i, int *ip, va_list va)
+{
+  printf ("%3$d%1$d", i, i, i); /* { dg-warning "before used" "unused $ operand" } */
+  printf ("%2$d%1$d", i, i, i);
+  vprintf ("%3$d%1$d", va); /* { dg-warning "before used" "unused $ operand" } */
+  /* With scanf formats, gaps in the used arguments are allowed only if the
+     arguments are all pointers.  In such a case, should only give the lesser
+     warning about unused arguments rather than the more serious one about
+     argument gaps.  */
+  scanf ("%3$d%1$d", ip, ip, ip);
+  /* If there are non-pointer arguments unused at the end, this is also OK.  */
+  scanf ("%3$d%1$d", ip, ip, ip, i);
+  scanf ("%3$d%1$d", ip, i, ip); /* { dg-warning "before used" "unused $ scanf non-pointer operand" } */
+  /* Can't check the arguments in the vscanf case, so should suppose the
+     lesser problem.  */
+  vscanf ("%3$d%1$d", va);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-y2k-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-y2k-1.c
new file mode 100644
index 000000000..4dfd5a04e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/no-y2k-1.c
@@ -0,0 +1,12 @@
+/* Test for warnings for Y2K problems not being on by default.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp)
+{
+  strftime (s, m, "%y%c%x", tp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-1.c
new file mode 100644
index 000000000..af0cd3723
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-1.c
@@ -0,0 +1,13 @@
+/* Test for warnings for non-string-literal formats.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-nonliteral" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t i)
+{
+  printf ((const char *)i, i); /* { dg-warning "argument types" "non-literal" } */
+  printf (s, i); /* { dg-warning "argument types" "non-literal" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-2.c
new file mode 100644
index 000000000..2ca2e4803
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-2.c
@@ -0,0 +1,13 @@
+/* Test for warnings for non-string-literal formats.  Test with -Wformat=2.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat=2" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t i)
+{
+  printf ((const char *)i, i); /* { dg-warning "argument types" "non-literal" } */
+  printf (s, i); /* { dg-warning "argument types" "non-literal" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-3.c
new file mode 100644
index 000000000..ce94c8c36
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nonlit-3.c
@@ -0,0 +1,12 @@
+/* Test for warnings for non-string-literal formats.  Test for strftime formats.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-nonliteral" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, const struct tm *tp, char *fmt)
+{
+  strftime (s, m, fmt, tp); /* { dg-warning "format string" "non-literal" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nul-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nul-1.c
new file mode 100644
index 000000000..c45453dba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nul-1.c
@@ -0,0 +1,14 @@
+/* Test diagnostics for suppressing contains nul
+   -Wformat.  -Wformat.  */
+/* Origin: Bruce Korb <bkorb@gnu.org> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat -Wno-format-contains-nul" } */
+
+#include "format.h"
+
+void
+foo (void)
+{
+  static char const fmt[] = "x%s\0%s\n\0abc";
+  printf (fmt+4, fmt+8); /* { dg-bogus "embedded.*in format" "bogus embed warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nul-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nul-2.c
new file mode 100644
index 000000000..4c9159658
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/nul-2.c
@@ -0,0 +1,16 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-.  */
+/* Origin: Bruce Korb <bkorb@gnu.org> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+/* { dg-warning "embedded .* in format" "ignored" { target *-*-* } 0 } */
+
+#include "format.h"
+
+void
+fumble (void)
+{
+  static char const fmt[] = "x%s\0%s\n\0abc";
+  printf (fmt+4, fmt+8);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/null-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/null-1.c
new file mode 100644
index 000000000..ed714442b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/null-1.c
@@ -0,0 +1,28 @@
+/* Test for some aspects of null format string handling.  */
+/* Origin: Jason Thorpe <thorpej@wasabisystems.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#define DONT_GNU_PROTOTYPE
+#include "format.h"
+
+extern void my_printf (const char *, ...) __attribute__((format(gnu_attr_printf,1,2)));
+extern const char *my_format (const char *, const char *)
+  __attribute__((format_arg(2)));
+
+void
+foo (int i1)
+{
+  /* Warning about a null format string has been decoupled from the actual
+     format check.  However, we still expect to be warned about any excess
+     arguments after a null format string.  */
+  my_printf (NULL);
+  my_printf (NULL, i1); /* { dg-warning "too many" "null format with arguments" } */
+
+  my_printf (my_format ("", NULL));
+  my_printf (my_format ("", NULL), i1); /* { dg-warning "too many" "null format_arg with arguments" } */
+
+  /* While my_printf allows a null argument, dgettext does not, so we expect
+     a null argument warning here.  */
+  my_printf (dgettext ("", NULL)); /* { dg-warning "null" "null format with dgettext" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-1.c
new file mode 100644
index 000000000..f8f370448
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-1.c
@@ -0,0 +1,7 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-extra-args.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat-extra-args" } */
+
+/* { dg-warning "-Wformat-extra-args ignored without -Wformat" "ignored" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-2.c
new file mode 100644
index 000000000..1ec9f0141
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-2.c
@@ -0,0 +1,7 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-nonliteral.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat-nonliteral" } */
+
+/* { dg-warning "-Wformat-nonliteral ignored without -Wformat" "ignored" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-3.c
new file mode 100644
index 000000000..03f55e436
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-3.c
@@ -0,0 +1,7 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-security.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat-security" } */
+
+/* { dg-warning "-Wformat-security ignored without -Wformat" "ignored" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-4.c
new file mode 100644
index 000000000..f02b6c094
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-4.c
@@ -0,0 +1,7 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-y2k.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat-y2k" } */
+
+/* { dg-warning "-Wformat-y2k ignored without -Wformat" "ignored" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-5.c
new file mode 100644
index 000000000..3315e3358
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-5.c
@@ -0,0 +1,7 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-zero-length.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat-zero-length" } */
+
+/* { dg-warning "-Wformat-zero-length ignored without -Wformat" "ignored" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-6.c
new file mode 100644
index 000000000..29dedfae5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/opt-6.c
@@ -0,0 +1,7 @@
+/* Test diagnostics for options used on their own without
+   -Wformat.  -Wformat-contains-nul.  */
+/* Origin: Bruce Korb <bkorb@gnu.org> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat-contains-nul" } */
+
+/* { dg-warning "-Wformat-contains-nul ignored without -Wformat" "ignored" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/plus-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/plus-1.c
new file mode 100644
index 000000000..02a213d41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/plus-1.c
@@ -0,0 +1,20 @@
+/* Test for printf formats using string literal plus constant.
+ */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat=2" } */
+
+#include "format.h"
+
+void
+foo (int i)
+{
+  printf ("%%d\n" + 1, i);
+  printf (5 + "%.-*d%3d\n", i);
+  printf ("%d%d" + 2, i, i);	/* { dg-warning "arguments" "wrong number of args" } */
+  printf (3 + "%d\n");		/* { dg-warning "zero-length" "zero-length string" } */
+  printf ("%d\n" + i, i);	/* { dg-warning "not a string" "non-constant addend" } */
+  printf ("%d\n" + 10);		/* { dg-warning "not a string" "too large addend" } */
+  printf ("%d\n" - 1, i);	/* { dg-warning "not a string" "minus constant" } */
+  printf ("%d\n" + -1, i);	/* { dg-warning "not a string" "negative addend" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sec-1.c
new file mode 100644
index 000000000..9189b51e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sec-1.c
@@ -0,0 +1,12 @@
+/* Test for security warning when non-literal format has no arguments.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat -Wformat-security" } */
+
+#include "format.h"
+
+void
+foo (char *s)
+{
+  printf (s); /* { dg-warning "no format arguments" "security warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sentinel-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sentinel-1.c
new file mode 100644
index 000000000..1dc090870
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sentinel-1.c
@@ -0,0 +1,73 @@
+/* Test for attribute sentinel.  */
+/* Origin: Kaveh Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include <stddef.h> /* For NULL, which must be (ptr)0.  */
+
+extern int execl (const char *, const char *, ...);
+extern int execlp (const char *, const char *, ...);
+extern int execle (const char *, const char *, ...);
+extern char *envp[];
+
+#define ATTR __attribute__ ((__sentinel__))
+
+extern int a ATTR; /* { dg-warning "applies to function types" "sentinel" } */
+
+extern void foo1 (const char *, ...) ATTR;
+extern void foo2 (...) ATTR; /* { dg-error "ISO C requires|named arguments" "sentinel" } */
+extern void foo3 () ATTR; /* { dg-warning "named arguments" "sentinel" } */
+extern void foo4 (const char *, int) ATTR; /* { dg-warning "variadic functions" "sentinel" } */
+extern void foo5 (const char *, ...) __attribute__ ((__sentinel__(1)));
+extern void foo6 (const char *, ...) __attribute__ ((__sentinel__(5)));
+extern void foo7 (const char *, ...) __attribute__ ((__sentinel__(0)));
+extern void foo8 (const char *, ...) __attribute__ ((__sentinel__("a"))); /* { dg-warning "not an integer constant" "sentinel" } */
+extern void foo9 (const char *, ...) __attribute__ ((__sentinel__(-1))); /* { dg-warning "less than zero" "sentinel" } */
+extern void foo10 (const char *, ...) __attribute__ ((__sentinel__(1,3))); /* { dg-error "wrong number of arguments" "sentinel" } */
+
+extern void bar(void)
+{
+  foo1 (); /* { dg-error "not enough|too few arguments" "sentinel" } */
+  foo1 (NULL); /* { dg-warning "not enough" "sentinel" } */
+  foo1 ("a"); /* { dg-warning "not enough" "sentinel" } */
+  foo1 ("a", 1); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo1 ("a", 0); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo1 ("a", (void*)1); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo1 ("a", NULL, 1); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo1 ("a", NULL);
+
+  foo5 (NULL); /* { dg-warning "not enough" "sentinel" } */
+  foo5 (NULL, 1); /* { dg-warning "not enough" "sentinel" } */
+  foo5 ("a", NULL); /* { dg-warning "not enough" "sentinel" } */
+  foo5 ("a", NULL, 1);
+  foo5 ("a", 1, 2, 3, NULL); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo5 ("a", 1, 2, NULL, 3);
+  foo5 ("a", 1, NULL, 2, 3); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo5 ("a", NULL, 1, 2, 3); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo5 ("a", 0, 1, 2, 3); /* { dg-warning "missing sentinel" "sentinel" } */
+
+  foo6 ("a", 1, NULL); /* { dg-warning "not enough" "sentinel" } */
+  foo6 ("a", 1, NULL, 2); /* { dg-warning "not enough" "sentinel" } */
+  foo6 ("a", 1, NULL, 2, 3); /* { dg-warning "not enough" "sentinel" } */
+  foo6 ("a", NULL, 1, 2, 3); /* { dg-warning "not enough" "sentinel" } */
+  foo6 ("a", NULL, 1, 2, 3, 4); /* { dg-warning "not enough" "sentinel" } */
+  foo6 (NULL, 1, 2, 3, 4, 5); /* { dg-warning "not enough" "sentinel" } */
+  foo6 ("a", NULL, 1, 2, 3, 4, 5);
+  foo6 ("a", 0, NULL, 1, 2, 3, 4, 5);
+  foo6 ("a", 0, 1, 2, 3, 4, 5); /* { dg-warning "missing sentinel" "sentinel" } */
+  foo6 ("a", NULL, 1, 2, 3, 4, 5, 6); /* { dg-warning "missing sentinel" "sentinel" } */
+
+  foo7 ("a", 1, 2, 3, NULL);
+
+  execl ("/bin/ls", "/bin/ls", "-aFC"); /* { dg-warning "missing sentinel" "sentinel" } */
+  execl ("/bin/ls", "/bin/ls", "-aFC", 0); /* { dg-warning "missing sentinel" "sentinel" } */
+  execl ("/bin/ls", "/bin/ls", "-aFC", NULL);
+
+  execlp ("ls", "ls", "-aFC"); /* { dg-warning "missing sentinel" "sentinel" } */
+  execlp ("ls", "ls", "-aFC", 0); /* { dg-warning "missing sentinel" "sentinel" } */
+  execlp ("ls", "ls", "-aFC", NULL);
+
+  execle ("ls", "ls", "-aFC", ".", envp); /* { dg-warning "missing sentinel" "sentinel" } */
+  execle ("ls", "ls", "-aFC", ".", 0, envp); /* { dg-warning "missing sentinel" "sentinel" } */
+  execle ("ls", "ls", "-aFC", ".", NULL, envp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/strfmon-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/strfmon-1.c
new file mode 100644
index 000000000..d16375132
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/strfmon-1.c
@@ -0,0 +1,63 @@
+/* Test for strfmon format checking.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m, double d, long double ld)
+{
+  /* Examples of valid formats from Austin Group draft 7.  */
+  strfmon (s, m, "%n", d);
+  strfmon (s, m, "%11n", d);
+  strfmon (s, m, "%#5n", d);
+  strfmon (s, m, "%=*#5n", d);
+  strfmon (s, m, "%=0#5n", d);
+  strfmon (s, m, "%^#5n", d);
+  strfmon (s, m, "%^#5.0n", d);
+  strfmon (s, m, "%^#5.4n", d);
+  strfmon (s, m, "%(#5n", d);
+  strfmon (s, m, "%!(#5n", d);
+  strfmon (s, m, "%-14#5.4n", d);
+  strfmon (s, m, "%14#5.4n", d);
+  /* Some more valid formats, including the GNU L length extension.  */
+  strfmon (s, m, "abc%-11ndef%==i%%", d, d);
+  strfmon (s, m, "%%abc%-11ndef%==Li%=%i", d, ld, d);
+  strfmon (s, m, "%Li", ld);
+  strfmon (s, m, "%11Li", ld);
+  strfmon (s, m, "%#5Li", ld);
+  strfmon (s, m, "%=*#5Li", ld);
+  strfmon (s, m, "%=0#5Li", ld);
+  strfmon (s, m, "%^#5Li", ld);
+  strfmon (s, m, "%^#5.0Li", ld);
+  strfmon (s, m, "%^#5.4Li", ld);
+  strfmon (s, m, "%(#5Li", ld);
+  strfmon (s, m, "%!(#5Li", ld);
+  strfmon (s, m, "%-14#5.4Li", ld);
+  strfmon (s, m, "%14#5.4Li", ld);
+  /* Formats with the wrong types used.  */
+  strfmon (s, m, "%Ln", d); /* { dg-warning "format" "wrong type" } */
+  strfmon (s, m, "%n", ld); /* { dg-warning "format" "wrong type" } */
+  /* The + and ( flags cannot be used together.  */
+  strfmon (s, m, "%+(i", d); /* { dg-warning "flag" "+ and ( flags" } */
+  strfmon (s, m, "%(+i", d); /* { dg-warning "flag" "+ and ( flags" } */
+  /* Although empty precision is OK for printf, it isn't here.  */
+  strfmon (s, m, "%#.5n", d); /* { dg-warning "empty" "empty left precision" } */
+  strfmon (s, m, "%#5.n", d); /* { dg-warning "empty" "empty right precision" } */
+  /* However, zero is a valid value for width and precisions.  */
+  strfmon (s, m, "%0#0.0n", d);
+  /* Test bogus %% constructions.  */
+  strfmon (s, m, "%^%"); /* { dg-warning "format" "bogus %%" } */
+  strfmon (s, m, "%!%\n"); /* { dg-warning "format" "bogus %%" } */
+  strfmon (s, m, "%5%\n"); /* { dg-warning "format" "bogus %%" } */
+  strfmon (s, m, "%.5%\n"); /* { dg-warning "format" "bogus %%" } */
+  strfmon (s, m, "%#5%\n"); /* { dg-warning "format" "bogus %%" } */
+  /* Miscellaneous bogus formats.  */
+  strfmon (s, m, "%n%n", d); /* { dg-warning "arguments" "too few args" } */
+  strfmon (s, m, ""); /* { dg-warning "zero-length" "empty" } */
+  strfmon (s, m, NULL); /* { dg-warning "null" "null format string" } */
+  strfmon (s, m, "%"); /* { dg-warning "trailing" "tailing %" } */
+  strfmon (s, m, "%n\0", d); /* { dg-warning "embedded" "embedded NUL" } */
+  strfmon (s, m, "%^^n", d); /* { dg-warning "repeated" "repeated flag" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/strfmon-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/strfmon-2.c
new file mode 100644
index 000000000..1ecef711d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/strfmon-2.c
@@ -0,0 +1,13 @@
+/* Test for strfmon format checking.  Test for missing fill character
+   at end of format.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (char *s, size_t m)
+{
+  strfmon (s, m, "%="); /* { dg-warning "missing fill character at end" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sys_format.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sys_format.c
new file mode 100755
index 000000000..b69ae5bc5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/sys_format.c
@@ -0,0 +1,14 @@
+/* Test system default printf formatter specifiers.  */
+/* Origin: Kai Tietz <KaiTietz.@onevision.com> */
+/* { dg-do compile { target { *-*-mingw* } } } */
+/* { dg-options "-std=gnu89" } */
+
+#define USE_SYSTEM_FORMATS
+#include "format.h"
+
+__attribute__((format(printf, 1, 2))) void foo (const char *, ...);
+
+void bar (long long v1, long v2, int v3)
+{
+  foo ("%I64d %I32d %ld %d\n", v1, v2, v2, v3);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/unnamed-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/unnamed-1.c
new file mode 100644
index 000000000..2d4f77cc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/unnamed-1.c
@@ -0,0 +1,24 @@
+/* Test for warnings with possibly unnamed integer types.  Bug 24329.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+/* { dg-options "-Wformat -msse" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+
+#include "format.h"
+
+/* Definition of TItype follows same logic as in gcc.dg/titype-1.c,
+   but must be a #define to avoid giving the type a name.  */
+#if defined(__LP64__) && !defined(__hppa__)
+#define TItype int __attribute__ ((mode (TI)))
+#else
+#define TItype long
+#endif
+
+void
+f (TItype x)
+{
+  printf("%d", x); /* { dg-warning "expects type" } */
+  printf("%d", 141592653589793238462643383279502884197169399375105820974944); /* { dg-warning "expects type" } */
+  /* { dg-warning "unsigned only|too large" "constant" { target *-*-* } 22 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/va-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/va-1.c
new file mode 100644
index 000000000..5f5eeab4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/va-1.c
@@ -0,0 +1,13 @@
+/* Test for strange warning in format checking.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+void
+foo (void *p)
+{
+  printf ("%d", p); /* { dg-bogus "va_list" "wrong type in format warning" } */
+  /* { dg-warning "format" "format error" { target *-*-* } 11 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/warnll-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/warnll-1.c
new file mode 100644
index 000000000..2d2277693
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/warnll-1.c
@@ -0,0 +1,45 @@
+/* Test for printf formats.  C99 "long long" formats should be accepted with
+   -Wno-long-long.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wno-long-long" } */
+
+#include "format.h"
+
+void
+foo (long long ll, unsigned long long ull, long long *lln,
+     long long *llp, unsigned long long *ullp)
+{
+  /* Test for accepting standard "long long" formats.  */
+  printf ("%lld%lli%llo%llu%llx%llX%lln", ll, ll, ull, ull, ull, ull, lln);
+  scanf ("%lld%lli%llo%llu%llx%llX%lln", llp, llp,
+	 ullp, ullp, ullp, ullp, lln);
+  /* Use of "q" and "L" should still be warned about.  */
+  printf ("%qd", ll); /* { dg-warning "C" "printf %qd" } */
+  printf ("%qi", ll); /* { dg-warning "C" "printf %qi" } */
+  printf ("%qo", ull); /* { dg-warning "C" "printf %qo" } */
+  printf ("%qu", ull); /* { dg-warning "C" "printf %qu" } */
+  printf ("%qx", ull); /* { dg-warning "C" "printf %qx" } */
+  printf ("%qX", ull); /* { dg-warning "C" "printf %qX" } */
+  printf ("%qn", lln); /* { dg-warning "C" "printf %qn" } */
+  printf ("%Ld", ll); /* { dg-warning "C" "printf %Ld" } */
+  printf ("%Li", ll); /* { dg-warning "C" "printf %Li" } */
+  printf ("%Lo", ull); /* { dg-warning "C" "printf %oL" } */
+  printf ("%Lu", ull); /* { dg-warning "C" "printf %Lu" } */
+  printf ("%Lx", ull); /* { dg-warning "C" "printf %Lx" } */
+  printf ("%LX", ull); /* { dg-warning "C" "printf %LX" } */
+  scanf ("%qd", llp); /* { dg-warning "C" "scanf %qd" } */
+  scanf ("%qi", llp); /* { dg-warning "C" "scanf %qi" } */
+  scanf ("%qo", ullp); /* { dg-warning "C" "scanf %qo" } */
+  scanf ("%qu", ullp); /* { dg-warning "C" "scanf %qu" } */
+  scanf ("%qx", ullp); /* { dg-warning "C" "scanf %qx" } */
+  scanf ("%qX", ullp); /* { dg-warning "C" "scanf %qX" } */
+  scanf ("%qn", lln); /* { dg-warning "C" "scanf %qn" } */
+  scanf ("%Ld", llp); /* { dg-warning "C" "scanf %Ld" } */
+  scanf ("%Li", llp); /* { dg-warning "C" "scanf %Li" } */
+  scanf ("%Lo", ullp); /* { dg-warning "C" "scanf %oL" } */
+  scanf ("%Lu", ullp); /* { dg-warning "C" "scanf %Lu" } */
+  scanf ("%Lx", ullp); /* { dg-warning "C" "scanf %Lx" } */
+  scanf ("%LX", ullp); /* { dg-warning "C" "scanf %LX" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-1.c
new file mode 100644
index 000000000..9b098fb1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-1.c
@@ -0,0 +1,125 @@
+/* Test for X/Open format extensions, as found in the
+   Single Unix Specification and in Austin Group draft 7.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i, unsigned int u, wint_t lc, wchar_t *ls, int *ip, double d,
+     char *s, void *p, int *n, long int l, int i2, float *fp, long int *lp,
+     va_list va)
+{
+  /* The conversion specifiers C and S, for both printf and scanf,
+     are X/Open extensions.
+  */
+  printf ("%C", lc);
+  printf ("%3C", lc);
+  printf ("%.3C", lc); /* { dg-warning "precision" "precision with %C" } */
+  printf ("%hC", lc); /* { dg-warning "length" "bad %hC" } */
+  printf ("%hhC", lc); /* { dg-warning "length" "bad %hhC" } */
+  printf ("%lC", lc); /* { dg-warning "length" "bad %lC" } */
+  printf ("%llC", lc); /* { dg-warning "length" "bad %llC" } */
+  printf ("%jC", lc); /* { dg-warning "length" "bad %jC" } */
+  printf ("%zC", lc); /* { dg-warning "length" "bad %zC" } */
+  printf ("%tC", lc); /* { dg-warning "length" "bad %tC" } */
+  printf ("%LC", lc); /* { dg-warning "length" "bad %LC" } */
+  printf ("%-C", lc);
+  printf ("%+C", lc); /* { dg-warning "flag" "bad %+C" } */
+  printf ("% C", lc); /* { dg-warning "flag" "bad % C" } */
+  printf ("%#C", lc); /* { dg-warning "flag" "bad %#C" } */
+  printf ("%0C", lc); /* { dg-warning "flag" "bad %0C" } */
+  printf ("%'C", lc); /* { dg-warning "flag" "bad %'C" } */
+  printf ("%S", ls);
+  printf ("%3S", ls);
+  printf ("%.3S", ls);
+  printf ("%hS", ls); /* { dg-warning "length" "bad %hS" } */
+  printf ("%hhS", ls); /* { dg-warning "length" "bad %hhS" } */
+  printf ("%lS", ls); /* { dg-warning "length" "bad %lS" } */
+  printf ("%llS", ls); /* { dg-warning "length" "bad %llS" } */
+  printf ("%jS", ls); /* { dg-warning "length" "bad %jS" } */
+  printf ("%zS", ls); /* { dg-warning "length" "bad %zS" } */
+  printf ("%tS", ls); /* { dg-warning "length" "bad %tS" } */
+  printf ("%LS", ls); /* { dg-warning "length" "bad %LS" } */
+  printf ("%-S", ls);
+  printf ("%+S", ls); /* { dg-warning "flag" "bad %+S" } */
+  printf ("% S", ls); /* { dg-warning "flag" "bad % S" } */
+  printf ("%#S", ls); /* { dg-warning "flag" "bad %#S" } */
+  printf ("%0S", ls); /* { dg-warning "flag" "bad %0S" } */
+  printf ("%'S", ls); /* { dg-warning "flag" "bad %'S" } */
+  scanf ("%C", ls);
+  scanf ("%S", ls);
+  scanf ("%*C%*S");
+  scanf ("%2C%3S", ls, ls);
+  scanf ("%hC", ls); /* { dg-warning "length" "bad %hC" } */
+  scanf ("%hhC", ls); /* { dg-warning "length" "bad %hhC" } */
+  scanf ("%lC", ls); /* { dg-warning "length" "bad %lC" } */
+  scanf ("%llC", ls); /* { dg-warning "length" "bad %llC" } */
+  scanf ("%jC", ls); /* { dg-warning "length" "bad %jC" } */
+  scanf ("%zC", ls); /* { dg-warning "length" "bad %zC" } */
+  scanf ("%tC", ls); /* { dg-warning "length" "bad %tC" } */
+  scanf ("%LC", ls); /* { dg-warning "length" "bad %LC" } */
+  scanf ("%hS", ls); /* { dg-warning "length" "bad %hS" } */
+  scanf ("%hhS", ls); /* { dg-warning "length" "bad %hhS" } */
+  scanf ("%lS", ls); /* { dg-warning "length" "bad %lS" } */
+  scanf ("%llS", ls); /* { dg-warning "length" "bad %llS" } */
+  scanf ("%jS", ls); /* { dg-warning "length" "bad %jS" } */
+  scanf ("%zS", ls); /* { dg-warning "length" "bad %zS" } */
+  scanf ("%tS", ls); /* { dg-warning "length" "bad %tS" } */
+  scanf ("%LS", ls); /* { dg-warning "length" "bad %LS" } */
+  /* In C99 mode (even with extensions), %aS is a floating point
+     format followed by an S.
+  */
+  scanf ("%aS", fp);
+  /* The printf flag character ' is an X/Open extension.  */
+  printf ("%'d%'i%'u%'f%'F%'g%'G", i, i, u, d, d, d, d);
+  printf ("%'o", u); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'x", u); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'X", u); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'e", d); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'E", d); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'a", d); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'A", d); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'c", i); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'s", s); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'p", p); /* { dg-warning "flag" "bad use of ' flag" } */
+  printf ("%'n", n); /* { dg-warning "flag" "bad use of ' flag" } */
+  /* The use of operand number $ formats is an X/Open extension.  */
+  scanf ("%1$d", ip);
+  printf ("%1$d", i);
+  printf ("%1$d", l); /* { dg-warning "arg 2|argument 2" "mismatched args with $ format" } */
+  printf ("%3$*2$.*1$ld", i2, i, l);
+  printf ("%4$ld%7$ld%5$d%6$d%3$d%1$d%2$d", i, i, i, l, i, i, l);
+  scanf ("%4$ld%7$ld%5$d%6$d%3$d%1$d%2$d", ip, ip, ip, lp, ip, ip, lp);
+  printf ("%1$d%d", i, i); /* { dg-warning "missing" "mixing $ and non-$ formats" } */
+  printf ("%%%1$d%%%2$d", i, i);
+  printf ("%d%2$d", i); /* { dg-warning "used after format" "mixing $ and non-$ formats" } */
+  printf ("%1$*d", i, i); /* { dg-warning "missing" "mixing $ and non-$ formats" } */
+  printf ("%*1$d", i); /* { dg-warning "missing" "mixing $ and non-$ formats" } */
+  scanf ("%1$d%d", ip, ip); /* { dg-warning "missing" "mixing $ and non-$ formats" } */
+  scanf ("%*f%%%1$d%%%2$d", ip, ip);
+  printf ("%2$d", i); /* { dg-warning "operand" "$ number too large" } */
+  printf ("%0$d", i); /* { dg-warning "operand" "$ number too small" } */
+  printf ("%3$d%1$d", i, i, i); /* { dg-warning "before used" "unused $ operand" } */
+  printf ("%2$d%1$d", i, i, i); /* { dg-warning "unused" "unused $ operand" } */
+  vprintf ("%3$d%1$d", va); /* { dg-warning "before used" "unused $ operand" } */
+  /* With scanf formats, gaps in the used arguments are allowed only if the
+     arguments are all pointers.  In such a case, should only give the lesser
+     warning about unused arguments rather than the more serious one about
+     argument gaps.  */
+  scanf ("%3$d%1$d", ip, ip, ip); /* { dg-bogus "before used" "unused $ scanf pointer operand" } */
+  /* { dg-warning "unused" "unused $ scanf pointer operand" { target *-*-* } 112 } */
+  /* If there are non-pointer arguments unused at the end, this is also OK.  */
+  scanf ("%3$d%1$d", ip, ip, ip, i); /* { dg-bogus "before used" "unused $ scanf pointer operand" } */
+  /* { dg-warning "unused" "unused $ scanf pointer operand" { target *-*-* } 115 } */
+  scanf ("%3$d%1$d", ip, i, ip); /* { dg-warning "before used" "unused $ scanf non-pointer operand" } */
+  /* Can't check the arguments in the vscanf case, so should suppose the
+     lesser problem.  */
+  vscanf ("%3$d%1$d", va); /* { dg-bogus "before used" "unused $ scanf pointer operand" } */
+  /* { dg-warning "unused" "unused $ scanf pointer operand" { target *-*-* } 120 } */
+  scanf ("%2$*d%1$d", ip, ip); /* { dg-warning "operand" "operand number with suppression" } */
+  printf ("%1$d%1$d", i);
+  scanf ("%1$d%1$d", ip); /* { dg-warning "more than once" "multiple use of scanf argument" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-2.c
new file mode 100644
index 000000000..5b837310f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-2.c
@@ -0,0 +1,21 @@
+/* Test for X/Open format extensions, as found in the
+   Single Unix Specification.  Test for bug reported by
+   Pierre-Canalsat PETIT <pierrecanalsat.petit.canalsat@canal-plus.com>
+   in PR c/6547.  The test for absence of a parameter for a * width was done
+   too early in the case of operand numbers and vprintf formats.
+*/
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void vbar (va_list, const char *) __attribute__((__format__(__printf__, 2, 0)));
+
+void
+foo (int i, int j, va_list va)
+{
+  printf("%2$*1$c", i, j);
+  printf("%2$*1$c %2$*1$c", i, j); /* { dg-bogus "too few" "bogus too few dollar" } */
+  vbar(va, "%*s"); /* { dg-bogus "too few" "bogus too few vprintf" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-3.c
new file mode 100644
index 000000000..5f78d77c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/xopen-3.c
@@ -0,0 +1,15 @@
+/* Test for warnings for $ operand numbers after ordinary formats.
+   Bug c/15444 from james-gcc-bugzilla-501qll3d at and dot org.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wformat" } */
+
+#include "format.h"
+
+void
+foo (int i)
+{
+  printf ("%d%2$d", i); /* { dg-warning "used after format" "mixing $ and non-$ formats" } */
+  printf ("%d%*1$d", i, i); /* { dg-warning "used after format" "mixing $ and non-$ formats" } */
+  printf ("%d%.*1$d", i, i); /* { dg-warning "used after format" "mixing $ and non-$ formats" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/z-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/z-1.c
new file mode 100644
index 000000000..7916201ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/z-1.c
@@ -0,0 +1,28 @@
+/* Test for bugs with %z and %Z formats.  See PRs c/89, c/156, c/376.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-Wformat" } */
+
+#include "format.h"
+
+size_t
+foo (void)
+{
+  size_t t;
+  scanf ("%zu", &t); /* { dg-bogus "length|format" "bogus scanf warning" } */
+  return t;
+}
+
+void
+bar (size_t t)
+{
+  printf ("%zu\n", t); /* { dg-bogus "format" "bogus printf warning" } */
+}
+
+/* The %Z printf format is an old GNU libc extension to do the same thing.  */
+
+void
+baz (size_t t)
+{
+  printf ("%Zu\n", t); /* { dg-bogus "format" "bogus printf warning" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/format/zero-length-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/zero-length-1.c
new file mode 100644
index 000000000..4cf37f320
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/format/zero-length-1.c
@@ -0,0 +1,15 @@
+/* Test the -Wno-format-zero-length option, which suppresses warnings
+   about zero-length formats.  */
+/* Origin: Jason Thorpe <thorpej@wasabisystems.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic -Wformat -Wno-format-zero-length" } */
+
+#include "format.h"
+
+void
+foo (void)
+{
+  /* See ISO/IEC 9899:1990 (E) subclause 7.9.6.1 (pages 131-134).  */
+  /* Zero-length format strings are allowed.  */
+  printf ("");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/framework-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/framework-1.c
new file mode 100644
index 000000000..7e6868329
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/framework-1.c
@@ -0,0 +1,4 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-F." } */
+
+#include <Carbon/Carbon.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/framework-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/framework-2.c
new file mode 100644
index 000000000..7e71b51b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/framework-2.c
@@ -0,0 +1,4 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-F$srcdir/gcc.dg" } */
+
+#include <Foundation/Foundation.h> /* { dg-error "Foundation/Foundation.h: No such file" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/free-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/free-1.c
new file mode 100644
index 000000000..5496c84fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/free-1.c
@@ -0,0 +1,26 @@
+/* PR c/36970 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern void free (void *);
+
+char *p, buf3[10], d;
+struct S { char a; int b; } *r;
+
+void foo (void)
+{
+  char buf[10], buf2[10], c;
+  static char buf4[10], e;
+  char *q = buf;
+  free (p);
+  free (q);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (buf2);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&c);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (buf3);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&d);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (buf4);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&e);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&r->a);
+  free ("abcd");      /* { dg-warning "attempt to free a non-heap object" } */
+  free (L"abcd");     /* { dg-warning "attempt to free a non-heap object" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/free-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/free-2.c
new file mode 100644
index 000000000..eb9465131
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/free-2.c
@@ -0,0 +1,26 @@
+/* PR c/36970 */
+/* { dg-do compile } */
+/* { dg-options "-O0" } */
+
+extern void free (void *);
+
+char *p, buf3[10], d;
+struct S { char a; int b; } *r;
+
+void foo (void)
+{
+  char buf[10], buf2[10], c;
+  static char buf4[10], e;
+  char *q = buf;
+  free (p);
+  free (q);	      /* At -O0 no warning is reported here.  */
+  free (buf2);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&c);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (buf3);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&d);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (buf4);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&e);	      /* { dg-warning "attempt to free a non-heap object" } */
+  free (&r->a);
+  free ("abcd");      /* { dg-warning "attempt to free a non-heap object" } */
+  free (L"abcd");     /* { dg-warning "attempt to free a non-heap object" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fshort-wchar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fshort-wchar.c
new file mode 100644
index 000000000..c9c751504
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fshort-wchar.c
@@ -0,0 +1,21 @@
+/* Copyright (C) 2002 Free Software Foundation, Inc.  */
+
+/* { dg-do run } */
+/* { dg-options "-fshort-wchar" } */
+/* { dg-options "-fshort-wchar -Wl,--no-wchar-size-warning" { target arm*-*-*eabi } } */
+
+/* Source: Neil Booth, 10 Dec 2002.
+
+   Test that __WCHAR_MAX__ is correct with -fshort-wchar.  */
+
+extern void abort (void);
+
+int main ()
+{
+  __WCHAR_TYPE__ w = ~(__WCHAR_TYPE__) 0;
+
+  if (w != __WCHAR_MAX__)
+    abort ();
+ 
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ftrapv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ftrapv-1.c
new file mode 100644
index 000000000..44eb176b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ftrapv-1.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   PR other/15526
+   Verify correct overflow checking with -ftrapv.
+
+   Written by Falk Hueffner, 20th May 2004.  */
+
+/* { dg-do run } */
+/* { dg-options "-ftrapv" } */
+
+__attribute__((noinline)) int
+mulv(int a, int b)
+{
+  return a * b;
+}
+
+int
+main()
+{
+  mulv( 0,  0);
+  mulv( 0, -1);
+  mulv(-1,  0);
+  mulv(-1, -1);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ftrapv-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ftrapv-2.c
new file mode 100644
index 000000000..d79b86dde
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ftrapv-2.c
@@ -0,0 +1,108 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   PR other/18665
+   Verify that -ftrapv doesn't produce bogus results
+   on 64-bit platforms.
+
+   Written by Eric Botcazou  */
+
+/* { dg-do run } */
+/* { dg-options "-ftrapv" } */
+
+extern void abort(void);
+extern long labs(long);
+
+int __attribute__((noinline))
+iabsv(int a)
+{
+  return abs(a);
+}
+
+int __attribute__((noinline))
+iaddv(int a, int b)
+{
+  return a + b;
+}
+
+int __attribute__((noinline))
+isubv(int a, int b)
+{
+  return a - b;
+}
+
+int __attribute__((noinline))
+imulv(int a, int b)
+{
+  return a * b;
+}
+
+int __attribute__((noinline))
+inegv(int a)
+{
+  return -a;
+}
+
+long __attribute__((noinline))
+labsv(long a)
+{
+  return labs(a);
+}
+
+long __attribute__((noinline))
+laddv(long a, long b)
+{
+  return a + b;
+}
+
+long __attribute__((noinline))
+lsubv(long a, long b)
+{
+  return a - b;
+}
+
+long __attribute__((noinline))
+lmulv(long a, long b)
+{
+  return a * b;
+}
+
+long __attribute__((noinline))
+lnegv(long a)
+{
+  return -a;
+}
+
+int main(void)
+{
+  if (iabsv (-1) != 1)
+    abort ();
+
+  if (iaddv (2,-3) != -1)
+    abort ();
+
+  if (isubv (2,3) != -1)
+    abort ();
+
+  if (imulv (-2,3) != -6)
+    abort ();
+
+  if (inegv (-1) != 1)
+    abort ();
+
+  if (labsv (-1L) != 1L)
+    abort ();
+
+  if (laddv (2L,-3L) != -1L)
+    abort ();
+
+  if (lsubv (2L,3L) != -1L)
+    abort ();
+
+  if (lmulv (-2L,3L) != -6L)
+    abort ();
+
+  if (lnegv (-1L) != 1L)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/func-args-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-args-1.c
new file mode 100644
index 000000000..2f9d8b80b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-args-1.c
@@ -0,0 +1,53 @@
+/* Test messages for wrong number of arguments to function.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f0(void);
+void f1(int);
+void f1v(int, ...);
+void f2(int, int);
+void f2v(int, int, ...);
+
+struct s {
+  void (*f0)(void);
+  void (*f1)(int);
+  void (*f1v)(int, ...);
+  void (*f2)(int, int);
+  void (*f2v)(int, int, ...);
+} x;
+
+void
+g (int a)
+{
+  f0();
+  x.f0();
+  f0(a); /* { dg-error "too many arguments to function 'f0'" } */
+  x.f0(a); /* { dg-error "too many arguments to function 'x.f0'" } */
+  f0(a, a); /* { dg-error "too many arguments to function 'f0'" } */
+  x.f0(a, a); /* { dg-error "too many arguments to function 'x.f0'" } */
+  f1(); /* { dg-error "too few arguments to function 'f1'" } */
+  x.f1(); /* { dg-error "too few arguments to function 'x.f1'" } */
+  f1(a);
+  x.f1(a);
+  f1(a, a); /* { dg-error "too many arguments to function 'f1'" } */
+  x.f1(a, a); /* { dg-error "too many arguments to function 'x.f1'" } */
+  f1v(); /* { dg-error "too few arguments to function 'f1v'" } */
+  x.f1v(); /* { dg-error "too few arguments to function 'x.f1v'" } */
+  f1v(a);
+  x.f1v(a);
+  f1v(a, a);
+  x.f1v(a, a);
+  f2(a); /* { dg-error "too few arguments to function 'f2'" } */
+  x.f2(a); /* { dg-error "too few arguments to function 'x.f2'" } */
+  f2(a, a);
+  x.f2(a, a);
+  f2(a, a, a); /* { dg-error "too many arguments to function 'f2'" } */
+  x.f2(a, a, a); /* { dg-error "too many arguments to function 'x.f2'" } */
+  f2v(a); /* { dg-error "too few arguments to function 'f2v'" } */
+  x.f2v(a); /* { dg-error "too few arguments to function 'x.f2v'" } */
+  f2v(a, a);
+  x.f2v(a, a);
+  f2v(a, a, a);
+  x.f2v(a, a, a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/func-args-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-args-2.c
new file mode 100644
index 000000000..a537f8956
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-args-2.c
@@ -0,0 +1,6 @@
+/* PR c/27420 */
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+void foo();
+void foo(struct A a) {}  /* { dg-error "incomplete type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/func-outside-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-outside-1.c
new file mode 100644
index 000000000..25c19c6f6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-outside-1.c
@@ -0,0 +1,9 @@
+/* Test for rejection of __func__ outside a function (GNU extensions
+   are OK there).  Test with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-fshow-column" } */
+
+const char *a = __func__; /* { dg-warning "17:'__func__' is not defined outside of function scope" "undef" } */
+const char *b = __FUNCTION__;
+const char *c = __PRETTY_FUNCTION__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/func-outside-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-outside-2.c
new file mode 100644
index 000000000..be3b0999e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-outside-2.c
@@ -0,0 +1,9 @@
+/* Test for rejection of __func__ outside a function (GNU extensions
+   are OK there).  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+const char *a = __func__; /* { dg-error "'__func__' is not defined outside of function scope" "undef" } */
+const char *b = __FUNCTION__;
+const char *c = __PRETTY_FUNCTION__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/func-ptr-conv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-ptr-conv-1.c
new file mode 100644
index 000000000..4e42e5fe1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/func-ptr-conv-1.c
@@ -0,0 +1,56 @@
+/* Conversions between function and object pointers are not permitted
+   in any version of ISO C, even with casts, except for the special
+   case of converting a null pointer constant to function pointer
+   type.  Likewise, comparisons between function and object pointers
+   are not permitted.  PR c/11234.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+void f(void);
+
+void *v1 = f; /* { dg-warning "pointer" "bad conversion" } */
+void *v2 = &f; /* { dg-warning "pointer" "bad conversion" } */
+void *v3 = (void *)f; /* { dg-warning "pointer" "bad conversion" } */
+void *v4 = (void *)&f; /* { dg-warning "pointer" "bad conversion" } */
+void *v5;
+char *c1 = f; /* { dg-warning "pointer" "bad conversion" } */
+char *c2 = &f; /* { dg-warning "pointer" "bad conversion" } */
+char *c3 = (char *)f; /* { dg-warning "pointer" "bad conversion" } */
+char *c4 = (char *)&f; /* { dg-warning "pointer" "bad conversion" } */
+char *c5;
+void (*fp)(void);
+int a;
+
+void
+g(void)
+{
+  v5 = f; /* { dg-warning "pointer" "bad conversion" } */
+  v5 = &f; /* { dg-warning "pointer" "bad conversion" } */
+  v5 = (void *)f; /* { dg-warning "pointer" "bad conversion" } */
+  v5 = (void *)&f; /* { dg-warning "pointer" "bad conversion" } */
+  c5 = f; /* { dg-warning "pointer" "bad conversion" } */
+  c5 = &f; /* { dg-warning "pointer" "bad conversion" } */
+  c5 = (char *)f; /* { dg-warning "pointer" "bad conversion" } */
+  c5 = (char *)&f; /* { dg-warning "pointer" "bad conversion" } */
+  fp = v5; /* { dg-warning "pointer" "bad conversion" } */
+  fp = c5; /* { dg-warning "pointer" "bad conversion" } */
+  fp = (void (*)(void))v5; /* { dg-warning "pointer" "bad conversion" } */
+  fp = (void (*)(void))c5; /* { dg-warning "pointer" "bad conversion" } */
+  (a ? f : v3); /* { dg-warning "pointer" "bad conversion" } */
+  (a ? v2 : fp); /* { dg-warning "pointer" "bad conversion" } */
+  /* The following are OK.  */
+  fp = 0;
+  fp = (void *)0;
+  fp = 0L;
+  fp = (void (*)(void))0;
+  fp = (void (*)(void))(void *)0;
+  (a ? f : 0);
+  (a ? f : (void *)0);
+  (a ? (void *)0 : fp);
+  (a ? 0 : fp);
+}
+
+/* The following are OK.  */
+void (*fp2)(void) = 0;
+void (*fp3)(void) = (void *)0;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-attr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-attr-1.c
new file mode 100644
index 000000000..17249a0cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-attr-1.c
@@ -0,0 +1,14 @@
+/* The declarator in a function definition should be able to take the
+   form of an attributed function declarator, not just a plain
+   function declarator.  This was formerly allowed by some of the code
+   but then the wrong constraint checks were made because other code
+   didn't recognise the declarator as being that of the function
+   definition.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk>.  */
+
+int (__attribute__((const)) x) (a, b)
+     int a;
+     int b;
+{
+  return a + b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-storage-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-storage-1.c
new file mode 100644
index 000000000..9aa963a02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-storage-1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+
+void
+flarm(void)
+{
+  static void foo();  /* { dg-error "invalid storage class" } */
+
+  foo();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-var-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-var-1.c
new file mode 100644
index 000000000..63a56838a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-var-1.c
@@ -0,0 +1,10 @@
+/* Test ICE on defining function with a name previously declared as a
+   nonfunction.  Bug 28299 from Bernhard Fischer
+   <aldot@gcc.gnu.org>.  */
+/* { dg-do compile } */
+/* { dg-options "-Wmissing-prototypes" } */
+
+extern __typeof(foo) foo __asm__(""); /* { dg-error "undeclared" } */
+/* { dg-message "note: previous declaration" "previous declaration" { target *-*-* } 7 } */
+void *foo (void) {} /* { dg-error "redeclared as different kind of symbol" } */
+/* { dg-warning "no previous prototype" "no previous prototype" { target *-*-* } 9 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-var-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-var-2.c
new file mode 100644
index 000000000..b3eb2ce6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcdef-var-2.c
@@ -0,0 +1,11 @@
+/* Test ICE on defining function with a name previously declared as a
+   nonfunction.  Bug 28299 from Bernhard Fischer <aldot@gcc.gnu.org>.
+   Reduced testcase from Volker Reichelt <reichelt@gcc.gnu.org>.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wmissing-prototypes" } */
+
+int foo;
+/* { dg-message "note: previous declaration" "previous declaration" { target *-*-* } 8 } */
+void foo () {} /* { dg-error "redeclared as different kind of symbol" } */
+/* { dg-warning "no previous prototype" "no previous prototype" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/funcorder.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcorder.c
new file mode 100644
index 000000000..a3edc1272
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/funcorder.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -funit-at-a-time" } */
+/* { dg-final { if [ istarget hppa*-*-* ] { scan-assembler-not "link_error,%r" { xfail hppa*64*-*-* } } else { scan-assembler-not "link_error" } } } */
+/*  In unit-at-time the functions should be assembled in order
+    e q t main, so we realize that they are pure.  The test is
+    xfailed on hppa64 because variable r in q is sign extended
+    to 64-bits.  As a result, "if (t!=mem)" is not simplified.  */
+ 
+static int mem;
+static int e(void) __attribute__ ((noinline));
+static int q(void) __attribute__ ((noinline));
+static int t(void) __attribute__ ((noinline));
+main()
+{
+	return t();
+}
+static t()
+{
+	int r,e;
+	if (mem)
+		t();
+	e=mem;
+	r=q();
+	if (e!=mem)
+		link_error();
+	return r;
+}
+static int e()
+{
+	return 0;
+}
+static int q()
+{
+	int t=mem,r;
+	r=e();
+	if (t!=mem)
+		link_error();
+	return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/funroll-loops-all.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/funroll-loops-all.c
new file mode 100644
index 000000000..c6276759e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/funroll-loops-all.c
@@ -0,0 +1,4 @@
+/* PR 17594 */
+/* { dg-do compile } */
+/* { dg-options "-funroll-loops-all" } */
+/* { dg-error "unrecognized command line option \"-funroll-loops-all\"" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fwrapv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fwrapv-1.c
new file mode 100644
index 000000000..f7ddda4a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fwrapv-1.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Test that the -fwrapv command line option is accepted and disables
+   "unsafe" optimizations that rely on undefined arithmetic overflow.
+
+   Written by Roger Sayle, 24th March 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -fwrapv" } */
+
+#include <limits.h>
+
+extern void abort ();
+
+int test(int x)
+{
+  return (2*x)/2;
+}
+
+main()
+{
+  int x = INT_MAX;
+
+  if (test(x) == x)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/fwrapv-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/fwrapv-2.c
new file mode 100644
index 000000000..cb4270e0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/fwrapv-2.c
@@ -0,0 +1,28 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+   Test that the -fno-wrapv command line option is accepted and enables
+   "unsafe" optimizations that rely on undefined arithmetic overflow.
+
+   Written by Roger Sayle, 31st May 2003.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -fno-wrapv" } */
+
+#include <limits.h>
+
+extern void abort ();
+
+int test(int x)
+{
+  return (2*x)/2;
+}
+
+main()
+{
+  int x = INT_MAX;
+
+  if (test(x) != x)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gcc-have-sync-compare-and-swap.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gcc-have-sync-compare-and-swap.c
new file mode 100644
index 000000000..faed818d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gcc-have-sync-compare-and-swap.c
@@ -0,0 +1,60 @@
+/* { dg-do link } */
+/* MIPS only supports these built-in functions for non-MIPS16 mode, and
+   -mflip-mips16 will change the mode of some functions to be different
+   from the command-line setting.  */
+/* { dg-skip-if "" { mips*-*-* } { "-mflip-mips16" } { "" } } */
+
+void f1()
+{
+#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
+  typedef int __attribute__  ((__mode__ (__QI__))) qi_int_type;
+  qi_int_type qi_int;
+  __sync_bool_compare_and_swap (&qi_int, (qi_int_type)0, (qi_int_type)1);
+#endif
+}
+
+void f2()
+{
+#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
+  typedef int __attribute__ ((__mode__ (__HI__))) hi_int_type;
+  hi_int_type hi_int;
+  __sync_bool_compare_and_swap (&hi_int, (hi_int_type)0, (hi_int_type)1);
+#endif
+}
+
+void f4()
+{
+#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
+  typedef int __attribute__ ((__mode__ (__SI__))) si_int_type;
+  si_int_type si_int;
+  __sync_bool_compare_and_swap (&si_int, (si_int_type)0, (si_int_type)1);
+#endif
+}
+
+void f8()
+{
+#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
+  typedef int __attribute__ ((__mode__ (__DI__))) di_int_type;
+  di_int_type di_int;
+  __sync_bool_compare_and_swap (&di_int, (di_int_type)0, (di_int_type)1);
+#endif
+}
+
+void f16()
+{
+#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16
+  typedef int __attribute__ ((__mode__ (__TI__))) ti_int_type;
+  ti_int_type ti_int;
+  __sync_bool_compare_and_swap (&ti_int, (ti_int_type)0, (ti_int_type)1);
+#endif
+}
+
+int main()
+{
+  f1();
+  f2();
+  f4();
+  f8();
+  f16();  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/glibc-uclibc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/glibc-uclibc-1.c
new file mode 100644
index 000000000..a3764046b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/glibc-uclibc-1.c
@@ -0,0 +1,6 @@
+/* Test -mglibc and -muclibc not allowed together.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do link { target *-*-linux* } } */
+/* { dg-options "-mglibc -muclibc" } */
+
+/* { dg-message "-mglibc and -muclibc used together" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/glibc-uclibc-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/glibc-uclibc-2.c
new file mode 100644
index 000000000..cb5226073
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/glibc-uclibc-2.c
@@ -0,0 +1,6 @@
+/* Test -mglibc and -muclibc not allowed together.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do link { target *-*-linux* } } */
+/* { dg-options "-muclibc -mglibc" } */
+
+/* { dg-message "-mglibc and -muclibc used together" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-1.c
new file mode 100644
index 000000000..0f0bb2142
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-1.c
@@ -0,0 +1,13 @@
+/* Test diagnostic for GNU extension: omitting middle term of
+   conditional expression.  Test with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int a, b, c;
+
+void
+f (void)
+{
+  c = (++a ? : b);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-2.c
new file mode 100644
index 000000000..2e561e4b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-2.c
@@ -0,0 +1,13 @@
+/* Test diagnostic for GNU extension: omitting middle term of
+   conditional expression.  Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+int a, b, c;
+
+void
+f (void)
+{
+  c = (++a ? : b); /* { dg-warning "ISO C forbids omitting the middle term of a \\?: expression" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-3.c
new file mode 100644
index 000000000..90555ad63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu-cond-expr-3.c
@@ -0,0 +1,13 @@
+/* Test diagnostic for GNU extension: omitting middle term of
+   conditional expression.  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+int a, b, c;
+
+void
+f (void)
+{
+  c = (++a ? : b); /* { dg-error "ISO C forbids omitting the middle term of a \\?: expression" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-dupqual-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-dupqual-1.c
new file mode 100644
index 000000000..9bd1db015
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-dupqual-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -Werror" } */
+
+typedef const int CI;
+const const int c1;		/* { dg-bogus "duplicate" } */
+const CI c2;			/* { dg-bogus "duplicate" } */
+const CI *c3;			/* { dg-bogus "duplicate" } */
+
+typedef volatile int VI;
+volatile volatile int v1;	/* { dg-bogus "duplicate" } */
+volatile VI v2;			/* { dg-bogus "duplicate" } */
+volatile VI *v3;		/* { dg-bogus "duplicate" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-1.c
new file mode 100644
index 000000000..07bf82353
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-1.c
@@ -0,0 +1,69 @@
+/* Test for GNU extensions to compound literals */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do run } */
+/* { dg-options "-std=gnu89" } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct A { int i; int j; int k[4]; };
+struct B { };
+struct C { int i; };
+struct D { int i; struct C j; };
+
+/* As a GNU extension, we allow initialization of objects with static storage
+   duration by compound literals.  It is handled as if the object
+   was initialized only with the bracket enclosed list if compound literal's
+   and object types match.  If the object being initialized has array type
+   of unknown size, the size is determined by compound literal's initializer
+   list, not by size of the compound literal.  */
+
+struct A a = (struct A) { .j = 6, .k[2] = 12 };
+struct B b = (struct B) { };
+int c[] = (int []) { [2] = 6, 7, 8 };
+int d[] = (int [3]) { 1 };
+int e[2] = (int []) { 1, 2 };
+int f[2] = (int [2]) { 1 };
+struct C g[3] = { [2] = (struct C) { 13 }, [1] = (const struct C) { 12 } };
+struct D h = { .j = (struct C) { 15 }, .i = 14 };
+struct D i[2] = { [1].j = (const struct C) { 17 },
+		  [0] = { 0, (struct C) { 16 } } };
+struct C j[2][3] = { [0 ... 1] = { [0 ... 2] = (struct C) { 26 } } };
+struct C k[3][2] = { [0 ... 2][0 ... 1] = (const struct C) { 27 } };
+
+int main (void)
+{
+  if (a.i || a.j != 6 || a.k[0] || a.k[1] || a.k[2] != 12 || a.k[3])
+    abort ();
+  if (c[0] || c[1] || c[2] != 6 || c[3] != 7 || c[4] != 8)
+    abort ();
+  if (sizeof (c) != 5 * sizeof (int))
+    abort ();
+  if (d[0] != 1 || d[1] || d[2])
+    abort ();
+  if (sizeof (d) != 3 * sizeof (int))
+    abort ();
+  if (e[0] != 1 || e[1] != 2)
+    abort ();
+  if (sizeof (e) != 2 * sizeof (int))
+    abort ();
+  if (f[0] != 1 || f[1])
+    abort ();
+  if (sizeof (f) != 2 * sizeof (int))
+    abort ();
+  if (g[0].i || g[1].i != 12 || g[2].i != 13)
+    abort ();
+  if (h.i != 14 || h.j.i != 15)
+    abort ();
+  if (i[0].i || i[0].j.i != 16 || i[1].i || i[1].j.i != 17)
+    abort ();
+  if (j[0][0].i != 26 || j[0][1].i != 26 || j[0][2].i != 26)
+    abort ();
+  if (j[1][0].i != 26 || j[1][1].i != 26 || j[1][2].i != 26)
+    abort ();
+  if (k[0][0].i != 27 || k[0][1].i != 27 || k[1][0].i != 27)
+    abort ();
+  if (k[1][1].i != 27 || k[2][0].i != 27 || k[2][1].i != 27)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-2.c
new file mode 100644
index 000000000..ce966ec89
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-2.c
@@ -0,0 +1,25 @@
+/* Test whether __compound_literal.* objects are not emitted unless
+   they are actually needed.  */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -O2" } */
+/* { dg-final { scan-assembler-not "__compound_literal" } } */
+
+struct A { int i; int j; int k[4]; };
+struct B { };
+struct C { int i; };
+struct D { int i; struct C j; };
+
+struct A a = (struct A) { .j = 6, .k[2] = 12 };
+struct B b = (struct B) { };
+int c[] = (int []) { [2] = 6, 7, 8 };
+int d[] = (int [3]) { 1 };
+int e[2] = (int []) { 1, 2 };
+int f[2] = (int [2]) { 1 };
+struct C g[3] = { [2] = (struct C) { 13 }, [1] = (const struct C) { 12 } };
+struct D h = { .j = (struct C) { 15 }, .i = 14 };
+struct D i[2] = { [1].j = (const struct C) { 17 },
+		  [0] = { 0, (struct C) { 16 } } };
+static const int *j = 1 ? (const int *) 0 : & (const int) { 26 };
+int k = (int) sizeof ((int [6]) { 1, 2, 3, 4, 5, 6 }) + 4;
+int l = (int) sizeof ((struct C) { 16 });
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-3.c
new file mode 100644
index 000000000..bd4283ec8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-3.c
@@ -0,0 +1,18 @@
+/* PR 11527 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+typedef struct smrdd_memory_blocks_s
+{
+  int blocks;
+  int block[];
+} smrdd_memory_blocks_t;
+
+const smrdd_memory_blocks_t smrdd_memory_blocks =
+{
+  3,
+  {
+    [5] = 5,
+    [1] = 2,
+  }
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-4.c
new file mode 100644
index 000000000..15e9cdb35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu89-init-4.c
@@ -0,0 +1,12 @@
+/* Test for GNU extensions to compound literals are giving the correct array bounds */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -W -Wall -O2" } */
+
+int a[] = (int[4]){1, 1, 2};
+int f(void)
+{
+  int sum = 0; int i;
+  for(i = 0;i<4;i++)
+    sum = a[i];
+  return sum;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-init-1.c
new file mode 100644
index 000000000..009c8515f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-init-1.c
@@ -0,0 +1,80 @@
+/* Test for GNU extensions to C99 designated initializers */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+
+int a[][2][4] = { [2 ... 4][0 ... 1][2 ... 3] = 1, [2] = 2, [2][0][2] = 3 };
+struct E {};
+struct F { struct E H; };
+struct G { int I; struct E J; int K; };
+struct H { int I; struct F J; int K; };
+struct G k = { .J = {}, 1 };
+struct H l = { .J.H = {}, 2 };
+struct H m = { .J = {}, 3 };
+struct I { int J; int K[3]; int L; };
+struct M { int N; struct I O[3]; int P; };
+struct M n[] = { [0 ... 5].O[1 ... 2].K[0 ... 1] = 4, 5, 6, 7 };
+struct M o[] = { [0 ... 5].O = { [1 ... 2].K[0 ... 1] = 4 },
+		 [5].O[2].K[2] = 5, 6, 7 };
+struct M p[] = { [0 ... 5].O[1 ... 2].K = { [0 ... 1] = 4 },
+		 [5].O[2].K[2] = 5, 6, 7 };
+int q[3][3] = { [0 ... 1] = { [1 ... 2] = 23 }, [1][2] = 24 };
+int r[1] = { [0 ... 1 - 1] = 27 };
+
+int main (void)
+{
+  int x, y, z;
+
+  if (a[2][0][0] != 2 || a[2][0][2] != 3)
+    abort ();
+  a[2][0][0] = 0;
+  a[2][0][2] = 1;
+  for (x = 0; x <= 4; x++)
+    for (y = 0; y <= 1; y++)
+      for (z = 0; z <= 3; z++)
+	if (a[x][y][z] != (x >= 2 && z >= 2))
+	  abort ();
+  if (k.I || l.I || m.I || k.K != 1 || l.K != 2 || m.K != 3)
+    abort ();
+  for (x = 0; x <= 5; x++)
+    {
+      if (n[x].N || n[x].O[0].J || n[x].O[0].L)
+	abort ();
+      for (y = 0; y <= 2; y++)
+	if (n[x].O[0].K[y])
+	  abort ();
+      for (y = 1; y <= 2; y++)
+	{
+	  if (n[x].O[y].J)
+	    abort ();
+	  if (n[x].O[y].K[0] != 4)
+	    abort ();
+	  if (n[x].O[y].K[1] != 4)
+	    abort ();
+	  if ((x < 5 || y < 2) && (n[x].O[y].K[2] || n[x].O[y].L))
+	    abort ();
+	}
+      if (x < 5 && n[x].P)
+	abort ();
+    }
+  if (n[5].O[2].K[2] != 5 || n[5].O[2].L != 6 || n[5].P != 7)
+    abort ();
+  if (memcmp (n, o, sizeof (n)) || sizeof (n) != sizeof (o))
+    abort ();
+  if (memcmp (n, p, sizeof (n)) || sizeof (n) != sizeof (p))
+    abort ();
+  if (q[0][0] || q[0][1] != 23 || q[0][2] != 23)
+    abort ();
+  if (q[1][0] || q[1][1] != 23 || q[1][2] != 24)
+    abort ();
+  if (q[2][0] || q[2][1] || q[2][2])
+    abort ();
+  if (r[0] != 27)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-init-2.c
new file mode 100644
index 000000000..a4728a608
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-init-2.c
@@ -0,0 +1,11 @@
+/* Test for designated initializers: array designators must be of
+   integer type.  Test for index ranges (GNU extension).  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int a[] = { [(void *)0 ... 0] = 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "integer type|near init" "pointer designator"  { target *-*-* } 7 } */
+
+int b[] = { [0 ... (void *)0] = 1 }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "integer type|near init" "pointer designator"  { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-static-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-static-1.c
new file mode 100644
index 000000000..b600a4b12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gnu99-static-1.c
@@ -0,0 +1,30 @@
+/* It is a constraint violation for a static function to be declared
+   but not defined if it is used except in a sizeof expression whose
+   result is an integer constant.  In GNU C, we need to consider
+   __typeof__ and __alignof__ as well.  __alignof__ always returns a
+   constant, so static functions can always be used therein.
+   __typeof__ evaluates its argument iff it has variably modified
+   type.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu99 -pedantic-errors" } */
+
+/* __alignof__, OK.  */
+static int f0(void);
+void g0(void) { __alignof__(f0()); }
+
+/* __typeof__ not variably modified, OK.  */
+static int f1(void);
+void g1(void) { __typeof__(f1()) x; }
+
+/* __typeof__ variably modified, not OK.  */
+static int f2(void); /* { dg-error "used but never defined" } */
+void g2(void) { __typeof__(int [f2()]) x; }
+
+/* __typeof__ variably modified, not OK.  */
+static int f3(void); /* { dg-error "used but never defined" } */
+void g3(void) { __typeof__(int (*)[f3()]) x; }
+
+/* Integer sizeof of VM typeof, OK.  */
+static int f4(void);
+void g4(void) { sizeof(__typeof__(int (*)[f3()])); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.1.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.1.1.c
new file mode 100644
index 000000000..f7f2924ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.1.1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+void
+a1 (int n, float *a, float *b)
+{
+  int i;
+#pragma omp parallel for
+  for (i = 1; i < n; i++)	/* i is private by default */
+    b[i] = (a[i] + a[i - 1]) / 2.0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.10.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.10.1.c
new file mode 100644
index 000000000..750bc378c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.10.1.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+#include <stdio.h>
+void
+work1 ()
+{
+}
+
+void
+work2 ()
+{
+}
+void
+a10 ()
+{
+#pragma omp parallel
+  {
+#pragma omp single
+    printf ("Beginning work1.\n");
+    work1 ();
+#pragma omp single
+    printf ("Finishing work1.\n");
+#pragma omp single nowait
+    printf ("Finished work1 and beginning work2.\n");
+    work2 ();
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.12.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.12.1.c
new file mode 100644
index 000000000..fab948dd7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.12.1.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+
+#include <stdio.h>
+extern float average (float, float, float);
+void
+a12 (float *x, float *xold, int n, float tol)
+{
+  int c, i, toobig;
+  float error, y;
+  c = 0;
+#pragma omp parallel
+  {
+    do
+      {
+#pragma omp for private(i)
+	for (i = 1; i < n - 1; ++i)
+	  {
+	    xold[i] = x[i];
+	  }
+#pragma omp single
+	{
+	  toobig = 0;
+	}
+#pragma omp for private(i,y,error) reduction(+:toobig)
+	for (i = 1; i < n - 1; ++i)
+	  {
+	    y = x[i];
+	    x[i] = average (xold[i - 1], x[i], xold[i + 1]);
+	    error = y - x[i];
+	    if (error > tol || error < -tol)
+	      ++toobig;
+	  }
+#pragma omp master
+	{
+	  ++c;
+	  printf ("iteration %d, toobig=%d\n", c, toobig);
+	}
+      }
+    while (toobig > 0);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.13.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.13.1.c
new file mode 100644
index 000000000..cc0fcc25d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.13.1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+int dequeue (float *a);
+void work (int i, float *a);
+void
+a13 (float *x, float *y)
+{
+  int ix_next, iy_next;
+#pragma omp parallel shared(x, y) private(ix_next, iy_next)
+  {
+#pragma omp critical (xaxis)
+    ix_next = dequeue (x);
+    work (ix_next, x);
+#pragma omp critical (yaxis)
+    iy_next = dequeue (y);
+    work (iy_next, y);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.14.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.14.1.c
new file mode 100644
index 000000000..14a7ed0bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.14.1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+void
+a14 ()
+{
+  int i = 1;
+#pragma omp parallel sections
+  {
+#pragma omp section
+    {
+#pragma omp critical (name)
+      {
+#pragma omp parallel
+	{
+#pragma omp single
+	  {
+	    i++;
+	  }
+	}
+      }
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.17.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.17.1.c
new file mode 100644
index 000000000..c460f7566
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.17.1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+
+void
+a17_1_wrong ()
+{
+  union
+  {
+    int n;
+    float x;
+  } u;
+#pragma omp parallel
+  {
+#pragma omp atomic
+    u.n++;
+#pragma omp atomic
+    u.x += 1.0;
+/* Incorrect because the atomic constructs reference the same location
+     through incompatible types */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.17.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.17.2.c
new file mode 100644
index 000000000..aaaec7ea3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.17.2.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+
+void
+a17_2_wrong ()
+{
+  int x;
+  int *i;
+  float *r;
+  i = &x;
+  r = (float *) &x;
+#pragma omp parallel
+  {
+#pragma omp atomic
+    *i += 1;
+#pragma omp atomic
+    *r += 1.0;
+/* Incorrect because the atomic constructs reference the same location
+     through incompatible types */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.20.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.20.1.c
new file mode 100644
index 000000000..d43e0cf45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.20.1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+void
+a20_wrong ()
+{
+  int a = 1;
+#pragma omp parallel
+  {
+    if (a != 0)
+#pragma omp flush(a)	/* { dg-error "'#pragma omp flush' may only" } */
+/* incorrect as flush cannot be immediate substatement
+    of if statement */
+      if (a != 0)
+#pragma omp barrier	/* { dg-error "'#pragma omp barrier' may only" } */
+/* incorrect as barrier cannot be immediate substatement
+    of if statement */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.20.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.20.2.c
new file mode 100644
index 000000000..4f1138356
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.20.2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+void
+a20 ()
+{
+  int a = 1;
+#pragma omp parallel
+  {
+    if (a != 0)
+      {
+#pragma omp flush(a)
+      }
+    if (a != 0)
+      {
+#pragma omp barrier
+      }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.21.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.21.2.c
new file mode 100644
index 000000000..a9b81d0c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.21.2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+
+void
+work (int i)
+{
+}
+
+void
+a21_wrong (int n)
+{
+  int i;
+#pragma omp for ordered
+  for (i = 0; i < n; i++)
+    {
+/* incorrect because an iteration may not execute more than one
+    ordered region */
+#pragma omp ordered
+      work (i);
+#pragma omp ordered
+      work (i + 1);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.21.3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.21.3.c
new file mode 100644
index 000000000..4d1ed6a52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.21.3.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+void work (int);
+
+void
+a21_good (int n)
+{
+  int i;
+#pragma omp for ordered
+  for (i = 0; i < n; i++)
+    {
+      if (i <= 10)
+	{
+#pragma omp ordered
+	  work (i);
+	}
+      if (i > 10)
+	{
+#pragma omp ordered
+	  work (i + 1);
+	}
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.22.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.22.1.c
new file mode 100644
index 000000000..2cc14888c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.22.1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+int counter = 0;
+#pragma omp threadprivate(counter)
+int
+increment_counter ()
+{
+  counter++;
+  return (counter);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.22.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.22.2.c
new file mode 100644
index 000000000..171bc2094
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.22.2.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+int
+increment_counter_2 ()
+{
+  static int counter = 0;
+#pragma omp threadprivate(counter)
+  counter++;
+  return (counter);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.24.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.24.1.c
new file mode 100644
index 000000000..5662e70c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.24.1.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+extern int omp_get_num_threads (void);
+int x, y, t, z[1000];
+#pragma omp threadprivate(x)
+void
+a24 (int a)
+{
+  const int c = 1;
+  int i = 0;
+  int l = 0;
+#pragma omp parallel default(none) private(a) shared(z)
+  {
+    int j = omp_get_num_threads ();
+    /* O.K. - j is declared within parallel region */
+    /* O.K.  -  a is listed in private clause */
+    /*       -  z is listed in shared clause */
+    x = c;			/* O.K.  -  x is threadprivate */
+    				/*       -  c has const-qualified type */
+    z[i] = y;
+    /* { dg-error "'i' not specified" "" { target *-*-* } 21 } */
+    /* { dg-error "enclosing parallel" "" { target *-*-* } 13 } */
+    /* { dg-error "'y' not specified" "" { target *-*-* } 21 }  */
+#pragma omp for firstprivate(y)
+    for (i = 0; i < 10; i++)
+      {
+	z[i] = y;		/* O.K. - i is the loop iteration variable */
+				/*      - y is listed in firstprivate clause */
+      }
+    z[l] = t;
+    /* { dg-error "'l' not specified" "" { target *-*-* } 31 } */
+    /* { dg-error "'t' not specified" "" { target *-*-* } 31 }  */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.26.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.26.2.c
new file mode 100644
index 000000000..b655edc10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.26.2.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -std=c99" } */
+
+int a;
+void
+g (int k)
+{
+  a = k;			/* The global "a", not the private "a" in f */
+}
+
+void
+f (int n)
+{
+  int a = 0;
+#pragma omp parallel for private(a)
+  for (int i = 1; i < n; i++)
+    {
+      a = i;
+      g (a * 2);		/* Private copy of "a" */
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.27.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.27.1.c
new file mode 100644
index 000000000..faa6ac621
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.27.1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+
+void
+a27 ()
+{
+  int i, a;
+#pragma omp parallel private(a)
+  {
+#pragma omp parallel for private(a)
+    for (i = 0; i < 10; i++)
+      {
+	/* do work here */
+      }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.30.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.30.1.c
new file mode 100644
index 000000000..e34be4c42
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.30.1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+
+void
+a30 (int n, float *a, float *b)
+{
+  int i;
+#pragma omp parallel
+  {
+#pragma omp for lastprivate(i)
+    for (i = 0; i < n - 1; i++)
+      a[i] = b[i] + b[i + 1];
+  }
+  a[i] = b[i];			/* i == n-1 here */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.31.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.31.1.c
new file mode 100644
index 000000000..cbb3f60df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.31.1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+void
+a31_1 (float *x, int *y, int n)
+{
+  int i, b;
+  float a;
+  a = 0.0;
+  b = 0;
+#pragma omp parallel for private(i) shared(x, y, n) \
+                         reduction(+:a) reduction(^:b)
+  for (i = 0; i < n; i++)
+    {
+      a += x[i];
+      b ^= y[i];
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.31.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.31.2.c
new file mode 100644
index 000000000..f9da3f4fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.31.2.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+void
+a31_2 (float *x, int *y, int n)
+{
+  int i, b, b_p;
+  float a, a_p;
+  a = 0.0;
+  b = 0;
+#pragma omp parallel shared(a, b, x, y, n) \
+                     private(a_p, b_p)
+  {
+    a_p = 0.0;
+    b_p = 0;
+#pragma omp for private(i)
+    for (i = 0; i < n; i++)
+      {
+	a_p += x[i];
+	b_p ^= y[i];
+      }
+#pragma omp critical
+    {
+      a += a_p;
+      b ^= b_p;
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.32.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.32.1.c
new file mode 100644
index 000000000..89d841c79
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.32.1.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+#include <stdlib.h>
+float *work;
+int size;
+float tol;
+void build (void);
+#pragma omp threadprivate(work,size,tol)
+void
+a32 (float t, int n)
+{
+  tol = t;
+  size = n;
+#pragma omp parallel copyin(tol,size)
+  {
+    build ();
+  }
+}
+void
+build ()
+{
+  int i;
+  work = (float *) malloc (sizeof (float) * size);
+  for (i = 0; i < size; ++i)
+    work[i] = tol;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.33.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.33.1.c
new file mode 100644
index 000000000..364a71e22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.33.1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+#include <stdio.h>
+float x, y;
+#pragma omp threadprivate(x, y)
+void
+init (float a, float b)
+{
+#pragma omp single copyprivate(a,b,x,y)
+  {
+    scanf ("%f %f %f %f", &a, &b, &x, &y);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.33.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.33.2.c
new file mode 100644
index 000000000..a0da739dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.33.2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#include <stdio.h>
+#include <stdlib.h>
+float
+read_next ()
+{
+  float *tmp;
+  float return_val;
+#pragma omp single copyprivate(tmp)
+  {
+    tmp = (float *) malloc (sizeof (float));
+  }				/* copies the pointer only */
+#pragma omp master
+  {
+    scanf ("%f", tmp);
+  }
+#pragma omp barrier
+  return_val = *tmp;
+#pragma omp barrier
+#pragma omp single nowait
+  {
+    free (tmp);
+  }
+  return return_val;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.34.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.34.1.c
new file mode 100644
index 000000000..e5ae7a61e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.34.1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+
+void
+work (int i, int j)
+{
+}
+
+void
+good_nesting (int n)
+{
+  int i, j;
+#pragma omp parallel default(shared)
+  {
+#pragma omp for
+    for (i = 0; i < n; i++)
+      {
+#pragma omp parallel shared(i, n)
+	{
+#pragma omp for
+	  for (j = 0; j < n; j++)
+	    work (i, j);
+	}
+      }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.34.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.34.2.c
new file mode 100644
index 000000000..7cc265fec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.34.2.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+
+void
+work (int i, int j)
+{
+}
+
+void
+work1 (int i, int n)
+{
+  int j;
+#pragma omp parallel default(shared)
+  {
+#pragma omp for
+    for (j = 0; j < n; j++)
+      work (i, j);
+  }
+}
+void
+good_nesting2 (int n)
+{
+  int i;
+#pragma omp parallel default(shared)
+  {
+#pragma omp for
+    for (i = 0; i < n; i++)
+      work1 (i, n);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.1.c
new file mode 100644
index 000000000..4196b2d15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+void
+work (int i, int j)
+{
+}
+
+void
+wrong1 (int n)
+{
+#pragma omp parallel default(shared)
+  {
+    int i, j;
+#pragma omp for
+    for (i = 0; i < n; i++)
+      {
+	/* incorrect nesting of loop regions */
+#pragma omp for		/* { dg-warning "may not be closely nested" } */
+	for (j = 0; j < n; j++)
+	  work (i, j);
+      }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.2.c
new file mode 100644
index 000000000..165c86e27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+
+void work (int, int);
+
+void
+work1 (int i, int n)
+{
+  int j;
+  /* incorrect nesting of loop regions */
+#pragma omp for
+  for (j = 0; j < n; j++)
+    work (i, j);
+}
+
+void
+wrong2 (int n)
+{
+#pragma omp parallel default(shared)
+  {
+    int i;
+#pragma omp for
+    for (i = 0; i < n; i++)
+      work1 (i, n);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.3.c
new file mode 100644
index 000000000..31b2ddf03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.3.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+
+void work (int, int);
+
+void
+wrong3 (int n)
+{
+#pragma omp parallel default(shared)
+  {
+    int i;
+#pragma omp for
+    for (i = 0; i < n; i++)
+      {
+/* incorrect nesting of regions */
+#pragma omp single	/* { dg-warning "may not be closely nested" } */
+	work (i, 0);
+      }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.4.c
new file mode 100644
index 000000000..d7579e6e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+void
+wrong4 (int n)
+{
+#pragma omp parallel default(shared)
+  {
+    int i;
+#pragma omp for
+    for (i = 0; i < n; i++)
+      {
+	work (i, 0);
+	/* incorrect nesting of barrier region in a loop region */
+#pragma omp barrier	/* { dg-warning "may not be closely nested" } */
+	work (i, 1);
+      }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.5.c
new file mode 100644
index 000000000..7b5301557
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.5.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+void
+wrong5 (int n)
+{
+#pragma omp parallel
+  {
+#pragma omp critical
+    {
+      work (n, 0);
+/* incorrect nesting of barrier region in a critical region */
+#pragma omp barrier
+      work (n, 1);
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.6.c
new file mode 100644
index 000000000..ac850e541
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.35.6.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+void
+wrong6 (int n)
+{
+#pragma omp parallel
+  {
+#pragma omp single
+    {
+      work (n, 0);
+/* incorrect nesting of barrier region in a single region */
+#pragma omp barrier	/* { dg-warning "may not be closely nested" } */
+      work (n, 1);
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.37.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.37.1.c
new file mode 100644
index 000000000..3581ee27d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.37.1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+
+extern int omp_get_num_threads (void);
+void work (int i);
+void
+incorrect ()
+{
+  int np, i;
+  np = omp_get_num_threads ();	/* misplaced */
+#pragma omp parallel for schedule(static)
+  for (i = 0; i < np; i++)
+    work (i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.37.2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.37.2.c
new file mode 100644
index 000000000..64256c78d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.37.2.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+
+extern int omp_get_thread_num (void);
+void work (int i);
+void
+correct ()
+{
+  int i;
+#pragma omp parallel private(i)
+  {
+    i = omp_get_thread_num ();
+    work (i);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.8.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.8.1.c
new file mode 100644
index 000000000..eed21b367
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.8.1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+#include <math.h>
+void
+a8 (int n, int m, float *a, float *b, float *y, float *z)
+{
+  int i;
+#pragma omp parallel
+  {
+#pragma omp for nowait
+    for (i = 1; i < n; i++)
+      b[i] = (a[i] + a[i - 1]) / 2.0;
+#pragma omp for nowait
+    for (i = 0; i < m; i++)
+      y[i] = sqrt (z[i]);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.9.1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.9.1.c
new file mode 100644
index 000000000..45be33f16
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/appendix-a/a.9.1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+void XAXIS ();
+void YAXIS ();
+void ZAXIS ();
+void
+a9 ()
+{
+#pragma omp parallel sections
+  {
+#pragma omp section
+    XAXIS ();
+#pragma omp section
+    YAXIS ();
+#pragma omp section
+    ZAXIS ();
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/asm-1.c
new file mode 100644
index 000000000..ced31f3b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/asm-1.c
@@ -0,0 +1,19 @@
+/* PR middle-end/30263 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+void
+foo (void)
+{
+  int s0, s1 = 5, s2 = 6;
+  int p0, p1, p2;
+  int f0 = 4, f1 = 5, f2 = 6;
+#pragma omp parallel shared (s0, s1, s2) private (p0, p1, p2) \
+	    firstprivate (f0, f1, f2)
+  {
+    asm ("" : "=m" (p0) : "m" (p1), "mr" (p2));
+    if (omp_get_thread_num () == 0)
+      asm ("" : "=m" (s0) : "m" (s1), "mr" (s2));
+    asm ("" : "=m" (f0) : "m" (f1), "mr" (f2));
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-1.c
new file mode 100644
index 000000000..3e4bc569b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-1.c
@@ -0,0 +1,99 @@
+/* { dg-do compile } */
+
+int x;
+volatile int y;
+volatile unsigned char z;
+
+void f1(void)
+{
+  #pragma omp atomic
+    x++;
+  #pragma omp atomic
+    x--;
+  #pragma omp atomic
+    ++x;
+  #pragma omp atomic
+    --x;
+  #pragma omp atomic
+    x += 1;
+  #pragma omp atomic
+    x -= y;
+  #pragma omp atomic
+    x |= 1;
+  #pragma omp atomic
+    x &= 1;
+  #pragma omp atomic
+    x ^= 1;
+  #pragma omp atomic
+    x *= 3;
+  #pragma omp atomic
+    x /= 3;
+  #pragma omp atomic
+    x /= 3;
+  #pragma omp atomic
+    x <<= 3;
+  #pragma omp atomic
+    x >>= 3;
+}
+
+void f2(void)
+{
+  #pragma omp atomic
+    y++;
+  #pragma omp atomic
+    y--;
+  #pragma omp atomic
+    ++y;
+  #pragma omp atomic
+    --y;
+  #pragma omp atomic
+    y += 1;
+  #pragma omp atomic
+    y -= x;
+  #pragma omp atomic
+    y |= 1;
+  #pragma omp atomic
+    y &= 1;
+  #pragma omp atomic
+    y ^= 1;
+  #pragma omp atomic
+    y *= 3;
+  #pragma omp atomic
+    y /= 3;
+  #pragma omp atomic
+    y /= 3;
+  #pragma omp atomic
+    y <<= 3;
+  #pragma omp atomic
+    y >>= 3;
+}
+
+void f3(void)
+{
+  #pragma omp atomic
+    z++;
+  #pragma omp atomic
+    z--;
+  #pragma omp atomic
+    ++z;
+  #pragma omp atomic
+    --z;
+  #pragma omp atomic
+    z += 1;
+  #pragma omp atomic
+    z |= 1;
+  #pragma omp atomic
+    z &= 1;
+  #pragma omp atomic
+    z ^= 1;
+  #pragma omp atomic
+    z *= 3;
+  #pragma omp atomic
+    z /= 3;
+  #pragma omp atomic
+    z /= 3;
+  #pragma omp atomic
+    z <<= 3;
+  #pragma omp atomic
+    z >>= 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-10.c
new file mode 100644
index 000000000..936d0c1f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-10.c
@@ -0,0 +1,24 @@
+/* PR middle-end/28046 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+int a[3], b;
+struct C { int x; int y; } c;
+
+int bar (void), *baz (void);
+
+void
+foo (void)
+{
+#pragma omp atomic
+  a[2] += bar ();
+#pragma omp atomic
+  b += bar ();
+#pragma omp atomic
+  c.y += bar ();
+#pragma omp atomic
+  *baz () += bar ();
+}
+
+/* { dg-final { scan-tree-dump-times "__sync_fetch_and_add" 4 "ompexp" { target i?86-*-* x86_64-*-* ia64-*-* powerpc*-*-* alpha*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-11.c
new file mode 100644
index 000000000..397972b3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-11.c
@@ -0,0 +1,17 @@
+/* PR middle-end/36877 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+/* { dg-options "-fopenmp -march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+int i;
+float f;
+
+void foo (void)
+{
+#pragma omp atomic
+  i++;
+#pragma omp atomic
+  f += 1.0;
+}
+
+/* { dg-final { scan-assembler-not "__sync_(fetch|add|bool|val)" { target i?86-*-* x86_64-*-* powerpc*-*-* ia64-*-* s390*-*-* sparc*-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-2.c
new file mode 100644
index 000000000..720ec9e8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-2.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+float x, y;
+
+void f1(void)
+{
+  #pragma omp atomic
+    x++;
+  #pragma omp atomic
+    x--;
+  #pragma omp atomic
+    ++x;
+  #pragma omp atomic
+    --x;
+  #pragma omp atomic
+    x += 1;
+  #pragma omp atomic
+    x -= y;
+  #pragma omp atomic
+    x *= 3;
+  #pragma omp atomic
+    x /= 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-3.c
new file mode 100644
index 000000000..7ea792d34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+int *xyzzy;
+
+void f1(void)
+{
+  #pragma omp atomic
+    xyzzy++;
+}
+
+/* { dg-final { scan-tree-dump-times "xyzzy, 4" 1 "ompexp" { target i?86-*-* x86_64-*-* ia64-*-* powerpc*-*-* alpha*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-4.c
new file mode 100644
index 000000000..7f27370d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-4.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+
+int a[4];
+int *p;
+struct S { int x; int y[4]; } s;
+int *bar(void);
+
+void f1(void)
+{
+  #pragma omp atomic
+    a[4] += 1;
+  #pragma omp atomic
+    *p += 1;
+  #pragma omp atomic
+    s.x += 1;
+  #pragma omp atomic
+    s.y[*p] += 1;
+  #pragma omp atomic
+    s.y[*p] *= 42;
+  #pragma omp atomic
+    *bar() += 1;
+  #pragma omp atomic
+    *bar() *= 42;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-5.c
new file mode 100644
index 000000000..445f7805f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-5.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+
+int x;
+const int y;
+int bar(void);
+
+void f1(void)
+{
+  register int z;
+
+  #pragma omp atomic
+    x %= 2;		/* { dg-error "invalid operator" } */
+  #pragma omp atomic
+    x = x + 1;		/* { dg-error "invalid operator" } */
+  #pragma omp atomic
+    x = 1;		/* { dg-error "invalid operator" } */
+  #pragma omp atomic
+    ++y;		/* { dg-error "read-only variable" } */
+  #pragma omp atomic
+    y--;		/* { dg-error "read-only variable" } */
+  #pragma omp atomic
+    y += 1;		/* { dg-error "read-only variable" } */
+  #pragma omp atomic
+    z += 1;		/* { dg-error "register variable" } */
+  #pragma omp atomic
+    bar();		/* { dg-error "invalid operator" } */
+  #pragma omp atomic
+    bar() += 1;		/* { dg-error "lvalue required" } */
+  #pragma omp atomic a	/* { dg-error "expected end of line" } */
+    x++;
+  #pragma omp atomic
+    ;			/* { dg-error "expected expression" } */
+  #pragma omp atomic
+  #pragma omp atomic	/* { dg-error "expected expression" } */
+    ;
+  /* Check that we didn't get stuck on the pragma eol marker.  */
+  undef;		/* { dg-error "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-6.c
new file mode 100644
index 000000000..0d56becd8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-6.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+int x[10], z;
+double y[10];
+
+void f1(void)
+{
+  #pragma omp atomic
+    x[z] /= y[z];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-7.c
new file mode 100644
index 000000000..612e97f45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-7.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+double x, y;
+
+void f2(void)
+{
+  #pragma omp atomic
+    y++;
+  #pragma omp atomic
+    y--;
+  #pragma omp atomic
+    ++y;
+  #pragma omp atomic
+    --y;
+  #pragma omp atomic
+    y += 1;
+  #pragma omp atomic
+    y -= x;
+  #pragma omp atomic
+    y *= 3;
+  #pragma omp atomic
+    y /= 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-8.c
new file mode 100644
index 000000000..2f04151f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-8.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+
+long double z;
+
+void f3(void)
+{
+  #pragma omp atomic
+    z++;
+  #pragma omp atomic
+    z--;
+  #pragma omp atomic
+    ++z;
+  #pragma omp atomic
+    --z;
+  #pragma omp atomic
+    z += 1;
+  #pragma omp atomic
+    z *= 3;
+  #pragma omp atomic
+    z /= 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-9.c
new file mode 100644
index 000000000..2fafbd409
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/atomic-9.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+volatile int *bar(void);
+
+void f1(void)
+{
+  #pragma omp atomic
+    *bar() += 1;
+}
+
+/* { dg-final { scan-tree-dump-times "__sync_fetch_and_add" 1 "ompexp" { target i?86-*-* x86_64-*-* ia64-*-* powerpc*-*-* alpha*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/barrier-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/barrier-1.c
new file mode 100644
index 000000000..ef7c9afb1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/barrier-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-gimple" } */
+
+void f1(void)
+{
+  #pragma omp barrier
+}
+
+void f2(_Bool p)
+{
+  if (p)
+    {
+      #pragma omp barrier
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_barrier" 2 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/barrier-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/barrier-2.c
new file mode 100644
index 000000000..3787c35a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/barrier-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+void f1(void)
+{
+  #pragma omp barrier a		/* { dg-error "expected end of line" } */
+}
+
+/* OpenMP 2.5, section 2.7.3:
+
+   Note that because the barrier construct does not have a C language
+   statement as part of its syntax, there are some restrictions on its
+   placement within a program. The barrier directive may only be placed
+   in the program at a position where ignoring or deleting the directive
+   would result in a program with correct syntax.  */
+
+void f2(void)
+{
+  label:       /* { dg-error "label at end of compound statement" } */
+    #pragma omp barrier
+}
+
+void f3(_Bool p)
+{
+  if (p)
+    #pragma omp barrier		/* { dg-error "compound statements" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-1.c
new file mode 100644
index 000000000..dd7fe7783
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-1.c
@@ -0,0 +1,22 @@
+// { dg-do compile }
+
+void foo()
+{
+  bad1:
+  #pragma omp parallel
+    goto bad1;			// { dg-error "invalid branch" }
+
+  goto bad2;			// { dg-error "invalid entry" }
+  #pragma omp parallel
+    {
+      bad2: ;
+    }
+
+  #pragma omp parallel
+    {
+      int i;
+      goto ok1;
+      for (i = 0; i < 10; ++i)
+	{ ok1: break; }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-10.c
new file mode 100644
index 000000000..76ee39745
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-10.c
@@ -0,0 +1,40 @@
+// { dg-do compile }
+
+void foo(int i)
+{
+  int j;
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp parallel
+    { case 0:; }
+  }
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp for
+    for (j = 0; j < 10; ++ j)
+      { case 1:; }
+  }
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp critical
+    { case 2:; }
+  }
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp master
+    { case 3:; }
+  }
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp sections
+    { case 4:;
+    #pragma omp section
+       { case 5:; }
+    }
+  }
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp ordered
+    { default:; }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-11.c
new file mode 100644
index 000000000..c2800061b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-11.c
@@ -0,0 +1,19 @@
+/* PR c++/24516 */
+/* { dg-do compile } */
+
+void
+bar (int *p)
+{
+  int m;
+#pragma omp parallel for
+  for (m = 0; m < 1000; ++m)
+    switch (p[m])
+      {
+      case 1:
+	p[m] = 2;
+	break;
+      default:
+	p[m] = 3;
+	break;
+      }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-2.c
new file mode 100644
index 000000000..4c56add57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-2.c
@@ -0,0 +1,32 @@
+// { dg-do compile }
+
+void foo()
+{
+  int i, j;
+
+  #pragma omp for
+  for (i = 0; i < 10; ++i)
+    break;			// { dg-error "break" }
+
+  bad1:
+  #pragma omp for
+  for (i = 0; i < 10; ++i)
+    goto bad1;			// { dg-error "invalid branch" }
+
+  goto bad2;			// { dg-error "invalid entry" }
+  #pragma omp for
+  for (i = 0; i < 10; ++i)
+    {
+      bad2: ;
+    }
+
+  #pragma omp for
+  for (i = 0; i < 10; ++i)
+    for (j = 0; j < 10; ++j)
+      if (i == j)
+	break;
+
+  #pragma omp for
+  for (i = 0; i < 10; ++i)
+    continue;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-3.c
new file mode 100644
index 000000000..c72b04c35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-3.c
@@ -0,0 +1,57 @@
+// { dg-do compile }
+
+extern int test(int);
+void foo()
+{
+  int i;
+
+  for (i = 0; i < 10; ++i)
+    {
+      #pragma omp sections
+      {
+	continue;		// { dg-error "invalid branch" }
+      }
+    }
+
+  #pragma omp sections
+    {
+    #pragma omp section
+      { bad1: ; }
+    #pragma omp section
+      goto bad1;		// { dg-error "invalid branch" }
+    }
+
+  #pragma omp sections
+    {
+      goto bad2;		// { dg-error "invalid branch" }
+    }
+  bad2:;
+
+  goto bad3;			// { dg-error "invalid entry" }
+  #pragma omp sections
+    {
+      bad3: ;
+    }
+
+  #pragma omp sections
+    {
+      goto ok1;
+      ok1:;
+
+    #pragma omp section
+      for (i = 0; i < 10; ++i)
+	if (test(i))
+	  break;
+	else
+	  continue;
+
+    #pragma omp section
+      switch (i)
+	{
+	case 0:
+	  break;
+	default:
+	  test(i);
+	}
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-4.c
new file mode 100644
index 000000000..61f490c00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-4.c
@@ -0,0 +1,9 @@
+// { dg-do compile }
+
+void foo()
+{
+  #pragma omp critical
+    {
+      return;		// { dg-error "invalid branch" }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-5.c
new file mode 100644
index 000000000..741049fdd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-5.c
@@ -0,0 +1,15 @@
+// { dg-do compile }
+
+void foo()
+{
+  #pragma omp master
+    {
+      goto bad1;	// { dg-error "invalid branch" }
+    }
+
+  #pragma omp master
+    {
+    bad1:
+      return;		// { dg-error "invalid branch" }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-6.c
new file mode 100644
index 000000000..87e6392e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-6.c
@@ -0,0 +1,9 @@
+// { dg-do compile }
+
+void foo()
+{
+  #pragma omp ordered
+    {
+      return;		// { dg-error "invalid branch" }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-7.c
new file mode 100644
index 000000000..2bc1cdb57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-7.c
@@ -0,0 +1,20 @@
+// { dg-do compile }
+
+void foo()
+{
+  int i, j;
+  for (i = 0; i < 10; ++i)
+    {
+      #pragma omp for
+      for (j = ({ continue; 0; });	// { dg-error "invalid branch" }
+	   j < ({ continue; 10; });	// { dg-error "invalid branch" }
+	   j += ({ continue; 1; }))	// { dg-error "invalid branch" }
+	continue;
+
+      #pragma omp for
+      for (j = ({ break; 0; });		// { dg-error "invalid branch" }
+	   j < ({ break; 10; });	// { dg-error "invalid branch" }
+	   j += ({ break; 1; }))	// { dg-error "invalid branch" }
+	break;				// { dg-error "break" }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-8.c
new file mode 100644
index 000000000..3c717d927
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-8.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+// PR 24451
+
+int foo()
+{
+  int i;
+
+  #pragma omp parallel for
+  for (i = 0; i < 10; ++i)
+    return 0;			// { dg-error "invalid branch" }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-9.c
new file mode 100644
index 000000000..9217cb749
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/block-9.c
@@ -0,0 +1,25 @@
+// { dg-do compile }
+
+void foo(int i)
+{
+  int j;
+  switch (i)			// { dg-error "invalid entry" }
+  {
+  #pragma omp parallel
+    { case 0:; }
+  #pragma omp for
+    for (j = 0; j < 10; ++ j)
+      { case 1:; }
+  #pragma omp critical
+    { case 2:; }
+  #pragma omp master
+    { case 3:; }
+  #pragma omp sections
+    { case 4:;
+    #pragma omp section
+       { case 5:; }
+    }
+  #pragma omp ordered
+    { default:; }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/clause-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/clause-1.c
new file mode 100644
index 000000000..cfab168af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/clause-1.c
@@ -0,0 +1,94 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+#define p parallel
+
+extern void bar (void);
+extern char q[];
+int t;
+#pragma omp threadprivate (t)
+
+void
+foo (int x)
+{
+  char *p;
+  struct S { int i; int j; } s;
+  char a[32];
+  double d;
+  int i;
+  const int c = 8;
+#pragma omp p shared (x, x) /* { dg-error "more than once" } */
+    ;
+#pragma omp p private (x) private (x) /* { dg-error "more than once" } */
+    ;
+#pragma omp p shared (x) firstprivate (x) /* { dg-error "more than once" } */
+    ;
+#pragma omp p firstprivate (x, x) /* { dg-error "more than once" } */
+    ;
+#pragma omp p for shared (x) lastprivate (x) /* { dg-error "more than" } */
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp p for private (x) lastprivate (x) /* { dg-error "more than" } */
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp p for lastprivate (x, x) /* { dg-error "more than once" } */
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp single private (x) copyprivate (x) /* { dg-error "more than" } */
+    ;
+#pragma omp p shared (bar) /* { dg-error "is not a variable" } */
+    ;
+#pragma omp p private (bar) /* { dg-error "is not a variable" } */
+    ;
+#pragma omp p firstprivate (bar) /* { dg-error "is not a variable" } */
+    ;
+#pragma omp p reduction (+:p) /* { dg-error "has invalid type for" } */
+    ;
+#pragma omp p reduction (*:s) /* { dg-error "has invalid type for" } */
+    ;
+#pragma omp p reduction (-:a) /* { dg-error "has invalid type for" } */
+    ;
+  d = 0;
+#pragma omp p reduction (*:d)
+    ;
+#pragma omp p reduction (|:d) /* { dg-error "has invalid type for" } */
+    ;
+#pragma omp p reduction (&&:d) /* { dg-error "has invalid type for" } */
+    ;
+#pragma omp p copyin (d) /* { dg-error "must be 'threadprivate'" } */
+    ;
+#pragma omp p copyin (x) /* { dg-error "must be 'threadprivate'" } */
+    ;
+#pragma omp p for firstprivate (x) lastprivate (x)
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp p private (q) /* { dg-error "incomplete type" } */
+    ;
+#pragma omp p firstprivate (q) /* { dg-error "incomplete type" } */
+    ;
+#pragma omp p for lastprivate (q) /* { dg-error "incomplete type" } */
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp p shared (t) /* { dg-error "predetermined 'threadprivate'" } */
+    ;
+#pragma omp p private (t) /* { dg-error "predetermined 'threadprivate'" } */
+    ;
+#pragma omp p firstprivate (t) /* { dg-error "predetermined 'threadpriv" } */
+    ;
+#pragma omp p for lastprivate (t) /* { dg-error "predetermined 'threadpr" } */
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp p reduction (*:t) /* { dg-error "predetermined 'threadprivate" } */
+    ;
+#pragma omp p shared (c) /* { dg-error "predetermined 'shared'" } */
+    ;
+#pragma omp p private (c) /* { dg-error "predetermined 'shared'" } */
+    ;
+#pragma omp p firstprivate (c) /* { dg-error "predetermined 'shared'" } */
+    ;
+#pragma omp p for lastprivate (c) /* { dg-error "predetermined 'shared'" } */
+  for (i = 0; i < 10; i++)
+    ;
+#pragma omp p reduction (*:c) /* { dg-error "predetermined 'shared'" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/clause-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/clause-2.c
new file mode 100644
index 000000000..4b12fc8f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/clause-2.c
@@ -0,0 +1,23 @@
+/* PR c/34506 */
+/* { dg-do compile } */
+
+#define p parallel
+
+void
+foo (int x)
+{
+#pragma omp p num_threads (4) if (1) private (x)
+    ;
+#pragma omp p num_threads(4)if(1)private(x)
+    ;
+#pragma omp p num_threads (4), if (1) , private (x)
+    ;
+#pragma omp p num_threads(4),if(1),private(x)
+    ;
+#pragma omp p, num_threads (4), if (1), private (x)	/* { dg-error "clause before" } */
+    ;
+#pragma omp p num_threads (4), if (1), private (x),	/* { dg-error "clause before" } */
+    ;
+#pragma omp p num_threads (4), , if (1), private (x)	/* { dg-error "clause before" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/collapse-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/collapse-1.c
new file mode 100644
index 000000000..89b76bb66
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/collapse-1.c
@@ -0,0 +1,92 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+int i, j, k;
+extern int foo (void);
+
+void
+f1 (void)
+{
+  #pragma omp for collapse (2)
+  for (i = 0; i < 5; i++)
+    ;					/* { dg-error "not enough perfectly nested" } */
+  {
+    for (j = 0; j < 5; j++)
+      ;
+  }
+}
+
+void
+f2 (void)
+{
+  #pragma omp for collapse (2)
+  for (i = 0; i < 5; i++)
+    {
+      {
+	{
+	  for (j = 0; j < 5; j++)
+	    {
+	    }
+	}
+      }
+    }
+}
+
+void
+f3 (void)
+{
+  #pragma omp for collapse (2)
+  for (i = 0; i < 5; i++)
+    {
+      int k = foo ();			/* { dg-error "not enough perfectly nested" } */
+      {
+	{
+	  for (j = 0; j < 5; j++)
+	    {
+	    }
+	}
+      }
+    }
+}
+
+void
+f4 (void)
+{
+  #pragma omp for collapse (2)
+  for (i = 0; i < 5; i++)
+    {
+      {
+	for (j = 0; j < 5; j++)
+	  ;
+	foo ();				/* { dg-error "collapsed loops not perfectly nested before" } */
+      }
+    }
+}
+
+void
+f5 (void)
+{
+  #pragma omp for collapse (2)
+  for (i = 0; i < 5; i++)
+    {
+      {
+	for (j = 0; j < 5; j++)
+	  ;
+      }
+      foo ();				/* { dg-error "collapsed loops not perfectly nested before" } */
+    }
+}
+
+void
+f6 (void)
+{
+  #pragma omp for collapse (2)
+  for (i = 0; i < 5; i++)
+    {
+      {
+	for (j = 0; j < 5; j++)
+	  ;
+      }
+    }
+  foo ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/combined-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/combined-1.c
new file mode 100644
index 000000000..fc86a9b0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/combined-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fopenmp -fdump-tree-final_cleanup" } */
+
+int a[10];
+int foo (void)
+{
+    int i;
+#pragma omp parallel for schedule(runtime)
+    for (i = 0; i < 10; i++)
+      a[i] = i;
+#pragma omp parallel
+#pragma omp for schedule(runtime)
+    for (i = 0; i < 10; i++)
+      a[i] = 10 - i;
+#pragma omp parallel
+      {
+#pragma omp for schedule(runtime)
+	for (i = 0; i < 10; i++)
+	  a[i] = i;
+      }
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_GOMP_parallel_loop_runtime_start" 3 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/complex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/complex-1.c
new file mode 100644
index 000000000..0858ac9d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/complex-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -O1" } */
+/* PR middle-end/30143 */
+
+
+int f (int n)
+{
+  int i;
+  _Complex float t;
+#pragma omp parallel
+    for (i = 1; i < n - 1; ++i)
+      t+=1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/copyin-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/copyin-1.c
new file mode 100644
index 000000000..f984d10b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/copyin-1.c
@@ -0,0 +1,27 @@
+// { dg-do compile }
+// { dg-require-effective-target tls_native }
+
+int i, j;
+
+#pragma omp threadprivate (i)
+
+void bar(void);
+void foo(void)
+{
+  int k;
+  extern int l;
+  extern int m;
+
+#pragma omp threadprivate (m)
+
+  #pragma omp parallel copyin(i)
+    bar();
+  #pragma omp parallel copyin(j)	// { dg-error "threadprivate" }
+    bar();
+  #pragma omp parallel copyin(k)	// { dg-error "threadprivate" }
+    bar();
+  #pragma omp parallel copyin(l)	// { dg-error "threadprivate" }
+    bar();
+  #pragma omp parallel copyin(m)
+    bar();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-1.c
new file mode 100644
index 000000000..6f3348c88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (void)
+{
+  #pragma omp critical
+    bar(0);
+
+  /* Note that "name" is in its own namespace, thus this foo is not
+     the same as the function.  */
+  #pragma omp critical(foo)
+  {
+    bar(1);
+    bar(2);
+  }
+
+  #pragma omp critical
+  #pragma omp critical(foo)
+    bar(3);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_critical_start" 2 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_critical_end" 2 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_critical_name_start" 2 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_critical_name_end" 2 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-2.c
new file mode 100644
index 000000000..d1ba3963f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+
+void f1(void)
+{
+  #pragma omp critical a	/* { dg-error "expected" } */
+    ;
+  #pragma omp critical (	/* { dg-error "expected identifier" } */
+    ;
+  #pragma omp critical (a	/* { dg-error "expected .\\)." } */
+    ;
+  #pragma omp critical (a b)	/* { dg-error "expected .\\)." } */
+}				/* { dg-error "expected expression" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-3.c
new file mode 100644
index 000000000..c0046f571
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-3.c
@@ -0,0 +1,12 @@
+// { dg-do compile }
+// { dg-options "-fopenmp -fdump-tree-ompexp" }
+
+void bar(void);
+void foo(void)
+{
+  #pragma omp critical (xyzzy)
+    bar();
+}
+
+// { dg-final { scan-tree-dump-times "\\&\\.gomp_critical_user_xyzzy" 2 "ompexp" } }
+// { dg-final { cleanup-tree-dump "ompexp" } }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-4.c
new file mode 100644
index 000000000..530e7c976
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/critical-4.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+
+extern void bar(int);
+
+void
+foo1 (void)
+{
+  #pragma omp critical
+  #pragma omp critical(foo)
+  #pragma omp critical(bar)
+    bar (0);
+}
+
+void
+foo2 (void)
+{
+  #pragma omp critical
+  #pragma omp critical		/* { dg-warning "with the same name" } */
+    bar (0);
+}
+
+void
+foo3 (void)
+{
+  #pragma omp critical(foo)
+  #pragma omp critical(foo)	/* { dg-warning "with the same name" } */
+    bar (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/empty.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/empty.c
new file mode 100644
index 000000000..6a21c0460
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/empty.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fopenmp -fdump-tree-ompexp" } */
+
+main()
+{
+#pragma omp parallel
+    {;}
+}
+
+/* There should not be a GOMP_parallel_start call.  */
+/* { dg-final { scan-tree-dump-times "GOMP_parallel_start" 0 "ompexp"} } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/flush-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/flush-1.c
new file mode 100644
index 000000000..d1a4d4a5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/flush-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-gimple" } */
+
+void f1(void)
+{
+  #pragma omp flush
+}
+
+int x, y, z;
+
+void f2(_Bool p)
+{
+  if (p)
+    {
+      #pragma omp flush (x)
+    }
+  else
+    {
+      #pragma omp flush (x, y, z)
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "__sync_synchronize" 3 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/flush-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/flush-2.c
new file mode 100644
index 000000000..c2685d837
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/flush-2.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+void f1(void)
+{
+  #pragma omp flush a	/* { dg-error "expected" } */
+  #pragma omp flush (	/* { dg-error "expected identifier" } */
+  #pragma omp flush (b	/* { dg-error "undeclared|expected|for each" } */
+  #pragma omp flush (c d)	/* { dg-error "undeclared|expected" } */
+  #pragma omp flush (e)		/* { dg-error "undeclared" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-1.c
new file mode 100644
index 000000000..840f94784
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-1.c
@@ -0,0 +1,49 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fshow-column" } */
+
+void foo (int j, int k)
+{
+  int i;
+
+  /* Valid loops.  */
+  #pragma omp for
+  for (i = 0; i < 10; i++)
+    baz (i);
+
+  #pragma omp for
+  for (i = j; i <= 10; i+=4)
+    baz (i);
+
+  #pragma omp for
+  for (i = j; i > 0; i = i - 1)
+    baz (j);
+
+  #pragma omp for
+  for (i = j; i >= k; i--)
+    baz (i);
+
+  /* Malformed parallel loops.  */
+  #pragma omp for
+  i = 0;		/* { dg-error "3:for statement expected" } */
+  for ( ; i < 10; )
+    {
+      baz (i);
+      i++;
+    }
+
+  #pragma omp for
+  for (i = 0; ; i--)	/* { dg-error "missing controlling predicate" } */
+    {
+      if (i >= 10)
+	break;		/* { dg-error "break" } */
+      baz (i);
+    }
+
+  #pragma omp for
+  for (i = 0; i < 10 && j > 4; i-=3)	/* { dg-error "15:invalid controlling predicate" } */
+    baz (i);
+
+  #pragma omp for
+  for (i = 0; i < 10; i-=3, j+=2)	/* { dg-error "23:invalid increment expression" } */
+    baz (i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-10.c
new file mode 100644
index 000000000..f21404249
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-10.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(runtime) ordered
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_runtime_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_runtime_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-11.c
new file mode 100644
index 000000000..8c747cdb9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-11.c
@@ -0,0 +1,73 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fopenmp" } */
+
+extern void baz (int);
+
+void foo (int j, int k)
+{
+  int i;
+
+  /* Valid loops.  */
+  #pragma omp for
+  for (i = 0; i < 10; i++)
+    baz (i);
+
+  #pragma omp for
+  for (i = j; i <= 10; i+=4)
+    baz (i);
+
+  #pragma omp for
+  for (i = j; i > 0; i = i - 1)
+    baz (j);
+
+  #pragma omp for
+  for (i = j; i >= k; i--)
+    baz (i);
+
+  #pragma omp for
+  for (int l = j; l < 10; l++)
+    baz (l);
+
+  /* Malformed parallel loops.  */
+  #pragma omp for
+  i = 0;		/* { dg-error "for statement expected" } */
+  for ( ; i < 10; )
+    {
+      baz (i);
+      i++;
+    }
+
+  #pragma omp for
+  for (i = 0; ; i--)	/* { dg-error "missing controlling predicate" } */
+    {
+      if (i >= 10)
+	break;		/* { dg-error "break" } */
+      baz (i);
+    }
+
+  #pragma omp for
+  for (i = 0;
+       i < 10 && j > 4; /* { dg-error "invalid controlling predicate" } */
+       i-=3)
+    baz (i);
+
+  #pragma omp for
+  for (i = 0;
+       i < 10;
+       i-=3, j+=2)	/* { dg-error "invalid increment expression" } */
+    baz (i);
+
+  int m = 0;
+  #pragma omp for
+  for (; m < 10; m++)	/* { dg-error "expected" } */
+    baz (m);
+
+  m = 0;
+  #pragma omp for
+  for (int n = 0; m < 10; m++)	/* { dg-error "invalid controlling predicate|invalid increment expression" } */
+    baz (m);
+
+  #pragma omp for
+  for (m = 0; m < 10; i++)	/* { dg-error "invalid increment expression" } */
+    baz (m);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-12.c
new file mode 100644
index 000000000..98318d7d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-12.c
@@ -0,0 +1,12 @@
+int foo (void)
+{
+  int i, a;
+
+  a = 30;
+
+  #pragma omp parallel for lastprivate (a)
+  for (i = 0; i < 10; i++)
+    a = a + i;
+
+  return a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-13.c
new file mode 100644
index 000000000..607de49c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-13.c
@@ -0,0 +1,18 @@
+// At one point in development, a typo disabled the remapping of the
+// for iteration variable as private.
+
+// { dg-do compile }
+// { dg-options "-fopenmp -fdump-tree-ompexp" }
+
+extern void bar(int);
+void foo(void)
+{
+  int i;
+
+#pragma omp parallel for default(none)
+  for (i = 0; i < 10; i++)
+    bar(i);
+}
+
+// { dg-final { scan-tree-dump-times "omp_data_o" 0 "ompexp" } }
+// { dg-final { cleanup-tree-dump "ompexp" } }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-14.c
new file mode 100644
index 000000000..fb2641370
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-14.c
@@ -0,0 +1,19 @@
+// { dg-do compile }
+
+extern int printf (const char *, ...);
+extern void foo (int *);
+
+int main (void)
+{
+  double d = 6;
+  int i = 1, j = 6, k = 8;
+#pragma omp parallel shared(d) private(i) num_threads (4)
+  {
+    i = 4;
+#pragma omp for lastprivate(j)
+    for (j = 1; j <= k; j++)
+      printf ("%s %d %d %d %p %g\n", "Hello, World!", i, j, k, &j, d);
+    printf ("%s %d %g\n", "Hello, World!", i, d);
+  }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-15.c
new file mode 100644
index 000000000..28c2c926c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-15.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void foo()
+{
+	long n = 10;
+	int i;
+#pragma omp for
+	for (i=0; i < n; ++i) ;
+#pragma omp for
+	for (i=0; n > i; ++i) ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-16.c
new file mode 100644
index 000000000..2f221e4c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-16.c
@@ -0,0 +1,18 @@
+// PR 24703
+// { dg-do compile }
+
+void work(int);
+int work_param;
+int sphinx_omp_thread_count;
+int schedule_loop_cap;
+
+int measure_omp_parallel_for_dynamic (void)
+{
+  int j;
+
+#pragma omp parallel for schedule(dynamic)
+  for(j=0; j < sphinx_omp_thread_count * schedule_loop_cap; j++)
+    work(work_param);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-17.c
new file mode 100644
index 000000000..1c51f1a4c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-17.c
@@ -0,0 +1,67 @@
+/* { dg-do compile } */
+extern int bar (int);
+
+void
+foo (void)
+{
+  int j, k = 1, l = 30, m = 4;
+  long int o = 4;
+  long long int p = 0;
+#pragma omp for
+  for (j = k; j <= l; j += m - 1)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j += (m - 1))
+    ;
+#pragma omp for
+  for (j = k; j <= l; j += bar (m - 1))
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = j + m - 1)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = j + (m - 1))
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = j + bar (m - 1))
+    ;
+#pragma omp for
+  for (j = ({ int n; n = k; n; }); j <= l; j++)
+    ;
+#pragma omp for
+  for (j = k; j <= ({ int n; n = l; n; }); j++)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j += ({ int n; n = 1; n; }))
+    ;
+#pragma omp for
+  for (j = k; j <= l; j += m + 1)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j += o)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = j + o)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = o + 1 + j)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = o + m + j)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j += o + p)
+    ;
+#pragma omp for
+  for (j = k; j <= l; j = j + o + p)
+    ;
+#pragma omp for
+  for (j = l; j >= k; j -= o)
+    ;
+#pragma omp for
+  for (j = l; j >= k; j -= p)
+    ;
+#pragma omp for
+  for (j = l; j >= k; j -= o + p)
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-18.c
new file mode 100644
index 000000000..545f271c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-18.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fopenmp -fdump-tree-ompexp" } */
+
+void
+foo (int *a, int i)
+{
+  int j, k = 1, l = 30, m = 4;
+#pragma omp parallel for num_threads (3 * i) schedule (dynamic, i * 4)
+  for (j = 0; j <= l; j++)
+    a[j] = 1;
+#pragma omp parallel for num_threads (3 * i) schedule (dynamic, i * 4)
+  for (j = k; j <= l; j += (m - 1))
+    a[j] = 2;
+#pragma omp parallel for num_threads (3 * i) schedule (dynamic, 4)
+  for (j = 0; j <= l; j++)
+    a[j] = 3;
+#pragma omp parallel for num_threads (3 * i) schedule (dynamic, 4)
+  for (j = k; j <= l; j += (m - 1))
+    a[j] = 4;
+}
+
+void
+bar (int *a, int i)
+{
+  int j, k = 1, l = 30, m = 4;
+#pragma omp parallel for num_threads (3 * i) schedule (guided, i * 4)
+  for (j = 0; j <= l; j++)
+    a[j] = 1;
+#pragma omp parallel for num_threads (3 * i) schedule (guided, i * 4)
+  for (j = k; j <= l; j += (m - 1))
+    a[j] = 2;
+#pragma omp parallel for num_threads (3 * i) schedule (guided, 4)
+  for (j = 0; j <= l; j++)
+    a[j] = 3;
+#pragma omp parallel for num_threads (3 * i) schedule (guided, 4)
+  for (j = k; j <= l; j += (m - 1))
+    a[j] = 4;
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_parallel_loop_dynamic_start" 4 "ompexp" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "GOMP_parallel_loop_guided_start" 4 "ompexp" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-19.c
new file mode 100644
index 000000000..a202ba479
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-19.c
@@ -0,0 +1,21 @@
+/* Verify that if GOMP_parallel_loop_dynamic_start is used, variables
+   mentioned in the INIT, COND and INCR expressions aren't unnecessarily
+   copied to the omp_fn function.  */
+/* { dg-do compile } */
+/* { dg-options "-O -fopenmp -fdump-tree-gimple" } */
+
+void foo (int *a, int i, int j, int k, int l, int m)
+{
+#pragma omp parallel for num_threads (3 * i) schedule (dynamic, i * 4)
+  for (j = 0; j <= (6 * l + 4 * k); j++)
+    a[j] = 1;
+#pragma omp parallel for num_threads (3 * i) schedule (dynamic, i * 4)
+  for (j = m; j <= l; j += (k + l - m))
+    a[j] = 1;
+}
+
+/* { dg-final { scan-tree-dump-times "shared\\(a\\)" 2 "gimple" } } */
+/* { dg-final { scan-tree-dump-times "shared\\(k\\)" 0 "gimple" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "shared\\(l\\)" 0 "gimple" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "shared\\(m\\)" 0 "gimple" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-2.c
new file mode 100644
index 000000000..37e5929af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+void foo()
+{
+  int i;
+
+  #pragma omp for nowait
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for nowait nowait		/* { dg-error "too many" } */
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for ordered
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for ordered ordered	/* { dg-error "too many" } */
+  for (i = 0; i < 10; ++i) ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-3.c
new file mode 100644
index 000000000..f3b0dbda7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-3.c
@@ -0,0 +1,62 @@
+// { dg-do compile }
+
+int bar ();
+
+void foo()
+{
+  int i;
+
+  #pragma omp for schedule		// { dg-error "expected '\\('" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule static	// { dg-error "expected '\\('" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (		// { dg-error "invalid schedule kind" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static	// { dg-error "expected" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static )
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( foo )	// { dg-error "invalid schedule kind" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static 1	// { dg-error "expected" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static 1 ) nowait	// { dg-error "expected" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static, 1 ) nowait
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static, 1, 1 ) nowait	// { dg-error "expected '\\)'" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static, 1 + 1 ) nowait
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule ( static, 1.0 )	// { dg-error "expected integer expression" }
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (dynamic)
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (dynamic, bar ())
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (guided)
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (guided, bar ())
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (runtime)
+  for (i = 0; i < 10; ++i) ;
+
+  #pragma omp for schedule (runtime, bar ())	// { dg-error "does not take" }
+  for (i = 0; i < 10; ++i) ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-4.c
new file mode 100644
index 000000000..fb6994ea2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-4.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(dynamic)
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_dynamic_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_dynamic_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-5.c
new file mode 100644
index 000000000..5912a4e55
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-5.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(guided)
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_guided_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_guided_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-6.c
new file mode 100644
index 000000000..100ee2c8c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-6.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(runtime)
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_runtime_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_runtime_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-7.c
new file mode 100644
index 000000000..10763dc59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(static) ordered
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_static_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_static_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-8.c
new file mode 100644
index 000000000..1bc66c49a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-8.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(dynamic) ordered
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_dynamic_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_dynamic_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-9.c
new file mode 100644
index 000000000..af99e216e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/for-9.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (int n)
+{
+  int i;
+
+  #pragma omp for schedule(guided) ordered
+  for (i = 0; i < n; ++i)
+    bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_guided_start" 1 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_loop_ordered_guided_next" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/gomp.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/gomp.exp
new file mode 100644
index 000000000..7ce426deb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/gomp.exp
@@ -0,0 +1,18 @@
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+if ![check_effective_target_fopenmp] {
+  return
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [find $srcdir/$subdir *.c]] \
+	"" "-fopenmp"
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-1.c
new file mode 100644
index 000000000..b04610d2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-1.c
@@ -0,0 +1,10 @@
+// { dg-do compile }
+
+#define N 10
+
+extern void bar(void);
+void foo(void)
+{
+  #pragma omp parallel num_threads(N)
+    bar();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-2.c
new file mode 100644
index 000000000..75d6490cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-2.c
@@ -0,0 +1,14 @@
+// { dg-do compile }
+
+#define p	parallel
+#define s(x)	shared(x##1, x##2)
+#define d(x)	default(x)
+
+void bar(int, int, int, int);
+void foo(void)
+{
+  int a1, a2, b1, b2;
+
+  #pragma omp p s(a) s(b) d(none)
+    bar(a1, a2, b1, b2);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-3.c
new file mode 100644
index 000000000..233d2edcd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-3.c
@@ -0,0 +1,26 @@
+/* PR preprocessor/27746 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-omplower" } */
+
+#define omp		FOO
+#define p		parallel
+#define omp_parallel	_Pragma ("omp parallel")
+#define omp_p		_Pragma ("omp p")
+
+void bar (void);
+
+void
+foo (void)
+{
+  #pragma omp parallel
+    bar ();
+  #pragma omp p
+    bar ();
+  omp_parallel
+    bar ();
+  omp_p
+    bar ();
+}
+
+/* { dg-final { scan-tree-dump-times "#pragma omp parallel" 4 "omplower" } } */
+/* { dg-final { cleanup-tree-dump "omplower" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-4.c
new file mode 100644
index 000000000..7d20f4cd6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/macro-4.c
@@ -0,0 +1,29 @@
+/* PR preprocessor/27746 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -Wunknown-pragmas" } */
+
+#define p		_Pragma ("omp parallel")
+#define omp_p		_Pragma ("omp p")
+
+void bar (void);
+
+void
+foo (void)
+{
+#pragma omp p		/* { dg-warning "ignoring #pragma omp _Pragma" } */
+    bar ();
+  omp_p			/* { dg-warning "ignoring #pragma omp _Pragma" } */
+    bar ();
+}
+
+#define parallel	serial
+#define omp_parallel	_Pragma ("omp parallel")
+
+void
+baz (void)
+{
+#pragma omp parallel	/* { dg-warning "ignoring #pragma omp serial" } */
+    bar ();
+  omp_parallel		/* { dg-warning "ignoring #pragma omp serial" } */
+    bar ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-1.c
new file mode 100644
index 000000000..2681c216a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+
+extern void bar(int);
+
+void foo (void)
+{
+  #pragma omp master
+    bar(0);
+
+  #pragma omp master
+  {
+    bar(1);
+    bar(2);
+  }
+
+  /* Yes, this is legal -- structured-block contains statement contains
+     openmp-construct contains master-construct.  */
+  #pragma omp master
+  #pragma omp master
+  #pragma omp master
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-2.c
new file mode 100644
index 000000000..3b0bdfc90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+void f1(void)
+{
+  #pragma omp master asdf	/* { dg-error "expected" } */
+  #pragma omp master
+}				/* { dg-error "expected expression" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-3.c
new file mode 100644
index 000000000..fee09ddd7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/master-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (void)
+{
+  #pragma omp master
+    bar(0);
+}
+
+/* { dg-final { scan-tree-dump-times "omp_get_thread_num" 1 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/nestedfn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/nestedfn-1.c
new file mode 100644
index 000000000..8532d8af1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/nestedfn-1.c
@@ -0,0 +1,53 @@
+/* This testcase violates the OpenMP requirements, as nested functions
+   access the original variables.
+   We test it just to make sure we don't ICE on it.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void abort (void);
+extern int omp_get_thread_num ();
+extern void omp_set_dynamic (int);
+
+int
+main (void)
+{
+  int j = 0, k = 6, l = 7, m = 8;
+  void foo (void)
+  {
+    int i = 5;
+    int bar (void)
+    {
+      return i + 1 + (j > 100 ? 10000 : 0);
+    }
+#pragma omp sections private (i)
+    {
+#pragma omp section
+      {
+	i = 6;
+	if (bar () != 6)
+#pragma omp atomic
+	  ++j;
+      }
+#pragma omp section
+      {
+	if (bar () != 6)
+#pragma omp atomic
+	  ++j;
+      }
+    }
+    if (k != 6 || l != 7 || m != 8)
+#pragma omp atomic
+      ++j;
+  }
+  omp_set_dynamic (0);
+#pragma omp parallel num_threads (2) firstprivate (k) shared (l) private (m)
+  {
+    if (omp_get_thread_num () != 0)
+      k += omp_get_thread_num ();
+    m = 9;
+    foo ();
+  }
+  if (j)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/nesting-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/nesting-1.c
new file mode 100644
index 000000000..6f27b907e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/nesting-1.c
@@ -0,0 +1,198 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void
+f1 (void)
+{
+  int i, j;
+  #pragma omp for
+  for (i = 0; i < 3; i++)
+    {
+      #pragma omp for		/* { dg-warning "may not be closely nested" } */
+      for (j = 0; j < 3; j++)
+	;
+      #pragma omp sections	/* { dg-warning "may not be closely nested" } */
+      {
+	;
+      #pragma omp section
+	;
+      }
+      #pragma omp single	/* { dg-warning "may not be closely nested" } */
+	;
+    #pragma omp master		/* { dg-warning "may not be closely nested" } */
+      ;
+      #pragma omp barrier	/* { dg-warning "may not be closely nested" } */
+    }
+  #pragma omp sections
+  {
+    #pragma omp for		/* { dg-warning "may not be closely nested" } */
+    for (j = 0; j < 3; j++)
+      ;
+    #pragma omp sections	/* { dg-warning "may not be closely nested" } */
+    {
+      ;
+    #pragma omp section
+      ;
+    }
+    #pragma omp single		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp master		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp section
+      ;
+  }
+  #pragma omp single
+  {
+    #pragma omp for		/* { dg-warning "may not be closely nested" } */
+    for (j = 0; j < 3; j++)
+      ;
+    #pragma omp sections	/* { dg-warning "may not be closely nested" } */
+    {
+      ;
+    #pragma omp section
+      ;
+    }
+    #pragma omp single		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp master		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp barrier		/* { dg-warning "may not be closely nested" } */
+  }
+  #pragma omp master
+  {
+    #pragma omp for		/* { dg-warning "may not be closely nested" } */
+    for (j = 0; j < 3; j++)
+      ;
+    #pragma omp sections	/* { dg-warning "may not be closely nested" } */
+    {
+      ;
+    #pragma omp section
+      ;
+    }
+    #pragma omp single		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp master
+      ;
+    #pragma omp barrier		/* { dg-warning "may not be closely nested" } */
+  }
+  #pragma omp task
+  {
+    #pragma omp for		/* { dg-warning "may not be closely nested" } */
+    for (j = 0; j < 3; j++)
+      ;
+    #pragma omp sections	/* { dg-warning "may not be closely nested" } */
+    {
+      ;
+    #pragma omp section
+      ;
+    }
+    #pragma omp single		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp master		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp barrier		/* { dg-warning "may not be closely nested" } */
+  }
+  #pragma omp parallel
+  {
+    #pragma omp for
+    for (j = 0; j < 3; j++)
+      ;
+    #pragma omp sections
+    {
+      ;
+    #pragma omp section
+      ;
+    }
+    #pragma omp single
+      ;
+    #pragma omp master
+      ;
+    #pragma omp barrier
+  }
+}
+
+void
+f2 (void)
+{
+  int i, j;
+  #pragma omp ordered
+  {
+    #pragma omp for		/* { dg-warning "may not be closely nested" } */
+    for (j = 0; j < 3; j++)
+      ;
+    #pragma omp sections	/* { dg-warning "may not be closely nested" } */
+    {
+      ;
+    #pragma omp section
+      ;
+    }
+    #pragma omp single		/* { dg-warning "may not be closely nested" } */
+      ;
+    #pragma omp master
+      ;
+    #pragma omp barrier		/* { dg-warning "may not be closely nested" } */
+  }
+}
+
+void
+f3 (void)
+{
+  #pragma omp critical
+  {
+    #pragma omp ordered		/* { dg-warning "may not be closely nested" } */
+      ;
+  }
+}
+
+void
+f4 (void)
+{
+  #pragma omp task
+  {
+    #pragma omp ordered		/* { dg-warning "may not be closely nested" } */
+      ;
+  }
+}
+
+void
+f5 (void)
+{
+  int i;
+  #pragma omp for
+  for (i = 0; i < 10; i++)
+    {
+      #pragma omp ordered		/* { dg-warning "must be closely nested" } */
+	;
+    }
+  #pragma omp for ordered
+  for (i = 0; i < 10; i++)
+    {
+      #pragma omp ordered
+	;
+    }
+}
+
+void
+f6 (void)
+{
+  #pragma omp critical (foo)
+    #pragma omp critical (bar)
+      ;
+  #pragma omp critical
+    #pragma omp critical (baz)
+      ;
+}
+
+void
+f7 (void)
+{
+  #pragma omp critical (foo2)
+    #pragma omp critical
+      ;
+  #pragma omp critical (bar)
+    #pragma omp critical (bar)		/* { dg-warning "may not be nested" } */
+      ;
+  #pragma omp critical
+    #pragma omp critical		/* { dg-warning "may not be nested" } */
+      ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/num-threads-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/num-threads-1.c
new file mode 100644
index 000000000..f792ef96b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/num-threads-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+extern void bar(void);
+void foo(void)
+{
+  #pragma omp parallel num_threads (0)	/* { dg-warning "must be positive" } */
+    {
+      bar ();
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/omp-parallel-if.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/omp-parallel-if.c
new file mode 100644
index 000000000..ca06aeef9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/omp-parallel-if.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+
+extern int foo(void);
+extern void bar(void);
+
+int main ()
+{
+  /* Malformed uses of 'if' and 'num_threads'.  */
+  #pragma omp parallel if (foo () > 10) if (foo () == 3) /* { dg-error "too many" } */
+    {
+      bar ();
+    }
+
+  #pragma omp parallel num_threads (3) num_threads (20)	/* { dg-error "too many" } */
+    {
+      bar ();
+    }
+
+  /* Valid uses of 'if' and 'num_threads'.  */
+  #pragma omp parallel if (foo () == 10) num_threads (foo ())
+    {
+      bar ();
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/ordered-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/ordered-1.c
new file mode 100644
index 000000000..de5e116eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/ordered-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-ompexp" } */
+
+extern void bar(int);
+
+void foo (void)
+{
+  #pragma omp ordered
+    bar(0);
+
+  #pragma omp ordered
+  {
+    bar(1);
+    bar(2);
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "GOMP_ordered_start" 2 "ompexp" } } */
+/* { dg-final { scan-tree-dump-times "GOMP_ordered_end" 2 "ompexp" } } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/ordered-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/ordered-2.c
new file mode 100644
index 000000000..2884b1026
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/ordered-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+void f1(void)
+{
+  #pragma omp ordered asdf	/* { dg-error "expected" } */
+  #pragma omp ordered
+}				/* { dg-error "expected expression" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-1.c
new file mode 100644
index 000000000..c5c233b76
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-1.c
@@ -0,0 +1,17 @@
+// { dg-do compile }
+
+void foo()
+{
+  int i;
+
+  #pragma omp parallel
+    {
+    #pragma omp parallel
+      {
+      #pragma omp parallel
+        {
+ 	  i++;
+	}
+      }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-2.c
new file mode 100644
index 000000000..68e577766
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-2.c
@@ -0,0 +1,17 @@
+// { dg-do compile }
+
+void foo()
+{
+  int i;
+
+  #pragma omp parallel default(none)		// { dg-error "enclosing" }
+    {
+    #pragma omp parallel
+      {
+      #pragma omp parallel default(none)	// { dg-error "enclosing" }
+        {
+ 	  i++;					// { dg-error "not specified" }
+	}
+      }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-3.c
new file mode 100644
index 000000000..633d7ba59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-3.c
@@ -0,0 +1,15 @@
+// { dg-do compile }
+
+extern int printf (const char *, ...);
+
+int main (void)
+{
+  double d = 6;
+  int i = 1;
+#pragma omp parallel shared(d) private(i) num_threads (4 + i)
+  {
+    i = 4;
+    printf ("%s %d %g\n", "Hello, World!", i, d);
+  }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-4.c
new file mode 100644
index 000000000..b8cd174a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/parallel-4.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+
+extern void bar (void);
+
+int main (void)
+{
+  int i;
+#pragma omp parallel for nowait /* { dg-error "'nowait'" } */
+  for (i = 0; i < 10; i++)
+    bar ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25874.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25874.c
new file mode 100644
index 000000000..2afd02ea3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25874.c
@@ -0,0 +1,17 @@
+/* { dg-options "-O -fopenmp" } */
+
+void foo();
+
+inline void bar()
+{
+  int i;
+  for ( i=0; i<1; ++i )
+#pragma omp parallel
+    foo();
+}
+
+void baz()
+{
+#pragma omp parallel
+  bar();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25989.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25989.c
new file mode 100644
index 000000000..39bd4b77c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25989.c
@@ -0,0 +1,16 @@
+/* PR middle-end/25989 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+int
+main (void)
+{
+  int i, j;
+  float a, b = 1.0;
+
+#pragma omp parallel for schedule(guided,1) private(j)
+  for (i = 1; i <= 9; i++)
+    for (j = 1; j <= 9; j++)
+      a = b;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25990.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25990.c
new file mode 100644
index 000000000..e3c4562cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25990.c
@@ -0,0 +1,261 @@
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -O2 -std=c99" } */
+
+typedef __SIZE_TYPE__ size_t;
+
+typedef struct {
+  int _flags;
+} FILE;
+
+extern FILE *fopen (__const char *__restrict __filename,
+      __const char *__restrict __modes);
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+extern int fclose (FILE *__stream);
+extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s) ;
+
+extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
+
+extern size_t strlen (__const char *__s)
+     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
+     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int __attribute__ ((__nothrow__)) atoi (__const char *__nptr);
+
+extern float cabsf (float _Complex __z) __attribute__ ((__nothrow__)); extern float __cabsf (float _Complex __z) __attribute__ ((__nothrow__));
+extern float sqrtf (float __x) __attribute__ ((__nothrow__)); extern float __sqrtf (float __x) __attribute__ ((__nothrow__));
+
+int main(int argc , char * argv[])
+{
+  int AA, BB, CC;
+  AA = 99;
+  BB = 99;
+  CC = (int)atoi(argv[3]);
+  int m,n,s;
+  int DD,EE,num_s;
+
+
+  float _Complex * restrict A;
+  A = malloc((AA) * (BB) * (CC) * sizeof(float _Complex));
+  int A_slice_stride;
+  A_slice_stride = (AA) * (BB) ;
+
+
+  float * restrict f;
+  f = malloc(CC * sizeof(float));
+
+
+
+  FILE *fp;
+
+  fp = fopen(argv[1],"rb");
+  fread(A,sizeof(float _Complex),AA * BB * CC,fp);
+  fclose(fp);
+
+  fp = fopen(argv[2],"rb");
+  fread(f,sizeof(float),CC,fp);
+  fclose(fp);
+
+
+  DD = (int)atoi(argv[4]);
+  EE = (int)atoi(argv[5]);
+
+  num_s = (EE - DD) + 1;
+
+
+
+  float * restrict INPUT;
+  INPUT = malloc(4 * 4 * sizeof(float));
+
+
+
+  int m_max = 99;
+  int n_max = 00;
+  float h = 0.1;
+  float FF = 10;
+
+  if ((__extension__ (__builtin_constant_p (5) && ((__builtin_constant_p (argv[6]) && strlen (argv[6]) < ((size_t) (5))) || (__builtin_constant_p ("plane") && strlen ("plane") < ((size_t) (5)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (argv[6]) && __builtin_constant_p ("plane") && (__s1_len = strlen (argv[6]), __s2_len = strlen ("plane"), (!((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("plane") + 1) - (size_t)(const void *)("plane") == 1) || __s2_len >= 4)) ? __builtin_strcmp (argv[6], "plane") : (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) && (__s1_len = strlen (argv[6]), __s1_len < 4) ? (__builtin_constant_p ("plane") && ((size_t)(const void *)(("plane") + 1) - (size_t)(const void *)("plane") == 1) ? __builtin_strcmp (argv[6], "plane") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("plane"); register int __result = (((__const unsigned char *) (__const char *) (argv[6]))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (argv[6]))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("plane") && ((size_t)(const void *)(("plane") + 1) - (size_t)(const void *)("plane") == 1) && (__s2_len = strlen ("plane"), __s2_len < 4) ? (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) ? __builtin_strcmp (argv[6], "plane") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (argv[6]); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("plane"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("plane"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("plane"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("plane"))[3]); } } __result; }))) : __builtin_strcmp (argv[6], "plane")))); }) : (__extension__ (__builtin_constant_p (5) && ((__builtin_constant_p (argv[6]) && strlen (argv[6]) < ((size_t) (5))) || (__builtin_constant_p ("plane") && strlen ("plane") < ((size_t) (5)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (argv[6]) && __builtin_constant_p ("plane") && (__s1_len = strlen (argv[6]), __s2_len = strlen ("plane"), (!((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("plane") + 1) - (size_t)(const void *)("plane") == 1) || __s2_len >= 4)) ? __builtin_strcmp (argv[6], "plane") : (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) && (__s1_len = strlen (argv[6]), __s1_len < 4) ? (__builtin_constant_p ("plane") && ((size_t)(const void *)(("plane") + 1) - (size_t)(const void *)("plane") == 1) ? __builtin_strcmp (argv[6], "plane") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("plane"); register int __result = (((__const unsigned char *) (__const char *) (argv[6]))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (argv[6]))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("plane") && ((size_t)(const void *)(("plane") + 1) - (size_t)(const void *)("plane") == 1) && (__s2_len = strlen ("plane"), __s2_len < 4) ? (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) ? __builtin_strcmp (argv[6], "plane") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (argv[6]); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("plane"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("plane"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("plane"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("plane"))[3]); } } __result; }))) : __builtin_strcmp (argv[6], "plane")))); }) : strncmp (argv[6], "plane", 5)))))==0) {
+      m_max = INPUT[ ( ((1)-1) + ( ((1)-1)*4 ))];
+      n_max = INPUT[ ( ((2)-1) + ( ((1)-1)*4 ))];
+      h = INPUT[ ( ((3)-1) + ( ((1)-1)*4 ))];
+      FF = INPUT[ ( ((4)-1) + ( ((1)-1)*4 ))];
+  }
+
+  if ((__extension__ (__builtin_constant_p (6) && ((__builtin_constant_p (argv[6]) && strlen (argv[6]) < ((size_t) (6))) || (__builtin_constant_p ("sphere") && strlen ("sphere") < ((size_t) (6)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (argv[6]) && __builtin_constant_p ("sphere") && (__s1_len = strlen (argv[6]), __s2_len = strlen ("sphere"), (!((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("sphere") + 1) - (size_t)(const void *)("sphere") == 1) || __s2_len >= 4)) ? __builtin_strcmp (argv[6], "sphere") : (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) && (__s1_len = strlen (argv[6]), __s1_len < 4) ? (__builtin_constant_p ("sphere") && ((size_t)(const void *)(("sphere") + 1) - (size_t)(const void *)("sphere") == 1) ? __builtin_strcmp (argv[6], "sphere") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("sphere"); register int __result = (((__const unsigned char *) (__const char *) (argv[6]))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (argv[6]))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("sphere") && ((size_t)(const void *)(("sphere") + 1) - (size_t)(const void *)("sphere") == 1) && (__s2_len = strlen ("sphere"), __s2_len < 4) ? (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) ? __builtin_strcmp (argv[6], "sphere") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (argv[6]); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("sphere"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("sphere"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("sphere"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("sphere"))[3]); } } __result; }))) : __builtin_strcmp (argv[6], "sphere")))); }) : (__extension__ (__builtin_constant_p (6) && ((__builtin_constant_p (argv[6]) && strlen (argv[6]) < ((size_t) (6))) || (__builtin_constant_p ("sphere") && strlen ("sphere") < ((size_t) (6)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (argv[6]) && __builtin_constant_p ("sphere") && (__s1_len = strlen (argv[6]), __s2_len = strlen ("sphere"), (!((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("sphere") + 1) - (size_t)(const void *)("sphere") == 1) || __s2_len >= 4)) ? __builtin_strcmp (argv[6], "sphere") : (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) && (__s1_len = strlen (argv[6]), __s1_len < 4) ? (__builtin_constant_p ("sphere") && ((size_t)(const void *)(("sphere") + 1) - (size_t)(const void *)("sphere") == 1) ? __builtin_strcmp (argv[6], "sphere") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("sphere"); register int __result = (((__const unsigned char *) (__const char *) (argv[6]))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (argv[6]))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (argv[6]))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("sphere") && ((size_t)(const void *)(("sphere") + 1) - (size_t)(const void *)("sphere") == 1) && (__s2_len = strlen ("sphere"), __s2_len < 4) ? (__builtin_constant_p (argv[6]) && ((size_t)(const void *)((argv[6]) + 1) - (size_t)(const void *)(argv[6]) == 1) ? __builtin_strcmp (argv[6], "sphere") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (argv[6]); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("sphere"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("sphere"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("sphere"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("sphere"))[3]); } } __result; }))) : __builtin_strcmp (argv[6], "sphere")))); }) : strncmp (argv[6], "sphere", 6)))))==0) {
+      m_max = 181;
+      n_max = 361;
+      h = INPUT[ ( ((3)-1) + ( ((1)-1)*4 ))];
+      FF = INPUT[ ( ((4)-1) + ( ((1)-1)*4 ))];
+  }
+
+
+
+
+
+  float * restrict X;
+  X = malloc(m_max * n_max * sizeof(float));
+
+
+  float * restrict Y;
+  Y = malloc(m_max * n_max * sizeof(float));
+
+
+  float * restrict Z;
+  Z = malloc(m_max * n_max * sizeof(float));
+
+
+
+
+
+
+  float _Complex * restrict P;
+  P = malloc(m_max * n_max * sizeof(float _Complex));
+
+
+  float _Complex * restrict Ps;
+  Ps = malloc((m_max) * (n_max) * (num_s) * sizeof(float _Complex));
+  int Ps_slice_stride;
+  Ps_slice_stride = (m_max) * (n_max) ;
+
+
+  float GG;
+  float HH;
+
+
+
+
+  for ( n = 1 ; n <= 99 ; n++ ) {
+      for ( m = 1 ; m <= 99 ; m++ ) {
+
+
+
+
+
+	  X[ ( ((m)-1) + ( ((n)-1)*m_max ))] = FF ;
+	  Y[ ( ((m)-1) + ( ((n)-1)*m_max ))] = FF ;
+	  Z[ ( ((m)-1) + ( ((n)-1)*m_max ))] = FF ;
+      }
+  }
+  int KK = atoi(argv[8]);
+  int LL = 3 * KK;
+
+
+  float * restrict MM;
+  MM = malloc(4 * LL * sizeof(float));
+  for ( n = 1 ; n <= n_max ; n++) {
+      for ( m = 1 ; m <= m_max ; m++) {
+	  for ( s = 1 ; s <= num_s ; s++) {
+	      Ps[ ( ((m)-1) + (((n)-1)*(m_max)) + (((s)-1)*(Ps_slice_stride)) ) ] = 0.0 + 0.0 * (__extension__ 1.0iF);
+	  }
+      }
+  }
+
+
+  int liter ;
+
+#pragma omp parallel for private(m,liter,s)
+  for ( n = 1 ; n <= n_max ; n++) {
+      for ( m = 1 ; m <= m_max ; m++) {
+	  for ( liter = 1 ; liter <= KK ; liter++ ) {
+	      for ( s = 1 ; s <= num_s ; s++) {
+
+
+		  int LM_column;
+		  float NN[4];
+		  float OO[4];
+		  float PP[4];
+		  float QQ[4];
+		  float k;
+		  int s_index;
+		  float RR;
+
+		  s_index = s + (DD -1);
+		  RR = f[ ( (s_index)-1) ];
+		  k = 99.0;
+
+		  NN[1 -1] = X[ ( ((m)-1) + ( ((n)-1)*m_max ))];
+		  NN[2 -1] = Y[ ( ((m)-1) + ( ((n)-1)*m_max ))];
+		  NN[3 -1] = Z[ ( ((m)-1) + ( ((n)-1)*m_max ))];
+		  NN[4 -1] = 1.0;
+
+		  LM_column = ((liter -1) * 3) + 1;
+		  OO[1 -1] = MM[ ( ((1)-1) + ( ((LM_column)-1)*4 ))];
+		  OO[2 -1] = MM[ ( ((2)-1) + ( ((LM_column)-1)*4 ))];
+		  OO[3 -1] = MM[ ( ((3)-1) + ( ((LM_column)-1)*4 ))];
+		  OO[4 -1] = MM[ ( ((4)-1) + ( ((LM_column)-1)*4 ))];
+
+		  LM_column = ((liter -1) * 3) + 2;
+		  PP[1 -1] = MM[ ( ((1)-1) + ( ((LM_column)-1)*4 ))];
+		  PP[2 -1] = MM[ ( ((2)-1) + ( ((LM_column)-1)*4 ))];
+		  PP[3 -1] = MM[ ( ((3)-1) + ( ((LM_column)-1)*4 ))];
+		  PP[4 -1] = MM[ ( ((4)-1) + ( ((LM_column)-1)*4 ))];
+
+		  LM_column = ((liter -1) * 3) + 3;
+		  QQ[1 -1] = MM[ ( ((1)-1) + ( ((LM_column)-1)*4 ))];
+		  QQ[2 -1] = MM[ ( ((2)-1) + ( ((LM_column)-1)*4 ))];
+		  QQ[3 -1] = MM[ ( ((3)-1) + ( ((LM_column)-1)*4 ))];
+		  QQ[4 -1] = MM[ ( ((4)-1) + ( ((LM_column)-1)*4 ))];
+
+	      }
+	  }
+      }
+  }
+
+
+#pragma omp parallel for private(m)
+  for ( n = 1 ; n <= n_max ; n++) {
+      for ( m = 1 ; m <= m_max ; m++) {
+
+
+
+	  int s;
+	  float SSS;
+	  float f1,f2,p1,p2,TT,h,FFF;
+	  SSS = 0.0;
+	  for ( s = 2 ; s <= num_s ; s++) {
+	      f1 = f[ ( ((s-1) + (DD - 1))-1) ];
+	      f2 = f[ ( ((s) + (DD - 1))-1) ];
+	      p1 = cabsf(Ps[ ( ((m)-1) + (((n)-1)*(m_max)) + ((((s-1))-1)*(Ps_slice_stride)) ) ]) ;
+	      p2 = cabsf(Ps[ ( ((m)-1) + (((n)-1)*(m_max)) + (((s)-1)*(Ps_slice_stride)) ) ]) ;
+
+	      h = f2 - f1;
+
+	      FFF = (f1 + f2) / 2.0;
+
+
+	      TT = (1.0 / sqrtf(2.0)) * (((h * p1) + (0.5 * h * (p2 - p1))) * (1.0 / FFF));
+
+	      SSS += TT;
+
+	  }
+
+	  P[ ( ((m)-1) + ( ((n)-1)*m_max ))] = SSS + ((__extension__ 1.0iF) * 0.0);
+      }
+  }
+
+
+
+
+
+  fp = fopen(argv[10],"wb");
+  fwrite(X,sizeof(float),m_max * n_max,fp);
+  fclose(fp);
+
+  fp = fopen(argv[11],"wb");
+  fwrite(Y,sizeof(float),m_max * n_max,fp);
+  fclose(fp);
+
+  fp = fopen(argv[12],"wb");
+  fwrite(Z,sizeof(float),m_max * n_max,fp);
+  fclose(fp);
+
+  fp = fopen(argv[13],"wb");
+  fwrite(P,sizeof(float _Complex),m_max * n_max,fp);
+  fclose(fp);
+
+
+
+  return(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25996.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25996.c
new file mode 100644
index 000000000..d58c9a1c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr25996.c
@@ -0,0 +1,32 @@
+/* PR c/25996 */
+
+void
+test1 (void)
+{
+#pragma omp for
+  for (i = 0; i < 1; ++i); /* { dg-error "undeclared|for each function" } */
+}
+
+void
+test2 (void)
+{
+  int i;
+#pragma omp for
+  for (i = j; i < 1; ++i); /* { dg-error "undeclared" } */
+}
+
+void
+test3 (void)
+{
+  int i;
+#pragma omp for
+  for (i = 0; i < j; ++i); /* { dg-error "undeclared|invalid controlling predicate" } */
+}
+
+void
+test4 (void)
+{
+  int i;
+#pragma omp for
+  for (i = 0; i < 10; i += j); /* { dg-error "undeclared|invalid increment expression" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr26412.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr26412.c
new file mode 100644
index 000000000..6baecfe68
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr26412.c
@@ -0,0 +1,18 @@
+/* PR middle-end/26412 */
+/* { dg-do compile } */
+
+extern double a[];
+extern int b;
+
+double
+test (void)
+{
+  int i;
+  double c = 0;
+
+#pragma omp parallel for private(i) reduction(+:c)
+  for (i = 0; i < 10000; i++)
+    c += a[b];
+
+  return c;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27328.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27328.c
new file mode 100644
index 000000000..afde738a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27328.c
@@ -0,0 +1,19 @@
+/* PR middle-end/27328 */
+/* { dg-do compile } */
+
+extern void baz (void) __attribute__((noreturn));
+
+void
+foo (void)
+{
+#pragma omp parallel
+  for (;;)
+    ;
+}
+
+void
+bar (void)
+{
+#pragma omp parallel
+  baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27358.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27358.c
new file mode 100644
index 000000000..3451284e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27358.c
@@ -0,0 +1,8 @@
+/* PR c/27358 */
+/* { dg-do compile } */
+
+void foo(error i)		/* { dg-error "" } */
+{
+#pragma omp parallel
+  i = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-1.c
new file mode 100644
index 000000000..f315b8bd3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-1.c
@@ -0,0 +1,23 @@
+/* PR middle-end/27388 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-omplower" } */
+
+int n, o;
+
+void
+foo (void)
+{
+#pragma omp parallel firstprivate (n)
+  {
+    int i;
+#pragma omp parallel for firstprivate (n)
+    for (i = 0; i < 10; i++)
+      ++n;
+#pragma omp atomic
+    o += n;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "shared\\\(i\\\)" 0 "omplower" } } */
+/* { dg-final { scan-tree-dump-times "private\\\(i\\\)" 1 "omplower" } } */
+/* { dg-final { cleanup-tree-dump "omplower" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-2.c
new file mode 100644
index 000000000..da8a48d7e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-2.c
@@ -0,0 +1,35 @@
+/* PR middle-end/27388 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-omplower" } */
+
+extern void baz (int);
+
+void
+foo (void)
+{
+  int i;
+#pragma omp parallel for shared (i)
+  for (i = 0; i < 2; i++)
+    baz (i);
+}
+
+void
+bar (void)
+{
+  int j = 0;
+#pragma omp parallel shared (j)
+  {
+    j++;
+#pragma omp for
+    for (j = 0; j < 2; j++)
+      baz (j);
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "shared\\\(i\\\)\[^\\n\]*private\\\(i\\\)" 0 "omplower" } } */
+/* { dg-final { scan-tree-dump-times "private\\\(i\\\)\[^\\n\]*shared\\\(i\\\)" 0 "omplower" } } */
+/* { dg-final { scan-tree-dump-times "omp for\[^\\n\]*private\\\(i\\\)" 1 "omplower" } } */
+/* { dg-final { scan-tree-dump-times "shared\\\(j\\\)\[^\\n\]*private\\\(j\\\)" 0 "omplower" } } */
+/* { dg-final { scan-tree-dump-times "private\\\(j\\\)\[^\\n\]*shared\\\(j\\\)" 0 "omplower" } } */
+/* { dg-final { scan-tree-dump-times "omp for\[^\\n\]*private\\\(j\\\)" 1 "omplower" } } */
+/* { dg-final { cleanup-tree-dump "omplower" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-3.c
new file mode 100644
index 000000000..2cddb23c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27388-3.c
@@ -0,0 +1,23 @@
+/* PR middle-end/27388 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-omplower" } */
+
+extern void bar (int);
+
+void
+foo (void)
+{
+  int i = 0, j = 0;
+#pragma omp parallel firstprivate (i) private (j)
+  {
+#pragma omp for
+    for (i = 0; i < 2; i++)
+      bar (i);
+#pragma omp for
+    for (j = 0; j < 2; j++)
+      bar (j);
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "omp for\[^\\n\]*private" 2 "omplower" } } */
+/* { dg-final { cleanup-tree-dump "omplower" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27415.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27415.c
new file mode 100644
index 000000000..418eaf678
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27415.c
@@ -0,0 +1,50 @@
+/* PR middle-end/27415 */
+/* { dg-do compile } */
+
+void
+test1 (void)
+{
+  int i = 0;
+#pragma omp parallel
+#pragma omp for firstprivate (i)		/* { dg-error "should not be firstprivate" } */
+  for (i = 0; i < 10; i++)
+    ;
+}
+
+void
+test2 (void)
+{
+  int i = 0;
+#pragma omp parallel for firstprivate (i)
+  for (i = 0; i < 10; i++)			/* { dg-error "should not be firstprivate" } */
+    ;
+}
+
+void
+test3 (void)
+{
+  int i = 0;
+#pragma omp parallel
+#pragma omp for reduction (+:i)			/* { dg-error "should not be reduction" } */
+  for (i = 0; i < 10; i++)
+    ;
+}
+
+void
+test4 (void)
+{
+  int i = 0;
+#pragma omp parallel for reduction (*:i)
+  for (i = 0; i < 10; i++)			/* { dg-error "should not be reduction" } */
+    ;
+}
+
+void
+test5 (void)
+{
+  int i = 0;
+#pragma omp parallel firstprivate (i)
+#pragma omp for
+  for (i = 0; i < 10; i++)
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27416.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27416.c
new file mode 100644
index 000000000..802402446
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27416.c
@@ -0,0 +1,31 @@
+/* PR middle-end/27416 */
+/* { dg-do compile } */
+
+void
+foo (void)
+{
+  int i = 0, j = 0;
+#pragma omp for firstprivate (j) /* { dg-error "is private in outer context" } */
+  for (i = 0; i < 10; i++)
+    j++;
+}
+
+int
+bar (void)
+{
+  int i, j;
+#pragma omp for lastprivate (j)	/* { dg-error "is private in outer context" } */
+  for (i = 0; i < 10; i++)
+    j = i;
+  return j;
+}
+
+int
+baz (void)
+{
+  int i, j = 0;
+#pragma omp for reduction (+:j)	/* { dg-error "is private in outer context" } */
+  for (i = 0; i < 10; i++)
+    j++;
+  return j;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27499.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27499.c
new file mode 100644
index 000000000..0de2e0686
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27499.c
@@ -0,0 +1,13 @@
+/* PR c/27499 */
+/* { dg-do compile } */
+
+extern void bar (unsigned int);
+
+void
+foo (void)
+{
+  unsigned int i;
+#pragma omp parallel for
+  for (i = 0; i < 64; ++i)
+    bar (i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27573.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27573.c
new file mode 100644
index 000000000..4dca4da43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr27573.c
@@ -0,0 +1,20 @@
+/* PR middle-end/27573 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp -fprofile-generate" } */
+
+extern int puts (const char *);
+
+int
+main (void)
+{
+  int i, j = 8;
+#pragma omp parallel
+  {
+    puts ("foo");
+    for (i = 1; i < j - 1; i++)
+      ;
+  }
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29955.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29955.c
new file mode 100644
index 000000000..e49c11cae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29955.c
@@ -0,0 +1,14 @@
+/* PR c/29955 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp -fexceptions" } */
+
+extern void bar (int);
+
+void
+foo (int n)
+{
+  int i;
+#pragma omp parallel for schedule(dynamic)
+  for (i = 0; i < n; i++)
+    bar (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-1.c
new file mode 100644
index 000000000..b587d81e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-1.c
@@ -0,0 +1,45 @@
+/* PR middle-end/29965 */
+/* Test that OpenMP construct bodies which never return don't cause ICEs.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void baz (void) __attribute__ ((noreturn));
+
+static inline void
+foo (void)
+{
+#pragma omp parallel
+  for (;;)
+    ;
+}
+
+static inline void
+bar (void)
+{
+#pragma omp parallel
+  baz ();
+}
+
+void
+foo1 (void)
+{
+  foo ();
+}
+
+void
+foo2 (void)
+{
+  foo ();
+}
+
+void
+bar1 (void)
+{
+  bar ();
+}
+
+void
+bar2 (void)
+{
+  bar ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-2.c
new file mode 100644
index 000000000..1bee4859d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-2.c
@@ -0,0 +1,98 @@
+/* PR middle-end/29965 */
+/* Test that OpenMP construct bodies which never return don't cause ICEs.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void baz (void) __attribute__ ((noreturn));
+
+void
+foo1 (void)
+{
+#pragma omp sections
+  {
+    for (;;)
+      ;
+  }
+}
+
+void
+bar1 (void)
+{
+#pragma omp sections
+  {
+#pragma omp section
+    baz ();
+#pragma omp section
+    baz ();
+  }
+}
+
+void
+foo2 (void)
+{
+#pragma omp sections
+  {
+    ;
+#pragma omp section
+    for (;;)
+      ;    
+  }
+}
+
+void
+bar2 (void)
+{
+#pragma omp sections
+  {
+#pragma omp section
+    baz ();
+#pragma omp section
+    ;
+  }
+}
+
+void
+foo3 (void)
+{
+#pragma omp parallel sections
+  {
+    for (;;)
+      ;
+  }
+}
+
+void
+bar3 (void)
+{
+#pragma omp parallel sections
+  {
+#pragma omp section
+    baz ();
+#pragma omp section
+    baz ();
+  }
+}
+
+void
+foo4 (void)
+{
+#pragma omp parallel sections
+  {
+    ;
+#pragma omp section
+    for (;;)
+      ;    
+  }
+}
+
+void
+bar4 (void)
+{
+#pragma omp parallel sections
+  {
+#pragma omp section
+    baz ();
+#pragma omp section
+    ;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-3.c
new file mode 100644
index 000000000..5901f5f42
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-3.c
@@ -0,0 +1,62 @@
+/* PR middle-end/29965 */
+/* Test that OpenMP construct bodies which never return don't cause ICEs.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void baz (void) __attribute__ ((noreturn));
+
+void
+foo1 (void)
+{
+#pragma omp single
+  for (;;);
+}
+
+void
+bar1 (void)
+{
+#pragma omp single
+  baz ();
+}
+
+void
+foo2 (void)
+{
+#pragma omp master
+  for (;;);
+}
+
+void
+bar2 (void)
+{
+#pragma omp master
+  baz ();
+}
+
+void
+foo3 (void)
+{
+#pragma omp ordered
+  for (;;);
+}
+
+void
+bar3 (void)
+{
+#pragma omp ordered
+  baz ();
+}
+
+void
+foo4 (void)
+{
+#pragma omp critical
+  for (;;);
+}
+
+void
+bar4 (void)
+{
+#pragma omp critical
+  baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-4.c
new file mode 100644
index 000000000..7416d8ec6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-4.c
@@ -0,0 +1,44 @@
+/* PR middle-end/29965 */
+/* Test that OpenMP construct bodies which never return don't cause ICEs.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void baz (void) __attribute__ ((noreturn));
+
+void
+foo1 (void)
+{
+  int i;
+#pragma omp for schedule (dynamic)
+  for (i = 0; i < 2834; i++)
+    for (;;)
+      ;
+}
+
+void
+bar1 (void)
+{
+  int i;
+#pragma omp for schedule (dynamic)
+  for (i = 0; i < 2834; i++)
+    baz ();
+}
+
+void
+foo2 (void)
+{
+  int i;
+#pragma omp parallel for schedule (dynamic)
+  for (i = 0; i < 2834; i++)
+    for (;;)
+      ;
+}
+
+void
+bar2 (void)
+{
+  int i;
+#pragma omp parallel for schedule (dynamic)
+  for (i = 0; i < 2834; i++)
+    baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-5.c
new file mode 100644
index 000000000..a948ec9dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-5.c
@@ -0,0 +1,44 @@
+/* PR middle-end/29965 */
+/* Test that OpenMP construct bodies which never return don't cause ICEs.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void baz (void) __attribute__ ((noreturn));
+
+void
+foo1 (void)
+{
+  int i;
+#pragma omp for schedule (static)
+  for (i = 0; i < 2834; i++)
+    for (;;)
+      ;
+}
+
+void
+bar1 (void)
+{
+  int i;
+#pragma omp for schedule (static)
+  for (i = 0; i < 2834; i++)
+    baz ();
+}
+
+void
+foo2 (void)
+{
+  int i;
+#pragma omp parallel for schedule (static)
+  for (i = 0; i < 2834; i++)
+    for (;;)
+      ;
+}
+
+void
+bar2 (void)
+{
+  int i;
+#pragma omp parallel for schedule (static)
+  for (i = 0; i < 2834; i++)
+    baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-6.c
new file mode 100644
index 000000000..6f6947836
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr29965-6.c
@@ -0,0 +1,44 @@
+/* PR middle-end/29965 */
+/* Test that OpenMP construct bodies which never return don't cause ICEs.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp" } */
+
+extern void baz (void) __attribute__ ((noreturn));
+
+void
+foo1 (void)
+{
+  int i;
+#pragma omp for schedule (static, 16)
+  for (i = 0; i < 2834; i++)
+    for (;;)
+      ;
+}
+
+void
+bar1 (void)
+{
+  int i;
+#pragma omp for schedule (static, 16)
+  for (i = 0; i < 2834; i++)
+    baz ();
+}
+
+void
+foo2 (void)
+{
+  int i;
+#pragma omp parallel for schedule (static, 16)
+  for (i = 0; i < 2834; i++)
+    for (;;)
+      ;
+}
+
+void
+bar2 (void)
+{
+  int i;
+#pragma omp parallel for schedule (static, 16)
+  for (i = 0; i < 2834; i++)
+    baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr30421.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr30421.c
new file mode 100644
index 000000000..901ba3c13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr30421.c
@@ -0,0 +1,39 @@
+/* PR middle-end/30421 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp -Wall" } */
+
+int
+foo ()
+{
+  int a = 0, i;
+
+#pragma omp parallel for firstprivate(a) lastprivate(a)
+  for (i = 0; i < 10; i++)
+    a += i;
+
+  return a;
+}
+
+int
+bar ()
+{
+  int a = 0, i;
+
+#pragma omp parallel for firstprivate(a) lastprivate(a) schedule(static, 2)
+  for (i = 0; i < 10; i++)
+    a += i;
+
+  return a;
+}
+
+int
+baz ()
+{
+  int a = 0, i;
+
+#pragma omp parallel for firstprivate(a) lastprivate(a) schedule(dynamic)
+  for (i = 0; i < 10; i++)
+    a += i;
+
+  return a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr30494.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr30494.c
new file mode 100644
index 000000000..6a042ce69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr30494.c
@@ -0,0 +1,30 @@
+/* PR middle-end/30494 */
+/* { dg-do compile } */
+
+int
+foo (int n)
+{
+  int i;
+#pragma omp for
+  for (i = 0; i < 6; i++)
+    {
+      int v[n], w[n * 3 + i];
+      v[0] = 1;
+      w[0] = 2;
+    }
+  return 0;
+}
+
+int
+bar (int n)
+{
+  int i;
+#pragma parallel omp for
+  for (i = 0; i < 6; i++)
+    {
+      int v[n], w[n * 3 + i];
+      v[0] = 1;
+      w[0] = 2;
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr32468-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr32468-1.c
new file mode 100644
index 000000000..437241357
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr32468-1.c
@@ -0,0 +1,100 @@
+/* PR libgomp/32468 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fopenmp -fdump-tree-ompexp" } */
+
+extern int printf (const char *, ...);
+extern int omp_get_thread_num (void), omp_get_num_threads (void);
+extern int bar (void);
+extern int baz (const char *, ...);
+
+void
+f1 (void)
+{
+#pragma omp parallel
+  {
+    baz ("%d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+    #pragma omp sections
+      {
+	#pragma omp section
+	printf ("section1 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+	#pragma omp section
+	printf ("section2 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+      }
+  }
+}
+
+void
+f2 (void)
+{
+#pragma omp parallel
+  {
+    #pragma omp sections
+      {
+	#pragma omp section
+	printf ("section1 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+	#pragma omp section
+	printf ("section2 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+      }
+    baz ("%d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+  }
+}
+
+void
+f3 (void)
+{
+#pragma omp parallel
+  {
+    int bb = bar ();
+    #pragma omp sections
+      {
+	#pragma omp section
+	printf ("section1 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+	#pragma omp section
+	printf ("section2 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+      }
+  }
+}
+
+void
+f4 (void)
+{
+  int i;
+#pragma omp parallel
+  {
+    baz ("%d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+    #pragma omp for schedule (dynamic, 15)
+    for (i = 0; i < 10000; i++)
+      printf ("section1 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+  }
+}
+
+void
+f5 (void)
+{
+  int i;
+#pragma omp parallel
+  {
+    #pragma omp for schedule (dynamic, 15)
+    for (i = 0; i < 10000; i++)
+      printf ("section1 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+    baz ("%d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+  }
+}
+
+void
+f6 (void)
+{
+  int i;
+#pragma omp parallel
+  {
+    int bb = bar ();
+    #pragma omp for schedule (runtime)
+    for (i = 0; i < 10000; i++)
+      printf ("section1 %d/%d\n", omp_get_thread_num (), omp_get_num_threads ());
+  }
+}
+
+/* There should not be a GOMP_parallel_{loop,sections}* call.  */
+/* { dg-final { scan-tree-dump-times "GOMP_parallel_loop" 0 "ompexp"} } */
+/* { dg-final { scan-tree-dump-times "GOMP_parallel_sections" 0 "ompexp"} } */
+/* { dg-final { cleanup-tree-dump "ompexp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34607.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34607.c
new file mode 100644
index 000000000..1b96099c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34607.c
@@ -0,0 +1,18 @@
+/* PR c++/34607 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -std=gnu99" } */
+
+void
+foo ()
+{
+#pragma omp for
+  for (int i =; i < 2; ++i)	/* { dg-error "expected expression before" } */
+    ;
+#pragma omp for
+  for (T i = 54; i < 56; i++)	/* { dg-error "expected iteration declaration" } */
+    ;
+  T j;				/* { dg-error "undeclared|for each function|expected" } */
+#pragma omp for
+  for (j = 1; j < 3; j++)	/* { dg-error "undeclared" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34610.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34610.c
new file mode 100644
index 000000000..95353a562
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34610.c
@@ -0,0 +1,30 @@
+/* PR gcov-profile/34610 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprofile-arcs -fopenmp" } */
+
+extern void bar (int);
+extern void baz (int) __attribute__((noreturn));
+
+void
+foo (int k)
+{
+  int i;
+#pragma omp for schedule(dynamic)
+  for (i = 0; i < 10; ++i)
+    bar (i);
+#pragma omp parallel for schedule(static)
+  for (i = 0; i < 10; ++i)
+    bar (i);
+#pragma omp parallel for schedule(static, 4)
+  for (i = 0; i < 10; ++i)
+    bar (i);
+  if (k)
+  #pragma omp for schedule(dynamic)
+    for (i = 0; i < 10; ++i)
+      baz (i);
+#pragma omp parallel
+  for (i = 0; i < 10; ++i)
+    bar (i);
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34692.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34692.c
new file mode 100644
index 000000000..cc93914b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34692.c
@@ -0,0 +1,28 @@
+/* PR preprocessor/34692 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp -fdump-tree-gimple" } */
+/* { dg-final { scan-tree-dump-times "#pragma omp parallel" 1 "gimple" } } */
+/* { dg-final { scan-tree-dump-times "#pragma omp for private" 1 "gimple" } } */
+
+void
+foo (void)
+{
+  int i;
+#define FOO(y, x) y #x
+#define BAR(x) x
+#define BAZ(x) x
+FOO (for (i = 0; i < 10; i++) { const char *vara =,
+a
+#define P parallel
+#pragma omp P
+#undef P
+#define P for
+b
+#pragma omp P
+#undef P
+#define parallel atomic
+cde f g h);
+  }
+}
+
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34694.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34694.c
new file mode 100644
index 000000000..35cbf3340
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34694.c
@@ -0,0 +1,15 @@
+/* PR middle-end/34694 */
+/* { dg-do compile } */
+/* { dg-options "-O -fopenmp -Wall" } */
+
+int i;
+
+void
+foo ()
+{
+#pragma omp parallel
+  {
+    int j;	/* { dg-message "note: 'j' was declared here" } */
+    i = j;	/* { dg-warning "is used uninitialized" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34964.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34964.c
new file mode 100644
index 000000000..7800be1d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr34964.c
@@ -0,0 +1,6 @@
+/* PR c++/34964 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+char x[] = 0;	/* { dg-error "invalid initializer" } */
+#pragma omp threadprivate (x)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35244.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35244.c
new file mode 100644
index 000000000..aa19a18bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35244.c
@@ -0,0 +1,20 @@
+/* PR c++/35244 */
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-options "-fopenmp" } */
+
+int v1;
+typedef struct A A;
+typedef int i;
+#pragma omp threadprivate (i)	/* { dg-error "expected identifier before" } */
+#pragma omp threadprivate (A)	/* { dg-error "expected identifier before" } */
+#pragma omp threadprivate (v1)
+
+void foo ()
+{
+  static int v4;
+  {
+    static int v5;
+#pragma omp threadprivate (v4, v5)
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35438.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35438.c
new file mode 100644
index 000000000..a3ae7de0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35438.c
@@ -0,0 +1,6 @@
+/* PR c/35438 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void foo ();
+#pragma omp threadprivate(foo)	/* { dg-error "is not a variable" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35439.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35439.c
new file mode 100644
index 000000000..1669a97a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35439.c
@@ -0,0 +1,6 @@
+/* PR c/35439 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void x[1];	/* { dg-error "array of voids" } */
+#pragma omp threadprivate(x)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35738.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35738.c
new file mode 100644
index 000000000..0b3866eae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35738.c
@@ -0,0 +1,18 @@
+/* PR c/35738 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void foo (void);
+
+void
+bar (void *p)
+{
+  int i = 0;
+  char q[10];
+#pragma omp atomic
+  i += q;		/* { dg-warning "makes integer from pointer without a cast" } */
+#pragma omp atomic
+  i += foo;		/* { dg-warning "makes integer from pointer without a cast" } */
+#pragma omp atomic
+  i += p;		/* { dg-warning "makes integer from pointer without a cast" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35751.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35751.c
new file mode 100644
index 000000000..f7777a5b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35751.c
@@ -0,0 +1,34 @@
+/* PR c/35751 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void
+foo (int i)
+{
+  extern int a[i];	/* { dg-error "must have no linkage|storage size of" } */
+  static int b[i];	/* { dg-error "storage size of" } */
+
+#pragma omp parallel
+  {
+    a[0] = 0;
+    b[0] = 0;
+  }
+
+#pragma omp parallel shared (a, b)
+  {
+    a[0] = 0;
+    b[0] = 0;
+  }
+
+#pragma omp parallel private (a, b)
+  {
+    a[0] = 0;
+    b[0] = 0;
+  }
+
+#pragma omp parallel firstprivate (a, b)
+  {
+    a[0] = 0;
+    b[0] = 0;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35818.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35818.c
new file mode 100644
index 000000000..b2165eb39
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr35818.c
@@ -0,0 +1,16 @@
+/* PR middle-end/35818 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+extern int a[];
+
+void
+foo (void)
+{
+#pragma omp parallel
+#pragma omp master
+  a[3] = 1;
+#pragma omp parallel shared(a)
+#pragma omp master
+  a[3] = 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr36790.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr36790.c
new file mode 100644
index 000000000..b3379f156
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr36790.c
@@ -0,0 +1,23 @@
+/* PR middle-end/36790 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void
+foo (char b)
+{
+}
+
+void
+bar (char b)
+{
+  foo (b);
+  #pragma omp task default (shared)
+    b = 0;
+}
+
+int
+main ()
+{
+  bar (0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr38633.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr38633.c
new file mode 100644
index 000000000..6c96bd1c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr38633.c
@@ -0,0 +1,14 @@
+/* PR middle-end/38633 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+void
+foo ()
+{
+#pragma omp parallel
+  {
+    struct A { int i; } j;
+    j.i = 6;
+    j.i++;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr38676.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr38676.c
new file mode 100644
index 000000000..cd9312028
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr38676.c
@@ -0,0 +1,19 @@
+/* PR middle-end/38676 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+int
+main ()
+{
+  int bar, foo = 1;
+#pragma omp parallel for shared(foo)
+  for (bar = 0; bar < 3; bar++)
+    {
+      switch (foo)
+	{
+	case 1:
+	  break;
+	}
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr39495-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr39495-1.c
new file mode 100644
index 000000000..cc165ca52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr39495-1.c
@@ -0,0 +1,95 @@
+/* PR c/39495 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+#define INT_MIN (-__INT_MAX__ - 1)
+#define INT_MAX __INT_MAX__
+#define UINT_MAX (2U * __INT_MAX__ + 1)
+
+int
+foo (void)
+{
+  int i;
+  unsigned int u;
+
+#pragma omp for
+  for (i = INT_MIN + 6; i > INT_MIN + 1; i--)
+    ;
+#pragma omp for
+  for (i = INT_MIN + 6; i >= INT_MIN + 1; i--)
+    ;
+#pragma omp for
+  for (i = INT_MIN + 6; i > INT_MIN; i--)
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i < INT_MAX - 1; i++)
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i <= INT_MAX - 1; i++)
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i < INT_MAX; i++)
+    ;
+#pragma omp for
+  for (u = 6; u > 1; u--)
+    ;
+#pragma omp for
+  for (u = 6; u >= 1; u--)
+    ;
+#pragma omp for
+  for (u = 6; u > 0; u--)
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u < UINT_MAX - 1; u++)
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u <= UINT_MAX - 1; u++)
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u < UINT_MAX; u++)
+    ;
+}
+
+int
+bar (void)
+{
+  int i;
+  unsigned int u;
+
+#pragma omp for
+  for (i = INT_MIN + 6; i > INT_MIN + 1; i -= 2)
+    ;
+#pragma omp for
+  for (i = INT_MIN + 6; i >= INT_MIN + 1; i -= 2)
+    ;
+#pragma omp for
+  for (i = INT_MIN + 6; i > INT_MIN; i -= 2)
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i < INT_MAX - 1; i += 2)
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i <= INT_MAX - 1; i += 2)
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i < INT_MAX; i += 2)
+    ;
+#pragma omp for
+  for (u = 6; u > 1; u -= 2)
+    ;
+#pragma omp for
+  for (u = 6; u >= 1; u -= 2)
+    ;
+#pragma omp for
+  for (u = 6; u > 0; u -= 2)
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u < UINT_MAX - 1; u += 2)
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u <= UINT_MAX - 1; u += 2)
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u < UINT_MAX; u += 2)
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr39495-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr39495-2.c
new file mode 100644
index 000000000..a276c24ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/pr39495-2.c
@@ -0,0 +1,39 @@
+/* PR c/39495 */
+/* { dg-do compile } */
+/* { dg-options "-fopenmp" } */
+
+#define INT_MIN (-__INT_MAX__ - 1)
+#define INT_MAX __INT_MAX__
+#define UINT_MAX (2U * __INT_MAX__ + 1)
+
+int
+foo (void)
+{
+  int i;
+  unsigned int u;
+
+#pragma omp for
+  for (i = INT_MIN + 6; i != INT_MIN; i--)	/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (i = INT_MIN + 6; i == INT_MIN; i--)	/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i != INT_MAX; i++)	/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (i = INT_MAX - 6; i == INT_MAX; i++)	/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (u = 6; u != 0; u--)			/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (u = 6; u == 0; u--)			/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u != UINT_MAX; u++)	/* { dg-error "invalid controlling predicate" } */
+    ;
+#pragma omp for
+  for (u = UINT_MAX - 6; u == UINT_MAX; u++)	/* { dg-error "invalid controlling predicate" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/preprocess-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/preprocess-1.c
new file mode 100644
index 000000000..714c8404d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/preprocess-1.c
@@ -0,0 +1,16 @@
+/* { dg-do preprocess } */
+
+void foo (void)
+{
+  int i1, j1, k1;
+#define p parallel
+#define P(x) private (x##1)
+#define S(x) shared (x##1)
+#define F(x) firstprivate (x##1)
+#pragma omp p P(i) \
+  S(j) \
+  F(k)
+  ;
+}
+
+/* { dg-final { scan-file preprocess-1.i "(^|\n)#pragma omp parallel private \\(i1\\) shared \\(j1\\) firstprivate \\(k1\\)($|\n)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-1.c
new file mode 100644
index 000000000..43704908e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-1.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+
+extern void bar(int);
+
+void f1(void)
+{
+  #pragma omp sections nowait
+    {
+      bar (1);
+    #pragma omp section
+      bar (2);
+    #pragma omp section
+      bar (3);
+    #pragma omp section
+      bar (4);
+    #pragma omp section
+      bar (5);
+    }
+}
+
+void f2(void)
+{
+  #pragma omp sections
+    {
+    #pragma omp section
+      {
+        bar (1);
+        bar (1);
+      }
+    #pragma omp section
+      bar (2);
+    #pragma omp section
+      bar (3);
+    #pragma omp section
+      bar (4);
+    #pragma omp section
+      bar (5);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-2.c
new file mode 100644
index 000000000..aabdfaf80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-2.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+
+extern void bar(int);
+void foo(void)
+{
+  #pragma omp sections
+    bar (0);		// { dg-error "expected" }
+
+  #pragma omp sections
+    {
+    }			// { dg-error "expected" }
+
+  #pragma omp sections
+    {
+      bar (1);
+    }
+
+  #pragma omp sections
+    {
+    #pragma omp section
+      bar(2);
+      bar(3);		// { dg-error "expected" }
+      bar(4);
+    #pragma omp section
+      bar(5);
+      bar(6);		// { dg-error "expected" }
+      bar(7);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-3.c
new file mode 100644
index 000000000..d8fb2a09d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-3.c
@@ -0,0 +1,15 @@
+
+// { dg-do compile }
+
+extern void bar (void);
+
+int main (void)
+{
+  #pragma omp parallel sections nowait /* { dg-error "'nowait'" } */
+    {
+    #pragma omp section
+	{ bar(); }
+    #pragma omp section
+	{ bar(); }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-4.c
new file mode 100644
index 000000000..44e7de98c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sections-4.c
@@ -0,0 +1,13 @@
+/* PR c++/24613 */
+/* { dg-compile } */
+
+#pragma omp section	/* { dg-error "may only be used in" } */
+
+int i;
+
+void
+foo (void)
+{
+  #pragma omp section	/* { dg-error "may only be used in" } */
+    i++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-1.c
new file mode 100644
index 000000000..6b53efe4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-1.c
@@ -0,0 +1,58 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+#include <stdlib.h>
+
+int thrglobalvar;
+#pragma omp threadprivate (thrglobalvar)
+int globalvar;
+const int constvar = 8;
+
+int
+foo (int x)
+{
+  return x;
+}
+
+int
+bar (int *x)
+{
+  return *x;
+}
+
+int
+main (void)
+{
+  static int thrlocvar;
+#pragma omp threadprivate (thrlocvar)
+  static int locvar;
+  static int *p;
+  int i, j, s, l;
+
+  p = malloc (sizeof (int));
+  if (p == NULL)
+    return 0;
+  *p = 7;
+  s = 6;
+  l = 0;
+#pragma omp parallel for /* { dg-error "enclosing parallel" } */ \
+  default (none) private (p) shared (s) 
+  for (i = 0; i < 64; i++)
+    {
+      int k = foo (0);	/* Predetermined - private (automatic var declared */
+      k++;		/* in scope of construct).  */
+      thrglobalvar++;	/* Predetermined - threadprivate.  */
+      thrlocvar++;	/* Predetermined - threadprivate.  */
+      foo (i);		/* Predetermined - private (omp for loop variable).  */
+      foo (constvar);	/* Predetermined - shared (const qualified type).  */
+      foo (*p);		/* *p predetermined - shared (heap allocated */
+      (*p)++;		/* storage).  */
+      bar (p);		/* Explicitly determined - private.  */
+      foo (s);		/* Explicitly determined - shared.  */
+      globalvar++;	/* { dg-error "not specified in" } */
+      locvar++;		/* { dg-error "not specified in" } */
+      l++;		/* { dg-error "not specified in" } */
+      for (j = 0; j < 2; j++); /* { dg-error "not specified in" } */
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-2.c
new file mode 100644
index 000000000..33bbb3bad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+
+void
+foo (void)
+{
+  int i;
+  int a[10];
+  #pragma omp parallel private (i) shared (a)
+  {
+    i = 1;
+    #pragma omp parallel shared (a, i)
+    {
+      #pragma omp master
+	i = 2;
+      #pragma omp parallel private (i) shared (a)
+      {
+	for (i = 0; i < 10; i++)
+	  a[i] = i + 1;
+      }
+      #pragma omp master
+	i = 3;
+    }
+    i = 4;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-3.c
new file mode 100644
index 000000000..36f72e3ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/sharing-3.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+#define N       50
+#define CHUNKSIZE   5
+
+main ()
+{
+  int i, chunk;
+  float c[N];
+
+  chunk = CHUNKSIZE;
+#pragma omp parallel for shared (c, chunk) schedule (dynamic, chunk)
+  for (i = 0; i < N; i++)
+    c[i] = i;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/static.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/static.c
new file mode 100644
index 000000000..8996d818b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/static.c
@@ -0,0 +1,14 @@
+static int bork;
+
+void bar(void);
+
+void foobar (void)
+{
+#pragma omp parallel
+  {
+#pragma omp for lastprivate(bork)
+    for (bork = 0; bork < 100; bork++) {
+        bar();
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/tls-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/tls-1.c
new file mode 100644
index 000000000..7a36c2db6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/tls-1.c
@@ -0,0 +1,18 @@
+// { dg-do compile }
+// { dg-require-effective-target tls_native }
+
+int tp1;
+static int tp2;
+extern int tp3;
+
+int tp4 = 1;
+static int tp5 = 1;
+
+#pragma omp threadprivate (tp1, tp2, tp3, tp4, tp5)
+
+#pragma omp threadprivate (undef)	// { dg-error "undeclared" }
+
+int tp6;
+int foo(void) { return tp6; }
+
+#pragma omp threadprivate (tp6)		// { dg-error "after first use" }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/tls-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/tls-2.c
new file mode 100644
index 000000000..26dbc53e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/tls-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target tls_native } */
+
+extern char buf[];
+#pragma omp threadprivate (buf)	/* { dg-error "has incomplete type" } */
+
+void
+foo (void)
+{
+  int i;
+#pragma omp threadprivate (i) /* { dg-error "automatic variable" } */
+  i = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/uninit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/uninit-1.c
new file mode 100644
index 000000000..223e617b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/uninit-1.c
@@ -0,0 +1,13 @@
+// PR 24612
+// { dg-do compile }
+// { dg-options "-O -Wuninitialized -fopenmp" }
+
+void foo()
+{
+    int i;
+#pragma omp parallel shared(i)
+    {
+      i = 0;
+      ++i;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-1.c
new file mode 100644
index 000000000..bb37f33e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-1.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+
+void foo(int n)
+{
+  int A[n];
+
+  #pragma omp parallel default(none)	// { dg-error "enclosing" }
+    {
+      A[0] = 0;				// { dg-error "'A' not specified" }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-2.c
new file mode 100644
index 000000000..fc18ffc57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-2.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+
+void foo(int n, int i)
+{
+  int A[n];
+
+  #pragma omp parallel private(A)
+    {
+      A[i] = 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-3.c
new file mode 100644
index 000000000..b1677b833
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-3.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+
+void foo(int n, int i)
+{
+  int A[n];
+
+  #pragma omp parallel shared(A)
+    {
+      A[i] = sizeof(A);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-4.c
new file mode 100644
index 000000000..2c3c0aa43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-4.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+
+void foo(int n, int i)
+{
+  int A[n];
+
+  #pragma omp parallel firstprivate(A)
+    {
+      A[i] = 1;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-5.c
new file mode 100644
index 000000000..6c6d5517a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/gomp/vla-5.c
@@ -0,0 +1,11 @@
+// { dg-do compile }
+
+void foo(int n, int i)
+{
+  int A[n];
+
+  #pragma omp parallel sections lastprivate(A)
+    {
+      A[i] = 1;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-0.c
new file mode 100644
index 000000000..627f044fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-0.c
@@ -0,0 +1,25 @@
+/* { dg-options "-O -floop-block -fdump-tree-graphite-all" } */
+
+#define N 1000
+
+int toto()
+{
+  int j;
+  int i;
+  int a[N];
+  int b[N];
+
+  for (i = 0; i < N; i++)
+    for (j = 0; j < N; j++)
+      a[j] = a[i] + 1;
+
+  return a[0];
+}
+
+main()
+{
+  return toto();
+}
+
+/* { dg-final { scan-tree-dump-times "will be loop blocked" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-1.c
new file mode 100644
index 000000000..0a70e9e10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-1.c
@@ -0,0 +1,40 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+#define MAX 8192
+
+void bar (void);
+
+int main()
+{
+  int i, j;
+  int sum = 0;
+  int A[MAX * MAX];
+  int B[MAX * MAX];
+
+  bar ();
+
+  for (i = 0; i < MAX; i++)
+    for (j = 0; j < MAX; j++)
+      {
+	A[i*MAX + j] = j;
+	B[i*MAX + j] = j;
+      }
+
+  for (i = 0; i < MAX; i++)
+    for (j = 0; j < MAX; j++)
+      A[i*MAX + j] += B[j*MAX + i];
+
+  bar ();
+
+  /* FIXME: For now, reductions are not handled by the code generation
+     of graphite.  We have to bound the scop to the above loops.  */
+
+  for(i = 0; i < MAX; i++)
+    for(j = 0; j < MAX; j++)
+      sum += A[i*MAX + j];
+
+  return sum;
+}
+
+/* { dg-final { scan-tree-dump-times "will be loop blocked" 2 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-2.c
new file mode 100644
index 000000000..fc4e889e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-2.c
@@ -0,0 +1,31 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+typedef unsigned char   UChar;
+typedef int             Int32;
+typedef unsigned int    UInt32;
+
+void fallbackSort ( UInt32* fmap, 
+                    UInt32* eclass, 
+                    Int32   nblock,
+                    Int32   verb )
+{
+   Int32 ftab[257];
+   Int32 ftabCopy[256];
+   Int32 H, i, j, k, l, r, cc, cc1;
+   Int32 nNotDone;
+   Int32 nBhtab;
+   UChar* eclass8 = (UChar*)eclass;
+
+   if (verb >= 4)
+      VPrintf0 ( "        bucket sorting ...\n" );
+   for (i = 0; i < 257;    i++) ftab[i] = 0;
+   for (i = 0; i < nblock; i++) ftab[eclass8[i]]++;
+   for (i = 0; i < 256;    i++) ftabCopy[i] = ftab[i];
+   for (i = 1; i < 257;    i++) ftab[i] += ftab[i-1];
+
+   for (i = 0; i < nblock; i++) {
+      j = eclass8[i] + ftab [i];
+   }
+   AssertH ( j < 256, 1005 );
+}
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-3.c
new file mode 100644
index 000000000..1d2ca40db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-3.c
@@ -0,0 +1,25 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+#define N 24
+#define M 100
+
+float A[M][M][M], B[M][M], C[M][M];
+
+void test (void)
+{
+  int i, j, k;
+
+  /* These loops contain too few iterations for being strip-mined by 64.  */
+  for (i = 0; i < 24; i++)
+    for (j = 0; j < 24; j++)
+      for (k = 0; k < 24; k++)
+        A[i][j][k] = B[i][k] * C[k][j];
+
+  /* These loops should still be strip mined.  */
+  for (i = 0; i < M; i++)
+    for (j = 0; j < M; j++)
+      for (k = 0; k < M; k++)
+        A[i][j][k] = B[i][k] * C[k][j];
+}
+
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-4.c
new file mode 100644
index 000000000..e3649f01d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-4.c
@@ -0,0 +1,23 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+#define N 24
+#define M 1000
+
+float A[1000][1000], B[1000][1000], C[1000][1000];
+
+void test (void)
+{
+  int i, j, k;
+
+  for (i = 0; i < 24; i++)
+    for (j = 0; j < 24; j++)
+      for (k = 0; k < 24; k++)
+        A[i][j] = B[i][k] * C[k][j];
+
+  for (i = 0; i < 1000; i++)
+    for (j = 0; j < 1000; j++)
+      for (k = 0; k < 1000; k++)
+        A[i][j] = B[i][k] * C[k][j];
+}
+
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-5.c
new file mode 100644
index 000000000..e0bd4688d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-5.c
@@ -0,0 +1,26 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+#define N 10000
+void foo (int);
+int test ()
+{
+  int a[N][N];
+  int b[N][N];
+  unsigned i, j;
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++)
+      a[i][j] = i*j;
+
+  for (j = 1; j < N; j++) 
+    for (i = 0; i < N; i++)
+      a[i][j] = a[i][j-1] + b[i][j];
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++) 
+      foo (a[i][j]); 
+}
+
+/* Interchange is legal for loops 0 and 1 of the first two SCoPs */
+/* { dg-final { scan-tree-dump-times "Interchange valid for loops 0 and 1:" 2 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-6.c
new file mode 100644
index 000000000..77429f1cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/block-6.c
@@ -0,0 +1,25 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+#define N 10000
+void foo (int);
+int test ()
+{
+  int a[N][N];
+  unsigned i, j;
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++)
+	a[i][j] = i*j;
+
+  for (i = 1; i < N; i++) 
+    for (j = 1; j < (N-1) ; j++)
+	a[i][j] = a[i-1][j+1] * a[i-1][j+1]/2;
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++)
+      foo (a[i][j]); 
+}
+
+/* Interchange is not legal for loops 0 and 1 of SCoP 2.  */
+/* { dg-final { scan-tree-dump-times "Interchange not valid for loops 0 and 1:" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/graphite.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/graphite.exp
new file mode 100644
index 000000000..a1257177f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/graphite.exp
@@ -0,0 +1,48 @@
+#   Copyright (C) 2006, 2007, 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
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+if ![check_effective_target_fgraphite] {
+  return
+}
+
+# The default action for a test is 'compile'.  Save current default.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+set dg-do-what-default compile
+
+# 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
+
+# Clean up.
+set dg-do-what-default ${save-dg-do-what-default}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37485.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37485.c
new file mode 100644
index 000000000..cf0969bac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37485.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+typedef unsigned char   UChar;
+typedef int             Int32;
+typedef unsigned int    UInt32;
+
+void fallbackSort ( UInt32* fmap, 
+                    UInt32* eclass, 
+                    Int32   nblock,
+                    Int32   verb )
+{
+   Int32 ftab[257];
+   Int32 ftabCopy[256];
+   Int32 H, i, j, k, l, r, cc, cc1;
+   Int32 nNotDone;
+   Int32 nBhtab;
+   UChar* eclass8 = (UChar*)eclass;
+
+   if (verb >= 4)
+      VPrintf0 ( "        bucket sorting ...\n" );
+   for (i = 0; i < 257;    i++) ftab[i] = 0;
+   for (i = 0; i < nblock; i++) ftab[eclass8[i]]++;
+   for (i = 0; i < 256;    i++) ftabCopy[i] = ftab[i];
+   for (i = 1; i < 257;    i++) ftab[i] += ftab[i-1];
+
+   for (i = 0; i < nblock; i++) {
+      j = eclass8[i] + ftab [i];
+   }
+   AssertH ( j < 256, 1005 );
+}
+/* { dg-final { scan-tree-dump-times "Loop blocked" 1 "graphite" { xfail *-*-* }} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37684.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37684.c
new file mode 100644
index 000000000..a9e6f5a4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37684.c
@@ -0,0 +1,67 @@
+/* { dg-options "-O2 -floop-block -fdump-tree-graphite-all" } */
+
+typedef struct _IO_FILE FILE;
+struct _IO_marker {
+};
+enum __codecvt_result
+{
+  __codecvt_noconv
+};
+struct _IO_FILE {
+};
+extern struct _IO_FILE *stderr;
+
+typedef
+   struct {
+      unsigned int avail_in;
+      unsigned int avail_out;
+      void *state;
+      void *(*bzalloc)(void *,int,int);
+      void *opaque;
+   }
+   bz_stream;
+extern int BZ2_bzCompressInit (
+      bz_stream* strm,
+      int blockSize100k,
+      int verbosity,
+      int workFactor
+   );
+typedef unsigned char Bool;
+typedef int Int32;
+typedef unsigned int UInt32;
+
+typedef
+   struct {
+      Int32 mode;
+      Int32 state;
+      UInt32* arr1;
+      UInt32* arr2;
+      UInt32* ftab;
+      Int32 nblock;
+      Int32 nblockMAX;
+      Bool inUse[256];
+      Int32 blockNo;
+   }
+   EState;
+
+void prepare_new_block ( EState* s )
+{
+   Int32 i;
+   for (i = 0; i < 256; i++) s->inUse[i] = ((Bool)0);
+   s->blockNo++;
+}
+
+int BZ2_bzCompressInit
+                    ( bz_stream* strm,
+                     int blockSize100k,
+                     int verbosity,
+                     int workFactor )
+{
+   EState* s;
+   s = (strm->bzalloc)(strm->opaque,(sizeof(EState)),1);
+   if (s->arr1 == ((void *)0) || s->arr2 == ((void *)0) || s->ftab == ((void *)0)) {
+   }
+   prepare_new_block ( s );
+}
+
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37828.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37828.c
new file mode 100644
index 000000000..0a0412d80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37828.c
@@ -0,0 +1,25 @@
+/* { dg-options "-O2 -floop-block" } */
+
+typedef struct foo
+{
+  struct foo **Node;
+} foo;
+
+static int sort_and_split (foo **Root, foo **Finite, long first)
+{
+  foo *cd;
+  long i;
+  for (i = 0; i < first; i++)
+    cd->Node[i] = Finite[first+i];
+
+  sort_and_split(Root, Finite, first);
+  return (0);
+}
+
+
+void Build_foo(foo **Root, foo **Finite, foo **Infinite)
+{
+  long low, high;
+  while (sort_and_split(Root, Finite, low) == 0);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37883.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37883.c
new file mode 100644
index 000000000..2ab043adc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37883.c
@@ -0,0 +1,11 @@
+/* { dg-options "-O3 -floop-block" } */
+
+void test_sort()
+{
+  char *base;
+  register char c, *i, *hi;
+
+  for (i = base; i < hi; i++)
+    *i++ = c;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37928.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37928.c
new file mode 100644
index 000000000..47ad5bce0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37928.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O3 -floop-block" } */
+
+int get_state(int size, int *node, int *hash)
+{
+  int i=0;
+  while(hash[i])
+    {
+     if(node[hash[i]] == 0)
+           return hash[i]-1;
+      i++;
+     if(i==5)
+       i=0;
+    }
+  return -1;
+}
+
+void foo (int);
+
+int gate1(int size, int *node, int *hash)
+{
+  int i, j ;
+  int add_size=0;
+  for(i=0; i<size; i++)
+  {
+     j = get_state(size,node, hash);
+     if(j == -1)
+     {
+    	add_size++;
+     }
+  }
+
+  foo (size+add_size);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37943.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37943.c
new file mode 100644
index 000000000..a4b4fe565
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr37943.c
@@ -0,0 +1,34 @@
+/* { dg-options "-O3 -fgraphite-identity -fdump-tree-graphite-all" } */
+
+typedef struct
+{
+      int mode,state,num,state_out;
+      unsigned char* bits;
+      char *out;
+}test;
+unsigned char copy( test* s )
+{
+   while(1)
+     {
+      if (s->mode == 0) break;
+      if (s->state_out >= s->num) break;
+      *(s->out) = s->bits[s->state_out];
+      if (s->mode == 0) s->mode++;
+     }
+}
+unsigned char compress(test *in)
+{
+   unsigned char p_in, p_out;
+   while(1)
+   {
+      if (in->state == 1) 
+      {
+         p_out |= copy(in);
+         if (in->state_out < in->num) break;
+      }
+   }
+   return p_in || p_out;
+}
+/* { dg-final { cleanup-tree-dump "graphite" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38073.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38073.c
new file mode 100644
index 000000000..9c48d8d09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38073.c
@@ -0,0 +1,9 @@
+/* { dg-options "-O3 -fgraphite-identity" } */
+
+test_seg(int a, int b)
+{
+  int i,r=1;
+  for(i=0; i<b ;i++)
+    r*=a;
+  return r;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38084.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38084.c
new file mode 100644
index 000000000..7193f9600
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38084.c
@@ -0,0 +1,31 @@
+/* { dg-options "-O3 -fgraphite-identity" } */
+
+typedef struct {
+  unsigned int avail_out;
+  void *state;
+} stream;
+
+typedef struct {
+  stream* test;
+  int num;
+} state_in;
+
+int test_in ( stream *test, int action )
+{
+  state_in* tst;
+  if (test == ((void *)0)) return (-2);
+  if (tst == ((void *)0)) return (-2);
+  if (tst->test != test) return (-2);
+ jump_here:
+  switch (tst->num) {
+  case 1:
+    return (-1);
+  case 2:
+    if (action == 0) {
+    }
+    if (action == 1) {
+      goto jump_here;
+    }
+  }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38125.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38125.c
new file mode 100644
index 000000000..780e6f643
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38125.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O3 -fgraphite-identity" } */
+
+typedef struct sv TEST_SV;
+typedef struct av TEST_AV;
+typedef struct magic TEST_MAGIC;
+typedef struct xpvav TEST_XPVAV;
+struct sv 
+{
+    void* sv_any;
+};
+struct av 
+{
+    TEST_XPVAV* sv_any;
+};
+struct xpvav 
+{
+    char* xav_array;
+    long int xav_fill;
+    long int xav_max;
+};
+struct magic {
+    TEST_SV* mg_obj;
+};
+extern TEST_SV PL_sv_undef;
+Perl_av_fill( register TEST_AV *av, int fill)
+{
+    TEST_MAGIC *mg;
+    int key = ((TEST_XPVAV*) (av)->sv_any)->xav_fill;
+    TEST_SV** ary = ((TEST_SV**)((TEST_XPVAV*) (av)->sv_any)->xav_array);
+    while (key < fill)
+          ary[++key] = &PL_sv_undef;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38409.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38409.c
new file mode 100644
index 000000000..41c677534
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38409.c
@@ -0,0 +1,24 @@
+/* { dg-options "-O2 -floop-block" } */
+
+typedef struct test input ;
+struct test 
+{
+  int type ;
+  int symflag ;
+};
+Chv_copyEntriesToVector ( input *chv,double *dvec) 
+{
+  double *entries ;
+  int mm, nent;
+  int first, i, k , stride ;
+  if ( ((chv)->type == 1) ) 
+    {
+      for ( i = 0 ; i < 10 ; i++)
+        {
+	  dvec[2*mm] = entries[2*k] ;
+	  k += stride ;
+	  stride -= 2 ;
+        }
+    }
+  return(mm) ; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38413.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38413.c
new file mode 100644
index 000000000..6c2b23a88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38413.c
@@ -0,0 +1,14 @@
+/* { dg-options "-O2 -fgraphite-identity" } */
+
+static int qsz;
+
+void specqsort(base, n, size, compar)
+     char *base;
+{
+  register char c, *i, *j, *lo, *hi;
+  qsz = size;
+  for (i = base, hi = base + qsz; i < hi; ) 
+    {
+      *i++ = c;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38446.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38446.c
new file mode 100644
index 000000000..b7b346cd9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38446.c
@@ -0,0 +1,14 @@
+/* { dg-options "-O2 -fgraphite-identity" } */
+
+void copy_data()
+{
+  int ****source;
+  int ****dest;
+
+  int i, j, k, l;
+  for (i = 0; i < 10; i++)
+      for (k = 0; k < 2; k++)
+        for (l = 0; l < 65; l++)
+          source[i][j][k][l] = dest[i][j][k][l];
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38498.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38498.c
new file mode 100644
index 000000000..c79bbad55
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38498.c
@@ -0,0 +1,19 @@
+/* { dg-options "-O2 -floop-block" } */
+
+double test_vector (float **data, int rows, int cols, int vqrows,double epsilon, int maxiter,int **mean, int *map)
+{
+    int i, j, r, it;
+    double sqerr, prev_sqerr=0, t;
+    unsigned int *sel;
+    int *count;
+    for (it = 0;; it++) 
+    {
+        if ((sqerr == 0.0) || (it >= maxiter-1) ||((it > 0) && ( ((prev_sqerr - sqerr) / prev_sqerr) < epsilon )) )
+            for (i = 0; i < vqrows; i++) 
+            {
+                for (j = 0; j < cols; j++)
+                    mean[i][j] = 0.0;
+                count[i] = 0;
+            }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38500.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38500.c
new file mode 100644
index 000000000..f5292d173
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38500.c
@@ -0,0 +1,29 @@
+/* { dg-options "-O3 -fgraphite-identity" } */
+
+typedef unsigned char U8;
+extern char test1;
+
+char *Perl_screaminstr (int, int, int);
+
+void
+Perl_re_intuit_start( int minlen,  char *strend, unsigned int flags, int i)
+{
+  register int start_shift = 0;
+  register int end_shift = 0;
+  register char *s;
+  char *strbeg;
+  char *t;
+  if(i > 0)
+    goto success_at_start;
+  int end = 0;
+  int eshift = (test1 ? Perl_utf8_distance((U8*)strend,(U8*)s) : (U8*)strend - (U8*)s) - end;
+  if (end_shift < eshift)
+    end_shift = eshift;
+ restart:
+  s = Perl_screaminstr(start_shift + (s - strbeg), end_shift, 0);
+  while( t < strend - minlen){  
+  }
+ success_at_start:
+  eshift = (test1 ? Perl_utf8_distance((U8*)strend,(U8*)s) : (U8*)strend - (U8*)s) - end;
+  goto restart;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38510.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38510.c
new file mode 100644
index 000000000..07ddb6ef1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38510.c
@@ -0,0 +1,40 @@
+/* { dg-options "-O2 -fgraphite-identity" } */
+typedef long int integer;
+typedef double doublereal;
+
+static int balanc_(nm, n, a, low, igh, scale)
+doublereal *a;
+{
+ integer a_dim1, a_offset, i__1, i__2;
+ integer iexc;
+ integer i__, j, k, l, m;
+ integer jj;
+goto L100;
+L20:
+if (j == m) {
+goto L50;
+}
+for (i__ = 1; i__ <= i__1; ++i__) {
+a[i__ + j * a_dim1] = a[i__ + m * a_dim1];
+}
+L50:
+switch ((int)iexc) {
+case 2: goto L130;
+}
+L100:
+for (jj = 1; jj <= i__1; ++jj) {
+goto L20;
+}
+L130:
+for (j = k; j <= i__1; ++j) {
+goto L20;
+}
+}
+
+int pymol_rg_(integer *nm, integer *n, doublereal *a, doublereal *wr,
+              doublereal *fv1,integer *ierr)
+{
+    integer a_dim1, a_offset, z_dim1, z_offset;
+    integer is1, is2;
+    balanc_(nm, n, &a[a_offset], &is1, &is2, &fv1[1]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38559.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38559.c
new file mode 100644
index 000000000..1e2ef0a4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38559.c
@@ -0,0 +1,14 @@
+/* { dg-options "-O2 -floop-block" } */
+
+int test()
+{
+  int offset, len;
+  register char *mid;
+  register char *midend;
+  register char *bigend;
+  long unsigned int curlen;
+  if (offset + len > curlen) {
+    while (midend > mid)
+      *--bigend = *--midend;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38786.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38786.c
new file mode 100644
index 000000000..47df44789
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr38786.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -fgraphite-identity" } */
+
+typedef struct
+{
+  int ****cofAC;
+} ImageParameters;
+typedef struct
+{
+  int ****cofAC;
+} RD_DATA;
+extern RD_DATA *rdopt;
+extern ImageParameters *img;
+dummy_slice_too_big (int bits_slice)
+{
+  int i, j, k, l;
+  for (j = 0; j < 4; j++)
+    for (k = 0; k < 2; k++)
+      for (l = 0; l < 65; l++)
+	img->cofAC[i][j][k][l] = rdopt->cofAC[i][j][k][l];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39260.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39260.c
new file mode 100644
index 000000000..066b5bde8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39260.c
@@ -0,0 +1,17 @@
+/* { dg-options "-O2 -fgraphite-identity -ffast-math" } */
+
+VBR_encode_frame (int mode_gr, int channels_out, int max_bits[2][2])
+{
+ int max_nbits_ch[2][2];
+ int gr, ch;
+ for (gr = 0; gr < mode_gr; ++gr)
+   {
+     float f[2], s = 0;
+     for (ch = 0; ch < channels_out; ++ch)
+       if (max_nbits_ch[gr][ch] > 0)
+         s += f[ch];
+     for (ch = 0; ch < channels_out; ++ch)
+       if (s > 0)
+         max_nbits_ch[gr][ch] = 7680 * f[ch] / s;
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39335.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39335.c
new file mode 100644
index 000000000..c86e03ab7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39335.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -floop-interchange" } */
+
+typedef unsigned char byte;
+typedef struct gx_device_s gx_device;
+typedef struct gs_devn_params_s gs_devn_params;
+typedef struct gs_devn_params_s {
+   struct compressed_color_list_s * compressed_color_list;
+} gs_devn_params_t;
+int devn_unpack_row(gx_device * dev, int num_comp,
+                   gs_devn_params * pdevn_params, int width, byte * in,
+                   byte * out)
+{
+ int i, comp_num, pixel_num;
+ if (pdevn_params->compressed_color_list == ((void *)0))
+   {
+     for (pixel_num = 0; pixel_num < width; pixel_num++)
+       for (i = 0; i < num_comp; i++)
+         *out++ = *in++;
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39335_1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39335_1.c
new file mode 100644
index 000000000..257c2c994
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr39335_1.c
@@ -0,0 +1,9 @@
+/* { dg-options "-O2 -floop-interchange" } */
+
+void crash_me(int num1, int num2, char * in, char * out)
+{
+ int i, j;
+ for (j = 0; j < num1; j++)
+   for (i = 0; i < num2; i++)
+     *out++ = *in++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr40281.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr40281.c
new file mode 100644
index 000000000..a09147a9f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/pr40281.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fprefetch-loop-arrays -w" } */
+/* { dg-options "-O -fprefetch-loop-arrays -march=i686 -msse -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+void foo(int);
+void bar(int n)
+{
+ int a[2], i, j = 0;
+
+ for (i = 0; i < 2; i += j+1)
+   for (j = 0; j < (n ? 1 : 2); ++j)
+     foo(a[i] + a[j]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-0.c
new file mode 100644
index 000000000..ea3ae065a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-0.c
@@ -0,0 +1,24 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+int foo (void);
+void bar (void);
+
+int toto()
+{
+  /* Scop 1. */
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+  int N = foo ();
+
+  for (i = 0; i < 2*N+ 100; i++)
+    for (j = 0; j < 200; j++)
+      a[j][i] = a[j+1][10] + 2;
+
+  return a[3][5] + b[1];
+  /* End scop 1. */
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 1" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-1.c
new file mode 100644
index 000000000..ed6159fb3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-1.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+	a[j][i] = a[j+1][i-1] + 2;
+
+      b[i] = b[i-1] + 2;
+
+      bar ();
+
+      for (j = 1; j < 100; j++)
+	a[j][i] = a[j+1][i-1] + 2;
+
+      b[i] = a[i-1][i] + 2;
+
+      for (j = 1; j < 100; j++)
+	a[j][i] = a[j+1][i-1] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-10.c
new file mode 100644
index 000000000..8aff2c743
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-10.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+        b[i+j] = b[i+j-1] + 2;
+
+      if (i * 2 == i + 8)
+        bar ();
+      else 
+        {
+	  for (j = 1; j < 100; j++)
+	    b[i+j] = b[i+j-1] + 2;
+	  a[i][i] = 2;
+	}
+
+      for (k = 1; k < 100; k++)
+        b[i+k] = b[i+k-5] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-11.c
new file mode 100644
index 000000000..e5a0fdb39
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-11.c
@@ -0,0 +1,34 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar ();
+
+int toto()
+{
+  int i,j, b;
+  int a[100];
+
+  if (i == 20)
+    {
+      for (j = 0; j <= 20; j++)
+        a[j] = b + i;
+      b = 3;
+      bar();
+    }
+  else 
+    {
+      if (i == 30)
+	{
+          for (j = 0; j <= 20; j++)
+            a[j] = b + i;
+	  b = 5;
+	}
+    }
+
+  for (j = 0; j <= 20; j++)
+    a[j] = b + i;
+
+  return a[b];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-12.c
new file mode 100644
index 000000000..0c130330c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-12.c
@@ -0,0 +1,38 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar ();
+
+int toto()
+{
+  int i,j, b;
+  int a[100];
+
+  switch (i)
+    {
+    
+      case 5:
+        for (j = 0; j <= 20; j++)
+          a[j] = b + i + 12;
+        break;
+      case 8:
+        for (j = 0; j <= 20; j++)
+          a[j] = b + i + 122;
+        break;
+      case 15:
+        for (j = 0; j <= 20; j++)
+          a[j] = b + i + 12;
+        break;
+      case 18:
+        for (j = 0; j <= 20; j++)
+          a[j] = b + i + 4;
+        break;
+     default:
+        for (j = 0; j <= 20; j++)
+          a[j] = b + i + 3;
+   }
+
+  return a[b];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 5" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-13.c
new file mode 100644
index 000000000..aa55e10f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-13.c
@@ -0,0 +1,43 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar ();
+
+int toto()
+{
+  int i,j, b;
+  int a[100];
+
+  if (i == 20)
+    {
+      b = 3;
+      goto B;
+    }
+  else 
+    {
+      if (i == 30)
+	{
+          a[i] = b;
+
+
+          for (j = 0; j <= 20; j++)
+            a[j] = b + i;
+
+          B:
+
+          for (j = 0; j <= 20; j++)
+            a[j+b] = b + i;
+          
+          bar ();
+	}
+      else 
+        {
+          a[i] = b + 3;
+        }
+    }
+
+
+  return a[b];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-14.c
new file mode 100644
index 000000000..a707b01d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-14.c
@@ -0,0 +1,27 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar ();
+
+int toto()
+{
+  int i,j, b;
+  int a[100];
+
+  for (j = 0; j <= 20; j++)
+    {
+      a[j] = b + i;
+      
+      if (j * i == b)
+        break;
+
+      a[j+b] = b + i;
+    }
+
+  a[i] = b + 3;
+
+
+  return a[b];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 0" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-15.c
new file mode 100644
index 000000000..9324631e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-15.c
@@ -0,0 +1,53 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+#  define EXTERN(type, array)  extern type array[]
+typedef unsigned char  uch;
+typedef unsigned short ush;
+EXTERN(uch, window);
+EXTERN(ush, prev);
+#ifndef WSIZE
+#  define WSIZE 0x8000
+#endif                
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+#define MAX_DIST  (WSIZE-MIN_LOOKAHEAD)
+#define near
+typedef unsigned IPos;
+unsigned near max_chain_length;
+extern unsigned near strstart;
+unsigned int near prev_length;
+#define NIL 0
+unsigned near good_match;
+int near nice_match;
+#define WMASK     (WSIZE-1)
+int longest_match(IPos cur_match)
+{
+    unsigned chain_length = max_chain_length;
+    register uch *scan = window + strstart;  
+    register uch *match;                     
+    register int len;                        
+    int best_len = prev_length;              
+    IPos limit = strstart > (IPos)MAX_DIST ? strstart - (IPos)MAX_DIST : NIL;
+    register uch *strend = window + strstart + MAX_MATCH;
+    register uch scan_end   = scan[best_len];
+    if (prev_length >= good_match) {
+    }
+    do {
+        if (match[best_len]   != scan_end  ||
+            *++match          != scan[1])      continue;
+        do {
+        } while (*++scan == *++match && *++scan == *++match &&
+                 scan < strend);
+        len = MAX_MATCH - (int)(strend - scan);
+        if (len > best_len) {
+            best_len = len;
+            if (len >= nice_match) break;
+        }
+    } while ((cur_match = prev[cur_match & WMASK]) > limit
+	     && --chain_length != 0);
+    return best_len;
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 0" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-16.c
new file mode 100644
index 000000000..d0b32f639
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-16.c
@@ -0,0 +1,25 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+#define N 10000
+void foo (int);
+int test ()
+{
+  int a[N][N];
+  int b[N][N];
+  unsigned i, j;
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++)
+      a[i][j] = i*j;
+
+  for (j = 1; j < N; j++) 
+    for (i = 0; i < N; i++)
+      a[i][j] = a[i][j-1] + b[i][j];
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++) 
+      foo (a[i][j]); 
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-17.c
new file mode 100644
index 000000000..c2fec3fcc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-17.c
@@ -0,0 +1,24 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+#define N 10000
+void foo (int);
+int test ()
+{
+  int a[N][N];
+  unsigned i, j;
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++)
+	a[i][j] = i*j;
+
+  for (i = 1; i < N; i++) 
+    for (j = 1; j < (N-1) ; j++)
+	a[i][j] = a[i-1][j+1] * a[i-1][j+1]/2;
+
+  for (i = 0; i < N; i++) 
+    for (j = 0; j < N; j++)
+      foo (a[i][j]); 
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-18.c
new file mode 100644
index 000000000..6264116e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-18.c
@@ -0,0 +1,26 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+#define N 24
+#define M 1000
+
+float A[1000][1000], B[1000][1000], C[1000][1000];
+
+void test (void)
+{
+  int i, j, k;
+
+  /* These loops contain too few iterations for being strip-mined by 64.  */
+  for (i = 0; i < 24; i++)
+    for (j = 0; j < 24; j++)
+      for (k = 0; k < 24; k++)
+        A[i][j] = B[i][k] * C[k][j];
+
+  /* These loops should still be strip mined.  */
+  for (i = 0; i < 1000; i++)
+    for (j = 0; j < 1000; j++)
+      for (k = 0; k < 1000; k++)
+        A[i][j] = B[i][k] * C[k][j];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-19.c
new file mode 100644
index 000000000..3ad49971b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-19.c
@@ -0,0 +1,35 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+typedef unsigned int __uint32_t;
+typedef __uint32_t __size_t;
+typedef __size_t size_t;
+struct demangle_component
+{
+  union
+  {
+  } u;
+};
+enum d_builtin_type_print
+{
+  D_PRINT_VOID
+};
+struct d_growable_string
+{
+  size_t alc;
+};
+d_growable_string_resize (struct d_growable_string *dgs, size_t need)
+{
+  size_t newalc;
+  newalc = dgs->alc > 0 ? dgs->alc : 2;
+  while (newalc < need)
+    newalc <<= 1;
+}
+d_growable_string_append_buffer (struct d_growable_string *dgs,
+                                 const char *s, size_t l)
+{
+  size_t need;
+  if (need > dgs->alc)
+    d_growable_string_resize (dgs, need);
+}
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 0" 2 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-2.c
new file mode 100644
index 000000000..cf25dcdaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-2.c
@@ -0,0 +1,41 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+	for (k = 1; k < 100; k++)
+	  a[j][k] = a[j+1][i-1] + 2;
+
+      b[i] = b[i-1] + 2;
+
+      bar ();
+
+      for (j = 1; j < 100; j++)
+	a[j][i] = a[j+1][i-1] + 2;
+
+      b[i] = b[i-1] + 2;
+
+      bar ();
+
+      for (j = 1; j < 100; j++)
+	a[j][i] = a[j+1][i-1] + 2;
+
+      b[i] = a[i-1][i] + 2;
+
+      for (j = 1; j < 100; j++)
+	a[j][i] = a[j+1][i-1] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 4" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-3.c
new file mode 100644
index 000000000..1789e6b6c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-3.c
@@ -0,0 +1,30 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 80; j++)
+	a[j][i] = a[j+1][2*i-1*j] + 12;
+
+      b[i] = b[i-1] + 10;
+
+      for (j = 1; j < 60; j++)
+	a[j][i] = a[j+1][i-1] + 8;
+
+      if (i == 23)
+	b[i] = a[i-1][i] + 6;
+
+      for (j = 1; j < 40; j++)
+	a[j][i] = a[j+1][i-1] + 4;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-4.c
new file mode 100644
index 000000000..515c53ad5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-4.c
@@ -0,0 +1,31 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar ();
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 80; j++)
+	a[j][i] = a[j+1][2*i-1*j] + 12;
+
+      b[i] = b[i-1] + 10;
+
+      for (j = 1; j < 60; j++)
+	a[j][i] = a[j+1][i-1] + 8;
+
+      bar ();
+
+      if (i == 23)
+	b[i] = a[i-1][i] + 6;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-5.c
new file mode 100644
index 000000000..697a28ea1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-5.c
@@ -0,0 +1,37 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar ();
+
+int toto()
+{
+  int i,j, b;
+  int a[100];
+
+  if (i == 20)
+    {
+      for (j = 0; j <= 20; j++)
+        a[j] = b + i;
+      b = 3;
+      bar();
+    }
+  else 
+    {
+      if (i == 30)
+	{
+          for (j = 0; j <= 20; j++)
+            a[j] = b + i;
+	  b = 5;
+	}
+      else
+	{
+          for (j = 0; j <= 20; j++)
+            a[j] = b + i;
+	  b = 8;
+	}
+    }
+
+  return a[b];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-6.c
new file mode 100644
index 000000000..d26232047
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-6.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+        b[i+j] = b[i+j-1] + 2;
+
+      if (i * 2 == i + 8)
+        b[i+k] = b[i+k-1] + 2;
+      else 
+        {
+        for (k = 1; k < 100; k++)
+          b[i+k] = b[i+k-1] + 2;
+        bar ();
+        }
+      
+      for (k = 1; k < 100; k++)
+        b[i+k] = b[i+k-5] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-7.c
new file mode 100644
index 000000000..1187ce104
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-7.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+        b[i+j] = b[i+j-1] + 2;
+
+      if (i * 2 == i + 8)
+	{
+	  bar ();
+	  for (j = 1; j < 100; j++)
+	    b[i+j] = b[i+j-1] + 2;
+	}
+      else 
+	a[i][i] = 2;
+
+      for (k = 1; k < 100; k++)
+        b[i+k] = b[i+k-5] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 3" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-8.c
new file mode 100644
index 000000000..491ad372f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-8.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+int bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+        b[i+j] = b[i+j-1] + 2;
+
+      if (i * 2 == i + 8)
+	{
+	  for (j = 1; j < 100; j++)
+	    if (bar ())
+	      b[i+j] = b[i+j-1] + 2;
+	}
+      else 
+	a[i][i] = 2;
+
+      for (k = 1; k < 100; k++)
+        b[i+k] = b[i+k-5] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-9.c
new file mode 100644
index 000000000..871b86b8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-9.c
@@ -0,0 +1,29 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+void bar (void);
+
+int toto()
+{
+  int i, j, k;
+  int a[100][100];
+  int b[100];
+
+  for (i = 1; i < 100; i++)
+    {
+      for (j = 1; j < 100; j++)
+        b[i+j] = b[i+j-1] + 2;
+
+      if (i * 2 == i + 8)
+        bar ();
+      else 
+	a[i][i] = 2;
+
+      for (k = 1; k < 100; k++)
+        b[i+k] = b[i+k-5] + 2;
+    }
+
+  return a[3][5] + b[1];
+}
+
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 2" 1 "graphite"} } */
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-matmult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-matmult.c
new file mode 100644
index 000000000..61a5be1fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/graphite/scop-matmult.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -fgraphite -fdump-tree-graphite-all" } */
+
+float A[1000][1000], B[1000][1000], C[1000][1000];
+
+/* Multiply two n x n matrices A and B and store the result in C.  */
+
+void matmult (int n)
+{
+  int i,j,k;
+
+  for (i = 0; i < n; i++)
+    for (j = 0; j < n; j++)
+      for (k = 0; k < n; k++)
+        A[i][j] += B[i][k] * C[k][j];
+}
+
+/* This one fails because the number of iterations cannot be
+   determined anymore for the outermost loop.  */
+/* { dg-final { scan-tree-dump-times "number of SCoPs: 1" 1 "graphite" { xfail *-*-* } } } */ 
+/* { dg-final { cleanup-tree-dump "graphite" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-bss-align-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-bss-align-1.c
new file mode 100644
index 000000000..d6459e15f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-bss-align-1.c
@@ -0,0 +1,12 @@
+/* Make sure that the H8 backend does align zero initialized variables. */
+/* { dg-do compile { target h8300-*-* } } */
+/* { dg-options "" } */
+
+struct s {
+  char a, b;
+  long c;
+};
+
+struct s s = {0};
+
+/* { dg-final { scan-assembler ".align" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-ice2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-ice2.c
new file mode 100644
index 000000000..216ea34c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-ice2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* ICE for signed/unsigned long and signed char comparison */
+int main()
+{
+       unsigned long ul = 4;
+       long sl = 2;
+       signed char sch = -1;
+       if (ul <= sch);
+               return 0;
+       if (sl <= sch)
+               return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-stack-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-stack-1.c
new file mode 100644
index 000000000..b63bde29c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/h8300-stack-1.c
@@ -0,0 +1,14 @@
+/* Make sure that the H8 backend does not generate a non-atomic stack
+   adjustment.  */
+/* { dg-do compile { target h8300-*-* } } */
+/* { dg-options "" } */
+
+void foo (short, short, short, short, short, short);
+
+void
+bar ()
+{
+  foo (0, 0, 0, 0, 0, 0);
+}
+
+/* { dg-final { scan-assembler-not "addx" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/hex-round-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/hex-round-1.c
new file mode 100644
index 000000000..e1283cae3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/hex-round-1.c
@@ -0,0 +1,114 @@
+/* Test for hexadecimal float rounding: bug 21720.  */
+/* { dg-do link } */
+/* { dg-options "-O -std=gnu99" } */
+/* { dg-skip-if "SPU float rounds towards zero" { spu-*-* } } */
+
+#include <float.h>
+
+extern void link_failure (void);
+
+int
+main (void)
+{
+#if FLT_RADIX == 2 && FLT_MANT_DIG == 24
+  if (0x1.0000011p0f == 1)
+    link_failure ();
+  if (0x1.00000101p0f == 1)
+    link_failure ();
+  if (0x1.000001001p0f == 1)
+    link_failure ();
+  if (0x1.0000010001p0f == 1)
+    link_failure ();
+  if (0x1.00000100001p0f == 1)
+    link_failure ();
+  if (0x1.000001000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.00000100000000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.000001000000000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+  if (0x1.0000010000000000000000000000000000000000000000000000001p0f == 1)
+    link_failure ();
+#endif
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/hex-round-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/hex-round-2.c
new file mode 100644
index 000000000..af49536ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/hex-round-2.c
@@ -0,0 +1,115 @@
+/* Test for hexadecimal float rounding: bug 21720.  Test with no "."
+   in number.  */
+/* { dg-do link } */
+/* { dg-options "-O -std=gnu99" } */
+/* { dg-skip-if "SPU float rounds towards zero" { spu-*-* } } */
+
+#include <float.h>
+
+extern void link_failure (void);
+
+int
+main (void)
+{
+#if FLT_RADIX == 2 && FLT_MANT_DIG == 24
+  if (0x10000011p-28f == 1)
+    link_failure ();
+  if (0x100000101p-32f == 1)
+    link_failure ();
+  if (0x1000001001p-36f == 1)
+    link_failure ();
+  if (0x10000010001p-40f == 1)
+    link_failure ();
+  if (0x100000100001p-44f == 1)
+    link_failure ();
+  if (0x1000001000001p-48f == 1)
+    link_failure ();
+  if (0x10000010000001p-52f == 1)
+    link_failure ();
+  if (0x100000100000001p-56f == 1)
+    link_failure ();
+  if (0x1000001000000001p-60f == 1)
+    link_failure ();
+  if (0x10000010000000001p-64f == 1)
+    link_failure ();
+  if (0x100000100000000001p-68f == 1)
+    link_failure ();
+  if (0x1000001000000000001p-72f == 1)
+    link_failure ();
+  if (0x10000010000000000001p-76f == 1)
+    link_failure ();
+  if (0x100000100000000000001p-80f == 1)
+    link_failure ();
+  if (0x1000001000000000000001p-84f == 1)
+    link_failure ();
+  if (0x10000010000000000000001p-88f == 1)
+    link_failure ();
+  if (0x100000100000000000000001p-92f == 1)
+    link_failure ();
+  if (0x1000001000000000000000001p-96f == 1)
+    link_failure ();
+  if (0x10000010000000000000000001p-100f == 1)
+    link_failure ();
+  if (0x100000100000000000000000001p-104f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000001p-108f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000001p-112f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000001p-116f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000001p-120f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000001p-124f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000001p-128f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000001p-132f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000001p-136f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000001p-140f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000001p-144f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000001p-148f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000000001p-152f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000000001p-156f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000000001p-160f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000000000001p-164f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000000000001p-168f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000000000001p-172f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000000000000001p-176f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000000000000001p-180f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000000000000001p-184f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000000000000000001p-188f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000000000000000001p-192f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000000000000000001p-196f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000000000000000000001p-200f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000000000000000000001p-204f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000000000000000000001p-208f == 1)
+    link_failure ();
+  if (0x100000100000000000000000000000000000000000000000000001p-212f == 1)
+    link_failure ();
+  if (0x1000001000000000000000000000000000000000000000000000001p-216f == 1)
+    link_failure ();
+  if (0x10000010000000000000000000000000000000000000000000000001p-220f == 1)
+    link_failure ();
+#endif
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-1.c
new file mode 100644
index 000000000..83c995a62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-1.c
@@ -0,0 +1,75 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_int_long } */
+/* { dg-options } */
+/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */
+
+/* { dg-message "note: '__sync_fetch_and_nand' changed semantics in GCC 4.4" "" { target *-*-* } 0 } */
+
+/* Test basic functionality of the intrinsics.  The operations should
+   not be optimized away if no one checks the return values.  */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+
+extern void abort (void);
+extern void *memcpy (void *, const void *, size_t);
+
+static int AI[12];
+static int init_noret_si[12] = { 0, 0, 0, 1, 0, 0, 0 , 0  , -1, 0, 0, -1 };
+static int test_noret_si[12] = { 1, 1, 1, 0, 1, 4, 22, -12, 7 , 8, 9, ~7 };
+
+static void
+do_noret_si (void)
+{
+  __sync_val_compare_and_swap(AI+0, 0, 1);
+  __sync_bool_compare_and_swap(AI+1, 0, 1);
+  __sync_lock_test_and_set(AI+2, 1);
+  __sync_lock_release(AI+3);
+
+  __sync_fetch_and_add(AI+4, 1);
+  __sync_fetch_and_add(AI+5, 4);
+  __sync_fetch_and_add(AI+6, 22);
+  __sync_fetch_and_sub(AI+7, 12);
+  __sync_fetch_and_and(AI+8, 7);
+  __sync_fetch_and_or(AI+9, 8);
+  __sync_fetch_and_xor(AI+10, 9);
+  __sync_fetch_and_nand(AI+11, 7);
+}
+
+static long AL[12];
+static long init_noret_di[12] = { 0, 0, 0, 1, 0, 0, 0 , 0  , -1, 0, 0, -1 };
+static long test_noret_di[12] = { 1, 1, 1, 0, 1, 4, 22, -12, 7 , 8, 9, ~7 };
+
+static void
+do_noret_di (void)
+{
+  __sync_val_compare_and_swap(AL+0, 0, 1);
+  __sync_bool_compare_and_swap(AL+1, 0, 1);
+  __sync_lock_test_and_set(AL+2, 1);
+  __sync_lock_release(AL+3);
+
+  __sync_fetch_and_add(AL+4, 1);
+  __sync_fetch_and_add(AL+5, 4);
+  __sync_fetch_and_add(AL+6, 22);
+  __sync_fetch_and_sub(AL+7, 12);
+  __sync_fetch_and_and(AL+8, 7);
+  __sync_fetch_and_or(AL+9, 8);
+  __sync_fetch_and_xor(AL+10, 9);
+  __sync_fetch_and_nand(AL+11, 7);
+}
+
+int main()
+{
+  memcpy(AI, init_noret_si, sizeof(init_noret_si));
+  memcpy(AL, init_noret_di, sizeof(init_noret_di));
+
+  do_noret_si ();
+  do_noret_di ();
+
+  if (memcmp (AI, test_noret_si, sizeof(test_noret_si)))
+    abort ();
+  if (memcmp (AL, test_noret_di, sizeof(test_noret_di)))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-2.c
new file mode 100644
index 000000000..69fb9b7c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-2.c
@@ -0,0 +1,131 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_int_long } */
+/* { dg-options } */
+/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */
+
+/* { dg-message "note: '__sync_fetch_and_nand' changed semantics in GCC 4.4" "" { target *-*-* } 0 } */
+/* { dg-message "note: '__sync_nand_and_fetch' changed semantics in GCC 4.4" "" { target *-*-* } 0 } */
+
+/* Test basic functionality of the intrinsics.  */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+
+extern void abort (void);
+extern void *memcpy (void *, const void *, size_t);
+
+static int AI[18];
+static int init_si[18] = { 0,0,0,1,0,0, 0,0  ,-1,0,0,-1,0,0  ,-1,0,0,-1 };
+static int test_si[18] = { 1,1,1,1,1,4,22,-12,7 ,8,9,~7,1,-12,7 ,8,9,~7 };
+
+static void
+do_si (void)
+{
+  if (__sync_val_compare_and_swap(AI+0, 0, 1) != 0)
+    abort ();
+  if (__sync_val_compare_and_swap(AI+0, 0, 1) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AI+1, 0, 1) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AI+1, 0, 1) != 0)
+    abort ();
+
+  if (__sync_lock_test_and_set(AI+2, 1) != 0)
+    abort ();
+
+  if (__sync_fetch_and_add(AI+4, 1) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AI+5, 4) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AI+6, 22) != 0)
+    abort ();
+  if (__sync_fetch_and_sub(AI+7, 12) != 0)
+    abort ();
+  if (__sync_fetch_and_and(AI+8, 7) != -1)
+    abort ();
+  if (__sync_fetch_and_or(AI+9, 8) != 0)
+    abort ();
+  if (__sync_fetch_and_xor(AI+10, 9) != 0)
+    abort ();
+  if (__sync_fetch_and_nand(AI+11, 7) != -1)
+    abort ();
+
+  if (__sync_add_and_fetch(AI+12, 1) != 1)
+    abort ();
+  if (__sync_sub_and_fetch(AI+13, 12) != -12)
+    abort ();
+  if (__sync_and_and_fetch(AI+14, 7) != 7)
+    abort ();
+  if (__sync_or_and_fetch(AI+15, 8) != 8)
+    abort ();
+  if (__sync_xor_and_fetch(AI+16, 9) != 9)
+    abort ();
+  if (__sync_nand_and_fetch(AI+17, 7) != ~7)
+    abort ();
+}
+
+static long AL[18];
+static long init_di[18] = { 0,0,0,1,0,0, 0,0  ,-1,0,0,-1,0,0  ,-1,0,0,-1 };
+static long test_di[18] = { 1,1,1,1,1,4,22,-12,7 ,8,9,~7,1,-12,7 ,8,9,~7 };
+
+static void
+do_di (void)
+{
+  if (__sync_val_compare_and_swap(AL+0, 0, 1) != 0)
+    abort ();
+  if (__sync_val_compare_and_swap(AL+0, 0, 1) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AL+1, 0, 1) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AL+1, 0, 1) != 0)
+    abort ();
+
+  if (__sync_lock_test_and_set(AL+2, 1) != 0)
+    abort ();
+
+  if (__sync_fetch_and_add(AL+4, 1) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AL+5, 4) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AL+6, 22) != 0)
+    abort ();
+  if (__sync_fetch_and_sub(AL+7, 12) != 0)
+    abort ();
+  if (__sync_fetch_and_and(AL+8, 7) != -1)
+    abort ();
+  if (__sync_fetch_and_or(AL+9, 8) != 0)
+    abort ();
+  if (__sync_fetch_and_xor(AL+10, 9) != 0)
+    abort ();
+  if (__sync_fetch_and_nand(AL+11, 7) != -1)
+    abort ();
+
+  if (__sync_add_and_fetch(AL+12, 1) != 1)
+    abort ();
+  if (__sync_sub_and_fetch(AL+13, 12) != -12)
+    abort ();
+  if (__sync_and_and_fetch(AL+14, 7) != 7)
+    abort ();
+  if (__sync_or_and_fetch(AL+15, 8) != 8)
+    abort ();
+  if (__sync_xor_and_fetch(AL+16, 9) != 9)
+    abort ();
+  if (__sync_nand_and_fetch(AL+17, 7) != ~7)
+    abort ();
+}
+
+int main()
+{
+  memcpy(AI, init_si, sizeof(init_si));
+  memcpy(AL, init_di, sizeof(init_di));
+
+  do_si ();
+  do_di ();
+
+  if (memcmp (AI, test_si, sizeof(test_si)))
+    abort ();
+  if (memcmp (AL, test_di, sizeof(test_di)))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-3.c
new file mode 100644
index 000000000..965d4359e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-3.c
@@ -0,0 +1,80 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_int_long } */
+/* { dg-options } */
+/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */
+
+/* Test basic functionality of the intrinsics.  */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+
+extern void abort (void);
+extern void *memcpy (void *, const void *, size_t);
+
+static int AI[4];
+static int init_si[4] = { -30,-30,-50,-50 };
+static int test_si[4] = { -115,-115,25,25 };
+
+static void
+do_si (void)
+{
+  if (__sync_val_compare_and_swap(AI+0, -30, -115) != -30)
+    abort ();
+  if (__sync_val_compare_and_swap(AI+0, -30, -115) != -115)
+    abort ();
+  if (__sync_bool_compare_and_swap(AI+1, -30, -115) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AI+1, -30, -115) != 0)
+    abort ();
+
+  if (__sync_val_compare_and_swap(AI+2, AI[2], 25) != -50)
+    abort ();
+  if (__sync_val_compare_and_swap(AI+2, AI[2], 25) != 25)
+    abort ();
+  if (__sync_bool_compare_and_swap(AI+3, AI[3], 25) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AI+3, AI[3], 25) != 1)
+    abort ();
+}
+
+static long AL[4];
+static long init_di[4] = { -30,-30,-50,-50 };
+static long test_di[4] = { -115,-115,25,25 };
+
+static void
+do_di (void)
+{
+  if (__sync_val_compare_and_swap(AL+0, -30, -115) != -30)
+    abort ();
+  if (__sync_val_compare_and_swap(AL+0, -30, -115) != -115)
+    abort ();
+  if (__sync_bool_compare_and_swap(AL+1, -30, -115) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AL+1, -30, -115) != 0)
+    abort ();
+
+  if (__sync_val_compare_and_swap(AL+2, AL[2], 25) != -50)
+    abort ();
+  if (__sync_val_compare_and_swap(AL+2, AL[2], 25) != 25)
+    abort ();
+  if (__sync_bool_compare_and_swap(AL+3, AL[3], 25) != 1)
+    abort ();
+  if (__sync_bool_compare_and_swap(AL+3, AL[3], 25) != 1)
+    abort ();
+}
+
+int main()
+{
+  memcpy(AI, init_si, sizeof(init_si));
+  memcpy(AL, init_di, sizeof(init_di));
+
+  do_si ();
+  do_di ();
+
+  if (memcmp (AI, test_si, sizeof(test_si)))
+    abort ();
+  if (memcmp (AL, test_di, sizeof(test_di)))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-4.c
new file mode 100644
index 000000000..e78fb4cf8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ia64-sync-4.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target sync_int_long } */
+/* { dg-options "-O2 -finline-functions" } */
+/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */
+
+/* Test inlining __sync_bool_compare_and_swap.  */
+
+#include <stdbool.h>
+
+static bool
+compare_and_swap(long *addr, long old, long new_val)
+{
+  return __sync_bool_compare_and_swap(addr, old, new_val);
+}
+
+void
+foo (long *address)
+{
+  long he_address = *address & ~1;
+  while (!compare_and_swap(address, he_address, he_address | 1))
+    he_address = *address & ~1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/if-empty-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/if-empty-1.c
new file mode 100644
index 000000000..b29a6cb92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/if-empty-1.c
@@ -0,0 +1,23 @@
+/* Test diagnostics for empty bodies in if / else.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wempty-body" } */
+
+void
+f (int x)
+{
+  if (x)
+    ; /* { dg-warning "suggest braces around empty body in an" } */
+  if (x)
+    ; /* By design we don't warn in this case.  */
+  else
+    (void)0;
+  if (x)
+    (void)0;
+  else
+    ; /* { dg-warning "suggest braces around empty body in an" } */
+  if (x)
+    (void)0;
+  else
+    (void)0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ifcvt-fabs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ifcvt-fabs-1.c
new file mode 100644
index 000000000..bdf6b3975
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ifcvt-fabs-1.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+/* { dg-options "-O -march=i686" { target { { i686-*-* x86_64-*-* } && ilp32 } } } */
+
+extern void abort(void);
+
+float foo(float f)
+{
+  if (f < 0.0f)
+    f = -f;
+
+  return f;
+}
+
+int main(void)
+{
+  if (foo (-1.0f) != 1.0f)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ifelse-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ifelse-1.c
new file mode 100644
index 000000000..2dd2208b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ifelse-1.c
@@ -0,0 +1,21 @@
+/*
+{ dg-do compile }
+{ dg-options "-W -Wall" }
+*/
+
+
+extern int bar ();
+extern int com ();
+extern int baz ();
+void
+foo (a,b)
+     int a, b;
+{
+  if (a)
+    if (b)
+      bar ();
+    else
+      com ();	/* { dg-bogus ".*warning.*" "bogus warning" } */
+  else
+    baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ifelse-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ifelse-2.c
new file mode 100644
index 000000000..0210fcfa4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ifelse-2.c
@@ -0,0 +1,34 @@
+/*
+{ dg-do run }
+{ dg-options "-O2" }
+*/
+
+extern void abort (void);
+
+enum Status
+{
+  P_ON_LOWER = -4,
+  P_ON_UPPER = -2,
+  P_FREE = -1
+};
+
+void
+foo (enum Status *stat, double newUpper, double lower, double max)
+{
+  if (newUpper >= max)
+    *stat = P_FREE;
+  else if (newUpper == lower)
+    *stat = P_ON_LOWER;
+}
+
+int
+main ()
+{
+  enum Status stat = P_ON_UPPER;
+
+  foo (&stat, 5.0, -10.0, 10.0);
+
+  if (stat != P_ON_UPPER)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/iftrap-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/iftrap-1.c
new file mode 100644
index 000000000..142782042
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/iftrap-1.c
@@ -0,0 +1,38 @@
+/* Verify that we optimize to conditional traps.  */
+/* { dg-options "-O" } */
+/* { dg-do compile { target rs6000-*-* powerpc*-*-* sparc*-*-* ia64-*-* } } */
+/* { dg-final { scan-assembler-not "^\t(trap|ta|break)\[ \t\]" } } */
+
+void f1(int p)
+{
+  if (p)
+    __builtin_trap();
+}
+
+void f2(int p)
+{
+  if (p)
+    __builtin_trap();
+  else
+    bar();
+}
+
+void f3(int p)
+{
+  if (p)
+    bar();
+  else
+    __builtin_trap();
+}
+
+void f4(int p, int q)
+{
+  if (p)
+    {
+      bar();
+      if (q)
+	bar();
+    }
+  else
+    __builtin_trap();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/iftrap-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/iftrap-2.c
new file mode 100644
index 000000000..8c9c0577c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/iftrap-2.c
@@ -0,0 +1,22 @@
+/* Verify that we optimize to conditional traps.  */
+/* { dg-options "-O" } */
+/* { dg-do compile { target rs6000-*-* powerpc*-*-* sparc*-*-* ia64-*-* } } */
+/* { dg-final { scan-assembler-not "^\t(trap|ta|break)\[ \t\]" } } */
+
+extern void abort(void);
+
+void f1(int p)
+{
+  if (p)
+    __builtin_trap();
+  else
+    abort();
+}
+
+void f2(int p)
+{
+  if (p)
+    abort();
+  else
+    __builtin_trap();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/imag-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/imag-1.c
new file mode 100644
index 000000000..e07ef72e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/imag-1.c
@@ -0,0 +1,18 @@
+/* Test for __imag__ side effects; see PR 33192.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int i, j;
+  i = 1;
+  j = __imag__ ++i;
+  if (i != 2 || j != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-1.c
new file mode 100644
index 000000000..cc808b752
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-1.c
@@ -0,0 +1,45 @@
+/* Test diagnostics for various bad initializers.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void f(void);
+void g(void) = f; /* { dg-error "function 'g' is initialized like a variable" } */
+
+void h(a)
+     int a = 1; /* { dg-error "parameter 'a' is initialized" } */
+{
+  struct s x = { 0 }; /* { dg-error "variable 'x' has initializer but incomplete type" } */
+  /* { dg-warning "excess elements|near init" "excess" { target *-*-* } 12 } */
+  /* { dg-error "storage size" "size" { target *-*-* } 12 } */
+}
+
+char s[1] = "x";
+char s1[1] = { "x" };
+char t[1] = "xy"; /* { dg-warning "initializer-string for array of chars is too long" } */
+char t1[1] = { "xy" }; /* { dg-warning "initializer-string for array of chars is too long" } */
+char u[1] = { "x", "x" }; /* { dg-error "excess elements in char array initializer" } */
+/* { dg-error "near init" "near" { target *-*-* } 21 } */
+
+int i = { }; /* { dg-error "empty scalar initializer" } */
+/* { dg-error "near init" "near" { target *-*-* } 24 } */
+
+int j = { 1 };
+
+int k = { 1, 2 }; /* { dg-warning "excess elements in scalar initializer" } */
+/* { dg-warning "near init" "near" { target *-*-* } 29 } */
+
+int a1[1] = { [1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 32 } */
+int a2[1] = { [-1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 34 } */
+int a3[1] = { [0 ... 1] = 0 }; /* { dg-error "array index range in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 36 } */
+int a4[2] = { [1 ... 0] = 0 }; /* { dg-error "empty index range in initializer" } */
+/* { dg-error "near init" "near" { target *-*-* } 38 } */
+int a5[2] = { [0 ... 2] = 0 }; /* { dg-error "array index range in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 40 } */
+int a6[2] = { [-1 ... 1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 42 } */
+int a7[] = { [-1 ... 1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 44 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-2.c
new file mode 100644
index 000000000..1f0f78bc6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-2.c
@@ -0,0 +1,33 @@
+/* Test diagnostics for various bad initializers.  Test cases with
+   standard syntax with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+void f(void);
+void g(void) = f; /* { dg-error "function 'g' is initialized like a variable" } */
+
+void h(a)
+     int a = 1; /* { dg-error "parameter 'a' is initialized" } */
+{
+  struct s x = { 0 }; /* { dg-error "variable 'x' has initializer but incomplete type" } */
+  /* { dg-warning "excess elements|near init" "near" { target *-*-* } 13 } */
+  /* { dg-error "storage size" "size" { target *-*-* } 13 } */
+}
+
+char s[1] = "x";
+char s1[1] = { "x" };
+char t[1] = "xy"; /* { dg-warning "initializer-string for array of chars is too long" } */
+char t1[1] = { "xy" }; /* { dg-warning "initializer-string for array of chars is too long" } */
+char u[1] = { "x", "x" }; /* { dg-error "excess elements in char array initializer" } */
+/* { dg-error "near init" "near" { target *-*-* } 22 } */
+
+int j = { 1 };
+
+int k = { 1, 2 }; /* { dg-warning "excess elements in scalar initializer" } */
+/* { dg-warning "near init" "near" { target *-*-* } 27 } */
+
+int a1[1] = { [1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 30 } */
+int a2[1] = { [-1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 32 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-3.c
new file mode 100644
index 000000000..109e65e3e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-3.c
@@ -0,0 +1,33 @@
+/* Test diagnostics for various bad initializers.  Test cases with
+   standard syntax with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+void f(void);
+void g(void) = f; /* { dg-error "function 'g' is initialized like a variable" } */
+
+void h(a)
+     int a = 1; /* { dg-error "parameter 'a' is initialized" } */
+{
+  struct s x = { 0 }; /* { dg-error "variable 'x' has initializer but incomplete type" } */
+  /* { dg-error "excess elements|near init" "near" { target *-*-* } 13 } */
+  /* { dg-error "storage size" "size" { target *-*-* } 13 } */
+}
+
+char s[1] = "x";
+char s1[1] = { "x" };
+char t[1] = "xy"; /* { dg-error "initializer-string for array of chars is too long" } */
+char t1[1] = { "xy" }; /* { dg-error "initializer-string for array of chars is too long" } */
+char u[1] = { "x", "x" }; /* { dg-error "excess elements in char array initializer" } */
+/* { dg-error "near init" "near" { target *-*-* } 22 } */
+
+int j = { 1 };
+
+int k = { 1, 2 }; /* { dg-error "excess elements in scalar initializer" } */
+/* { dg-error "near init" "near" { target *-*-* } 27 } */
+
+int a1[1] = { [1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 30 } */
+int a2[1] = { [-1] = 0 }; /* { dg-error "array index in initializer exceeds array bounds" } */
+/* { dg-error "near init" "near" { target *-*-* } 32 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-4.c
new file mode 100644
index 000000000..c8c11845c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-4.c
@@ -0,0 +1,5 @@
+/* PR c/25875 */
+/* Origin: Richard Guenther <rguenth@gcc.gnu.org> */
+/* { dg-do compile } */
+
+struct A { } a = (struct A) {{ (X)0 }};  /* { dg-error "no members|extra brace|near|undeclared|constant|compound|excess" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-5.c
new file mode 100644
index 000000000..18cee43b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-5.c
@@ -0,0 +1,5 @@
+/* PR c/28136 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int i = (struct A[]) {};  /* { dg-error "incomplete|empty|initialization" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-6.c
new file mode 100644
index 000000000..8235f5d96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-bad-6.c
@@ -0,0 +1,12 @@
+/* ICE arising from bug computing composite type of zero-length array
+   types: PR 35433.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int* X;
+typedef int* Y;
+
+X (*p)[][0];
+Y (*q)[][0];
+
+typeof(*(0 ? p : q)) x = { 0 }; /* { dg-warning "excess elements in array initializer|near initialization" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-1.c
new file mode 100644
index 000000000..52639c86b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-1.c
@@ -0,0 +1,19 @@
+/* Test obsolete forms of designated initializers.  Test with default
+   warning options: valid forms are accepted, while ".member" without
+   "=" should not be (bug 16667).  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+struct s { int a; };
+struct s s0 = { .a = 1 };
+struct s s1 = { a: 1 };
+
+int x0[] = { [0] = 1 };
+int x1[] = { [0] 1 };
+
+/* Invalid syntax: multiple designators without "=".  */
+int x2[2][2] = { [0][0] 1 }; /* { dg-error "syntax error|parse error|expected" } */
+
+
+/* Invalid syntax: C99-style structure designator without "=".  */
+struct s s2 = { .a 1 }; /* { dg-error "syntax error|parse error|expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-2.c
new file mode 100644
index 000000000..4fbd45643
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-2.c
@@ -0,0 +1,11 @@
+/* Test obsolete forms of designated initializers.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+struct s { int a; };
+struct s s0 = { .a = 1 };
+struct s s1 = { a: 1 }; /* { dg-warning "obsolete use of designated initializer with ':'" } */
+
+int x0[] = { [0] = 1 };
+int x1[] = { [0] 1 }; /* { dg-warning "obsolete use of designated initializer without '='" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-3.c
new file mode 100644
index 000000000..e3fca6cdd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-desig-obs-3.c
@@ -0,0 +1,11 @@
+/* Test obsolete forms of designated initializers.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+struct s { int a; };
+struct s s0 = { .a = 1 };
+struct s s1 = { a: 1 }; /* { dg-error "obsolete use of designated initializer with ':'" } */
+
+int x0[] = { [0] = 1 };
+int x1[] = { [0] 1 }; /* { dg-error "obsolete use of designated initializer without '='" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-1.c
new file mode 100644
index 000000000..39a5174ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-1.c
@@ -0,0 +1,9 @@
+/* Test diagnostic for empty initializer braces.  Test with no special
+   options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+struct s { int a; } x = { };
+
+struct s *p = &(struct s){ };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-2.c
new file mode 100644
index 000000000..597d72d37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-2.c
@@ -0,0 +1,9 @@
+/* Test diagnostic for empty initializer braces.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+struct s { int a; } x = { }; /* { dg-warning "ISO C forbids empty initializer braces" } */
+
+struct s *p = &(struct s){ }; /* { dg-warning "ISO C forbids empty initializer braces" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-3.c
new file mode 100644
index 000000000..136931867
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-empty-3.c
@@ -0,0 +1,9 @@
+/* Test diagnostic for empty initializer braces.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+struct s { int a; } x = { }; /* { dg-error "ISO C forbids empty initializer braces" } */
+
+struct s *p = &(struct s){ }; /* { dg-error "ISO C forbids empty initializer braces" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-excess-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-excess-1.c
new file mode 100644
index 000000000..ade6fd085
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-excess-1.c
@@ -0,0 +1,48 @@
+/* Test for various cases of excess initializers for empty objects:
+   bug 21873.  Various versions of GCC ICE, hang or loop repeating
+   diagnostics on various of these tests.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s0 { };
+struct s1 { int a; };
+struct s2 { int a; int b; };
+
+int a0[0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a1[0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a2[0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a3[1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a4[][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a5[][0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a6[][0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+int a7[][1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+
+struct s0 b0[0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b1[0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b2[0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b3[1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b4[][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b5[][0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b6[][0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b7[][1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b8[1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s0 b9[] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+
+struct s1 c0[0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c1[0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c2[0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c3[1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c4[][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c5[][0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c6[][0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s1 c7[][1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+
+struct s2 d0[0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d1[0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d2[0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d3[1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d4[][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d5[][0][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d6[][0][1] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
+struct s2 d7[][1][0] = { 1, 2 }; /* { dg-warning "excess elements|near init" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-string-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-string-1.c
new file mode 100644
index 000000000..ace3b3456
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-string-1.c
@@ -0,0 +1,59 @@
+/* String initializers for arrays must not be parenthesized.  Bug
+   11250 from h.b.furuseth at usit.uio.no.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+#include <stddef.h>
+
+char *a = "a";
+char *b = ("b");
+char *c = (("c"));
+
+char d[] = "d";
+char e[] = ("e"); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 14 } */
+char f[] = (("f")); /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 16 } */
+
+signed char g[] = { "d" };
+unsigned char h[] = { ("e") }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 20 } */
+signed char i[] = { (("f")) }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 22 } */
+
+
+struct s { char a[10]; int b; wchar_t c[10]; };
+
+struct s j = {
+  "j",
+  1,
+  (L"j")
+}; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 32 } */
+struct s k = {
+  (("k")), /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 35 } */
+  1,
+  L"k"
+};
+
+struct s l = {
+  .c = (L"l"), /* { dg-bogus "warning" "warning in place of error" } */
+  /* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 42 } */
+  .a = "l"
+};
+
+struct s m = {
+  .c = L"m",
+  .a = ("m")
+}; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 50 } */
+
+char *n = (char []){ "n" };
+
+char *o = (char []){ ("o") }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 55 } */
+
+wchar_t *p = (wchar_t [5]){ (L"p") }; /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "parenthesized|near init" "paren array" { target *-*-* } 58 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-string-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-string-2.c
new file mode 100644
index 000000000..9efd44b3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-string-2.c
@@ -0,0 +1,57 @@
+/* Character arrays but not arrays of compatible enum type may be
+   initialized by narrow string literals.  Arrays of type compatible
+   with wchar_t, including compatible enums, may be initialized by
+   wide string literals.  Use -fshort-enums -fshort-wchar so the
+   relevant circumstances can be obtained portably; may still fail if
+   char, short and int do not all have distinct precisions.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target int32plus } */
+/* { dg-options "-std=c99 -pedantic-errors -fshort-enums -fshort-wchar" } */
+
+#include <limits.h>
+#include <stddef.h>
+
+typedef enum { schar_min = SCHAR_MIN, schar_max = SCHAR_MAX } schar;
+typedef enum { uchar_max = UCHAR_MAX } uchar;
+typedef enum { shrt_min = SHRT_MIN, shrt_max = SHRT_MAX } sshrt;
+typedef enum { ushrt_max = USHRT_MAX } ushrt;
+
+char a0[] = "foo";
+const signed char a2[4] = "foo";
+volatile unsigned char a3[3] = "foo";
+wchar_t a4[] = L"foo";
+const wchar_t a5[3] = L"foo";
+volatile ushrt a6[] = L"foo";
+
+schar a7[] = "foo"; /* { dg-error "string constant" "a7" } */
+uchar a8[] = "foo"; /* { dg-error "string constant" "a8" } */
+const schar a9[] = "foo"; /* { dg-error "string constant" "a9" } */
+short a10[] = L"foo"; /* { dg-error "string constant" "a10" } */
+const sshrt a11[] = L"foo"; /* { dg-error "string constant" "a11" } */
+char a12[] = L"foo"; /* { dg-error "from wide string" "a12" } */
+wchar_t a13[] = "foo"; /* { dg-error "non-wide string" "a13" } */
+
+char b0[] = { "foo" };
+const signed char b2[4] = { "foo" };
+volatile unsigned char b3[3] = { "foo" };
+wchar_t b4[] = { L"foo" };
+const wchar_t b5[3] = { L"foo" };
+volatile ushrt b6[] = { L"foo" };
+
+schar b7[] = { "foo" }; /* { dg-error "string constant" "b7" } */
+uchar b8[] = { "foo" }; /* { dg-error "string constant" "b8" } */
+const schar b9[] = { "foo" }; /* { dg-error "string constant" "b9" } */
+short b10[] = { L"foo" }; /* { dg-error "string constant" "b10" } */
+const sshrt b11[] = { L"foo" }; /* { dg-error "string constant" "b11" } */
+char b12[] = { L"foo" }; /* { dg-error "from wide string" "b12" } */
+wchar_t b13[] = { "foo" }; /* { dg-error "non-wide string" "b13" } */
+
+struct s { signed char a[10]; int b; ushrt c[10]; };
+
+struct s c = { "foo", 0, L"bar" };
+struct s d = { .c = L"bar", .a = "foo" };
+
+ushrt *e = (ushrt [7]){ L"bar" };
+
+wchar_t f[5][5] = { L"foo", L"bar" };
+ushrt g[5][5] = { L"foo", L"bar" };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-undef-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-undef-1.c
new file mode 100644
index 000000000..b775889ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-undef-1.c
@@ -0,0 +1,8 @@
+/* Invalid initializers should not receive an "is not constant"
+   error.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int p = c; /* { dg-error "undeclared" } */
+struct s { int a; } x = { b }; /* { dg-error "undeclared" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/init-vec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-vec-1.c
new file mode 100644
index 000000000..9921b16a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/init-vec-1.c
@@ -0,0 +1,4 @@
+/* Don't ICE or emit spurious errors when init a vector with a scalar.  */
+/* { dg-do compile } */
+typedef float v2sf __attribute__ ((vector_size (8)));
+v2sf a = 0.0;  /* { dg-error "incompatible types" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/initpri1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/initpri1.c
new file mode 100644
index 000000000..794ea2b9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/initpri1.c
@@ -0,0 +1,62 @@
+/* { dg-do run { target init_priority } } */
+
+extern void abort ();
+
+int i;
+int j;
+
+void c1() __attribute__((constructor (500)));
+void c2() __attribute__((constructor (700)));
+void c3() __attribute__((constructor (600)));
+
+void c1() {
+  if (i++ != 0)
+    abort ();
+}
+
+void c2() {
+  if (i++ != 2)
+    abort ();
+}
+
+void c3() {
+  if (i++ != 1)
+    abort ();
+}
+
+void d1() __attribute__((destructor (500)));
+void d2() __attribute__((destructor (700)));
+void d3() __attribute__((destructor (600)));
+
+void d1() {
+  if (--i != 0)
+    abort ();
+}
+
+void d2() {
+  if (--i != 2)
+    abort ();
+}
+
+void d3() {
+  if (j != 2)
+    abort ();
+  if (--i != 1)
+    abort ();
+}
+
+void cd4() __attribute__((constructor (800), destructor (800)));
+
+void cd4() {
+  if (i != 3)
+    abort ();
+  ++j;
+}
+
+int main () {
+  if (i != 3)
+    return 1;
+  if (j != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/initpri2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/initpri2.c
new file mode 100644
index 000000000..fa9fda0d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/initpri2.c
@@ -0,0 +1,39 @@
+/* { dg-do compile { target init_priority } } */
+
+/* Priorities must be in the range [0, 65535].  */
+void c1()
+     __attribute__((constructor (-1))); /* { dg-error "priorities" } */
+void c2() 
+     __attribute__((constructor (65536))); /* { dg-error "priorities" } */
+void d1() 
+     __attribute__((destructor (-1))); /* { dg-error "priorities" } */
+void d2() 
+     __attribute__((destructor (65536))); /* { dg-error "priorities" } */
+
+/* Priorities 0-100 are reserved for system libraries.  */
+void c3() 
+     __attribute__((constructor (50))); /* { dg-warning "reserved" } */
+void d3() 
+     __attribute__((constructor (50))); /* { dg-warning "reserved" } */
+
+/* Priorities must be integral constants.  */
+
+/* Pointers, even with constant values, are not allowed.  */
+void c4() 
+     __attribute__((constructor ((void*) 500))); /* { dg-error "priorities" } */
+void d4()    
+     __attribute__((destructor ((void*) 500))); /* { dg-error "priorities" } */
+
+/* Integer variables are not allowed.  */
+int i;
+void c5() 
+     __attribute__((constructor ((i)))); /* { dg-error "priorities" } */
+void d5()    
+     __attribute__((destructor ((i)))); /* { dg-error "priorities" } */
+
+/* Enumeration constants are allowed.  */
+enum E { e = 500 };
+void c6() 
+     __attribute__((constructor ((e))));
+void d6()    
+     __attribute__((destructor ((e))));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-1.c
new file mode 100644
index 000000000..4dce611d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-1.c
@@ -0,0 +1,28 @@
+/* Verify that DECL_INLINE gets copied between DECLs properly.  */
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+/* { dg-final { if [ istarget hppa*-*-* ] { scan-assembler-not "xyzzy?,%r" } else { scan-assembler-not "xyzzy" } } } */
+
+/* Test that declaration followed by definition inlines.  */
+static inline int xyzzy0 (int);
+static int xyzzy0 (int x) { return x; }
+int test0 (void)
+{
+  return xyzzy0 (5);
+}
+
+/* Test that definition following declaration inlines.  */
+static int xyzzy1 (int);
+static inline int xyzzy1 (int x) { return x; }
+int test1 (void)
+{
+  return xyzzy1 (5);
+}
+
+/* Test that redeclaration inside a function body inlines.  */
+extern inline int xyzzy2 (int x) { return x; }
+int test2 (void)
+{
+  extern int xyzzy2 (int);
+  return xyzzy2 (5);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-10.c
new file mode 100644
index 000000000..f7a7592a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-10.c
@@ -0,0 +1,6 @@
+/* Test inline main, gnu99 mode, freestanding, -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -ffreestanding -pedantic-errors" } */
+
+inline int main (void) { return 1; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-11.c
new file mode 100644
index 000000000..dd07fdd11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-11.c
@@ -0,0 +1,14 @@
+/* Test misuses of inline.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* These should perhaps be hard errors, but are pedwarns at
+   present.  */
+
+inline int a; /* { dg-warning "variable 'a' declared 'inline'" } */
+inline int (*b)(void); /* { dg-warning "variable 'b' declared 'inline'" } */
+typedef inline void c(void); /* { dg-warning "typedef 'c' declared 'inline'" } */
+typedef inline int d; /* { dg-warning "typedef 'd' declared 'inline'" } */
+void e(inline int f(void)); /* { dg-warning "parameter 'f' declared 'inline'" } */
+void g(inline int(void)); /* { dg-warning "parameter '\\({anonymous}\\)' declared 'inline'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-12.c
new file mode 100644
index 000000000..c28951763
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-12.c
@@ -0,0 +1,14 @@
+/* Test misuses of inline.  -pedantic-errors test.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+/* These should perhaps be hard errors, but are pedwarns at
+   present.  */
+
+inline int a; /* { dg-error "variable 'a' declared 'inline'" } */
+inline int (*b)(void); /* { dg-error "variable 'b' declared 'inline'" } */
+typedef inline void c(void); /* { dg-error "typedef 'c' declared 'inline'" } */
+typedef inline int d; /* { dg-error "typedef 'd' declared 'inline'" } */
+void e(inline int f(void)); /* { dg-error "parameter 'f' declared 'inline'" } */
+void g(inline int(void)); /* { dg-error "parameter '\\({anonymous}\\)' declared 'inline'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-13.c
new file mode 100644
index 000000000..62a898c3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-13.c
@@ -0,0 +1,56 @@
+/* Verify basic C99 inline functionality.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+/* { dg-final { scan-assembler-not "dontgenerate" } } */
+/* { dg-final { scan-assembler "func1" } } */
+/* { dg-final { scan-assembler "func2" } } */
+/* { dg-final { scan-assembler "func3" } } */
+/* { dg-final { scan-assembler "func4" } } */
+/* { dg-final { scan-assembler "func5" } } */
+/* { dg-final { scan-assembler "func6" } } */
+/* { dg-final { scan-assembler "func7" } } */
+/* { dg-final { scan-assembler "func8" } } */
+/* { dg-final { scan-assembler "func9" } } */
+
+inline int dontgenerate1 (void)
+{
+  return 1;
+}
+
+inline int dontgenerate2 (void);
+inline int dontgenerate2 (void)
+{
+  return 2;
+}
+
+inline int dontgenerate3 (void)
+{
+  return 3;
+}
+inline int dontgenerate3 (void);
+
+extern inline int func1 (void) { return 1; }
+
+extern inline int func2 (void);
+inline int func2 (void) { return 2; }
+
+inline int func3 (void) { return 3; }
+extern inline int func3 (void);
+
+inline int func4 (void);
+extern inline int func4 (void) { return 4; }
+
+extern inline int func5 (void) { return 5; }
+inline int func5 (void);
+
+extern int func6 (void);
+inline int func6 (void) { return 6; }
+
+inline int func7 (void) { return 7; }
+extern int func7 (void);
+
+inline int func8 (void);
+extern int func8 (void) { return 8; }
+
+extern int func9 (void) { return 9; }
+inline int func9 (void);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-14.c
new file mode 100644
index 000000000..b2bfb67c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-14.c
@@ -0,0 +1,23 @@
+/* Check that you can't redefine a C99 inline function.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+extern inline int func1 (void) /* { dg-message "note: previous definition" } */
+{
+  return 1;
+}
+
+inline int func1 (void) /* { dg-error "redefinition" } */
+{
+  return 1;
+}
+
+inline int func2 (void) /* { dg-message "note: previous definition" } */
+{
+  return 2;
+}
+
+inline int func2 (void) /* { dg-error "redefinition" } */
+{
+  return 2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-15.c
new file mode 100644
index 000000000..e66819115
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-15.c
@@ -0,0 +1,7 @@
+/* Check that an error message is produced when a C99 inline function
+   is never defined.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+extern inline int func1 (void); /* { dg-warning "never defined" } */
+inline int func2 (void); /* { dg-warning "never defined" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-16.c
new file mode 100644
index 000000000..4f9fe978b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-16.c
@@ -0,0 +1,22 @@
+/* { dg-do link } */
+/* { dg-options "-std=c99" } */
+
+static inline __SIZE_TYPE__
+func1(const volatile void * base, __SIZE_TYPE__ byteOffset)
+{
+  volatile __SIZE_TYPE__ *addr
+    = (volatile __SIZE_TYPE__ *)((__SIZE_TYPE__)base + byteOffset);
+  return *addr;
+}
+
+static inline __SIZE_TYPE__
+func2(__SIZE_TYPE__ data)
+{
+    return func1(&data, 0);
+}
+
+int main(int argc, char *argv[]) {
+  __SIZE_TYPE__ b = func2(argc);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-17.c
new file mode 100644
index 000000000..235ad8b00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-17.c
@@ -0,0 +1,24 @@
+/* Test __attribute__((gnu_inline)).  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+/* { dg-final { scan-assembler "func1" } } */
+/* { dg-final { scan-assembler-not "func2" } } */
+/* { dg-final { scan-assembler "func3" } } */
+/* { dg-final { scan-assembler "func4" } } */
+
+#if __STDC_VERSION__ >= 199901L
+# define inline __attribute__((gnu_inline)) inline
+#endif
+
+extern inline int func1 (void) { return 0; }
+inline int func1 (void) { return 1; }
+
+extern int func2 (void);
+extern inline int func2 (void) { return 2; }
+
+inline int func3 (void);
+inline int func3 (void) { return 3; }
+
+extern int func4 (void);
+extern inline int func4 (void) { return 4; }
+int func4 (void) { return 5; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-18.c
new file mode 100644
index 000000000..5a37195be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-18.c
@@ -0,0 +1,28 @@
+/* Test -fgnu89-extern-inline.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fgnu89-inline" } */
+/* { dg-final { scan-assembler "func1" } } */
+/* { dg-final { scan-assembler-not "func2" } } */
+/* { dg-final { scan-assembler "func3" } } */
+/* { dg-final { scan-assembler "func4" } } */
+
+#ifndef __GNUC_GNU_INLINE__
+#error __GNUC_GNU_INLINE__ is not defined
+#endif
+
+#ifdef __GNUC_STDC_INLINE__
+#error __GNUC_STDC_INLINE__ is defined
+#endif
+
+extern inline int func1 (void) { return 0; }
+inline int func1 (void) { return 1; }
+
+extern int func2 (void);
+extern inline int func2 (void) { return 2; }
+
+inline int func3 (void);
+inline int func3 (void) { return 3; }
+
+extern int func4 (void);
+extern inline int func4 (void) { return 4; }
+int func4 (void) { return 5; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-19.c
new file mode 100644
index 000000000..96dceb433
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-19.c
@@ -0,0 +1,28 @@
+/* Test -fgnu89-extern-inline.  */
+/* { dg-do compile } */
+/* { dg-options "-fgnu89-inline" } */
+/* { dg-final { scan-assembler "func1" } } */
+/* { dg-final { scan-assembler-not "func2" } } */
+/* { dg-final { scan-assembler "func3" } } */
+/* { dg-final { scan-assembler "func4" } } */
+
+#ifndef __GNUC_GNU_INLINE__
+#error __GNUC_GNU_INLINE__ is not defined
+#endif
+
+#ifdef __GNUC_STDC_INLINE__
+#error __GNUC_STDC_INLINE__ is defined
+#endif
+
+extern inline int func1 (void) { return 0; }
+inline int func1 (void) { return 1; }
+
+extern int func2 (void);
+extern inline int func2 (void) { return 2; }
+
+inline int func3 (void);
+inline int func3 (void) { return 3; }
+
+extern int func4 (void);
+extern inline int func4 (void) { return 4; }
+int func4 (void) { return 5; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-2.c
new file mode 100644
index 000000000..ef7c71105
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-2.c
@@ -0,0 +1,19 @@
+/* Ensure that we continue to consider FOO local, even though
+   it has been deferred.  */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O3 -finline-limit=0 -fpic" } */
+
+static int foo(void)
+{
+  return 3;
+}
+
+int bar(void)
+{
+  /* Call twice to avoid bypassing the limit for functions called once.  */
+  return foo() + foo() + 1;
+}
+
+/* { dg-final { scan-assembler-not "jsr" { target alpha*-*-* } } } */
+/* { dg-final { scan-assembler-not "PLT" { target i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-assembler-not "plt" { target powerpc*-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-20.c
new file mode 100644
index 000000000..31354abca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-20.c
@@ -0,0 +1,64 @@
+/* Test -fno-gnu89-extern-inline.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -fno-gnu89-inline" } */
+/* { dg-final { scan-assembler-not "dontgenerate" } } */
+/* { dg-final { scan-assembler "func1" } } */
+/* { dg-final { scan-assembler "func2" } } */
+/* { dg-final { scan-assembler "func3" } } */
+/* { dg-final { scan-assembler "func4" } } */
+/* { dg-final { scan-assembler "func5" } } */
+/* { dg-final { scan-assembler "func6" } } */
+/* { dg-final { scan-assembler "func7" } } */
+/* { dg-final { scan-assembler "func8" } } */
+/* { dg-final { scan-assembler "func9" } } */
+
+#ifdef __GNUC_GNU_INLINE__
+#error __GNUC_GNU_INLINE__ is defined
+#endif
+
+#ifndef __GNUC_STDC_INLINE__
+#error __GNUC_STDC_INLINE__ is not defined
+#endif
+
+inline int dontgenerate1 (void)
+{
+  return 1;
+}
+
+inline int dontgenerate2 (void);
+inline int dontgenerate2 (void)
+{
+  return 2;
+}
+
+inline int dontgenerate3 (void)
+{
+  return 3;
+}
+inline int dontgenerate3 (void);
+
+extern inline int func1 (void) { return 1; }
+
+extern inline int func2 (void);
+inline int func2 (void) { return 2; }
+
+inline int func3 (void) { return 3; }
+extern inline int func3 (void);
+
+inline int func4 (void);
+extern inline int func4 (void) { return 4; }
+
+extern inline int func5 (void) { return 5; }
+inline int func5 (void);
+
+extern int func6 (void);
+inline int func6 (void) { return 6; }
+
+inline int func7 (void) { return 7; }
+extern int func7 (void);
+
+inline int func8 (void);
+extern int func8 (void) { return 8; }
+
+extern int func9 (void) { return 9; }
+inline int func9 (void);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-21.c
new file mode 100644
index 000000000..c7f9a07b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-21.c
@@ -0,0 +1,4 @@
+/* Test -fno-gnu89-extern-inline.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -fno-gnu89-inline" } */
+/* { dg-error "only supported in GNU99 or C99 mode" "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-22.c
new file mode 100644
index 000000000..6d790f974
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-22.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-funit-at-a-time" } */
+/* Verify we can inline without a complete prototype and with promoted
+   arguments.  See also PR32492.  */
+__attribute__((always_inline)) void f1() {}
+__attribute__((always_inline)) void f2(char x) {}
+void f3() { f1(); f2(0); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-23.c
new file mode 100644
index 000000000..55bd72a59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-23.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+/* Make sure we can inline a varargs function whose variable arguments
+   are not used.  See PR32493.  */
+#include <stddef.h>
+static inline __attribute__((always_inline)) void __check_printsym_format(const
+char *fmt, ...)
+{
+}
+static inline __attribute__((always_inline)) void print_symbol(const char *fmt,
+ptrdiff_t addr)
+{
+ __check_printsym_format(fmt, "");
+}
+void do_initcalls(void **call)
+{
+   print_symbol(": %s()", (ptrdiff_t) *call);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-24.c
new file mode 100644
index 000000000..d9758176c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-24.c
@@ -0,0 +1,28 @@
+/* Verify that gnu_inline inlines disregard inlining limits.  */
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern int foo (int);
+extern int baz (int);
+
+extern inline __attribute__((gnu_inline))
+int foo (int x)
+{
+  int i;
+  if (!__builtin_constant_p (x))
+    {
+#define B(n) baz (1##n) + baz (2##n) + baz (3##n) \
+	     + baz (4##n) + baz (5##n) + baz (6##n)
+#define C(n) B(1##n) + B(2##n) + B(3##n) + B(4##n) + B(5##n) + B(6##n)
+#define D(n) C(1##n) + C(2##n) + C(3##n) + C(4##n) + C(5##n) + C(6##n)
+      return D(0) + D(1) + D(2) + D(3) + D(4)
+	     + D(5) + D(6) + D(7) + D(8) + D(9);
+    }
+  return 0;
+}
+
+int
+main (void)
+{
+  return foo (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-25.c
new file mode 100644
index 000000000..8063d6cd5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-25.c
@@ -0,0 +1,145 @@
+/* PR c/35017 */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+static int a = 6;
+static const int b = 6;
+int c = 6;
+
+inline int
+fn1 (void)
+{
+  return a;		/* { dg-error "used in inline" } */
+}
+
+inline int
+fn2 (void)
+{
+  return b;		/* { dg-error "used in inline" } */
+}
+
+inline int
+fn3 (void)
+{
+  return c;
+}
+
+inline int
+fn4 (void)
+{
+  static int d = 6;	/* { dg-error "declared in inline" } */
+  return d;
+}
+
+inline int
+fn5 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+inline int
+fn6 (void)
+{
+  int f = 6;
+  return f;
+}
+
+inline int
+fn7 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
+
+extern inline int
+fn8 (void)
+{
+  return a;
+}
+
+extern inline int
+fn9 (void)
+{
+  return b;
+}
+
+extern inline int
+fn10 (void)
+{
+  return c;
+}
+
+extern inline int
+fn11 (void)
+{
+  static int d = 6;
+  return d;
+}
+
+extern inline int
+fn12 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+extern inline int
+fn13 (void)
+{
+  int f = 6;
+  return f;
+}
+
+extern inline int
+fn14 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
+
+static inline int
+fn15 (void)
+{
+  return a;
+}
+
+static inline int
+fn16 (void)
+{
+  return b;
+}
+
+static inline int
+fn17 (void)
+{
+  return c;
+}
+
+static inline int
+fn18 (void)
+{
+  static int d = 6;
+  return d;
+}
+
+static inline int
+fn19 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+static inline int
+fn20 (void)
+{
+  int f = 6;
+  return f;
+}
+
+static inline int
+fn21 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-26.c
new file mode 100644
index 000000000..02f78bb94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-26.c
@@ -0,0 +1,145 @@
+/* PR c/35017 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+static int a = 6;
+static const int b = 6;
+int c = 6;
+
+inline int
+fn1 (void)
+{
+  return a;		/* { dg-warning "used in inline" } */
+}
+
+inline int
+fn2 (void)
+{
+  return b;		/* { dg-warning "used in inline" } */
+}
+
+inline int
+fn3 (void)
+{
+  return c;
+}
+
+inline int
+fn4 (void)
+{
+  static int d = 6;	/* { dg-warning "declared in inline" } */
+  return d;
+}
+
+inline int
+fn5 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+inline int
+fn6 (void)
+{
+  int f = 6;
+  return f;
+}
+
+inline int
+fn7 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
+
+extern inline int
+fn8 (void)
+{
+  return a;
+}
+
+extern inline int
+fn9 (void)
+{
+  return b;
+}
+
+extern inline int
+fn10 (void)
+{
+  return c;
+}
+
+extern inline int
+fn11 (void)
+{
+  static int d = 6;
+  return d;
+}
+
+extern inline int
+fn12 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+extern inline int
+fn13 (void)
+{
+  int f = 6;
+  return f;
+}
+
+extern inline int
+fn14 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
+
+static inline int
+fn15 (void)
+{
+  return a;
+}
+
+static inline int
+fn16 (void)
+{
+  return b;
+}
+
+static inline int
+fn17 (void)
+{
+  return c;
+}
+
+static inline int
+fn18 (void)
+{
+  static int d = 6;
+  return d;
+}
+
+static inline int
+fn19 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+static inline int
+fn20 (void)
+{
+  int f = 6;
+  return f;
+}
+
+static inline int
+fn21 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-27.c
new file mode 100644
index 000000000..0ecfbcf5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-27.c
@@ -0,0 +1,145 @@
+/* PR c/35017 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+static int a = 6;
+static const int b = 6;
+int c = 6;
+
+inline int
+fn1 (void)
+{
+  return a;
+}
+
+inline int
+fn2 (void)
+{
+  return b;
+}
+
+inline int
+fn3 (void)
+{
+  return c;
+}
+
+inline int
+fn4 (void)
+{
+  static int d = 6;
+  return d;
+}
+
+inline int
+fn5 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+inline int
+fn6 (void)
+{
+  int f = 6;
+  return f;
+}
+
+inline int
+fn7 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
+
+extern inline int
+fn8 (void)
+{
+  return a;		/* { dg-warning "used in inline" } */
+}
+
+extern inline int
+fn9 (void)
+{
+  return b;		/* { dg-warning "used in inline" } */
+}
+
+extern inline int
+fn10 (void)
+{
+  return c;
+}
+
+extern inline int
+fn11 (void)
+{
+  static int d = 6;	/* { dg-warning "declared in inline" } */
+  return d;
+}
+
+extern inline int
+fn12 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+extern inline int
+fn13 (void)
+{
+  int f = 6;
+  return f;
+}
+
+extern inline int
+fn14 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
+
+static inline int
+fn15 (void)
+{
+  return a;
+}
+
+static inline int
+fn16 (void)
+{
+  return b;
+}
+
+static inline int
+fn17 (void)
+{
+  return c;
+}
+
+static inline int
+fn18 (void)
+{
+  static int d = 6;
+  return d;
+}
+
+static inline int
+fn19 (void)
+{
+  static const int e = 6;
+  return e;
+}
+
+static inline int
+fn20 (void)
+{
+  int f = 6;
+  return f;
+}
+
+static inline int
+fn21 (int i)
+{
+  static const char g[10] = "abcdefghij";
+  return g[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-28.c
new file mode 100644
index 000000000..20916aef9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-28.c
@@ -0,0 +1,28 @@
+/* PR c/36507 */
+/* { dg-do run } */
+/* { dg-options "-O0 -std=gnu89" } */
+
+int
+main (void)
+{
+  int i = 2;
+  auto inline int f1 (void)
+  {
+    return i;
+  }
+  inline int f2 (void)
+  {
+    return i;
+  }
+  auto inline int f3 (void);
+  auto inline int f3 (void)
+  {
+    return i;
+  }
+  auto inline int f4 (void);
+  inline int f4 (void)
+  {
+    return i;
+  }
+  return f1 () + f2 () + f3 () + f4 () - 8;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-29.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-29.c
new file mode 100644
index 000000000..77672f342
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-29.c
@@ -0,0 +1,28 @@
+/* PR c/36507 */
+/* { dg-do run } */
+/* { dg-options "-O0 -std=gnu99" } */
+
+int
+main (void)
+{
+  int i = 2;
+  auto inline int f1 (void)
+  {
+    return i;
+  }
+  inline int f2 (void)
+  {
+    return i;
+  }
+  auto inline int f3 (void);
+  auto inline int f3 (void)
+  {
+    return i;
+  }
+  auto inline int f4 (void);
+  inline int f4 (void)
+  {
+    return i;
+  }
+  return f1 () + f2 () + f3 () + f4 () - 8;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-3.c
new file mode 100644
index 000000000..a3de19306
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-3.c
@@ -0,0 +1,47 @@
+/* { dg-options "-O2 -funit-at-a-time" } */
+/* { dg-final { scan-assembler-not "big_function_2" } } */
+static void
+big_function_2(void);
+void
+big_function_1()
+{
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	big_function_2();
+}
+static void
+big_function_2()
+{
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+	while (t());
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-30.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-30.c
new file mode 100644
index 000000000..bb9b2b477
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-30.c
@@ -0,0 +1,28 @@
+/* PR c/36507 */
+/* { dg-do run } */
+/* { dg-options "-O0 -std=gnu99 -fgnu89-inline" } */
+
+int
+main (void)
+{
+  int i = 2;
+  auto inline int f1 (void)
+  {
+    return i;
+  }
+  inline int f2 (void)
+  {
+    return i;
+  }
+  auto inline int f3 (void);
+  auto inline int f3 (void)
+  {
+    return i;
+  }
+  auto inline int f4 (void);
+  inline int f4 (void)
+  {
+    return i;
+  }
+  return f1 () + f2 () + f3 () + f4 () - 8;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-31.c
new file mode 100644
index 000000000..1d9a2212e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-31.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+inline int f (void) { return 0; }
+
+void
+g (void)
+{
+  extern int f();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-32.c
new file mode 100644
index 000000000..bfcafd5db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-32.c
@@ -0,0 +1,11 @@
+/* { dg-do link } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+/* { dg-additional-sources inline-32a.c } */
+inline int f (void) { return 0; }
+
+int
+main (void)
+{
+  extern int f();
+  return f ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-32a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-32a.c
new file mode 100644
index 000000000..a2bde0aac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-32a.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+int f (void) { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-33.c
new file mode 100644
index 000000000..ac577e3cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-33.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fdump-tree-optimized"  } */
+/* { dg-options "-O3 -fdump-tree-optimized -fpie" { target { ! nonpic } } } */
+
+int i;
+
+int foo ();
+
+main ()
+{
+  return foo (i);
+}
+
+int foo (i)
+     int i;
+{
+  return bar(i);
+}
+
+/* { dg-final { scan-tree-dump-times "bar"  2 "optimized"  } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-4.c
new file mode 100644
index 000000000..2442f2d39
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler-not "big_static_inline" } } */
+
+extern void f(void);
+static inline void big_static_inline(void)
+{
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+  f(); f(); f(); f(); f(); f(); f(); f(); f(); f();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-5.c
new file mode 100644
index 000000000..d72fad656
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-5.c
@@ -0,0 +1,13 @@
+/* PR middle-end/13448 */
+
+/* { dg-options "-O3" } */
+
+void funct (const int n)
+{
+  n++; /* { dg-error "" } */
+}
+
+int main () {
+  funct (1);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-6.c
new file mode 100644
index 000000000..81d6dc220
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-6.c
@@ -0,0 +1,6 @@
+/* Test duplicate inline, gnu89 mode.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+inline inline void f (void) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-7.c
new file mode 100644
index 000000000..b239a2046
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-7.c
@@ -0,0 +1,6 @@
+/* Test duplicate inline, gnu99 mode.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+inline inline void f (void) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-8.c
new file mode 100644
index 000000000..b4c0eb840
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-8.c
@@ -0,0 +1,6 @@
+/* Test inline main, gnu99 mode, hosted.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -fhosted" } */
+
+inline int main (void); /* { dg-warning "cannot inline function 'main'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-9.c
new file mode 100644
index 000000000..c8dda5360
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline-9.c
@@ -0,0 +1,6 @@
+/* Test inline main, gnu99 mode, hosted, -pedantic-errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -fhosted -pedantic-errors" } */
+
+inline int main (void); /* { dg-error "cannot inline function 'main'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline1.c
new file mode 100644
index 000000000..c660fe314
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -std=gnu89" } */
+/* This test is expected to fail with an error for the redefinition of foo.
+   This violates the constraint of 6.9#3 (no more than one external definition
+   of an identifier with internal linkage in the same translation unit).  */
+static inline int foo(void) { return 1; } /* { dg-message "note: previous definition of" } */
+static inline int foo(void) { return 0; } /* { dg-error "redefinition of" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline2.c
new file mode 100644
index 000000000..ede410492
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline2.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -std=gnu89" } */
+/* This test should compile successfully.  */
+extern inline int foo (void) { return 0; }
+inline int foo (void) { return 1; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline3.c
new file mode 100644
index 000000000..d7fd8dba6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline3.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -std=gnu89" } */
+/* This testcase should fail since we're redefining foo in the same
+   translation unit.  */
+extern inline int foo(void) { return 0; }
+inline int foo (void) { return 1; } /* { dg-message "note: previous definition of" } */
+int foo (void) { return 2; } /* { dg-error "redefinition of" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline4.c
new file mode 100644
index 000000000..64cea7515
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline4.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -std=gnu89" } */
+/* This testcase should fail since we're redefining foo in the same
+   translation unit.  */
+int foo (void) { return 2; } /* { dg-message "note: previous definition of" } */
+extern inline int foo (void) { return 1; } /* { dg-error "redefinition of" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline5.c
new file mode 100644
index 000000000..40fb7cd91
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline5.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall -std=gnu89" } */
+/* This testcase should fail since we're redefining foo in the same
+   translation unit.  */
+extern inline int foo (void) { return 2; } /* { dg-message "note: previous definition of" } */
+extern inline int foo (void) { return 1; } /* { dg-error "redefinition of" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline6.c
new file mode 100644
index 000000000..3b9e3e99e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline6.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+static int i;
+extern int j;
+extern inline int func1 (void) {
+  return i++;  /* { dg-warning "static" } */
+}
+extern inline int func2 (void) {
+  return j++;
+}
+inline int func3 (void) 
+{
+  return i++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/inline7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline7.c
new file mode 100644
index 000000000..54f3360b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/inline7.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+extern inline void func1 (void) {
+  static int i;  /* { dg-warning "static" } */
+}
+inline void func3 (void) 
+{
+  static int i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-1.c
new file mode 100644
index 000000000..1e2d8acc6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-finstrument-functions" } */
+
+void fn () { }
+
+/* { dg-final { scan-assembler "__cyg_profile_func_enter" } } */
+/* { dg-final { scan-assembler "__cyg_profile_func_exit" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-2.c
new file mode 100644
index 000000000..297a02da6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-finstrument-functions -finstrument-functions-exclude-function-list=fn" } */
+
+void fn () { }
+
+/* { dg-final { scan-assembler-not "__cyg_profile_func_enter" } } */
+/* { dg-final { scan-assembler-not "__cyg_profile_func_exit" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-3.c
new file mode 100644
index 000000000..c1a9c2a81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/instrument-3.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-finstrument-functions -finstrument-functions-exclude-file-list=instrument-3" } */
+
+void fn () { }
+
+/* { dg-final { scan-assembler-not "__cyg_profile_func_enter" } } */
+/* { dg-final { scan-assembler-not "__cyg_profile_func_exit" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/intermod-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/intermod-1.c
new file mode 100644
index 000000000..9f8d19deb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/intermod-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-final { scan-assembler-not {foo[1-9]\.[0-9]} } } */
+
+/* Check that we don't get .0 suffixes on static variables when not using
+   intermodule analysis.  */
+
+static int foo1;
+static int foo2 = 1;
+
+static void foo5(void) {  }
+static void foo6(void);
+static void foo6(void) { }
+static void foo7(void);
+void foo7(void) { }
+
+void foo9(void) 
+{
+  foo1 = 2;
+  foo2 = 3;
+  foo5();
+  foo6();
+  foo7();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/intmax_t-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/intmax_t-1.c
new file mode 100644
index 000000000..00b503c25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/intmax_t-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+/* { dg-error "" "" { target { { *arm*-*-*elf* xtensa*-*-elf* } || vxworks_kernel } } 0 } */
+
+/* Compile with -Wall to get a warning if built-in and system intmax_t don't
+   match.  */
+
+#include <inttypes.h>
+
+__INTMAX_TYPE__ __im_t__;
+__UINTMAX_TYPE__ __uim_t__;
+intmax_t *im_t_p;
+uintmax_t *uim_t_p;
+
+void
+imt (void)
+{
+  im_t_p = &__im_t__;
+}
+
+void
+uimt (void)
+{
+  uim_t_p = &__uim_t__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/invalid-call-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/invalid-call-1.c
new file mode 100644
index 000000000..1d19c56a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/invalid-call-1.c
@@ -0,0 +1,18 @@
+/* PR rtl-optimization/29841 */
+/* Testcase by Khem Raj <raj.khem@gmail.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -march=i586" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+typedef void (*fp)(void);
+extern char* bar(void* a1, int a2);
+extern char* mar(int n);
+char* cptr;
+
+void foo()
+{
+  cptr = mar(6);
+  ((char *(*)(void *,int (*)(void *,unsigned char **),char**))((fp)bar))(0,0,(void*)(0)); /* { dg-warning "function called through a non-compatible type" "non-compatible type" } */
+  /* { dg-message "note: if this code is reached, the program will abort" "" { target *-*-* } 16 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/iinline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/iinline-1.c
new file mode 100644
index 000000000..9f0ad68e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/iinline-1.c
@@ -0,0 +1,26 @@
+/* Verify that simple indirect calls are inlined even without early
+   inlining..  */
+/* { dg-do compile } */
+/* { dg-options "-O3 -c -fdump-ipa-inline -fno-early-inlining"  } */
+
+extern void non_existent(int);
+
+static void hooray ()
+{
+  non_existent (1);
+}
+
+static void hiphip (void (*f)())
+{
+  non_existent (2);
+  f ();
+}
+
+int main (int argc, int *argv[])
+{
+  hiphip (hooray);
+  return 0;
+}
+
+/* { dg-final { scan-ipa-dump "hooray\[^\\n\]*inline copy in main"  "inline"  } } */
+/* { dg-final { cleanup-ipa-dump "inline" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-1.c
new file mode 100644
index 000000000..76ef9a643
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-1.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining"  } */
+/* { dg-skip-if "PR 25442" { "*-*-*" } { "-fpic" "-fPIC" } { "" } } */
+
+#include <stdio.h>
+int g (int b, int c)
+{
+  printf ("%d %d\n", b, c);
+}
+int f (int a)
+{
+  /* Second parameter of g gets different values.  */
+  if (a > 0)
+    g (a, 3);
+  else
+    g (a, 5); 	
+}
+int main ()
+{
+  f (7);
+  return 0;	
+}
+
+
+/* { dg-final { scan-ipa-dump-times "versioned function" 2 "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param a with const 7" "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param b with const 7" "cp"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-2.c
new file mode 100644
index 000000000..454927a2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining"  } */
+/* { dg-skip-if "PR 25442" { "*-*-*" } { "-fpic" "-fPIC" } { "" } } */
+
+#include <stdio.h>
+int g (int b, int c)
+{
+  printf ("%d %d\n", b, c);
+}
+int f (int a)
+{
+  /* a is modified.  */
+  if (a++ > 0)
+    g (a, 3);
+}
+int main ()
+{
+  f (7);
+  return 0;	
+}
+
+
+/* { dg-final { scan-ipa-dump-times "versioned function" 2 "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param a with const 7" "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param c with const 3" "cp"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-3.c
new file mode 100644
index 000000000..c476b9250
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-3.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining"  } */
+/* { dg-skip-if "PR 25442" { "*-*-*" } { "-fpic" "-fPIC" } { "" } } */
+
+
+/* Double constants.  */
+
+#include <stdio.h>
+int g (double b, double c)
+{
+  return (int)(b+c);  
+}
+int f (double a)
+{
+  if (a > 0)
+    g (a, 3.1);
+  else
+    g (a, 3.1); 	
+}
+int main ()
+{
+  f (7.44);
+  return 0;	
+}
+
+
+/* { dg-final { scan-ipa-dump-times "versioned function" 2 "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param a with const 7" "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param b with const 7" "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param c with const 3" "cp"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-4.c
new file mode 100644
index 000000000..9f716f139
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-4.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp"  } */
+/* { dg-skip-if "PR 25442" { "*-*-*" } { "-fpic" "-fPIC" } { "" } } */
+
+#include <stdio.h>
+int g (int b, int c)
+{
+  printf ("%d %d\n", b, c);
+}
+int f (int a)
+{
+  /* First and second parameter of g gets different values.  */ 
+     
+  if (a > 0)
+    g (a, 3);
+  else
+    g (a+1, 5); 	
+}
+int main ()
+{
+  f (7);
+  return 0;	
+}
+
+
+/* { dg-final { scan-ipa-dump-times "versioned function" 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-times "replacing param a with const 7" 1 "cp"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-5.c
new file mode 100644
index 000000000..9352e19ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-5.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining"  } */
+/* { dg-skip-if "PR 25442" { "*-*-*" } { "-fpic" "-fPIC" } { "" } } */
+
+/* Float & short constants.  */
+
+#include <stdio.h>
+int g (float b, short c)
+{
+  return c + (int)b;
+}
+int f (float a)
+{
+  /* a is modified.  */
+  if (a++ > 0)
+    g (a, 3);
+}
+int main ()
+{
+  f (7.6);
+  return 0;	
+}
+
+
+/* { dg-final { scan-ipa-dump-times "versioned function" 2 "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param c with const 3" "cp"  } } */
+/* { dg-final { scan-ipa-dump "replacing param a with const 7" "cp"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-6.c
new file mode 100644
index 000000000..a22555c2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-6.c
@@ -0,0 +1,31 @@
+/* PR middle-end/29122 */
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fno-early-inlining" } */
+
+int
+dont_inline (int);
+
+int
+bar (int b, int c)
+{
+   return dont_inline (c);
+}
+
+int
+foo (int a)
+{
+  if (a++ > 0)
+    bar (a, 3);
+
+  foo (7);
+}
+
+int
+main ()
+{
+  foo (7);
+  return 0;
+}
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-7.c
new file mode 100644
index 000000000..1c4a1709d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa-7.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining"  } */
+/* { dg-skip-if "PR 25442" { "*-*-*" } { "-fpic" "-fPIC" } { "" } } */
+
+#include <stdio.h>
+void send_addr (int *);
+int g (int b, int c)
+{
+  printf ("%d %d\n", b, c);
+}
+int f (int a)
+{
+  if (a > 0)
+    g (a, 3);
+  else
+    g (a, 5); 	
+   
+  send_addr (&a);
+}
+int main ()
+{
+  f (7);
+  return 0;	
+}
+
+
+/* { dg-final { scan-ipa-dump-times "versioned function" 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-times "replacing param a with const 7" 1 "cp"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa.exp
new file mode 100644
index 000000000..1bbfee7cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipa.exp
@@ -0,0 +1,35 @@
+# Copyright (C) 1997, 2004, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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-4.4.3/gcc/testsuite/gcc.dg/ipa/ipacost-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipacost-1.c
new file mode 100644
index 000000000..1c75c6cfd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipacost-1.c
@@ -0,0 +1,59 @@
+/* { dg-do compile } */
+/* { dg-options "-Os -fipa-cp -fdump-ipa-cp -fno-early-inlining -fdump-tree-optimized"  } */
+
+int array[100];
+
+int t(int);
+
+static int 
+i_can_be_propagated_fully (int *a)
+{
+  int i;
+  for (i=0;i<50;i++)
+  {
+    t(a[i]);
+    t(a[i+1]);
+    t(a[i+2]);
+    t(a[i+3]);
+  }
+}
+static int 
+i_can_be_propagated_fully2 (int *a)
+{
+  i_can_be_propagated_fully (a);
+  i_can_be_propagated_fully (a);
+  i_can_be_propagated_fully (a);
+}
+static int 
+i_can_not_be_propagated_fully (int *a)
+{
+  int i;
+  for (i=0;i<50;i++)
+  {
+    t(a[i]);
+    t(a[i+1]);
+    t(a[i+2]);
+    t(a[i+3]);
+  }
+}
+int 
+i_can_not_be_propagated_fully2 (int *a)
+{
+  i_can_not_be_propagated_fully (a);
+  i_can_not_be_propagated_fully (a);
+  i_can_not_be_propagated_fully (a);
+}
+main()
+{
+  i_can_be_propagated_fully2 (array);
+  i_can_not_be_propagated_fully2 (array);
+}
+
+/* { dg-final { scan-ipa-dump-times "versioned function i_can_be_propagated_fully2" 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-times "versioned function i_can_be_propagated_fully " 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-not "versioned function i_can_not_be_propagated_fully2" "cp"  } } */
+/* { dg-final { scan-ipa-dump-not "versioned function i_can_not_be_propagated_fully " "cp"  } } */
+/* { dg-final { scan-tree-dump-not "i_can_be_propagated_fully " "optimized"  } } */
+/* { dg-final { scan-tree-dump-not "i_can_be_propagated_fully2 " "optimized"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipacost-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipacost-2.c
new file mode 100644
index 000000000..46db85fde
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/ipacost-2.c
@@ -0,0 +1,60 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining -fdump-tree-optimized"  } */
+/* { dg-options "-O3 -fipa-cp -fipa-cp-clone -fdump-ipa-cp -fno-early-inlining -fdump-tree-optimized -fpie" { target { ! nonpic } } } */
+
+int array[100];
+
+int t(int);
+
+static int 
+i_can_be_propagated_fully (int *a)
+{
+  int i;
+  for (i=0;i<50;i++)
+  {
+    t(a[i]);
+    t(a[i+1]);
+    t(a[i+2]);
+    t(a[i+3]);
+  }
+}
+static int 
+i_can_be_propagated_fully2 (int *a)
+{
+  i_can_be_propagated_fully (a);
+  i_can_be_propagated_fully (a);
+  i_can_be_propagated_fully (a);
+}
+static int 
+i_can_not_be_propagated_fully (int *a)
+{
+  int i;
+  for (i=0;i<50;i++)
+  {
+    t(a[i]);
+    t(a[i+1]);
+    t(a[i+2]);
+    t(a[i+3]);
+  }
+}
+int 
+i_can_not_be_propagated_fully2 (int *a)
+{
+  i_can_not_be_propagated_fully (a);
+  i_can_not_be_propagated_fully (a);
+  i_can_not_be_propagated_fully (a);
+}
+main()
+{
+  i_can_be_propagated_fully2 (array);
+  i_can_not_be_propagated_fully2 (array);
+}
+
+/* { dg-final { scan-ipa-dump-times "versioned function i_can_be_propagated_fully2" 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-times "versioned function i_can_be_propagated_fully " 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-times "versioned function i_can_not_be_propagated_fully2" 1 "cp"  } } */
+/* { dg-final { scan-ipa-dump-times "versioned function i_can_not_be_propagated_fully " 1 "cp"  } } */
+/* { dg-final { scan-tree-dump-not "i_can_be_propagated" "optimized"  } } */
+/* { dg-final { scan-tree-dump-not "i_can_be_propagated" "optimized"  } } */
+/* { dg-final { cleanup-ipa-dump "cp" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/modif-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/modif-1.c
new file mode 100644
index 000000000..bc1706c56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ipa/modif-1.c
@@ -0,0 +1,44 @@
+/* Verify that modification analysis detects modfications.  */
+/* { dg-do compile } */
+/* { dg-options "-O3 -c -fdump-ipa-inline-details -fno-early-inlining"  } */
+
+struct whatever
+{
+  int first;
+  unsigned second;
+};
+
+void func1 (struct whatever w);
+void func2 (struct whatever *pw);
+void func3 (int i);
+void func4 (int *pi);
+
+void the_test (struct whatever u, struct whatever v,
+	       struct whatever w, struct whatever x,
+	       int i, int j, int k, int l)
+{
+  struct whatever *pw = &w;
+  int *pk = &k;
+
+  j = l+3;
+  v.first = 9;
+
+  func1 (u);
+  func1 (v);
+  func2 (pw);
+  func2 (&x);
+  func3 (i);
+  func3 (j);
+  func4 (pk);
+  func4 (&l);
+}
+
+/* { dg-final { scan-ipa-dump-not "param 0\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump "param 1\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump "param 2\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump "param 3\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump-not "param 4\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump "param 5\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump "param 6\[^\\n\]*modified" "inline" } } */
+/* { dg-final { scan-ipa-dump "param 7\[^\\n\]*modified" "inline" } } */
+/* { dg-final { cleanup-ipa-dump "inline" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/kpice1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/kpice1.c
new file mode 100644
index 000000000..be9179b03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/kpice1.c
@@ -0,0 +1,6 @@
+/* { dg-do compile { target h8300-*-* } } */
+/* { dg-options "-ms -mn" } */
+
+void f(void) __attribute__((interrupt_handler));
+void g(void) { }
+void f(void) { g(); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/label-compound-stmt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-compound-stmt-1.c
new file mode 100644
index 000000000..71411631b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-compound-stmt-1.c
@@ -0,0 +1,7 @@
+/* Test that labels at ends of compound statements are hard errors.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f(void) { g: } /* { dg-bogus "warning" "warning in place of error" } */
+/* { dg-error "label|parse|syntax" "label at end of compound statement" { target *-*-* } 6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-1.c
new file mode 100644
index 000000000..3b33888d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-1.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for label declarations.  Test with no special
+   options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int b;
+
+void
+f (void)
+{
+  __label__ a, b, c, d;
+  __extension__ (void)&&d; /* { dg-error "label 'd' used but not defined" } */
+  goto c; /* { dg-error "label 'c' used but not defined" } */
+ a: (void)0;
+ b: (void)0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-2.c
new file mode 100644
index 000000000..97c453b78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-2.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for label declarations.  Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+typedef int b;
+
+void
+f (void)
+{
+  __label__ a, b, c, d;
+  __extension__ (void)&&d; /* { dg-error "label 'd' used but not defined" } */
+  /* { dg-warning "ISO C forbids label declarations" "label decls" { target *-*-* } 11 } */
+  goto c; /* { dg-error "label 'c' used but not defined" } */
+ a: (void)0;
+ b: (void)0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-3.c
new file mode 100644
index 000000000..32daea87f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-3.c
@@ -0,0 +1,18 @@
+/* Test diagnostics for label declarations.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+typedef int b;
+
+void
+f (void)
+{
+  __label__ a, b, c, d;
+  __extension__ (void)&&d; /* { dg-error "label 'd' used but not defined" } */
+  /* { dg-error "ISO C forbids label declarations" "label decls" { target *-*-* } 12 } */
+  goto c; /* { dg-error "label 'c' used but not defined" } */
+ a: (void)0;
+ b: (void)0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-4.c
new file mode 100644
index 000000000..3cfe965fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/label-decl-4.c
@@ -0,0 +1,14 @@
+/* Test diagnostics for duplicate label declarations.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (void)
+{
+  __label__ a, b, a; /* { dg-error "duplicate label declaration 'a'" } */
+  /* { dg-message "note: previous declaration of 'a' was here" "previous" { target *-*-* } 9 } */
+  __label__ c; /* { dg-message "note: previous declaration of 'c' was here" } */
+  __label__ c; /* { dg-error "duplicate label declaration 'c'" } */
+  return;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-2.c
new file mode 100644
index 000000000..bff2f8250
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-2.c
@@ -0,0 +1,7 @@
+/* PR c/25309 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+static char * name[] = {
+    [0x80000000]  = "bar"
+  };
+/* { dg-error "too large" "" { target { { ! lp64 } && { ! llp64 } } }  6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-3.c
new file mode 100644
index 000000000..ea13b933a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-3.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+#include <limits.h>
+
+#if defined(__LP64__) || defined(_WIN64)
+#define DIM (UINT_MAX>>1)+1
+#else
+#define DIM 65536
+#endif
+
+int
+sub (int *a)
+{
+  return a[0];
+}
+
+int
+main (void)
+{
+  int a[DIM][DIM];  /* { dg-error "size of array 'a' is too large" } */
+  return sub (&a[0][0]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-4.c
new file mode 100644
index 000000000..f6099b915
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array-4.c
@@ -0,0 +1,7 @@
+/* PR c/25309 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+static char * name[] = {
+    [0x80000000]  = "bar"
+  };
+/* { dg-error "too large" "" { target { { ! lp64 } && { ! llp64 } } }  6 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array.c
new file mode 100644
index 000000000..6ea760669
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/large-size-array.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+#include <limits.h>
+
+#if defined(__LP64__) || defined(_WIN64)
+#define DIM UINT_MAX>>1
+#else
+#define DIM USHRT_MAX>>1
+#endif
+
+int
+sub (int *a)
+{
+  return a[0];
+}
+
+int
+main (void)
+{
+  int a[DIM][DIM];  /* { dg-error "size of array 'a' is too large" } */
+  return sub (&a[0][0]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/lazy-ptr-test.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/lazy-ptr-test.c
new file mode 100644
index 000000000..da66b518f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/lazy-ptr-test.c
@@ -0,0 +1,18 @@
+/* { dg-do compile { target powerpc*-apple-darwin* } } */
+/* { dg-options "-S" } */
+
+void f () __attribute__((weak_import));
+
+typedef void PF (void);
+
+void f(void){};
+
+PF* g (void) { return f; }
+
+int main()
+{
+	(*g())();
+	return 0;
+}
+
+/* { dg-final { scan-assembler "non_lazy_ptr" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/local1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/local1.c
new file mode 100644
index 000000000..e9f653bcc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/local1.c
@@ -0,0 +1,23 @@
+/* This is allowed, with the effect that the 'extern' declaration at block
+   scope refers to the same object as the 'static' declaration at file scope.
+
+      C90 6.1.2.2 [as corrected by TC1], C99 6.2.2:
+
+	  For an identifier declared with the storage-class specifier
+	  extern in a scope in which a prior declaration of that
+	  identifier is visible, if the prior declaration specifies
+	  internal or external linkage, the linkage of the identifier at
+	  the later daclaration is the same as the linkage specified at
+	  the prior declaration.  If no prior declaration is visible,
+	  or if the prior declaration specifies no linkage, then the
+	  identifer has external linkage.
+
+   This is PR 14366.  */
+
+static int i;
+
+extern int i;
+
+static void f() {
+  extern int i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-compare-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-compare-1.c
new file mode 100644
index 000000000..c650cb18d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-compare-1.c
@@ -0,0 +1,126 @@
+/* Problem only noticed on SH for -mcbranchdi DImode comparison with constants.
+ * Target dependant failure but test valid for alls.  */
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+/* { dg-options "-O0 -mcbranchdi" { target sh4-*-* } } */
+
+extern void abort(void);
+extern void exit(int);
+
+int test2(long long n)
+{
+  if (n < 2)
+    return 1;
+  return 0;
+}
+
+int test1(long long n)
+{
+  if (n < 1)
+    return 1;
+  return 0;
+}
+
+int test0(long long n)
+{
+  if (n < 0)
+    return 1;
+  return 0;
+}
+
+int test1n(long long n)
+{
+  if (n < -1LL)
+    return 1;
+  return 0;
+}
+
+int test2n(long long n)
+{
+  if (n < -2LL)
+    return 1;
+  return 0;
+}
+
+int main()
+{
+  if (test2n (-1LL))
+    abort ();
+
+  if (test2n (-2LL))
+    abort ();
+
+  if (test2n (0LL))
+    abort ();
+
+  if (test2n (1LL))
+    abort ();
+
+  if (test2n (2LL))
+    abort ();
+ 
+  if (test1n (-1LL))
+    abort ();
+
+  if (!test1n (-2LL))
+    abort ();
+
+  if (test1n (0LL))
+    abort ();
+
+  if (test1n (1LL))
+    abort ();
+
+  if (test1n (2LL))
+    abort ();
+
+  if (!test0 (-1LL))
+    abort ();
+
+  if (!test0 (-2LL))
+    abort ();
+
+  if (test0 (0LL))
+    abort ();
+
+  if (test0 (1LL))
+    abort ();
+
+  if (test0 (2LL))
+    abort ();
+
+  if (!test2 (-1LL))
+    abort ();
+
+  if (!test2 (-2LL))
+    abort ();
+
+  if (!test2 (0LL))
+    abort ();
+
+  if (!test2 (1LL))
+    abort ();
+
+  if (test2 (2LL))
+    abort ();
+
+  if (!test1 (-1LL))
+    abort ();
+
+  if (!test1 (-2LL))
+    abort ();
+
+  if (!test1 (0LL))
+    abort ();
+
+  if (test1 (1LL))
+    abort ();
+
+  if (test1 (2LL))
+    abort ();
+
+  exit (0);
+}
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-cst1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-cst1.c
new file mode 100644
index 000000000..7c60648d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-cst1.c
@@ -0,0 +1,18 @@
+/* PR middle-end/27724 */
+/* { dg-do run } */
+/* { dg-options "" } */
+
+extern void abort();
+
+struct st{
+  int _mark;
+};
+unsigned long long t = ((int)(__SIZE_TYPE__)&(((struct st*)16)->_mark) - 32);
+
+int main()
+{
+  if (t != (unsigned long long)(int)-16)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-typespec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-typespec-1.c
new file mode 100644
index 000000000..2ef2416f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/long-long-typespec-1.c
@@ -0,0 +1,828 @@
+/* Test for valid and invalid combinations of type specifiers in C90
+   with -Wno-long-long.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1990 -pedantic-errors -Wno-long-long" } */
+
+typedef char type;
+extern *x0;
+void *x1;
+char *x2;
+short *x3;
+int *x4;
+long *x5;
+float *x6;
+double *x7;
+signed *x8;
+unsigned *x9;
+type *x10;
+void void *x11; /* { dg-error "" "void void" } */
+void char *x12; /* { dg-error "" "void char" } */
+void short *x13; /* { dg-error "" "void short" } */
+void int *x14; /* { dg-error "" "void int" } */
+void long *x15; /* { dg-error "" "void long" } */
+void float *x16; /* { dg-error "" "void float" } */
+void double *x17; /* { dg-error "" "void double" } */
+void signed *x18; /* { dg-error "" "void signed" } */
+void unsigned *x19; /* { dg-error "" "void unsigned" } */
+char void *x20; /* { dg-error "" "char void" } */
+char char *x21; /* { dg-error "" "char char" } */
+char short *x22; /* { dg-error "" "char short" } */
+char int *x23; /* { dg-error "" "char int" } */
+char long *x24; /* { dg-error "" "char long" } */
+char float *x25; /* { dg-error "" "char float" } */
+char double *x26; /* { dg-error "" "char double" } */
+char signed *x27;
+char unsigned *x28;
+short void *x29; /* { dg-error "" "short void" } */
+short char *x30; /* { dg-error "" "short char" } */
+short short *x31; /* { dg-error "" "short short" } */
+short int *x32;
+short long *x33; /* { dg-error "" "short long" } */
+short float *x34; /* { dg-error "" "short float" } */
+short double *x35; /* { dg-error "" "short double" } */
+short signed *x36;
+short unsigned *x37;
+int void *x38; /* { dg-error "" "int void" } */
+int char *x39; /* { dg-error "" "int char" } */
+int short *x40;
+int int *x41; /* { dg-error "" "int int" } */
+int long *x42;
+int float *x43; /* { dg-error "" "int float" } */
+int double *x44; /* { dg-error "" "int double" } */
+int signed *x45;
+int unsigned *x46;
+long void *x47; /* { dg-error "" "long void" } */
+long char *x48; /* { dg-error "" "long char" } */
+long short *x49; /* { dg-error "" "long short" } */
+long int *x50;
+long long *x51;
+long float *x52; /* { dg-error "" "long float" } */
+long double *x53;
+long signed *x54;
+long unsigned *x55;
+float void *x56; /* { dg-error "" "float void" } */
+float char *x57; /* { dg-error "" "float char" } */
+float short *x58; /* { dg-error "" "float short" } */
+float int *x59; /* { dg-error "" "float int" } */
+float long *x60; /* { dg-error "" "float long" } */
+float float *x61; /* { dg-error "" "float float" } */
+float double *x62; /* { dg-error "" "float double" } */
+float signed *x63; /* { dg-error "" "float signed" } */
+float unsigned *x64; /* { dg-error "" "float unsigned" } */
+double void *x65; /* { dg-error "" "double void" } */
+double char *x66; /* { dg-error "" "double char" } */
+double short *x67; /* { dg-error "" "double short" } */
+double int *x68; /* { dg-error "" "double int" } */
+double long *x69;
+double float *x70; /* { dg-error "" "double float" } */
+double double *x71; /* { dg-error "" "double double" } */
+double signed *x72; /* { dg-error "" "double signed" } */
+double unsigned *x73; /* { dg-error "" "double unsigned" } */
+signed void *x74; /* { dg-error "" "signed void" } */
+signed char *x75;
+signed short *x76;
+signed int *x77;
+signed long *x78;
+signed float *x79; /* { dg-error "" "signed float" } */
+signed double *x80; /* { dg-error "" "signed double" } */
+signed signed *x81; /* { dg-error "" "signed signed" } */
+signed unsigned *x82; /* { dg-error "" "signed unsigned" } */
+unsigned void *x83; /* { dg-error "" "unsigned void" } */
+unsigned char *x84;
+unsigned short *x85;
+unsigned int *x86;
+unsigned long *x87;
+unsigned float *x88; /* { dg-error "" "unsigned float" } */
+unsigned double *x89; /* { dg-error "" "unsigned double" } */
+unsigned signed *x90; /* { dg-error "" "unsigned signed" } */
+unsigned unsigned *x91; /* { dg-error "" "unsigned unsigned" } */
+type void *x92; /* { dg-error "" "type void" } */
+type char *x93; /* { dg-error "" "type char" } */
+type short *x94; /* { dg-error "" "type short" } */
+type int *x95; /* { dg-error "" "type int" } */
+type long *x96; /* { dg-error "" "type long" } */
+type float *x97; /* { dg-error "" "type float" } */
+type double *x98; /* { dg-error "" "type double" } */
+type signed *x99; /* { dg-error "" "type signed" } */
+type unsigned *x100; /* { dg-error "" "type unsigned" } */
+char signed void *x101; /* { dg-error "" "char signed void" } */
+char signed char *x102; /* { dg-error "" "char signed char" } */
+char signed short *x103; /* { dg-error "" "char signed short" } */
+char signed int *x104; /* { dg-error "" "char signed int" } */
+char signed long *x105; /* { dg-error "" "char signed long" } */
+char signed float *x106; /* { dg-error "" "char signed float" } */
+char signed double *x107; /* { dg-error "" "char signed double" } */
+char signed signed *x108; /* { dg-error "" "char signed signed" } */
+char signed unsigned *x109; /* { dg-error "" "char signed unsigned" } */
+char unsigned void *x110; /* { dg-error "" "char unsigned void" } */
+char unsigned char *x111; /* { dg-error "" "char unsigned char" } */
+char unsigned short *x112; /* { dg-error "" "char unsigned short" } */
+char unsigned int *x113; /* { dg-error "" "char unsigned int" } */
+char unsigned long *x114; /* { dg-error "" "char unsigned long" } */
+char unsigned float *x115; /* { dg-error "" "char unsigned float" } */
+char unsigned double *x116; /* { dg-error "" "char unsigned double" } */
+char unsigned signed *x117; /* { dg-error "" "char unsigned signed" } */
+char unsigned unsigned *x118; /* { dg-error "" "char unsigned unsigned" } */
+short int void *x119; /* { dg-error "" "short int void" } */
+short int char *x120; /* { dg-error "" "short int char" } */
+short int short *x121; /* { dg-error "" "short int short" } */
+short int int *x122; /* { dg-error "" "short int int" } */
+short int long *x123; /* { dg-error "" "short int long" } */
+short int float *x124; /* { dg-error "" "short int float" } */
+short int double *x125; /* { dg-error "" "short int double" } */
+short int signed *x126;
+short int unsigned *x127;
+short signed void *x128; /* { dg-error "" "short signed void" } */
+short signed char *x129; /* { dg-error "" "short signed char" } */
+short signed short *x130; /* { dg-error "" "short signed short" } */
+short signed int *x131;
+short signed long *x132; /* { dg-error "" "short signed long" } */
+short signed float *x133; /* { dg-error "" "short signed float" } */
+short signed double *x134; /* { dg-error "" "short signed double" } */
+short signed signed *x135; /* { dg-error "" "short signed signed" } */
+short signed unsigned *x136; /* { dg-error "" "short signed unsigned" } */
+short unsigned void *x137; /* { dg-error "" "short unsigned void" } */
+short unsigned char *x138; /* { dg-error "" "short unsigned char" } */
+short unsigned short *x139; /* { dg-error "" "short unsigned short" } */
+short unsigned int *x140;
+short unsigned long *x141; /* { dg-error "" "short unsigned long" } */
+short unsigned float *x142; /* { dg-error "" "short unsigned float" } */
+short unsigned double *x143; /* { dg-error "" "short unsigned double" } */
+short unsigned signed *x144; /* { dg-error "" "short unsigned signed" } */
+short unsigned unsigned *x145; /* { dg-error "" "short unsigned unsigned" } */
+int short void *x146; /* { dg-error "" "int short void" } */
+int short char *x147; /* { dg-error "" "int short char" } */
+int short short *x148; /* { dg-error "" "int short short" } */
+int short int *x149; /* { dg-error "" "int short int" } */
+int short long *x150; /* { dg-error "" "int short long" } */
+int short float *x151; /* { dg-error "" "int short float" } */
+int short double *x152; /* { dg-error "" "int short double" } */
+int short signed *x153;
+int short unsigned *x154;
+int long void *x155; /* { dg-error "" "int long void" } */
+int long char *x156; /* { dg-error "" "int long char" } */
+int long short *x157; /* { dg-error "" "int long short" } */
+int long int *x158; /* { dg-error "" "int long int" } */
+int long long *x159;
+int long float *x160; /* { dg-error "" "int long float" } */
+int long double *x161; /* { dg-error "" "int long double" } */
+int long signed *x162;
+int long unsigned *x163;
+int signed void *x164; /* { dg-error "" "int signed void" } */
+int signed char *x165; /* { dg-error "" "int signed char" } */
+int signed short *x166;
+int signed int *x167; /* { dg-error "" "int signed int" } */
+int signed long *x168;
+int signed float *x169; /* { dg-error "" "int signed float" } */
+int signed double *x170; /* { dg-error "" "int signed double" } */
+int signed signed *x171; /* { dg-error "" "int signed signed" } */
+int signed unsigned *x172; /* { dg-error "" "int signed unsigned" } */
+int unsigned void *x173; /* { dg-error "" "int unsigned void" } */
+int unsigned char *x174; /* { dg-error "" "int unsigned char" } */
+int unsigned short *x175;
+int unsigned int *x176; /* { dg-error "" "int unsigned int" } */
+int unsigned long *x177;
+int unsigned float *x178; /* { dg-error "" "int unsigned float" } */
+int unsigned double *x179; /* { dg-error "" "int unsigned double" } */
+int unsigned signed *x180; /* { dg-error "" "int unsigned signed" } */
+int unsigned unsigned *x181; /* { dg-error "" "int unsigned unsigned" } */
+long int void *x182; /* { dg-error "" "long int void" } */
+long int char *x183; /* { dg-error "" "long int char" } */
+long int short *x184; /* { dg-error "" "long int short" } */
+long int int *x185; /* { dg-error "" "long int int" } */
+long int long *x186;
+long int float *x187; /* { dg-error "" "long int float" } */
+long int double *x188; /* { dg-error "" "long int double" } */
+long int signed *x189;
+long int unsigned *x190;
+long long void *x191; /* { dg-error "" "long long void" } */
+long long char *x192; /* { dg-error "" "long long char" } */
+long long short *x193; /* { dg-error "" "long long short" } */
+long long int *x194;
+long long long *x195; /* { dg-error "" "long long long" } */
+long long float *x196; /* { dg-error "" "long long float" } */
+long long double *x197; /* { dg-error "" "long long double" } */
+long long signed *x198;
+long long unsigned *x199;
+long double void *x200; /* { dg-error "" "long double void" } */
+long double char *x201; /* { dg-error "" "long double char" } */
+long double short *x202; /* { dg-error "" "long double short" } */
+long double int *x203; /* { dg-error "" "long double int" } */
+long double long *x204; /* { dg-error "" "long double long" } */
+long double float *x205; /* { dg-error "" "long double float" } */
+long double double *x206; /* { dg-error "" "long double double" } */
+long double signed *x207; /* { dg-error "" "long double signed" } */
+long double unsigned *x208; /* { dg-error "" "long double unsigned" } */
+long signed void *x209; /* { dg-error "" "long signed void" } */
+long signed char *x210; /* { dg-error "" "long signed char" } */
+long signed short *x211; /* { dg-error "" "long signed short" } */
+long signed int *x212;
+long signed long *x213;
+long signed float *x214; /* { dg-error "" "long signed float" } */
+long signed double *x215; /* { dg-error "" "long signed double" } */
+long signed signed *x216; /* { dg-error "" "long signed signed" } */
+long signed unsigned *x217; /* { dg-error "" "long signed unsigned" } */
+long unsigned void *x218; /* { dg-error "" "long unsigned void" } */
+long unsigned char *x219; /* { dg-error "" "long unsigned char" } */
+long unsigned short *x220; /* { dg-error "" "long unsigned short" } */
+long unsigned int *x221;
+long unsigned long *x222;
+long unsigned float *x223; /* { dg-error "" "long unsigned float" } */
+long unsigned double *x224; /* { dg-error "" "long unsigned double" } */
+long unsigned signed *x225; /* { dg-error "" "long unsigned signed" } */
+long unsigned unsigned *x226; /* { dg-error "" "long unsigned unsigned" } */
+double long void *x227; /* { dg-error "" "double long void" } */
+double long char *x228; /* { dg-error "" "double long char" } */
+double long short *x229; /* { dg-error "" "double long short" } */
+double long int *x230; /* { dg-error "" "double long int" } */
+double long long *x231; /* { dg-error "" "double long long" } */
+double long float *x232; /* { dg-error "" "double long float" } */
+double long double *x233; /* { dg-error "" "double long double" } */
+double long signed *x234; /* { dg-error "" "double long signed" } */
+double long unsigned *x235; /* { dg-error "" "double long unsigned" } */
+signed char void *x236; /* { dg-error "" "signed char void" } */
+signed char char *x237; /* { dg-error "" "signed char char" } */
+signed char short *x238; /* { dg-error "" "signed char short" } */
+signed char int *x239; /* { dg-error "" "signed char int" } */
+signed char long *x240; /* { dg-error "" "signed char long" } */
+signed char float *x241; /* { dg-error "" "signed char float" } */
+signed char double *x242; /* { dg-error "" "signed char double" } */
+signed char signed *x243; /* { dg-error "" "signed char signed" } */
+signed char unsigned *x244; /* { dg-error "" "signed char unsigned" } */
+signed short void *x245; /* { dg-error "" "signed short void" } */
+signed short char *x246; /* { dg-error "" "signed short char" } */
+signed short short *x247; /* { dg-error "" "signed short short" } */
+signed short int *x248;
+signed short long *x249; /* { dg-error "" "signed short long" } */
+signed short float *x250; /* { dg-error "" "signed short float" } */
+signed short double *x251; /* { dg-error "" "signed short double" } */
+signed short signed *x252; /* { dg-error "" "signed short signed" } */
+signed short unsigned *x253; /* { dg-error "" "signed short unsigned" } */
+signed int void *x254; /* { dg-error "" "signed int void" } */
+signed int char *x255; /* { dg-error "" "signed int char" } */
+signed int short *x256;
+signed int int *x257; /* { dg-error "" "signed int int" } */
+signed int long *x258;
+signed int float *x259; /* { dg-error "" "signed int float" } */
+signed int double *x260; /* { dg-error "" "signed int double" } */
+signed int signed *x261; /* { dg-error "" "signed int signed" } */
+signed int unsigned *x262; /* { dg-error "" "signed int unsigned" } */
+signed long void *x263; /* { dg-error "" "signed long void" } */
+signed long char *x264; /* { dg-error "" "signed long char" } */
+signed long short *x265; /* { dg-error "" "signed long short" } */
+signed long int *x266;
+signed long long *x267;
+signed long float *x268; /* { dg-error "" "signed long float" } */
+signed long double *x269; /* { dg-error "" "signed long double" } */
+signed long signed *x270; /* { dg-error "" "signed long signed" } */
+signed long unsigned *x271; /* { dg-error "" "signed long unsigned" } */
+unsigned char void *x272; /* { dg-error "" "unsigned char void" } */
+unsigned char char *x273; /* { dg-error "" "unsigned char char" } */
+unsigned char short *x274; /* { dg-error "" "unsigned char short" } */
+unsigned char int *x275; /* { dg-error "" "unsigned char int" } */
+unsigned char long *x276; /* { dg-error "" "unsigned char long" } */
+unsigned char float *x277; /* { dg-error "" "unsigned char float" } */
+unsigned char double *x278; /* { dg-error "" "unsigned char double" } */
+unsigned char signed *x279; /* { dg-error "" "unsigned char signed" } */
+unsigned char unsigned *x280; /* { dg-error "" "unsigned char unsigned" } */
+unsigned short void *x281; /* { dg-error "" "unsigned short void" } */
+unsigned short char *x282; /* { dg-error "" "unsigned short char" } */
+unsigned short short *x283; /* { dg-error "" "unsigned short short" } */
+unsigned short int *x284;
+unsigned short long *x285; /* { dg-error "" "unsigned short long" } */
+unsigned short float *x286; /* { dg-error "" "unsigned short float" } */
+unsigned short double *x287; /* { dg-error "" "unsigned short double" } */
+unsigned short signed *x288; /* { dg-error "" "unsigned short signed" } */
+unsigned short unsigned *x289; /* { dg-error "" "unsigned short unsigned" } */
+unsigned int void *x290; /* { dg-error "" "unsigned int void" } */
+unsigned int char *x291; /* { dg-error "" "unsigned int char" } */
+unsigned int short *x292;
+unsigned int int *x293; /* { dg-error "" "unsigned int int" } */
+unsigned int long *x294;
+unsigned int float *x295; /* { dg-error "" "unsigned int float" } */
+unsigned int double *x296; /* { dg-error "" "unsigned int double" } */
+unsigned int signed *x297; /* { dg-error "" "unsigned int signed" } */
+unsigned int unsigned *x298; /* { dg-error "" "unsigned int unsigned" } */
+unsigned long void *x299; /* { dg-error "" "unsigned long void" } */
+unsigned long char *x300; /* { dg-error "" "unsigned long char" } */
+unsigned long short *x301; /* { dg-error "" "unsigned long short" } */
+unsigned long int *x302;
+unsigned long long *x303;
+unsigned long float *x304; /* { dg-error "" "unsigned long float" } */
+unsigned long double *x305; /* { dg-error "" "unsigned long double" } */
+unsigned long signed *x306; /* { dg-error "" "unsigned long signed" } */
+unsigned long unsigned *x307; /* { dg-error "" "unsigned long unsigned" } */
+short int signed void *x308; /* { dg-error "" "short int signed void" } */
+short int signed char *x309; /* { dg-error "" "short int signed char" } */
+short int signed short *x310; /* { dg-error "" "short int signed short" } */
+short int signed int *x311; /* { dg-error "" "short int signed int" } */
+short int signed long *x312; /* { dg-error "" "short int signed long" } */
+short int signed float *x313; /* { dg-error "" "short int signed float" } */
+short int signed double *x314; /* { dg-error "" "short int signed double" } */
+short int signed signed *x315; /* { dg-error "" "short int signed signed" } */
+short int signed unsigned *x316; /* { dg-error "" "short int signed unsigned" } */
+short int unsigned void *x317; /* { dg-error "" "short int unsigned void" } */
+short int unsigned char *x318; /* { dg-error "" "short int unsigned char" } */
+short int unsigned short *x319; /* { dg-error "" "short int unsigned short" } */
+short int unsigned int *x320; /* { dg-error "" "short int unsigned int" } */
+short int unsigned long *x321; /* { dg-error "" "short int unsigned long" } */
+short int unsigned float *x322; /* { dg-error "" "short int unsigned float" } */
+short int unsigned double *x323; /* { dg-error "" "short int unsigned double" } */
+short int unsigned signed *x324; /* { dg-error "" "short int unsigned signed" } */
+short int unsigned unsigned *x325; /* { dg-error "" "short int unsigned unsigned" } */
+short signed int void *x326; /* { dg-error "" "short signed int void" } */
+short signed int char *x327; /* { dg-error "" "short signed int char" } */
+short signed int short *x328; /* { dg-error "" "short signed int short" } */
+short signed int int *x329; /* { dg-error "" "short signed int int" } */
+short signed int long *x330; /* { dg-error "" "short signed int long" } */
+short signed int float *x331; /* { dg-error "" "short signed int float" } */
+short signed int double *x332; /* { dg-error "" "short signed int double" } */
+short signed int signed *x333; /* { dg-error "" "short signed int signed" } */
+short signed int unsigned *x334; /* { dg-error "" "short signed int unsigned" } */
+short unsigned int void *x335; /* { dg-error "" "short unsigned int void" } */
+short unsigned int char *x336; /* { dg-error "" "short unsigned int char" } */
+short unsigned int short *x337; /* { dg-error "" "short unsigned int short" } */
+short unsigned int int *x338; /* { dg-error "" "short unsigned int int" } */
+short unsigned int long *x339; /* { dg-error "" "short unsigned int long" } */
+short unsigned int float *x340; /* { dg-error "" "short unsigned int float" } */
+short unsigned int double *x341; /* { dg-error "" "short unsigned int double" } */
+short unsigned int signed *x342; /* { dg-error "" "short unsigned int signed" } */
+short unsigned int unsigned *x343; /* { dg-error "" "short unsigned int unsigned" } */
+int short signed void *x344; /* { dg-error "" "int short signed void" } */
+int short signed char *x345; /* { dg-error "" "int short signed char" } */
+int short signed short *x346; /* { dg-error "" "int short signed short" } */
+int short signed int *x347; /* { dg-error "" "int short signed int" } */
+int short signed long *x348; /* { dg-error "" "int short signed long" } */
+int short signed float *x349; /* { dg-error "" "int short signed float" } */
+int short signed double *x350; /* { dg-error "" "int short signed double" } */
+int short signed signed *x351; /* { dg-error "" "int short signed signed" } */
+int short signed unsigned *x352; /* { dg-error "" "int short signed unsigned" } */
+int short unsigned void *x353; /* { dg-error "" "int short unsigned void" } */
+int short unsigned char *x354; /* { dg-error "" "int short unsigned char" } */
+int short unsigned short *x355; /* { dg-error "" "int short unsigned short" } */
+int short unsigned int *x356; /* { dg-error "" "int short unsigned int" } */
+int short unsigned long *x357; /* { dg-error "" "int short unsigned long" } */
+int short unsigned float *x358; /* { dg-error "" "int short unsigned float" } */
+int short unsigned double *x359; /* { dg-error "" "int short unsigned double" } */
+int short unsigned signed *x360; /* { dg-error "" "int short unsigned signed" } */
+int short unsigned unsigned *x361; /* { dg-error "" "int short unsigned unsigned" } */
+int long long void *x362; /* { dg-error "" "int long long void" } */
+int long long char *x363; /* { dg-error "" "int long long char" } */
+int long long short *x364; /* { dg-error "" "int long long short" } */
+int long long int *x365; /* { dg-error "" "int long long int" } */
+int long long long *x366; /* { dg-error "" "int long long long" } */
+int long long float *x367; /* { dg-error "" "int long long float" } */
+int long long double *x368; /* { dg-error "" "int long long double" } */
+int long long signed *x369;
+int long long unsigned *x370;
+int long signed void *x371; /* { dg-error "" "int long signed void" } */
+int long signed char *x372; /* { dg-error "" "int long signed char" } */
+int long signed short *x373; /* { dg-error "" "int long signed short" } */
+int long signed int *x374; /* { dg-error "" "int long signed int" } */
+int long signed long *x375;
+int long signed float *x376; /* { dg-error "" "int long signed float" } */
+int long signed double *x377; /* { dg-error "" "int long signed double" } */
+int long signed signed *x378; /* { dg-error "" "int long signed signed" } */
+int long signed unsigned *x379; /* { dg-error "" "int long signed unsigned" } */
+int long unsigned void *x380; /* { dg-error "" "int long unsigned void" } */
+int long unsigned char *x381; /* { dg-error "" "int long unsigned char" } */
+int long unsigned short *x382; /* { dg-error "" "int long unsigned short" } */
+int long unsigned int *x383; /* { dg-error "" "int long unsigned int" } */
+int long unsigned long *x384;
+int long unsigned float *x385; /* { dg-error "" "int long unsigned float" } */
+int long unsigned double *x386; /* { dg-error "" "int long unsigned double" } */
+int long unsigned signed *x387; /* { dg-error "" "int long unsigned signed" } */
+int long unsigned unsigned *x388; /* { dg-error "" "int long unsigned unsigned" } */
+int signed short void *x389; /* { dg-error "" "int signed short void" } */
+int signed short char *x390; /* { dg-error "" "int signed short char" } */
+int signed short short *x391; /* { dg-error "" "int signed short short" } */
+int signed short int *x392; /* { dg-error "" "int signed short int" } */
+int signed short long *x393; /* { dg-error "" "int signed short long" } */
+int signed short float *x394; /* { dg-error "" "int signed short float" } */
+int signed short double *x395; /* { dg-error "" "int signed short double" } */
+int signed short signed *x396; /* { dg-error "" "int signed short signed" } */
+int signed short unsigned *x397; /* { dg-error "" "int signed short unsigned" } */
+int signed long void *x398; /* { dg-error "" "int signed long void" } */
+int signed long char *x399; /* { dg-error "" "int signed long char" } */
+int signed long short *x400; /* { dg-error "" "int signed long short" } */
+int signed long int *x401; /* { dg-error "" "int signed long int" } */
+int signed long long *x402;
+int signed long float *x403; /* { dg-error "" "int signed long float" } */
+int signed long double *x404; /* { dg-error "" "int signed long double" } */
+int signed long signed *x405; /* { dg-error "" "int signed long signed" } */
+int signed long unsigned *x406; /* { dg-error "" "int signed long unsigned" } */
+int unsigned short void *x407; /* { dg-error "" "int unsigned short void" } */
+int unsigned short char *x408; /* { dg-error "" "int unsigned short char" } */
+int unsigned short short *x409; /* { dg-error "" "int unsigned short short" } */
+int unsigned short int *x410; /* { dg-error "" "int unsigned short int" } */
+int unsigned short long *x411; /* { dg-error "" "int unsigned short long" } */
+int unsigned short float *x412; /* { dg-error "" "int unsigned short float" } */
+int unsigned short double *x413; /* { dg-error "" "int unsigned short double" } */
+int unsigned short signed *x414; /* { dg-error "" "int unsigned short signed" } */
+int unsigned short unsigned *x415; /* { dg-error "" "int unsigned short unsigned" } */
+int unsigned long void *x416; /* { dg-error "" "int unsigned long void" } */
+int unsigned long char *x417; /* { dg-error "" "int unsigned long char" } */
+int unsigned long short *x418; /* { dg-error "" "int unsigned long short" } */
+int unsigned long int *x419; /* { dg-error "" "int unsigned long int" } */
+int unsigned long long *x420;
+int unsigned long float *x421; /* { dg-error "" "int unsigned long float" } */
+int unsigned long double *x422; /* { dg-error "" "int unsigned long double" } */
+int unsigned long signed *x423; /* { dg-error "" "int unsigned long signed" } */
+int unsigned long unsigned *x424; /* { dg-error "" "int unsigned long unsigned" } */
+long int long void *x425; /* { dg-error "" "long int long void" } */
+long int long char *x426; /* { dg-error "" "long int long char" } */
+long int long short *x427; /* { dg-error "" "long int long short" } */
+long int long int *x428; /* { dg-error "" "long int long int" } */
+long int long long *x429; /* { dg-error "" "long int long long" } */
+long int long float *x430; /* { dg-error "" "long int long float" } */
+long int long double *x431; /* { dg-error "" "long int long double" } */
+long int long signed *x432;
+long int long unsigned *x433;
+long int signed void *x434; /* { dg-error "" "long int signed void" } */
+long int signed char *x435; /* { dg-error "" "long int signed char" } */
+long int signed short *x436; /* { dg-error "" "long int signed short" } */
+long int signed int *x437; /* { dg-error "" "long int signed int" } */
+long int signed long *x438;
+long int signed float *x439; /* { dg-error "" "long int signed float" } */
+long int signed double *x440; /* { dg-error "" "long int signed double" } */
+long int signed signed *x441; /* { dg-error "" "long int signed signed" } */
+long int signed unsigned *x442; /* { dg-error "" "long int signed unsigned" } */
+long int unsigned void *x443; /* { dg-error "" "long int unsigned void" } */
+long int unsigned char *x444; /* { dg-error "" "long int unsigned char" } */
+long int unsigned short *x445; /* { dg-error "" "long int unsigned short" } */
+long int unsigned int *x446; /* { dg-error "" "long int unsigned int" } */
+long int unsigned long *x447;
+long int unsigned float *x448; /* { dg-error "" "long int unsigned float" } */
+long int unsigned double *x449; /* { dg-error "" "long int unsigned double" } */
+long int unsigned signed *x450; /* { dg-error "" "long int unsigned signed" } */
+long int unsigned unsigned *x451; /* { dg-error "" "long int unsigned unsigned" } */
+long long int void *x452; /* { dg-error "" "long long int void" } */
+long long int char *x453; /* { dg-error "" "long long int char" } */
+long long int short *x454; /* { dg-error "" "long long int short" } */
+long long int int *x455; /* { dg-error "" "long long int int" } */
+long long int long *x456; /* { dg-error "" "long long int long" } */
+long long int float *x457; /* { dg-error "" "long long int float" } */
+long long int double *x458; /* { dg-error "" "long long int double" } */
+long long int signed *x459;
+long long int unsigned *x460;
+long long signed void *x461; /* { dg-error "" "long long signed void" } */
+long long signed char *x462; /* { dg-error "" "long long signed char" } */
+long long signed short *x463; /* { dg-error "" "long long signed short" } */
+long long signed int *x464;
+long long signed long *x465; /* { dg-error "" "long long signed long" } */
+long long signed float *x466; /* { dg-error "" "long long signed float" } */
+long long signed double *x467; /* { dg-error "" "long long signed double" } */
+long long signed signed *x468; /* { dg-error "" "long long signed signed" } */
+long long signed unsigned *x469; /* { dg-error "" "long long signed unsigned" } */
+long long unsigned void *x470; /* { dg-error "" "long long unsigned void" } */
+long long unsigned char *x471; /* { dg-error "" "long long unsigned char" } */
+long long unsigned short *x472; /* { dg-error "" "long long unsigned short" } */
+long long unsigned int *x473;
+long long unsigned long *x474; /* { dg-error "" "long long unsigned long" } */
+long long unsigned float *x475; /* { dg-error "" "long long unsigned float" } */
+long long unsigned double *x476; /* { dg-error "" "long long unsigned double" } */
+long long unsigned signed *x477; /* { dg-error "" "long long unsigned signed" } */
+long long unsigned unsigned *x478; /* { dg-error "" "long long unsigned unsigned" } */
+long signed int void *x479; /* { dg-error "" "long signed int void" } */
+long signed int char *x480; /* { dg-error "" "long signed int char" } */
+long signed int short *x481; /* { dg-error "" "long signed int short" } */
+long signed int int *x482; /* { dg-error "" "long signed int int" } */
+long signed int long *x483;
+long signed int float *x484; /* { dg-error "" "long signed int float" } */
+long signed int double *x485; /* { dg-error "" "long signed int double" } */
+long signed int signed *x486; /* { dg-error "" "long signed int signed" } */
+long signed int unsigned *x487; /* { dg-error "" "long signed int unsigned" } */
+long signed long void *x488; /* { dg-error "" "long signed long void" } */
+long signed long char *x489; /* { dg-error "" "long signed long char" } */
+long signed long short *x490; /* { dg-error "" "long signed long short" } */
+long signed long int *x491;
+long signed long long *x492; /* { dg-error "" "long signed long long" } */
+long signed long float *x493; /* { dg-error "" "long signed long float" } */
+long signed long double *x494; /* { dg-error "" "long signed long double" } */
+long signed long signed *x495; /* { dg-error "" "long signed long signed" } */
+long signed long unsigned *x496; /* { dg-error "" "long signed long unsigned" } */
+long unsigned int void *x497; /* { dg-error "" "long unsigned int void" } */
+long unsigned int char *x498; /* { dg-error "" "long unsigned int char" } */
+long unsigned int short *x499; /* { dg-error "" "long unsigned int short" } */
+long unsigned int int *x500; /* { dg-error "" "long unsigned int int" } */
+long unsigned int long *x501;
+long unsigned int float *x502; /* { dg-error "" "long unsigned int float" } */
+long unsigned int double *x503; /* { dg-error "" "long unsigned int double" } */
+long unsigned int signed *x504; /* { dg-error "" "long unsigned int signed" } */
+long unsigned int unsigned *x505; /* { dg-error "" "long unsigned int unsigned" } */
+long unsigned long void *x506; /* { dg-error "" "long unsigned long void" } */
+long unsigned long char *x507; /* { dg-error "" "long unsigned long char" } */
+long unsigned long short *x508; /* { dg-error "" "long unsigned long short" } */
+long unsigned long int *x509;
+long unsigned long long *x510; /* { dg-error "" "long unsigned long long" } */
+long unsigned long float *x511; /* { dg-error "" "long unsigned long float" } */
+long unsigned long double *x512; /* { dg-error "" "long unsigned long double" } */
+long unsigned long signed *x513; /* { dg-error "" "long unsigned long signed" } */
+long unsigned long unsigned *x514; /* { dg-error "" "long unsigned long unsigned" } */
+signed short int void *x515; /* { dg-error "" "signed short int void" } */
+signed short int char *x516; /* { dg-error "" "signed short int char" } */
+signed short int short *x517; /* { dg-error "" "signed short int short" } */
+signed short int int *x518; /* { dg-error "" "signed short int int" } */
+signed short int long *x519; /* { dg-error "" "signed short int long" } */
+signed short int float *x520; /* { dg-error "" "signed short int float" } */
+signed short int double *x521; /* { dg-error "" "signed short int double" } */
+signed short int signed *x522; /* { dg-error "" "signed short int signed" } */
+signed short int unsigned *x523; /* { dg-error "" "signed short int unsigned" } */
+signed int short void *x524; /* { dg-error "" "signed int short void" } */
+signed int short char *x525; /* { dg-error "" "signed int short char" } */
+signed int short short *x526; /* { dg-error "" "signed int short short" } */
+signed int short int *x527; /* { dg-error "" "signed int short int" } */
+signed int short long *x528; /* { dg-error "" "signed int short long" } */
+signed int short float *x529; /* { dg-error "" "signed int short float" } */
+signed int short double *x530; /* { dg-error "" "signed int short double" } */
+signed int short signed *x531; /* { dg-error "" "signed int short signed" } */
+signed int short unsigned *x532; /* { dg-error "" "signed int short unsigned" } */
+signed int long void *x533; /* { dg-error "" "signed int long void" } */
+signed int long char *x534; /* { dg-error "" "signed int long char" } */
+signed int long short *x535; /* { dg-error "" "signed int long short" } */
+signed int long int *x536; /* { dg-error "" "signed int long int" } */
+signed int long long *x537;
+signed int long float *x538; /* { dg-error "" "signed int long float" } */
+signed int long double *x539; /* { dg-error "" "signed int long double" } */
+signed int long signed *x540; /* { dg-error "" "signed int long signed" } */
+signed int long unsigned *x541; /* { dg-error "" "signed int long unsigned" } */
+signed long int void *x542; /* { dg-error "" "signed long int void" } */
+signed long int char *x543; /* { dg-error "" "signed long int char" } */
+signed long int short *x544; /* { dg-error "" "signed long int short" } */
+signed long int int *x545; /* { dg-error "" "signed long int int" } */
+signed long int long *x546;
+signed long int float *x547; /* { dg-error "" "signed long int float" } */
+signed long int double *x548; /* { dg-error "" "signed long int double" } */
+signed long int signed *x549; /* { dg-error "" "signed long int signed" } */
+signed long int unsigned *x550; /* { dg-error "" "signed long int unsigned" } */
+signed long long void *x551; /* { dg-error "" "signed long long void" } */
+signed long long char *x552; /* { dg-error "" "signed long long char" } */
+signed long long short *x553; /* { dg-error "" "signed long long short" } */
+signed long long int *x554;
+signed long long long *x555; /* { dg-error "" "signed long long long" } */
+signed long long float *x556; /* { dg-error "" "signed long long float" } */
+signed long long double *x557; /* { dg-error "" "signed long long double" } */
+signed long long signed *x558; /* { dg-error "" "signed long long signed" } */
+signed long long unsigned *x559; /* { dg-error "" "signed long long unsigned" } */
+unsigned short int void *x560; /* { dg-error "" "unsigned short int void" } */
+unsigned short int char *x561; /* { dg-error "" "unsigned short int char" } */
+unsigned short int short *x562; /* { dg-error "" "unsigned short int short" } */
+unsigned short int int *x563; /* { dg-error "" "unsigned short int int" } */
+unsigned short int long *x564; /* { dg-error "" "unsigned short int long" } */
+unsigned short int float *x565; /* { dg-error "" "unsigned short int float" } */
+unsigned short int double *x566; /* { dg-error "" "unsigned short int double" } */
+unsigned short int signed *x567; /* { dg-error "" "unsigned short int signed" } */
+unsigned short int unsigned *x568; /* { dg-error "" "unsigned short int unsigned" } */
+unsigned int short void *x569; /* { dg-error "" "unsigned int short void" } */
+unsigned int short char *x570; /* { dg-error "" "unsigned int short char" } */
+unsigned int short short *x571; /* { dg-error "" "unsigned int short short" } */
+unsigned int short int *x572; /* { dg-error "" "unsigned int short int" } */
+unsigned int short long *x573; /* { dg-error "" "unsigned int short long" } */
+unsigned int short float *x574; /* { dg-error "" "unsigned int short float" } */
+unsigned int short double *x575; /* { dg-error "" "unsigned int short double" } */
+unsigned int short signed *x576; /* { dg-error "" "unsigned int short signed" } */
+unsigned int short unsigned *x577; /* { dg-error "" "unsigned int short unsigned" } */
+unsigned int long void *x578; /* { dg-error "" "unsigned int long void" } */
+unsigned int long char *x579; /* { dg-error "" "unsigned int long char" } */
+unsigned int long short *x580; /* { dg-error "" "unsigned int long short" } */
+unsigned int long int *x581; /* { dg-error "" "unsigned int long int" } */
+unsigned int long long *x582;
+unsigned int long float *x583; /* { dg-error "" "unsigned int long float" } */
+unsigned int long double *x584; /* { dg-error "" "unsigned int long double" } */
+unsigned int long signed *x585; /* { dg-error "" "unsigned int long signed" } */
+unsigned int long unsigned *x586; /* { dg-error "" "unsigned int long unsigned" } */
+unsigned long int void *x587; /* { dg-error "" "unsigned long int void" } */
+unsigned long int char *x588; /* { dg-error "" "unsigned long int char" } */
+unsigned long int short *x589; /* { dg-error "" "unsigned long int short" } */
+unsigned long int int *x590; /* { dg-error "" "unsigned long int int" } */
+unsigned long int long *x591;
+unsigned long int float *x592; /* { dg-error "" "unsigned long int float" } */
+unsigned long int double *x593; /* { dg-error "" "unsigned long int double" } */
+unsigned long int signed *x594; /* { dg-error "" "unsigned long int signed" } */
+unsigned long int unsigned *x595; /* { dg-error "" "unsigned long int unsigned" } */
+unsigned long long void *x596; /* { dg-error "" "unsigned long long void" } */
+unsigned long long char *x597; /* { dg-error "" "unsigned long long char" } */
+unsigned long long short *x598; /* { dg-error "" "unsigned long long short" } */
+unsigned long long int *x599;
+unsigned long long long *x600; /* { dg-error "" "unsigned long long long" } */
+unsigned long long float *x601; /* { dg-error "" "unsigned long long float" } */
+unsigned long long double *x602; /* { dg-error "" "unsigned long long double" } */
+unsigned long long signed *x603; /* { dg-error "" "unsigned long long signed" } */
+unsigned long long unsigned *x604; /* { dg-error "" "unsigned long long unsigned" } */
+int long long signed void *x605; /* { dg-error "" "int long long signed void" } */
+int long long signed char *x606; /* { dg-error "" "int long long signed char" } */
+int long long signed short *x607; /* { dg-error "" "int long long signed short" } */
+int long long signed int *x608; /* { dg-error "" "int long long signed int" } */
+int long long signed long *x609; /* { dg-error "" "int long long signed long" } */
+int long long signed float *x610; /* { dg-error "" "int long long signed float" } */
+int long long signed double *x611; /* { dg-error "" "int long long signed double" } */
+int long long signed signed *x612; /* { dg-error "" "int long long signed signed" } */
+int long long signed unsigned *x613; /* { dg-error "" "int long long signed unsigned" } */
+int long long unsigned void *x614; /* { dg-error "" "int long long unsigned void" } */
+int long long unsigned char *x615; /* { dg-error "" "int long long unsigned char" } */
+int long long unsigned short *x616; /* { dg-error "" "int long long unsigned short" } */
+int long long unsigned int *x617; /* { dg-error "" "int long long unsigned int" } */
+int long long unsigned long *x618; /* { dg-error "" "int long long unsigned long" } */
+int long long unsigned float *x619; /* { dg-error "" "int long long unsigned float" } */
+int long long unsigned double *x620; /* { dg-error "" "int long long unsigned double" } */
+int long long unsigned signed *x621; /* { dg-error "" "int long long unsigned signed" } */
+int long long unsigned unsigned *x622; /* { dg-error "" "int long long unsigned unsigned" } */
+int long signed long void *x623; /* { dg-error "" "int long signed long void" } */
+int long signed long char *x624; /* { dg-error "" "int long signed long char" } */
+int long signed long short *x625; /* { dg-error "" "int long signed long short" } */
+int long signed long int *x626; /* { dg-error "" "int long signed long int" } */
+int long signed long long *x627; /* { dg-error "" "int long signed long long" } */
+int long signed long float *x628; /* { dg-error "" "int long signed long float" } */
+int long signed long double *x629; /* { dg-error "" "int long signed long double" } */
+int long signed long signed *x630; /* { dg-error "" "int long signed long signed" } */
+int long signed long unsigned *x631; /* { dg-error "" "int long signed long unsigned" } */
+int long unsigned long void *x632; /* { dg-error "" "int long unsigned long void" } */
+int long unsigned long char *x633; /* { dg-error "" "int long unsigned long char" } */
+int long unsigned long short *x634; /* { dg-error "" "int long unsigned long short" } */
+int long unsigned long int *x635; /* { dg-error "" "int long unsigned long int" } */
+int long unsigned long long *x636; /* { dg-error "" "int long unsigned long long" } */
+int long unsigned long float *x637; /* { dg-error "" "int long unsigned long float" } */
+int long unsigned long double *x638; /* { dg-error "" "int long unsigned long double" } */
+int long unsigned long signed *x639; /* { dg-error "" "int long unsigned long signed" } */
+int long unsigned long unsigned *x640; /* { dg-error "" "int long unsigned long unsigned" } */
+int signed long long void *x641; /* { dg-error "" "int signed long long void" } */
+int signed long long char *x642; /* { dg-error "" "int signed long long char" } */
+int signed long long short *x643; /* { dg-error "" "int signed long long short" } */
+int signed long long int *x644; /* { dg-error "" "int signed long long int" } */
+int signed long long long *x645; /* { dg-error "" "int signed long long long" } */
+int signed long long float *x646; /* { dg-error "" "int signed long long float" } */
+int signed long long double *x647; /* { dg-error "" "int signed long long double" } */
+int signed long long signed *x648; /* { dg-error "" "int signed long long signed" } */
+int signed long long unsigned *x649; /* { dg-error "" "int signed long long unsigned" } */
+int unsigned long long void *x650; /* { dg-error "" "int unsigned long long void" } */
+int unsigned long long char *x651; /* { dg-error "" "int unsigned long long char" } */
+int unsigned long long short *x652; /* { dg-error "" "int unsigned long long short" } */
+int unsigned long long int *x653; /* { dg-error "" "int unsigned long long int" } */
+int unsigned long long long *x654; /* { dg-error "" "int unsigned long long long" } */
+int unsigned long long float *x655; /* { dg-error "" "int unsigned long long float" } */
+int unsigned long long double *x656; /* { dg-error "" "int unsigned long long double" } */
+int unsigned long long signed *x657; /* { dg-error "" "int unsigned long long signed" } */
+int unsigned long long unsigned *x658; /* { dg-error "" "int unsigned long long unsigned" } */
+long int long signed void *x659; /* { dg-error "" "long int long signed void" } */
+long int long signed char *x660; /* { dg-error "" "long int long signed char" } */
+long int long signed short *x661; /* { dg-error "" "long int long signed short" } */
+long int long signed int *x662; /* { dg-error "" "long int long signed int" } */
+long int long signed long *x663; /* { dg-error "" "long int long signed long" } */
+long int long signed float *x664; /* { dg-error "" "long int long signed float" } */
+long int long signed double *x665; /* { dg-error "" "long int long signed double" } */
+long int long signed signed *x666; /* { dg-error "" "long int long signed signed" } */
+long int long signed unsigned *x667; /* { dg-error "" "long int long signed unsigned" } */
+long int long unsigned void *x668; /* { dg-error "" "long int long unsigned void" } */
+long int long unsigned char *x669; /* { dg-error "" "long int long unsigned char" } */
+long int long unsigned short *x670; /* { dg-error "" "long int long unsigned short" } */
+long int long unsigned int *x671; /* { dg-error "" "long int long unsigned int" } */
+long int long unsigned long *x672; /* { dg-error "" "long int long unsigned long" } */
+long int long unsigned float *x673; /* { dg-error "" "long int long unsigned float" } */
+long int long unsigned double *x674; /* { dg-error "" "long int long unsigned double" } */
+long int long unsigned signed *x675; /* { dg-error "" "long int long unsigned signed" } */
+long int long unsigned unsigned *x676; /* { dg-error "" "long int long unsigned unsigned" } */
+long int signed long void *x677; /* { dg-error "" "long int signed long void" } */
+long int signed long char *x678; /* { dg-error "" "long int signed long char" } */
+long int signed long short *x679; /* { dg-error "" "long int signed long short" } */
+long int signed long int *x680; /* { dg-error "" "long int signed long int" } */
+long int signed long long *x681; /* { dg-error "" "long int signed long long" } */
+long int signed long float *x682; /* { dg-error "" "long int signed long float" } */
+long int signed long double *x683; /* { dg-error "" "long int signed long double" } */
+long int signed long signed *x684; /* { dg-error "" "long int signed long signed" } */
+long int signed long unsigned *x685; /* { dg-error "" "long int signed long unsigned" } */
+long int unsigned long void *x686; /* { dg-error "" "long int unsigned long void" } */
+long int unsigned long char *x687; /* { dg-error "" "long int unsigned long char" } */
+long int unsigned long short *x688; /* { dg-error "" "long int unsigned long short" } */
+long int unsigned long int *x689; /* { dg-error "" "long int unsigned long int" } */
+long int unsigned long long *x690; /* { dg-error "" "long int unsigned long long" } */
+long int unsigned long float *x691; /* { dg-error "" "long int unsigned long float" } */
+long int unsigned long double *x692; /* { dg-error "" "long int unsigned long double" } */
+long int unsigned long signed *x693; /* { dg-error "" "long int unsigned long signed" } */
+long int unsigned long unsigned *x694; /* { dg-error "" "long int unsigned long unsigned" } */
+long long int signed void *x695; /* { dg-error "" "long long int signed void" } */
+long long int signed char *x696; /* { dg-error "" "long long int signed char" } */
+long long int signed short *x697; /* { dg-error "" "long long int signed short" } */
+long long int signed int *x698; /* { dg-error "" "long long int signed int" } */
+long long int signed long *x699; /* { dg-error "" "long long int signed long" } */
+long long int signed float *x700; /* { dg-error "" "long long int signed float" } */
+long long int signed double *x701; /* { dg-error "" "long long int signed double" } */
+long long int signed signed *x702; /* { dg-error "" "long long int signed signed" } */
+long long int signed unsigned *x703; /* { dg-error "" "long long int signed unsigned" } */
+long long int unsigned void *x704; /* { dg-error "" "long long int unsigned void" } */
+long long int unsigned char *x705; /* { dg-error "" "long long int unsigned char" } */
+long long int unsigned short *x706; /* { dg-error "" "long long int unsigned short" } */
+long long int unsigned int *x707; /* { dg-error "" "long long int unsigned int" } */
+long long int unsigned long *x708; /* { dg-error "" "long long int unsigned long" } */
+long long int unsigned float *x709; /* { dg-error "" "long long int unsigned float" } */
+long long int unsigned double *x710; /* { dg-error "" "long long int unsigned double" } */
+long long int unsigned signed *x711; /* { dg-error "" "long long int unsigned signed" } */
+long long int unsigned unsigned *x712; /* { dg-error "" "long long int unsigned unsigned" } */
+long long signed int void *x713; /* { dg-error "" "long long signed int void" } */
+long long signed int char *x714; /* { dg-error "" "long long signed int char" } */
+long long signed int short *x715; /* { dg-error "" "long long signed int short" } */
+long long signed int int *x716; /* { dg-error "" "long long signed int int" } */
+long long signed int long *x717; /* { dg-error "" "long long signed int long" } */
+long long signed int float *x718; /* { dg-error "" "long long signed int float" } */
+long long signed int double *x719; /* { dg-error "" "long long signed int double" } */
+long long signed int signed *x720; /* { dg-error "" "long long signed int signed" } */
+long long signed int unsigned *x721; /* { dg-error "" "long long signed int unsigned" } */
+long long unsigned int void *x722; /* { dg-error "" "long long unsigned int void" } */
+long long unsigned int char *x723; /* { dg-error "" "long long unsigned int char" } */
+long long unsigned int short *x724; /* { dg-error "" "long long unsigned int short" } */
+long long unsigned int int *x725; /* { dg-error "" "long long unsigned int int" } */
+long long unsigned int long *x726; /* { dg-error "" "long long unsigned int long" } */
+long long unsigned int float *x727; /* { dg-error "" "long long unsigned int float" } */
+long long unsigned int double *x728; /* { dg-error "" "long long unsigned int double" } */
+long long unsigned int signed *x729; /* { dg-error "" "long long unsigned int signed" } */
+long long unsigned int unsigned *x730; /* { dg-error "" "long long unsigned int unsigned" } */
+long signed int long void *x731; /* { dg-error "" "long signed int long void" } */
+long signed int long char *x732; /* { dg-error "" "long signed int long char" } */
+long signed int long short *x733; /* { dg-error "" "long signed int long short" } */
+long signed int long int *x734; /* { dg-error "" "long signed int long int" } */
+long signed int long long *x735; /* { dg-error "" "long signed int long long" } */
+long signed int long float *x736; /* { dg-error "" "long signed int long float" } */
+long signed int long double *x737; /* { dg-error "" "long signed int long double" } */
+long signed int long signed *x738; /* { dg-error "" "long signed int long signed" } */
+long signed int long unsigned *x739; /* { dg-error "" "long signed int long unsigned" } */
+long signed long int void *x740; /* { dg-error "" "long signed long int void" } */
+long signed long int char *x741; /* { dg-error "" "long signed long int char" } */
+long signed long int short *x742; /* { dg-error "" "long signed long int short" } */
+long signed long int int *x743; /* { dg-error "" "long signed long int int" } */
+long signed long int long *x744; /* { dg-error "" "long signed long int long" } */
+long signed long int float *x745; /* { dg-error "" "long signed long int float" } */
+long signed long int double *x746; /* { dg-error "" "long signed long int double" } */
+long signed long int signed *x747; /* { dg-error "" "long signed long int signed" } */
+long signed long int unsigned *x748; /* { dg-error "" "long signed long int unsigned" } */
+long unsigned int long void *x749; /* { dg-error "" "long unsigned int long void" } */
+long unsigned int long char *x750; /* { dg-error "" "long unsigned int long char" } */
+long unsigned int long short *x751; /* { dg-error "" "long unsigned int long short" } */
+long unsigned int long int *x752; /* { dg-error "" "long unsigned int long int" } */
+long unsigned int long long *x753; /* { dg-error "" "long unsigned int long long" } */
+long unsigned int long float *x754; /* { dg-error "" "long unsigned int long float" } */
+long unsigned int long double *x755; /* { dg-error "" "long unsigned int long double" } */
+long unsigned int long signed *x756; /* { dg-error "" "long unsigned int long signed" } */
+long unsigned int long unsigned *x757; /* { dg-error "" "long unsigned int long unsigned" } */
+long unsigned long int void *x758; /* { dg-error "" "long unsigned long int void" } */
+long unsigned long int char *x759; /* { dg-error "" "long unsigned long int char" } */
+long unsigned long int short *x760; /* { dg-error "" "long unsigned long int short" } */
+long unsigned long int int *x761; /* { dg-error "" "long unsigned long int int" } */
+long unsigned long int long *x762; /* { dg-error "" "long unsigned long int long" } */
+long unsigned long int float *x763; /* { dg-error "" "long unsigned long int float" } */
+long unsigned long int double *x764; /* { dg-error "" "long unsigned long int double" } */
+long unsigned long int signed *x765; /* { dg-error "" "long unsigned long int signed" } */
+long unsigned long int unsigned *x766; /* { dg-error "" "long unsigned long int unsigned" } */
+signed int long long void *x767; /* { dg-error "" "signed int long long void" } */
+signed int long long char *x768; /* { dg-error "" "signed int long long char" } */
+signed int long long short *x769; /* { dg-error "" "signed int long long short" } */
+signed int long long int *x770; /* { dg-error "" "signed int long long int" } */
+signed int long long long *x771; /* { dg-error "" "signed int long long long" } */
+signed int long long float *x772; /* { dg-error "" "signed int long long float" } */
+signed int long long double *x773; /* { dg-error "" "signed int long long double" } */
+signed int long long signed *x774; /* { dg-error "" "signed int long long signed" } */
+signed int long long unsigned *x775; /* { dg-error "" "signed int long long unsigned" } */
+signed long int long void *x776; /* { dg-error "" "signed long int long void" } */
+signed long int long char *x777; /* { dg-error "" "signed long int long char" } */
+signed long int long short *x778; /* { dg-error "" "signed long int long short" } */
+signed long int long int *x779; /* { dg-error "" "signed long int long int" } */
+signed long int long long *x780; /* { dg-error "" "signed long int long long" } */
+signed long int long float *x781; /* { dg-error "" "signed long int long float" } */
+signed long int long double *x782; /* { dg-error "" "signed long int long double" } */
+signed long int long signed *x783; /* { dg-error "" "signed long int long signed" } */
+signed long int long unsigned *x784; /* { dg-error "" "signed long int long unsigned" } */
+signed long long int void *x785; /* { dg-error "" "signed long long int void" } */
+signed long long int char *x786; /* { dg-error "" "signed long long int char" } */
+signed long long int short *x787; /* { dg-error "" "signed long long int short" } */
+signed long long int int *x788; /* { dg-error "" "signed long long int int" } */
+signed long long int long *x789; /* { dg-error "" "signed long long int long" } */
+signed long long int float *x790; /* { dg-error "" "signed long long int float" } */
+signed long long int double *x791; /* { dg-error "" "signed long long int double" } */
+signed long long int signed *x792; /* { dg-error "" "signed long long int signed" } */
+signed long long int unsigned *x793; /* { dg-error "" "signed long long int unsigned" } */
+unsigned int long long void *x794; /* { dg-error "" "unsigned int long long void" } */
+unsigned int long long char *x795; /* { dg-error "" "unsigned int long long char" } */
+unsigned int long long short *x796; /* { dg-error "" "unsigned int long long short" } */
+unsigned int long long int *x797; /* { dg-error "" "unsigned int long long int" } */
+unsigned int long long long *x798; /* { dg-error "" "unsigned int long long long" } */
+unsigned int long long float *x799; /* { dg-error "" "unsigned int long long float" } */
+unsigned int long long double *x800; /* { dg-error "" "unsigned int long long double" } */
+unsigned int long long signed *x801; /* { dg-error "" "unsigned int long long signed" } */
+unsigned int long long unsigned *x802; /* { dg-error "" "unsigned int long long unsigned" } */
+unsigned long int long void *x803; /* { dg-error "" "unsigned long int long void" } */
+unsigned long int long char *x804; /* { dg-error "" "unsigned long int long char" } */
+unsigned long int long short *x805; /* { dg-error "" "unsigned long int long short" } */
+unsigned long int long int *x806; /* { dg-error "" "unsigned long int long int" } */
+unsigned long int long long *x807; /* { dg-error "" "unsigned long int long long" } */
+unsigned long int long float *x808; /* { dg-error "" "unsigned long int long float" } */
+unsigned long int long double *x809; /* { dg-error "" "unsigned long int long double" } */
+unsigned long int long signed *x810; /* { dg-error "" "unsigned long int long signed" } */
+unsigned long int long unsigned *x811; /* { dg-error "" "unsigned long int long unsigned" } */
+unsigned long long int void *x812; /* { dg-error "" "unsigned long long int void" } */
+unsigned long long int char *x813; /* { dg-error "" "unsigned long long int char" } */
+unsigned long long int short *x814; /* { dg-error "" "unsigned long long int short" } */
+unsigned long long int int *x815; /* { dg-error "" "unsigned long long int int" } */
+unsigned long long int long *x816; /* { dg-error "" "unsigned long long int long" } */
+unsigned long long int float *x817; /* { dg-error "" "unsigned long long int float" } */
+unsigned long long int double *x818; /* { dg-error "" "unsigned long long int double" } */
+unsigned long long int signed *x819; /* { dg-error "" "unsigned long long int signed" } */
+unsigned long long int unsigned *x820; /* { dg-error "" "unsigned long long int unsigned" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-1.c
new file mode 100644
index 000000000..a2c7fe642
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-1.c
@@ -0,0 +1,20 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   Simplified from gcc/fold-const.c
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do compile } */
+
+void
+mul_double ()
+{
+  int i, j, *prod;
+
+  for (i = 0; i < 4; i++)
+    {
+      for (j = 0; j < 4; j++)
+        {
+          *prod = 0;
+        }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-2.c
new file mode 100644
index 000000000..fa96f8927
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-2.c
@@ -0,0 +1,23 @@
+/* PR optimization/10171 */
+/* Bug: unroll_loop misoptimized the function so that we got
+   0 iterations of the loop rather than the correct 1.  */
+/* { dg-do run } */
+
+extern void abort (void);
+extern void exit (int);
+
+__inline__ int tag() { return 0; }
+
+void f ();
+
+int main() {
+  int i;
+  for (i = 0; i < (tag() ? 2 : 1); i++)
+    f();
+  abort ();
+}
+
+void f ()
+{
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-3.c
new file mode 100644
index 000000000..06428d92f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-3.c
@@ -0,0 +1,45 @@
+/* PR optimization/13985 */
+/* Copied from gcc.c-torture/compile/930621-1.c */
+
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+/* { dg-options "-O3 -mtune=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#if defined(STACK_SIZE) && (STACK_SIZE < 65536)
+# define BYTEMEM_SIZE 10000L
+#endif
+
+#ifndef BYTEMEM_SIZE
+# define BYTEMEM_SIZE 45000L
+#endif
+
+int bytestart[5000 + 1];
+unsigned char modtext[400 + 1];
+unsigned char bytemem[2][BYTEMEM_SIZE + 1];
+
+long
+modlookup (int l)
+{
+  signed char c;
+  long j;
+  long k;
+  signed char w;
+  long p;
+  while (p != 0)
+    {
+      while ((k < bytestart[p + 2]) && (j <= l) && (modtext[j] == bytemem[w][k]))
+	{
+	  k = k + 1;
+	  j = j + 1;
+	}
+      if (k == bytestart[p + 2])
+	if (j > l)
+	  c = 1;
+	else c = 4;
+      else if (j > l)
+	c = 3;
+      else if (modtext[j] < bytemem[w][k])
+	c = 0;
+      else c = 2;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-4.c
new file mode 100644
index 000000000..c83fd1c0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-4.c
@@ -0,0 +1,25 @@
+/* PR optimization/11841 */
+/* Originator: Andrey Panov <panov@canopus.iacp.dvo.ru> */
+/* Reduced testcase by Volker Reichelt <reichelt@igpm.rwth-aachen.de> */
+
+/* Verify that the (old) loop unroller doesn't wrongly mark a pseudo
+   referenced in a note as local.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -funroll-loops" } */
+
+int *a;
+
+int main()
+{
+  double d[6];
+  int i, j;
+
+  for (i=0; i<4; ++i)
+    for (j=0; j<3; ++j)
+      d[i+j] = 0;
+
+  a = &i;
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-5.c
new file mode 100644
index 000000000..198823b19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-5.c
@@ -0,0 +1,16 @@
+/* PR c/16180 */
+/* { dg-options "-O2" } */
+
+extern int b;
+int foo (int a)
+{
+  if (a)
+    {
+      b = 0;
+      for(;;)
+	goto L;
+    }
+ L:
+  for(;;)
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-6.c
new file mode 100644
index 000000000..653854eb8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-6.c
@@ -0,0 +1,25 @@
+/* PR optimization/18577 */
+/* Origin: Falk Hueffner <falk@debian.org> */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -funroll-all-loops" } */
+
+static float tfcos12[3];
+__attribute__((noinline)) double f(double x) { return x; }
+int g;
+
+int main(void)
+{
+  int i, j;
+  for (i = 0; i < 1; i++) 
+    tfcos12[i] = 0.5;
+    
+  for (i = 0; i < 1; i++)
+    {
+      tfcos12[i] = 0.5 * f(i);
+      for (j = 0; j < 12; j++)
+	g++;
+    }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-7.c
new file mode 100644
index 000000000..0457add9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-7.c
@@ -0,0 +1,16 @@
+/* PR rtl-optimization/31360  */
+
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-options "-O1 -fdump-rtl-loop2_invariant" } */
+
+void f(int *a)
+{
+  int i;
+  for (i = 0;i<100;i++)
+    a[i] = 0;
+}
+
+/* Load of 0 is moved out of the loop.  */
+/* { dg-final { scan-rtl-dump-times "Decided" 1 "loop2_invariant" } } */
+/* { dg-final { cleanup-rtl-dump "loop2_invariant" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-unswitch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-unswitch-1.c
new file mode 100644
index 000000000..930364c81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/loop-unswitch-1.c
@@ -0,0 +1,34 @@
+/* For PR rtl-optimization/27735  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -funswitch-loops" } */
+
+void set_color(void);
+void xml_colorize_line(unsigned int *p, int state)
+{
+  int c;
+  switch(state) 
+    {
+    case 1:
+      goto parse_tag;
+    case 2:
+      goto parse_comment;
+    }
+
+  for(;;) 
+    {
+      c = *p;  
+      if (c == '<' && state == 0) 
+	{
+parse_comment: ;
+	  while (*p != '\n') 
+	    state = 3;
+parse_tag: ;
+	  while (*p != '\n') 
+	    state = 0;
+	  set_color();
+	}
+      else
+	p++;
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/lower-subreg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/lower-subreg-1.c
new file mode 100644
index 000000000..4de90bd99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/lower-subreg-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile { target { { { ! mips64 } && { ! ia64-*-* } } && { ! spu-*-* } } } } */
+/* { dg-options "-O -fdump-rtl-subreg1" } */
+/* { dg-require-effective-target ilp32 } */
+
+long long test (long long a, long long b) { return a | b; }
+
+/* { dg-final { scan-rtl-dump "Splitting reg" "subreg1" } } */
+/* { dg-final { cleanup-rtl-dump "subreg1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-2.c
new file mode 100644
index 000000000..a6f880962
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-2.c
@@ -0,0 +1,48 @@
+/* Test diagnostic messages for invalid lvalues and non-modifiable
+   lvalues.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int a, b;
+
+void
+f0 (void)
+{
+  (a+b) = 1; /* { dg-error "lvalue required as left operand of assignment" } */
+  (a+b)++; /* { dg-error "lvalue required as increment operand" } */
+  ++(a+b); /* { dg-error "lvalue required as increment operand" } */
+  (a+b)--; /* { dg-error "lvalue required as decrement operand" } */
+  --(a+b); /* { dg-error "lvalue required as decrement operand" } */
+  &(a+b); /* { dg-error "lvalue required as unary '&' operand" } */
+}
+
+const int c;
+const struct { int x; } d;
+struct { const int x; } e;
+const int *f;
+
+void
+f1 (void)
+{
+  c = 1; /* { dg-error "assignment of read-only variable 'c'" } */
+  d.x = 1; /* { dg-error "assignment of read-only variable 'd'" } */
+  e.x = 1; /* { dg-error "assignment of read-only member 'x'" } */
+  *f = 1; /* { dg-error "assignment of read-only location" } */
+  c++; /* { dg-error "increment of read-only variable 'c'" } */
+  d.x++; /* { dg-error "increment of read-only variable 'd'" } */
+  e.x++; /* { dg-error "increment of read-only member 'x'" } */
+  (*f)++; /* { dg-error "increment of read-only location" } */
+  ++c; /* { dg-error "increment of read-only variable 'c'" } */
+  ++d.x; /* { dg-error "increment of read-only variable 'd'" } */
+  ++e.x; /* { dg-error "increment of read-only member 'x'" } */
+  ++(*f); /* { dg-error "increment of read-only location" } */
+  c--; /* { dg-error "decrement of read-only variable 'c'" } */
+  d.x--; /* { dg-error "decrement of read-only variable 'd'" } */
+  e.x--; /* { dg-error "decrement of read-only member 'x'" } */
+  (*f)--; /* { dg-error "decrement of read-only location" } */
+  --c; /* { dg-error "decrement of read-only variable 'c'" } */
+  --d.x; /* { dg-error "decrement of read-only variable 'd'" } */
+  --e.x; /* { dg-error "decrement of read-only member 'x'" } */
+  --(*f); /* { dg-error "decrement of read-only location" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-3.c
new file mode 100644
index 000000000..6a500d4d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-3.c
@@ -0,0 +1,14 @@
+/* Test that assignment of a read-only variable that gets const-ness
+   from a read-only field is diagnosed.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s { const int a; } x;
+typeof (x.a) b;
+void
+f (void)
+{
+  x.a = 1; /* { dg-error "assignment of read-only member 'a'" } */
+  b = 1; /* { dg-error "assignment of read-only variable 'b'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-4.c
new file mode 100644
index 000000000..bc9290134
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue-4.c
@@ -0,0 +1,8 @@
+/* PR c/27721 */
+/* { dg-do compile } */
+
+void foo()
+{
+  int i();
+  i += 0;  /* { dg-error "lvalue required" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue1.c
new file mode 100644
index 000000000..67b013078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/lvalue1.c
@@ -0,0 +1,9 @@
+/* PR c/5225 */
+/* { dg-do compile } */
+
+int main()
+{
+  int i;
+  +i = 1;	/* { dg-error "lvalue required as left operand of assignment" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/m-un-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/m-un-1.c
new file mode 100644
index 000000000..ad84d44ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/m-un-1.c
@@ -0,0 +1,37 @@
+/* m-un-1.c: "un" for "uninitialized" */
+
+/*
+From: Jim Wilson <wilson@cygnus.com>
+Date: Wed, 6 Jul 1994 13:11:47 -0700
+To: dje@cygnus.com
+Subject: Re: devo/gcc ChangeLog.fsf stmt.c
+Cc: cvs-gcc@cygnus.com, tege@cygnus.com
+
+	How about a test case?  :-)
+
+Compile with -O -Wall and the broken compiler gives you:
+tmp.c:6: warning: `k' might be used uninitialized in this function
+The fixed compiler (and gcc 2.5.8) gives no warning.
+
+This happens to fix a performance regression in the code generated for
+while loops, but that is presumably much much harder to test for.
+*/
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+int
+sub ()
+{
+  int i = 0;
+  int j = 0;
+  int k;	/* { dg-bogus "`k' might be used uninitialized" "uninitialized warning regression" } */
+
+  while (i == 0 && j == 0)
+    {
+      k = 10;
+      i = sub ();
+    }
+
+  return k;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/m-un-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/m-un-2.c
new file mode 100644
index 000000000..0d280bb57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/m-un-2.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-W -Wall" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern void* malloc (size_t);
+extern void free (void*);
+extern void* realloc (void*, size_t);
+
+struct vtable {
+  void* (* _malloc) (size_t);
+  void (* _free) (void*);
+  void* (* _realloc) (void*, size_t);
+};
+
+struct vtable mtable = {
+  malloc,
+  free
+}; /* { dg-warning "missing initializer" "warning regression" { target *-*-* } {18} } */
+   /* { dg-warning "initialization for 'mtable._realloc'" "warning regression 2" { target *-*-* } {18} } */
+
+/* With designated initializers, we assume you meant to leave out the
+   initialization of any blank fields.  */
+struct vtable mtable2 = {
+  ._malloc = malloc,
+  ._realloc = realloc
+};
+
+struct vtable mtable3 = {
+  ._free = free,
+  ._malloc = malloc,
+  ._realloc = realloc
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/macro-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/macro-1.c
new file mode 100644
index 000000000..e1d9d34cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/macro-1.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+
+short array[3] __attribute__ ((aligned (__BIGGEST_ALIGNMENT__)));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/mallign.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/mallign.c
new file mode 100644
index 000000000..6a0041e64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/mallign.c
@@ -0,0 +1,15 @@
+/* Check that malloc's alignment honors what we trust it
+   minimally should.  */
+
+/* { dg-do run } */
+/* { dg-options "-fno-builtin-malloc" } */
+
+#include <stdlib.h>                                                            
+typedef int word __attribute__((mode(word)));
+
+int main()
+{
+    if ((size_t)malloc (1) & (sizeof(word)-1))
+	abort ();
+    return 0;
+}                                                                              
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-1.c
new file mode 100644
index 000000000..ac2fd6ced
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-1.c
@@ -0,0 +1,92 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The whole matrix VEL is flattened (3 dimensions).  */
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k, id;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+  mem_init ();
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-2.c
new file mode 100644
index 000000000..318faa54e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-2.c
@@ -0,0 +1,115 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void);
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The last dimension of VEL escapes because of
+   the assignment : vel[1][1] =...
+   Only the two external dimensions are flattened.  */
+
+
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      printf ("%x\n",vel[i][j]);
+      /*if (i!=1 || j!=1)*/
+      /*if (i==1 && j==1)
+        continue;
+      else
+        free (vel[i][j]);*/
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+          printf ("%x %d %d\n",vel[i][j], ARCHnodes1, sizeof (int));
+	}
+    }
+   for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+        {
+          printf ("%x\n",vel[i][j]);
+        }
+    }
+
+  printf ("again:\n\n");
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  printf ("%x\n",vel[i][j]);
+          /*for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }*/
+	}
+    }
+  /*vel[1][1] = vel[0][1];*/
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-3.c
new file mode 100644
index 000000000..5990abf48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-3.c
@@ -0,0 +1,101 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-matrix-reorg -fdump-ipa-matrix-reorg -c -fwhole-program -combine"  } */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void);
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+void just_a_call (int *);
+
+/* The last dimension of VEL escapes because it was sent
+   as argumet to just_a_call(). (external function)
+   Only the two external dimensions are flattened.
+   Run with -c.  */
+
+
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  just_a_call (vel[1][1]);
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-4.c
new file mode 100644
index 000000000..7ca79ec4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-4.c
@@ -0,0 +1,99 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fipa-matrix-reorg -fdump-ipa-matrix-reorg -c -fwhole-program -combine"  } */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void);
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+void just_a_call (int ****);
+
+/* Address of VEL is taken.
+   It is not flattened.  */
+
+
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  just_a_call (&vel);
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump-times "Flattened" 0 "matrix-reorg"  } } */
+/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-5.c
new file mode 100644
index 000000000..1398c5b42
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-5.c
@@ -0,0 +1,98 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void);
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The two inner dimesions of matrix escape because of the 
+   assignment vel[1]= ...
+   VEL is not Flattened. */
+
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes-1; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes-1; i++)
+      free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  vel[1] = vel[0];
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump-times "Flattened" 0 "matrix-reorg"  } } */
+/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-6.c
new file mode 100644
index 000000000..536afb537
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix-6.c
@@ -0,0 +1,97 @@
+/* { dg-do compile } */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void);
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The last dimension of VEL escapes because of
+   the assignment : *vel[1] =...
+   Only the two external dimensions are flattened.  */
+
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  *vel[1] = &d;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix.exp
new file mode 100644
index 000000000..b2f4ede94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/matrix.exp
@@ -0,0 +1,64 @@
+#   Copyright (C) 2001, 2002, 2004, 2005, 2007 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/>.
+
+# Test the functionality of programs compiled with profile-directed block
+# ordering using -fprofile-generate followed by -fbranch-use.
+load_lib gcc-dg.exp
+load_lib target-supports.exp
+
+set DEFAULT_MATCFLAGS "-O3 -fipa-matrix-reorg -fdump-ipa-matrix-reorg -fwhole-program -combine"
+
+# Initialize `dg'.
+dg-init
+
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/matrix-\[1-6\].\[cS\]]]  \
+        "" $DEFAULT_MATCFLAGS
+
+dg-final
+
+# Some targets don't support tree profiling.
+if { ![check_profiling_available ""] } {
+    return
+}
+
+# The procedures in profopt.exp need these parameters.
+set tool gcc
+set prof_ext "gcda"
+
+# Override the list defined in profopt.exp.
+set PROFOPT_OPTIONS [list {}]
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+# Load support procs.
+load_lib profopt.exp
+
+# These are globals used by profopt-execute.  The first is options
+# needed to generate profile data, the second is options to use the
+# profile data.
+set profile_option "-fprofile-generate -O3"
+set feedback_option "-fprofile-use -fipa-matrix-reorg -fdump-ipa-matrix-reorg -O3 -fwhole-program -combine"
+
+foreach src [lsort [glob -nocomplain $srcdir/$subdir/transpose-*.c]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $src] then {
+        continue
+    }
+    profopt-execute $src
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-1.c
new file mode 100644
index 000000000..c58c5dced
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-1.c
@@ -0,0 +1,97 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The whole matrix VEL is flattened (3 dimensions).  
+   All dimensions are transposed : dim 0 -> dim 2
+                                   dim 1 -> dim 0
+                                   dim 2 -> dim 1 
+*/
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (i = 0; i < 3; i++)
+    {
+      for (j = 0; j < 4; j++)
+	{
+	  for (k = 0; k < 2; k++)
+	{
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[k][i][j]);
+	}
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final-use { scan-ipa-dump-times "Transposed" 3 "matrix-reorg"  } } */
+/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-2.c
new file mode 100644
index 000000000..ef74b8896
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-2.c
@@ -0,0 +1,95 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The whole matrix VEL is flattened (3 dimensions).  
+   No transposing is necessary.  */
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (j = 0; j < 2; j++)
+    {
+      for (i = 0; i < 4; i++)
+	{
+	  for (k = 0; k < 2; k++)
+	{
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[k][k][k]);
+	}
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < ARCHnodes; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final-use { scan-ipa-dump-times "Transposed" 0 "matrix-reorg"  } } */
+/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-3.c
new file mode 100644
index 000000000..a9281735e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-3.c
@@ -0,0 +1,101 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+/* The inner most dimension escapes. 
+   The two external dimensions are flattened 
+   after being transposed.  */
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (j = 0; j < 4; j++)
+    {
+      for (i = 0; i < 3; i++)
+	{
+	  for (k = 0; k < 2; k++)
+	   {
+ 	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[k][i][j]);
+           }
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  vel[0][0]=vel[1][1];
+
+  for (i = 0; i < 2; i++)
+    for (j = 0; j < 3; j++)
+      if (i==1 && j==1)
+        continue;
+      else
+        free (vel[i][j]);
+
+  for (i = 0; i < 2; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  signed int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+              printf ("acc to dim2 ");
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  printf ("\n");
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump-times "Flattened 2 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final-use { scan-ipa-dump-times "Transposed" 2 "matrix-reorg"  } } */
+/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-4.c
new file mode 100644
index 000000000..f42ac9322
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-4.c
@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The whole matrix VEL is flattened (3 dimensions).  
+   The two inner dimensions are transposed.  
+                                    dim 1 -> dim 2
+                                    dim 2 -> dim 1
+*/
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (j = 0; j < 4; j++)
+    {
+      for (i = 0; i < 2; i++)
+	{
+	  for (k = 0; k < 3; k++)
+	{
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][k][j]);
+	}
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < 2; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < 2; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  signed int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+              printf ("acc to dim2 ");
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  printf ("\n");
+
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final-use { scan-ipa-dump-times "Transposed" 2 "matrix-reorg"  } } */
+/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-5.c
new file mode 100644
index 000000000..fc6cbdf3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-5.c
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The whole matrix VEL is flattened (3 dimensions).  
+   The dimensions are NOT transposed.  */
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (j = 0; j < 3; j++)
+    {
+      for (i = 0; i < 2; i++)
+	{
+	  for (k = 0; k < 4; k++)
+	{
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][j][k]);
+	}
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < 2; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < 2; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  signed int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+              printf ("acc to dim2 ");
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  printf ("\n");
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final-use { scan-ipa-dump-times "Transposed" 0 "matrix-reorg"  } } */
+/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-6.c
new file mode 100644
index 000000000..2902fc023
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/matrix/transpose-6.c
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+void mem_init (void) __attribute__ ((noinline));
+int ARCHnodes, ARCHnodes1;
+int ***vel;
+
+/* The whole matrix VEL is flattened (3 dimensions).  
+   The dimensions are NOT transposed.  */
+/*--------------------------------------------------------------------------*/
+
+int
+main (int argc, char **argv)
+{
+  int i, j, k;
+
+  ARCHnodes = 2;
+  ARCHnodes1 = 4;
+
+/* Dynamic memory allocations and initializations */
+
+  mem_init ();
+
+  for (j = 0; j < 3; j++)
+    {
+      for (i = 0; i < 2; i++)
+	{
+	  for (k = 0; k < 3; k++)
+	{
+	    printf ("[%d][%d][%d]=%d ", i, j, k, vel[i][k][k]);
+	}
+	  printf ("\n");
+	}
+      printf ("\n");
+    }
+  for (i = 0; i < 2; i++)
+    for (j = 0; j < 3; j++)
+      free (vel[i][j]);
+
+  for (i = 0; i < 2; i++)
+    free (vel[i]);
+
+  free (vel);
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Dynamic memory allocations and initializations                           */
+
+void
+mem_init (void)
+{
+
+  signed int i, j, k,d;
+ 
+  d = 0;
+  vel = (int ***) malloc (ARCHnodes * sizeof (int **));
+
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      vel[i] = (int **) malloc (3 * sizeof (int *));
+      if (vel[i] == (int **) NULL)
+	{
+	  fprintf (stderr, "malloc failed for vel[%d]\n", i);
+	  fflush (stderr);
+	  exit (0);
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  vel[i][j] = (int *) malloc (ARCHnodes1 * sizeof (int));
+	}
+    }
+  for (i = 0; i < ARCHnodes; i++)
+    {
+      for (j = 0; j < 3; j++)
+	{
+	  for (k = 0; k < ARCHnodes1; k++)
+	    {
+              printf ("acc to dim2 ");
+	      vel[i][j][k] = d;
+	      d++;
+	    }
+	}
+    }
+  printf ("\n");
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump-times "Flattened 3 dimensions" 1 "matrix-reorg"  } } */
+/* { dg-final-use { scan-ipa-dump-times "Transposed" 0 "matrix-reorg"  } } */
+/* { dg-final-use { cleanup-ipa-dump "matrix-reorg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/max-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/max-1.c
new file mode 100644
index 000000000..40f2145c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/max-1.c
@@ -0,0 +1,45 @@
+/* PR middle-end/18548 */
+/* Test case reduced by Andrew Pinski <pinskia@physics.uc.edu> */
+/* { dg-do run } */
+/* { dg-options "-O1 " } */
+/* Option -fno-tree-lrs removed By Andrew MacLeod since it is no longer 
+   supported in the compiler beginning with GCC 4.3.  */
+/* m32c has varying sized pointers */
+/* { dg-skip-if "" { "m32c-*-*" } { "*" } { "-mcpu=m32c" "-mcpu=m32cm" } } */
+
+/* Kludge to make it signed. */
+#define unsigned signed
+__extension__ typedef __SIZE_TYPE__ ssize_t;
+#undef unsigned
+
+extern void abort (void);
+
+ssize_t fff[10];
+
+void f(ssize_t a, ssize_t b)
+{
+  ssize_t crcc = b;
+  ssize_t d = *((ssize_t*)(a+1));
+  int i;
+
+  a = d >= b? d:b;
+
+
+  for(i=0;i<10;i++)
+   fff[i] = a;
+}
+
+/* The variable a cannot be a local variable as we get better aliasing
+   now and decide that the store to a is dead.  The better aliasing comes
+   from better representation of pointer arithmetic. */
+ssize_t a = 10;
+int main(void)
+{
+  int i;
+  f((ssize_t)(&a)-1,0);
+  for(i = 0;i<10;i++)
+   if (fff[i]!=10)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/memcpy-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/memcpy-1.c
new file mode 100644
index 000000000..cc6024237
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/memcpy-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized --param sra-max-structure-size=32" } */
+/* PR36598 AVR fail maybe due to cost metrics */
+/* { dg-final { scan-tree-dump-times "nasty_local" 0 "optimized" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+struct a {int a,b,c;} a;
+int test(struct a a)
+{
+struct a nasty_local;
+__builtin_memcpy (&nasty_local,&a, sizeof(a));
+return nasty_local.a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/memcpy-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/memcpy-2.c
new file mode 100644
index 000000000..24464abd4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/memcpy-2.c
@@ -0,0 +1,25 @@
+/* PR middle-end/38454 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+
+extern inline __attribute__((gnu_inline, always_inline, artificial)) void *
+memcpy (void *__restrict dest, const void *__restrict src, size_t len)
+{
+  return __builtin___memcpy_chk (dest, /* { dg-warning "will always overflow destination buffer" } */
+				 src, len, __builtin_object_size (dest, 0));
+}
+
+struct S { char buf[10]; } s;
+
+void
+foo (void)
+{
+  char buf[12];
+  char *p = buf + 4;
+  struct S *q = (struct S *) p;
+  memcpy (q, &s, sizeof (s));
+}
+
+/* { dg-final { scan-assembler "__memcpy_chk" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/memmove-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/memmove-1.c
new file mode 100644
index 000000000..46918ee0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/memmove-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-final { scan-tree-dump-times "memmove" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+static const char a[100]={1,2,3,4};
+char b[1000];
+int i,i1;
+static inline void
+__attribute__ ((always_inline))
+domem (void *dest, const void *src, int len)
+{
+	__builtin_memmove (dest, src, len);
+}
+t()
+{
+	domem (b,a,100);
+	domem (b+i1,(const void *)b,1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/memset-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/memset-1.c
new file mode 100644
index 000000000..677ae91bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/memset-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef __SIZE_TYPE__ size_t;
+
+extern void warn_memset_zero_len (void)
+__attribute__((__warning__ ("memset used with constant zero length parameter;"
+			    " this could be due to transposed parameters")));
+
+extern inline __attribute__((gnu_inline, always_inline, artificial)) void *
+memset (void *dest, int ch, size_t len)
+{
+  if (__builtin_constant_p (len) && len == 0)
+    {
+      warn_memset_zero_len ();	/* { dg-warning "memset used with constant zero" } */
+      return dest;
+    }
+  return __builtin_memset (dest, ch, len);
+}
+
+char buf[10];
+
+int
+main (void)
+{
+  memset (buf, sizeof (buf), 0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/merge-all-constants-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/merge-all-constants-1.c
new file mode 100644
index 000000000..5c9cd06e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/merge-all-constants-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-w -O2 -fmerge-all-constants" } */
+
+const char str1[36] = "0123456789abcdefghijklmnopqrstuvwxyz";
+const char str2[38] = "0123456789abcdefghijklmnopqrstuvwxyz";
+const char str3[10] = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+/* { dg-final { scan-assembler-not "\.rodata\.str" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/minmax-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/minmax-1.c
new file mode 100644
index 000000000..e279c0e20
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/minmax-1.c
@@ -0,0 +1,83 @@
+/* { dg-do run } */
+/* { dg-options "-fdump-tree-original" } */
+
+/* Check that MIN-MAX and MAX-MIN combinations are folded.  */
+
+extern void abort (void);
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+int f1(int a, int b)
+{
+   return MIN (MAX (a, b), b); /* == b */
+}
+
+int f2(int a, int b)
+{
+   return MAX (MIN (a, b), b); /* == b */
+}
+
+int f3(int a, int b)
+{
+   return MIN (MAX (b, a), b); /* == b */
+}
+
+int f4(int a, int b)
+{
+   return MAX (MIN (b, a), b); /* == b */
+}
+
+
+int g1(int a, int b)
+{
+   return MIN (a, MAX (a, b)); /* == a */
+}
+
+int g2(int a, int b)
+{
+   return MAX (a, MIN (a, b)); /* == a */
+}
+
+int g3(int a, int b)
+{
+   return MIN (a, MAX (b, a)); /* == a */
+}
+
+int g4(int a, int b)
+{
+   return MAX (a, MIN (b, a)); /* == a */
+}
+
+int main(void)
+{
+  if (f1 (1, 2) != 2)
+    abort ();
+
+  if (f2 (1, 2) != 2)
+    abort ();
+
+  if (f3 (1, 2) != 2)
+    abort ();
+
+  if (f4 (1, 2) != 2)
+    abort ();
+
+  if (g1 (1, 2) != 1)
+    abort ();
+
+  if (g2 (1, 2) != 1)
+    abort ();
+
+  if (g3 (1, 2) != 1)
+    abort ();
+
+  if (g4 (1, 2) != 1)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "MIN_EXPR" 0 "original"} } */
+/* { dg-final { scan-tree-dump-times "MAX_EXPR" 0 "original"} } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/misc-column.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/misc-column.c
new file mode 100644
index 000000000..a24427e4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/misc-column.c
@@ -0,0 +1,40 @@
+/* { dg-options "-fshow-column -Wall -Wfloat-equal -pedantic" } */
+
+int i, j;
+float a, b;
+
+int *p;
+struct {
+	int a;
+	char b;
+} *q;
+
+extern void bar();
+
+void foo (void)
+{
+  if (a == b) /* { dg-warning "9:comparing floating point with" } */
+    bar ();
+
+  if (p < q) /* { dg-warning "9:comparison of distinct pointer types" } */
+    bar ();
+
+  if (&p == 0) /* { dg-warning "10:will never be NULL" } */
+    bar();
+
+  if (p == 4) /* { dg-warning "9:comparison between pointer and integer" } */
+    bar();
+
+  if (p < 0) /* { dg-warning "9:ordered comparison of pointer with" } */
+    bar();
+
+  -q;	 /* { dg-error "3:wrong type argument to unary" } */
+
+  ~q;    /* { dg-error "3:wrong type argument to bit" } */
+
+  ++*q; /* { dg-error "3:wrong type argument to increment" } */
+
+  i = j / 0;  /* { dg-warning "9:division by zero" } */
+
+  i /= 0; /* { dg-warning "5:division by zero" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/missing-field-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/missing-field-init-1.c
new file mode 100644
index 000000000..5f32b021f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/missing-field-init-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-Wextra -Wno-missing-field-initializers -std=c99" } */
+
+struct s { int a, b, c; };
+struct s s1 = { 1, 2, 3 };
+struct s s2 = { 1, 2 }; /* { dg-bogus "missing initializer" } */
+struct s s3[] = { { 1, 2 }, { 4, 5 } }; /* { dg-bogus "missing initializer" } */
+struct s s4[] = { 1, 2, 3, 4, 5 }; /* { dg-bogus "missing initializer" } */
+struct s s5[] = { 1, 2, 3, 4, 5, 6 };
+struct s s6 = { .a = 1 }; /* { dg-bogus "missing initializer" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/missing-field-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/missing-field-init-2.c
new file mode 100644
index 000000000..581eb30d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/missing-field-init-2.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-Wmissing-field-initializers -std=c99" } */
+
+struct s { int a, b, c; };
+struct s s1 = { 1, 2, 3 };
+struct s s2 = { 1, 2 }; /* { dg-warning "(missing initializer)|(near initialization)" } */
+struct s s3[] = { { 1, 2 }, { 4, 5 } }; /* { dg-warning "(missing initializer)|(near initialization)" } */
+struct s s4[] = { 1, 2, 3, 4, 5 }; /* { dg-warning "(missing initializer)|(near initialization)" } */
+struct s s5[] = { 1, 2, 3, 4, 5, 6 };
+/* Designated initializers produce no warning.  */
+struct s s6 = { .a = 1 }; /* { dg-bogus "missing initializer" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/mmix-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/mmix-1.c
new file mode 100644
index 000000000..802ae18ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/mmix-1.c
@@ -0,0 +1,42 @@
+/* Origin: <hp@bitrange.com>
+   Test that MMIX -mtoplevel-symbols cause a ":" to be prepended on the
+   right symbols and only there.  */
+/* { dg-do compile { target mmix-*-* } } */
+/* { dg-options "-mtoplevel-symbols" } */
+
+static int static_variable = 1;
+int global_initialized_variable = 2;
+extern int extern_declared_variable;
+int common_variable;
+extern int extern_declared_function (void);
+static int static_function (void);
+
+int global_defined_function ()
+{
+  static int static_variable_in_function = 2009;
+  return
+    static_variable
+    + static_variable_in_function++
+    + global_initialized_variable
+    + common_variable
+    + extern_declared_function ()
+    + static_function ();
+}
+
+static int
+static_function (void)
+{
+  if (extern_declared_variable)
+    return 42;
+  else
+    return 42 + global_defined_function ();
+}
+
+/* { dg-final { scan-assembler-not ":static_variable" } } */
+/* { dg-final { scan-assembler-not "(^|\[^:\])global_initialized_variable" } } */
+/* { dg-final { scan-assembler-not "\[^:\]extern_declared_variable" } } */
+/* { dg-final { scan-assembler-not "\[^:\]common_variable" } } */
+/* { dg-final { scan-assembler-not "\[^:\]extern_declared_function" } } */
+/* { dg-final { scan-assembler-not ":static_function" } } */
+/* { dg-final { scan-assembler-not "(^|\[^:\])global_defined_function" } } */
+/* { dg-final { scan-assembler-not "\[^:\]extern_declared_variable" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-1.c
new file mode 100644
index 000000000..be7b3b856
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-1.c
@@ -0,0 +1,13 @@
+/* PR c/19978 : Test for duplicated warnings (unary operators).  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Woverflow" } */
+
+#include <limits.h>
+
+int 
+g (void)
+{
+  return - - - - -INT_MIN; /* { dg-bogus "integer overflow in expression.*integer overflow in expression" } */
+  /* { dg-warning "integer overflow in expression" "" { target *-*-* } 10 } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-2.c
new file mode 100644
index 000000000..8a4e9e5c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-2.c
@@ -0,0 +1,12 @@
+/* PR c/19978 : Test for duplicated warnings (binary operators).  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Woverflow" } */
+
+#include <limits.h>
+
+int 
+g1 (void)
+{
+  return INT_MAX + 1 - INT_MAX; /* { dg-bogus "integer overflow in expression.*integer overflow in expression" } */
+  /* { dg-warning "integer overflow in expression" "" { target *-*-* } 10 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-3.c
new file mode 100644
index 000000000..da19de508
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiple-overflow-warn-3.c
@@ -0,0 +1,13 @@
+/* PR 30465 : Test for duplicated warnings in a conversion.  */
+/* { dg-do compile } */
+/* { dg-options "-Woverflow" } */
+
+short int
+g (void)
+{
+  short int wc = ((short int)1 << (8 * __SIZEOF_INT__ - 1)) - 1; /* { dg-bogus "overflow .* overflow" } */
+  /* { dg-warning "overflow" "" { target *-*-* } 8 } */
+  return wc;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/multiword-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiword-1.c
new file mode 100644
index 000000000..c08161791
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/multiword-1.c
@@ -0,0 +1,68 @@
+/* { dg-do run } */
+/* { dg-options "-O3" } */
+/* { dg-require-effective-target ilp32 } */
+
+typedef unsigned int u32;
+typedef unsigned long long u64;
+
+u64 __attribute__((noinline))
+foo (u32 high, u32 low)
+{
+  return ((u64)high << 32) | low;
+}
+
+u32 __attribute__((noinline))
+right (u64 t)
+{
+  return (u32)(t >> 32);
+}
+
+u64 __attribute__((noinline))
+left (u32 t)
+{
+  return (u64)t << 32;
+}
+
+u32 __attribute__((noinline))
+right2 (u64 t)
+{
+  return (u32)(t >> 40);
+}
+
+u64 __attribute__((noinline))
+left2 (u32 t)
+{
+  return (u64)t << 40;
+}
+
+u64 __attribute__((noinline))
+zeroextend (u32 t)
+{
+  return (u64)t;
+}
+
+extern void abort ();
+
+int
+main ()
+{
+  if (foo (13000, 12000) != 55834574860000ULL)
+    abort ();
+
+  if (right (55834574860000ULL) != 13000)
+    abort ();
+
+  if (left (13000) != 55834574848000ULL)
+    abort ();
+
+  if (right2 (55834574860000ULL) != 50)
+    abort ();
+
+  if (left2 (13000) != 14293651161088000ULL)
+    abort ();
+
+  if (zeroextend (13000) != 13000ULL)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nest.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nest.c
new file mode 100644
index 000000000..5734c11f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nest.c
@@ -0,0 +1,28 @@
+/* PR 5967, PR 7114 */
+/* { dg-do run } */
+/* { dg-require-profiling "-pg" } */
+/* { dg-options "-O2 -pg" } */
+/* { dg-options "-O2 -pg -static" { target hppa*-*-hpux* } } */
+/* { dg-error "profiler" "No profiler support" { target xstormy16-*-* } 0 } */
+
+extern void abort (void);
+
+long foo (long x)
+{
+  long i, sum = 0;
+  long bar (long z) { return z * 2; }
+
+  for (i = 0; i < x; i++)
+    sum += bar (i);
+
+  return sum;
+}
+
+int main (void)
+{
+  if (foo(10) != 90)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { cleanup-profile-file } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-calls-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-calls-1.c
new file mode 100644
index 000000000..89fdc88c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-calls-1.c
@@ -0,0 +1,42 @@
+/* PR middle-end/24003 */
+/* Contributed by Eric Botcazou <ebotcazou@adacore.com> */
+
+/* { dg-do run } */
+/* { dg-options "-std=c99 -O -fno-inline" } */
+/* { dg-options "-std=c99 -O -fno-inline -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#include <limits.h>
+
+typedef unsigned long uns32_t;
+typedef unsigned long long uns64_t;
+
+extern void abort(void);
+
+uns32_t lo (uns64_t p)
+{
+  return (uns32_t)p;
+}
+
+uns64_t concat (uns32_t p1, uns32_t p2)
+{
+#if LLONG_MAX > 2147483647L
+  return ((uns64_t)p1 << 32) | p2;
+#else
+  return 0;
+#endif
+}
+
+uns64_t lshift32 (uns64_t p1, uns32_t p2)
+{
+  return concat (lo (p1), p2);
+}
+
+int main(void)
+{
+#if LLONG_MAX > 2147483647L
+  if (lshift32 (0xFFFFFFFF12345678ULL, 0x90ABCDEFUL) != 0x1234567890ABCDEFULL)
+    abort ();
+#endif
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-1.c
new file mode 100644
index 000000000..cb26e895e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-1.c
@@ -0,0 +1,35 @@
+/* Test for proper errors for break and continue in nested functions.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+foo (int a)
+{
+  switch (a) {
+    void bar1 (void) { break; } /* { dg-error "break statement" "break switch 1" } */
+  }
+  switch (a) {
+  case 0:
+    (void) 0;
+    void bar2 (void) { break; } /* { dg-error "break statement" "break switch 2" } */
+  }
+  while (1) {
+    void bar3 (void) { break; } /* { dg-error "break statement" "break while" } */
+  }
+  do {
+    void bar4 (void) { break; } /* { dg-error "break statement" "break do" } */
+  } while (1);
+  for (;;) {
+    void bar5 (void) { break; } /* { dg-error "break statement" "break for" } */
+  }
+  while (1) {
+    void bar6 (void) { continue; } /* { dg-error "continue statement" "continue while" } */
+  }
+  do {
+    void bar7 (void) { continue; } /* { dg-error "continue statement" "continue do" } */
+  } while (1);
+  for (;;) {
+    void bar8 (void) { continue; } /* { dg-error "continue statement" "continue for" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-2.c
new file mode 100644
index 000000000..14f14c67e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-2.c
@@ -0,0 +1,28 @@
+/* PR middle-end/18820 */
+/* Check that we reject nested functions as initializers
+   of static variables.  */
+
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct S {
+  void (*f)(int);
+};
+
+extern void baz(struct S *);
+extern void p(int);
+
+void foo(void)
+{
+  int u;
+
+  void bar(int val)
+    {
+      u = val;
+    }
+
+  static struct S s = { bar }; /* { dg-error "(is not constant)|(near initialization)" } */
+
+  baz(&s);
+  p(u);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-3.c
new file mode 100644
index 000000000..19e8a6155
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-3.c
@@ -0,0 +1,20 @@
+/* Undefined nested function should be a error, whether or not the
+   function is called.  Bug 17807.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (void)
+{
+  auto int fn (int); /* { dg-error "nested function 'fn' declared but never defined" } */
+  auto int fn2 (int); /* { dg-error "nested function 'fn2' declared but never defined" } */
+  sizeof(fn(1));
+}
+
+void
+h (void)
+{
+  auto int hn (int); /* { dg-error "nested function 'hn' declared but never defined" } */
+  hn (1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-4.c
new file mode 100644
index 000000000..36a8c405c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-4.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-pg" } */
+/* { dg-options "-pg -static" { target hppa*-*-hpux* } } */
+/* { dg-require-profiling "-pg" } */
+
+extern void abort(void);
+
+void foo(int i)
+{
+  void bar(void)
+  {
+    if (i != 2)
+      abort ();
+  }
+
+  bar();
+}
+
+int main(void)
+{
+  foo (2);
+  return 0;
+}
+
+/* { dg-final { cleanup-profile-file } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-5.c
new file mode 100644
index 000000000..3545f37e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-5.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-fexceptions" } */
+/* PR28516: ICE generating ARM unwind directives for nested functions.  */
+/* { dg-require-effective-target trampolines } */
+
+void ex(int (*)(void));
+void foo(int i)
+{
+  int bar(void)
+  {
+    return i;
+  }
+  ex(bar);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-6.c
new file mode 100644
index 000000000..3bae4db35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-func-6.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Winline" } */
+
+static inline int foo1 (int a)
+{                       /* { dg-bogus "function not inlinable" } */
+  void bar1 (int b)
+  {}
+  return a;
+}
+
+int foo2 (int a)
+{
+  return foo1 (a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-redef-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-redef-1.c
new file mode 100644
index 000000000..a3786b0c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nested-redef-1.c
@@ -0,0 +1,44 @@
+/* Test diagnosis of nested tag redefinitions.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s0 {
+  struct s0 { int a; } x; /* { dg-error "nested redefinition of 'struct s0'" } */
+};
+
+struct s1 {
+  const struct s1 { int b; } x; /* { dg-error "nested redefinition of 'struct s1'" } */
+};
+
+struct s2 {
+  struct s2 { int c; } *x; /* { dg-error "nested redefinition of 'struct s2'" } */
+};
+
+struct s3 {
+  struct s4 {
+    struct s5 {
+      struct s3 { int a; } **x; /* { dg-error "nested redefinition of 'struct s3'" } */
+    } y;
+  } z;
+};
+
+struct s6;
+struct s6 { struct s6 *p; };
+
+union u0 {
+  union u0 { int c; } *x; /* { dg-error "nested redefinition of 'union u0'" } */
+};
+
+enum e0 {
+  E0 = sizeof(enum e0 { E1 }) /* { dg-error "nested redefinition of 'enum e0'" } */
+};
+
+enum e1 {
+  E2 = sizeof(enum e2 { E2 }), /* { dg-error "redeclaration of enumerator 'E2'" } */
+  /* { dg-message "note: previous definition" "previous E2" { target *-*-* } 38 } */
+  E3
+};
+
+enum e3;
+enum e3 { E4 = 0 };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-1.c
new file mode 100644
index 000000000..fdcf05459
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+/* Verify that these GNU extensions are recognized as keywords in
+   GNU89 mode.  */
+
+int asm;	/* { dg-error "before .asm." } */
+int inline;	/* { dg-warning "empty declaration" } */
+/* { dg-error "empty declaration" "" { target *-*-* } 8 } */
+int typeof;	/* { dg-error "before .typeof." } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-2.c
new file mode 100644
index 000000000..3cd41141d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-2.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -fno-asm" } */
+
+/* Verify that these GNU extensions are not recognized as keywords
+   when using -fno-asm in GNU89 mode.  */
+
+int asm;	/* { dg-bogus "before .asm." } */
+int inline;	/* { dg-bogus "empty declaration" } */
+int typeof;	/* { dg-bogus "before .typeof." } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-3.c
new file mode 100644
index 000000000..9c806e435
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-3.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* Verify that these GNU extensions are recognized as keywords in
+   GNU99 mode.  */
+
+int asm;	/* { dg-error "before .asm." } */
+int inline;	/* { dg-warning "empty declaration" } */
+/* { dg-error "empty declaration" "" { target *-*-* } 8 } */
+int typeof;	/* { dg-error "before .typeof." } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-4.c
new file mode 100644
index 000000000..c4c168780
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-asm-4.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -fno-asm" } */
+
+/* Verify that the GNU extensions asm and typeof are not recognized as
+   keywords when using -fno-asm in GNU89 mode, but that inline (which
+   is a keyword in C99 but not C89) is recognized.  */
+
+int asm;	/* { dg-bogus "before .asm." } */
+int inline;	/* { dg-warning "empty declaration" } */
+/* { dg-error "empty declaration" "" { target *-*-* } 9 } */
+int typeof;	/* { dg-bogus "before .typeof." } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-1.c
new file mode 100644
index 000000000..6d449cac1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of strict-overflow-1.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return i - 5 < 10;
+}
+
+/* { dg-final { scan-tree-dump "-[ ]*5" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-2.c
new file mode 100644
index 000000000..cfe4bc16f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of strict-overflow-2.c.  */
+
+/* We can only simplify the division when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return (i * 100) / 10;
+}
+
+/* { dg-final { scan-tree-dump "100" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-3.c
new file mode 100644
index 000000000..a98117981
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of strict-overflow-3.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i, int j)
+{
+  return i + 100 < j + 1000;
+}
+
+/* { dg-final { scan-tree-dump "1000" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-4.c
new file mode 100644
index 000000000..da6264a72
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-4.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of strict-overflow-4.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return i + 1 > i;
+}
+
+/* We expect to see "<bb N>"; confirm that, so that we know to count
+   it in the real test.  */
+/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times ">|<" 3 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-5.c
new file mode 100644
index 000000000..7f82014c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-5.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Dual of strict-overflow-5.c.  */
+
+/* We can only unroll when using strict overflow semantics.  */
+
+int foo (int i)
+{
+  int index;
+  int r=0;
+ 
+  for (index = i; index <= i+4; index+=2) 
+    r++;
+ 
+  return r;
+}
+
+/* { dg-final { scan-tree-dump-times "r = 3" 0 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-6.c
new file mode 100644
index 000000000..664aa256a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-6.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  */
+
+/* VRP test.  We can not simplify the conditional when not using
+   strict overflow semantics.  We don't test this with
+   -fstrict-overflow because it turns into an infinite loop.  That is
+   OK but it would also be OK to not do that.  */
+
+int
+foo ()
+{
+  int i, bits;
+  for (i = 1, bits = 1; i > 0; i += i)
+    ++bits;
+  return bits;
+}
+
+/* { dg-final { scan-tree-dump "return bits" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-7.c
new file mode 100644
index 000000000..07ad27b1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/no-strict-overflow-7.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-strict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of strict-overflow-6.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (char* p)
+{
+  return p + 1000 < p;
+}
+
+/* { dg-final { scan-tree-dump "\[+\]\[ \]*1000" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nodfp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nodfp-1.c
new file mode 100644
index 000000000..55019d8c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nodfp-1.c
@@ -0,0 +1,6 @@
+/* { dg-do compile { target {! dfp} } } */
+/* { dg-options "-std=gnu99" } */
+
+_Decimal32 x;	/* { dg-error "not supported" "reject decimal float" } */
+_Decimal64 y;	/* { dg-error "not supported" "reject decimal float" } */
+_Decimal128 z;	/* { dg-error "not supported" "reject decimal float" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nofixed-point-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nofixed-point-1.c
new file mode 100644
index 000000000..babbe5989
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nofixed-point-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile { target {! fixed_point} } } */
+/* { dg-options "-std=gnu99" } */
+
+_Fract w;       /* { dg-error "not supported" "reject fixed-point" } */
+_Sat _Fract x;  /* { dg-error "not supported" "reject fixed-point" } */
+_Accum y;       /* { dg-error "not supported" "reject fixed-point" } */
+_Sat _Accum z;  /* { dg-error "not supported" "reject fixed-point" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nofixed-point-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nofixed-point-2.c
new file mode 100644
index 000000000..97bbf7022
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nofixed-point-2.c
@@ -0,0 +1,30 @@
+/* PR inline-asm/39059 */
+/* { dg-do compile { target {! fixed_point} } } */
+/* { dg-options "-std=gnu99" } */
+
+void
+f1 (void)
+{
+  asm ("" : : "r" (0r));       /* { dg-error "not supported" "reject fixed-point" } */
+}
+
+__typeof (0r)		       /* { dg-error "not supported" "reject fixed-point" } */
+b2 (void)
+{
+  return 0r;		       /* { dg-error "not supported" "reject fixed-point" } */
+}
+
+_Accum			       /* { dg-error "not supported" "reject fixed-point" } */
+f3 (void)
+{
+  return 0k;			/* { dg-error "not supported" "reject fixed-point" } */
+}
+
+_Sat
+f4 (void)			/* { dg-error "not supported" "reject fixed-point" } */
+{
+  return 0k;			/* { dg-error "not supported" "reject fixed-point" } */
+}
+
+/* { dg-warning "defaults to" "" { target *-*-* } 13 } */
+/* { dg-error "is used without" "" { target *-*-* } 24 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/non-local-goto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/non-local-goto-1.c
new file mode 100644
index 000000000..2bace076f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/non-local-goto-1.c
@@ -0,0 +1,56 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+int global;
+
+static foo(void) __attribute__((noinline));
+
+static foo(void)
+{
+  global = 1;
+}
+
+static bar(void)
+{
+  foo ();
+}
+
+int execute(int cmd)
+{
+  __label__ start;
+
+  void raise(void)
+  {
+    goto start;
+  }
+
+  int last;
+
+  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.4.3/gcc/testsuite/gcc.dg/non-local-goto-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/non-local-goto-2.c
new file mode 100644
index 000000000..24ed650a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/non-local-goto-2.c
@@ -0,0 +1,57 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+int global;
+
+static foo(void) __attribute__((noinline));
+
+static foo(void)
+{
+  global = 1;
+}
+
+static bar(void)
+{
+  foo ();
+  global = 0;
+}
+
+int execute(int cmd)
+{
+  __label__ start;
+
+  void raise(void)
+  {
+    goto start;
+  }
+
+  int last;
+
+  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.4.3/gcc/testsuite/gcc.dg/noncompile/20000901-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20000901-1.c
new file mode 100644
index 000000000..ef5c3cbca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20000901-1.c
@@ -0,0 +1 @@
+struct foo bar[] = { {"baz"} }; /* { dg-error "array type has incomplete element type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20001228-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20001228-1.c
new file mode 100644
index 000000000..73a44a859
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20001228-1.c
@@ -0,0 +1,6 @@
+void rof(void)
+{
+  union { int a; } u;
+  for (u.a = 0; u; u.a++)  /* { dg-error "used union" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20010425-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20010425-1.c
new file mode 100644
index 000000000..e36269e8d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20010425-1.c
@@ -0,0 +1,9 @@
+__inline__ void bar(int x)
+{
+  (void)x;
+}
+
+void foo(void)
+{
+  bar(baz);  /* { dg-error "undeclared|for each function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20010524-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20010524-1.c
new file mode 100644
index 000000000..95c5db15d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20010524-1.c
@@ -0,0 +1,2 @@
+int i = 7 / 0; /* { dg-error "not constant" } */
+	/* { dg-warning "division by zero" "div by zero" { target *-*-* } 1 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20011025-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20011025-1.c
new file mode 100644
index 000000000..51e60e5cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20011025-1.c
@@ -0,0 +1,5 @@
+double foo [] =
+{ &bar,		/* { dg-error "undeclared|is not constant|near init" } */
+  (void *) 0 };	/* { dg-error "incompatible types|is not constant|near init" } */
+double baz [] =
+{ (void *) 0 };	/* { dg-error "incompatible types|is not constant|near init" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020130-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020130-1.c
new file mode 100644
index 000000000..d820e062e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020130-1.c
@@ -0,0 +1,9 @@
+/* Test for ICE when using typedef for bad type.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>.  */
+
+void
+foo (void)
+{
+  typedef int t[x]; /* { dg-error "undeclared|function" "x undeclared" } */
+  t bar;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020207-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020207-1.c
new file mode 100644
index 000000000..945eb1b1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020207-1.c
@@ -0,0 +1,32 @@
+/* This testcase ICEd because statement expression type was set, but was not
+   as used.  */
+
+struct A {
+  unsigned int a, b, c;
+};
+
+extern void abort (void);
+extern void exit (int);
+
+struct A bar (void)
+{
+  return (struct A) { 176, 52, 31 };
+}
+
+void baz (struct A *a)
+{
+  if (a->a != 176 || a->b != 52 || a->c != 31)
+    abort ();
+}
+
+int main ()
+{
+  struct A d;
+
+  d = ({ { bar (); } });		/* { dg-error "void value" } */
+  d = ({ if (1) { bar (); } });		/* { dg-error "void value" } */
+  d = ({ while (0) { bar (); } });	/* { dg-error "void value" } */
+  d = ({ do { bar (); } while (0); });	/* { dg-error "void value" } */
+  baz (&d);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020213-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020213-1.c
new file mode 100644
index 000000000..41480f079
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020213-1.c
@@ -0,0 +1,34 @@
+/* PR c/5503
+   Test whether argument checking is done for fputs, bzero and bcmp.  */
+typedef struct { int i; } FILE;
+typedef __SIZE_TYPE__ size_t;
+int fputs (const char *, FILE *);
+void bzero (void *, size_t);
+int bcmp (const void *, const void *, size_t);
+
+char buf[32];
+FILE *f;
+
+int main ()
+{
+  fputs ("foo");		/* { dg-error "too few" } */
+  fputs ("foo", "bar", "baz");	/* { dg-error "too many" } */
+  fputs (21, 43);
+  bzero (buf);			/* { dg-error "too few" } */
+  bzero (21);			/* { dg-error "too few" } */
+  bcmp (buf, buf + 16);		/* { dg-error "too few" } */
+  bcmp (21);			/* { dg-error "too few" } */
+  fputs ("foo", f);
+  bzero (buf, 32);
+  bcmp (buf, buf + 16, 16);
+  return 0;
+}
+
+/* { dg-warning "passing argument 2 of" "2nd incompatible" { target *-*-* } 15 } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 5 } */
+/* { dg-warning "passing argument 1 of" "1st incompatible" { target *-*-* } 16 } */
+/* { dg-warning "passing argument 2 of" "2nd incompatible" { target *-*-* } 16 } */
+/* { dg-warning "passing argument 1 of" "1st incompatible" { target *-*-* } 18 } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 6 } */
+/* { dg-warning "passing argument 1 of" "1st incompatible" { target *-*-* } 20 } */
+/* { dg-message "note: expected '\[^'\n\]*' but argument is of type '\[^'\n\]*'" "note: expected" { target *-*-* } 7 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020220-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020220-1.c
new file mode 100644
index 000000000..3063f422c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20020220-1.c
@@ -0,0 +1,12 @@
+/* PR c++/5713
+   Test that there are no ICEs after redeclaration error.  */
+
+int foo (const char*, const char*);
+
+void bar (void)
+{
+  const char *s = "bar";
+  int i;			/* { dg-message "note: previous declaration" } */
+  int size = 2;
+  int i = foo (s, s + size);	/* { dg-error "redeclaration of" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20030818-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20030818-1.c
new file mode 100644
index 000000000..71b89ec6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20030818-1.c
@@ -0,0 +1,3 @@
+/* PR 11207.  */
+
+char font8x8[256][8] = { [-1] = { 0 } }; /* { dg-error "array index|near init" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-1.c
new file mode 100644
index 000000000..dc5ab7a7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-1.c
@@ -0,0 +1,15 @@
+/* PR/11658  The error message was quite mysterious for gcc up to 3.4.x */
+
+struct a {
+  int x;
+};
+
+int bug_if(struct a a) { if (a) return 1; else return 0; }  /* { dg-error "struct type" } */
+int bug_while(struct a a) { while (a); }  /* { dg-error "struct type" } */
+int bug_do_while(struct a a) { do ; while (a); }  /* { dg-error "struct type" } */
+int bug_for(struct a a) { for ( ; a; ) ; }  /* { dg-error "struct type" } */
+int bug_or(struct a a) { return (a || 1); }  /* { dg-error "struct type" } */
+int bug_and(struct a a) { return (a && 1); }  /* { dg-error "struct type" } */
+int bug_cond(struct a a) { return (a ? 1 : 0); }  /* { dg-error "struct type" } */
+int bug_cond2(struct a a) { return (a ? : 0); }  /* { dg-error "struct type" } */
+int bug_bool(struct a a) { return (_Bool) a; }  /* { dg-error "struct type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-2.c
new file mode 100644
index 000000000..5c8b22f02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-2.c
@@ -0,0 +1,15 @@
+/* PR/11658  The error message was quite mysterious for gcc up to 3.4.x */
+
+union a {
+  int x;
+};
+
+int bug_if(union a a) { if (a) return 1; else return 0; }  /* { dg-error "union type" } */
+int bug_while(union a a) { while (a); }  /* { dg-error "union type" } */
+int bug_do_while(union a a) { do ; while (a); }  /* { dg-error "union type" } */
+int bug_for(union a a) { for ( ; a; ) ; }  /* { dg-error "union type" } */
+int bug_or(union a a) { return (a || 1); }  /* { dg-error "union type" } */
+int bug_and(union a a) { return (a && 1); }  /* { dg-error "union type" } */
+int bug_cond(union a a) { return (a ? 1 : 0); }  /* { dg-error "union type" } */
+int bug_cond2(union a a) { return (a ? : 0); }  /* { dg-error "union type" } */
+int bug_bool(union a a) { return (_Bool) a; }  /* { dg-error "union type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-3.c
new file mode 100644
index 000000000..5b90c3ee8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040203-3.c
@@ -0,0 +1,16 @@
+/* PR/11658  The error message was quite mysterious for gcc up to 3.4.x */
+/* { dg-options "-std=gnu89" } */
+
+struct s { char c[1]; };
+struct s f(void);
+
+int bug_if(void) { if (f().c) return 1; else return 0; }  /* { dg-error "array that cannot be converted" } */
+int bug_while(void) { while (f().c); }  /* { dg-error "array that cannot be converted" } */
+int bug_do_while(void) { do ; while (f().c); }  /* { dg-error "array that cannot be converted" } */
+int bug_for(void) { for ( ; f().c; ) ; }  /* { dg-error "array that cannot be converted" } */
+int bug_or(void) { return (f().c || 1); }  /* { dg-error "array that cannot be converted" } */
+int bug_and(void) { return (f().c && 1); }  /* { dg-error "array that cannot be converted" } */
+int bug_cond(void) { return (f().c ? 1 : 0); }  /* { dg-error "array that cannot be converted" } */
+int bug_cond2(void) { return (f().c ? : 0); }  /* { dg-error "array that cannot be converted" } */
+int bug_not(void) { return !f().c; }  /* { dg-error "wrong type argument to unary exclamation mark" } */
+int bug_bool(void) { return (_Bool) f().c; }  /* { dg-error "array that cannot be converted" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040629-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040629-1.c
new file mode 100644
index 000000000..3575b839e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20040629-1.c
@@ -0,0 +1,7 @@
+/* PR 16216 */
+
+void func()
+{
+        const char *pek; int i;
+        pek=__builtin_va_arg(ap,const char*);	/* { dg-error "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20041207.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20041207.c
new file mode 100644
index 000000000..0d02da909
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20041207.c
@@ -0,0 +1,8 @@
+/* PR18867 - ICE on a switch controlling expressions with an
+   invalid type.  Origin: Serge Belyshev <belyshev@lubercy.com>  */
+   
+void f()
+{
+  float x;
+  switch (x) {case 0: break;}; /* { dg-error "not an integer" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20050120-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20050120-1.c
new file mode 100644
index 000000000..4af84b6f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/20050120-1.c
@@ -0,0 +1,19 @@
+/* PR c/18946 */
+/* { dg-do compile } */
+/* { dg-options "-Wshadow" } */
+
+void bar (void)
+{
+  {
+    if (foo)		/* { dg-error "undeclared|for each" } */
+      foo ();		/* { dg-warning "shadows previous" } */
+  }
+}
+
+void baz (void)
+{
+  if (foo)		/* { dg-error "undeclared" } */
+    {
+      int foo;		/* { dg-warning "shadows previous" } */
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920507-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920507-1.c
new file mode 100644
index 000000000..c1a352300
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920507-1.c
@@ -0,0 +1,7 @@
+int *
+x(void)
+{
+ register int *a asm("unknown_register");  /* { dg-error "invalid register" } */
+ int *v[1] = {a};
+ return v[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920616-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920616-2.c
new file mode 100644
index 000000000..25f59434f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920616-2.c
@@ -0,0 +1 @@
+f(void a,...){}		/* { dg-error "has incomplete type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920721-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920721-2.c
new file mode 100644
index 000000000..b21ff994e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920721-2.c
@@ -0,0 +1,6 @@
+void f(int n)
+{
+int s;
+for(s=0;s<n;s++)
+  s==5?1 n=1;		/* { dg-error "parse error|syntax error|expected" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920824-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920824-1.c
new file mode 100644
index 000000000..bc8b19c3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920824-1.c
@@ -0,0 +1 @@
+struct s{struct s{int i;}x;};	/* { dg-error "nested redefinition" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920923-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920923-1.c
new file mode 100644
index 000000000..8dd19b272
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/920923-1.c
@@ -0,0 +1,126 @@
+typedef BYTE unsigned char;	/* { dg-error "expected" } */
+typedef int item_n;
+typedef int perm_set;
+struct PENT { caddr_t v_addr; };/* { dg-error "expected" } */
+typedef struct PENT prec;
+typedef struct PENT *prec_t;
+prec_t mem_hash;
+BYTE *mem_base;			/* { dg-error "expected" } */
+struct PTE {
+     BYTE *p_page;		/* { dg-error "expected" } */
+     perm_set p_perms;
+};
+typedef struct PTE pte;
+struct PTP {
+     union {
+	  struct *PTP p_tablep;	/* { dg-error "expected" } */
+	  struct *PTE p_entry;
+     } u;
+     int valid;
+};
+typedef struct PTP (u.p_tablep);/* { dg-error "expected" } */
+int pfree=0;
+int pcount=0;
+
+void
+mmu_walk_find(va)
+caddr_t va;			/* { dg-error "expected" } */
+{
+     BYTE *page_addr; /* { dg-error "undeclared|for each function" } */
+     if (mmu_base[Level1(va)]->valid==0x0) { /* { dg-error "undeclared" } */
+	  l1_base = mmu_base[Level1(va)]->(u.p_tablep) = p_alloc(); /* { dg-error "expected|undeclared" } */
+	  mmu_base[Level1(va)]->valid = 0x3;
+	  for (idx=0; idx<LEVEL1_ENTRIES; idx++) /* { dg-error "undeclared" } */
+	       l1_base[idx]->valid = 0x0;
+	  goto build_level2;
+     } else
+	  l1_base = mmu_base[Level1(va)]->(u.p_tablep); /* { dg-error "expected" } */
+
+     if (l1_base[Level2(va)]->valid==0x0) {
+     build_level2:
+	  l2_base = l1_base[Level2(va)]->(u.p_tablep) = p_alloc(); /* { dg-error "expected|undeclared" } */
+	  l1_base[Level2(va)]->valid = 0x3;
+	  for (idx=0; idx<LEVEL2_ENTRIES; idx++) /* { dg-error "undeclared" } */
+	       l2_base[idx]->valid=0x0;
+	  goto build_page; /* { dg-error "used but not defined" } */
+     } else
+	  l2_base = mmu_base[Level2(va)]->(u.p_tablep); /* { dg-error "expected" } */
+
+     page_addr = l2_base[Level2(va)]->valid;
+}
+
+void *
+a_translate(va_op, v_addr)
+int va_op;
+caddr_t v_addr;			/* { dg-error "expected" } */
+{
+     register prec_t bucket;
+     register caddr_t p_addr;	/* { dg-error "expected|undeclared" } */
+     bucket = mem_hash+((((v_addr)>>ITEMBITS))&hash_mask);  /* { dg-error "undeclared" } */
+     do {
+	  if (bucket->v_addr == ((v_addr)>>ITEMBITS) {	/* { dg-error "expected|undeclared|no member" } */
+	       if(!(bucket->perm_set&va_op))
+		    goto prot_fault;
+	       return mem_base + v_addr;
+	  }
+     } while((bucket++)->v_addr != ((caddr_t)0));  /* { dg-error "expected|undeclared|no member" } */
+
+ page_miss:
+     p_addr = (--bucket)->p_addr;	/* { dg-error "no member" } */
+ page_type:
+     switch (p_addr) {
+     case BUCKET_FULL:		/* { dg-error "undeclared" } */
+	  enlarge_hash_table(mem_hash);
+     case((caddr_t)0):		/* { dg-error "expected" } */
+	  p_addr = fill_item_entry(va_op, v_addr);
+	  goto page_type;
+     case((caddr_t)1):		/* { dg-error "expected" } */
+     default:
+	  ((void)(((0))?0:(__eprintf("Failed assertion`%s'at line%d of`%s'.\n",
+				     "FALSE", 327, "b.c"), 0)));
+     }
+}
+
+void
+flush_hash(hasht, hash_size)
+prec_t hasht;
+int hash_size;
+{
+     register prec_t bucket;
+     register int idx;
+     bucket = hasht;
+     for(idx=(hash_size*3)-1; idx>=0; idx--) {
+	  bucket->v_addr = ((caddr_t)0);/* { dg-error "undeclared|expected|no member" } */
+	  bucket->p_addr = ((caddr_t)0);/* { dg-error "no member|expected" } */
+	  bucket->perm_set = VA_EMPTY;	/* { dg-error "undeclared|no member" } */
+     }
+}
+
+extern void *calloc(__SIZE_TYPE__, __SIZE_TYPE__);
+
+void
+init_mem()
+{
+     mem_base = (BYTE *) calloc(1024, (1<<13)); /* { dg-error "undeclared|expected" } */
+     ((void)((mem_base != (BYTE *)0)	/* { dg-error "expected" } */
+	     ? 0
+	     : (__eprintf("Failed assertion`%s'at line%d of`%s'.\n",
+			  "mem_base != (BYTE *)0", 366, "b.c"),
+		0)));
+     hash_num = INIT_NUM_ENTRIES * 3;	/* { dg-error "undeclared" } */
+     mem_hash = (prec_t) calloc(hash_num, sizeof(prec));
+     ((void)((mem_hash != (prec_t)0)
+	     ? 0
+	     : (__eprintf("Failed assertion`%s'at line%d of`%s'.\n",
+			  "mem_hash != (prec_t)0", 370, "b.c"),
+		0)));
+     flush_hash(mem_hash, 32);
+     build_ptables(mem_base, 1024*(1<<13)); /* { dg-bogus "integer overflow" "int smaller than 32 bits" { xfail int16 } } */
+}
+
+struct tm {
+     int tm_sec; int tm_min; int tm_hour;
+     int tm_mday;int tm_mon; int tm_year;
+     int tm_wday;int tm_yday;int tm_isdst;
+     char*tm_zone; long tm_gmtoff;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/921102-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/921102-1.c
new file mode 100644
index 000000000..ef04b1b2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/921102-1.c
@@ -0,0 +1 @@
+int x[]={[0.3 ... 4.6]9}; /* { dg-error "not of integer type|near init" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/921116-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/921116-1.c
new file mode 100644
index 000000000..890bbb634
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/921116-1.c
@@ -0,0 +1 @@
+void a (void x) {}	/* { dg-error "has incomplete type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930301-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930301-1.c
new file mode 100644
index 000000000..afabd1513
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930301-1.c
@@ -0,0 +1,5 @@
+struct a *q;
+f()
+{
+  q++;	/* { dg-error "pointer to" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930622-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930622-1.c
new file mode 100644
index 000000000..835e072c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930622-1.c
@@ -0,0 +1,6 @@
+f ()
+{
+  double b;
+  b = b * 10;
+  goto c;	/* { dg-error "used but not defined" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930622-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930622-2.c
new file mode 100644
index 000000000..5e02d8951
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930622-2.c
@@ -0,0 +1,6 @@
+f ()
+{
+  int i;
+  for (i--)	/* { dg-error "parse|syntax|expected" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930714-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930714-1.c
new file mode 100644
index 000000000..bdbc13394
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/930714-1.c
@@ -0,0 +1,25 @@
+typedef union _yystype
+{
+  int i;
+  int *iptr;
+  int (*ifunc)(int);
+  void (*vfunc)(int);
+}
+YYSTYPE;
+
+extern int f1(int k);
+
+void test()
+{
+  YYSTYPE a;
+  int (*iptr)(int);
+  int foo[5];
+
+  a = f1;		/* { dg-error "incompatible types" } */
+  a = (YYSTYPE)f1;
+  a = (YYSTYPE)foo;
+  a = (YYSTYPE)(int *)foo;
+  iptr = f1;
+  a = iptr;		/* { dg-error "incompatible types" } */
+  a = (YYSTYPE)iptr;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/931203-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/931203-1.c
new file mode 100644
index 000000000..0c6a9f2d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/931203-1.c
@@ -0,0 +1,11 @@
+typedef struct
+{
+  int x, y;
+} point_t;
+
+
+point_t
+f ()
+{
+  return 0;	/* { dg-error "incompatible types" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/940112-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/940112-1.c
new file mode 100644
index 000000000..bb5e0f66c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/940112-1.c
@@ -0,0 +1,7 @@
+double
+f (int x)
+{
+  double e = 1;
+  e = 1;
+  return (e)
+}	/* { dg-error "parse error|syntax error|expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/940227-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/940227-1.c
new file mode 100644
index 000000000..2e6d91393
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/940227-1.c
@@ -0,0 +1,5 @@
+struct font {
+  struct {
+    char *line,*ulmask;
+  } c[2];
+} character[1] = { { {"", ""}, {"", ""} } }; /* { dg-error "extra|near|excess" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/950825-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/950825-1.c
new file mode 100644
index 000000000..4f4c6fbb9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/950825-1.c
@@ -0,0 +1,4 @@
+main()
+{
+return (struct x) {{y: 0}};   /* { dg-error "extra|near|excess|incompatible" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/950921-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/950921-1.c
new file mode 100644
index 000000000..f141d510b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/950921-1.c
@@ -0,0 +1,10 @@
+typedef enum
+{
+  a = (X) 0,	/* { dg-error "undeclared|not integer|parse error|syntax error|expected" } */
+  b
+} c;
+
+typedef enum
+{
+  d = (X) 0	/* { dg-error "undeclared|not integer|parse error|syntax error|expected" } */
+} e;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/951123-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/951123-1.c
new file mode 100644
index 000000000..009d02b8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/951123-1.c
@@ -0,0 +1,2 @@
+struct S { int a; int b[2]; };
+struct S x = { 0, [0]; };    /* { dg-error "array index|near|parse|syntax|expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/971104-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/971104-1.c
new file mode 100644
index 000000000..722b71c78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/971104-1.c
@@ -0,0 +1,29 @@
+extern int printf(const char *, ...);
+typedef unsigned short          ushort;
+struct sembuf {
+  ushort  sem_num;         
+  short   sem_op;          
+  short   sem_flg;         
+};
+union semun {
+  int val;                       
+  struct semid_ds *buf;          
+  ushort *array;                 
+  struct seminfo *__buf;         
+  void *__pad;
+};
+static union semun semctl_arg;
+static int semid;
+static void up(int sem){
+  struct sembuf sb;
+  sb.sem_num = (unsigned short) sem;
+  sb.sem_op  = 1;         
+  sb.sem_flg = 0x1000 ;  
+  if(semop(semid, &sb, 1) == -1) error("up failure");
+  if(semctl(semid, sb.sem_num, 12 , semctl_arg) == 0)
+    printf("%s had processes sleeping on it!\n",
+    ({ "MUTEX     ", "BARB_SEM 1", "BARB_SEM 2", "CUST_SEM 1",
+       "CUST_SEM 2", "WAIT_SEM 1", "WAIT_SEM 2", "WAIT_SEM 3",
+       "WAIT_SEM 4"}	 /* { dg-error "parse error|syntax error|expected" } */
+	[( sb.sem_num )]) ); /* { dg-error "expected" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/990416-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/990416-1.c
new file mode 100644
index 000000000..49f556939
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/990416-1.c
@@ -0,0 +1,12 @@
+extern void *memcpy (void *, const void *, __SIZE_TYPE__);
+typedef int word_type;
+   
+static void
+copy_reg (unsigned int reg, frame_state *udata,	/* { dg-error "parse|syntax|expected" } */
+	  frame_state *target_udata)	/* { dg-error "expected" } */
+{  
+  word_type *preg = get_reg_addr (reg, udata, 0);	/* { dg-error "undeclared|function|without a cast" } */
+  word_type *ptreg = get_reg_addr (reg, target_udata, 0); /* { dg-error "undeclared|without a cast" } */
+   
+  memcpy (ptreg, preg, __builtin_dwarf_reg_size (reg));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/const-ll-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/const-ll-1.c
new file mode 100644
index 000000000..cac3af6aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/const-ll-1.c
@@ -0,0 +1,24 @@
+/* Test for broken long long suffixes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+
+/* The following are valid integer suffixes, according to C99:
+
+   no suffix
+   u or U
+   ul, uL, Ul or UL
+   ull, uLL, Ull or ULL
+   l or L
+   lu, lU, Lu or LU
+   llu, llU, LLu or LLU
+
+   The following are not but have been accepted by GCC in the past:
+
+   lul and case variants (the 'l's being separated by a 'u')
+   lL, Ll and variants with a 'u' (mixed case pair of 'l's)
+
+   (cpplib gets this right when processing #if expressions.)
+
+*/
+
+unsigned long long a = 1LUL; /* { dg-error "lul|LUL" "error for LUL suffix" } */
+long long b = 1Ll; /* { dg-error "Ll" "error for Ll suffix" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-1.c
new file mode 100644
index 000000000..773643b3f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-1.c
@@ -0,0 +1,4 @@
+struct a
+{
+  struct b t;	/* { dg-error "has incomplete type" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-2.c
new file mode 100644
index 000000000..0c707e372
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-2.c
@@ -0,0 +1,12 @@
+/* Origin: <steven@gcc.gnu.org>
+   Make sure we do not ICE when the type in the function
+   argument list is incomplete (Bug 10602).  */
+/* { dg-options "-w" } */
+
+int g95_type_for_mode (enum machine_mode);
+
+int
+g95_type_for_mode (enum machine_mode mode) /* { dg-error "incomplete type" } */
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-3.c
new file mode 100644
index 000000000..735ef465b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-3.c
@@ -0,0 +1,9 @@
+/* Both occurrences of "c" should get diagnostics.  PR 12391.  */
+typedef struct { int a; } b_t;
+
+int foo (void)
+{
+  b_t d;
+  struct b_t *c = &d;	/* { dg-warning "incompatible pointer type" } */
+  c->a;			/* { dg-error "incomplete type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-4.c
new file mode 100644
index 000000000..a4f47694d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/incomplete-4.c
@@ -0,0 +1,4 @@
+void foo()
+{
+  enum E e; /* { dg-error "storage size" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-1.c
new file mode 100644
index 000000000..007991b6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-1.c
@@ -0,0 +1,17 @@
+struct a
+{ double a, b, c; };
+
+struct b
+{
+  struct a arr[6];
+};
+
+static struct b a_b =
+{
+  {0,0,0},
+  {0,0,0},	/* { dg-error "extra brace|excess elements|near" } */
+  {0,0,0},	/* { dg-error "extra brace|excess elements|near" } */
+  {0,0,0},	/* { dg-error "extra brace|excess elements|near" } */
+  {0,0,0},	/* { dg-error "extra brace|excess elements|near" } */
+  {0,0,0},	/* { dg-error "extra brace|excess elements|near" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-2.c
new file mode 100644
index 000000000..b0699023a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-2.c
@@ -0,0 +1 @@
+int d[][] = { {1}, {2}, {3} };	/* { dg-error "incomplete element type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-3.c
new file mode 100644
index 000000000..fe9543522
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-3.c
@@ -0,0 +1,4 @@
+void die(void)
+{
+  char foo[BAR] = "1234"; /* { dg-error "undeclared|function|incomplete type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-4.c
new file mode 100644
index 000000000..782251fa3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-4.c
@@ -0,0 +1 @@
+struct a { char *b; } c[D]; /* { dg-error "undeclared" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-5.c
new file mode 100644
index 000000000..366397aef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/init-5.c
@@ -0,0 +1,4 @@
+/* Test for ICE after syntax error in initializer with range
+   designator: PR 35446.  */
+
+int a[2][2] = { [0 ... 1] = { ; } }; /* { dg-error "expected expression" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/invalid_asm.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/invalid_asm.c
new file mode 100644
index 000000000..0cb14799f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/invalid_asm.c
@@ -0,0 +1,4 @@
+asm_invalid_register_name()
+{
+  asm("":::"this_is_an_invalid_register_name");	/* { dg-error "unknown register" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/label-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/label-1.c
new file mode 100644
index 000000000..58d212f96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/label-1.c
@@ -0,0 +1,175 @@
+/* Test various diagnostics of ill-formed constructs involving labels.  */
+/* { dg-do compile } */
+/* { dg-options "-Wunused" } */
+
+extern void dummy(void);
+
+/* labels must be defined */
+void a(void)
+{
+  goto l;   /* { dg-error "used but not defined" "no label" } */
+}
+
+/* warnings for labels defined but not used, or declared but not defined */
+void b(void)
+{
+  __label__ l;
+ l:  /* { dg-warning "defined but not used"  "no goto 1" } */
+ m:  /* { dg-warning "defined but not used"  "no goto 2" } */
+  dummy();
+}
+
+void c(void)
+{
+  __label__ l;  /* { dg-warning "declared but not defined" "only __label__" } */
+  dummy();
+}
+
+/* can't have two labels with the same name in the same function */
+void d(void)
+{
+ l: dummy();  /* { dg-message "note: previous definition" "prev def same scope" } */
+ l: dummy();  /* { dg-error "duplicate label" "dup label same scope" } */
+ goto l;
+}
+
+/* even at different scopes */
+void e(void)
+{
+ l: dummy();	/* { dg-message "note: previous definition"  "prev def diff scope" } */
+  {
+  l: dummy();	/* { dg-error "duplicate label" "dup label diff scope" } */
+  }
+  goto l;
+}
+
+/* but, with __label__, you can */
+void f(void)
+{
+ l: dummy();
+  {
+    __label__ l;
+    l: dummy();	  /* { dg-warning "defined but not used" "unused shadow 1" } */
+  };
+  goto l;  /* this reaches the outer l */
+}
+
+/* a __label__ is not visible outside its scope */
+void g(void)
+{
+  dummy();
+  {
+    __label__ l;
+    l: dummy();
+    goto l;
+  }
+  goto l;  /* { dg-error "used but not defined" "label ref out of scope" } */
+}
+
+/* __label__ can appear at top level of a function, too...
+   ... but doesn't provide a definition of the label */
+void h(void)
+{
+  __label__ l;
+  dummy ();
+
+  goto l;  /* { dg-error "used but not defined" "used, only __label__" } */
+}
+
+/* A nested function may not goto a label outside itself  */
+void i(void)
+{
+  auto void nest(void);
+
+ l: nest();
+  
+  void nest(void)
+    {
+      goto l;  /* { dg-error "used but not defined" "nest use outer label" } */
+    }
+
+  goto l; /* reaches the outer l */
+}
+
+/* which means that a nested function may have its own label with the
+   same name as the outer function */
+void j(void)
+{
+  auto void nest(void);
+
+ l: nest();
+  
+  void nest(void)
+    {
+    l: dummy(); /* { dg-warning "defined but not used" "nest label same name" } */
+    }
+
+  goto l; /* reaches the outer l */
+}
+
+/* and, turnabout, an outer function may not goto a label in a nested
+   function */
+void k(void)
+{
+  void nest(void)
+  {
+  l: dummy();  /* { dg-warning "defined but not used" "outer use nest label" } */
+  }
+
+  goto l; /* { dg-error "used but not defined" "outer use nest label" } */
+  nest();
+}
+
+/* not even with __label__ */
+void l(void)
+{
+  void nest(void)
+  {
+    __label__ l;
+  l: dummy(); /* { dg-warning "defined but not used" "outer use nest __label__" } */
+  }
+
+  goto l; /* { dg-error "used but not defined" "outer use nest __label__" } */
+  nest();
+}
+
+
+/* but if the outer label is declared with __label__, then a nested
+   function can goto that label (accomplishing a longjmp) */
+void m(void)
+{
+  __label__ l;
+  void nest(void) { goto l; }
+  nest();
+  dummy();
+ l:;
+}
+
+/* and that means the nested function cannot have its own label with
+   the same name as an outer label declared with __label__ */
+
+void n(void)
+{
+  __label__ l; /* { dg-message "note: previous declaration" "outer label decl" } */
+  void nest(void)
+    {
+    l: goto l;  /* { dg-error "duplicate label" "inner label defn" } */
+    }
+
+ l:
+  nest();
+}
+
+/* unless the nested function uses __label__ too!  */
+void o(void)
+{
+  __label__ l;
+  void nest(void)
+    {
+      __label__ l;
+    l: goto l;
+    }
+
+ l: goto l;
+ nest();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c
new file mode 100644
index 000000000..6d4def7ea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c
@@ -0,0 +1,14 @@
+/* Ensure that diagnostics for labels appear on the correct lineno.
+   by Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/23/2000.  */
+
+void
+foo(int i)
+{
+ my_label: /* { dg-message "note: previous definition" "prev label" } */
+
+  i++;
+
+ my_label: /* { dg-error "duplicate label" "label lineno" } */
+
+  i++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/noncompile.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/noncompile.exp
new file mode 100644
index 000000000..cc77a7d2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/noncompile.exp
@@ -0,0 +1,25 @@
+#   Copyright (C) 1997, 2000, 2007 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/>.
+
+# Test error reporting.
+# Don't run this directory with any default CFLAGS, but do cycle through
+# torture options.
+
+load_lib gcc-dg.exp
+
+dg-init
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] ""
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/old-style-parm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/old-style-parm-1.c
new file mode 100644
index 000000000..5f879c3f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/old-style-parm-1.c
@@ -0,0 +1,11 @@
+/* Test that stray semicolon in old-style parameters is not
+   accepted.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f(a)
+     int a;; /* { dg-error "parse error|syntax error|expected declaration specifiers" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/old-style-parm-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/old-style-parm-2.c
new file mode 100644
index 000000000..1b156b770
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/old-style-parm-2.c
@@ -0,0 +1,11 @@
+/* Test that parameter without declaration specifiers in old-style
+   parameters is not accepted.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f(a)
+     a; /* { dg-error "parse error|syntax error|no type or storage class|expected declaration specifiers" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr23576.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr23576.c
new file mode 100644
index 000000000..384b0f68c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr23576.c
@@ -0,0 +1 @@
+struct ipr_path_entry path[0]; /* { dg-error "array type has incomplete element type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35444-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35444-1.c
new file mode 100644
index 000000000..f85588786
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35444-1.c
@@ -0,0 +1,3 @@
+/* PR 35444: ICE from pending VLA sizes in invalid parameter list.  */
+void foo(int n, int a[n], int 0); /* { dg-error "expected" } */
+void bar() {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35444-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35444-2.c
new file mode 100644
index 000000000..43817b90d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35444-2.c
@@ -0,0 +1,4 @@
+/* PR 35444: ICE from pending VLA sizes in invalid parameter list.
+   Similar case to the PR, but with "..." before the syntax error.  */
+void foo(int n, int a[n], ... 0); /* { dg-error "expected" } */
+void bar() {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35447-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35447-1.c
new file mode 100644
index 000000000..9c31e9bb6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr35447-1.c
@@ -0,0 +1,7 @@
+/* ICE arising from preparing to enter a scope for a nested function
+   but never doing so.  PR 35447.  */
+
+void foo()
+{
+  ({ int i().; }); /* { dg-error "expected" } */
+} /* { dg-error "expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr40033-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr40033-1.c
new file mode 100644
index 000000000..4f0744207
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/pr40033-1.c
@@ -0,0 +1,7 @@
+/* ICE from error_mark_node being wrapped in a C_MAYBE_CONST_EXPR.  PR
+   40033.  */
+
+void foo()
+{
+  ({ 0,; }); /* { dg-error "expected" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/redecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/redecl-1.c
new file mode 100644
index 000000000..732db0098
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/redecl-1.c
@@ -0,0 +1,9 @@
+/* Copyright 2000  Free Software Foundation */
+/* by Alexandre Oliva  <aoliva@redhat.com> */
+
+int
+foo ()
+{
+  int bar; /* { dg-message "note: previous.*decl" "previous.*decl" } */
+  volatile int bar; /* { dg-error "conflicting type qualifiers" "conflicting type qualifiers" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/scope.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/scope.c
new file mode 100644
index 000000000..7f09c27cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/scope.c
@@ -0,0 +1,19 @@
+extern void abort (void);
+extern void exit (int);
+static int v = 3;
+
+f ()
+{
+  int v = 4;
+  {
+    extern int v; /* { dg-error "static" } */  
+    if (v != 3)
+      abort ();
+  }
+}
+
+main ()
+{
+  f ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/undeclared-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/undeclared-1.c
new file mode 100644
index 000000000..5bb7c2a4d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/undeclared-1.c
@@ -0,0 +1,8 @@
+/* Test for no ICE with an undeclared identifier in an enum in old-style
+   parameter decls.  PR 12560.  */
+/* { dg-options "-w" } */
+
+foo(c)
+     enum { a = b } c;  /* { dg-error "undeclared|for each" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/undeclared-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/undeclared-2.c
new file mode 100644
index 000000000..36cd0eaf1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/undeclared-2.c
@@ -0,0 +1,3 @@
+/* Invalid, but should not ICE.  PRs 11944, 14734.  */
+
+void foo(const int[i]);  /* { dg-error "undeclared|for each" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/va-arg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/va-arg-1.c
new file mode 100644
index 000000000..b8b7d3c31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/va-arg-1.c
@@ -0,0 +1,8 @@
+#include <stdarg.h>
+
+f (int x, ...)
+{
+  va_list args;
+  va_start (args, bogus_variable);  /* { dg-error "undeclared|for each function|not last named" } */
+  va_end (args);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/voidparam-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/voidparam-1.c
new file mode 100644
index 000000000..3378adddf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noncompile/voidparam-1.c
@@ -0,0 +1,17 @@
+/* Test for bad uses of 'void' in parameter lists.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+
+typedef const void cv;
+typedef volatile void vv;
+
+void foo0 (const void); /* { dg-error "parameter" "const void decl" } */
+void foo0a (cv); /* { dg-error "parameter" "const void decl" } */
+void foo1 (volatile void); /* { dg-error "parameter" "volatile void decl" } */
+void foo1a (vv); /* { dg-error "parameter" "volatile void decl" } */
+void foo2 (register void); /* { dg-error "parameter" "register void decl" } */
+
+void bar0 (const void) { } /* { dg-error "parameter" "const void defn" } */
+void bar0a (cv) { } /* { dg-error "parameter" "const void defn" } */
+void bar1 (volatile void) { } /* { dg-error "parameter" "volatile void defn" } */
+void bar1a (vv) { } /* { dg-error "parameter" "volatile void defn" } */
+void bar2 (register void) { } /* { dg-error "parameter" "register void defn" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-1.c
new file mode 100644
index 000000000..51a8a3373
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-1.c
@@ -0,0 +1,39 @@
+/* Test for the "nonnull" function attribute.  */
+/* Origin: Jason Thorpe <thorpej@wasabisystems.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wnonnull" } */
+
+#include <stddef.h>
+
+extern void func1 (char *, char *, int) __attribute__((nonnull));
+
+extern void func2 (char *, char *) __attribute__((nonnull(1)));
+
+extern void func3 (char *, int, char *, int)
+  __attribute__((nonnull(1,3)));
+
+extern void func4 (char *, char *) __attribute__((nonnull(1)))
+  __attribute__((nonnull(2)));
+
+void
+foo (int i1, int i2, int i3, char *cp1, char *cp2, char *cp3)
+{
+  func1(cp1, cp2, i1);
+
+  func1(NULL, cp2, i1); /* { dg-warning "null" "null with argless nonnull 1" } */
+  func1(cp1, NULL, i1); /* { dg-warning "null" "null with argless nonnull 2" } */
+  func1(cp1, cp2, 0);
+
+  func2(cp1, NULL);
+  func2(NULL, cp1); /* { dg-warning "null" "null with single explicit nonnull" } */
+
+  func3(NULL, i2, cp3, i3); /* { dg-warning "null" "null with explicit nonnull 1" } */
+  func3(cp3, i2, NULL, i3); /* { dg-warning "null" "null with explicit nonnull 3" } */
+
+  func1(i1 ? cp1 : NULL, cp2, i3); /* { dg-warning "null" "null with cond expr rhs" } */
+  func1(i1 ? NULL : cp1, cp2, i3); /* { dg-warning "null" "null with cond expr lhs" } */
+  func1(i1 ? (i2 ? cp1 : NULL) : cp2, cp3, i3); /* { dg-warning "null" "null with nested cond expr" } */
+
+  func4(NULL, cp1); /* { dg-warning "null" "null with multiple attributes 1" } */
+  func4(cp1, NULL); /* { dg-warning "null" "null with multiple attributes 2" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-2.c
new file mode 100644
index 000000000..bd36d232d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-2.c
@@ -0,0 +1,16 @@
+/* Test for the invalid use of the "nonnull" function attribute.  */
+/* Origin: Jason Thorpe <thorpej@wasabisystems.com> */
+/* { dg-do compile } */
+
+extern void func1 () __attribute__((nonnull)); /* { dg-error "without arguments" } */
+
+extern void func2 (char *) __attribute__((nonnull(2))); /* { dg-error "out-of-range operand" } */
+
+extern void func3 (char *) __attribute__((nonnull(foo))); /* { dg-error "invalid operand number" } */
+
+extern void func4 (int) __attribute__((nonnull(1))); /* { dg-error "references non-pointer" } */
+
+void
+foo (void)
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-3.c
new file mode 100644
index 000000000..040248c53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nonnull-3.c
@@ -0,0 +1,82 @@
+/* Test for the "nonnull" function attribute on builtins.  Use the
+   "__builtin_" style below so we don't need prototypes.  */
+/* Origin: Kaveh R. Ghazi <ghazi@caip.rutgers.edu> */
+/* { dg-do compile } */
+/* { dg-options "-Wnonnull" } */
+
+#include <stddef.h>
+
+void
+foo (void *p, char *s)
+{
+  __builtin_bzero (NULL, 0);
+  __builtin_bcopy (NULL, p, 0);
+  __builtin_bcopy (p, NULL, 0);
+  __builtin_bcmp (NULL, p, 0);
+  __builtin_bcmp (p, NULL, 0);
+  __builtin_index (NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_rindex (NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+
+  __builtin_memcpy (p, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_memcpy (NULL, p, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_memmove (p, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_memmove (NULL, p, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_memcmp (p, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_memcmp (NULL, p, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_memset (NULL, 0, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_mempcpy (p, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_mempcpy (NULL, p, 16);  /* { dg-warning "null" "null pointer check" } */
+
+  __builtin_strcat (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcat (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncat (NULL, s, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncat (s, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_stpcpy (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_stpcpy (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_stpncpy (NULL, s, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_stpncpy (s, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcpy (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcpy (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncpy (NULL, s, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncpy (s, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcasecmp (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcasecmp (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncasecmp (NULL, s, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncasecmp (s, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcmp (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strcmp (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncmp (NULL, s, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strncmp (s, NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strlen (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strstr (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strstr (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strpbrk (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strpbrk (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strspn (NULL, s);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strspn (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strchr (NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strrchr (NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strdup (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_strndup (NULL, 16);  /* { dg-warning "null" "null pointer check" } */
+
+  __builtin_nan (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_nanf (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_nanl (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_nans (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_nansf (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_nansl (NULL);  /* { dg-warning "null" "null pointer check" } */
+
+  __builtin_puts (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fputc (*s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fputs (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fputs (NULL, p);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fwrite (s, 16, 16, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fwrite (NULL, 16, 16, p);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_puts_unlocked (NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fputc_unlocked (*s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fputs_unlocked (s, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fputs_unlocked (NULL, p);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fwrite_unlocked (s, 16, 16, NULL);  /* { dg-warning "null" "null pointer check" } */
+  __builtin_fwrite_unlocked (NULL, 16, 16, p);  /* { dg-warning "null" "null pointer check" } */
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-1.c
new file mode 100644
index 000000000..1e7a77810
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-1.c
@@ -0,0 +1,59 @@
+/* Check for various valid and erroneous "noreturn" cases. */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wmissing-noreturn" } */
+
+extern void exit (int);
+
+extern void foo1(void) __attribute__ ((__noreturn__));
+void
+foo1(void)
+{
+} /* { dg-warning "'noreturn' function does return" "detect falling off end of noreturn" } */
+
+extern void foo2(void) __attribute__ ((__noreturn__));
+void
+foo2(void)
+{
+  exit(0);
+} /* { dg-bogus "warning:" "this function should not get any warnings" } */
+
+extern void foo3(void);
+void
+foo3(void)
+{
+} /* { dg-bogus "warning:" "this function should not get any warnings" } */
+
+extern void foo4(void);
+void
+foo4(void) /* { dg-warning "candidate for attribute 'noreturn'" "detect noreturn candidate" } */
+{
+  exit(0);
+}
+
+extern void foo5(void) __attribute__ ((__noreturn__));
+void
+foo5(void)
+{
+  return; /* { dg-warning "'noreturn' has a 'return' statement" "detect invalid return" } */
+} /* { dg-warning "function does return" "detect return from noreturn" } */
+
+extern void foo6(void);
+void
+foo6(void)
+{
+  return;
+} /* { dg-bogus "warning:" "this function should not get any warnings" } */
+
+extern void foo7(void);
+void
+foo7(void)
+{
+  foo6();
+} /* { dg-bogus "warning:" "this function should not get any warnings" } */
+
+extern void foo8(void) __attribute__ ((__noreturn__));
+void
+foo8(void)
+{
+  foo7();
+} /* { dg-warning "'noreturn' function does return" "detect return from tail call" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-2.c
new file mode 100644
index 000000000..4214de314
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-2.c
@@ -0,0 +1,12 @@
+/* Check for invalid "noreturn" warning. */
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wall" } */
+extern void abort (void) __attribute__ ((__noreturn__));
+
+void noreturn (int x) __attribute__ ((__noreturn__));
+
+void
+noreturn (int x)
+{
+  abort ();
+} /* { dg-bogus "does return" "noreturn does return" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-3.c
new file mode 100644
index 000000000..3e727d25f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-3.c
@@ -0,0 +1,10 @@
+/* Check for no "noreturn" warning in main. */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wmissing-noreturn -fhosted" } */
+extern void exit (int) __attribute__ ((__noreturn__));
+
+int
+main (void)
+{
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-4.c
new file mode 100644
index 000000000..bcc29dac6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-4.c
@@ -0,0 +1,10 @@
+/* Check for "noreturn" warning in main. */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wmissing-noreturn -ffreestanding" } */
+extern void exit (int) __attribute__ ((__noreturn__));
+
+int
+main (void) /* { dg-warning "function might be possible candidate for attribute 'noreturn'" "warn for main" } */
+{
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-5.c
new file mode 100644
index 000000000..e69087a4d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-5.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+/* Check that 'noreturn' and 'volatile extern' are compatible.  
+   The testsuite uses -ansi -pedantic-errors by default, so this has
+   to override.  */
+extern void xxx (int) __attribute__((noreturn));
+typedef void voidfn (int);
+__volatile extern voidfn xxx;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-6.c
new file mode 100644
index 000000000..eb1fd2437
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-6.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* Check for volatile behaviour.  */
+extern int xxx (void);
+volatile extern int xxx (void);  /* { dg-error "not compatible" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-7.c
new file mode 100644
index 000000000..1913be1fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/noreturn-7.c
@@ -0,0 +1,42 @@
+/* PR optimization/13394 */
+/* Origin: Carlo Wood <carlo@gcc.gnu.org> */
+
+/* Verify that a bogus "function does return" warning is not issued
+   in presence of tail recursion within a noreturn function.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wreturn-type -Wmissing-noreturn" } */
+
+
+void f(void) __attribute__ ((__noreturn__));
+void _exit(int status) __attribute__ ((__noreturn__));
+
+int z = 0;
+
+void g() /* { dg-warning "possible candidate" } */
+{
+  if (++z > 10)
+    _exit(0);
+  g();
+}
+
+void f()
+{
+  if (++z > 10)
+    _exit(0);
+  f();
+}             /* { dg-bogus "does return" } */
+
+int h() /* { dg-warning "possible candidate" } */
+{
+  if (++z > 10)
+    _exit(0);
+  return h();
+}             /* { dg-bogus "end of non-void function" } */
+
+int k() /* { dg-warning "possible candidate" } */
+{
+  if (++z > 10)
+    _exit(0);
+  k();
+}             /* { dg-warning "control reaches" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv1.c
new file mode 100644
index 000000000..ca700924a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv1.c
@@ -0,0 +1,28 @@
+/* Test that the NRV optimization doesn't cause a1 to change too soon.  This
+   is equivalent to c++/19317.  */
+/* { dg-do run } */
+
+void abort (void);
+
+struct A
+{
+  int i[100];
+};
+
+struct A a1;
+
+struct A f ()
+{
+  struct A a2;
+  a2.i[0] = 42;
+  /* a1.i[0] should still be 0 until we return. */
+  if (a1.i[0] != 0)
+    abort ();
+  return a2;
+}
+
+int main()
+{
+  a1 = f();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv2.c
new file mode 100644
index 000000000..e4d1f9aba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv2.c
@@ -0,0 +1,25 @@
+/* Test that the tree_nrv pass works by making sure that we don't generate
+   a memcpy.  Throw in a bit of control flow to make its job a bit harder.  */
+
+/* { dg-options "-O" } */
+
+struct A { int i[100]; };
+
+int b;
+
+struct A f ()
+{
+  struct A a;
+  if (b)
+    {
+      a.i[0] = 42;
+      return a;
+    }
+  else
+    {
+      a.i[42] = 1;
+      return a;
+    }
+}
+
+/* { dg-final { scan-assembler-not "memcpy" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv3.c
new file mode 100644
index 000000000..c28b8ec57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv3.c
@@ -0,0 +1,35 @@
+/* Verify that gimple-level NRV is occurring when values other than the
+   return slot are call-clobbered.  */
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+#ifdef __SPU__
+/* SPU returns aggregates up to 1172 bytes in registers.  */
+typedef struct { int x[300]; void *y; } S;
+#else
+typedef struct { int x[20]; void *y; } S;
+#endif
+typedef struct { int a; S b; } T;
+S nrv_candidate (void);
+void use_result (S, int);
+int *ptr;
+void foo (void)
+{
+  S result;
+  T result_arr[10][5];
+
+  int i;
+
+  ptr = &i;
+
+  /* i is call-clobbered for these calls, but result and result_arr
+     aren't.  */
+  result = nrv_candidate ();
+  result_arr[3][4].b = nrv_candidate ();
+
+  use_result (result, i);
+  use_result (result_arr[3][4].b, i);
+}
+
+/* { dg-final { scan-tree-dump-times "return slot optimization" 2 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv4.c
new file mode 100644
index 000000000..e213d860e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv4.c
@@ -0,0 +1,33 @@
+/* Verify that NRV optimizations are prohibited when the LHS is an
+   indirect reference to something that may be call-clobbered. */
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+typedef struct { int x[20]; void *y; } S;
+S nrv_candidate (void);
+void use_result (S);
+void make_escape (S *);
+S global_S;
+void foo (void)
+{
+  S *result;
+  S local_S;
+
+  /* We can't perform return slot optimization because global_S is
+     global and may be clobbered by nrv_candidate.  */
+  result = &global_S;
+  *result = nrv_candidate ();
+  use_result (*result);
+
+  /* We can't perform return slot optimization because local_S is
+     call_clobbered (its address escapes prior to invoking
+     nrv_candidate).  */
+  make_escape (&local_S);
+  result = &local_S;
+  *result = nrv_candidate ();
+  use_result (*result);
+}
+
+/* { dg-final { scan-tree-dump-times "return slot optimization" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv5.c
new file mode 100644
index 000000000..629b0f329
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/nrv5.c
@@ -0,0 +1,28 @@
+/* Verify that NRV optimizations are prohibited when the LHS is
+   something that may be call-clobbered. */
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+typedef struct { int x[20]; void *y; } S;
+typedef struct { int a; S b; } T;
+S nrv_candidate (void);
+void use_result (S);
+void make_escape (S *);
+void foo (void)
+{
+  S result;
+  T result_arr[10][5];
+
+  make_escape (&result);
+  make_escape (&(result_arr[3][4].b));
+
+  /* Neither call should be allowed to use NRV optimization.  */
+  result = nrv_candidate ();
+  result_arr[3][4].b = nrv_candidate ();
+
+  use_result (result);
+  use_result (result_arr[3][4].b);
+}
+
+/* { dg-final { scan-tree-dump-times "return slot optimization" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/null-pointer-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/null-pointer-1.c
new file mode 100644
index 000000000..8cc15c6d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/null-pointer-1.c
@@ -0,0 +1,20 @@
+/* PR c/13382 */
+/* Origin: Richard Hutchinson <richard.hutchinson@asa.co.uk> */
+
+/* Verify that the null initializer is converted to the right
+   pointer type.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+struct t
+{
+  int aMember;
+};
+
+struct t *const aPointer = 0;
+
+void foo()
+{
+  int anInt = (aPointer == 0) ? 0 : aPointer->aMember;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-asm-1.c
new file mode 100644
index 000000000..8af007795
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-asm-1.c
@@ -0,0 +1,23 @@
+/* PR inline-asm/8832 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -dP" } */
+
+/* Verify that GCC doesn't optimize
+   old style asm instructions.  */
+
+void foo(int v)
+{
+  if (v)
+    asm ("dummy1");
+
+  asm ("dummy2");
+
+  if (v)
+    asm ("dummy3");
+}
+
+/* The purpose of the test below is to check that there are two branches
+   in the generated code, supposedly corresponding to the if-statements.
+   It tries to check for jump_insn (set (pc) pattern, so that jump_insns
+   corresponding to return are not taken into account.  */
+/* { dg-final { scan-assembler "jump_insn.*set \\(pc\\).*jump_insn.*set \\(pc\\)"} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-param-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-param-1.c
new file mode 100644
index 000000000..1742069c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-param-1.c
@@ -0,0 +1,4 @@
+/* PR c/35750 */
+
+void foo(int[]);
+void foo(x) int x[](); {} /* { dg-error "array of functions" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-1.c
new file mode 100644
index 000000000..165ff9827
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-1.c
@@ -0,0 +1,13 @@
+/* Test for prototype followed by old-style definition, as in
+   dremf-type-compat-1.c but with a non-built-in function.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+float f (float, float);
+
+float
+f (x, y)
+     float x, y;
+{
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-2.c
new file mode 100644
index 000000000..0460facef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-2.c
@@ -0,0 +1,14 @@
+/* Test for prototype followed by old-style definition, as in
+   dremf-type-compat-2.c but with a non-built-in function.  */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+float f (float, float); /* { dg-warning "prototype declaration" } */
+
+float
+f (x, y)
+     float x;
+     float y;
+{ /* { dg-warning "promoted argument '.' doesn't match prototype" } */
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-3.c
new file mode 100644
index 000000000..931a4a726
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-prom-3.c
@@ -0,0 +1,14 @@
+/* Test for prototype followed by old-style definition, as in
+   dremf-type-compat-3.c but with a non-built-in function.  */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+float f (float, float); /* { dg-error "prototype declaration" } */
+
+float
+f (x, y)
+     float x;
+     float y;
+{ /* { dg-error "promoted argument '.' doesn't match prototype" } */
+  return x + y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-then-proto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-then-proto-1.c
new file mode 100644
index 000000000..7d76287b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/old-style-then-proto-1.c
@@ -0,0 +1,44 @@
+/* Test for old-style definition followed by prototype declaration.
+   Mismatched qualifiers used to be wrongly forbidden.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f1() {}
+void f1(void); /* { dg-warning "prototype for 'f1' follows non-prototype definition" } */
+
+void f2() {} /* { dg-message "note: previous definition of 'f2' was here" } */
+void f2(int); /* { dg-error "prototype for 'f2' declares more arguments than previous old-style definition" } */
+
+void f3(a) int a; {} /* { dg-message "note: previous definition of 'f3' was here" } */
+void f3(void); /* { dg-error "prototype for 'f3' declares fewer arguments than previous old-style definition" } */
+
+void f4(a) int a; {}
+void f4(int); /* { dg-warning "prototype for 'f4' follows non-prototype definition" } */
+
+void f5(a) int a; {} /* { dg-message "note: previous definition of 'f5' was here" } */
+void f5(int, int); /* { dg-error "prototype for 'f5' declares more arguments than previous old-style definition" } */
+
+void f6(a) int a; {} /* { dg-message "note: previous definition of 'f6' was here" } */
+void f6(int, ...); /* { dg-error "conflicting types for 'f6'" } */
+
+void f7(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f7' was here" } */
+void f7(int); /* { dg-error "prototype for 'f7' declares fewer arguments than previous old-style definition" } */
+
+void f8(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f8' was here" } */
+void f8(int, ...); /* { dg-error "conflicting types for 'f8'" } */
+
+void f9(a, b) int a, b; {}
+void f9(int, int); /* { dg-warning "prototype for 'f9' follows non-prototype definition" } */
+
+void f10(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f10' was here" } */
+void f10(int, long); /* { dg-error "prototype for 'f10' declares argument 2 with incompatible type" } */
+
+void f11(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f11' was here" } */
+void f11(long, int); /* { dg-error "prototype for 'f11' declares argument 1 with incompatible type" } */
+
+void f12(a, b) const int a; volatile int b; {}
+void f12(volatile int, const int); /* { dg-warning "prototype for 'f12' follows non-prototype definition" } */
+
+void f13(a) const int a[2][2]; {} /* { dg-message "note: previous definition of 'f13' was here" } */
+void f13(volatile int [2][2]); /* { dg-error "prototype for 'f13' declares argument 1 with incompatible type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/out-of-bounds-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/out-of-bounds-1.c
new file mode 100644
index 000000000..8cdf643eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/out-of-bounds-1.c
@@ -0,0 +1,13 @@
+/* PR rtl-optimization/33822 */
+/* Origin: Andrew Pinski <pinskia@gcc.gnu.org> */
+
+/* { dg-do compile } */
+/* { dg-options "-O -g" } */
+/* { dg-options "-O -g -mstrict-align" { target { powerpc*-*-linux* powerpc*-*-elf* } } } */
+
+void ProjectOverlay(const float localTextureAxis[2], char *lump)
+{
+   const void *d = &localTextureAxis;
+   int size = sizeof(float)*8 ;
+   __builtin_memcpy( &lump[ 0 ], d, size );  
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-1.c
new file mode 100644
index 000000000..db51a5ef1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-1.c
@@ -0,0 +1,25 @@
+/* PR optimization/13318 */
+/* Origin: <bremner@unb.ca> */
+/* Reduced testcase: Wolfgang Bangerth <bangerth@dealii.org> */
+
+/* Verify that the big multiplier doesn't cause an integer
+   overflow in the loop optimizer.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+struct S {
+  int key;
+  int rnext,rprev;
+};
+ 
+void foo(struct S* H)
+{
+  int i, k;
+  for (i=0; i<2; i++){
+    struct S* cell=H+k;
+    cell->key=i*(0xffffffffUL/2);
+    cell->rnext=k+(1-i);
+    cell->rprev=k+(1-i);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-2.c
new file mode 100644
index 000000000..23c22a65d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+/* PR c/24599 */
+
+int
+main (void)
+{
+  if ((_Bool)(__INT_MAX__ + 1)) /* { dg-warning "overflow in expression" } */
+    return 1;
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-1.c
new file mode 100644
index 000000000..9f763879f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-1.c
@@ -0,0 +1,121 @@
+/* Test for diagnostics for constant overflow.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+#include <limits.h>
+
+enum e {
+  E0 = INT_MAX,
+  /* Unsigned overflow wraps around.  */
+  E1 = UINT_MAX + 1,
+  /* Overflow in an unevaluated part of an expression is OK (example
+     in the standard).  */
+  E2 = 2 || 1 / 0,
+  E3 = 1 / 0, /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
+  /* But as in DR#031, the 1/0 in an evaluated subexpression means the
+     whole expression violates the constraints.  */
+  E4 = 0 * (1 / 0), /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
+  E5 = INT_MAX + 1, /* { dg-warning "integer overflow in expression" } */
+  /* Again, overflow in evaluated subexpression.  */
+  E6 = 0 * (INT_MAX + 1), /* { dg-warning "integer overflow in expression" } */
+  /* A cast does not constitute overflow in conversion.  */
+  E7 = (char) INT_MAX
+};
+
+struct s {
+  int a;
+  int : 0 * (1 / 0); /* { dg-warning "division by zero" } */
+  int : 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+};
+
+void
+f (void)
+{
+  /* This expression is not required to be a constant expression, so
+     it should just involve undefined behavior at runtime.  */
+  int c = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+}
+
+/* But this expression does need to be constant.  */
+static int sc = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+
+/* The first two of these involve overflow, so are not null pointer
+   constants.  The third has the overflow in an unevaluated
+   subexpression, so is a null pointer constant.  */
+void *p = 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+/* { dg-warning "initialization makes pointer from integer without a cast" "null" { target *-*-* } 48 } */
+void *q = 0 * (1 / 0); /* { dg-warning "division by zero" } */
+/* { dg-warning "initialization makes pointer from integer without a cast" "null" { xfail *-*-* } 50 } */
+void *r = (1 ? 0 : INT_MAX+1);
+
+void
+g (int i)
+{
+  switch (i)
+    {
+    case 0 * (1/0): /* { dg-warning "division by zero" } */
+      ;
+    case 1 + 0 * (INT_MAX + 1): /* { dg-warning "integer overflow in expression" } */
+      ;
+    }
+}
+
+int
+h (void)
+{
+  return INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+}
+
+int
+h1 (void)
+{
+  return INT_MAX + 1 - INT_MAX; /* { dg-warning "integer overflow in expression" } */
+}
+
+void fuc (unsigned char);
+void fsc (signed char);
+
+void
+h2 (void)
+{
+  fsc (SCHAR_MAX + 1);
+  fsc (SCHAR_MIN - 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (UCHAR_MAX);
+  fsc (UCHAR_MAX + 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fuc (-1);
+  fuc (UCHAR_MAX + 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  fuc (SCHAR_MIN);
+  fuc (SCHAR_MIN - 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  fuc (-UCHAR_MAX); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+}
+
+void fui (unsigned int);
+void fsi (signed int);
+
+int si;
+unsigned ui;
+
+void
+h2i (int x)
+{
+  /* For some reason, we only give certain warnings for implicit
+     conversions among values of the same precision with -Wconversion,
+     while we don't give others at all.  */
+  fsi ((unsigned)INT_MAX + 1);
+  si = (unsigned)INT_MAX + 1;
+  si = x ? (unsigned)INT_MAX + 1 : 1;
+  fsi ((unsigned)INT_MAX + 2);
+  si = (unsigned)INT_MAX + 2;
+  si = x ? (unsigned)INT_MAX + 2 : 1;
+  fsi (UINT_MAX);
+  si = UINT_MAX;
+  fui (-1);
+  ui = -1;
+  ui = x ? -1 : 1U;
+  fui (INT_MIN);
+  ui = INT_MIN;
+  ui = x ? INT_MIN : 1U;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-2.c
new file mode 100644
index 000000000..7da84324a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-2.c
@@ -0,0 +1,132 @@
+/* Test for diagnostics for constant overflow.  Test with -Wtraditional-conversion.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Wtraditional-conversion" } */
+
+#include <limits.h>
+
+enum e {
+  E0 = INT_MAX,
+  /* Unsigned overflow wraps around.  */
+  E1 = UINT_MAX + 1,
+  /* Overflow in an unevaluated part of an expression is OK (example
+     in the standard).  */
+  E2 = 2 || 1 / 0,
+  E3 = 1 / 0, /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
+  /* But as in DR#031, the 1/0 in an evaluated subexpression means the
+     whole expression violates the constraints.  */
+  E4 = 0 * (1 / 0), /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
+  E5 = INT_MAX + 1, /* { dg-warning "integer overflow in expression" } */
+  /* Again, overflow in evaluated subexpression.  */
+  E6 = 0 * (INT_MAX + 1), /* { dg-warning "integer overflow in expression" } */
+  /* A cast does not constitute overflow in conversion.  */
+  E7 = (char) INT_MAX
+};
+
+struct s {
+  int a;
+  int : 0 * (1 / 0); /* { dg-warning "division by zero" } */
+  int : 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+};
+
+void
+f (void)
+{
+  /* This expression is not required to be a constant expression, so
+     it should just involve undefined behavior at runtime.  */
+  int c = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+}
+
+/* But this expression does need to be constant.  */
+static int sc = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+
+/* The first two of these involve overflow, so are not null pointer
+   constants.  The third has the overflow in an unevaluated
+   subexpression, so is a null pointer constant.  */
+void *p = 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+/* { dg-warning "initialization makes pointer from integer without a cast" "null" { target *-*-* } 48 } */
+void *q = 0 * (1 / 0); /* { dg-warning "division by zero" } */
+/* { dg-warning "initialization makes pointer from integer without a cast" "null" { xfail *-*-* } 50 } */
+void *r = (1 ? 0 : INT_MAX+1);
+
+void
+g (int i)
+{
+  switch (i)
+    {
+    case 0 * (1/0): /* { dg-warning "division by zero" } */
+      ;
+    case 1 + 0 * (INT_MAX + 1): /* { dg-warning "integer overflow in expression" } */
+      ;
+    }
+}
+
+int
+h (void)
+{
+  return INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+}
+
+int
+h1 (void)
+{
+  return INT_MAX + 1 - INT_MAX; /* { dg-warning "integer overflow in expression" } */
+}
+
+void fuc (unsigned char);
+void fsc (signed char);
+
+void
+h2 (void)
+{
+  fsc (SCHAR_MAX + 1);
+  /* { dg-warning "passing argument 1 of 'fsc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 84 } */
+  fsc (SCHAR_MIN - 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  /* { dg-warning "passing argument 1 of 'fsc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 86 } */
+  fsc (UCHAR_MAX);
+  /* { dg-warning "passing argument 1 of 'fsc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 88 } */
+  fsc (UCHAR_MAX + 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  /* { dg-warning "passing argument 1 of 'fsc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 90 } */
+  fuc (-1);
+  /* { dg-warning "passing argument 1 of 'fuc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 92 } */
+  fuc (UCHAR_MAX + 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  /* { dg-warning "passing argument 1 of 'fuc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 94 } */
+  fuc (SCHAR_MIN);
+  /* { dg-warning "passing argument 1 of 'fuc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 96 } */
+  fuc (SCHAR_MIN - 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  /* { dg-warning "passing argument 1 of 'fuc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 98 } */
+  fuc (-UCHAR_MAX); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  /* { dg-warning "passing argument 1 of 'fuc' with different width due to prototype" "-Wtraditional-conversion" { target *-*-* } 100 } */
+}
+
+void fui (unsigned int);
+void fsi (signed int);
+
+int si;
+unsigned ui;
+
+void
+h2i (int x)
+{
+  /* For some reason, we only give certain warnings for implicit
+     conversions among values of the same precision with -Wtraditional-conversion,
+     while we don't give others at all.  */
+  fsi ((unsigned)INT_MAX + 1); /* { dg-warning "passing argument 1 of 'fsi' as signed due to prototype" } */
+  si = (unsigned)INT_MAX + 1;
+  si = x ? (unsigned)INT_MAX + 1 : 1;
+  fsi ((unsigned)INT_MAX + 2); /* { dg-warning "passing argument 1 of 'fsi' as signed due to prototype" } */
+  si = (unsigned)INT_MAX + 2;
+  si = x ? (unsigned)INT_MAX + 2 : 1;
+  fsi (UINT_MAX); /* { dg-warning "passing argument 1 of 'fsi' as signed due to prototype" } */
+  si = UINT_MAX;
+  fui (-1);
+  /* { dg-warning "passing argument 1 of 'fui' as unsigned due to prototype" "-Wtraditional-conversion" { target *-*-* } 124 } */
+  ui = -1;
+  ui = x ? -1 : 1U;
+  fui (INT_MIN);
+  /* { dg-warning "passing argument 1 of 'fui' as unsigned due to prototype" "-Wtraditional-conversion" { target *-*-* } 128 } */
+  ui = INT_MIN;
+  ui = x ? INT_MIN : 1U;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-3.c
new file mode 100644
index 000000000..6b1dc053e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-3.c
@@ -0,0 +1,128 @@
+/* Test for diagnostics for constant overflow.  Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic" } */
+
+#include <limits.h>
+
+enum e {
+  E0 = INT_MAX,
+  /* Unsigned overflow wraps around.  */
+  E1 = UINT_MAX + 1,
+  /* Overflow in an unevaluated part of an expression is OK (example
+     in the standard).  */
+  E2 = 2 || 1 / 0,
+  E3 = 1 / 0, /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
+  /* But as in DR#031, the 1/0 in an evaluated subexpression means the
+     whole expression violates the constraints.  */
+  E4 = 0 * (1 / 0), /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
+  E5 = INT_MAX + 1, /* { dg-warning "integer overflow in expression" } */
+  /* { dg-warning "overflow in constant expression" "constant" { target *-*-* } 21 } */
+  /* Again, overflow in evaluated subexpression.  */
+  E6 = 0 * (INT_MAX + 1), /* { dg-warning "integer overflow in expression" } */
+  /* { dg-warning "overflow in constant expression" "constant" { target *-*-* } 24 } */
+  /* A cast does not constitute overflow in conversion.  */
+  E7 = (char) INT_MAX
+};
+
+struct s {
+  int a;
+  int : 0 * (1 / 0); /* { dg-warning "division by zero" } */
+  int : 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+  /* { dg-warning "overflow in constant expression" "constant" { target *-*-* } 33 } */
+};
+
+void
+f (void)
+{
+  /* This expression is not required to be a constant expression, so
+     it should just involve undefined behavior at runtime.  */
+  int c = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+
+}
+
+/* But this expression does need to be constant.  */
+static int sc = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+/* { dg-warning "overflow in constant expression" "constant" { target *-*-* } 47 } */
+
+/* The first two of these involve overflow, so are not null pointer
+   constants.  The third has the overflow in an unevaluated
+   subexpression, so is a null pointer constant.  */
+void *p = 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+/* { dg-warning "overflow in constant expression" "constant" { target *-*-* } 53 } */
+/* { dg-warning "initialization makes pointer from integer without a cast" "null" { target *-*-* } 53 } */
+void *q = 0 * (1 / 0); /* { dg-warning "division by zero" } */
+/* { dg-warning "initialization makes pointer from integer without a cast" "null" { xfail *-*-* } 56 } */
+void *r = (1 ? 0 : INT_MAX+1);
+
+void
+g (int i)
+{
+  switch (i)
+    {
+    case 0 * (1/0): /* { dg-warning "division by zero" } */
+      ;
+    case 1 + 0 * (INT_MAX + 1): /* { dg-warning "integer overflow in expression" } */
+      /* { dg-warning "overflow in constant expression" "constant" { target *-*-* } 67 } */
+      ;
+    }
+}
+
+int
+h (void)
+{
+  return INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+}
+
+int
+h1 (void)
+{
+  return INT_MAX + 1 - INT_MAX; /* { dg-warning "integer overflow in expression" } */
+}
+
+void fuc (unsigned char);
+void fsc (signed char);
+
+void
+h2 (void)
+{
+  fsc (SCHAR_MAX + 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (SCHAR_MIN - 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (UCHAR_MAX); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (UCHAR_MAX + 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fuc (-1);
+  fuc (UCHAR_MAX + 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  fuc (SCHAR_MIN);
+  fuc (SCHAR_MIN - 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  fuc (-UCHAR_MAX); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+}
+
+void fui (unsigned int);
+void fsi (signed int);
+
+int si;
+unsigned ui;
+
+void
+h2i (int x)
+{
+  /* For some reason, we only give certain warnings for implicit
+     conversions among values of the same precision with -Wconversion,
+     while we don't give others at all.  */
+  fsi ((unsigned)INT_MAX + 1);
+  si = (unsigned)INT_MAX + 1;
+  si = x ? (unsigned)INT_MAX + 1 : 1;
+  fsi ((unsigned)INT_MAX + 2);
+  si = (unsigned)INT_MAX + 2;
+  si = x ? (unsigned)INT_MAX + 2 : 1;
+  fsi (UINT_MAX);
+  si = UINT_MAX;
+  fui (-1);
+  ui = -1;
+  ui = x ? -1 : 1U;
+  fui (INT_MIN);
+  ui = INT_MIN;
+  ui = x ? INT_MIN : 1U;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-4.c
new file mode 100644
index 000000000..1e2518f9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-4.c
@@ -0,0 +1,128 @@
+/* Test for diagnostics for constant overflow.  Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+#include <limits.h>
+
+enum e {
+  E0 = INT_MAX,
+  /* Unsigned overflow wraps around.  */
+  E1 = UINT_MAX + 1,
+  /* Overflow in an unevaluated part of an expression is OK (example
+     in the standard).  */
+  E2 = 2 || 1 / 0,
+  E3 = 1 / 0, /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
+  /* But as in DR#031, the 1/0 in an evaluated subexpression means the
+     whole expression violates the constraints.  */
+  E4 = 0 * (1 / 0), /* { dg-warning "division by zero" } */
+  /* { dg-error "enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
+  E5 = INT_MAX + 1, /* { dg-warning "integer overflow in expression" } */
+  /* { dg-error "overflow in constant expression" "constant" { target *-*-* } 21 } */
+  /* Again, overflow in evaluated subexpression.  */
+  E6 = 0 * (INT_MAX + 1), /* { dg-warning "integer overflow in expression" } */
+  /* { dg-error "overflow in constant expression" "constant" { target *-*-* } 24 } */
+  /* A cast does not constitute overflow in conversion.  */
+  E7 = (char) INT_MAX
+};
+
+struct s {
+  int a;
+  int : 0 * (1 / 0); /* { dg-warning "division by zero" } */
+  int : 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+  /* { dg-error "overflow in constant expression" "constant" { target *-*-* } 33 } */
+};
+
+void
+f (void)
+{
+  /* This expression is not required to be a constant expression, so
+     it should just involve undefined behavior at runtime.  */
+  int c = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+
+}
+
+/* But this expression does need to be constant.  */
+static int sc = INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+/* { dg-error "overflow in constant expression" "constant" { target *-*-* } 47 } */
+
+/* The first two of these involve overflow, so are not null pointer
+   constants.  The third has the overflow in an unevaluated
+   subexpression, so is a null pointer constant.  */
+void *p = 0 * (INT_MAX + 1); /* { dg-warning "integer overflow in expression" } */
+/* { dg-error "overflow in constant expression" "constant" { target *-*-* } 53 } */
+/* { dg-error "initialization makes pointer from integer without a cast" "null" { target *-*-* } 53 } */
+void *q = 0 * (1 / 0); /* { dg-warning "division by zero" } */
+/* { dg-error "initialization makes pointer from integer without a cast" "null" { xfail *-*-* } 56 } */
+void *r = (1 ? 0 : INT_MAX+1);
+
+void
+g (int i)
+{
+  switch (i)
+    {
+    case 0 * (1/0): /* { dg-warning "division by zero" } */
+      ;
+    case 1 + 0 * (INT_MAX + 1): /* { dg-warning "integer overflow in expression" } */
+      /* { dg-error "overflow in constant expression" "constant" { target *-*-* } 67 } */
+      ;
+    }
+}
+
+int
+h (void)
+{
+  return INT_MAX + 1; /* { dg-warning "integer overflow in expression" } */
+}
+
+int
+h1 (void)
+{
+  return INT_MAX + 1 - INT_MAX; /* { dg-warning "integer overflow in expression" } */
+}
+
+void fuc (unsigned char);
+void fsc (signed char);
+
+void
+h2 (void)
+{
+  fsc (SCHAR_MAX + 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (SCHAR_MIN - 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (UCHAR_MAX); /* { dg-warning "overflow in implicit constant conversion" } */
+  fsc (UCHAR_MAX + 1); /* { dg-warning "overflow in implicit constant conversion" } */
+  fuc (-1);
+  fuc (UCHAR_MAX + 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  fuc (SCHAR_MIN);
+  fuc (SCHAR_MIN - 1); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+  fuc (-UCHAR_MAX); /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+}
+
+void fui (unsigned int);
+void fsi (signed int);
+
+int si;
+unsigned ui;
+
+void
+h2i (int x)
+{
+  /* For some reason, we only give certain warnings for implicit
+     conversions among values of the same precision with -Wconversion,
+     while we don't give others at all.  */
+  fsi ((unsigned)INT_MAX + 1);
+  si = (unsigned)INT_MAX + 1;
+  si = x ? (unsigned)INT_MAX + 1 : 1;
+  fsi ((unsigned)INT_MAX + 2);
+  si = (unsigned)INT_MAX + 2;
+  si = x ? (unsigned)INT_MAX + 2 : 1;
+  fsi (UINT_MAX);
+  si = UINT_MAX;
+  fui (-1);
+  ui = -1;
+  ui = x ? -1 : 1U;
+  fui (INT_MIN);
+  ui = INT_MIN;
+  ui = x ? INT_MIN : 1U;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-5.c
new file mode 100644
index 000000000..472d4a7ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-5.c
@@ -0,0 +1,7 @@
+/* PR c/27273 */
+/* { dg-do compile } */
+/* { dg-options "-Woverflow" } */
+
+unsigned char rx_async(unsigned char p) {
+    return p & 512; /* { dg-warning "overflow in implicit constant conversion" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-6.c
new file mode 100644
index 000000000..b3bc73610
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-6.c
@@ -0,0 +1,18 @@
+/* Test non-constant operands in overflowed expressions.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Woverflow" } */
+
+#include <limits.h>
+
+int 
+h1 (int x)
+{
+  return x * (0 * (INT_MAX + 1)); /* { dg-warning "integer overflow in expression" } */
+}
+
+int 
+h2 (int x)
+{
+  return ((INT_MAX + 1) * 0) * x; /* { dg-warning "integer overflow in expression" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-7.c
new file mode 100644
index 000000000..7c0ce68df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/overflow-warn-7.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+int f(char *device)
+{
+  return device == ((char *)0 + ~0UL);  /* { dg-bogus "overflow" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-1.c
new file mode 100644
index 000000000..8bd3f6c75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-1.c
@@ -0,0 +1,154 @@
+/* Test semantics of #pragma pack.
+   Contributed by Mike Coleman <mcoleman2@kc.rr.com> */
+
+/* { dg-do compile { target { { *-*-linux* *-*-cygwin* powerpc*-*-eabi* } && { ! default_packed } } } } */
+
+/* Mainly we're just testing whether pushing and popping seem to be
+   working correctly, and verifying the (alignment == 1) case, which
+   is really the only reason anyone would use this pragma anyway. */
+
+#include <stddef.h>
+
+/* generalized compile-time test expression */
+#define test(n, expr) int test_##n [(expr) ? 1 : -1]
+
+/* Round V down to multiple of A */
+#define floor(v,a) ((v) / (a) * (a))
+
+/* Offset of field with alignment A in structure S after a field P of
+   type PT */
+#define offset(s,p,pt,a) \
+	floor ((offsetof(struct s, p) + sizeof (pt) + (a) - 1), a)
+
+/* regular minimum */
+#define min(a,b)  ((a) < (b) ? (a) : (b))
+
+/* Check that field A (type AT) followed by field B (type BT) are
+   packed according to P */
+#define test_pack(n, a, at, b, bt, p) \
+	test(n, offsetof (struct SNAME, b) \
+ 	        == min (offset (SNAME,a,at,__alignof__(bt)), \
+		        offset (SNAME,a,at,p)))
+
+/* Test offset of field F in structs s1 and s2 are the same.  */
+#define test_offset(n, s1, s2, f) \
+	test (n, (offsetof(struct s1, f) == offsetof(struct s2, f)))
+
+#define SNAME s0
+#include "pack-test-1.h"
+
+#undef SNAME
+#define SNAME s1
+#pragma pack(push, p1, 1)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 1);
+  test_pack(1, f2, short, f3, double, 1);
+  test_pack(2, f4, int, f5, double, 1);
+}
+
+#undef SNAME
+#define SNAME s2
+#pragma pack(push, p2, 2)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 2);
+  test_pack(1, f2, short, f3, double, 2);
+  test_pack(2, f4, int, f5, double, 2);
+}
+
+#undef SNAME
+#define SNAME s3
+#pragma pack(push, p3, 4)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 4);
+  test_pack(1, f2, short, f3, double, 4);
+  test_pack(2, f4, int, f5, double, 4);
+}
+
+#undef SNAME
+#define SNAME s4
+#pragma pack(pop)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 2);
+  test_pack(1, f2, short, f3, double, 2);
+  test_pack(2, f4, int, f5, double, 2);
+}
+
+#undef SNAME
+#define SNAME s5
+#pragma pack(pop, p2)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 1);
+  test_pack(1, f2, short, f3, double, 1);
+  test_pack(2, f4, int, f5, double, 1);
+}
+
+#undef SNAME
+#define SNAME s6
+#pragma pack(pop, p1)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_offset (0, s0, SNAME, f0);
+  test_offset (1, s0, SNAME, f1);
+  test_offset (2, s0, SNAME, f2);
+  test_offset (3, s0, SNAME, f3);
+  test_offset (4, s0, SNAME, f4);
+  test_offset (5, s0, SNAME, f5);
+}
+
+#undef SNAME
+#define SNAME s7
+#pragma pack(1)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 1);
+  test_pack(1, f2, short, f3, double, 1);
+  test_pack(2, f4, int, f5, double, 1);
+}
+
+#undef SNAME
+#define SNAME s8
+#pragma pack(push, p2, 2)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 2);
+  test_pack(1, f2, short, f3, double, 2);
+  test_pack(2, f4, int, f5, double, 2);
+}
+
+#undef SNAME
+#define SNAME s9
+#pragma pack(pop)
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_pack(0, f0, char, f1, double, 1);
+  test_pack(1, f2, short, f3, double, 1);
+  test_pack(2, f4, int, f5, double, 1);
+}
+
+#undef SNAME
+#define SNAME s10
+#pragma pack()
+#include "pack-test-1.h"
+
+void SNAME() {
+  test_offset (0, s0, SNAME, f0);
+  test_offset (1, s0, SNAME, f1);
+  test_offset (2, s0, SNAME, f2);
+  test_offset (3, s0, SNAME, f3);
+  test_offset (4, s0, SNAME, f4);
+  test_offset (5, s0, SNAME, f5);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-1.h
new file mode 100644
index 000000000..f4889fabe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-1.h
@@ -0,0 +1,12 @@
+/* Helper file, included repeatedly by pack-test-1.c.  */
+
+struct SNAME {
+  char f0;
+  double f1;
+  short f2;
+  double f3;
+  int f4;
+  double f5;
+  double f6;
+  double f7;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-2.c
new file mode 100644
index 000000000..86e4d8df4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-2.c
@@ -0,0 +1,25 @@
+/* Tests for syntax checking of #pragma pack.
+   Contributed by Mike Coleman <mcoleman2@kc.rr.com> */
+
+/* { dg-do compile { target *-*-linux* *-*-cygwin* powerpc*-*-eabi* } } */
+
+#pragma pack(pop)               /* { dg-warning "without matching" } */
+
+#pragma pack(push)
+#pragma pack(pop)               /* reset */
+
+#pragma pack(push, foo, 1)
+#pragma pack(pop, foo, 1)       /* { dg-warning "malformed" } (/
+#pragma pack(pop)               /* reset */
+
+#pragma pack(push, foo, 1)
+#pragma pack(pop, bar)          /* { dg-warning "without matching" } */
+#pragma pack(pop)               /* reset */
+
+#pragma pack(push, foo, 1)
+#pragma pack(pop)
+#pragma pack(pop, foo)          /* { dg-warning "without matching" } */
+
+#pragma pack(push, foo, 3)      /* { dg-warning "small power of two" } */
+
+extern int blah;	/* prevent "ISO C forbids an empty translation unit" */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-3.c
new file mode 100644
index 000000000..8b0390378
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-3.c
@@ -0,0 +1,44 @@
+/* { dg-do compile } */
+
+/* Copyright (C) 2003 Free Software Foundation, Inc.
+   Contributed by Nathan Sidwell 15 Jul 2003 <nathan@codesourcery.com> */
+
+/* you should not be able to pack a typedef to a struct, only the
+   underlying struct can be packed.  */
+
+/* ok */
+struct u1
+{
+  char field1;
+  short field2;
+  int field3;
+};
+
+/* ok */
+typedef struct p1 {
+   char  field1;
+   short field2;
+   int field3;
+} __attribute__ ((packed)) p1_t1;
+
+/* ok */
+typedef struct __attribute__ ((packed)) p2 {
+   char  field1;
+   short field2;
+   int field3;
+} p2_t1;
+
+int ary1[sizeof (struct p1) == sizeof (p1_t1) ? 1 : -1];
+int ary2[sizeof (struct p2) == sizeof (p2_t1) ? 1 : -1];
+int ary3[sizeof (struct p1) == sizeof (struct p2) ? 1 : -1];
+
+/* not ok */
+typedef struct u1 __attribute__ ((packed)) u1_t1; /* { dg-warning "attribute ignored" "" }*/
+typedef struct u1 u1_t2 __attribute__ ((packed)); /* { dg-warning "attribute ignored" "" }*/
+
+typedef struct p3 {
+   char  field1;
+   short field2;
+   int field3;
+} p3_t1 __attribute__ ((packed)); /* { dg-warning "attribute ignored" "" }*/
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-4.c
new file mode 100644
index 000000000..1ad8ee4fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-4.c
@@ -0,0 +1,36 @@
+/* PR c/11885
+   Bug: flag4 was allocated into the same byte as the other flags.
+   { dg-options "" }
+   { dg-do run } */
+
+extern void abort (void);
+
+typedef unsigned char uint8_t;
+
+typedef struct {
+    uint8_t flag1:2;
+    uint8_t flag2:1;
+    uint8_t flag3:1;
+   
+    uint8_t flag4;
+
+} __attribute__ ((packed)) MyType;
+
+int main (void)
+{
+  MyType a;
+  MyType *b = &a;
+
+  b->flag1 = 0;
+  b->flag2 = 0;
+  b->flag3 = 0;
+
+  b->flag4 = 0;
+
+  b->flag4++;
+    
+  if (b->flag1 != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-5.c
new file mode 100644
index 000000000..7645043dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pack-test-5.c
@@ -0,0 +1,21 @@
+/* PR c/11446: packed on a struct takes precedence over aligned on the type
+   of a field.  */
+/* { dg-do run } */
+
+extern void abort (void);
+
+struct A {
+  double d;
+} __attribute__ ((aligned));
+
+struct B {
+  char c;
+  struct A a;
+} __attribute__ ((packed));
+
+int main ()
+{
+  if (sizeof (struct B) != sizeof (char) + sizeof (struct A))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/packed-array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/packed-array.c
new file mode 100644
index 000000000..b57f3ac03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/packed-array.c
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fno-inline" } */
+
+struct usb_interface_descriptor {
+ unsigned short wMaxPacketSize;
+  char e;
+} __attribute__ ((packed));
+
+struct usb_device {
+ int devnum;
+ struct usb_interface_descriptor if_desc[2];
+};
+
+extern int printf (const char *, ...);
+
+void foo (unsigned short a)
+{
+  printf ("%d\n", a);
+}
+
+struct usb_device ndev;
+
+void usb_set_maxpacket(int n)
+{
+  int i;
+
+  for(i=0; i<n;i++)
+    foo((&ndev)->if_desc[i].wMaxPacketSize);
+}
+
+int
+main()
+{
+  usb_set_maxpacket(2);
+  return 0;
+}
+
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/packed-vla.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/packed-vla.c
new file mode 100644
index 000000000..04ccb9663
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/packed-vla.c
@@ -0,0 +1,31 @@
+/* PR middle-end/27945 */
+/* { dg-do run } */
+/* { dg-options "" } */
+
+extern int printf (const char *, ...);
+extern void abort ();
+
+int func(int levels) 
+{
+  struct bar {
+    unsigned char	a;
+    int			b[levels];
+  } __attribute__ ((__packed__)) bar;
+
+  struct foo {
+    unsigned char	a;
+    int			b[4];
+  } __attribute__ ((__packed__)) foo;
+
+  printf("foo %d\n", sizeof(foo));
+  printf("bar %d\n", sizeof(bar));
+
+  if (sizeof (foo) != sizeof (bar))
+    abort ();
+}
+
+int main()
+{
+  func(4);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-1.c
new file mode 100644
index 000000000..470636de9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-1.c
@@ -0,0 +1,26 @@
+/* Test GNU parameter forward declarations.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Valid uses.  */
+int f1(int a; int a);
+int f2(int a; int a) { return 0; }
+int f3(int a; int a; int a);
+int f4(int a; int a; int a) { return 0; }
+int f5(int a; int (*x)[a], int a);
+int f6(int a; int (*x)[a], int a) { return 0; }
+int f7(int a; int (*x)[a]; int (*y)[x[1][2]], int (*x)[a], int a);
+int f8(int a; int (*x)[a]; int (*y)[x[1][2]], int (*x)[a], int a) { return 0; }
+
+/* Strange uses accepted by GCC 4.0 but not by 3.4 and probably not
+   desirable to accept.  */
+int g1(int a;); /* { dg-error "just a forward declaration" "no parms" { xfail *-*-* } } */
+int g2(int a; __attribute__((unused))); /* { dg-error "just a forward declaration" "no parms" { xfail *-*-* } } */
+int g3(int;); /* { dg-error "just a forward declaration" "no parms" { xfail *-*-* } } */
+int g4(int, long;); /* { dg-error "just a forward declaration" "no parms" { xfail *-*-* } } */
+
+/* Invalid uses.  */
+int h1(int a; int b); /* { dg-error "just a forward declaration" } */
+int h2(int; int b); /* { dg-error "just a forward declaration" } */
+int h3(int a; long a); /* { dg-error "conflicting types|previous definition|just a forward declaration" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-2.c
new file mode 100644
index 000000000..42db4b157
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-2.c
@@ -0,0 +1,8 @@
+/* Test GNU parameter forward declarations.  Warning with
+   -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+int f1(int a; int a); /* { dg-warning "ISO C forbids forward parameter declarations" } */
+int f2(int a; int a) { return 0; } /* { dg-warning "ISO C forbids forward parameter declarations" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-3.c
new file mode 100644
index 000000000..7937532fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-3.c
@@ -0,0 +1,8 @@
+/* Test GNU parameter forward declarations.  Error with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+int f1(int a; int a); /* { dg-error "ISO C forbids forward parameter declarations" } */
+int f2(int a; int a) { return 0; } /* { dg-error "ISO C forbids forward parameter declarations" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-4.c
new file mode 100644
index 000000000..a210092e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-forwdecl-4.c
@@ -0,0 +1,10 @@
+/* Test GNU parameter forward declarations.  OK with
+   -Wredundant-decls.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wredundant-decls" } */
+
+int f1(int a; int a);
+int f2(int a; int a) { return 0; }
+int f3(int a; int a; int a);
+int f4(int a; int a; int a) { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-impl-decl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-impl-decl-1.c
new file mode 100644
index 000000000..467c19abd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-impl-decl-1.c
@@ -0,0 +1,33 @@
+/* Test implicit function declarations and other odd declarations in
+   function prototypes.  Bug 18239.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Implicit function declaration in attribute in definition (testcase
+   from bug).  */
+int
+foo (int __attribute__ ((__mode__ (vector_size(8)))) i) /* { dg-warning "'__mode__' attribute ignored" } */
+{
+  return (long long) i;
+}
+
+/* Various other cases.  */
+
+int f (int [sizeof(g())]);
+int f1 (int [sizeof(g1())]);
+
+int g () { return 1; }
+
+int
+h (int (*p)[sizeof(i())])
+{
+  int g2 (), g3 ();
+  return (*p)[0] + g3() + g2();
+}
+
+int i () { return 2; }
+
+int f2 (int [sizeof(g2())]);
+int f3 (int [sizeof(g3())]);
+int g3 () { return 4; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-impl-decl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-impl-decl-2.c
new file mode 100644
index 000000000..22ea0c6e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-impl-decl-2.c
@@ -0,0 +1,7 @@
+/* Test implicit function declarations and other odd declarations in
+   function prototypes.  Make sure that LABEL_DECLs don't occur.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int k (int [sizeof &&z]); /* { dg-error "label 'z' referenced outside of any function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-incomplete-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-incomplete-1.c
new file mode 100644
index 000000000..83dca8253
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-incomplete-1.c
@@ -0,0 +1,28 @@
+/* Test warnings and errors for incomplete parameter types.  Should
+   not be warned for in declarations that are not definitions: bug
+   17881.  Void types may be a special case, especially for unnamed
+   parameters and when qualified or with a storage class specifier;
+   see C90 6.5.4.3, DR#017 Q14, C90 TC1, DR#157, C99 J.2 (referencing
+   C99 6.7.5.3); the precise rules are unclear.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s;
+void f (struct s);
+void (*g)(struct s);
+struct t { void (*p)(struct s); };
+
+struct s { int b; };
+void h (struct s x) { }
+
+void j(struct t2); /* { dg-warning "'struct t2' declared inside parameter list" } */
+/* { dg-warning "its scope is only" "explanation" { target *-*-* } 19 } */
+
+union u;
+
+void v(union u x) { } /* { dg-error "parameter 1 \\('x'\\) has incomplete type" } */
+
+void p(void x); /* { dg-warning "parameter 1 \\('x'\\) has void type" } */
+
+void q(const void x); /* { dg-warning "parameter 1 \\('x'\\) has void type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-mismatch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-mismatch-1.c
new file mode 100644
index 000000000..8f62e122b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parm-mismatch-1.c
@@ -0,0 +1,18 @@
+/* Test diagnostics for parameter mismatches.  Types that can't match
+   ().  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f0(); /* { dg-message "note: previous declaration of 'f0' was here" } */
+void f0(int, ...); /* { dg-error "conflicting types for 'f0'" } */
+/* { dg-message "note: a parameter list with an ellipsis can't match an empty parameter name list declaration" "note" { target *-*-* } 8 } */
+void f1(int, ...); /* { dg-message "note: previous declaration of 'f1' was here" } */
+void f1(); /* { dg-error "conflicting types for 'f1'" } */
+/* { dg-message "note: a parameter list with an ellipsis can't match an empty parameter name list declaration" "note" { target *-*-* } 11 } */
+void f2(); /* { dg-message "note: previous declaration of 'f2' was here" } */
+void f2(char); /* { dg-error "conflicting types for 'f2'" } */
+/* { dg-message "note: an argument type that has a default promotion can't match an empty parameter name list declaration" "note" { target *-*-* } 14 } */
+void f3(char); /* { dg-message "note: previous declaration of 'f3' was here" } */
+void f3(); /* { dg-error "conflicting types for 'f3'" } */
+/* { dg-message "note: an argument type that has a default promotion can't match an empty parameter name list declaration" "note" { target *-*-* } 17 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-decl-after-if.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-decl-after-if.c
new file mode 100644
index 000000000..f48e6dfc2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-decl-after-if.c
@@ -0,0 +1,11 @@
+/* Parse error recovery
+{ dg-do compile }
+{ dg-options "-fsyntax-only" }
+*/
+
+void f(x)
+{
+  if (x > 1)
+    int ret = 1; /* { dg-error "expected expression before 'int'" } */
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-decl-after-label.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-decl-after-label.c
new file mode 100644
index 000000000..f457c6a69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-decl-after-label.c
@@ -0,0 +1,17 @@
+/* PR 29062 
+{ dg-do compile }
+{ dg-options "-fsyntax-only" }
+*/
+
+int f(x)
+{
+  if (x > 1) 
+    {
+      goto finish;
+    }
+  return x;
+  
+ finish:
+  int ret = 1; /* { dg-error "a label can only be part of a statement and a declaration is not a statement" } */
+  return ret;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-2.c
new file mode 100644
index 000000000..ce59af381
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-2.c
@@ -0,0 +1,13 @@
+/* PR 23722 */
+/* { dg-do compile } */
+/* { dg-options "-fsyntax-only" } */
+int f()
+{
+  if (1)
+    {
+      return 1;
+  else /* { dg-error "expected .\}. before 'else'" } */
+  {
+      }
+  }
+} /* { dg-error "expected identifier or '\\(' before .\}. token" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-3.c
new file mode 100644
index 000000000..13666f595
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-3.c
@@ -0,0 +1,11 @@
+/* PR 23722 */
+/* { dg-do compile } */
+/* { dg-options "-fsyntax-only" } */
+int f()
+{
+
+  else  /* { dg-error "'else' without a previous 'if'" } */
+    {
+      return 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-4.c
new file mode 100644
index 000000000..617c3f3e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error-4.c
@@ -0,0 +1,14 @@
+/* PR 23722 */
+/* { dg-do compile } */
+/* { dg-options "-fsyntax-only" } */
+int f()
+{
+  if (1)
+    {
+      return 1;
+    }
+  else 
+    {
+      else; /* { dg-error "'else' without a previous 'if'" } */
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error.c
new file mode 100644
index 000000000..ca20bdf9f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-else-error.c
@@ -0,0 +1,12 @@
+/* PR 23722 */
+/* { dg-do compile } */
+/* { dg-options "-fsyntax-only" } */
+int f()
+{
+  if (1)
+  {
+   return 1;
+  else /* { dg-error "expected .\}. before 'else'" } */
+  {
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-error-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-error-1.c
new file mode 100644
index 000000000..704786f4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-error-1.c
@@ -0,0 +1,10 @@
+/* PR c/28649 */
+/* { dg-do compile } */
+
+void foo()
+{
+   +;  /* { dg-error "expected expression" } */
+   +;  /* { dg-error "expected expression" } */
+}
+
+int +;  /* { dg-error "expected identifier" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-error-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-error-2.c
new file mode 100644
index 000000000..7ab3cd7c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parse-error-2.c
@@ -0,0 +1,14 @@
+/* PR c/28649 */
+/* { dg-do compile } */
+
+void foo()
+{
+  +;  /* { dg-error "expected expression" } */
+}
+
+int i;
+
+void bar()
+{
+  i++;  /* { dg-bogus "undeclared" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parser-pr28152-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parser-pr28152-2.c
new file mode 100644
index 000000000..18dc1e63d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parser-pr28152-2.c
@@ -0,0 +1,11 @@
+/* PR 28152: error messages should mention __complex__ */
+/* { dg-do compile } */
+/* { dg-options "" } */
+int
+main (void)
+{
+  __complex__ float z;
+
+  z = __complex__ (1.90000007326203904e+19, 0.0);   /* { dg-error "__complex__" } */
+  z = __complex__ (1.0e+0, 0.0) / z;   /* { dg-error "__complex__" } */
+  /* { dg-error "at end of input" "" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/parser-pr28152.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/parser-pr28152.c
new file mode 100644
index 000000000..99534c10b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/parser-pr28152.c
@@ -0,0 +1,11 @@
+/* PR 28152: error messages should mention _Complex */
+/* { dg-do compile } */
+/* { dg-options "" } */
+int
+main (void)
+{
+  _Complex float z;
+
+  z = _Complex (1.90000007326203904e+19, 0.0);   /* { dg-error "_Complex" } */
+  z = _Complex (1.0e+0, 0.0) / z;   /* { dg-error "_Complex" } */
+  /* { dg-error "at end of input" "" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/common-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/common-1.c
new file mode 100644
index 000000000..ec5731028
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/common-1.c
@@ -0,0 +1,3 @@
+#include "common-1.h"
+int foo2 = 3;
+int zz = 2;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/common-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/common-1.hs
new file mode 100644
index 000000000..971e1996a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/common-1.hs
@@ -0,0 +1,3 @@
+static int foo1 = 9;
+int foo2;
+extern int zz;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-1.c
new file mode 100644
index 000000000..79cea882d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-1.c
@@ -0,0 +1,9 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+#include "counter-1.h"
+
+int main(void) 
+{
+  return __COUNTER__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-1.hs
new file mode 100644
index 000000000..c3d2ce791
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-1.hs
@@ -0,0 +1,5 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+static unsigned offset[] = {__COUNTER__, __COUNTER__, __COUNTER__};
+#define counter __COUNTER__
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-2.c
new file mode 100644
index 000000000..22ba245b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-2.c
@@ -0,0 +1,17 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+/* { dg-options "-I. -Winvalid-pch" } */
+
+#if __COUNTER__ != 0
+#error __COUNTER__ != 0
+#endif
+
+#include "counter-2.h" /* { dg-warning "not used because `__COUNTER__' is invalid" } */
+/* { dg-error "counter-2.h: No such file or directory" "no such file" { target *-*-* } 10 } */
+/* { dg-error "one or more PCH files were found, but they were invalid" "invalid files" { target *-*-* } 10 } */
+
+int main(void) 
+{
+  return __COUNTER__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-2.hs
new file mode 100644
index 000000000..63b8a2b7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-2.hs
@@ -0,0 +1,4 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+static int i = __COUNTER__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-3.c
new file mode 100644
index 000000000..827920563
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-3.c
@@ -0,0 +1,13 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+#if __COUNTER__ != 0
+#error __COUNTER__ != 0
+#endif
+
+#include "counter-3.h"
+
+int main(void) 
+{
+  return __COUNTER__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-3.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-3.hs
new file mode 100644
index 000000000..19039c820
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/counter-3.hs
@@ -0,0 +1,4 @@
+/* Copyright (C) 2007 Free Software Foundation
+   Contributed by Ollie Wild <aaw@google.com> */
+
+#define counter __COUNTER__
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-1.c
new file mode 100644
index 000000000..9a3d6700d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-1.c
@@ -0,0 +1,4 @@
+#include "cpp-1.h"
+#if !defined(__GNUC__)
+panic! panic!
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-1.hs
new file mode 100644
index 000000000..6e25b021a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-1.hs
@@ -0,0 +1 @@
+/* Empty.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-2.c
new file mode 100644
index 000000000..aab84110e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-2.c
@@ -0,0 +1,4 @@
+/* { dg-options "-Wunknown-pragmas -I." } */
+#include "cpp-2.h"
+#pragma GCC poison not_used
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-2.hs
new file mode 100644
index 000000000..6e25b021a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-2.hs
@@ -0,0 +1 @@
+/* Empty.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3.c
new file mode 100644
index 000000000..25b5ca407
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3.c
@@ -0,0 +1,13 @@
+/* PR preprocessor/36649 */
+/* { dg-do compile } */
+/* { dg-options "-H -I." } */
+/* { dg-message "cpp-3.h\[^\n\]*(\n\[^\n\]*cpp-3.c)?\n\[^\n\]*cpp-3a.h\n\[^\n\]*cpp-3b.h" "" { target *-*-* } 0 } */
+
+#include "cpp-3.h"
+#include "cpp-3a.h"
+
+int
+main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3.hs
new file mode 100644
index 000000000..728b1afc7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3.hs
@@ -0,0 +1,4 @@
+#ifndef CPP_3_H
+#define CPP_3_H
+/* empty */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3a.h
new file mode 100644
index 000000000..3788d1179
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3a.h
@@ -0,0 +1,4 @@
+#ifndef CPP_3A_H
+#define CPP_3A_H
+#include "cpp-3b.h"
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3b.h
new file mode 100644
index 000000000..5cb0e8104
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/cpp-3b.h
@@ -0,0 +1,4 @@
+#ifndef CPP_3B_H
+#define CPP_3B_H
+/* empty */
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-1.c
new file mode 100644
index 000000000..5d6bb1d4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-1.c
@@ -0,0 +1,2 @@
+#include "decl-1.h"
+int main(void) { return foo; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-1.hs
new file mode 100644
index 000000000..399f5d3e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-1.hs
@@ -0,0 +1 @@
+extern int foo;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-2.c
new file mode 100644
index 000000000..72b6538b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-2.c
@@ -0,0 +1,2 @@
+#include "decl-2.h"
+int main(void) { return fun (1, 2); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-2.hs
new file mode 100644
index 000000000..99c372690
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-2.hs
@@ -0,0 +1,3 @@
+extern int fun (int a, int b);
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-3.c
new file mode 100644
index 000000000..c12abbb1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-3.c
@@ -0,0 +1,11 @@
+#include "decl-3.h"
+
+foo_p bar (void) 
+{
+  return foop;
+}
+
+struct foo *bar2 (void) 
+{
+  return foop;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-3.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-3.hs
new file mode 100644
index 000000000..787d480f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-3.hs
@@ -0,0 +1,3 @@
+struct foo;
+typedef struct foo *foo_p;
+extern foo_p foop;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-4.c
new file mode 100644
index 000000000..61affdbc0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-4.c
@@ -0,0 +1,9 @@
+#include "decl-4.h"
+
+int bar (foo_p f)
+{
+  if (f->a + foop->a)
+    return f->c->b + foop->b;
+  else
+    return foop->c->b + f->a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-4.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-4.hs
new file mode 100644
index 000000000..3fb220032
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-4.hs
@@ -0,0 +1,7 @@
+typedef struct foo {
+  int a;
+  char b;
+  struct foo *c;
+} foo_s;
+typedef struct foo *foo_p;
+extern foo_p foop;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-5.c
new file mode 100644
index 000000000..705c2fe0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-5.c
@@ -0,0 +1,2 @@
+#include "decl-5.h"
+static int (*t)(void) = foo;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-5.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-5.hs
new file mode 100644
index 000000000..914983c49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/decl-5.hs
@@ -0,0 +1 @@
+extern int foo(void);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/empty.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/empty.c
new file mode 100644
index 000000000..7daa7ca7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/empty.c
@@ -0,0 +1,8 @@
+/* Yes, it's called "empty" because it has no contents at all.  
+   Even this comment goes here, rather than in empty.h.  */
+#include "empty.h"
+
+int main(void) 
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/empty.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/empty.hs
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/empty.hs
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/except-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/except-1.c
new file mode 100644
index 000000000..f81b098d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/except-1.c
@@ -0,0 +1,7 @@
+/* { dg-options "-fexceptions -I." } */
+#include "except-1.h"
+
+int main(void) 
+{
+  return foo(1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/except-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/except-1.hs
new file mode 100644
index 000000000..33a893d15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/except-1.hs
@@ -0,0 +1,6 @@
+/* { dg-options "-fexceptions" } */
+extern inline int
+foo(int a)
+{
+  return a + 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/global-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/global-1.c
new file mode 100644
index 000000000..c1cff5f1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/global-1.c
@@ -0,0 +1,2 @@
+#include "global-1.h"
+const int bar = 3;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/global-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/global-1.hs
new file mode 100644
index 000000000..26efffcb2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/global-1.hs
@@ -0,0 +1 @@
+const int foo = 2;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1.c
new file mode 100644
index 000000000..b036217f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1.c
@@ -0,0 +1,21 @@
+/* { dg-options "-I. -I $srcdir/gcc.dg/pch -Wno-deprecated" } */
+#include "import-1.h"
+#include "import-1a.h"
+#import "import-1b.h"
+#include "import-1c.h"
+
+#ifndef IMPORT_1A
+IMPORT_1A not defined
+#endif
+
+#ifndef IMPORT_1B
+IMPORT_1B not defined
+#endif
+
+#ifndef IMPORT_1C
+IMPORT_1C not defined
+#endif
+
+#ifndef IMPORT_1
+IMPORT_1 not defined
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1.hs
new file mode 100644
index 000000000..a59099d44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1.hs
@@ -0,0 +1,5 @@
+/* { dg-options "-I. -I $srcdir/gcc.dg/pch -Wno-deprecated" } */
+#import "import-1a.h"
+#include "import-1b.h"
+#include "import-1c.h"
+#define IMPORT_1
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1a.h
new file mode 100644
index 000000000..d65336afe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1a.h
@@ -0,0 +1,5 @@
+#ifdef IMPORT_1A
+#error import-1a failure
+#endif
+#define IMPORT_1A
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1b.h
new file mode 100644
index 000000000..0dd0c9a9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1b.h
@@ -0,0 +1,4 @@
+#ifdef IMPORT_1B
+#error import-1b failure
+#endif
+#define IMPORT_1B
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1c.h
new file mode 100644
index 000000000..1c16356cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-1c.h
@@ -0,0 +1,6 @@
+#pragma once
+#ifdef IMPORT_1C
+#error import-1c failure
+#endif
+#define IMPORT_1C
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-2.c
new file mode 100644
index 000000000..c037e3d1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-2.c
@@ -0,0 +1,8 @@
+/* { dg-options "-I. -I $srcdir/gcc.dg/pch/include -Wno-deprecated" } */
+
+#include "import-2.h"
+#import "import-2b.h"
+
+int main(int argc, char **argv) {
+   return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-2.hs
new file mode 100644
index 000000000..8a725de14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/import-2.hs
@@ -0,0 +1,4 @@
+/* { dg-options "-I $srcdir/gcc.dg/pch/include -Wno-deprecated" } */
+
+#import "import-2b.h"
+#import "import-2a.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/include/import-2a.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/include/import-2a.h
new file mode 100644
index 000000000..bb3250cf6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/include/import-2a.h
@@ -0,0 +1 @@
+#import "import-2b.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/include/import-2b.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/include/import-2b.h
new file mode 100644
index 000000000..ad10c6271
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/include/import-2b.h
@@ -0,0 +1 @@
+int dup = 9;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-1.c
new file mode 100644
index 000000000..38fad39c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-1.c
@@ -0,0 +1,10 @@
+#include "inline-1.h"
+int bar(int a, int b)
+{
+  return foo(a) + b;
+}
+
+int baz(void)
+{
+  return foo(3);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-1.hs
new file mode 100644
index 000000000..e8f1d6f13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-1.hs
@@ -0,0 +1,5 @@
+extern inline int
+foo(int a)
+{
+  return a * 2 + 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-2.c
new file mode 100644
index 000000000..59b238a3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-2.c
@@ -0,0 +1,12 @@
+#include "inline-2.h"
+extern inline char
+bar(int a)
+{
+  return foo(a)[0];
+}
+
+extern inline char
+baz(void)
+{
+  return foo(0)[0];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-2.hs
new file mode 100644
index 000000000..7d90c63de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-2.hs
@@ -0,0 +1,5 @@
+extern inline const char *
+foo(int a)
+{
+  return "abcdefgh"+a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-3.c
new file mode 100644
index 000000000..fadaf0785
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-3.c
@@ -0,0 +1,5 @@
+#include "inline-3.h"
+unsigned bar(double d)
+{
+  foo (d);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-3.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-3.hs
new file mode 100644
index 000000000..ef2819ace
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-3.hs
@@ -0,0 +1,7 @@
+extern double rint(double);
+extern double fmod (double, double);
+static inline unsigned foo(double d) {
+    double a;
+    a = rint(d);
+    return (unsigned)(fmod(a, (double)0xFFFFFFFF) + ((d - a) * 0xFFFFFFFF));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-4.c
new file mode 100644
index 000000000..60e35aa62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-4.c
@@ -0,0 +1,6 @@
+#include "inline-4.h"
+extern int printf (const char *, ...);
+int main(void) {
+  printf (getstring());
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-4.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-4.hs
new file mode 100644
index 000000000..31a5069ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/inline-4.hs
@@ -0,0 +1,4 @@
+static inline char *getstring(void)
+{
+  return "hello";
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-1.c
new file mode 100644
index 000000000..70546bb09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-1.c
@@ -0,0 +1,6 @@
+#include "macro-1.h"
+
+int main(void) 
+{
+  return DEFINED_VALUE + 1 - DEFINED_PARAM (3);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-1.hs
new file mode 100644
index 000000000..5d5b3f4ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-1.hs
@@ -0,0 +1,2 @@
+#define DEFINED_VALUE 3
+#define DEFINED_PARAM(x) (x+1)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-2.c
new file mode 100644
index 000000000..e2d965ff1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-2.c
@@ -0,0 +1,8 @@
+#define DEFINED_VALUE_2 3
+
+#include "macro-2.h"
+
+int main(void) 
+{
+  return DEFINED_VALUE - DEFINED_VALUE_2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-2.hs
new file mode 100644
index 000000000..6152a84a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-2.hs
@@ -0,0 +1,2 @@
+#define DEFINED_VALUE 3
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-3.c
new file mode 100644
index 000000000..493d95498
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-3.c
@@ -0,0 +1,8 @@
+#define DEFINED_FUNC_2(x) (3 + (x))
+
+#include "macro-3.h"
+
+int main(void) 
+{
+  return DEFINED_FUNC (1) - DEFINED_FUNC_2 (-1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-3.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-3.hs
new file mode 100644
index 000000000..d394792a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-3.hs
@@ -0,0 +1,2 @@
+#define DEFINED_FUNC(x) 3 - (x)
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-4.c
new file mode 100644
index 000000000..1c199fa6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-4.c
@@ -0,0 +1,8 @@
+#define DEFN aa + bb
+
+#include "macro-4.h"
+
+int foo(int aa, int bb)
+{
+  return DEFN;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-4.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-4.hs
new file mode 100644
index 000000000..5af162d63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/macro-4.hs
@@ -0,0 +1 @@
+/* No content!  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pch.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pch.exp
new file mode 100644
index 000000000..ff2b34c09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pch.exp
@@ -0,0 +1,64 @@
+#   Copyright (C) 1997, 2002, 2003, 2007, 2009 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/>.
+
+# GCC testsuite for precompiled header interaction,
+# that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+load_lib dg-pch.exp
+load_lib torture-options.exp
+
+# Initialize `dg'.
+dg-init
+torture-init
+set-torture-options $DG_TORTURE_OPTIONS
+
+set old_dg_do_what_default "${dg-do-what-default}"
+
+# Main loop.
+foreach test [lsort [glob -nocomplain $srcdir/$subdir/*.c]] {
+    global torture_without_loops
+
+    # We don't try to use the loop-optimizing options, since they are highly
+    # unlikely to make any difference to PCH.  However, we do want to
+    # add -O0 -g, since users who want PCH usually want debugging and quick
+    # compiles.
+    dg-pch $subdir $test [concat [list {-O0 -g}] $torture_without_loops] ".h"
+}
+
+set test "largefile.c"
+set testh "largefile.hs"
+set f [open $test w]
+puts $f "/* { dg-xfail-if \"PR 14940\" { \"i?86-*-solaris2.10\" } { \"*\" } { \"\" } } */"
+puts $f "/* { dg-timeout-factor 4.0 } */"
+set v 0
+for { set v 0 } { $v < 10000 } { incr v } {
+    puts $f "#define MACRO_${v} \"1234567890\" \"$v\""
+}
+puts $f "#include \"largefile.h\""
+close $f
+set f [open $testh w]
+close $f
+dg-pch $subdir $test [concat [list {-O0 -g}] $torture_without_loops] ".h"    
+file delete $test
+file delete $testh
+
+set dg-do-what-default "$old_dg_do_what_default"
+
+# All done.
+torture-finish
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pushpop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pushpop-1.c
new file mode 100644
index 000000000..c093e575a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pushpop-1.c
@@ -0,0 +1,11 @@
+#include "pushpop-1.hs"
+
+#if FOO != 2
+#error FOO != 2
+#endif
+#pragma pop_macro("FOO")
+
+#if FOO != 1
+#error FOR != 1
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pushpop-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pushpop-1.hs
new file mode 100644
index 000000000..e97a4f33a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/pushpop-1.hs
@@ -0,0 +1,5 @@
+#define FOO 1
+#pragma push_macro ("FOO")
+#undef FOO
+#define FOO 2
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/save-temps-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/save-temps-1.c
new file mode 100644
index 000000000..9a5e7223c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/save-temps-1.c
@@ -0,0 +1,9 @@
+/* { dg-options "-I. -save-temps" } */
+#include "save-temps-1.h"
+#ifndef T
+#error T not defined
+#endif
+#include <stddef.h>
+int x;
+
+/* { dg-final { cleanup-saved-temps ".s" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/save-temps-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/save-temps-1.hs
new file mode 100644
index 000000000..2fe5a3ee7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/save-temps-1.hs
@@ -0,0 +1,5 @@
+#define T 123
+int foo (void) 
+{
+  return 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-1.c
new file mode 100644
index 000000000..33a139120
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-1.c
@@ -0,0 +1,6 @@
+#include "static-1.h"
+static int bar(void)
+{
+  static int counter;
+  return counter++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-1.hs
new file mode 100644
index 000000000..08cc4395d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-1.hs
@@ -0,0 +1,5 @@
+static int foo(void)
+{
+  static int counter;
+  return counter++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-2.c
new file mode 100644
index 000000000..23e9af126
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-2.c
@@ -0,0 +1,6 @@
+#include "static-2.h"
+int bar(void)
+{
+  static int counter;
+  return counter++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-2.hs
new file mode 100644
index 000000000..08cc4395d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-2.hs
@@ -0,0 +1,5 @@
+static int foo(void)
+{
+  static int counter;
+  return counter++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-3.c
new file mode 100644
index 000000000..eae0ab078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-3.c
@@ -0,0 +1,8 @@
+#include "static-3.h"
+int bar(int *a)
+{
+  int i, tot;
+  for (i = tot = 0; i < 100; i++)
+    tot += a[i];
+  return tot;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-3.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-3.hs
new file mode 100644
index 000000000..b881945f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/static-3.hs
@@ -0,0 +1,7 @@
+static int foo(int *a)
+{
+  int i, tot;
+  for (i = tot = 0; i < 100; i++)
+    tot += a[i];
+  return tot;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/struct-1.c
new file mode 100644
index 000000000..9559c07e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/struct-1.c
@@ -0,0 +1,16 @@
+#include "struct-1.h"
+
+struct ChainSearchRecord {
+ int identity;
+};
+typedef struct ChainSearchRecord ChainSearchRecord;
+void foo (ChainSearchPtr s)
+{
+#if(__SIZEOF_INT__ >= 4)	
+  s->identity = 0x6a73616d;
+#else
+   s->identity = 0x616d;
+#endif
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/struct-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/struct-1.hs
new file mode 100644
index 000000000..055353a8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/struct-1.hs
@@ -0,0 +1,3 @@
+struct ChainSearchRecord;
+typedef struct ChainSearchRecord *ChainSearchPtr;
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/system-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/system-1.c
new file mode 100644
index 000000000..9fde1365d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/system-1.c
@@ -0,0 +1,6 @@
+#include "system-1.h"
+int main(void)
+{
+  puts ("hello world!");
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/system-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/system-1.hs
new file mode 100644
index 000000000..fbfff34ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/system-1.hs
@@ -0,0 +1,2 @@
+#include <stdio.h>
+#include <stdlib.h>
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1.c
new file mode 100644
index 000000000..1bf7d9144
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1.c
@@ -0,0 +1,7 @@
+/* { dg-options "-I. -Winvalid-pch -g" } */
+
+#include "valid-1.h"/* { dg-warning "created with -gnone, but used with -g" } */
+/* { dg-error "No such file" "no such file" { target *-*-* } 3 } */
+/* { dg-error "they were invalid" "invalid files" { target *-*-* } 3 } */
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1.hs
new file mode 100644
index 000000000..e1ed11df4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1.hs
@@ -0,0 +1,3 @@
+/* { dg-options "-I. -Winvalid-pch -g0" } */
+
+extern int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1b.c
new file mode 100644
index 000000000..a2709967c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1b.c
@@ -0,0 +1,5 @@
+/* { dg-options "-I. -Winvalid-pch -g0" } */
+
+#include "valid-1b.h"
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1b.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1b.hs
new file mode 100644
index 000000000..6dc358735
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-1b.hs
@@ -0,0 +1,3 @@
+/* { dg-options "-I. -Winvalid-pch -g" } */
+
+extern int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-2.c
new file mode 100644
index 000000000..4dbc4b2d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-2.c
@@ -0,0 +1,6 @@
+/* { dg-options "-I. -Winvalid-pch -fexceptions" } */
+
+#include "valid-2.h" /* { dg-warning "settings for -fexceptions do not match" } */
+/* { dg-error "No such file" "no such file" { target *-*-* } 3 } */
+/* { dg-error "they were invalid" "invalid files" { target *-*-* } 3 } */
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-2.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-2.hs
new file mode 100644
index 000000000..2497af651
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-2.hs
@@ -0,0 +1 @@
+extern int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-4.c
new file mode 100644
index 000000000..e4419b570
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-4.c
@@ -0,0 +1,6 @@
+/* { dg-options "-I. -Winvalid-pch -Wtrigraphs" } */
+
+#include "valid-4.h"
+
+char * x = "??/";  /* { dg-warning "trigraph" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-4.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-4.hs
new file mode 100644
index 000000000..051c720ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-4.hs
@@ -0,0 +1 @@
+extern char * x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-5.c
new file mode 100644
index 000000000..4022d0458
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-5.c
@@ -0,0 +1,5 @@
+/* { dg-options "-I. -Winvalid-pch -pedantic-errors" } */
+
+#include "valid-5.h"
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-5.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-5.hs
new file mode 100644
index 000000000..2497af651
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-5.hs
@@ -0,0 +1 @@
+extern int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-6.c
new file mode 100644
index 000000000..f111c31ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-6.c
@@ -0,0 +1,5 @@
+/* { dg-options "-I. -Winvalid-pch -dH -pipe -fcond-mismatch" } */
+
+#include "valid-6.h"
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-6.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-6.hs
new file mode 100644
index 000000000..2497af651
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/valid-6.hs
@@ -0,0 +1 @@
+extern int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/warn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/warn-1.c
new file mode 100644
index 000000000..eaa9cafc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/warn-1.c
@@ -0,0 +1,13 @@
+/* { dg-options "-I. -Winvalid-pch" } */
+
+#define DEFINED_VALUE 3
+
+#include "warn-1.h"/* { dg-warning "not used because .DEFINED_VALUE. is defined" } */
+/* { dg-error "No such file" "no such file" { target *-*-* } 5 } */
+/* { dg-error "they were invalid" "invalid files" { target *-*-* } 5 } */
+
+
+int main(void) 
+{
+  return DEFINED_VALUE;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/warn-1.hs b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/warn-1.hs
new file mode 100644
index 000000000..460963f56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pch/warn-1.hs
@@ -0,0 +1,5 @@
+enum {
+  DEFINED_VALUE
+};
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pic-macro-define.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pic-macro-define.c
new file mode 100644
index 000000000..7bda6fedf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pic-macro-define.c
@@ -0,0 +1,10 @@
+/* { dg-do run { target "i?86-*-*-darwin" powerpc*-*-darwin* } } */
+/* { dg-options "-fPIC" } */
+
+#if defined __PIC__ 
+int main() {
+	return 0;
+}
+#else
+  error "NO __PIC__ DEFINED"	
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pie-link.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pie-link.c
new file mode 100644
index 000000000..00ff49597
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pie-link.c
@@ -0,0 +1,7 @@
+/* { dg-do link { target *-*-darwin[912]* *-*-linux* } } */
+/* { dg-options "-fpie" } */
+
+int main(void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c
new file mode 100644
index 000000000..74e68bb82
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c
@@ -0,0 +1,12 @@
+/* Test the ggcplug plugin.  */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+int main()
+{
+  int i=0, j=0;
+  for (i= 0; i<1000; i++)
+    if (i%8 == 0)
+      j++;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/ggcplug.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/ggcplug.c
new file mode 100644
index 000000000..f90e77bcf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/ggcplug.c
@@ -0,0 +1,112 @@
+/* This plugin tests the GGC related plugin events.  */
+/* { dg-options "-O" } */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "toplev.h"
+#include "basic-block.h"
+#include "gimple.h"
+#include "tree.h"
+#include "tree-pass.h"
+#include "intl.h"
+#include "gcc-plugin.h"
+
+
+
+/* our callback is the same for all PLUGIN_GGC_START,
+   PLUGIN_GGC_MARKING, PLUGIN_GGC_END events; it just increments the
+   user_data which is an int */
+static void increment_callback (void *gcc_data, void *user_data);
+
+/* our counters are user_data */
+static int our_ggc_start_counter;
+static int our_ggc_end_counter;
+static int our_ggc_marking_counter;
+
+/* our empty GGC extra root table */
+static const struct ggc_root_tab our_xtratab[] = {
+  LAST_GGC_ROOT_TAB
+};
+
+
+/* The initialization routine exposed to and called by GCC. The spec of this
+   function is defined in gcc/gcc-plugin.h.
+
+   Note that this function needs to be named exactly "plugin_init".  */
+int
+plugin_init (struct plugin_name_args *plugin_info,
+	      struct plugin_gcc_version *version)
+{
+  const char *plugin_name = plugin_info->base_name;
+  int argc = plugin_info->argc;
+  int i = 0;
+  struct plugin_argument *argv = plugin_info->argv;
+  if (!plugin_default_version_check (version, version))
+    return 1;
+  /* Process the plugin arguments. This plugin takes the following arguments:
+     count-ggc-start count-ggc-end count-ggc-mark */
+  for (i = 0; i < argc; ++i)
+    {
+      if (!strcmp (argv[i].key, "count-ggc-start"))
+	{
+	  if (argv[i].value)
+	    warning (0, G_ ("option '-fplugin-arg-%s-count-ggc-start=%s'"
+			    " ignored (superfluous '=%s')"),
+		     plugin_name, argv[i].value, argv[i].value);
+	  else
+	    register_callback ("ggcplug",
+			       PLUGIN_GGC_START,
+			       increment_callback,
+			       (void *) &our_ggc_start_counter);
+	}
+      else if (!strcmp (argv[i].key, "count-ggc-end"))
+	{
+	  if (argv[i].value)
+	    warning (0, G_ ("option '-fplugin-arg-%s-count-ggc-end=%s'"
+			    " ignored (superfluous '=%s')"),
+		     plugin_name, argv[i].value, argv[i].value);
+	  else
+	    register_callback ("ggcplug",
+			       PLUGIN_GGC_END,
+			       increment_callback,
+			       (void *) &our_ggc_end_counter);
+	}
+      else if (!strcmp (argv[i].key, "count-ggc-mark"))
+	{
+	  if (argv[i].value)
+	    warning (0, G_ ("option '-fplugin-arg-%s-count-ggc-mark=%s'"
+			    " ignored (superfluous '=%s')"),
+		     plugin_name, argv[i].value, argv[i].value);
+	  else
+	    register_callback ("ggcplug",
+			       PLUGIN_GGC_MARKING,
+			       increment_callback,
+			       (void *) &our_ggc_marking_counter);
+	}
+      else if (!strcmp (argv[i].key, "test-extra-root"))
+	{
+	  if (argv[i].value)
+	    warning (0, G_ ("option '-fplugin-arg-%s-test-extra-root=%s'"
+			    " ignored (superfluous '=%s')"),
+		     plugin_name, argv[i].value, argv[i].value);
+	  else
+	    register_callback ("ggcplug",
+			       PLUGIN_REGISTER_GGC_ROOTS,
+			       NULL,
+			       (void *) our_xtratab);
+	}
+    }
+  /* plugin initialization succeeded */
+  return 0;
+ }
+
+static void
+increment_callback (void *gcc_data, void *user_data)
+{
+  int *usercountptr = (int *) user_data;
+  gcc_assert (!gcc_data);
+  gcc_assert (user_data);
+  (*usercountptr)++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/one_time-test-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/one_time-test-1.c
new file mode 100644
index 000000000..a49ecb4af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/one_time-test-1.c
@@ -0,0 +1,8 @@
+/* Test that pass is inserted and invoked once. */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+int main (int argc, char **argv) 
+{ 
+  return 0;  
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/one_time_plugin.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/one_time_plugin.c
new file mode 100644
index 000000000..8ae327a68
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/one_time_plugin.c
@@ -0,0 +1,60 @@
+/* Plugin that prints message if it inserted (and invoked) more than once. */
+#include "config.h"
+#include "gcc-plugin.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "toplev.h"
+#include "gimple.h"
+#include "tree-pass.h"
+#include "intl.h"
+
+static bool one_pass_gate (void)
+{
+  return true;
+}
+
+static unsigned int one_pass_exec (void)
+{
+  static int counter = 0;
+
+  if (counter > 0) {
+    printf ("Executed more than once \n");
+ }
+ counter++;
+}
+
+struct gimple_opt_pass one_pass = 
+{
+  {
+  GIMPLE_PASS,
+  "useless",                           /* name */
+  one_pass_gate,                         /* gate */
+  one_pass_exec,       /* execute */
+  NULL,                                 /* sub */
+  NULL,                                 /* next */
+  0,                                    /* static_pass_number */
+  0,                                    /* tv_id */
+  PROP_gimple_any,                      /* properties_required */
+  0,                                    /* properties_provided */
+  0,                                    /* properties_destroyed */
+  0,                                    /* todo_flags_start */
+  TODO_dump_func                        /* todo_flags_finish */
+  }
+};
+
+
+int plugin_init (struct plugin_name_args *plugin_info,
+                 struct plugin_gcc_version *version)
+{
+  struct plugin_pass p;
+
+  p.pass = &one_pass.pass;
+  p.reference_pass_name = "useless";
+  p.ref_pass_instance_number = 1;
+  p.pos_op = PASS_POS_INSERT_AFTER;
+
+  register_callback ("one_pass", PLUGIN_PASS_MANAGER_SETUP, NULL, &p);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/plugin.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/plugin.exp
new file mode 100644
index 000000000..3122fa8dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/plugin.exp
@@ -0,0 +1,69 @@
+#   Copyright (C) 2009 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/>.
+
+# Test the functionality of the GCC plugin support
+
+load_lib target-supports.exp
+load_lib gcc-dg.exp
+
+global TESTING_IN_BUILD_TREE
+global ENABLE_PLUGIN
+
+# The plugin testcases currently only work when the build tree is available.
+# Also check whether the host supports plugins.
+if { ![info exists TESTING_IN_BUILD_TREE] || ![info exists ENABLE_PLUGIN] } {
+    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"
+}
+
+# The procedures in plugin-support.exp need these parameters.
+set default_flags $DEFAULT_CFLAGS
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+# Load support procs.
+load_lib plugin-support.exp
+
+# Specify the plugin source file and the associated test files in a list.
+# plugin_test_list={ {plugin1 test1 test2 ...} {plugin2 test1 ...} ... }
+set plugin_test_list [list \
+    { selfassign.c self-assign-test-1.c self-assign-test-2.c } \
+    { ggcplug.c ggcplug-test-1.c } \
+    { one_time_plugin.c one_time-test-1.c } \
+    { start_unit_plugin.c start_unit-test-1.c } \
+]
+
+foreach plugin_test $plugin_test_list {
+    # Replace each source file with its full-path name
+    for {set i 0} {$i < [llength $plugin_test]} {incr i} {
+	set basename [lindex $plugin_test $i]
+	set plugin_test [lreplace $plugin_test $i $i $srcdir/$subdir/$basename]
+    }
+    set plugin_src [lindex $plugin_test 0]
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $plugin_src] then {
+        continue
+    }
+    set plugin_input_tests [lreplace $plugin_test 0 0]
+    plugin-test-execute $plugin_src $plugin_input_tests
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c
new file mode 100644
index 000000000..f6dc5240f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c
@@ -0,0 +1,23 @@
+/* Test the self-assignemnt detection plugin.  */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+struct Bar {
+  int b_;
+  int c_;
+};
+
+int g;
+
+int main()
+{
+  struct Bar *bar;
+  int x = x; /* { dg-warning "assigned to itself" } */
+  static int y;
+  struct Bar b_array[5];
+
+  b_array[x+g].b_ = b_array[x+g].b_; /* { dg-warning "self-assignment detected" } */
+  g = g; /* { dg-warning "assigned to itself" } */
+  y = y; /* { dg-warning "assigned to itself" } */
+  bar->b_ = bar->b_; /* { dg-warning "assigned to itself" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c
new file mode 100644
index 000000000..2ede371a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c
@@ -0,0 +1,23 @@
+/* Test the self-assignemnt detection plugin with the 'disable' argument.  */
+/* { dg-do compile } */
+/* { dg-options "-O -fplugin-arg-selfassign-disable" } */
+
+struct Bar {
+  int b_;
+  int c_;
+};
+
+int g;
+
+int main()
+{
+  struct Bar *bar;
+  int x = x; /* { dg-bogus "assigned to itself" } */
+  static int y;
+  struct Bar b_array[5];
+
+  b_array[x+g].b_ = b_array[x+g].b_; /* { dg-bogus "self-assignment detected" } */
+  g = g; /* { dg-bogus "assigned to itself" } */
+  y = y; /* { dg-bogus "assigned to itself" } */
+  bar->b_ = bar->b_; /* { dg-bogus "assigned to itself" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/selfassign.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/selfassign.c
new file mode 100644
index 000000000..c210ab4c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/selfassign.c
@@ -0,0 +1,380 @@
+/* This plugin contains an analysis pass that detects and warns about
+   self-assignment statements.  */
+/* { dg-options "-O" } */
+
+#include "gcc-plugin.h"
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "toplev.h"
+#include "basic-block.h"
+#include "gimple.h"
+#include "tree.h"
+#include "tree-pass.h"
+#include "intl.h"
+#include "plugin-version.h"
+
+
+/* Indicate whether to check overloaded operator '=', which is performed by
+   default. To disable it, use -fplugin-arg-NAME-no-check-operator-eq.  */
+bool check_operator_eq = true;
+
+/* Given a rhs EXPR of a gimple assign statement, if it is
+   - SSA_NAME : returns its var decl, or, if it is a temp variable,
+                returns the rhs of its SSA def statement.
+   - VAR_DECL, PARM_DECL, FIELD_DECL, or a reference expression :
+                returns EXPR itself.
+   - any other expression : returns NULL_TREE.  */
+
+static tree
+get_real_ref_rhs (tree expr)
+{
+  switch (TREE_CODE (expr))
+    {
+      case SSA_NAME:
+        {
+          /* Given a self-assign statement, say foo.x = foo.x,
+             the IR (after SSA) looks like:
+
+             D.1797_14 = foo.x;
+             foo.x ={v} D.1797_14;
+
+             So if the rhs EXPR is an SSA_NAME of a temp variable,
+             e.g. D.1797_14, we need to grab the rhs of its SSA def
+             statement (i.e. foo.x).  */
+          tree vdecl = SSA_NAME_VAR (expr);
+          if (DECL_ARTIFICIAL (vdecl)
+              && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
+            {
+              gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+              /* We are only interested in an assignment with a single
+                 rhs operand because if it is not, the original assignment
+                 will not possibly be a self-assignment.  */
+              if (is_gimple_assign (def_stmt)
+                  && (get_gimple_rhs_class (gimple_assign_rhs_code (def_stmt))
+                      == GIMPLE_SINGLE_RHS))
+                return get_real_ref_rhs (gimple_assign_rhs1 (def_stmt));
+              else
+                return NULL_TREE;
+            }
+          else
+            return vdecl;
+        }
+      case VAR_DECL:
+      case PARM_DECL:
+      case FIELD_DECL:
+      case COMPONENT_REF:
+      case INDIRECT_REF:
+      case ARRAY_REF:
+        return expr;
+      default:
+        return NULL_TREE;
+    }
+}
+
+/* Given an expression tree, EXPR, that may contains SSA names, returns an
+   equivalent tree with the SSA names converted to var/parm/field decls
+   so that it can be used with '%E' format modifier when emitting warning
+   messages.
+
+   This function currently only supports VAR/PARM/FIELD_DECL, reference
+   expressions (COMPONENT_REF, INDIRECT_REF, ARRAY_REF), integer constant,
+   and SSA_NAME. If EXPR contains any other tree nodes (e.g. an arithmetic
+   expression appears in array index), NULL_TREE is returned.  */
+
+static tree
+get_non_ssa_expr (tree expr)
+{
+  switch (TREE_CODE (expr))
+    {
+      case VAR_DECL:
+      case PARM_DECL:
+      case FIELD_DECL:
+        {
+          if (DECL_NAME (expr))
+            return expr;
+          else
+            return NULL_TREE;
+        }
+      case COMPONENT_REF:
+        {
+          tree base, orig_base = TREE_OPERAND (expr, 0);
+          tree component, orig_component = TREE_OPERAND (expr, 1);
+          base = get_non_ssa_expr (orig_base);
+          if (!base)
+            return NULL_TREE;
+          component = get_non_ssa_expr (orig_component);
+          if (!component)
+            return NULL_TREE;
+          /* If either BASE or COMPONENT is converted, build a new
+             component reference tree.  */
+          if (base != orig_base || component != orig_component)
+            return build3 (COMPONENT_REF, TREE_TYPE (component),
+                           base, component, NULL_TREE);
+          else
+            return expr;
+        }
+      case INDIRECT_REF:
+        {
+          tree orig_base = TREE_OPERAND (expr, 0);
+          tree base = get_non_ssa_expr (orig_base);
+          if (!base)
+            return NULL_TREE;
+          /* If BASE is converted, build a new indirect reference tree.  */
+          if (base != orig_base)
+            return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (base)), base);
+          else
+            return expr;
+        }
+      case ARRAY_REF:
+        {
+          tree array, orig_array = TREE_OPERAND (expr, 0);
+          tree index, orig_index = TREE_OPERAND (expr, 1);
+          array = get_non_ssa_expr (orig_array);
+          if (!array)
+            return NULL_TREE;
+          index = get_non_ssa_expr (orig_index);
+          if (!index)
+            return NULL_TREE;
+          /* If either ARRAY or INDEX is converted, build a new array
+             reference tree.  */
+          if (array != orig_array || index != orig_index)
+            return build4 (ARRAY_REF, TREE_TYPE (expr), array, index,
+                           TREE_OPERAND (expr, 2), TREE_OPERAND (expr, 3));
+          else
+            return expr;
+        }
+      case SSA_NAME:
+        {
+          tree vdecl = SSA_NAME_VAR (expr);
+          if (DECL_ARTIFICIAL (vdecl)
+              && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
+            {
+              gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+              if (is_gimple_assign (def_stmt)
+                  && (get_gimple_rhs_class (gimple_assign_rhs_code (def_stmt))
+                      == GIMPLE_SINGLE_RHS))
+                vdecl = gimple_assign_rhs1 (def_stmt);
+            }
+          return get_non_ssa_expr (vdecl);
+        }
+      case INTEGER_CST:
+        return expr;
+      default:
+        /* Return NULL_TREE for any other kind of tree nodes.  */
+        return NULL_TREE;
+    }
+}
+
+/* Given the LHS and (real) RHS of a gimple assign statement, STMT, check if
+   they are the same. If so, print a warning message about self-assignment.  */
+
+static void
+compare_and_warn (gimple stmt, tree lhs, tree rhs)
+{
+  if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
+    {
+      location_t location;
+      location = (gimple_has_location (stmt)
+                  ? gimple_location (stmt)
+                  : (DECL_P (lhs)
+                     ? DECL_SOURCE_LOCATION (lhs)
+                     : input_location));
+      /* If LHS contains any tree node not currently supported by
+         get_non_ssa_expr, simply emit a generic warning without
+         specifying LHS in the message.  */
+      lhs = get_non_ssa_expr (lhs);
+      if (lhs)
+        warning (0, G_("%H%qE is assigned to itself"), &location, lhs);
+      else
+        warning (0, G_("%Hself-assignment detected"), &location);
+    }
+}
+
+/* Check and warn if STMT is a self-assign statement.  */
+
+static void
+check_self_assign (gimple stmt)
+{
+  tree rhs, lhs;
+
+  /* Check assigment statement.  */
+  if (is_gimple_assign (stmt)
+      && (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
+          == GIMPLE_SINGLE_RHS))
+    {
+      rhs = get_real_ref_rhs (gimple_assign_rhs1 (stmt));
+      if (!rhs)
+        return;
+
+      lhs = gimple_assign_lhs (stmt);
+      if (TREE_CODE (lhs) == SSA_NAME)
+        {
+          lhs = SSA_NAME_VAR (lhs);
+          if (DECL_ARTIFICIAL (lhs))
+            return;
+        }
+
+      compare_and_warn (stmt, lhs, rhs);
+    }
+  /* Check overloaded operator '=' (if enabled).  */
+  else if (check_operator_eq && is_gimple_call (stmt))
+    {
+      tree fdecl = gimple_call_fndecl (stmt);
+      if (fdecl && (DECL_NAME (fdecl) == maybe_get_identifier ("operator=")))
+        {
+          /* If 'operator=' takes reference operands, the arguments will be 
+             ADDR_EXPR trees. In this case, just remove the address-taken
+             operator before we compare the lhs and rhs.  */
+          lhs = gimple_call_arg (stmt, 0);
+          if (TREE_CODE (lhs) == ADDR_EXPR)
+            lhs = TREE_OPERAND (lhs, 0);
+          rhs = gimple_call_arg (stmt, 1);
+          if (TREE_CODE (rhs) == ADDR_EXPR)
+            rhs = TREE_OPERAND (rhs, 0);
+
+          compare_and_warn (stmt, lhs, rhs);
+        }
+    }
+}
+
+/* Entry point for the self-assignment detection pass.  */
+
+static unsigned int
+execute_warn_self_assign (void)
+{
+  gimple_stmt_iterator gsi;
+  basic_block bb;
+
+  FOR_EACH_BB (bb)
+    {
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+        check_self_assign (gsi_stmt (gsi));
+    }
+
+  return 0;
+}
+
+/* Pass gate function. Currently always returns true.  */
+
+static bool
+gate_warn_self_assign (void)
+{
+  return true;
+}
+
+static struct gimple_opt_pass pass_warn_self_assign =
+{
+  {
+    GIMPLE_PASS,
+    "warn_self_assign",                   /* name */
+    gate_warn_self_assign,                /* gate */
+    execute_warn_self_assign,             /* execute */
+    NULL,                                 /* sub */
+    NULL,                                 /* next */
+    0,                                    /* static_pass_number */
+    0,                                    /* tv_id */
+    PROP_ssa,                             /* properties_required */
+    0,                                    /* properties_provided */
+    0,                                    /* properties_destroyed */
+    0,                                    /* todo_flags_start */
+    TODO_dump_func                        /* todo_flags_finish */
+  }
+};
+
+/* The initialization routine exposed to and called by GCC. The spec of this
+   function is defined in gcc/gcc-plugin.h.
+
+   PLUGIN_NAME - name of the plugin (useful for error reporting)
+   ARGC        - the size of the ARGV array
+   ARGV        - an array of key-value argument pair
+
+   Returns 0 if initialization finishes successfully.
+
+   Note that this function needs to be named exactly "plugin_init".  */
+
+int
+plugin_init (struct plugin_name_args *plugin_info,
+             struct plugin_gcc_version *version)
+{
+  struct plugin_pass pass_info;
+  const char *plugin_name = plugin_info->base_name;
+  int argc = plugin_info->argc;
+  struct plugin_argument *argv = plugin_info->argv;
+  bool enabled = true;
+  int i;
+  struct plugin_info info = {"0.1",
+			     "check-operator-eq:\n" \
+			     "  check calls to operator=\n"\
+			     "no-check-operator-eq: bar\n" \
+			     "  don't check calls to operator=\n" \
+			     "enable:\n" \
+			     "  register the pass\n" \
+			     "disable: bar\n"
+                             "  don't register the pass\n" };
+
+  if (!plugin_default_version_check (version, &gcc_version))
+    return 1;
+
+  /* Self-assign detection should happen after SSA is constructed.  */
+  pass_info.pass = &pass_warn_self_assign.pass;
+  pass_info.reference_pass_name = "ssa";
+  pass_info.ref_pass_instance_number = 1;
+  pass_info.pos_op = PASS_POS_INSERT_AFTER;
+
+  /* Process the plugin arguments. This plugin takes the following arguments:
+     check-operator-eq, no-check-operator-eq, enable, and disable.
+     By default, the analysis is enabled with 'operator=' checked.  */
+  for (i = 0; i < argc; ++i)
+    {
+      if (!strcmp (argv[i].key, "check-operator-eq"))
+        {
+          if (argv[i].value)
+            warning (0, G_("option '-fplugin-arg-%s-check-operator-eq=%s'"
+                           " ignored (superfluous '=%s')"),
+                     plugin_name, argv[i].value, argv[i].value);
+          else
+            check_operator_eq = true;
+        }
+      else if (!strcmp (argv[i].key, "no-check-operator-eq"))
+        {
+          if (argv[i].value)
+            warning (0, G_("option '-fplugin-arg-%s-no-check-operator-eq=%s'"
+                           " ignored (superfluous '=%s')"),
+                     plugin_name, argv[i].value, argv[i].value);
+          else
+            check_operator_eq = false;
+        }
+      else if (!strcmp (argv[i].key, "enable"))
+        {
+          if (argv[i].value)
+            warning (0, G_("option '-fplugin-arg-%s-enable=%s' ignored"
+                           " (superfluous '=%s')"),
+                     plugin_name, argv[i].value, argv[i].value);
+          else
+            enabled = true;
+        }
+      else if (!strcmp (argv[i].key, "disable"))
+        {
+          if (argv[i].value)
+            warning (0, G_("option '-fplugin-arg-%s-disable=%s' ignored"
+                           " (superfluous '=%s')"),
+                     plugin_name, argv[i].value, argv[i].value);
+          else
+            enabled = false;
+        }
+      else
+        warning (0, G_("plugin %qs: unrecognized argument %qs ignored"),
+                 plugin_name, argv[i].key);
+    }
+
+  register_callback (plugin_name, PLUGIN_INFO, NULL, &info);
+
+  /* Register this new pass with GCC if the analysis is enabled.  */
+  if (enabled)
+    register_callback (plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL,
+                       &pass_info);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c
new file mode 100644
index 000000000..4cd8a40f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+int main (int argc, char **argv) 
+{ 
+  return 0;  
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c
new file mode 100644
index 000000000..e238d4257
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c
@@ -0,0 +1,66 @@
+/* This plugin tests the correct operation of a PLUGIN_START_UNIT callback.
+ * By the time a PLUGIN_START_UNIT callback is invoked, the frontend 
+ * initialization should have completed. At least the different *_type_nodes
+ * should have been created. This plugin creates an artifical global 
+ * interger variable.
+ * 
+*/
+#include "gcc-plugin.h"
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "toplev.h"
+#include "basic-block.h"
+#include "gimple.h"
+#include "tree.h"
+#include "tree-pass.h"
+#include "intl.h"
+
+int plugin_is_GPL_compatible;
+static tree fake_var = NULL;
+
+static bool
+gate_start_unit (void)
+{
+  return true;
+}
+
+static void start_unit_callback (void *gcc_data, void *user_data)
+{
+  if (integer_type_node) {
+    fake_var = build_decl (VAR_DECL, 
+                           get_identifier ("_fake_var_"),
+                           integer_type_node);
+    TREE_PUBLIC (fake_var) = 1;
+    DECL_ARTIFICIAL (fake_var) = 1;
+  }
+}
+
+static void finish_unit_callback (void *gcc_data, void *user_data)
+{
+  if (fake_var == NULL) {
+    printf ("fake_var not created \n");
+    return;
+  }
+  if (TREE_CODE (fake_var) != VAR_DECL) {
+    printf ("fake_var not a VAR_DECL \n");
+    return;
+  }
+  if (TREE_CODE (TREE_TYPE (fake_var)) != INTEGER_TYPE) {
+    printf ("fake_var not INTEGER_TYPE \n");
+    return;
+  }
+  if (DECL_ARTIFICIAL (fake_var) == 0) {
+    printf ("fake_var not ARTIFICIAL \n");
+    return;
+  }
+}
+
+int plugin_init (struct plugin_name_args *plugin_info,
+                 struct plugin_gcc_version *version)
+{
+  register_callback ("start_unit", PLUGIN_START_UNIT, &start_unit_callback, NULL);
+  register_callback ("finish_unit", PLUGIN_FINISH_UNIT, &finish_unit_callback, NULL);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-1.c
new file mode 100644
index 000000000..8bf6e285d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-1.c
@@ -0,0 +1,39 @@
+/* Test diagnostics for arithmetic on void and function pointers.
+   Test with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void *p;
+void (*f)(void);
+
+void
+g (void)
+{
+  p + 0;
+  p + 1;
+  0 + p;
+  1 + p;
+  p - 0;
+  p - 1;
+  p += 0;
+  p += 1;
+  p -= 0;
+  p -= 1;
+  f + 0;
+  f + 1;
+  0 + f;
+  1 + f;
+  f - 0;
+  f - 1;
+  f += 0;
+  f += 1;
+  f -= 0;
+  f -= 1;
+  p[0]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  0[p]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  f[0]; /* { dg-error "subscripted value is pointer to function" } */
+  0[f]; /* { dg-error "subscripted value is pointer to function" } */
+  p - p;
+  f - f;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-10.c
new file mode 100644
index 000000000..220891e20
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-10.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+char *foo(char *p, __SIZE_TYPE__ i)
+{
+  return (char *)i + (__SIZE_TYPE__)p;
+}
+
+/* { dg-final { scan-tree-dump "p +" "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-2.c
new file mode 100644
index 000000000..cda287c28
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-2.c
@@ -0,0 +1,41 @@
+/* Test diagnostics for arithmetic on void and function pointers.
+   Test with -Wpointer-arith.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wpointer-arith" } */
+
+void *p;
+void (*f)(void);
+
+void
+g (void)
+{
+  p + 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p + 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  0 + p; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  1 + p; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p - 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p - 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p += 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p += 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p -= 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p -= 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  f + 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f + 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  0 + f; /* { dg-warning "pointer to a function used in arithmetic" } */
+  1 + f; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f - 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f - 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f += 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f += 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f -= 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f -= 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  p[0]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  /* { dg-warning "pointer of type 'void \\*' used in arithmetic" "array 1" { target *-*-* } 33 } */
+  0[p]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  /* { dg-warning "pointer of type 'void \\*' used in arithmetic" "array 1" { target *-*-* } 35 } */
+  f[0]; /* { dg-error "subscripted value is pointer to function" } */
+  0[f]; /* { dg-error "subscripted value is pointer to function" } */
+  p - p; /* { dg-warning "pointer of type 'void \\*' used in subtraction" } */
+  f - f; /* { dg-warning "pointer to a function used in subtraction" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-3.c
new file mode 100644
index 000000000..bcfb2a4b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-3.c
@@ -0,0 +1,41 @@
+/* Test diagnostics for arithmetic on void and function pointers.
+   Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+void *p;
+void (*f)(void);
+
+void
+g (void)
+{
+  p + 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p + 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  0 + p; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  1 + p; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p - 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p - 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p += 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p += 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p -= 0; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  p -= 1; /* { dg-warning "pointer of type 'void \\*' used in arithmetic" } */
+  f + 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f + 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  0 + f; /* { dg-warning "pointer to a function used in arithmetic" } */
+  1 + f; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f - 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f - 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f += 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f += 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f -= 0; /* { dg-warning "pointer to a function used in arithmetic" } */
+  f -= 1; /* { dg-warning "pointer to a function used in arithmetic" } */
+  p[0]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  /* { dg-warning "pointer of type 'void \\*' used in arithmetic" "array 1" { target *-*-* } 33 } */
+  0[p]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  /* { dg-warning "pointer of type 'void \\*' used in arithmetic" "array 1" { target *-*-* } 35 } */
+  f[0]; /* { dg-error "subscripted value is pointer to function" } */
+  0[f]; /* { dg-error "subscripted value is pointer to function" } */
+  p - p; /* { dg-warning "pointer of type 'void \\*' used in subtraction" } */
+  f - f; /* { dg-warning "pointer to a function used in subtraction" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-4.c
new file mode 100644
index 000000000..daa5e0f5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-4.c
@@ -0,0 +1,41 @@
+/* Test diagnostics for arithmetic on void and function pointers.
+   Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+void *p;
+void (*f)(void);
+
+void
+g (void)
+{
+  p + 0; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p + 1; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  0 + p; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  1 + p; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p - 0; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p - 1; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p += 0; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p += 1; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p -= 0; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  p -= 1; /* { dg-error "pointer of type 'void \\*' used in arithmetic" } */
+  f + 0; /* { dg-error "pointer to a function used in arithmetic" } */
+  f + 1; /* { dg-error "pointer to a function used in arithmetic" } */
+  0 + f; /* { dg-error "pointer to a function used in arithmetic" } */
+  1 + f; /* { dg-error "pointer to a function used in arithmetic" } */
+  f - 0; /* { dg-error "pointer to a function used in arithmetic" } */
+  f - 1; /* { dg-error "pointer to a function used in arithmetic" } */
+  f += 0; /* { dg-error "pointer to a function used in arithmetic" } */
+  f += 1; /* { dg-error "pointer to a function used in arithmetic" } */
+  f -= 0; /* { dg-error "pointer to a function used in arithmetic" } */
+  f -= 1; /* { dg-error "pointer to a function used in arithmetic" } */
+  p[0]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  /* { dg-error "pointer of type 'void \\*' used in arithmetic" "array 1" { target *-*-* } 33 } */
+  0[p]; /* { dg-warning "dereferencing 'void \\*' pointer" } */
+  /* { dg-error "pointer of type 'void \\*' used in arithmetic" "array 1" { target *-*-* } 35 } */
+  f[0]; /* { dg-error "subscripted value is pointer to function" } */
+  0[f]; /* { dg-error "subscripted value is pointer to function" } */
+  p - p; /* { dg-error "pointer of type 'void \\*' used in subtraction" } */
+  f - f; /* { dg-error "pointer to a function used in subtraction" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-5.c
new file mode 100644
index 000000000..47564c049
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-5.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for sizeof on void and function types.  Test with
+   no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern const void v;
+void f(void);
+
+void
+g (void)
+{
+  sizeof (v);
+  sizeof (void);
+  sizeof (f);
+  sizeof (void (void));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-6.c
new file mode 100644
index 000000000..cf5f08b3e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-6.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for sizeof on void and function types.  Test with
+   -Wpointer-arith.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wpointer-arith" } */
+
+extern const void v;
+void f(void);
+
+void
+g (void)
+{
+  sizeof (v); /* { dg-warning "invalid application of 'sizeof' to a void type" } */
+  sizeof (void); /* { dg-warning "invalid application of 'sizeof' to a void type" } */
+  sizeof (f); /* { dg-warning "invalid application of 'sizeof' to a function type" } */
+  sizeof (void (void)); /* { dg-warning "invalid application of 'sizeof' to a function type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-7.c
new file mode 100644
index 000000000..a65e42866
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-7.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for sizeof on void and function types.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+extern const void v;
+void f(void);
+
+void
+g (void)
+{
+  sizeof (v); /* { dg-warning "invalid application of 'sizeof' to a void type" } */
+  sizeof (void); /* { dg-warning "invalid application of 'sizeof' to a void type" } */
+  sizeof (f); /* { dg-warning "invalid application of 'sizeof' to a function type" } */
+  sizeof (void (void)); /* { dg-warning "invalid application of 'sizeof' to a function type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-8.c
new file mode 100644
index 000000000..5426b79e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-8.c
@@ -0,0 +1,17 @@
+/* Test diagnostics for sizeof on void and function types.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+extern const void v;
+void f(void);
+
+void
+g (void)
+{
+  sizeof (v); /* { dg-error "invalid application of 'sizeof' to a void type" } */
+  sizeof (void); /* { dg-error "invalid application of 'sizeof' to a void type" } */
+  sizeof (f); /* { dg-error "invalid application of 'sizeof' to a function type" } */
+  sizeof (void (void)); /* { dg-error "invalid application of 'sizeof' to a function type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-9.c
new file mode 100644
index 000000000..2d2611272
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pointer-arith-9.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void *foo(void)
+{
+  return (void *)0 - 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/postincr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/postincr-1.c
new file mode 100644
index 000000000..752cda40c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/postincr-1.c
@@ -0,0 +1,21 @@
+/* Simple test for proper postincrement semantics.  */
+/* { dg-do run } */
+
+extern void abort (void);
+
+int i;
+int c;
+int *f ()
+{
+  ++c;
+  return &i;
+}
+
+int main ()
+{
+  int r;
+  r = (*f())++;
+  if (!(r == 0 && i == 1 && c == 1))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr10392-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr10392-1.c
new file mode 100644
index 000000000..8d599b8af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr10392-1.c
@@ -0,0 +1,63 @@
+/* PR optimization/10392
+ * Reporter: marcus@mc.pp.se
+ * Summary: [3.3/3.4 regression] [SH] optimizer generates faulty array indexing
+ * Description:
+ * The address calculation of an index operation on an array on the stack 
+ * can _under some conditions_ get messed up completely
+ *
+ * Testcase tweaked by dank@kegel.com
+ * Problem only happens with -O2 -m4, so it should only happen on sh4,
+ * but what the heck, let's test other architectures, too.
+ * Not marked as xfail since it's a regression.
+*/
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -m4" { target sh4-*-* } } */
+extern void abort (void);
+const char *dont_optimize_function_away;
+
+const char *use(const char *str)
+{
+	dont_optimize_function_away = str;
+	if (str[0] != 'v')
+		abort();
+	if (str[1] < '1' || str[1] > '6')
+		abort();
+	if (str[2])
+		abort();
+	return str[2] ? "notused" : "v6";
+}
+
+const char *func(char *a, char *b)
+{
+	char buf[128];
+	unsigned char i;
+	const char *result;
+
+	char *item[] = {
+		"v1",
+		"v2",
+	};
+
+	buf[0] = 'v';
+	buf[1] = '3';
+	buf[2] = 0;
+
+	for (i = 0; i < 2; i++) {
+		/* bug is: following line passes wild pointer to use() on sh4 -O2 */
+		result = use(item[i]);
+
+		use(buf);
+		use(a);
+		use(b);
+		result = use(result);
+	}
+	return result;
+}
+
+int main()
+{
+	func("v4", "v5");
+	return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11459-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11459-1.c
new file mode 100644
index 000000000..1edd94f81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11459-1.c
@@ -0,0 +1,6 @@
+/* -ansi -std=c99 should mean -std=c99, but the specs reordered the
+    options.  Bug 11459.  */
+/* { dg-do compile } */
+/* { dg-options "-ansi -std=c99 -pedantic" } */
+
+long long i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11492.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11492.c
new file mode 100644
index 000000000..866309953
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11492.c
@@ -0,0 +1,12 @@
+/* PR11492 */
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare" } */
+int main( void )
+{
+  unsigned int a;
+  unsigned char b;
+  for ( a = 0, b = 2; a > b * 100; a++ ) /* { dg-bogus "comparison between signed and unsigned integer" "" } */
+    { ; }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11864-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11864-1.c
new file mode 100644
index 000000000..b8d713419
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr11864-1.c
@@ -0,0 +1,42 @@
+/* PR optimization/11864
+ * Reporter: Kazumoto Kojima <kkojima@gcc.gnu.org>
+ * Summary: [3.3/3.4 regression] miscompiles zero extension and test
+ * Description:
+ * gcc-3.3/3.4 -O2 for sh target may miscompile the combination of zero extension
+ * and test if it's zero.
+ *
+ * Testcase tweaked by dank@kegel.com.  Not marked as xfail because it's a regression.
+ */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort(void);
+
+int val = 0xff00;
+
+int f(void)
+{
+	return val;
+}
+
+unsigned char a[1];
+
+void foo(void)
+{
+	a[0] = f() & 255;
+
+	if (!a[0])
+		a[0] = f() & 255;
+
+	if (!a[0])
+		a[0] = 1 + (f() & 127);
+}
+
+int main(int argc, char **argv)
+{
+	foo();
+	if (!a[0])
+		abort();
+
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr12603.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr12603.c
new file mode 100644
index 000000000..d0a4835cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr12603.c
@@ -0,0 +1,8 @@
+/* PR 12603: No return statement warning on function that never returns with -O3. */
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wall -Wextra -Wreturn-type -Wunreachable-code" } */
+int
+this_function_never_returns ()
+{
+  for (;;);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr12625-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr12625-1.c
new file mode 100644
index 000000000..9ad9f2889
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr12625-1.c
@@ -0,0 +1,13 @@
+/* Warning for assignment used as truth-value should apply for
+   bit-fields.  */
+/* Origin: bug 12625 from nomura at netapp.com */
+/* { dg-do compile } */
+/* { dg-options "-Wparentheses" } */
+
+static struct { int i:8; } s; 
+
+void
+foo ()
+{
+  if (s.i = 0) ; /* { dg-warning "parentheses" "warning for bit-field" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr13519-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr13519-1.c
new file mode 100644
index 000000000..907165f5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr13519-1.c
@@ -0,0 +1,47 @@
+/* typeof applied to const+nonconst should be nonconst, as should
+   typeof applied to other arithmetic expressions.  Bug 13519.  */
+/* Origin: Debian bug report 208981
+   from Kalle Olavi Niemitalo <kon@iki.fi>, adapted to a testcase by
+   Joseph Myers <jsm@polyomino.org.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void fn(void)
+{
+  int n;
+  const int c;
+
+  { __typeof__(n) a1; a1=0; }
+  { __typeof__(c) a2; a2=0; } /* { dg-error "read-only" "correct error" } */
+  { __typeof__((int)n) a3; a3=0; }
+  { __typeof__((int)c) a4; a4=0; } /* { dg-bogus "read-only" "bogus error" { xfail *-*-* } } */
+  { __typeof__((const int)n) a5; a5=0; } /* { dg-error "read-only" "correct error" { xfail *-*-* } } */
+  { __typeof__((const int)c) a6; a6=0; } /* { dg-error "read-only" "correct error" } */
+  { __typeof__(0) a7; a7=0; }
+  { __typeof__(1) a8; a8=0; }
+
+  { __typeof__(n+n) b0; b0=0; }
+  { __typeof__(n+c) b1; b1=0; }
+  { __typeof__(c+n) b2; b2=0; }
+  { __typeof__(c+c) b3; b3=0; }
+
+  { __typeof__(0+n) c0; c0=0; }
+  { __typeof__(0+c) c1; c1=0; }
+  { __typeof__(n+0) c2; c2=0; }
+  { __typeof__(c+0) c3; c3=0; }
+
+  { __typeof__(1+n) d0; d0=0; }
+  { __typeof__(1+c) d1; d1=0; }
+  { __typeof__(n+1) d2; d2=0; }
+  { __typeof__(c+1) d3; d3=0; }
+
+  { __typeof__(((int)n)+((int)n)) e0; e0=0; }
+  { __typeof__(((int)n)+((int)c)) e1; e1=0; }
+  { __typeof__(((int)c)+((int)n)) e2; e2=0; }
+  { __typeof__(((int)c)+((int)c)) e3; e3=0; }
+
+  { __typeof__(((const int)n)+((const int)n)) f0; f0=0; }
+  { __typeof__(((const int)n)+((const int)c)) f1; f1=0; }
+  { __typeof__(((const int)c)+((const int)n)) f2; f2=0; }
+  { __typeof__(((const int)c)+((const int)c)) f3; f3=0; }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr13804-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr13804-1.c
new file mode 100644
index 000000000..436367828
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr13804-1.c
@@ -0,0 +1,28 @@
+/* Diagnostics for attempts to access a member not in a structure or
+   union should name the type involved.  Bug 13804.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s0 { int a; };
+union u0 { long b; };
+typedef struct s0 S0;
+typedef union u0 U0;
+
+struct s0 x0;
+S0 x1;
+union u0 x2;
+U0 x3;
+struct s0 *x4;
+union u0 *x5;
+
+void
+f (void)
+{
+  x0.c; /* { dg-error "'struct s0' has no member named 'c'" } */
+  x1.c; /* { dg-error "'S0' has no member named 'c'" } */
+  x2.c; /* { dg-error "'union u0' has no member named 'c'" } */
+  x3.c; /* { dg-error "'U0' has no member named 'c'" } */
+  x4->c; /* { dg-error "'struct s0' has no member named 'c'" } */
+  x5->c; /* { dg-error "'union u0' has no member named 'c'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14092-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14092-1.c
new file mode 100644
index 000000000..927ecf6aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14092-1.c
@@ -0,0 +1,20 @@
+/* PR c/14092
+ * Origin: bonzini@gnu.org
+ * rejects-valid
+ */
+/* { dg-do compile } */
+
+/* Define this so that we are more portable.  The testcase in the
+   PR failed on 64-bit hosts.  */
+typedef int __attribute__ ((mode (__pointer__))) intptr_t;
+
+typedef struct _PLCI {
+  unsigned char x;
+  unsigned char buf[1];
+} PLCI;
+
+void nl_ind(PLCI * plci)
+{
+  plci->x = -((intptr_t)(plci->buf)) & 3;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14475.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14475.c
new file mode 100644
index 000000000..4fa5b0436
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14475.c
@@ -0,0 +1,10 @@
+/* This used to ICE because there was no null check in
+   check_bitfield_type_and_width. */
+
+struct tree_common
+{
+  enum tree_code code : 8; /* { dg-error "ISO C forbids forward references to" "" } */
+  /* { dg-error "type of bit-field .code. is a GCC extension" "" { target *-*-* } 6 } */
+  /* { dg-warning "narrower than values of its type" "" { target *-*-* } 6 } */
+  /* { dg-error "incomplete type" "" { target *-*-* } 6 } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14649-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14649-1.c
new file mode 100644
index 000000000..83a9f570e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14649-1.c
@@ -0,0 +1,16 @@
+/* PR c/14649 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+double atan(double);
+
+const double pi = 4*atan(1.0);  /* { dg-warning "(not constant)|(near initialization)" } */
+
+const double ok = 4*__builtin_atan(1.0);
+
+double foo()
+{
+  double ok2 = 4*atan(1.0);
+  return ok2;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14765-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14765-1.c
new file mode 100644
index 000000000..d2b341839
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14765-1.c
@@ -0,0 +1,11 @@
+/* Empty statement expressions should get void type.  Bug 14765 from
+   Serge Belyshev <belyshev@lubercy.com>.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int a;
+void fun ()
+{
+	a = 0;
+	a = ({}); /* { dg-error "not ignored" "void stmt expr" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14796-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14796-1.c
new file mode 100644
index 000000000..7ddc4fe34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14796-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int f (int a) {
+	return (a << 3) << 6;
+}
+
+int g (int b) {
+	return (b >> 5) << 5;
+}
+
+unsigned long long h (unsigned long long c) {
+	return (c << 60) >> 60;
+}
+
+int l (int d) {
+	return (d << 6) >> 6;
+}
+
+/* { dg-final { scan-tree-dump "a << 9" "gimple" } } */
+/* { dg-final { scan-tree-dump "b & -32" "gimple" } } */
+/* { dg-final { scan-tree-dump "c & 15" "gimple" } } */
+/* { dg-final { scan-tree-dump "d << 6" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14796-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14796-2.c
new file mode 100644
index 000000000..c0a91dc95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14796-2.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target int32plus } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int f (int a) {
+	return (a << 31) << 6;
+}
+
+unsigned int g (unsigned int a) {
+	return (a >> 7) >> 25;
+}
+
+int h (int b) {
+	return (b >> 30) >> 30;
+}
+
+long long j (long long c) {
+	return (c >> 35) << 35;
+}
+/* { dg-final { scan-tree-dump-times "= 0" 2 "gimple" } } */
+/* { dg-final { scan-tree-dump "b >> 31" "gimple" } } */
+/* { dg-final { scan-tree-dump "c & -(34359738368|0x800000000)" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14963.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14963.c
new file mode 100644
index 000000000..5a494d4c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr14963.c
@@ -0,0 +1 @@
+X Y(Z); /* { dg-error "" "error before" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15236.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15236.c
new file mode 100644
index 000000000..b01a4e858
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15236.c
@@ -0,0 +1,9 @@
+/* PR 15236: pedantic switch modifies treatment of non-ISO compliant
+   enumerations.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wextra -pedantic-errors -Wconversion" } */
+typedef enum OMX_ERRORTYPE
+{
+  OMX_ErrorNone = 0,
+  OMX_ErrorInsufficientResources = 0x80001000 /* { dg-error "ISO C restricts enumerator values to range of .int." } */
+} OMX_ERRORTYPE;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15360-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15360-1.c
new file mode 100644
index 000000000..4f900d7ea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15360-1.c
@@ -0,0 +1,24 @@
+/* Static declarations followed by extern are OK even if the extern
+   declaration is initialized.  Bug 15360 from hozelda at
+   yahoo.com.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+static int a;
+static int a;
+extern int a;
+static int a;
+
+static int b;
+extern int b = 1; /* { dg-warning "initialized and declared" "extern init warning" } */
+static int b;
+static int b;
+
+static int c; /* { dg-message "note: previous declaration" "" } */
+int c; /* { dg-error "non-static" "correct error" } */
+
+static int d; /* { dg-message "note: previous declaration" "" } */
+int d = 1; /* { dg-error "non-static" "correct error" } */
+
+void foo (void) { extern int e = 1; } /* { dg-error "has both" "extern init in function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15443-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15443-1.c
new file mode 100644
index 000000000..d6106b5b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15443-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+void f () __attribute__ ((__malloc__)); /* { dg-warning "ignored" } */
+
+int main ()
+{
+	/* This used to cause an ICE.  */
+	f ();
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15443-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15443-2.c
new file mode 100644
index 000000000..d97fa2573
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15443-2.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+
+struct foo {
+	int bar;
+};
+
+typedef struct foo* bar;
+void f () __attribute__ ((__malloc__)); /* { dg-warning "ignored" } */
+int g () __attribute__ ((__malloc__)); /* { dg-warning "ignored" } */
+int* h () __attribute__ ((__malloc__));
+void* i () __attribute__ ((__malloc__));
+
+struct foo j () __attribute__ ((__malloc__)); /* { dg-warning "ignored" } */
+struct foo* k () __attribute__ ((__malloc__));
+bar l () __attribute__((malloc));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15649-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15649-1.c
new file mode 100644
index 000000000..090209c91
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15649-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math -O2" } */
+
+double foo (double x)
+{
+  return __builtin_isgreater (x, 0.0) ? 0.0 : x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-1.c
new file mode 100644
index 000000000..6bb001aea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-1.c
@@ -0,0 +1,23 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Original test.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int	foobar ();
+
+int func (int blah)
+{
+  char *rindex();
+}
+
+int foobar ()
+{
+  return 0;
+}
+
+char *rindex(a, b)
+     register char *a, b;
+{ /* { dg-warning "argument 'a' doesn't match built-in prototype" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-2.c
new file mode 100644
index 000000000..3ad60a9a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-2.c
@@ -0,0 +1,9 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Prototype at inner scope.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void f() { void g(void); } /* { dg-error "prototype declaration" } */
+void g(a) int a; {} /* { dg-error "number of arguments doesn't match prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-3.c
new file mode 100644
index 000000000..a7a35059c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-3.c
@@ -0,0 +1,11 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Prototype not last declaration.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void f();
+void f(int); /* { dg-error "prototype declaration" } */
+void f();
+void f(a) long a; {} /* { dg-error "argument 'a' doesn't match prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-4.c
new file mode 100644
index 000000000..f86a35124
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-4.c
@@ -0,0 +1,9 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Unprototyped built-in function with user prototype.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int isnan(void); /* { dg-error "prototype declaration" } */
+int isnan(a) int a; {} /* { dg-error "number of arguments doesn't match prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-5.c
new file mode 100644
index 000000000..288404b4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-5.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Unprototyped built-in function with user prototype at
+   inner scope.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void f(void) { int isnan(void); } /* { dg-error "prototype declaration" } */
+int isnan(a) int a; {} /* { dg-error "number of arguments doesn't match prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-6.c
new file mode 100644
index 000000000..efbc2e42d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-6.c
@@ -0,0 +1,9 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Prototyped built-in function, wrong number of
+   arguments.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+char *strchr(a) const char *a; { return 0; } /* { dg-warning "number of arguments doesn't match built-in prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-7.c
new file mode 100644
index 000000000..2393eac61
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-7.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Prototyped built-in function, wrong number of
+   arguments, with explicit prototype as well.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+char *strchr(const char *, int); /* { dg-error "prototype declaration" } */
+char *strchr(a) const char *a; { return 0; } /* { dg-error "number of arguments doesn't match prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-8.c
new file mode 100644
index 000000000..ee0c3ae46
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15698-8.c
@@ -0,0 +1,11 @@
+/* Test diagnostics for old-style definition not matching prior
+   prototype are present and give correct location for that prototype
+   (bug 15698).  Prototype refined at inner scope with only refinement
+   conflicting with definition.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int f(int (*)[]);
+int g() { int f(int (*)[2]); } /* { dg-error "prototype declaration" } */
+int f(a) int (*a)[3]; { return 0; } /* { dg-error "argument 'a' doesn't match prototype" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15749-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15749-1.c
new file mode 100644
index 000000000..e78816f80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15749-1.c
@@ -0,0 +1,8 @@
+/* Flexible array misuses (that are accepted without -pedantic) should
+   be OK in system headers even with -pedantic-errors.  PR 15749
+   from Tuomo dot Tikkanen at nokia dot com.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+#include "pr15749-1.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15749-1.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15749-1.h
new file mode 100644
index 000000000..db4a259fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15749-1.h
@@ -0,0 +1,28 @@
+/* Similar to c99-flex-array-3.c, but a system header so should not
+   have diagnostics even with -pedantic-errors.  */
+
+#pragma GCC system_header
+
+struct flex { int a; int b[]; };
+union rf1 { struct flex a; int b; };
+union rf2 { int a; struct flex b; };
+union rf3 { int a; union rf1 b; };
+union rf4 { union rf2 a; int b; };
+
+struct t0 { struct flex a; };
+struct t1 { union rf1 a; };
+struct t2 { union rf2 a; };
+struct t3 { union rf3 a; };
+struct t4 { union rf4 a; };
+
+void f0 (struct flex[]);
+void f1 (union rf1[]);
+void f2 (union rf2[]);
+void f3 (union rf3[]);
+void f4 (union rf4[]);
+
+struct flex a0[1];
+union rf1 a1[1];
+union rf2 a2[1];
+union rf3 a3[1];
+union rf4 a4[1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-1.c
new file mode 100644
index 000000000..77e398e1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-1.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -fdump-tree-gimple" } */
+/* Test for folding abs(x) where appropriate.  */
+#define abs(x) x > 0 ? x : -x
+extern double fabs (double);
+
+int a (int x) {
+	return (abs(x)) >= 0;
+}
+
+int b (int x) {
+	return (abs(x)) == 0;
+}
+
+int c (int x) {
+	return (abs(x)) != 0;
+}
+
+int d (int x) {
+	return 0 != (abs(x));
+}
+
+int e (int x) {
+	return 0 == (abs(x));
+}
+
+int f (int x) {
+	return 0 <= (abs(x));
+}
+
+int g (int x) {
+	return 0 > (abs(x));
+}
+
+int h (float x) {
+	return 0.0 > fabs(x);
+}
+
+int i (float x) {
+	return fabs(x) == -0.0;
+}
+/* { dg-final { scan-tree-dump-times "ABS_EXPR" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-2.c
new file mode 100644
index 000000000..eb1608c64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple -ffast-math" } */
+/* Test for folding abs(x) where appropriate.  */
+#define abs(x) x > 0 ? x : -x
+extern double fabs (double);
+
+int a (float x) {
+	return fabs(x) >= 0.0;
+}
+
+/* { dg-final { scan-tree-dump-times "ABS_EXPR" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-3.c
new file mode 100644
index 000000000..746f9660e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-3.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-skip-if "No NaN support" { spu-*-* } } */
+/* SH4 without -mieee defaults to -ffinite-math-only.  */
+/* { dg-options "-fdump-tree-gimple -fno-finite-math-only" } */
+/* Test for folding abs(x) where appropriate.  */
+#define abs(x) x > 0 ? x : -x
+extern double fabs (double);
+
+int a (float x) {
+	return fabs(x) >= 0.0;
+}
+
+/* { dg-final { scan-tree-dump-times "ABS_EXPR" 1 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-4.c
new file mode 100644
index 000000000..0d31697a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15784-4.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int a (int x) {
+	return ~x + 1; /* -x */
+}
+
+int b (int x) {
+	return -x -1; /* ~x */
+}
+
+/* { dg-final { scan-tree-dump "~x;" "optimized" } } */
+/* { dg-final { scan-tree-dump "-x;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15785-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15785-1.c
new file mode 100644
index 000000000..47cd3d7b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15785-1.c
@@ -0,0 +1,42 @@
+/* { dg-do link } */
+
+extern void link_error ();
+
+void a (int x) {
+	if (~ (~x) - x)
+		link_error ();
+}
+void b (int x) {
+	if (- (-x) - x)
+		link_error ();
+}
+
+void c (int x) {
+	if (!(- (~x) - x))
+		link_error ();
+}
+
+void d (int x) {
+	if (!(~ (-x) - x))
+		link_error ();
+}
+
+void e (int x) {
+	if (x + ~(x - 1))
+		link_error ();
+}
+
+void f (int x) {
+	if (x + ~(x + (-1)))
+		link_error ();
+}
+
+int main (int argc, char *argv[]) {
+	a(argc);
+	b(argc);
+	c(argc);
+	d(argc);
+	e(argc);
+	f(argc);
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15825-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15825-1.c
new file mode 100644
index 000000000..a4b46d444
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr15825-1.c
@@ -0,0 +1,18 @@
+/* PR middle-end/15825 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+unsigned int foo(long long high, int unsigned_p)
+{
+  int i;
+  if (high < 0)
+    if (!unsigned_p)
+    {
+      i = 1;
+      goto t;
+    }
+  i = 0;
+t:
+  return i;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr16194.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr16194.c
new file mode 100644
index 000000000..8b4492240
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr16194.c
@@ -0,0 +1,78 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+/* { dg-bogus "internal compiler error" "ICE" { target *-*-* } 0 } */
+
+#undef SKIP
+#define ASMDECL __asm (REG);
+#define CLOBBER_LIST : REG
+#define INP_CLOBBER_LIST : CLOBBER_LIST
+#if defined (__alpha__)
+# define REG "$1"
+#elif defined (__CRIS__) || defined (__sh__)
+# define REG "r10"
+#elif defined (__hppa__)
+# define REG "%r10"
+#elif defined (__i386__)
+# define REG "%eax"
+#elif defined (__MMIX__)
+# define REG "$8"
+#elif defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) \
+        || defined (__POWERPC__) || defined (PPC) || defined (_IBMR2)
+# define REG "6"
+#elif defined (__x86_64__)
+# define REG "rax"
+#elif defined (__m68k__)
+# define REG "%d0"
+#else
+/* Make this test harmless for any target not recognized above.  */
+# define SKIP 1
+#endif
+
+#ifndef SKIP
+
+struct A
+{
+  int a;
+};
+
+struct B
+{
+  struct A b[3];
+};
+
+struct C
+{
+  struct B c;
+};
+
+void bug (void)
+{
+  register char* dst ASMDECL;
+  __asm__ ("":"=g"(*dst): : REG);
+}
+
+/* The tree optimizers currently prevent us from finding an overlap -
+   we end up using a copy of dst rather than dst.
+   But at least make sure we don't get an ICE.  */
+void bug2 (void)
+{
+  register char* dst ASMDECL;
+  __asm__ ("": :"g"(*dst) CLOBBER_LIST);
+}
+
+void
+foo (void)
+{
+  register struct C *dst ASMDECL;
+  __asm__ ("" : "=g"(dst->c.b[1].a) INP_CLOBBER_LIST);
+}
+
+#else
+
+int main ()
+{
+  return 0;
+}
+
+#endif
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr16973.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr16973.c
new file mode 100644
index 000000000..e24c9f821
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr16973.c
@@ -0,0 +1,12 @@
+/* We were removing the label "a" because
+   we were removing the BB for it but forgot
+   to add back the label.   */
+
+/* { dg-options "" } */
+
+void
+f (void)
+{
+  static __SIZE_TYPE__ x = &&a - &&b;
+  a : b : return;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17024-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17024-1.c
new file mode 100644
index 000000000..d8bdf012b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17024-1.c
@@ -0,0 +1,15 @@
+/* PR middle-end/17024 */
+/* { dg-do compile } */
+/* { dg-options "-funsafe-math-optimizations" } */
+
+#define MAX2(a,b) (((a)>(b)) ? (a) : (b))
+
+void C(double);
+
+void i(int k)
+{
+	double c[1];
+	C(MAX2(0.,c[k]));
+	return;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17036-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17036-1.c
new file mode 100644
index 000000000..ea2c9caf6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17036-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+
+int main ()
+{
+  int R, N = 4;
+  unsigned int A = 2;
+  signed int B = 2;
+  ((B >> N) & 1) ? 1 : 0;
+  ((A >> N) & 1) ? 1 : 0;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17055-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17055-1.c
new file mode 100644
index 000000000..faac48bc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17055-1.c
@@ -0,0 +1,25 @@
+/* PR middle-end/17055.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+/* { dg-options "-O2 -ffast-math -fno-common" { target hppa*-*-hpux* } } */
+
+/* This test used to abort, beacuse we do an "integer" fold to zero, i.e.
+   x - x = (T)0 where T is the type of x.  Unfortunately, fold_convert
+   was unable to convert integer_zero_node to the appropriate vector type.  */
+
+typedef float v4sf __attribute__((vector_size(16)));
+typedef int v4si __attribute__((vector_size(16)));
+
+v4sf ivf, ovf;
+v4si ivi, ovi;
+
+void testf (void)
+{
+  ovf = ivf - ivf;
+}
+
+void testi (void)
+{
+  ovi = ivi - ivi;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17112-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17112-1.c
new file mode 100644
index 000000000..d43868fe0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17112-1.c
@@ -0,0 +1,33 @@
+/* PR middle-end/17112 */
+/* { dg-do run } */
+/* { dg-require-effective-target int32plus } */
+/* { dg-options "-O2" } */
+
+extern void abort(void);
+
+typedef struct {
+  int int24:24  __attribute__ ((packed));
+} myint24;
+
+myint24 x[3] = {
+  0x123456,
+  0x789abc,
+  0xdef012
+};
+
+myint24 y[3];  // starts out as zeros
+
+void foo()
+{
+  y[1] = x[1];
+}
+
+int main()
+{
+  foo();
+
+  if (y[0].int24 != 0 || y[2].int24 != 0)
+    abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17188-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17188-1.c
new file mode 100644
index 000000000..2cad0120f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17188-1.c
@@ -0,0 +1,31 @@
+/* A redefinition of an empty struct should be diagnosed the same as a
+   redefinition of any other tag, but formerly only s2 and s4 were
+   diagnosed.  Bug 17188.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s0 { };
+struct s0;
+struct s0 { }; /* { dg-error "redefinition of 'struct s0'" } */
+
+struct s1 { };
+struct s1 { }; /* { dg-error "redefinition of 'struct s1'" } */
+
+struct s2 { int a : 1; };
+struct s2 { int a : 1; }; /* { dg-error "redefinition of 'struct s2'" } */
+
+struct s3 { };
+struct s3 { int a : 1; }; /* { dg-error "redefinition of 'struct s3'" } */
+
+struct s4 { int a : 1; };
+struct s4 { }; /* { dg-error "redefinition of 'struct s4'" } */
+
+struct s5 { int a : 1; };
+struct s5;
+
+struct s6;
+struct s6 { int a : 1; };
+
+struct s7;
+struct s7 { };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17301-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17301-1.c
new file mode 100644
index 000000000..28968fbb2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17301-1.c
@@ -0,0 +1,11 @@
+/* Invalid use of __builtin_va_start should not cause an ICE.  Bug
+   17301.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int
+write_format (char *format, ...)
+{
+  __builtin_va_list p;
+  __builtin_va_start (p); /* { dg-error "too few arguments to function 'va_start'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17301-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17301-2.c
new file mode 100644
index 000000000..b91a2314b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17301-2.c
@@ -0,0 +1,9 @@
+/* Invalid use of __builtin_va_start should not cause an ICE.  Bug
+   17301.  Case with no arguments.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void foo (char *format, ...)
+{
+  __builtin_va_start (); /* { dg-error "too few arguments to function '__builtin_va_start'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17319.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17319.c
new file mode 100644
index 000000000..5d39e4c57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17319.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dce" } */
+
+typedef unsigned long long HARD_REG_ELT_TYPE;
+typedef HARD_REG_ELT_TYPE HARD_REG_SET[2];
+static HARD_REG_SET newpat_used_regs;
+int try_combine (void)
+{
+ HARD_REG_ELT_TYPE *scan_tp_ = newpat_used_regs;
+ scan_tp_[0] = 0;
+ scan_tp_[1] = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17322.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17322.c
new file mode 100644
index 000000000..705787273
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17322.c
@@ -0,0 +1,5 @@
+/* PR 17322 */
+
+struct s { int a; int b[1]; };
+struct s x;
+int *y = ((struct s *)&x.a)->b;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17424-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17424-1.c
new file mode 100644
index 000000000..893b4af13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17424-1.c
@@ -0,0 +1,5 @@
+/* Test for bug 17424: ICE for sizeof an undeclared variable.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+;int foezis = sizeof tni; /* { dg-error "'tni' undeclared" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17581-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17581-1.c
new file mode 100644
index 000000000..b63517c84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17581-1.c
@@ -0,0 +1,30 @@
+/* PR rtl-optimization/17581 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort (void);
+
+int foo(int x)
+{
+  unsigned long long tmp = 0;
+
+  switch(x) {
+    case 21:
+      tmp |= 1;
+      tmp |= 2;
+      tmp |= 8;
+      break;
+    default:
+      break;
+  }
+  
+  return (int)tmp;
+}
+
+int main()
+{
+  if (foo(21) != 11)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17635.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17635.c
new file mode 100644
index 000000000..d2154c3f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17635.c
@@ -0,0 +1,11 @@
+/* PR 17635 */
+/* Contributed by Devang Patel  <dpatel@apple.com>  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+void foo(int i)
+{
+  while (1)
+    if (i) ++i;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17730-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17730-1.c
new file mode 100644
index 000000000..8f70ad805
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17730-1.c
@@ -0,0 +1,5 @@
+/* Test formatting of message for invalid lvalue.  Bug 17730.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+char *p = &'C'; /* { dg-error "lvalue required as unary '&' operand" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17844-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17844-1.c
new file mode 100644
index 000000000..d06bbb6d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17844-1.c
@@ -0,0 +1,20 @@
+/* -fshort-enums should affect only the type with which an enum is
+    compatible, not the type of the enumeration constants which should
+    still be int.  Bug 17844.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-fshort-enums" } */
+
+enum e { A, B };
+
+enum e ev;
+unsigned char uv;
+enum e *ep = &uv;
+unsigned char *up = &ev;
+
+int i;
+__typeof__(A) te;
+int *ip = &te;
+__typeof__(B) *tep = &i;
+
+int x[((sizeof(A) == sizeof(int)) ? 1 : -1)];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17957.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17957.c
new file mode 100644
index 000000000..ea18ea806
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr17957.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "--param ggc-min-expand=0 --param ggc-min-heapsize=0" } */
+/* { dg-options "-fno-common --param ggc-min-expand=0 --param ggc-min-heapsize=0" { target hppa*-*-hpux* } } */
+__attribute__ ((vector_size (64))) unsigned char v1, v2, v3;
+void
+vadd (void)
+{
+  v1 = v2 + v3;
+}
+void
+test_add (void)
+{
+  vadd ();
+}
+void
+vsub (void)
+{
+  v1 = v2 - v3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18164.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18164.c
new file mode 100644
index 000000000..cc753bbf5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18164.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+void
+f (void)
+{
+  int x;
+  asm ("" :  "" (x)); /* { dg-error "output operand constraint lacks" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-1.c
new file mode 100644
index 000000000..a37e77dac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-1.c
@@ -0,0 +1,111 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -Wall -Wextra -O1" } */ 
+
+extern void *memset (void*, int, __SIZE_TYPE__);
+extern void abort (void);
+
+struct radix_tree_root {
+	unsigned int height;
+	struct radix_tree_node *rnode;
+};
+
+struct radix_tree_node {
+	unsigned int count;
+	void *slots[64];
+	unsigned long tags[2][2];
+};
+
+struct radix_tree_path {
+	struct radix_tree_node *node, **slot;
+	int offset;
+};
+
+static unsigned long height_to_maxindex[7] =
+{0, 63, 4095, 262143, 16777215, 1073741823, 4294967295};
+
+static inline void tag_clear(struct radix_tree_node *node, int tag, int offset)
+{
+	int nr;
+	volatile unsigned long *addr;
+#if(__SIZEOF_INT__ >= 4)	
+	int mask;
+#else
+	long mask;
+#endif
+	
+	nr = offset;
+	addr = &node->tags[tag][0];
+
+	addr += nr >> 5;
+	mask = 1 << (nr & 0x1f);
+	*addr &= ~mask;
+}
+
+void *radix_tree_tag_clear(struct radix_tree_root *root, unsigned long index, int tag)
+{
+	struct radix_tree_path path[7], *pathp = path;
+	unsigned int height, shift;
+	void *ret = 0;
+	
+	height = root->height;
+	if (index > height_to_maxindex[height])
+		goto out;
+	
+	shift = (height - 1) * 6;
+	pathp->node = 0;
+	pathp->slot = &root->rnode;
+	
+	while (height > 0) {
+		int offset;
+		
+		if (*pathp->slot == 0)
+			goto out;
+		
+		offset = (index >> shift) & (64-1);
+		pathp[1].offset = offset;
+		pathp[1].node = *pathp[0].slot;
+		pathp[1].slot = (struct radix_tree_node **)
+			(pathp[1].node->slots + offset);
+		pathp++;
+		shift -= 6;
+		height--;
+	}
+	
+	ret = *pathp[0].slot;
+	if (ret == 0)
+		goto out;
+	
+	do {
+		int idx;
+		
+		tag_clear(pathp[0].node, tag, pathp[0].offset);
+		for (idx = 0; idx < 2; idx++) {
+			if (pathp[0].node->tags[tag][idx])
+				goto out;
+		}
+		pathp--;
+	} while (pathp[0].node);
+out:
+	return ret;
+}
+
+int main ()
+{
+	struct radix_tree_root r;
+	struct radix_tree_node node;
+	void *p = (void *) 0xdeadbeef;
+	
+  	r.height = 1;
+	r.rnode = &node;
+	
+	memset (&node, 0, sizeof (node));
+	
+	node.count = 1;
+	node.slots [13] = p;
+	
+	radix_tree_tag_clear (&r, 13, 1);
+	
+	if (r.rnode->slots[13] != p)
+		abort ();
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-2.c
new file mode 100644
index 000000000..a3ff1de0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-2.c
@@ -0,0 +1,65 @@
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -Wall -Wextra -O1" } */ 
+
+extern void *memset (void*, int, __SIZE_TYPE__);
+extern void abort (void);
+
+struct radix_tree_root {
+	unsigned int height;
+	struct radix_tree_node *rnode;
+};
+
+struct radix_tree_node {
+	unsigned int count;
+	void *slots[64];
+	unsigned long tags[2];
+};
+
+struct radix_tree_path {
+	struct radix_tree_node *node, **slot;
+	int offset;
+};
+
+void radix_tree_tag_clear(struct radix_tree_root *root, unsigned long index)
+{
+	struct radix_tree_path path[7], *pathp = path;
+	unsigned int height, shift;
+	volatile unsigned long *addr;
+	
+	height = root->height;
+	
+	shift = (height - 1) * 6;
+	path[0].slot = &root->rnode;
+	
+	while (height > 0) {
+		int offset;
+		
+		offset = (index >> shift) & (64-1);
+		pathp[1].offset = offset;
+		pathp[1].node = *pathp[0].slot;
+		pathp[1].slot = (struct radix_tree_node **)
+			(pathp[1].node->slots + offset);
+		pathp++;
+		shift -= 6;
+		height--;
+	}
+	
+	addr = &(pathp->node->tags[0]) + 1;
+	*addr = 574;
+}
+
+struct radix_tree_root r;
+struct radix_tree_node node;
+
+int main ()
+{
+  	r.height = 1;
+	r.rnode = &node;
+	
+	memset (&node, 0, sizeof (node));
+	
+	node.count = 1;
+	
+	radix_tree_tag_clear (&r, 13);
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-3.c
new file mode 100644
index 000000000..869b1e914
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-3.c
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-O1" } */ 
+
+void abort (void);
+
+void radix_tree_tag_clear (int *node)
+{
+	int *path[2], **pathp = path, height;
+	volatile int *addr;
+	
+	height = 1;
+	pathp[0] = node;
+	
+	while (height > 0) {
+		pathp[1] = pathp[0];
+		pathp++;
+		height--;
+	}
+	
+	addr = pathp[0];
+	*addr = 1;
+}
+
+int main ()
+{
+	int n;
+	radix_tree_tag_clear (&n);
+	if (n != 1)
+		abort ();
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-4.c
new file mode 100644
index 000000000..ad619377b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-4.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "-O1" } */ 
+
+void abort (void);
+
+int f(int i1243)
+{
+  int i[2], *i1 = i;
+  i[0] = 1;
+  volatile int *i2 = i1;
+  i2[1] = 1;
+  i1243 = 0;
+  return i2[1]+i2[0];
+}
+
+
+int main(void)
+{
+  if( f(100) != 2)
+   abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-5.c
new file mode 100644
index 000000000..0ddb55f75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18241-5.c
@@ -0,0 +1,14 @@
+/* { dg-do run } */
+/* { dg-options "-O1" } */ 
+
+void abort (void);
+
+int main ()
+{
+  int a;
+  volatile int *b = &a;
+  a = 1;
+  if (*b != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18479.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18479.c
new file mode 100644
index 000000000..493574e8a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18479.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+struct __attribute__ ((visibility("default"))) Foo { int foo; }; /* { dg-warning "attribute ignored on types" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18501.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18501.c
new file mode 100644
index 000000000..8794486ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18501.c
@@ -0,0 +1,20 @@
+/* Expected uninitialized variable warning.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+unsigned bmp_iter_set ();
+int something (void);
+
+void
+bitmap_print_value_set (void)
+{
+  unsigned first;	/* { dg-warning "may be used" "conditional in loop" { xfail *-*-* } } */
+  
+  for (; bmp_iter_set (); )
+    {
+      if (!first)
+	something ();
+      first = 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18502-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18502-1.c
new file mode 100644
index 000000000..038c8104a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18502-1.c
@@ -0,0 +1,7 @@
+/* Test that -trigraphs isn't reordered before -std=gnu99.  Bug
+   18502.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -trigraphs" } */
+
+int a??(2??);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18520-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18520-1.c
new file mode 100644
index 000000000..872d3a946
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18520-1.c
@@ -0,0 +1,11 @@
+/* PR middle-end/18520 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+extern int isnan (double __value) __attribute__ ((__const__));
+
+int gsl_isnan (const double x)
+{
+  return isnan(x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-1.c
new file mode 100644
index 000000000..dc34f444e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-1.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-unit-at-a-time" } */
+
+int f(int i)
+{
+  static int g(); /* { dg-error "invalid storage class" } */
+  static int g() { return i; } /* { dg-error "invalid storage class" } */
+  return g();
+}
+
+int k (int i)
+{
+  static int g (); /* { dg-error "invalid storage class" } */
+  int g () {
+	return i;
+  }
+
+  return g ();
+}
+
+int l (int i)
+{
+  auto int g ();
+  static int g () { /* { dg-error "invalid storage class" } */
+    return i;
+  }
+
+  static int h () { /* { dg-error "invalid storage class" } */
+    return 3;
+  }
+  return g () + h ();
+}
+
+int m (int i)
+{
+  static g ();  /* { dg-error "invalid storage class" } */
+  static g () { return i; } /* { dg-error "invalid storage class" } */
+  return g ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-2.c
new file mode 100644
index 000000000..7a52e807d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-2.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-funit-at-a-time" } */
+
+int f(int i)
+{
+  static int g(); /* { dg-error "invalid storage class" } */
+  static int g() { return i; } /* { dg-error "invalid storage class" } */
+  return g();
+}
+
+int k (int i)
+{
+  static int g (); /* { dg-error "invalid storage class" } */
+  int g () {
+	return i;
+  }
+
+  return g ();
+}
+
+int l (int i)
+{
+  auto int g ();
+  static int g () { /* { dg-error "invalid storage class" } */
+    return i;
+  }
+
+  static int h () { /* { dg-error "invalid storage class" } */
+    return 3;
+  }
+  return g () + h ();
+}
+
+int m (int i)
+{
+  static g ();  /* { dg-error "invalid storage class" } */
+  static g () { return i; } /* { dg-error "invalid storage class" } */
+  return g ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-3.c
new file mode 100644
index 000000000..74a6e63b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18596-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int foo ()
+{
+  static g () = 0; /* { dg-error "invalid storage class" } */
+  static int f () = 1; /* { dg-error "invalid storage class" } */
+  auto int h () = 0; /* { dg-error "initialized like a variable" } */
+  /* { dg-error "declared but never defined" "nested" { target *-*-* } 8 } */
+  static int i () = { 0 }; /* { dg-error "invalid storage class" } */
+  static int j () = /* { dg-error "invalid storage class" } */
+	{ 0, 0.0 };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18628.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18628.c
new file mode 100644
index 000000000..d365075b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18628.c
@@ -0,0 +1,31 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+/* PR middle-end/18628 exposed a problem in which cse folded a load
+   from a jump table into the label that was the target of the branch.
+   Unfortunately, the indirect jump was moved to a different basic
+   block, and the LABEL_REF copied to the register wasn't enough to
+   keep the cfg from optimizing the otherwise-unused label away.  So
+   we ended up with a dangling reference to the label.  */
+
+int i;
+
+int main()
+{
+  for (;;)
+  {
+    switch (i)
+    {
+      case 0:
+      case 1:
+        return 1;
+
+      case 2:
+      case 3:
+        return 0;
+
+      case 5:
+        --i;
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18725.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18725.c
new file mode 100644
index 000000000..0282d3b61
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18725.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (void)
+{
+   int x = 1;
+   asm ("" : "" (x), "" (x)); /* { dg-error "output operand constraint lacks" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18792.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18792.c
new file mode 100644
index 000000000..4e93fe145
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18792.c
@@ -0,0 +1,16 @@
+/* PR tree-optimization/18792 */
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-loop-linear" } */
+void put_atoms_in_triclinic_unitcell(float x[][3])
+{
+	int i=0,d;
+
+	while (x[i][3] < 0)
+		for (d=0; d<=3; d++)
+			x[i][d] = 0;
+
+	while (x[i][3] >= 0)
+		for (d=0; d<=3; d++)
+			x[i][d] = 0;
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18809-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18809-1.c
new file mode 100644
index 000000000..27f2be9ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18809-1.c
@@ -0,0 +1,10 @@
+/* PR c/18809 */
+/* Origin: Andrew Pinski <pinskia@gcc.gnu.org> */
+
+/* { dg-do compile } */
+
+void foo(enum E e) {}   /* { dg-error "forward ref" "forward" } */
+			/* { dg-warning "declared" "declared" { target *-*-* } 6 } */
+			/* { dg-warning "scope" "scope" { target *-*-* } 6 } */
+			/* { dg-error "incomplete" "incomplete" { target *-*-* } 6 } */
+void bar() { foo(0); }  /* { dg-error "formal" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18921-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18921-1.c
new file mode 100644
index 000000000..b8c91aa09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18921-1.c
@@ -0,0 +1,20 @@
+/* PR middle-end/18921 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+int foo (int k)
+{
+  unsigned char j = 0;
+  (k ? 0 : j++) == -1;
+  return j;
+}
+
+int main ()
+{
+  if (!foo (0))
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18928-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18928-1.c
new file mode 100644
index 000000000..406b2fcab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18928-1.c
@@ -0,0 +1,20 @@
+/* PR rtl-optimization/18928 */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fPIC" } */
+
+const char *toHex( unsigned short u )
+{
+  static char hexVal[5];
+  int i = 3;
+  while ( i >= 0 ) {
+    unsigned short hex = (u & 0x000f);
+    if ( hex < 0x0a )
+      hexVal[i] = '0'+hex;
+    else
+      hexVal[i] = 'A'+(hex-0x0a);
+    i--;
+  }
+  hexVal[4] = '\0';
+  return hexVal;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18963-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18963-1.c
new file mode 100644
index 000000000..df43c6543
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr18963-1.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "" } */
+
+static int barf ();
+
+int foo ()
+{ 
+  auto int barf ();
+  int j = 4;
+
+  int barf () {
+    return j;
+  }
+
+  return barf ();
+}
+
+static int barf () {
+  return 3;
+}
+
+extern void exit (int);
+extern void abort ();
+
+int main (int argc, char *argv[]) {
+  if (foo () != 4)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19340.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19340.c
new file mode 100644
index 000000000..844d80677
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19340.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fschedule-insns2 -fsched2-use-traces" } */
+/* { dg-skip-if "No scheduling" { mmix-*-* cris-*-* crisv32-*-* fido-*-* m68k-*-* m32c-*-* avr-*-* } { "*" } { "" } } */
+
+extern double f (double x);
+
+double g (int a)
+{
+  int b, c, d, e = 0;
+  double h;
+
+  for (d = 0; d < a; d++)
+    for (c = 0; c < a; c++)
+      b = 1;
+
+  h = (double) e / (double) a;
+
+  if (h)
+    {
+      h = 1.0 / h;
+      h = f (h);
+    }
+  else
+    h = 1.0;
+
+  return h;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19345.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19345.c
new file mode 100644
index 000000000..40c6de4d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19345.c
@@ -0,0 +1,12 @@
+/* We shouldn't crash trying to produce the inlined structure type die debug info.  */
+/* { dg-do compile } */
+/* { dg-options "-O1 -g" } */
+inline void bar(char a[], unsigned int l)
+{
+  asm volatile ("" :: "m" ( *(struct {char x[l]; } *)a));
+}
+
+void foo(void)
+{
+  bar (0, 0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19402-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19402-1.c
new file mode 100644
index 000000000..866ac63cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19402-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+float test_powif(float x)
+{
+  return __builtin_powif(x, -1)
+	 + __builtin_powif(x, 0)
+	 + __builtin_powif(x, 1)
+	 + __builtin_powif(x, 2);
+}
+
+double test_powi(double x)
+{
+  return __builtin_powi(x, -1)
+	 + __builtin_powi(x, 0)
+	 + __builtin_powi(x, 1)
+	 + __builtin_powi(x, 2);
+}
+
+long double test_powil(long double x)
+{
+  return __builtin_powil(x, -1)
+	 + __builtin_powil(x, 0)
+	 + __builtin_powil(x, 1)
+	 + __builtin_powil(x, 2);
+}
+
+/* { dg-final { scan-assembler-not "__builtin_" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19402-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19402-2.c
new file mode 100644
index 000000000..1902227a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19402-2.c
@@ -0,0 +1,82 @@
+/* { dg-do run } */
+/* { dg-options "-fno-inline -Os" } */
+
+void abort(void);
+
+
+float powif(float x, int n)
+{
+  return __builtin_powif(x, n);
+}
+
+double powi(double x, int n)
+{
+  return __builtin_powi(x, n);
+}
+
+long double powil(long double x, int n)
+{
+  return __builtin_powil(x, n);
+}
+
+
+float powcif(float x)
+{
+  return __builtin_powif(x, 5);
+}
+
+double powci(double x)
+{
+  return __builtin_powi(x, 5);
+}
+
+long double powcil(long double x)
+{
+  return __builtin_powil(x, 5);
+}
+
+
+float powicf(int n)
+{
+  return __builtin_powif(2.0, n);
+}
+
+double powic(int n)
+{
+  return __builtin_powi(2.0, n);
+}
+
+long double powicl(int n)
+{
+  return __builtin_powil(2.0, n);
+}
+
+
+int main()
+{
+  if (__builtin_powi(1.0, 5) != 1.0)
+    abort();
+  if (__builtin_powif(1.0, 5) != 1.0)
+    abort();
+  if (__builtin_powil(1.0, 5) != 1.0)
+    abort();
+  if (powci(1.0) != 1.0)
+    abort();
+  if (powcif(1.0) != 1.0)
+    abort();
+  if (powcil(1.0) != 1.0)
+    abort();
+  if (powi(1.0, -5) != 1.0)
+    abort();
+  if (powif(1.0, -5) != 1.0)
+    abort();
+  if (powil(1.0, -5) != 1.0)
+    abort();
+  if (powic(1) != 2.0)
+    abort();
+  if (powicf(1) != 2.0)
+    abort();
+  if (powicl(1) != 2.0)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19633-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19633-1.c
new file mode 100644
index 000000000..6370ff59b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19633-1.c
@@ -0,0 +1,70 @@
+/* { dg-do run } */
+
+/* The max-aliased-vops setting is a temporary workaround to avoid the
+   random failures as described in PR 30194.  This test case does not
+   need alias sets bigger than 13 elements.  */
+/* { dg-options "-O2 --param max-aliased-vops=15" } */
+
+extern void abort (void);
+
+struct S
+{
+  int w, x, y, z;
+};
+
+struct T
+{
+  int r;
+  struct S s;
+};
+
+struct S bar (struct S x, struct S *y)
+{
+  y->w = 4;
+  return *y;
+}
+
+void
+foo (int a, struct T b)
+{
+  struct S x;
+  struct S *c = &x;
+  if (a)
+    c = &b.s;
+  b.s.w = 3;
+  /* This call should be marked as clobbering 'x' and 'b'.  */
+  *c = bar (*c, c);
+  if (b.s.w == 3)
+    abort ();
+}
+
+float Y;
+
+struct S bar1 (struct S x, struct S y)
+{
+  Y = 4;
+  return x;
+}
+
+void
+foo1 (int a, struct T b)
+{
+  struct S x;
+  struct S *c = &x;
+  float z, *k = &z;
+  if (a)
+    c = &b.s;
+  b.s.w = 3;
+  /* This call should NOT be marked as clobbering 'x' and 'b'.  */
+  x = bar1 (*c, *c);
+  if (b.s.w != 3)
+    link_error ();
+}
+
+int main ()
+{
+  struct T b;
+  foo (3, b);
+  foo1 (3, b);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19633.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19633.c
new file mode 100644
index 000000000..fda0df6c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19633.c
@@ -0,0 +1,49 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+struct S
+{
+  int w, x, y, z;
+};
+
+struct T
+{
+  int r;
+  struct S s;
+};
+
+void
+foo (int a, struct T b)
+{
+  struct S *c = 0;
+
+  if (a)
+    c = &b.s;
+
+  b.s.w = 3;
+
+  /* Since 'c' may be pointing to NULL here, we used to flag it as
+     pointing anywhere, which was forcing the aliaser to mark as
+     call-clobbered every other variable pointed-to by 'c' ('b' in
+     this case).  This, in turn, caused the insertion of V_MAY_DEFs
+     for 'b' at this call-site, which prevented constant propagation
+     from 'b.s.w = 3' to 'if (b.s.w != 3)'.  */
+  bar (*c, a);
+
+  if (b.s.w != 3)
+    link_error ();
+}
+
+int main ()
+{
+  struct T b;
+  foo (3, b);
+  return 0;
+}
+
+int X;
+
+int bar (struct S x, int i)
+{
+  X = 3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19910.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19910.c
new file mode 100644
index 000000000..1ee0d213b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19910.c
@@ -0,0 +1,16 @@
+/* Contributed by Volker Reichelt <reichelt@gcc.gnu.org>.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int a[3];
+
+void foo()
+{
+  int i, j;
+
+  for (i = 1; i >= 0; --i)
+    for (j = i; j >= 0; --j)
+      a[i+j] = 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19967.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19967.c
new file mode 100644
index 000000000..85afeafe2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19967.c
@@ -0,0 +1,26 @@
+/* PR middle-end/19967
+   These functions mentioned below are supposed to return char *.
+   However, fold_builtin_... had bugs that caused the return types to
+   be const char *.  */
+
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+char *strchr(const char *, int);
+char *strrchr(const char *, int);
+char *index(const char *, int);
+char *rindex(const char *, int);
+char *strpbrk(const char *, const char *);
+char *strstr(const char *, const char *);
+char *p;
+
+void
+f (void)
+{
+  p = strchr(__func__, 'f');
+  p = strrchr(__func__, 'f');
+  p = index(__func__, 'f');
+  p = rindex(__func__, 'f');
+  p = strpbrk(__func__, "f");
+  p = strstr(__func__, "f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19984.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19984.c
new file mode 100644
index 000000000..1b61d7f76
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr19984.c
@@ -0,0 +1,17 @@
+/* PR c/19984 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=c99" } */
+
+
+double nan (const char *);
+
+const double nok = nan ("");	/* { dg-warning "(not constant)|(near initialization)" } */
+
+const double ok = __builtin_nan ("");
+
+double
+foo ()
+{
+  double ok2 = nan ("");
+  return ok2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20017.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20017.c
new file mode 100644
index 000000000..1fd6d586e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20017.c
@@ -0,0 +1,41 @@
+/* PR rtl-optimization/20017
+
+   After CSE/GCSE folds a switch statement to an unconditional jump,
+   cfg_cleanup did not remove a dead jump table, confusing the CFG
+   layout code later on.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+/* { dg-options "-O1 -march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+int
+foo (int *buf, int *p)
+{
+  int result;
+  const int *tmp;
+
+  if (*buf)
+    return 1;
+
+  result = 2;
+  *buf = 2;
+  tmp = buf;
+  switch (*tmp)
+    {
+    case 3:
+    case 4:
+    case 6:
+    case 14:
+      return 1;
+
+    case 0:
+      result = *p;
+
+      /* Fall through.  */
+    default:
+      if (result)
+	return 1;
+    }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20054.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20054.c
new file mode 100644
index 000000000..292b856d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20054.c
@@ -0,0 +1,23 @@
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-strict-aliasing" } */
+
+
+unsigned int *foo (void);
+
+char *
+bar (double *d)
+{
+  return (char *) (d + 1) - sizeof (unsigned int);
+}
+
+char
+baz (double x)
+{
+  unsigned int h = *foo ();
+  unsigned int l = *(unsigned int *) bar (&x);
+
+  return (h & ~0x80000000L) == 0x7FF00000 && l == 0;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20100.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20100.c
new file mode 100644
index 000000000..988fbda64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20100.c
@@ -0,0 +1,32 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int func_pure (void) __attribute__ ((pure));
+void func_other (int);
+int global_int;
+void abort ();
+void func_other(int a)
+{
+  if (a != global_int)
+   abort ();
+  global_int++;
+}
+
+int func_pure(void)
+{
+  return global_int;
+}
+
+int
+func_loop (int arg)
+{
+ // global_int ++;
+  while (arg--)
+      func_other (func_pure ());
+}
+
+int main(void)
+{
+  func_loop(10);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20115-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20115-1.c
new file mode 100644
index 000000000..60313cd53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20115-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dom1" } */
+
+extern int foo (void) __attribute__((pure));
+
+int bar()
+{
+  int a = foo ();
+  a += foo ();
+  return a;
+}
+
+/* Check that we only have one call to foo.  */
+/* { dg-final { scan-tree-dump-times "foo" 1 "dom1" } } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20115.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20115.c
new file mode 100644
index 000000000..cea4b4868
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20115.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int func_pure (void);
+void func_other (int);
+int global_int;
+int func_pure (void) { return global_int; }
+void func_other (int a)
+{
+  global_int = a + 1;
+}
+int f(void)
+{
+  int a;
+  a = func_pure();
+  func_other (a);
+  a = func_pure (); // We were removing this function call
+  return a;
+}
+void abort (void);
+
+int main(void)
+{
+  global_int = 10;
+  if (f() != 11)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20126.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20126.c
new file mode 100644
index 000000000..257832ab1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20126.c
@@ -0,0 +1,50 @@
+/* dg-do run */
+/* dg-options "-O2" */
+
+/* PR target/20126 was not really target-specific, but rather a loop's
+   failure to take into account the possibility that a DEST_ADDR giv
+   replacement might fail, such as when you attempt to replace a REG
+   with a PLUS in one of the register_operands of cmpstrqi_rex_1.  */
+
+extern void abort (void);
+
+typedef struct { int a; char b[3]; } S;
+S c = { 2, "aa" }, d = { 2, "aa" };
+
+void *
+bar (const void *x, int y, int z)
+{
+  return (void *) 0;
+}
+
+int
+foo (S *x, S *y)
+{
+  const char *e, *f, *g;
+  int h;
+
+  h = y->a;
+  f = y->b;
+  e = x->b;
+
+  if (h == 1)
+    return bar (e, *f, x->a) != 0;
+
+  g = e + x->a - h;
+  while (e <= g)
+    {
+      const char *t = e + 1;
+      if (__builtin_memcmp (e, f, h) == 0)
+        return 1;
+      e = t;
+    }
+  return 0;
+}
+
+int
+main (void)
+{
+  if (foo (&c, &d) != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20130-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20130-1.c
new file mode 100644
index 000000000..976372560
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20130-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+int z (int a) {
+	return a * -1;
+}
+
+int x (int a) {
+	return -1 * a;
+}
+
+int y (int a) {
+	return -(-1 * -a);
+}
+/* { dg-final { scan-tree-dump-times "-a" 3 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20216.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20216.c
new file mode 100644
index 000000000..1014ef3e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20216.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+static unsigned int *buffer;
+
+void FUNC (void)
+{
+ unsigned int *base;
+ int i, j;
+
+ for (i = 0; i < 4; i++)
+  for (j = 0; j < 1600000; j++)
+   *base++ = buffer[j];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20245-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20245-1.c
new file mode 100644
index 000000000..51089c6e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20245-1.c
@@ -0,0 +1,5 @@
+/* Bug 20245: the parse error should not result in an ICE.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void foo() x; /* { dg-error "expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-1.c
new file mode 100644
index 000000000..ac76c16f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-1.c
@@ -0,0 +1,12 @@
+/* ICE with -Wstrict-prototypes and typeof an undeclared function.
+   Bug 20368.  */
+/* { dg-do compile } */
+/* { dg-options "-Wstrict-prototypes" } */
+
+extern __typeof (f) g; /* { dg-error "'f' undeclared here \\(not in a function\\)" } */
+
+int
+f (x)
+     float x; /* { dg-warning "function declaration isn't a prototype" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-2.c
new file mode 100644
index 000000000..7faded6bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-2.c
@@ -0,0 +1,12 @@
+/* ICE with -Wstrict-prototypes and typeof an undeclared function.
+   Bug 20368.  Test with -Wmissing-prototypes.  */
+/* { dg-do compile } */
+/* { dg-options "-Wmissing-prototypes" } */
+
+extern __typeof (f) g; /* { dg-error "'f' undeclared here \\(not in a function\\)" } */
+
+int
+f (x) /* { dg-warning "no previous prototype for 'f'" } */
+     float x;
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-3.c
new file mode 100644
index 000000000..0d0ea6dfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20368-3.c
@@ -0,0 +1,12 @@
+/* ICE with -Wstrict-prototypes and typeof an undeclared function.
+   Bug 20368.  Test with -Wmissing-declarations.  */
+/* { dg-do compile } */
+/* { dg-options "-Wmissing-declarations" } */
+
+extern __typeof (f) g; /* { dg-error "'f' undeclared here \\(not in a function\\)" } */
+
+int
+f (x) /* { dg-warning "no previous declaration for 'f'" } */
+     float x;
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20672-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20672-1.c
new file mode 100644
index 000000000..e47fef3fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20672-1.c
@@ -0,0 +1,7 @@
+/* EOF must cause an error inside a function, not just set parser->error.
+   Bug 20672.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+int main(void)
+{
+int a; /* { dg-error "expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-1.c
new file mode 100644
index 000000000..cfa8a29ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-1.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-wrapv -fstrict-overflow -fdump-tree-gimple" } */
+int f(int i)
+{
+  return (i - 2) > i;
+}
+
+int g(int i)
+{
+  return (i + 2) < i;
+}
+
+int h(int i)
+{
+  return (i + (-2)) > i;
+}
+
+int j(int i)
+{
+  return (i - (-2)) < i;
+}
+
+int x(double i)
+{
+  return (i - 2.0) > i;
+}
+
+int y(double i)
+{
+  return (i + 2.0) < i;
+}
+
+int z(double i)
+{
+  return (i + (-2.0)) > i;
+}
+/* { dg-final { scan-tree-dump-times " = 0" 7 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-2.c
new file mode 100644
index 000000000..4bbebfd5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-fwrapv -fdump-tree-gimple" } */
+int f (int i)
+{
+  return (i - 2) > i;
+}
+
+int g (int i)
+{
+  return (i + 2) < i;
+}
+
+int h (double i)
+{
+  return (i + 2.0) <= i;
+}
+/* { dg-final { scan-tree-dump-times " = 0" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-3.c
new file mode 100644
index 000000000..84ecafef9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-3.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math -fno-wrapv -fstrict-overflow -fdump-tree-gimple" } */
+int f(int i)
+{
+  return (i - 2) <= i;
+}
+
+int g(int i)
+{
+  return (i + 2) >= i;
+}
+
+int h(int i)
+{
+  return (i + (-2)) <= i;
+}
+
+int x(double i)
+{
+  return (i - 2.0) <= i;
+}
+
+int y(double i)
+{
+  return (i + 2.0) >= i;
+}
+
+int z(double i)
+{
+  return (i + (-2.0)) <= i;
+}
+/* { dg-final { scan-tree-dump-times " = 1" 6 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-4.c
new file mode 100644
index 000000000..0240435fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-4.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-wrapv -fstrict-overflow -fdump-tree-gimple" } */
+int f(int i)
+{
+  return i < (i - 2);
+}
+
+int g(int i)
+{
+  return i > (i + 2);
+}
+
+int h(int i)
+{
+  return i < (i + (-2));
+}
+
+int j(int i)
+{
+  return i > (i - (-2));
+}
+
+int x(double i)
+{
+  return i < (i - 2.0);
+}
+
+int y(double i)
+{
+  return i > (i + 2.0);
+}
+
+int z(double i)
+{
+  return i < (i + (-2.0));
+}
+/* { dg-final { scan-tree-dump-times " = 0" 7 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-5.c
new file mode 100644
index 000000000..db94c7ba0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-5.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-fsignaling-nans -fwrapv -fdump-tree-gimple" } */
+int f(int i)
+{
+  return i < (i - 2);
+}
+
+int g(int i)
+{
+  return i > (i + 2);
+}
+
+int h (double i)
+{
+  return i >= i + 2.0;
+}
+
+int j (double i)
+{
+  return i > i + 2.0;
+}
+/* { dg-final { scan-tree-dump-times " = 0" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-6.c
new file mode 100644
index 000000000..65a8f1d56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr20922-6.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math -fno-wrapv -fstrict-overflow -fdump-tree-gimple" } */
+int f(int i)
+{
+  return i >= (i - 2);
+}
+
+int g(int i)
+{
+  return i <= (i + 2);
+}
+
+int h(int i)
+{
+  return i >= (i + (-2));
+}
+
+int x(double i)
+{
+  return i >= (i - 2.0);
+}
+
+int y(double i)
+{
+  return i <= (i + 2.0);
+}
+
+int z(double i)
+{
+  return i >= (i + (-2.0));
+}
+/* { dg-final { scan-tree-dump-times " = 1" 6 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21032.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21032.c
new file mode 100644
index 000000000..839a180ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21032.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized -frounding-math" } */
+
+void bar(float x);
+void foo(double x)
+{
+  bar(-x);
+}
+
+/* { dg-final { scan-tree-dump-not "-\\(float\\)" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21041.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21041.c
new file mode 100644
index 000000000..34ed14d1e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21041.c
@@ -0,0 +1,42 @@
+
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fPIC" } */
+
+struct args
+{
+  short int matrix[8][8];
+  char **current;
+};
+
+int test (struct args *args, char *init, int a, int b)
+{
+  int i, j, k;
+
+  if (!args || a > b || a < 0)
+    return -1;
+
+  for (i = 0; i < 2; i++)
+    {
+      char *dest = *args->current;
+      char *p = dest;
+
+      for (j = 0; j < 8; j++)
+        *p++ = *init++;
+
+      for (k = 0; k < 8; k++)
+        {
+          short int *blockvals = &args->matrix[k][0];
+          dest[0] += blockvals[0];
+          dest[1] += blockvals[1];
+          dest[2] += blockvals[2];
+          dest[3] += blockvals[3];
+          dest[4] += blockvals[4];
+          dest[5] += blockvals[5];
+          dest[6] += blockvals[6];
+          dest[7] += blockvals[7];
+       }
+    }
+
+  return 1;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21085.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21085.c
new file mode 100644
index 000000000..6a51adb90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21085.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* This used to cause excessive use, or a stack overflow, depending on which
+   came first.  */
+void foo (void)
+{
+  int maxstringlen = 1;
+  int limit = 0, maxblock = 0, maxblockrem = 0;
+  maxblockrem = (maxstringlen) % (2147483647 + 1); /* { dg-warning "overflow" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21282.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21282.c
new file mode 100644
index 000000000..427e39385
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21282.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+extern double floor (double);
+
+long foo (float f)
+{
+	  return (long) floor (f);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21419.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21419.c
new file mode 100644
index 000000000..dc8f602e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21419.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+const int i = 0;
+
+void f(void)
+{
+  __asm__ __volatile__ ("" : "=m" (i)); /* { dg-error "read-only variable" } */
+
+}
+
+void g(const int set)
+{
+  __asm__ __volatile__ ("" : "=r" (set)); /* { dg-error "read-only location" } */
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21709-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21709-1.c
new file mode 100644
index 000000000..0d6f20f32
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21709-1.c
@@ -0,0 +1,6 @@
+/* PR middle-end/21709 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+double _Complex f(void) { return 1.0iF / 0.0; }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21858.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21858.c
new file mode 100644
index 000000000..41cd240c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21858.c
@@ -0,0 +1,15 @@
+/* Fold used to create a GT_EXPR of pointer vs. integer types,
+   which caused us to ICE in VRP.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Os -w" } */
+
+unsigned int dsdblm_GetBlockAddress();
+void error_LocalAssert(void);
+int dsdblm_CreateBlock(unsigned int address)
+{
+   address = dsdblm_GetBlockAddress();
+   if (address >= (void*)0x00020000)
+     error_LocalAssert();
+   return address;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21921.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21921.c
new file mode 100644
index 000000000..d6a8a2a94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr21921.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -funsafe-math-optimizations" } */
+
+void
+Q (double *s, double h)
+{
+  int i;
+  if (h > 1)
+    h = h - 1;
+
+  for (i = 1; i < 3; i++)
+    if (s[i] / h > 0)
+      s[0] = h, s[i] = s[i] / h;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22231.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22231.c
new file mode 100644
index 000000000..210700684
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22231.c
@@ -0,0 +1,7 @@
+/* Test case for PR 22231.  -c and -MG are invalid together.  */
+
+/* { dg-do compile } */
+/* { dg-options "-MG -MD -c" } */
+/* { dg-error "may only be used with -M" "-MG incompatible with -c" { target *-*-* } 0 } */
+
+int anything;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22308-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22308-1.c
new file mode 100644
index 000000000..2b3067577
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22308-1.c
@@ -0,0 +1,13 @@
+/* Bug 22308: C_TYPE_FIELDS_READONLY not updated on type variants.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct foo s;
+volatile struct foo t;
+struct foo { const int z; };
+
+void
+bar (void)
+{
+  t = s; /* { dg-error "assignment of read-only variable 't'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22311-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22311-1.c
new file mode 100644
index 000000000..4eec5ce9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22311-1.c
@@ -0,0 +1,6 @@
+/* Bug 22311: ICE with -fshort-enums on shortened operations.  */
+/* { dg-do compile } */
+/* { dg-options "-fshort-enums" } */
+
+typedef enum { A = 1 } E;
+void f(E e, unsigned char c) { c |= e; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22329.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22329.c
new file mode 100644
index 000000000..94e32d695
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22329.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+int f(int i)
+{
+  int k = 0;
+  if (i == 0)
+    k = i == 0;
+  return k;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22335-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22335-1.c
new file mode 100644
index 000000000..a2a760bfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22335-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdelete-null-pointer-checks"  } */
+int t(int *a)
+{
+  int i;
+  *a = 1;
+  i = a == 0;
+  return i;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22335-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22335-2.c
new file mode 100644
index 000000000..afba95521
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22335-2.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O2"  } */
+void abort(void) __attribute__((__noreturn__));
+typedef struct {
+  int container;
+} edge_iterator;
+struct ls_expr
+{
+  int index;
+  int stores;
+  struct ls_expr * next;
+};
+struct ls_expr * pre_ldst_mems;
+edge_iterator ei;
+void
+store_motion (void)
+{
+  struct ls_expr * ptr, **prev_next_ptr_ptr;
+  edge_iterator ei1;
+  edge_iterator ei2;
+  int a = ptr != ((void *)0);
+  for (ptr = pre_ldst_mems, prev_next_ptr_ptr = &pre_ldst_mems;
+       ptr != ((void *)0);
+       ptr = *prev_next_ptr_ptr)
+    if (!((ptr)->stores))
+     *prev_next_ptr_ptr = ptr->next;
+    else
+      prev_next_ptr_ptr = &ptr->next;
+
+  for (ptr = pre_ldst_mems; ptr != 0; ptr = ptr->next)
+    ;
+  ei1 = ei;
+  ei2 = ei1;
+  if (!ei2.container)
+    abort ();
+  ei2 = ei1;
+  if (!ei2.container)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22356-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22356-1.c
new file mode 100644
index 000000000..118b0b2d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22356-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu99" } */
+typedef _Complex float GFC_COMPLEX_4;
+void product_c4 (GFC_COMPLEX_4 *src, GFC_COMPLEX_4 *dest, int len)
+{
+  int n;
+  GFC_COMPLEX_4 result;
+  for (n = 0; n < len; n++, src += 1)
+    result *= *src;
+  *dest = result;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22458-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22458-1.c
new file mode 100644
index 000000000..8b8032c41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr22458-1.c
@@ -0,0 +1,4 @@
+/* { dg-error "expected declaration or statement" "" { target *-*-* } 0 } */
+void foo()
+{
+     __PRETTY_FUNCTION__;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23049.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23049.c
new file mode 100644
index 000000000..e58cef8fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23049.c
@@ -0,0 +1,27 @@
+/* This was an ICE in fold where we tried to fold something like,
+
+     a = 0 == 0 ? 0 : 3988292384
+
+   after doing if-conversion for the vectorizer.  Folding "0 == 0"
+   should have been done before calling fold on the whole rhs of
+   the above expression.  */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target int32plus } */
+/* { dg-options "-O3 -ftree-vectorize" } */
+
+static unsigned short int crc_table[256];
+void AC3_encode_init(void)
+{
+  unsigned int c, n, k;
+  for(n=0;  n<256; n++)
+  {
+    c = n << 8;
+    for (k = 0; k < 8; k++)
+    {
+      if (c & (1 << 15))
+       c = ((c << 1) & 0xffff) ^ (((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16)) & 0xffff);
+    }
+    crc_table[n] = c;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23075.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23075.c
new file mode 100644
index 000000000..2d85fb065
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23075.c
@@ -0,0 +1,14 @@
+/* PR c/23075 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wreturn-type" } */
+
+int
+foo (void)
+{
+  return;	/* { dg-warning "with no value" } */
+}		/* { dg-bogus "control reaches end" } */
+
+int
+bar (void)
+{
+}		/* { dg-warning "control reaches end" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23165.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23165.c
new file mode 100644
index 000000000..49194a146
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23165.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-Wempty-body" } */
+void foo (void)
+{
+	if (0)
+	  a: ; /* { dg-warning "empty body in an" } */
+
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23295.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23295.c
new file mode 100644
index 000000000..0418964a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23295.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int foo(int i)
+{
+  return -i - 5;
+}
+
+/* { dg-final { scan-tree-dump "-5 - i" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23408.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23408.c
new file mode 100644
index 000000000..ca8193fba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23408.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* { dg-options "--param ggc-min-expand=0 --param ggc-min-heapsize=0" } */
+static __inline__ int f () { return g (); }
+int g () { return f (); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23470-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23470-1.c
new file mode 100644
index 000000000..2ddf6f2f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23470-1.c
@@ -0,0 +1,12 @@
+/* PR middle-end/23470 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -fdump-tree-original" } */
+
+int f(double a, double b)
+{
+  if (((a*a) + (b*b))<0)
+    link_error();
+}
+
+/* { dg-final { scan-tree-dump-times "if \\(0\\)" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23518.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23518.c
new file mode 100644
index 000000000..3c6bd2754
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23518.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/23518.
+   make_range used to transform a + 1 < 0 into a < -1 even when a is
+   signed and -fwrapv is given.  Make sure that no longer happens.  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -fwrapv" } */
+
+#include <limits.h>
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int a = INT_MAX;
+  if ((a < 0) || (a + 1 < 0))
+    exit (0);
+
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23547.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23547.c
new file mode 100644
index 000000000..210fae7ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23547.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "--param ggc-min-expand=0 --param ggc-min-heapsize=0" } */
+void foo()
+{
+  void bar()
+  {
+    bar();
+  }
+}
+
+void foo1(int i)
+{
+    void bar (char c[1][i]) { }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23584.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23584.c
new file mode 100644
index 000000000..691a11956
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23584.c
@@ -0,0 +1,21 @@
+/* Regression test for PR middle-end/23584 */
+/* Verify that dereferencing an absolute address inside of a function
+   makes that function impure.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-ipa-pure-const" } */
+
+int test1 (void)
+{
+  return * (volatile int *) 0x1234;
+}
+
+int test2 (void)
+{
+  int local = * (volatile int *) 0x1234;
+  return local;
+}
+
+/* { dg-final { scan-ipa-dump-not "found to be pure: test1" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be pure: test2" "pure-const" } } */
+/* { dg-final { cleanup-ipa-dump "pure-const" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23625.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23625.c
new file mode 100644
index 000000000..aaeddb288
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23625.c
@@ -0,0 +1,27 @@
+/* Test case for PR23625 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-loop-linear" } */
+
+typedef long INT32;
+void find_best_colors ()
+{
+int ic0, ic1, ic2;
+INT32 * bptr;
+INT32 dist1;
+INT32 dist2;
+INT32 xx1;
+for (ic0 = (1<<(5 -3))-1;ic0 >= 0;ic0--)
+{
+  for (ic1 = (1<<(6 -3))-1;ic1 >= 0;ic1--)
+  {
+    dist2 = dist1;
+     for (ic2 = (1<<(5 -3))-1;ic2 >= 0;ic2--)
+     {
+        *bptr = dist2;
+        bptr++;
+     }
+     dist1 += xx1;
+  }
+}
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23818.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23818.c
new file mode 100644
index 000000000..be0bb9a01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23818.c
@@ -0,0 +1,33 @@
+/* PR tree-optimization/23818 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fno-tree-dominator-opts" } */
+
+#include <stdarg.h>
+
+extern void abort (void);
+
+void
+foo (int p[100], int k, ...)
+{
+  int j, *q;
+  va_list ap;
+
+  va_start (ap, k);
+  q = va_arg (ap, int *);
+  for (j = 0; j < 100; j++)
+    q[j] = p[j] + 10;
+  va_end(ap);
+}
+
+int
+main (void)
+{
+  int buf[100], buf2[100], i;
+  for (i = 0; i < 100; i++)
+    buf[i] = i + 1;
+  foo (buf, 0, buf2);
+  for (i = 0; i < 100; i++)
+    if (buf2[i] != buf[i] + 10)
+      abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23911.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23911.c
new file mode 100644
index 000000000..b77dbaab9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr23911.c
@@ -0,0 +1,21 @@
+/* This was a missed optimization in tree constant propagation
+   that CSE would catch later on.  */
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-dce2" } */
+
+double _Complex *a; 
+static const double _Complex b[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ 
+void 
+test (void) 
+{ 
+  a[0] = b[0] + b[1]; 
+  a[1] = b[0] + b[1]; 
+  return; 
+} 
+
+/* After DCE2 which runs after FRE, the expressions should be fully
+   constant folded.  There should be no loads from b left.  */
+/* { dg-final { scan-tree-dump-times "__complex__ \\\(1.0e\\\+0, 0.0\\\)" 2 "dce2" } } */
+/* { dg-final { scan-tree-dump-times "= b" 0 "dce2" } } */
+/* { dg-final { cleanup-tree-dump "dce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24101-1.i b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24101-1.i
new file mode 100644
index 000000000..45c165539
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24101-1.i
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* { dg-options "-ansi" } */
+
+# 1 "/usr/local/lib/gcc/i686-pc-linux-gnu/4.1.0/include/stddef.h" 1 3 4
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24101-2.i b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24101-2.i
new file mode 100644
index 000000000..501382da4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24101-2.i
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* { dg-options "-ansi" } */
+
+#
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24225.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24225.c
new file mode 100644
index 000000000..af33710cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24225.c
@@ -0,0 +1,17 @@
+/* This was an ICE caused by the compiler-generated stack save/restore
+   statements around s[b].  */
+/* { dg-do compile} */
+/* { dg-options "-O1 -fprofile-arcs" } */
+
+int
+foo (int a, int b)
+{
+  if (a)
+    return 1;
+  {
+    int s [b];
+    return 0;
+  }
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24367.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24367.c
new file mode 100644
index 000000000..648671909
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24367.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fPIC -funroll-loops" } */
+
+char *
+test (const char *parent, const char *child)
+{
+  static char rtn_path[1024];
+  char *s = rtn_path;
+  char *s_end = rtn_path + sizeof (rtn_path);
+  const char *s2 = child;
+
+  while (*s != '\0')
+    s++;
+  while ((s < s_end) && (*s2 != '\0'))
+    *s++ = *s2++;
+  return (rtn_path);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24445.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24445.c
new file mode 100644
index 000000000..f34784ced
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24445.c
@@ -0,0 +1,9 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O1 -fpic" } */
+extern int *bar (void) __attribute__ ((__pure__));
+extern char *baz;
+void
+foo (void)
+{
+  baz = (char *) bar ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24561.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24561.c
new file mode 100644
index 000000000..20ac00e0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24561.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O0" } */
+/* { dg-final { scan-assembler "debug_hook" } } */
+static int debug_hook()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24600.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24600.c
new file mode 100644
index 000000000..62bb7cad6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24600.c
@@ -0,0 +1,16 @@
+/* This used to ICE on s390 due to a old-loop bug.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+char *strcpy (char *dest, const char *src);
+
+void test (char *Line, int len)
+{
+  int z;
+
+  for (z = 1; z <= len; z++)
+    if (Line[z - 1])
+      strcpy (Line + z + 1, Line);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24615.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24615.c
new file mode 100644
index 000000000..9e4291175
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24615.c
@@ -0,0 +1,27 @@
+
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-Os -fPIC" } */
+
+void *memset (void *, int, __SIZE_TYPE__);
+void *memcpy (void *, const void *, __SIZE_TYPE__);
+
+char *alloc (int);
+
+char *
+test (int type, int size, char *data, int len)
+{
+  char *block = alloc (size);
+  char *bp = block;
+
+  *bp++ = type;
+  switch (type)
+    {
+    case 0:
+    case 1:
+      memset (bp, type == 0 ? 0x00 : 0xff, size);
+      memcpy (bp, data, len);
+    }
+
+  return block;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24620.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24620.c
new file mode 100644
index 000000000..926a524d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24620.c
@@ -0,0 +1,27 @@
+/* This used to ICE due to a backend problem on s390.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+struct rgba
+{
+  unsigned char r;
+  unsigned char g;
+  unsigned char b;
+  unsigned char a;
+};
+
+void g (struct rgba);
+
+void f (void) 
+{
+  struct rgba x;
+
+  x.r = 0;
+  x.g = 128;
+  x.b = 128;
+  x.a = 26;
+
+  g (x);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24683.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24683.c
new file mode 100644
index 000000000..79d321006
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24683.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fPIC" } */
+int *block;
+void final(unsigned int j)
+{
+  unsigned int i;
+  unsigned char *data = (unsigned char *)"\0";
+  for (i = 0; i < 8; i++)
+    for (; j + 63 < 1; j += 64)
+      block = (int *) &data[j];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24820.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24820.c
new file mode 100644
index 000000000..0482ca321
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr24820.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double floor (double);
+double bar (double sum)
+{
+  int i;
+  for (i = 0; i < 256; i++)
+   sum += floor (0.5 + (i - 128));
+  return sum;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25023.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25023.c
new file mode 100644
index 000000000..b8cb7cf0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25023.c
@@ -0,0 +1,12 @@
+/* PR debug/25023 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=i686" { target { { i?86-*-* || x86_64-*-* } && ilp32 } } } */
+
+extern unsigned char v;
+
+float
+foo (void)
+{
+  return v;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25376.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25376.c
new file mode 100644
index 000000000..3008b091d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25376.c
@@ -0,0 +1,9 @@
+/* PR25376.  Verify that a named section is honored.  */
+/* { dg-require-named-sections "" } */
+
+void simple (void) __attribute__((section("my_named_section")));
+void simple (void)
+{
+}
+
+/* { dg-final { scan-assembler "my_named_section" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25559.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25559.c
new file mode 100644
index 000000000..7879a1558
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25559.c
@@ -0,0 +1,10 @@
+/* PR c/25559 */
+/* { dg-do compile } */
+
+#define vs(n) __attribute__((vector_size (n)))
+int vs (-1) a;			/* { dg-warning "attribute ignored" } */
+int vs (0) b;			/* { dg-error "zero vector size" } */
+int vs (1) c;			/* { dg-error "multiple of component size" } */
+int vs (sizeof (int) / 2) d;	/* { dg-error "multiple of component size" } */
+int vs (sizeof (int)) e;
+int vs (sizeof (int) * 2) f;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25682.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25682.c
new file mode 100644
index 000000000..4118862a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25682.c
@@ -0,0 +1,28 @@
+/* PR c/25682 */
+/* { dg-do compile } */
+/* { dg-options "-ansi" } */
+/* Test whether we don't ICE on questionable constructs where offsetof
+   should have been used instead.  */
+
+struct S
+{
+  char a[4];
+  int b;
+};
+
+char c[(char *) &((struct S *) 0)->b - (char *) 0];
+char d[(__SIZE_TYPE__) &((struct S *) 8)->b];
+char e[sizeof (c) == __builtin_offsetof (struct S, b) ? 1 : -1];
+char f[sizeof (d) == __builtin_offsetof (struct S, b) + 8 ? 1 : -1];
+
+extern void bar (char *, char *);
+
+void
+foo (void)
+{
+  char g[(char *) &((struct S *) 0)->b - (char *) 0];
+  char h[(__SIZE_TYPE__) &((struct S *) 8)->b];
+  char i[sizeof (g) == __builtin_offsetof (struct S, b) ? 1 : -1];
+  char j[sizeof (h) == __builtin_offsetof (struct S, b) + 8 ? 1 : -1];
+  bar (g, h);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25795-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25795-1.c
new file mode 100644
index 000000000..e568b2544
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25795-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fwhole-program" } */
+/* { dg-final { scan-assembler-not "mystr" } } */
+
+
+extern const char *mystr;       /* normally in a header */
+const char *mystr;
+main()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25795.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25795.c
new file mode 100644
index 000000000..decbe54e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25795.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fwhole-program" } */
+/* { dg-final { scan-assembler "mystr" } } */
+
+
+extern const char *mystr;       /* normally in a header */
+const char *mystr __attribute__ ((externally_visible));
+main()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25805.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25805.c
new file mode 100644
index 000000000..71182c52f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr25805.c
@@ -0,0 +1,20 @@
+/* When -fzero-initialized-in-bss was in effect, we used to only allocate
+   storage for d1.a.  */
+/* { dg-do run } */
+/* { dg-options "" } */
+extern void abort (void);
+extern void exit (int);
+
+struct { int a; int x[]; } d1 = { 0, 0 };
+int d2 = 0;
+
+int
+main ()
+{
+  d2 = 1;
+  if (sizeof (d1) != sizeof (int))
+    abort ();
+  if (d1.x[0] != 0)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26004.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26004.c
new file mode 100644
index 000000000..35e6a2feb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26004.c
@@ -0,0 +1,11 @@
+/* PR c/26004 */
+/* Bug: the return slot optimization was taking the address of s_3,
+   causing an error. */
+
+struct s_3 { short s[3]; } z_3, s_3;
+struct s_3 add_struct_3 (struct s_3 s){}
+wack_struct_3 (void)
+{
+  int i; register struct s_3 u = z_3;
+  u = add_struct_3 (u);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26427.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26427.c
new file mode 100644
index 000000000..3077221c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26427.c
@@ -0,0 +1,24 @@
+/* { dg-warning "this target does not support" } */
+/* { dg-do run { target { *-*-darwin* } } } */
+/* { dg-options { -fsection-anchors -O } } */
+/* PR target/26427 */
+
+struct a {};
+static const int d = 1;
+static const struct a b = {};
+static const int c = 1;
+int f(const int *, const struct a *, const int*, const int*);
+
+int g(void) {
+  return f(&c, &b, &d, &c);
+}
+
+int f(const int *b, const struct a *c, const int *d, const int *e) {
+  return *b == *d;
+}
+
+int main(void) {
+  if (!g())
+    __builtin_abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26632.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26632.c
new file mode 100644
index 000000000..1cc843ebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26632.c
@@ -0,0 +1,14 @@
+/* PR middle-end/26632
+   We used to issue a warning for an implicit cast whose result is not
+   used.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+int g (void);
+long h (void);
+
+void
+f (void)
+{
+  0 ? h () : g (); /* { dg-bogus "value computed is not used" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26717.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26717.c
new file mode 100644
index 000000000..d16b576ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26717.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math" } */
+_Complex float f (_Complex float a)
+{
+  _Complex float b = a / a;
+  return b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26719.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26719.c
new file mode 100644
index 000000000..3c87df17b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26719.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort (void);
+
+int table[32][256];
+
+int main(void)
+{
+  int i, j;
+
+  for (i = 0; i < 32; i++)
+    for (j = 0; j < 256; j++)
+      table[i][j] = ((signed char)j) * i;
+
+  if (table[9][132] != -1116)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26729-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26729-1.c
new file mode 100644
index 000000000..2f55ef7f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26729-1.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort(void);
+
+__attribute__((noinline))
+int f (unsigned short word) {  
+  return (word & 0x1) && (((unsigned short) (word & 0x8000)) == 0x8000);
+}
+
+int main(void) {
+  if (!f(0x8001))
+    abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26865.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26865.c
new file mode 100644
index 000000000..d9f1fe0d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26865.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=c99" } */
+
+void
+foo (void)
+{
+  char *e = alloca (100); /* { dg-warning "implicit declaration|initialization makes" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26961-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26961-1.c
new file mode 100644
index 000000000..56907d89d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26961-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+long long foo(int i, int j)
+{
+  return i ? (long long)(!j) : 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26983.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26983.c
new file mode 100644
index 000000000..5e2120a1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr26983.c
@@ -0,0 +1,19 @@
+/* { dg-do link } */
+
+/* This used to cause a linker failure because GCC would output
+   assembler code referencing labels that it had not output.  */
+
+void *jmpbuf[6];
+
+void
+foo (void)
+{
+  __builtin_setjmp (jmpbuf);
+}
+
+int
+main (void)
+{
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27003.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27003.c
new file mode 100644
index 000000000..5e416f4c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27003.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-Os" } */
+
+unsigned int
+foo (unsigned int x)
+{
+  unsigned int r = x;
+  while (--x)
+    r *= x;
+  return r;
+}
+
+unsigned long long
+bar (unsigned long long x)
+{
+  unsigned long long r = x;
+  while (--x)
+    r *= x;
+  return r;
+}
+
+extern void abort (void);
+
+int
+main (void)
+{
+  if (foo (5) != 120 || bar (5) != 120)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27095.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27095.c
new file mode 100644
index 000000000..d274f4e84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27095.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern void *memset (void *, int, __SIZE_TYPE__);
+extern __SIZE_TYPE__ strlen (const char *);
+
+int
+main (int argc, char **argv)
+{
+  char x[8] = "abc";
+  memset (x, argc, strlen (x));
+  return 0;
+}
+/* { dg-final { scan-assembler-not "(?n)strlen\(.*\n\)+.*strlen" { target { ! { powerpc*-*-darwin* hppa*-*-hpux* ia64-*-hpux* alpha*-*-* spu-*-* } } } } } */
+/* hppa*-*-hpux* has an IMPORT statement for strlen (plus the branch). */
+/* *-*-darwin* has something similar. */
+/* { dg-final { scan-assembler-not "(?n)strlen\(.*\n\)+.*strlen\(.*\n\)+.*strlen" { target hppa*-*-hpux* } } } */
+/* { dg-final { scan-assembler-not "(?n)bl L_strlen\(.*\n\)+.*bl L_strlen" { target powerpc*-*-darwin* } } } */
+/* ia64-*-hpux* has a global statement, a type statement, and the branch. */
+/* { dg-final { scan-assembler-not "(?n)strlen\(.*\n\)+.*strlen\(.*\n\)+.*strlen\(.*\n\)+.*strlen" { target ia64-*-hpux* } } } */
+/* alpha-*-* has a GOT load and the call.  */
+/* { dg-final { scan-assembler-not "(?n)jsr .*,strlen\(.*\n\)+.*jsr .*,strlen" { target alpha*-*-* } } } */
+/* spu-*-* has a branch hint and the call.  */
+/* { dg-final { scan-assembler-not "(?n)brsl.*,strlen\(.*\n\)+.*brsl.*,strlen" { target spu-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27132.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27132.c
new file mode 100644
index 000000000..272862a2d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27132.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int foo(int i)
+{
+  return i - -1;
+}
+
+/* { dg-final { scan-tree-dump "i \\+ 1" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27150-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27150-1.c
new file mode 100644
index 000000000..03810cd7e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27150-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+int g(int f)
+{
+  return (&f)!=0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27301.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27301.c
new file mode 100644
index 000000000..3b5a8f55b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27301.c
@@ -0,0 +1,15 @@
+/* PR c/27301 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu89" } */
+
+void
+foo (void *ptr, long n)
+{
+  __asm__ __volatile__ ("" :: "m" (({ struct { char x[n]; } *p = ptr; *p; })));
+}
+
+void
+bar (void *ptr, long n)
+{
+  __asm__ __volatile__ ("" :: "m" (*({ struct { char x[n]; } *p = ptr; p; })));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27314.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27314.c
new file mode 100644
index 000000000..d99be5eb8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27314.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ffast-math" } */
+
+extern double floor (double);
+
+inline int bar (double x)
+{
+  return (int) floor (x);
+}
+
+int foo (int i)
+{
+  return bar (i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27331.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27331.c
new file mode 100644
index 000000000..9b5c71e84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27331.c
@@ -0,0 +1,56 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+struct funny_match
+{
+  int this, other;
+};
+
+typedef struct rtx {
+    int code;
+} *rtx;
+
+extern rtx recog_operand[];
+extern int which_alternative;
+extern int nalternatives;
+
+int
+constrain_operands (insn_code_num, strict)
+     int insn_code_num;
+     int strict;
+{
+  char *constraints[10];
+  struct funny_match funny_match[10];
+  register int c;
+  int funny_match_index;
+
+  which_alternative = 0;
+
+  while (which_alternative < nalternatives)
+    {
+      register int opno;
+      register char *p = constraints[opno];
+      int lose = 0;
+      funny_match_index = 0;
+
+      while (*p && (c = *p++) != ',')
+	funny_match[funny_match_index++].other = c - '0';
+
+      if ((((recog_operand[opno])->code) == 12))
+	lose = 1;
+
+      if (!lose)
+	{
+	  while (--funny_match_index >= 0)
+	    recog_operand[funny_match[funny_match_index].other]
+		    = recog_operand[funny_match[funny_match_index].this];
+	  return 1;
+	}
+      which_alternative++;
+    }
+
+  if (strict == 0)
+    return constrain_operands (insn_code_num, -1);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27335.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27335.c
new file mode 100644
index 000000000..d08db30bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27335.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -funroll-loops" } */
+
+extern void bar () __attribute__ ((noreturn));
+
+inline double
+baz (double *x, unsigned int y)
+{
+  if (y >= 6)
+    bar ();
+  return x[y];
+}
+
+double *a, *b;
+
+void
+foo ()
+{
+  unsigned int r, s, t;
+
+  for (r = 0; r < 2; r++)
+    for (t = 0; t < 2; t++)
+      {
+        for (s = 0; s < 3; s++)
+          b[r * 2 + t] += baz (a, 3 * s + t);
+      }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27363.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27363.c
new file mode 100644
index 000000000..40a3c6b35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27363.c
@@ -0,0 +1,39 @@
+/* PR27363.  CSE was breaking on the arm store multiple insn used for
+   structure copies.  */
+/* { dg-do run } */
+/* { dg-options "-Os" } */
+extern void abort (void);
+
+struct snd_mask {
+    unsigned int bits[6];
+};
+
+static int __attribute__((noinline))
+snd_mask_refine(struct snd_mask *mask)
+{
+  struct snd_mask old;
+
+  old = *mask;
+  if (mask->bits[0]==0 && mask->bits[1]==0)
+    return 1;
+
+  return old.bits[0] != mask->bits[0];
+}
+
+int main(int argc, char *argv[])
+{
+  struct snd_mask mask;
+
+
+  mask.bits[0] = 23;
+  mask.bits[1] = 42;
+  mask.bits[2] = 0;
+  mask.bits[3] = 0;
+  mask.bits[4] = 0; 
+  mask.bits[5] = 0;
+
+
+  if (snd_mask_refine(&mask))
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27382-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27382-1.c
new file mode 100644
index 000000000..0b25a7b38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27382-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+void foo()
+{
+    L:
+    !&&L;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27382-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27382-2.c
new file mode 100644
index 000000000..97365247e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27382-2.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+void foo()
+{
+    L:
+    &&L != 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27428-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27428-1.c
new file mode 100644
index 000000000..93a221c84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27428-1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void foo()
+{
+    goto L;
+    if (0..) { L: ; }  // { dg-error "too many decimal points" }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27528.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27528.c
new file mode 100644
index 000000000..4f33a31cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27528.c
@@ -0,0 +1,18 @@
+/* Check the warnings and errors generated for asm operands that aren't
+   obviously constant but that are constrained to be constants.  */
+/* { dg-options "" } */
+/* { dg-error "impossible constraint" "" { target *-*-* } 13 } */
+/* { dg-error "impossible constraint" "" { target *-*-* } 14 } */
+/* { dg-error "impossible constraint" "" { target *-*-* } 15 } */
+/* { dg-error "impossible constraint" "" { target *-*-* } 16 } */
+int bar (int);
+void
+foo (int *x, int y)
+{
+  int constant = 0;
+  asm ("# %0" :: "i" (x)); /* { dg-warning "probably doesn't match" } */
+  asm ("# %0" :: "i" (bar (*x))); /* { dg-warning "probably doesn't match" } */
+  asm ("# %0" :: "i" (*x + 0x11)); /* { dg-warning "probably doesn't match" } */
+  asm ("# %0" :: "i" (constant)); /* { dg-warning "probably doesn't match" } */
+  asm ("# %0" :: "i" (y * 0)); /* folded */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27531-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27531-1.c
new file mode 100644
index 000000000..08e3f5ea2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27531-1.c
@@ -0,0 +1,114 @@
+/* PR target/27531 */
+/* This test case stressed the register allocator into reloading a LABEL_REF
+   on sparc, but didn't add a REG_LABEL note, ultimately causing the assembly
+   output to reference a label that had been eliminated.  */
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+typedef struct _IO_FILE FILE;
+char const *RCSname;
+void *Locks;
+void * Head;
+struct Revpairs{
+    struct Revpairs * rnext;
+};
+extern char *strchr(const char *s, int c);
+extern int fprintf(FILE *, const char *format, ...);
+static void getrevpairs (char*);
+static int branchflag;
+static struct Revpairs *revlist, *Revlst;
+
+extern int warn(const char *msg, char *argv);
+extern int error(const char *msg, int c, char *argv);
+extern int recentdate(void *foo, void *bar);
+
+char *t;
+int main (int argc, char **argv)
+{
+    FILE *out;
+    char *a, **newargv;
+    void *currdate;
+    int descflag, selectflag;
+    int onlylockflag;
+    int onlyRCSflag;
+    int shownames;
+    descflag = selectflag = shownames = 1;
+    onlylockflag = onlyRCSflag = 0;
+    while (a = *++argv, 0<--argc)
+    {
+        switch (*a++)
+        {
+            case 'L':
+                onlylockflag = 1;
+            case 'N':
+                shownames = 0;
+            case 'R':
+                t = a;
+            case 'b':
+                branchflag = 1;
+            case 'r':
+                getrevpairs(a);
+        }
+        if (onlylockflag && !Locks)
+            fprintf(out, "%s\n", RCSname);
+        if (shownames) 
+            while( currdate)
+                recentdate(Head, currdate);
+    }
+}
+void getrevpairs(char *argv)
+{
+    char c;
+    struct Revpairs * nextrevpair;
+    int separator;
+    if (strchr(argv,':'))
+        separator = ':';
+    else
+    {
+        if (strchr(argv,'-') )
+            warn("`-' is obsolete in `-r%s'; use `:' instead", argv);
+        separator = '-';
+    }
+    for (;;)
+    {
+        nextrevpair->rnext = revlist;
+        for (;; c = *++argv)
+        {
+            switch (c)
+            {
+                default:
+                    continue;
+                case ' ':
+                case '\t':
+                case '\n':
+                    break;
+                case ':':
+                case '-':
+                    if (c == separator)
+                        continue;
+            }
+            break;
+        }
+        if (!c)
+            break;
+        error("missing `,' near `%c%s'", c, argv+1);
+    }
+}
+
+int warn(const char *msg, char *argv)
+{
+  t = 0;  /* this function needs side-effects.  */
+  return 0;
+}
+
+int error(const char *msg, int c, char *argv)
+{
+  t = 0; /* this function needs side-effects.  */
+  return 0;
+}
+
+int recentdate(void *foo, void *bar)
+{
+  t = 0; /* this function needs side-effects.  */
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27639.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27639.c
new file mode 100644
index 000000000..cb7b1429d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27639.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=c99" } */
+#if(__SIZEOF_INT__ >= 4)
+char heap[50000];
+#else
+char heap[32000];
+#endif
+int
+main ()
+{
+  for (unsigned ix = sizeof (heap); ix--;)
+    heap[ix] = ix;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27671-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27671-2.c
new file mode 100644
index 000000000..78820427b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27671-2.c
@@ -0,0 +1,24 @@
+/* PR rtl-optimization/27671.
+   The combiner used to simplify "a ^ b == a" to "a" via
+   simplify_relational_operation_1 in simplify-rtx.c.  */
+/* { dg-do run } */
+/* { dg-options "-O1" } */
+/* { dg-options "-O1 -march=pentium4" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern void abort (void) __attribute__ ((noreturn));
+extern void exit (int) __attribute__ ((noreturn));
+
+static void __attribute__ ((noinline))
+bar (int k)
+{
+  int n = k % 2;
+  if (n == 0)
+    abort ();
+}
+
+int
+main (void)
+{  
+  bar (1);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27758.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27758.c
new file mode 100644
index 000000000..d385fc5c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27758.c
@@ -0,0 +1,24 @@
+/* PR target/27758 */
+/* { dg-do run { target fpic } } */
+/* { dg-options "-O0 -fpic" } */
+
+typedef int (*fn) (void);
+
+static inline int
+foo (void)
+{
+  return 1;
+}
+   
+fn
+test (void)
+{
+  return foo;
+}
+
+int
+main (void)
+{
+  fn f = test ();
+  return f () != 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27802-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27802-1.c
new file mode 100644
index 000000000..839459ac0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27802-1.c
@@ -0,0 +1,16 @@
+/* Noreturn functions returning FP types used to confuse reg-stack on x86.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+double bar1() __attribute__((noreturn));
+void foo1() { bar1(); }
+
+double bar2() __attribute__((noreturn));
+double foo2() { return bar2(); }
+
+void bar3() __attribute__((noreturn));
+double foo3() { bar3(); }
+
+double bar4() __attribute__((noreturn));
+double foo4() { bar4(); }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27861-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27861-1.c
new file mode 100644
index 000000000..cf269dc0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27861-1.c
@@ -0,0 +1,67 @@
+/* PR target/27861 */
+/* The following code used to cause an ICE during RTL expansion, as
+   expand shift was stripping the SUBREG of a rotate shift count, and
+   later producing a VAR_DECL tree whose DECL_RTL's mode didn't match
+   the VAR_DECL's type's mode.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef struct sim_state *SIM_DESC;
+typedef enum
+{
+  SIM_OPEN_STANDALONE, SIM_OPEN_DEBUG
+}
+SIM_RC;
+typedef unsigned int unsigned32 __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int unsigned64 __attribute__ ((__mode__ (__DI__)));
+typedef unsigned32 unsigned_address;
+typedef unsigned_address address_word;
+static __inline__ unsigned64
+  __attribute__ ((__unused__)) ROTR64 (unsigned64 val, int shift)
+{
+  unsigned64 result;
+  result = (((val) >> (shift)) | ((val) << ((64) - (shift))));
+  return result;
+}
+typedef struct _sim_cpu sim_cpu;
+enum
+{
+    TRACE_MEMORY_IDX, TRACE_MODEL_IDX, TRACE_ALU_IDX, TRACE_CORE_IDX,
+};
+typedef struct _trace_data
+{
+  char trace_flags[32];
+}
+TRACE_DATA;
+typedef enum
+{
+    nr_watchpoint_types,
+}
+watchpoint_type;
+typedef struct _sim_watchpoints
+{
+  TRACE_DATA trace_data;
+}
+sim_cpu_base;
+struct _sim_cpu
+{
+  sim_cpu_base base;
+};
+struct sim_state
+{
+  sim_cpu cpu[1];
+};
+typedef address_word instruction_address;
+do_dror (SIM_DESC sd, instruction_address cia, int MY_INDEX, unsigned64 x,
+	 unsigned64 y)
+{
+  unsigned64 result;
+  result = ROTR64 (x, y);
+    {
+      if ((((-1) & (1 << (TRACE_ALU_IDX))) != 0
+	   && (((&(((&(sd)->cpu[0])))->base.trace_data))->
+	       trace_flags)[TRACE_ALU_IDX] != 0))
+	trace_result_word1 (sd, ((&(sd)->cpu[0])), TRACE_ALU_IDX, (result));
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27898.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27898.c
new file mode 100644
index 000000000..bb7cce175
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27898.c
@@ -0,0 +1,8 @@
+/* PR c/27898 */
+/* { dg-do compile } */
+/* { dg-options "--combine" } */
+/* { dg-additional-sources "pr27898.c" } */
+
+union u { struct { int i; }; };
+
+extern int foo (union u *);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27953.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27953.c
new file mode 100644
index 000000000..245b59e0b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27953.c
@@ -0,0 +1,8 @@
+/* PR c/27953 */
+
+void foo(struct A a) {}  /* { dg-warning "declared inside parameter list" } */
+/* { dg-warning "its scope is only" "" { target *-*-* } 3 } */
+/* { dg-error "incomplete type" "" { target *-*-* } 3 } */
+
+void foo() {}            /* { dg-error "redefinition" } */
+/* { dg-message "note: previous definition" "" { target *-*-* } 3 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27959-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27959-2.c
new file mode 100644
index 000000000..65894756b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27959-2.c
@@ -0,0 +1,94 @@
+/* PR middle-end/27959 */
+/* { dg-do run { target { stdint_types } } } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=z990" { target s390*-*-* } } */
+
+#include <stdint.h>
+extern void abort (void);
+
+struct B
+{
+  unsigned int b1, b2, b3;
+  char b4;
+};
+
+struct C
+{
+  char c1;
+};
+
+struct D
+{
+  char *d1;
+  struct C **d2;
+  unsigned int d3;
+};
+
+void
+__attribute__((noinline))
+foo (void *x, struct B *y, unsigned int *z)
+{
+  if (x)
+    abort ();
+  if (y->b1 != 7 || y->b2 != 5 || y->b3 != 3 || y->b4)
+    abort ();
+  if (*z != 2)
+    abort ();
+}
+
+int
+__attribute__((noinline))
+baz (unsigned int *x, unsigned int y)
+{
+  asm volatile ("" : : "r" (&x), "r" (&y) : "memory");
+  return *x + y;
+}
+
+inline int bar (unsigned int *x, unsigned int y)
+{
+  if (y < *x)
+    return 0;
+  return baz (x, y);
+}
+
+unsigned int *
+__attribute__((noinline))
+test (struct D *x, unsigned int *y)
+{
+  struct B b;
+  uint32_t c;
+
+  bar (y, x->d3);
+  if ((*(x->d2))->c1)
+    c = ((uint32_t) x->d1[0]
+	 + ((uint32_t) x->d1[1] << 8)
+	 + ((uint32_t) x->d1[2] << 16)
+	 + ((uint32_t) x->d1[3] << 24));
+  else
+    {
+      int32_t d;
+      ((char *) &d)[0] = x->d1[0];
+      ((char *) &d)[1] = x->d1[1];
+      ((char *) &d)[2] = x->d1[2];
+      ((char *) &d)[3] = x->d1[3];
+      c = d;
+    }
+  b.b4 = 0;
+  b.b1 = c / 10000L % 10000;
+  b.b2 = c / 100 % 100;
+  b.b3 = c % 100;
+  foo (0, &b, y);
+  return y;
+}
+
+int
+main (void)
+{
+  uint32_t x = 900070503;
+  unsigned int y = 2;
+  struct C c = { 0 }, *cptr = &c;
+  struct D d = { (char *) &x, &cptr, 0 };
+  if (test (&d, &y) != &y)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27959.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27959.c
new file mode 100644
index 000000000..f1fdda1b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr27959.c
@@ -0,0 +1,93 @@
+/* PR middle-end/27959 */
+/* { dg-do run { target { int32plus } } } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=z990" { target s390*-*-* } } */
+
+extern void abort (void);
+
+struct B
+{
+  unsigned int b1, b2, b3;
+  char b4;
+};
+
+struct C
+{
+  char c1;
+};
+
+struct D
+{
+  char *d1;
+  struct C **d2;
+  unsigned int d3;
+};
+
+void
+__attribute__((noinline))
+foo (void *x, struct B *y, unsigned int *z)
+{
+  if (x)
+    abort ();
+  if (y->b1 != 7 || y->b2 != 5 || y->b3 != 3 || y->b4)
+    abort ();
+  if (*z != 2)
+    abort ();
+}
+
+int
+__attribute__((noinline))
+baz (unsigned int *x, unsigned int y)
+{
+  asm volatile ("" : : "r" (&x), "r" (&y) : "memory");
+  return *x + y;
+}
+
+inline int bar (unsigned int *x, unsigned int y)
+{
+  if (y < *x)
+    return 0;
+  return baz (x, y);
+}
+
+unsigned int *
+__attribute__((noinline))
+test (struct D *x, unsigned int *y)
+{
+  struct B b;
+  unsigned int c;
+
+  bar (y, x->d3);
+  if ((*(x->d2))->c1)
+    c = ((unsigned char) x->d1[0]
+	 + ((unsigned char) x->d1[1] << 8)
+	 + ((unsigned char) x->d1[2] << 16)
+	 + ((short) x->d1[3] << 24));
+  else
+    {
+      int d;
+      ((char *) &d)[0] = x->d1[0];
+      ((char *) &d)[1] = x->d1[1];
+      ((char *) &d)[2] = x->d1[2];
+      ((char *) &d)[3] = x->d1[3];
+      c = d;
+    }
+  b.b4 = 0;
+  b.b1 = c / 10000L % 10000;
+  b.b2 = c / 100 % 100;
+  b.b3 = c % 100;
+  foo (0, &b, y);
+  return y;
+}
+
+int
+main (void)
+{
+  unsigned int x = 900070503;
+  unsigned int y = 2;
+  struct C c = { 0 }, *cptr = &c;
+  struct D d = { (char *) &x, &cptr, 0 };
+  if (test (&d, &y) != &y)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28121.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28121.c
new file mode 100644
index 000000000..5cbf8f89e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28121.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+short
+GetCmd ()
+{
+  int c, c1;
+  for (c = 255; c == 255;)
+    {
+      c = GetMouseButton ();
+      if (c >= 0)
+	{
+	  c = ParsePos (c, -1, 0);
+	  c1 = ParsePos (c1, c, 1);
+	  if (c == c1 && (c >= 0 || c == -10))
+	    {
+	      return c;
+	    }
+	  if (c >= 0 && c1 == -12)
+	    {
+	      return ((((((10) + 1) + 1)) + 1) << 7) | c;
+	    }
+	  c = 255;
+	}
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28162.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28162.c
new file mode 100644
index 000000000..8bd28ad24
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28162.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+void Lag_max_wght(float corr[], long wght_flg)
+{
+     float t0, max;
+     const float *ww;
+     long i;
+     if ( wght_flg > 0 ) {
+        for ( i = 143; i >= 20; i-- ) {
+           t0 = corr[ - i] * *ww--;
+           if ( t0 >= max )
+             max = t0;
+        }
+     }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28187.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28187.c
new file mode 100644
index 000000000..bc3b62d33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28187.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-vrp -fwrapv" } */
+
+extern void bar(int);
+void checkgroups(int last, int verbose) 
+{
+    int window = 0;
+    int outstanding = 0;
+    while (window < last || outstanding) {
+	while (outstanding < 47 && window < last) {
+	    if (window < last) { 
+		outstanding++; 
+		if (verbose)
+		    bar(window);
+		bar(window++);
+	    }
+	}
+	if (outstanding > 0)
+	    bar(0);
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28243.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28243.c
new file mode 100644
index 000000000..12447a1c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28243.c
@@ -0,0 +1,53 @@
+/* PR rtl-optimization/28243 */
+/* Reported by Mike Frysinger <vapier@gentoo.org> */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O2 -ftracer -fPIC" } */
+/* { dg-skip-if "requires unsupported run-time relocation" { spu-*-* } { "*" } { "" } } */
+
+struct displayfuncs {
+  void (*init) ();
+} funcs;
+
+struct gpsdisplay {
+  struct displayfuncs *funcs;
+};
+
+static void PSMyArc(double cx, double cy, double radx, double rady, double sa,
+		    double ta)
+{
+  double ea;
+  double temp;
+  ea = sa + ta;
+  while (sa < ea) {
+    temp = ((sa + 90) / 90) * 90;
+    PSDoArc(cx, sa, ea < temp ? ea : temp);
+    sa = temp;
+  }
+}
+
+static void PSDrawElipse()
+{
+  float cx;
+  float cy;
+  float radx;
+  float rady;
+  if (radx != rady)
+    PSMyArc(cx, cy, radx, rady, 0, 360);
+}
+
+static void PSDrawFillCircle()
+{
+  PSDrawElipse();
+}
+
+static struct displayfuncs psfuncs[] = {
+  PSDrawFillCircle
+};
+
+void _GPSDraw_CreateDisplay()
+{
+  struct gpsdisplay *gdisp;
+  gdisp->funcs = (void *)&psfuncs;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322-2.c
new file mode 100644
index 000000000..89dd15390
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322-2.c
@@ -0,0 +1,12 @@
+/* PR28322: ignore unknown -Wno-* if no warning is emitted.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wextra -Wno-foobar" } */
+
+int foo (void) 
+{
+  int i = 1/0;  /* { dg-warning "division by zero" } */
+  return i;
+}
+
+/* { dg-warning "unrecognized command line option .-Wno-foobar." "" { target *-*-* } 0 } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322-3.c
new file mode 100644
index 000000000..7a5a4c579
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322-3.c
@@ -0,0 +1,10 @@
+/* PR28322: ignore unknown -Wno-* if no warning is emitted.  */
+/* { dg-do compile } */
+/* { dg-options " -fno-foobar -mno-foobar" } */
+
+void foo(void)
+{
+  int i =  1;
+}
+/* { dg-message "unrecognized command line option .-fno-foobar." "" { target *-*-* } 0 } */
+/* { dg-message "unrecognized command line option .-mno-foobar." "" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322.c
new file mode 100644
index 000000000..99872fca8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28322.c
@@ -0,0 +1,8 @@
+/* PR28322: ignore unknown -Wno-* if no warning is emitted.  */
+/* { dg-do compile } */
+/* { dg-options " -Wno-foobar -Wno-div-by-zero" } */
+
+void foo(void)
+{
+  int i =  1/0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28402.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28402.c
new file mode 100644
index 000000000..1368ac723
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28402.c
@@ -0,0 +1,22 @@
+/* { dg-options "" } */
+typedef long long ll;
+typedef unsigned long long ull;
+
+int global;
+
+#define A(BASE, OP, AMT) \
+  ll BASE ## AMT (ll x) { return x OP AMT; } \
+  ull BASE ## AMT ## u (ull x) { return x OP AMT; }
+
+#define B(BASE, OP) \
+  A (BASE, OP, 1) \
+  A (BASE, OP, 10) \
+  A (BASE, OP, 31) \
+  A (BASE, OP, 33) \
+  A (BASE, OP, 61) \
+  A (BASE, OP, global)
+
+B (left, <<)
+B (right, >>)
+
+/* { dg-final { scan-assembler-not "__\[a-z\]*si3" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28419.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28419.c
new file mode 100644
index 000000000..a1aa4bfe8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28419.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+void foo() 
+const char* p = __FUNCTION__; /* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28574.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28574.c
new file mode 100644
index 000000000..f5ff6c01d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28574.c
@@ -0,0 +1,74 @@
+/* On IA64 This test resulted in a missing jumptable and an undefined
+   reference    to a label.  Make sure we can compile and link it with
+   no undefs at -O2.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+typedef enum yasm_module_type {
+    YASM_MODULE_ARCH = 0,
+    YASM_MODULE_DBGFMT,
+    YASM_MODULE_OBJFMT,
+    YASM_MODULE_LISTFMT,
+    YASM_MODULE_OPTIMIZER
+} yasm_module_type;
+
+struct yasm_module {
+    const char *name;
+};
+
+typedef struct yasm_module yasm_arch_module;
+typedef struct yasm_module yasm_dbgfmt_module;
+typedef struct yasm_module yasm_objfmt_module;
+typedef struct yasm_module yasm_listfmt_module;
+typedef struct yasm_module yasm_optimizer_module;
+
+typedef struct module {
+    void *data;
+} module;
+
+static struct {
+    module *m;
+    int n;
+} module_types[] = {
+ {},
+};
+
+void
+yasm_list_modules(yasm_module_type type,
+                  void (*printfunc) (const char *name))
+{
+    int i;
+    module *modules = module_types[type].m;
+    yasm_arch_module *arch;
+    yasm_dbgfmt_module *dbgfmt;
+    yasm_objfmt_module *objfmt;
+    yasm_listfmt_module *listfmt;
+    yasm_optimizer_module *optimizer;
+
+    for (i=0; i<2; i++) {
+        switch (type) {
+            case YASM_MODULE_ARCH:
+                arch = modules[i].data;
+                printfunc(arch->name);
+                break;
+            case YASM_MODULE_DBGFMT:
+                dbgfmt = modules[i].data;
+                printfunc(dbgfmt->name);
+                break;
+            case YASM_MODULE_OBJFMT:
+                objfmt = modules[i].data;
+                printfunc(objfmt->name);
+                break;
+            case YASM_MODULE_LISTFMT:
+                listfmt = modules[i].data;
+                printfunc(listfmt->name);
+                break;
+            case YASM_MODULE_OPTIMIZER:
+                optimizer = modules[i].data;
+                printfunc(optimizer->name);
+        }
+    }
+}
+
+main() {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28706.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28706.c
new file mode 100644
index 000000000..4c185af41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28706.c
@@ -0,0 +1,12 @@
+/* PR c/28706 */
+/* { dg-do compile } */
+/* { dg-options "--combine" } */
+/* { dg-additional-sources "pr28706.c" } */
+
+struct A
+{
+  int i;
+} __attribute__((aligned (sizeof (long int))));
+
+extern void foo (struct A *);
+extern void foo (struct A *);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28712.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28712.c
new file mode 100644
index 000000000..0bbb45314
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28712.c
@@ -0,0 +1,16 @@
+/* PR c/28712 */
+/* { dg-do compile } */
+/* { dg-options "--combine" } */
+/* { dg-additional-sources "pr28712.c pr28712.c" } */
+
+struct A;
+
+extern struct A *a;
+
+struct A { } __attribute__((packed));
+
+struct B __attribute__((aligned (sizeof (int))));
+
+extern struct B *b;
+
+struct B { int i; } __attribute__((packed));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28726.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28726.c
new file mode 100644
index 000000000..11232ac86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28726.c
@@ -0,0 +1,29 @@
+/* PR rtl-optimization/28726 */
+/* Origin: Sigurd Schneider <sg313d@gmail.com> */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -fsched2-use-superblocks" } */
+
+extern void abort (void);
+
+static double my_loop(void) __attribute__((noinline));
+
+static double my_loop(void)
+{
+  double retval = 0.0;
+  const unsigned char *start = "\005\b\000";
+  const unsigned char *const end = start + 2;
+
+  while (start < end)
+    retval += *start++;
+
+  return retval;
+}
+
+int main(void)
+{
+  if (my_loop() != 13.0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28755.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28755.c
new file mode 100644
index 000000000..9cd1330d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28755.c
@@ -0,0 +1,23 @@
+/* PR middle-end/28755 */
+/* { dg-do compile } */
+/* { dg-require-effective-target ptr32plus } */
+/* { dg-options "-Os" } */
+/* { dg-final { scan-assembler-times "2112543726\|7deadbee" 2 } } */
+
+struct S
+{
+  void *s1;
+  unsigned s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14;
+};
+
+const struct S array[] = {
+  { (void *) 0, 60, 640, 2112543726, 39682, 48, 16, 33, 10, 96, 2, 0, 0, 4 },
+  { (void *) 0, 60, 2112543726, 192, 18251, 16, 33, 10, 96, 2, 0, 0, 4, 212 }
+};
+
+void
+foo (struct S *x)
+{
+  x[0] = array[0];
+  x[5] = array[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28796-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28796-1.c
new file mode 100644
index 000000000..077118a29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28796-1.c
@@ -0,0 +1,62 @@
+/* { dg-do link } */
+/* { dg-options "-ffinite-math-only" } */
+
+extern void link_error(void);
+
+float f;
+double d;
+long double ld;
+
+int main()
+{
+  if (__builtin_isunordered (f, f) != 0)
+    link_error ();
+  if (__builtin_isunordered (d, d) != 0)
+    link_error ();
+  if (__builtin_isunordered (ld, ld) != 0)
+    link_error ();
+
+  if (__builtin_isnan (f) != 0)
+    link_error ();
+  if (__builtin_isnan (d) != 0)
+    link_error ();
+  if (__builtin_isnan (ld) != 0)
+    link_error ();
+  if (__builtin_isnanf (f) != 0)
+    link_error ();
+  if (__builtin_isnanl (ld) != 0)
+    link_error ();
+
+  if (__builtin_finite (f) != 1)
+    link_error ();
+  if (__builtin_finite (d) != 1)
+    link_error ();
+  if (__builtin_finite (ld) != 1)
+    link_error ();
+  if (__builtin_finitef (f) != 1)
+    link_error ();
+  if (__builtin_finitel (ld) != 1)
+    link_error ();
+
+  if (__builtin_isinf (f) != 0)
+    link_error ();
+  if (__builtin_isinf (d) != 0)
+    link_error ();
+  if (__builtin_isinf (ld) != 0)
+    link_error ();
+
+  if (__builtin_isfinite (f) != 1)
+    link_error ();
+  if (__builtin_isfinite (d) != 1)
+    link_error ();
+  if (__builtin_isfinite (ld) != 1)
+    link_error ();
+
+  if (f != f)
+    link_error ();
+  if (d != d)
+    link_error ();
+  if (ld != ld)
+    link_error ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28796-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28796-2.c
new file mode 100644
index 000000000..17fd1584d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28796-2.c
@@ -0,0 +1,11 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -funsafe-math-optimizations -fno-finite-math-only -DUNSAFE" } */
+/* { dg-options "-mieee -O2 -funsafe-math-optimizations -fno-finite-math-only -DUNSAFE" { target alpha*-*-* } } */
+/* { dg-skip-if "No Inf/NaN support" { spu-*-* } } */
+
+#include "tg-tests.h"
+
+int main(void)
+{
+  return main_tests ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28888.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28888.c
new file mode 100644
index 000000000..c65a26a08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28888.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+static const unsigned char _c30[] =
+  "statistic of allocated integer registers:";
+Allocate__WriteStats (void)
+{
+  register int i0, i1, i2, i3, i4, i5;
+l0:i1 = (int) (i5 << 2);
+  if (i0)
+  i4 = i5;
+l1:i2 += i1;
+  if (i1)
+  goto l0;
+l3:i0 = i1 == 255;
+  i1++;
+  Out__LongInt ((int) i0, (int) 0);
+  i0 = i4 >= i1;
+  if (i0)
+    goto l3;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28911.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28911.c
new file mode 100644
index 000000000..e1748f0fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28911.c
@@ -0,0 +1,13 @@
+/* PR target/28911
+   The following used to cause crash on m68k-elf because 0x80000000
+   was used as an SImode constant.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -m68000" { target m68k-*-* } } */
+
+_Complex float
+foo (float a)
+{
+  return __builtin_copysign (a != a, a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28935.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28935.c
new file mode 100644
index 000000000..9a0e70ecf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr28935.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -ftree-vectorize" } */
+
+int col[8];
+int extend_options(int w, int h, int *map, int x, int y, int index)
+{
+  int dx, dy;
+  for (dx = -1; dx <= +1; dx++)
+    {
+      int index = (dy < 0 ? 6-dx : dy > 0 ? 2+dx : 2*(1+dx));
+      if (x+dx >= 0 && x+dx < w && y+dy >= 0 && y+dy < h)
+        col[index] = map[(y+dy)*w+(x+dx)];
+      col[index] = -1;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29091.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29091.c
new file mode 100644
index 000000000..6e06c63da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29091.c
@@ -0,0 +1,44 @@
+/* PR c/29091 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+__attribute__ ((vector_size (sizeof (int) * 4))) int a = { 1, 2 };
+int d = 3;
+__attribute__ ((vector_size (sizeof (int) * 4))) int b = { 4, 5, 6 };
+int e = 7;
+__attribute__ ((vector_size (sizeof (int) * 4))) int c = { };
+
+int
+main (void)
+{
+  int *p = (int *) &a;
+  if (p[0] != 1)
+    abort ();
+  if (p[1] != 2)
+    abort ();
+  if (p[2] != 0)
+    abort ();
+  if (p[3] != 0)
+    abort ();
+  p = (int *) &b;
+  if (p[0] != 4)
+    abort ();
+  if (p[1] != 5)
+    abort ();
+  if (p[2] != 6)
+    abort ();
+  if (p[3] != 0)
+    abort ();
+  p = (int *) &c;
+  if (p[0] != 0)
+    abort ();
+  if (p[1] != 0)
+    abort ();
+  if (p[2] != 0)
+    abort ();
+  if (p[3] != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29215.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29215.c
new file mode 100644
index 000000000..aa3f82ce0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29215.c
@@ -0,0 +1,33 @@
+/* PR middle-end/29215 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+char buf[5 * sizeof (int) + 1] __attribute__((aligned (__alignof__ (int))));
+
+static void
+foo (int arg1, int arg2, int arg3, int arg4, int arg5)
+{
+  __builtin_memcpy (buf, &arg1, sizeof (int));
+  __builtin_memcpy (buf + sizeof (int), &arg2, sizeof (int));
+  __builtin_memcpy (buf + 2 * sizeof (int), &arg3, sizeof (int));
+  __builtin_memcpy (buf + 3 * sizeof (int), &arg4, sizeof (int));
+  __builtin_memcpy (buf + 4 * sizeof (int), &arg5, sizeof (int));
+}
+
+int
+main (void)
+{
+  union { char buf[4]; int i; } u;
+  u.i = 0;
+  u.buf[0] = 'a';
+  u.buf[1] = 'b';
+  u.buf[2] = 'c';
+  u.buf[3] = 'd';
+  foo (u.i, u.i, u.i, u.i, u.i);
+  buf[5 * sizeof (int)] = '\0';
+  __builtin_puts (buf);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-not "memcpy" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29254.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29254.c
new file mode 100644
index 000000000..598b6bf7b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29254.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -Werror" } */
+
+list_compare (int * list1)
+{
+  if (list1)
+    value_compare ();
+}
+
+func1 (int * f){}
+
+value_compare (int * a)
+{
+    if (a)
+        list_compare (a);
+}
+
+func2 (const int * fb)
+{
+  func1 ((int *) fb); /* { dg-bogus "discards qualifiers" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29299.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29299.c
new file mode 100644
index 000000000..9049060fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29299.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+static int bof __attribute__((used));
+int foo()
+{
+	static int barbarbarbar __attribute__((used));
+};
+
+/* { dg-final { scan-assembler "barbarbarbar" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29330.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29330.c
new file mode 100644
index 000000000..dff420779
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29330.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/29330 */
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-loop-linear -std=gnu99" } */
+
+int buf[2][2][2][2];
+
+void
+f (void)
+{
+  for (int a = 0; a < 2; ++a)
+    for (int b = 0; b < 2; ++b)
+      for (int c = 0; c < 2; ++c)
+	for (int d = 0; d < 2; ++d)
+	  buf[a][b][c][d] = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29521-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29521-2.c
new file mode 100644
index 000000000..734652c90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29521-2.c
@@ -0,0 +1,15 @@
+/* PR 29521 : warning for return with expression in function returning void */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+void func (void) { }
+
+void func2 (void)
+{
+  return func (); /* { dg-error "ISO C forbids 'return' with expression" } */
+}
+
+void func3 (void)
+{
+  return 1; /* { dg-error "'return' with a value" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29521.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29521.c
new file mode 100644
index 000000000..b6fb535fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29521.c
@@ -0,0 +1,15 @@
+/* PR 29521 : warning for return with expression in function returning void */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void func (void) { }
+
+void func2 (void)
+{
+  return func ();
+}
+
+void func3 (void)
+{
+  return 1;  /* { dg-warning "'return' with a value" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-1.c
new file mode 100644
index 000000000..e54007355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-1.c
@@ -0,0 +1,44 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-85.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+	  k = i + N;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < N; j++)
+    if (a[j] != i + N - 1)
+      abort();	
+
+  for (j = 0; j < N; j++)
+    if (b[j] != j + N)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  main1 (a);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-2.c
new file mode 100644
index 000000000..c99d78ce2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-2.c
@@ -0,0 +1,46 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-86.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n)
+{
+  int i, j, k;
+  int a[N], b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (i = 0; i < n; i++)
+    if (b[i] != i + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  main1 (N);
+  main1 (0);
+  main1 (1);
+  main1 (2);
+  main1 (N-1);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-3.c
new file mode 100644
index 000000000..c9d72ce28
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-3.c
@@ -0,0 +1,48 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-87.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  main1 (N, a);
+  main1 (0, a);
+  main1 (1, a);
+  main1 (2, a);
+  main1 (N-1, a);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-4.c
new file mode 100644
index 000000000..c2d894c8d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29581-4.c
@@ -0,0 +1,48 @@
+/* PR tree-optimization/29581 */
+/* Origin: gcc.dg/vect/vect-88.c */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void abort (void);
+
+#define N 16
+
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+	{
+	  k = i + n;
+	  a[j] = k;
+	}
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N+1] __attribute__ ((__aligned__(16)));
+
+  main1 (N, a+1);
+  main1 (0, a+1);
+  main1 (1, a+1);
+  main1 (2, a+1);
+  main1 (N-1, a+1);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29637.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29637.c
new file mode 100644
index 000000000..5dfee41b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29637.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/29637 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+typedef struct __attribute__ ((aligned (8)))
+{
+    short a, b, c, d;
+} A;
+
+typedef struct
+{
+  A a[24];
+} B;
+
+static const A b = { 0, 0, 1, -1 };
+
+void
+foo (B *x)
+{
+  int i;
+  for (i = 0; i <= 20; i += 4)
+    x->a[i] = b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29683.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29683.c
new file mode 100644
index 000000000..4bed679b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29683.c
@@ -0,0 +1,43 @@
+/* { dg-do run } */
+/* { dg-options "-Os -fno-inline-functions" } */
+
+void abort (void);
+
+typedef struct {
+  int x[7];
+} agg7;
+
+typedef struct {
+  int mbr1;
+  int mbr2;
+} agg2;
+
+int expected = 31415;
+agg7 filler;
+
+int GetConst (agg7 filler, agg2 split)
+{
+  return expected;
+}
+
+void VerifyValues (agg7 filler, int last_reg, int first_stack, int second_stack)
+{
+  if (first_stack != 123 || second_stack != expected)
+    abort ();
+}
+
+void RunTest (agg2 a)
+{
+  int result;
+	
+  result = GetConst (filler, a);
+  VerifyValues (filler, 0, a.mbr1, result);
+}
+
+int main(void)
+{
+  agg2 result = {123, 456};
+  RunTest (result);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29736.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29736.c
new file mode 100644
index 000000000..54eb9aaaa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29736.c
@@ -0,0 +1,13 @@
+/* PR c/29736 */
+
+int __attribute__ ((vector_size (8), vector_size (8))) v; /* { dg-error "invalid vector type" } */
+
+extern int __attribute__ ((vector_size (8))) w;
+int __attribute__ ((vector_size (8))) w;
+
+void
+foo ()
+{
+  v = v + v;
+  w = w + w;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29801.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29801.c
new file mode 100644
index 000000000..b61ae5142
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29801.c
@@ -0,0 +1,24 @@
+/* We used to crash in ccp here, because the initial constant value of 2
+   was changed to 5.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+static const int a = 2;
+
+int test (int param)
+{
+  int *p = (int *) &a;
+
+  if (param)
+    *p = 5;
+
+  return a;
+}
+
+/* Check that we return the correct (unchanged) value.  */
+
+/* { dg-final { scan-tree-dump-times "return 2" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "return 5" 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29921-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29921-2.c
new file mode 100644
index 000000000..8cf665eed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29921-2.c
@@ -0,0 +1,27 @@
+/* With -ffast-math, the latice value for sum2 used to change from NaN to
+   VARYING, in turn causing the lattice value of sum1 * sum2 change from
+   NaN to 0 (since sum1 is believed to be 0 at that moment, and
+   0 * VARYING = 0 with -ffast-math), which caused an ICE.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+int
+foo (float *array, int end)
+{
+  int i;
+  float sum1, sum2;
+
+  sum2 = 0;
+  for (i = 0; i < end; i++)
+    sum2 = sum2+array[i];
+  sum2 = 1./sum2;
+  sum1 = 0.;
+  for (i = 0; i < end; i++)
+    sum1 = sum1+array[i];
+  sum1 = sum1 * sum2;
+  if (-10.0 / sum1 < 5.E-5)
+    end = 0;
+  return end;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29921.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29921.c
new file mode 100644
index 000000000..7689f54ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr29921.c
@@ -0,0 +1,20 @@
+/* With -ffast-math, the latice value for t changes from -0.0 to 0.0 in this
+   testcase.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double test (int param)
+{
+  double a = 0.0, b = -1.0, t;
+  int i;
+
+  for (i = 0; i < 100; i++)
+    {
+      t = a * b;
+      if (param)
+	b = 2.0;
+    }
+
+  return t;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30045.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30045.c
new file mode 100644
index 000000000..6dd22a1df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30045.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-inline" }  */
+int f(int *a)
+{
+  int  __attribute__((nonnull(1))) g(int *b)
+  {
+    int **c = &a;
+    if (b)
+      return *a + **c;
+    return *b;
+  }
+  if (a)
+    return g(a);
+  return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30137-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30137-1.c
new file mode 100644
index 000000000..cf1b40634
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30137-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-w -fdump-tree-gimple" } */
+
+/* Things that should not be folded.  */
+
+struct { long base; int tail; void * volatile ptr; } *s;
+int foo3 (void) { return s == &s; }
+int foo5 (void) { return s->ptr == s->ptr; }
+
+struct { union { int i; short s } u; } x;
+int foo6 (void) { return x.u.i == x.u.s; }
+
+void **p;
+int foo8 (void) { return p == &p; }
+int foo9 (void) { return *p == p; }
+int foo10 (void) { return *p == &p; }
+int foo11 (void) { return p != &p; }
+int foo12 (void) { return *p != p; }
+int foo13 (void) { return *p != &p; }
+
+/* { dg-final { scan-tree-dump-not "= 0;" "gimple" } } */
+/* { dg-final { scan-tree-dump-not "= 1;" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30137-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30137-2.c
new file mode 100644
index 000000000..53be1633b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30137-2.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-w -fdump-tree-gimple" } */
+
+/* Things that should be folded.  */
+
+struct { long base; int tail; void * volatile ptr; } *s;
+int foo1a (void) { return (s == &s->base); }
+int foo1b (void) { return (&s->base == s); }
+int foo2 (void) { return ((void *)s == (void *) &s->base); }
+int foo4 (void) { return s->base == s->base; }
+int foo5 (void) { return &s->ptr == &s->ptr; }
+int foo6 (void) { return &s->ptr != &s->ptr; }
+int foo7 (void) { return &s->base != &s->ptr; }
+
+struct { union { int i; short s } u; } x;
+int foo8 (void) { return &x.u.i == &x.u.s; }
+
+/* { dg-final { scan-tree-dump-times "= 0" 1 "gimple" } } */
+/* { dg-final { scan-tree-dump-times "= 1" 7 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30172-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30172-1.c
new file mode 100644
index 000000000..2388a091c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30172-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-signed-zeros -ffinite-math-only -fdump-tree-gimple" } */
+
+_Complex double test1 (double x) { return x + 1.i; }
+_Complex double test2 (double x) { return 1 + x * 1.i; }
+_Complex double test3 (double x, double y) { return x + y * 1.i; }
+_Complex double test4 (double x, double y) { return (x + y * 1.i) * 1.i; }
+_Complex double test5 (double x, double y) { return (x + y * 1.i) * -1.i; }
+
+/* { dg-final { scan-tree-dump "COMPLEX_EXPR <x, 1.0e\\+0>" "gimple" } } */
+/* { dg-final { scan-tree-dump "COMPLEX_EXPR <1.0e\\+0, x>" "gimple" } } */
+/* { dg-final { scan-tree-dump "COMPLEX_EXPR <x, y>" "gimple" } } */
+/* { dg-final { scan-tree-dump "D.* = -y;\n.*COMPLEX_EXPR <D.*, x>" "gimple" } } */
+/* { dg-final { scan-tree-dump "D.* = -x;\n.*COMPLEX_EXPR <y, D.*>" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30189.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30189.c
new file mode 100644
index 000000000..6aa963e7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30189.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-g -O" } */
+
+extern void foo (void);
+
+static
+void baz (int i)
+{
+  foo ();
+  typedef char A[i];
+  struct { A b; } *x = 0;
+}
+
+void
+bar (i)
+{
+  baz (i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30260.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30260.c
new file mode 100644
index 000000000..f7373176e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30260.c
@@ -0,0 +1,32 @@
+/* PR 30260  */
+/* { dg-do link } */
+/* { dg-options "-pedantic -O" } */
+#include <limits.h>
+
+enum A {
+  A1 = 0, 
+  A2 = A1 - 1
+};
+enum B {
+  B1 = 0u, 
+  B2 = B1 - 1 /* { dg-bogus "ISO C restricts enumerator values to range of 'int'" } */
+};
+int main(void)
+{
+  enum A a = -1;
+  enum B b = -1;
+
+  if (!(a < 0))
+    link_error ();
+  if (!(A2 < 0))
+    link_error ();
+  if (!(b < 0))
+    link_error ();
+  if (!(B2 < 0))
+    link_error ();
+
+  return 0;
+}
+
+enum E1 { e10 = INT_MAX, e11 }; /* { dg-error "overflow in enumeration values" } */
+enum E2 { e20 = (unsigned) INT_MAX, e21 }; /* { dg-error "overflow in enumeration values" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30286.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30286.c
new file mode 100644
index 000000000..9ec49b423
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30286.c
@@ -0,0 +1,37 @@
+/* PR middle-end/30286 */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftrapv" } */
+
+extern void abort (void);
+struct S { struct S *s; };
+struct T { struct S *t[25]; };
+
+void
+__attribute__((noinline))
+foo (int i, struct T *x, struct S *y)
+{
+  int j;
+  for (j = 14; j > i; j--)
+    x->t[j] = y->s;
+}
+
+int
+main (void)
+{
+  struct S s;
+  struct T t;
+  int i;
+
+  s.s = &s;
+  __builtin_memset (&t, 0, sizeof (t));
+  foo (6, &t, &s);
+  for (i = 0; i < 25; i++)
+    if (t.t[i] != ((i > 6 && i <= 14) ? &s : (struct S *) 0))
+      abort ();
+  __builtin_memset (&t, 0, sizeof (t));
+  foo (-1, &t, &s);
+  for (i = 0; i < 25; i++)
+    if (t.t[i] != ((i >= 0 && i <= 14) ? &s : (struct S *) 0))
+      abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30360.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30360.c
new file mode 100644
index 000000000..d4dae0d5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30360.c
@@ -0,0 +1,25 @@
+/* PR c/30360 */
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* ia64-*-linux* s390*-*-linux* } } */
+/* { dg-options "-O2 -std=gnu99" } */
+
+#define I	(__extension__ 1.0iF)
+#define H(x)	asm ("" : "=m" (x) : "m" (x))
+extern void abort (void);
+
+int
+main (void)
+{
+  _Complex double a = 1.0 + 1.0 * I, b = 0.0, c;
+  H (a);
+  H (b);
+  c = a / b;
+  if (!__builtin_isinf (__real__ c) && !__builtin_isinf (__imag__ c))
+    abort ();
+  a = 0.0;
+  H (a);
+  H (b);
+  c = a / b;
+  if (!__builtin_isnan (__real__ c) || !__builtin_isnan (__imag__ c))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30457.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30457.c
new file mode 100644
index 000000000..f52332d0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30457.c
@@ -0,0 +1,26 @@
+/* PR 30457 warn about va_start(ap, invalid) */
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+/* Undefined by C99 7.15.1.4p4 (va_start):
+   "If the parameter parmN is declared with the register storage
+    class, with a function or array type, or with a type that is
+    not compatible with the type that results after application of
+    the default argument promotions, the behavior is undefined."  */
+
+#include <stdarg.h>
+
+void foo(register short paramN, ...)
+{
+  va_list ap;
+
+  va_start(ap, paramN); /* { dg-warning "undefined behaviour when second parameter of 'va_start' is declared with 'register' storage" } */
+  
+  /* Undefined by C99 7.15.1.1p2:  */
+  (void) va_arg(ap, char); /* { dg-warning "'char' is promoted to 'int' when passed through '...'" } */
+  /* { dg-message "note: .so you should pass .int. not .char. to .va_arg.." "" { target *-*-* } 20 } */
+  /* { dg-message "note: if this code is reached, the program will abort"  "" { target *-*-* } 20 } */
+
+  va_end(ap);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30473.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30473.c
new file mode 100644
index 000000000..f01c1cc4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30473.c
@@ -0,0 +1,13 @@
+/* PR middle-end/30473 */
+/* Make sure this doesn't ICE.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern int sprintf (char *, const char *, ...);
+
+void
+foo (char *buf1, char *buf2)
+{
+  sprintf (buf1, "%s", "abcde");
+  sprintf (buf2, "%s");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-2.c
new file mode 100644
index 000000000..fdd5df668
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-2.c
@@ -0,0 +1,8 @@
+/* PR 30551 -Wmain is not enabled by default. */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void main(char a) {} /* { dg-bogus "first argument of .main. should be .int." } */
+/* { dg-bogus ".main. takes only zero or two arguments" "" { target *-*-* } 5 } */ 
+/* { dg-bogus "return type of .main. is not .int." "" { target *-*-* } 5 } */ 
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-3.c
new file mode 100644
index 000000000..bc33187e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-3.c
@@ -0,0 +1,7 @@
+/* PR 30551 -Wmain is enabled by -pedantic-errors. */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+/* { dg-skip-if "-Wmain not enabled with -pedantic on SPU" { spu-*-* } } */
+void main(char a) {} /* { dg-error "first argument of .main. should be .int." } */
+/* { dg-error ".main. takes only zero or two arguments" "" { target *-*-* } 5 } */ 
+/* { dg-error "return type of .main. is not .int." "" { target *-*-* } 5 } */ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-4.c
new file mode 100644
index 000000000..4803dbac0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-4.c
@@ -0,0 +1,8 @@
+/* PR 30551 -Wmain is enabled by -pedantic-errors and can be disabled. */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -Wno-main" } */
+
+void main(char a) {} /* { dg-bogus "first argument of .main. should be .int." } */
+/* { dg-bogus ".main. takes only zero or two arguments" "" { target *-*-* } 5 } */ 
+/* { dg-bogus "return type of .main. is not .int." "" { target *-*-* } 5 } */ 
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-5.c
new file mode 100644
index 000000000..060ed016b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-5.c
@@ -0,0 +1,7 @@
+/* PR 30551 -Wmain is enabled by -pedantic and can be disabled. */
+/* { dg-do compile } */
+/* { dg-options "-pedantic -Wno-main" } */
+
+void main(char a) {} /* { dg-bogus "first argument of .main. should be .int." } */
+/* { dg-bogus ".main. takes only zero or two arguments" "" { target *-*-* } 5 } */ 
+/* { dg-bogus "return type of .main. is not .int." "" { target *-*-* } 5 } */ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-6.c
new file mode 100644
index 000000000..48824e3a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551-6.c
@@ -0,0 +1,7 @@
+/* PR 30551 -Wmain is enabled by -pedantic. */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+/* { dg-skip-if "-Wmain not enabled with -pedantic on SPU" { spu-*-* } } */
+void main(char a) {} /* { dg-warning "first argument of .main. should be .int." } */
+/* { dg-warning ".main. takes only zero or two arguments" "" { target *-*-* } 5 } */ 
+/* { dg-warning "return type of .main. is not .int." "" { target *-*-* } 5 } */ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551.c
new file mode 100644
index 000000000..218a50ad9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30551.c
@@ -0,0 +1,7 @@
+/* PR 30551 -Wmain is enabled by -Wall.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+/* { dg-skip-if "-Wmain not enabled with -Wall on SPU" { spu-*-* } } */
+void main(char a) {} /* { dg-warning "first argument of .main. should be .int." } */
+/* { dg-warning ".main. takes only zero or two arguments" "" { target *-*-* } 5 } */ 
+/* { dg-warning "return type of .main. is not .int." "" { target *-*-* } 5 } */ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30643.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30643.c
new file mode 100644
index 000000000..67fe111a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30643.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler-not "undefined" } } */
+
+/* Make sure we optimize all calls away.  */
+
+extern void undefined (void);
+struct s { int a, b; };
+void bar (struct s *ps,  int *p, int *__restrict__ rp, int *__restrict__ rq)
+{
+  ps->a = 0;
+  ps->b = 1;
+  if (ps->a != 0)
+    undefined ();
+  p[0] = 0;
+  p[1] = 1;
+  if (p[0] != 0)
+    undefined ();
+  rp[0] = 0;
+  rq[0] = 1;
+  if (rp[0] != 0)
+    undefined ();
+}
+int main (void) {
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr3074-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr3074-1.c
new file mode 100644
index 000000000..4716b79da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr3074-1.c
@@ -0,0 +1,9 @@
+/* PR middle-end/3074  */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+void foo(int a)
+{
+  5 * (a == 1) | (a == 2);  /* { dg-warning "no effect" "no effect" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30744-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30744-1.c
new file mode 100644
index 000000000..a35c5526a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30744-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+#include <stddef.h>
+
+typedef struct {
+  ptrdiff_t unique;
+} G;
+
+void r(G* n)
+{
+  ptrdiff_t p;
+  if (((G *) ((void *)((~(ptrdiff_t)(p))))) != ((void *)0)) {
+    ((G *) ((void *)((~(ptrdiff_t)(p)))))->unique = n->unique;
+  }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30762-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30762-1.c
new file mode 100644
index 000000000..97dca8c02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30762-1.c
@@ -0,0 +1,15 @@
+/* PR c/30762 */
+/* { dg-do compile } */
+/* { dg-options "--combine -O3" } */
+/* { dg-additional-sources pr30762-2.c } */
+
+typedef struct { int i; } D;
+extern void foo (D);
+
+void
+bar (void)
+{
+  D d;
+  d.i = 1;
+  foo (d);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30762-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30762-2.c
new file mode 100644
index 000000000..7e914ebfa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30762-2.c
@@ -0,0 +1,9 @@
+/* PR c/30762 */
+/* { dg-do compile } */
+
+typedef struct { int i; } D;
+
+void
+foo (D x)
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30904.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30904.c
new file mode 100644
index 000000000..31ca0497f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30904.c
@@ -0,0 +1,18 @@
+/* { dg-do link } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+extern int t;
+extern void link_error(void);
+int main (void)
+{
+      struct { unsigned int a : 7; } s;
+      s.a = t;
+      if (s.a >> 8)
+          link_error ();
+      if (s.a >> 9)
+          link_error ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"  } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30949.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30949.c
new file mode 100644
index 000000000..a3f6a1413
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30949.c
@@ -0,0 +1,11 @@
+/* PR30949 */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+int func (int x);
+void recv (int (* funcptr) (double x)); /* { dg-message "note: expected 'int .\\\*..double.' but argument is of type 'int .\\\*..int.'" } */
+void call (void)
+{
+  recv (func); /* { dg-error "passing argument 1 of 'recv' from incompatible pointer type" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30951.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30951.c
new file mode 100644
index 000000000..149b8ecaa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30951.c
@@ -0,0 +1,36 @@
+/* { dg-do link } */
+
+extern void link_error (void);
+
+void test (int x, unsigned int y)
+{
+  if (x + 5 == x)
+    link_error ();
+  if (x == x + 10)
+    link_error ();
+  if (y + 5 == y)
+    link_error ();
+  if (y == y + 10)
+    link_error ();
+  if (x + 5 != x)
+    ;
+  else
+    link_error ();
+  if (x != x + 10)
+    ;
+  else
+    link_error ();
+  if (y + 5 != y)
+    ;
+  else
+    link_error ();
+  if (y != y + 10)
+    ;
+  else
+    link_error ();
+}
+
+int main()
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30957-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30957-1.c
new file mode 100644
index 000000000..65b98fa53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr30957-1.c
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* We don't (and don't want to) perform this optimisation on soft-float
+   targets, where each addition is a library call.  This test requires
+   -fassociative-math for enabling the variable-expansion as well as
+   -fsigned-zeros for honoring the sign of zero; but
+   they can not co-exist; also under -funsafe-math-optimizations, so we
+   expect it to fail.  */
+/* { dg-require-effective-target hard_float } */
+/* { dg-options "-O2 -funroll-loops -funsafe-math-optimizations -fvariable-expansion-in-unroller -fdump-rtl-loop2_unroll" } */
+
+extern void abort (void);
+extern void exit (int);
+
+float __attribute__((noinline))
+foo (float d, int n)
+{
+  unsigned i;
+  float accum = d;
+
+  for (i = 0; i < n; i++)
+    accum += d;
+
+  return accum;
+}
+
+int
+main ()
+{
+  if (__builtin_copysignf (1.0, foo (0.0 / -5.0, 10)) != -1.0)
+    abort ();
+  exit (0);
+}
+
+/* { dg-final { scan-rtl-dump "Expanding Accumulator" "loop2_unroll" } } */
+/* { dg-final { cleanup-rtl-dump "loop*" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31127.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31127.c
new file mode 100644
index 000000000..f45b10ed5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31127.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void ParseStringSidToSid(char *s, int* p) {
+    int i = 0;
+
+    while (*s) {
+        while (*s && *s != '-')
+            s++;
+        if (*s== '-')
+            s++;
+
+        p[i++] = *s;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31507-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31507-1.c
new file mode 100644
index 000000000..dbba1e1fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31507-1.c
@@ -0,0 +1,41 @@
+/* PR target/31507 */
+/* { dg-do run } */
+/* { dg-options "-Os -fno-omit-frame-pointer" } */
+
+extern void abort (void);
+
+__attribute__((noinline)) void
+foo (double d0, double d1, double d2, double d3,
+     double d4, double d5, double d6, double d7,
+     float f0, float f1, float f2, float f3,
+     char *p)
+{
+  if (d0 != 0 || d1 != 1 || d2 != 2 || d3 != 3)
+    abort ();
+  if (d4 != 4 || d5 != 5 || d6 != 6 || d7 != 7)
+    abort ();
+  if (f0 != 10 || f1 != 11 || f2 != 12 || f3 != 13)
+    abort ();
+  if (__builtin_memcmp (p, "foo", 4) != 0)
+    abort ();
+  __builtin_memcpy (p, "bar", 4);
+}
+
+__attribute__((noinline)) void
+bar (int x)
+{
+  char p[x];
+  if (x >= sizeof "foo")
+    __builtin_memcpy (p, "foo", 4);
+  foo (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0,
+       10.0f, 11.0f, 12.0f, 13.0f, p);
+  if (x >= sizeof "bar" && __builtin_memcmp (p, "bar", 4) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  bar (128);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31507-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31507-2.c
new file mode 100644
index 000000000..ee2388b7e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31507-2.c
@@ -0,0 +1,14 @@
+/* PR target/31507 */
+/* { dg-do compile } */
+/* { dg-options "-Os -fno-omit-frame-pointer" } */
+
+typedef int (*closure_test_type3)(float, float, float, float, float, float,
+				  float, float, double, int, float, float, int,
+				  float, float, int);
+int f (closure_test_type3 pcl)
+{
+  int res;
+  res = (pcl)
+    (1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9, 10, 11.11, 12.0, 13,
+     19.19, 21.21, 1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31529-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31529-1.c
new file mode 100644
index 000000000..20703ed25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31529-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-combine" } */
+/* { dg-additional-sources "pr31529-2.c" } */
+
+getline ()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31529-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31529-2.c
new file mode 100644
index 000000000..40d8ef868
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31529-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+
+extern __inline
+getline ()
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31847.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31847.c
new file mode 100644
index 000000000..4b945a994
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31847.c
@@ -0,0 +1,15 @@
+/* PR 31847 */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-all" } */
+
+extern int bar(int);
+
+int foo()
+{
+  int a = 0;
+  return bar(a);
+}
+
+/* { dg-final { scan-tree-dump-not "Created value  for " "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31866.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31866.c
new file mode 100644
index 000000000..4081c0e6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31866.c
@@ -0,0 +1,28 @@
+/* PR tree-optimization/31866 */
+/* { dg-do compile { target alpha*-*-* cris-*-* crisv32-*-* i?86-*-* mmix-*-* powerpc*-*-* rs6000-*-* x86_64-*-* } } */
+/* { dg-options "-O2" } */
+
+#if defined (__alpha__)
+# define REG "$1"
+#elif defined (__CRIS__)
+# define REG "r10"
+#elif defined (__i386__)
+# define REG "%eax"
+#elif defined (__MMIX__)
+# define REG "$8"
+#elif defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) \
+	|| defined (__POWERPC__) || defined (PPC) || defined (_IBMR2)
+# define REG "6"
+#elif defined (__x86_64__)
+# define REG "rax"
+#endif
+
+long int
+foo (void)
+{
+  unsigned long int s;
+  long int a = (long int) 0;
+  register long int r asm (REG) = a;
+  asm ("" : "=r" (s) : "0" (r));
+  return s;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31959.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31959.c
new file mode 100644
index 000000000..f8090f45c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr31959.c
@@ -0,0 +1,20 @@
+/* PR middle-end/31959 */
+/* { dg-do compile } */
+/* { dg-options "-O0 -fguess-branch-probability" } */
+
+struct A { int i; };
+
+static inline struct A *
+bar (struct A *x)
+{
+  return x;
+}
+
+void *
+foo (struct A *x, int y)
+{
+  void *p = (void *) 0;
+  if (__builtin_expect (y >= 6, 0))
+    p = bar (x);
+  return p;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32041.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32041.c
new file mode 100644
index 000000000..60837b204
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32041.c
@@ -0,0 +1,12 @@
+/* PR c/32041 */
+/* { dg-do compile } */
+
+struct S
+{
+  int c;
+  struct { float f; } sa[2];
+};
+
+char a[__builtin_offsetof (struct S, sa->f)
+       == __builtin_offsetof (struct S, sa[0].f) ? 1 : -1];
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32069.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32069.c
new file mode 100644
index 000000000..2ec37c675
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32069.c
@@ -0,0 +1,7 @@
+/* { dg-do-compile } */
+/* { dg-options "-O0 -fsplit-wide-types" } */
+
+long long int segfault (long long int a, long long int b)
+{
+  return a ^ b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32135.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32135.c
new file mode 100644
index 000000000..445965644
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32135.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-Warray-bounds -O2" } */
+struct PhaseEntryType
+{
+  char raw_field[50 + 1];
+};
+int
+ParsePhase (char in_cols[15][250], struct PhaseEntryType *P)
+{
+  __builtin_strncpy (P->raw_field, in_cols[2], 50);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32176.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32176.c
new file mode 100644
index 000000000..6646db04f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32176.c
@@ -0,0 +1,28 @@
+/* Contributed by Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -w" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=i686 -msse" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+void foo (void)
+{
+  int i, m;
+  float xa[21];
+
+  m = 0;
+  while (1)
+    {
+      i = 0;
+      while (1)
+	{
+	  if (xa[(long int)i] == xa[(long int)(i+m)])
+	    _gfortran_abort ();
+	  if (i == 10)
+	    break;
+	  i++;
+	}
+      if (m == 10)
+	break;
+      m++;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32293.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32293.c
new file mode 100644
index 000000000..fb1268ba1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32293.c
@@ -0,0 +1,61 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+unsigned int _IDEC_glbround;
+unsigned int _IDEC_glbflags;
+typedef unsigned UINT32;
+typedef signed SINT32;
+typedef unsigned long long UINT64;
+typedef signed long long SINT64;
+typedef
+__attribute__ ((aligned(16)))
+     struct {
+       UINT64 w[2];
+     } UINT128;
+
+static __inline UINT64
+unpack_BID128 (UINT64 * psign_x, int *pexponent_x,
+        UINT128 * pcoefficient_x, UINT128 * px) {
+  UINT128 coeff;
+  UINT64 ex;
+  *psign_x = (px->w[1]) & 0x8000000000000000ull;
+  ex = (px->w[1]) >> 49;
+  *pexponent_x = ((int) ex) & 0x3fff;
+  return coeff.w[0] | coeff.w[1];
+}
+
+static __inline UINT32
+get_BID32 (UINT32 sgn, int expon, UINT64 coeff, int rmode,
+    unsigned *fpsc) {
+  UINT32 r;
+
+  if (((unsigned) expon) > 191) {
+      r = sgn | 0x78000000ul;
+      switch (rmode) {
+      case 0x00002:
+        if (sgn)
+          r = sgn | 0x77f8967f;
+      }
+      return r;
+  }
+  r = expon;
+  return r;
+}
+
+UINT32
+bid128_to_bid32 (UINT128 x)
+{
+  UINT128 *px;
+  UINT128 CX;
+  UINT64 sign_x;
+  UINT32 res;
+  int exponent_x = 0;
+  px = &x;
+  if (!unpack_BID128 (&sign_x, &exponent_x, &CX, px)) {
+      return(res);
+  }
+  res = get_BID32 ((UINT32) (sign_x >> 32),
+        exponent_x, CX.w[0], _IDEC_glbround, &_IDEC_glbflags);
+  return(res);;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32328.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32328.c
new file mode 100644
index 000000000..69b08fc4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32328.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct barstruct { char const* some_string; };
+
+void changethepointer(struct barstruct**);
+
+void baz()
+{
+        struct barstruct bar1;
+        struct barstruct* barptr = &bar1;
+        changethepointer(&barptr);
+        barptr->some_string = "Everything OK";
+}
+
+/* { dg-final { scan-tree-dump "Everything OK" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32338-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32338-1.c
new file mode 100644
index 000000000..6a79a8c22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32338-1.c
@@ -0,0 +1,47 @@
+/* PR target/32338 */
+/* { dg-do link } */
+/* { dg-options "-O2 -fno-omit-frame-pointer" } */
+
+struct S
+{
+};
+
+int
+__attribute__((noinline))
+foo (struct S *d)
+{
+  return 2;
+}
+
+int
+__attribute__((noinline))
+bar (struct S *d)
+{
+  return 4;
+}
+
+int
+__attribute__((noinline))
+fnl (char const *q)
+{
+  return __builtin_strlen (q);
+}
+
+int
+__attribute__((noinline))
+baz (struct S *d, char const *q)
+{
+  unsigned int len;
+  len = fnl (q);
+  if (len > 512)
+    return bar (d);
+  return foo (d);
+}
+
+int
+main (int argc, char *argv[])
+{
+  if (argc > 30)
+    return baz ((void *) 0, "abcde");
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32338-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32338-2.c
new file mode 100644
index 000000000..81daddf6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32338-2.c
@@ -0,0 +1,47 @@
+/* PR target/32338 */
+/* { dg-do link } */
+/* { dg-options "-O2 -fno-omit-frame-pointer" } */
+
+struct S
+{
+};
+
+int
+__attribute__((noinline))
+foo (void)
+{
+  return 2;
+}
+
+int
+__attribute__((noinline))
+bar (void)
+{
+  return 4;
+}
+
+int
+__attribute__((noinline))
+fnl (void)
+{
+  return 6;
+}
+
+int
+__attribute__((noinline))
+baz (void)
+{
+  unsigned int len;
+  len = fnl ();
+  if (len > 512)
+    return bar ();
+  return foo ();
+}
+
+int
+main (int argc, char *argv[])
+{
+  if (argc > 30)
+    return baz ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32370.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32370.c
new file mode 100644
index 000000000..80a7c545d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32370.c
@@ -0,0 +1,26 @@
+/* PR middle-end/32370 */
+/* { dg-do compile { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "" { target ia64-*-* } } */
+/* { dg-options "-ffixed-esi" { target i?86-*-* x86_64-*-* } } */
+
+#if defined __i386__ || defined __x86_64__
+# define C "=S"
+# define TYPE unsigned long
+#elif defined __ia64__
+# define C "=a"
+# define TYPE unsigned long long
+#endif
+
+unsigned int
+foo (TYPE port)
+{
+  unsigned int v;
+  __asm__ __volatile__ ("" : C (v) : "Nd" (port));	/* { dg-error "while reloading\|has impossible" } */
+  return v;
+}
+
+void
+bar (void)
+{
+  foo (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32374.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32374.c
new file mode 100644
index 000000000..de15d559f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32374.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern int *stderr;
+
+void f (int *, const char *, ...);
+
+void g (const char *conf_name)
+{
+  typedef struct
+  {
+    const char *label;
+    const int value;
+  } Section;
+
+  const Section sections[2] = { {"", 0}, {"", 1} };
+
+  f (stderr, "", "", conf_name, 0, sections[0]);
+  f (stderr, "", "", conf_name, 0, sections[0]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32450.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32450.c
new file mode 100644
index 000000000..9606e3021
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32450.c
@@ -0,0 +1,36 @@
+/* Contributed by Joost VandeVondele  <jv244@cam.ac.uk> */
+
+/* { dg-do run } */
+/* { dg-require-profiling "-pg" } */
+/* { dg-options "-O2 -pg" } */
+/* { dg-options "-O2 -pg -mtune=core2" { target { i?86-*-* x86_64-*-* } } } */
+/* { dg-options "-O2 -pg -static" { target hppa*-*-hpux* } } */
+
+extern void abort (void);
+
+int stack_pointer;
+
+void
+__attribute__((noinline))
+mystop ()
+{
+  abort ();
+}
+
+void
+__attribute__((noinline))
+add ()
+{
+  if (stack_pointer + 1 > 10)
+    mystop ();
+
+  stack_pointer = stack_pointer + 1;
+}
+
+int main ()
+{
+  add ();
+  return stack_pointer - 1;
+}
+
+/* { dg-final { cleanup-profile-file } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32559.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32559.c
new file mode 100644
index 000000000..fee1c9790
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32559.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int __attribute__((vector_size (8))) v;
+
+void foo()
+{
+  v += ~v;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32573.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32573.c
new file mode 100644
index 000000000..d6897fbc2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32573.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/32573 */
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+int
+foo (void *x, long long *y)
+{
+  char a[256];
+  int i = 0;
+  long long b;
+  int c;
+  int d = 0;
+  int e = 0;
+  unsigned f = 0;
+  b = bar (x);
+  c = (unsigned) b;
+  while (d < b && d < 65557)
+    {
+      f = *(unsigned *) &a[0];
+      for (i = c - 4; i > 0; i--)
+	if (a[i + 0] == 0x50
+	    && a[i + 1] == 0x4B
+	    && a[i + 3] == 0x06)
+	  {
+	    e = 1;
+	    break;
+	  }
+    }
+  return !e;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32721.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32721.c
new file mode 100644
index 000000000..b62272b56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32721.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int spinlock[2];
+int main ()
+{
+volatile int * spinlock0;
+volatile int * spinlock1;
+spinlock0 = &spinlock[0];
+spinlock1 = &spinlock[1];
+
+*spinlock0 = 0;
+*spinlock1 = 0;
+ while (*spinlock0);
+}
+
+/* { dg-final { scan-tree-dump "={v} .*spinlock" "optimized" } } */
+/* { dg-final { scan-tree-dump "spinlock.* ={v}" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-1.c
new file mode 100644
index 000000000..1ceb77ad4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-1.c
@@ -0,0 +1,45 @@
+/* PR middle-end/32912 */
+/* { dg-do run } */
+/* { dg-options "-O2 -w" } */
+/* { dg-options "-O2 -w -fno-common" { target hppa*-*-hpux* } } */
+
+extern void abort (void);
+
+typedef int __m128i __attribute__ ((__vector_size__ (16)));
+
+__m128i a, b, c, d, e, f;
+
+void
+foo (__m128i x)
+{
+  a = x ^ ~x;
+  b = ~x ^ x;
+  c = x | ~x;
+  d = ~x | x;
+  e = x & ~x;
+  f = ~x & x;
+}
+
+int
+main (void)
+{
+  union { __m128i v; int i[sizeof (__m128i) / sizeof (int)]; } u;
+  int i;
+
+  for (i = 0; i < sizeof (u.i) / sizeof (u.i[0]); i++)
+    u.i[i] = i * 49 - 36;
+  foo (u.v);
+#define check(x, val) \
+  u.v = (x); \
+  for (i = 0; i < sizeof (u.i) / sizeof (u.i[0]); i++) \
+    if (u.i[i] != (val)) \
+      abort ()
+
+  check (a, ~0);
+  check (b, ~0);
+  check (c, ~0);
+  check (d, ~0);
+  check (e, 0);
+  check (f, 0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-2.c
new file mode 100644
index 000000000..f3c754cc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-2.c
@@ -0,0 +1,50 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -w" } */
+
+extern void abort (void);
+
+#if(__SIZEOF_INT__ >= 4)
+typedef int __m128i __attribute__ ((__vector_size__ (16)));
+#else
+typedef long __m128i __attribute__ ((__vector_size__ (16)));
+#endif
+__m128i
+foo (void)
+{
+  __m128i x = { 0x11111111, 0x22222222, 0x44444444 };
+  return x;
+}
+
+__m128i
+bar (void)
+{
+  __m128i x = { 0x11111111, 0x22222222, 0x44444444 };
+  return ~x;
+}
+
+int
+main (void)
+{
+#if(__SIZEOF_INT__ >= 4)
+  union { __m128i v; int i[sizeof (__m128i) / sizeof (int)]; } u, v;
+#else
+  union { __m128i v; long i[sizeof (__m128i) / sizeof (long)]; } u, v;
+#endif
+  int i;
+
+  u.v = foo ();
+  v.v = bar ();
+  for (i = 0; i < sizeof (u.i) / sizeof (u.i[0]); i++)
+    {
+      if (u.i[i] != ~v.i[i])
+	abort ();
+      if (i < 3)
+	{
+	  if (u.i[i] != (0x11111111 << i))
+	    abort ();
+	}
+      else if (u.i[i])
+	abort ();
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-3.c
new file mode 100644
index 000000000..407ac524f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32912-3.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-w -O2 -fdump-tree-optimized" } */
+
+typedef int __m128i __attribute__ ((__vector_size__ (16)));
+
+__m128i
+bar (void)
+{
+  __m128i x = { 0x11111111, 0x22222222, 0x44444444 };
+  return ~x;
+}
+
+/* { dg-final { scan-tree-dump-not "~\{" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32975.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32975.c
new file mode 100644
index 000000000..8ddb0d8d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr32975.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/32975 */
+/* { dg-do compile } */
+/* { dg-options "-O1 -finline-functions -fipa-cp" } */
+
+static int
+f0 (char *s0, char *s1)
+{
+  return __builtin_strlen (s0) > __builtin_strlen (s1);
+}
+
+int
+f1 (char *s, int j)
+{
+  if (f0 (s, ""))
+    return 1;
+  return j;
+}
+
+void
+f2 (char *s)
+{
+  f1 (s, 0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33007.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33007.c
new file mode 100644
index 000000000..26b22fdd3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33007.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math -ftrapping-math" } */
+/* { dg-warning "-fassociative-math disabled" "" { target *-*-* } 1 } */
+
+long
+foo (int i)
+{
+  float x;
+  x = i;
+  return __builtin_lroundf (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33017.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33017.c
new file mode 100644
index 000000000..851fe71f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33017.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/33017 */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+extern __SIZE_TYPE__ strlen (const char *);
+extern void abort (void);
+
+char *
+__attribute__((noinline))
+foo (const char *string)
+{
+  int len;
+  static char var[0x104];
+  int off;
+  len = strlen (string);
+  for (off = 0; off < 64; off++)
+    var[len + off + 2] = 0x57;
+  return var;
+}
+
+int
+main (void)
+{
+  char *p = foo ("abcd");
+  int i;
+  for (i = 0; i < 0x104; i++)
+    if (p[i] != ((i >= 6 && i < 70) ? 0x57 : 0))
+      abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33092.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33092.c
new file mode 100644
index 000000000..8f48fab5d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33092.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-tree-salias" } */
+int foo ()
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-1.c
new file mode 100644
index 000000000..d07c97eb7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-1.c
@@ -0,0 +1,54 @@
+/* PR tree-optimization/33136 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+struct S
+{
+  struct S *a;
+  int b;
+  float f;
+};
+
+static struct S s;
+
+static int *
+__attribute__((noinline, const))
+foo (void)
+{
+  return &s.b;
+}
+
+float
+__attribute__((noinline))
+bar (float *f)
+{
+  s.f = 1.0;
+  *f = 4.0;
+  return s.f;
+}
+
+int
+__attribute__((noinline))
+baz (int *x)
+{
+  s.b = 1;
+  *x = 4;
+  return s.b;
+}
+
+int
+t (void)
+{
+  float f = 8.0;
+  return bar (&f) + baz (foo ());
+}
+
+int
+main (void)
+{
+  if (t () != 5)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-2.c
new file mode 100644
index 000000000..760b5a06f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-2.c
@@ -0,0 +1,60 @@
+/* PR tree-optimization/33136 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+struct S
+{
+  void *a;
+  int b;
+  int *c;
+};
+static int d, e;
+
+static struct S s;
+
+static int *
+__attribute__((noinline, const))
+foo (void)
+{
+  return &s.b;
+}
+
+int *
+__attribute__((noinline))
+bar (int **f)
+{
+  s.c = &d;
+  *f = &e;
+  /* As nothing ever takes the address of any int * field in struct S,
+     the write to *f can't alias with the s.c field.  */
+  return s.c;
+}
+
+int
+__attribute__((noinline))
+baz (int *x)
+{
+  s.b = 1;
+  *x = 4;
+  /* Function foo takes address of an int field in struct S,
+     so *x can alias with the s.b field (and it does in this testcase).  */
+  return s.b;
+}
+
+int
+__attribute__((noinline))
+t (void)
+{
+  int *f = (int *) 0;
+  return 10 * (bar (&f) != &d) + baz (foo ());
+}
+
+int
+main (void)
+{
+  if (t () != 4)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-3.c
new file mode 100644
index 000000000..fcb5972eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33136-3.c
@@ -0,0 +1,60 @@
+/* PR tree-optimization/33136 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+struct S
+{
+  void *a;
+  int b[3];
+  double *c;
+};
+static double d, e;
+
+static struct S s;
+
+static int *
+__attribute__((noinline, const))
+foo (void)
+{
+  return (int *) &s.b;
+}
+
+double *
+__attribute__((noinline))
+bar (double **f)
+{
+  s.c = &d;
+  *f = &e;
+  /* As nothing ever takes the address of any double * field in struct S,
+     the write to *f can't alias with the s.c field.  */
+  return s.c;
+}
+
+int
+__attribute__((noinline))
+baz (int *x)
+{
+  s.b[0] = 1;
+  *x = 4;
+  /* Function foo takes address of an int array field in struct S,
+     so *x can alias with the s.b field (and it does in this testcase).  */
+  return s.b[0];
+}
+
+int
+__attribute__((noinline))
+t (void)
+{
+  double *f = (double *) 0;
+  return 10 * (bar (&f) != &d) + baz (foo ());
+}
+
+int
+main (void)
+{
+  if (t () != 4)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33238.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33238.c
new file mode 100644
index 000000000..0b399041a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33238.c
@@ -0,0 +1,12 @@
+/* PR c/33238 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+void
+reverse (void *x, int y, int z)
+{
+  struct { char w[z]; } *p = x, a;
+  int i, j;
+  for (i = y - 1, j = 0; j < y / 2; i--, j++)
+    ({ a = p[i]; p[i] = p[j]; p[j] = a; });
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-1.c
new file mode 100644
index 000000000..d646ff74d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-1.c
@@ -0,0 +1,25 @@
+/* PR tree-optimization/33434 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int k;
+
+void f1 (int a, int b)
+{
+  a = 1;
+  b = 1;
+  if (a)
+    while (b --)
+      k = 1;
+  else
+    if (b != 1)
+      __builtin_abort ();
+}
+
+int main (void)
+{
+  f1 (1, 1);
+  if (k != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-2.c
new file mode 100644
index 000000000..7dd614c0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-2.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/33434 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int k;
+
+void f1 (int a)
+{
+  int b;
+  a = 1;
+  b = 1;
+  if (a)
+    while (b --)
+      k = 1;
+  else
+    if (b != 1)
+      __builtin_abort ();
+}
+
+int main (void)
+{
+  f1 (1);
+  if (k != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-3.c
new file mode 100644
index 000000000..3e99451fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-3.c
@@ -0,0 +1,31 @@
+/* PR tree-optimization/33434 */
+/* { dg-do run } */
+/* { dg-options "-O3" } */
+
+int k;
+
+void __attribute__((noinline)) f2 (int b)
+{
+  k = b - 1;
+}
+
+void f1 (int a, int b)
+{
+  f2 (b);
+  a = 1;
+  b = 1;
+  if (a)
+    while (b --)
+      k = 1;
+  else
+    if (b != 1)
+      __builtin_abort ();
+}
+
+int main (void)
+{
+  f1 (1, 1);
+  if (k != 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-4.c
new file mode 100644
index 000000000..d34675fe4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33434-4.c
@@ -0,0 +1,18 @@
+/* PR tree-optimization/33434 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void *baz (void);
+
+static void *
+bar (void *x)
+{
+  x = baz ();
+  return x;
+}
+
+void *
+foo (void *x)
+{
+  return bar (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33619.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33619.c
new file mode 100644
index 000000000..8011e69e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33619.c
@@ -0,0 +1,45 @@
+/* PR tree-optimization/33619 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+#ifdef __powerpc__
+# define REG1 __asm__ ("3")
+# define REG2 __asm__ ("4")
+#elif defined __x86_64__
+# define REG1 __asm__ ("rdi")
+# define REG2 __asm__ ("rsi")
+#else
+# define REG1
+# define REG2
+#endif
+
+static inline void
+bar (unsigned long x, int y)
+{
+  register unsigned long p1 REG1 = x;
+  register unsigned long p2 REG2 = y;
+  __asm__ volatile ("" : "=r" (p1), "=r" (p2) : "0" (p1), "1" (p2) : "memory");
+  if (p1 != 0xdeadUL || p2 != 0xbefUL)
+    __builtin_abort ();
+}
+
+__attribute__((const, noinline)) int
+baz (int x)
+{
+  return x;
+}
+
+__attribute__((noinline)) void
+foo (unsigned long *x, int y)
+{
+  unsigned long a = *x;
+  bar (a, baz (y));
+}
+
+int
+main (void)
+{
+  unsigned long a = 0xdeadUL;
+  foo (&a, 0xbefUL);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33644.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33644.c
new file mode 100644
index 000000000..f3f543cbe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33644.c
@@ -0,0 +1,19 @@
+/* PR rtl-optimization/33644 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftrapv" } */
+
+extern char *bar (const char *);
+
+int *m, *b;
+
+void foo (void)
+{
+  int *mv;
+  int p;
+  char a[17];
+
+  p = bar (a) - a;
+  for (mv = m; mv < b; mv++)
+    if (p && ((*mv  & 7) != p))
+      *mv=0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33645-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33645-1.c
new file mode 100644
index 000000000..1ec8a2ff8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33645-1.c
@@ -0,0 +1,18 @@
+/* PR tree-optimization/33645 */
+/* { dg-do link } */
+/* { dg-options "-O2 -fno-unit-at-a-time" } */
+
+__attribute__((noinline)) int
+bar (int *x)
+{
+  return *x++;
+}
+
+int
+main ()
+{
+  static int var1_s;
+  static int *var1_t = &var1_s;
+
+  return bar (var1_t) != 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33645-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33645-2.c
new file mode 100644
index 000000000..3c4bcb060
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33645-2.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/33645 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -funit-at-a-time" } */
+
+__attribute__((noinline)) int
+bar (int *x)
+{
+  return *x++;
+}
+
+int
+main ()
+{
+  static int var1_s;
+  static int *var1_t = &var1_s;
+
+  return bar (var1_t) != 0;
+}
+
+/* { dg-final { scan-assembler-not "var1_t" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33648.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33648.c
new file mode 100644
index 000000000..f5da55cd4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33648.c
@@ -0,0 +1,14 @@
+/* PR rtl-optimization/33648 */
+/* { dg-do compile } */
+/* { dg-require-effective-target freorder } */
+/* { dg-options "-O2 -fmodulo-sched -freorder-blocks-and-partition" } */
+
+unsigned res;
+
+void
+foo (unsigned code, int len)
+{
+  int i;
+  for (i = 0; i < len; i++)
+    res |= code & 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33653.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33653.c
new file mode 100644
index 000000000..91274c27e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33653.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-rtl-shorten" } */
+
+void f (volatile char *p)
+{
+  char c = p[0];
+}
+
+/* { dg-final { scan-rtl-dump "mem/v" "shorten" } } */
+/* { dg-final { cleanup-rtl-dump "shorten" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33666.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33666.c
new file mode 100644
index 000000000..1f27b136d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33666.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options { -std=c99 } } */
+
+/* This used to fail with type-checking enabled because we stripped
+   the inner conversion to unsigned int.  */
+
+void __lock_get_list(void *dp)
+{
+  if (((__SIZE_TYPE__)dp + 1) & ~1ULL)
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33667.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33667.c
new file mode 100644
index 000000000..676c4a46d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33667.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned long long int uint64_t;
+struct magic {
+  uint8_t mask_op;
+  union {
+   uint64_t _mask;
+  } _u;
+  union VALUETYPE {
+   uint16_t h;
+  } value;
+};
+void cvt_16(union VALUETYPE *p, const struct magic *m)
+{
+  if (m->_u._mask)
+    p->h %= (uint16_t) m->_u._mask;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33670.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33670.c
new file mode 100644
index 000000000..5232af965
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33670.c
@@ -0,0 +1,19 @@
+/* PR middle-end/33670 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fsched-stalled-insns=0" } */
+
+struct B
+{
+  int p;
+  int n;
+};
+extern struct B ***b;
+extern int a;
+
+int
+foo (int d, int e)
+{
+  int c;
+  for (c = d; c <= e; c++)
+    b[a][c]->n = b[a][c]->p;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33673.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33673.c
new file mode 100644
index 000000000..d238d112c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33673.c
@@ -0,0 +1,43 @@
+/* PR rtl-optimization/33673 */
+/* { dg-do compile } */
+/* { dg-options "-Os -fno-forward-propagate -fno-guess-branch-probability -fno-move-loop-invariants -fno-tree-dominator-opts -fno-tree-loop-optimize" } */
+
+extern int f1 (int);
+extern int f2 (int);
+
+extern int *a;
+
+static void
+find_reg (int n)
+{
+  int i, pass;
+  unsigned int used[2], used1[2];
+
+  int c = n ? f1 (a[1]) : f2 (a[1]);
+
+  for (i = 64, pass = 0; pass <= 1 && i >= 64; pass++)
+    {
+      if (pass == 1)
+	{
+	  unsigned int *scan_tp_ = used;
+	  unsigned int *scan_fp_ = used1;
+	  int j;
+	  for (j = 0; j < 2; j++)
+	    *scan_tp_++ = *scan_fp_++;
+	}
+      for (i = 0; i < 64; i++)
+	{
+	  int regno = i;
+	  if (n == 0)
+	    if (i == regno)
+	      break;
+	}
+    }
+}
+
+void
+global_alloc ()
+{
+  find_reg (0);
+  find_reg (1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33676.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33676.c
new file mode 100644
index 000000000..af65478a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33676.c
@@ -0,0 +1,51 @@
+/* { dg-do run } */
+/* { dg-options "-O0 -mtune=i386 -fomit-frame-pointer" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+__attribute__((noreturn,noinline)) void abrt (const char *fi, const char *fu)
+{
+  __builtin_abort ();
+}
+
+__attribute__((noinline)) int f (int k)
+{
+  return k;
+}
+
+__attribute__((noinline)) int g (int t, int k)
+{
+  int b;
+
+  switch (t)
+    {
+    case 0:
+      abrt (__FILE__, __FUNCTION__);
+
+    case 1:
+      b = f (k);
+      break;
+
+    case 2:
+      b = f (k);
+      break;
+
+    case 3:
+      b = f (k);
+      break;
+
+    case 4:
+      b = f (k);
+      break;
+
+    default:
+      abrt (__FILE__, __FUNCTION__);
+    }
+
+  return b;
+}
+
+int main (void)
+{
+  if (g (3, 1337) != 1337)
+      abrt (__FILE__, __FUNCTION__);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33691.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33691.c
new file mode 100644
index 000000000..93213610d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33691.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+
+/* ICEd with type-checking enabled.  */
+
+unsigned int mgaSetTexImages(int i)
+{
+    return ((i | 0x40) & 0xffffffc0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33692.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33692.c
new file mode 100644
index 000000000..08ee332dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33692.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+
+/* We ICEd with type-checking enabled.  */
+
+typedef struct { int i; } snd_pcm_info_t;
+typedef struct { snd_pcm_info_t info; } snd_pcm_shm_ctrl_t;
+void snd_pcm_info(snd_pcm_info_t *);
+int pcm_shm_cmd(volatile snd_pcm_shm_ctrl_t *ctrl)
+{
+  snd_pcm_info((snd_pcm_info_t *) &ctrl->info);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33693.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33693.c
new file mode 100644
index 000000000..147c164c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33693.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+
+/* This used to ICE with type-checking enabled.  */
+
+unsigned long modify_field (unsigned long mask, long fieldval)
+{
+  return (~fieldval & ~mask);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33694.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33694.c
new file mode 100644
index 000000000..fa62b9eae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33694.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-ansi" } */
+
+/* This used to ICE with type-checking enabled.  */
+
+__SIZE_TYPE__ cnfs_mapcntl(long pagesize)
+{
+     return ~(__SIZE_TYPE__)(pagesize - 1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33695.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33695.c
new file mode 100644
index 000000000..2d3ffbd66
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33695.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+
+/* We used to ICE with type-checking enabled.  */
+
+unsigned int bfstages(int M, float *Utbl, int Ustride)
+{
+   return ((unsigned int) 1 << M) * Ustride;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33696.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33696.c
new file mode 100644
index 000000000..97bbfe8bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33696.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+
+/* This used to ICE with type-checking enabled.  */
+
+typedef unsigned char uint8_t;
+typedef unsigned int uint_least32_t;
+extern int foo (long int __off);
+void write (uint_least32_t chunk_len)
+{
+     uint8_t tmp[4];
+     foo (-(long)chunk_len - sizeof(tmp));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33697.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33697.c
new file mode 100644
index 000000000..8c5edb658
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33697.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+
+/* We used to ICE for this with type-checking enabled.  */
+
+typedef signed short gint16;
+typedef unsigned short guint16;
+gint16 dissect_old_pflog(gint16 rnr)
+{
+  return (guint16) ((guint16) ((guint16)rnr >> 8) | (guint16) ((guint16)rnr << 8));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33724.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33724.c
new file mode 100644
index 000000000..7e8eb5ddd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33724.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+
+/* We ICEd with type-checking enabled.  */
+
+struct xt_entry_target {
+  char name[1];
+};
+struct ipt_entry {
+  unsigned char elems[1];
+};
+void match_different(const unsigned char *);
+int dump_entry(struct xt_entry_target *t)
+{
+  return __builtin_strcmp (t->name, "");
+}
+void is_same(const struct ipt_entry *a)
+{
+  match_different(a->elems);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33726.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33726.c
new file mode 100644
index 000000000..e87cbc565
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33726.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+/* We used to ICE here with type-checking enabled.  */
+
+typedef unsigned int U032;
+typedef volatile struct X {
+     U032 Monochrome[1];
+     struct {
+          U032 WidthHeight;
+     } UnclippedRectangle[1];
+} RivaBitmap;
+void writel(void *);
+void rivafb_fillrect(RivaBitmap *bm)
+{
+  writel((void *)&bm->UnclippedRectangle[0].WidthHeight);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33742.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33742.c
new file mode 100644
index 000000000..b905d9dda
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33742.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+typedef unsigned short ush;
+extern ush prev[];
+
+void fill_window ()
+{
+  register unsigned n, m;
+
+  for (n = 0; n < 32768; n++)
+    {
+      m = prev[n];
+      prev[n] = (ush) (m >= 0x8000 ? m - 0x8000 : 0);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33826.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33826.c
new file mode 100644
index 000000000..3e08b14fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33826.c
@@ -0,0 +1,41 @@
+/* Regression test for PR middle-end/33826 */
+/* Verify that recursive functions cannot be pure or const.  */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target nonpic } */
+/* { dg-options "-O1 -fdump-ipa-pure-const" } */
+
+int recurese1 (int i)
+{
+  return recurse1 (i+1);
+}
+
+int recurse2a (int i)
+{
+  return recurse2b (i+1);
+}
+
+int recurse2b (int i)
+{
+  return recurse2a (i+1);
+}
+
+int norecurse1a (int i)
+{
+  return norecurse1b (i+1);
+}
+
+int norecurse1b (int i)
+{
+  return i+1;
+}
+
+/* { dg-final { scan-ipa-dump "found to be const: norecurse1a" "pure-const" } } */
+/* { dg-final { scan-ipa-dump "found to be const: norecurse1b" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be pure: recurse1" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be pure: recurse2a" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be pure: recurse2b" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be const: recurse1" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be const: recurse2a" "pure-const" } } */
+/* { dg-final { scan-ipa-dump-not "found to be const: recurse2b" "pure-const" } } */
+/* { dg-final { cleanup-ipa-dump "pure-const" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33923.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33923.c
new file mode 100644
index 000000000..d71e5578a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33923.c
@@ -0,0 +1,76 @@
+/* PR target/33923 */
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-O3 --param max-partial-antic-length=0" } */
+
+static int pendingCommand;
+static int currentModifiers;
+typedef struct
+{
+  int (*updateKeys) (int *keyPressed);
+}
+ProtocolOperations;
+static const ProtocolOperations *protocol;
+brl_readCommand (void)
+{
+  unsigned long int keys;
+  int command;
+  int keyPressed;
+  unsigned char routingKeys[200];
+  int routingKeyCount;
+  signed char rightVerticalSensor;
+  if (pendingCommand != (-1))
+    {
+      return command;
+    }
+  if (!protocol->updateKeys (&keyPressed))
+    {
+      if (rightVerticalSensor >= 0)
+        keys |= 1;
+      if ((routingKeyCount == 0) && keys)
+        {
+          if (currentModifiers)
+            {
+            doChord:switch (keys);
+            }
+          else
+            {
+            doCharacter:
+              command = 0X2200;
+              if (keys & 0X01UL)
+                command |= 0001;
+              if (keys & 0X02UL)
+                command |= 0002;
+              if (keys & 0X04UL)
+                command |= 0004;
+              if (keys & 0X08UL)
+                command |= 0010;
+              if (keys & 0X10UL)
+                command |= 0020;
+              if (keys & 0X20UL)
+                command |= 0040;
+              if (currentModifiers & (0X0010 | 0X0200))
+                command |= 0100;
+              if (currentModifiers & 0X0040)
+                command |= 0200;
+              if (currentModifiers & 0X0100)
+                command |= 0X020000;
+              if (currentModifiers & 0X0400)
+                command |= 0X080000;
+              if (currentModifiers & 0X0800)
+                command |= 0X040000;
+            }
+          unsigned char key1 = routingKeys[0];
+          if (key1 == 0)
+            {
+            } else if (key1 == 1)
+            if (keys)
+              {
+                currentModifiers |= 0X0010;
+                goto doCharacter;
+              }
+        }
+    }
+  return command;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33961.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33961.c
new file mode 100644
index 000000000..43403ed30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr33961.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/33961 */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-cselim" } */
+
+void decode(char *d, int len);
+
+void decode(char *d, int len) {
+        int i = len - 1;
+        while(i >= 0) {
+                d[i];
+                if(d[i] == 0)
+                        d[i]=' ';
+		if(d[i] == 1)
+			d[i]='x';
+                i--;
+        }
+}
+
+int main(int argc, char **argv)
+{
+        decode("this bug is really weird", 24);
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34003-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34003-1.c
new file mode 100644
index 000000000..ff97fe6d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34003-1.c
@@ -0,0 +1,8 @@
+/* PR bootstrap/34003 */
+/* { dg-do link } */
+/* { dg-options "-O0" } */
+/* { dg-additional-sources "pr34003-2.c" } */
+
+extern void foo (void);
+int bar (void) { foo (); return 1; }
+extern void foo (void);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34003-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34003-2.c
new file mode 100644
index 000000000..a5330567f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34003-2.c
@@ -0,0 +1,20 @@
+/* PR bootstrap/34003 */
+/* { dg-do compile } */
+/* { dg-options "-O0" } */
+
+extern void abort (void);
+
+int seen = 0;
+
+void foo (void)
+{
+  ++seen;
+}
+
+int main (void)
+{
+  extern int bar (void);
+  if (bar () != 1 || seen != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34016.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34016.c
new file mode 100644
index 000000000..5ca84bb62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34016.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/34016 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern void bar (double *);
+
+void foo (void)
+{
+  double gr[36];
+  int i, j;
+  for (i = 0; i <= 5; i++)
+    {
+      for (j = 0; j <= 5; j++)
+        gr[i + j * 6] = 0.0;
+      if (i <= 2)
+        gr[i + i * 6] = 1.0;
+    }
+  bar (gr);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34027-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34027-1.c
new file mode 100644
index 000000000..8e8872a51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34027-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-Os -fdump-tree-optimized" } */
+
+unsigned long foobar(unsigned long ns)
+{
+  while(ns >= 10000L)
+    ns -= 10000L;
+  return ns;
+}
+
+/* This test was originally introduced to test that we transform
+   to ns % 10000.  See the discussion of PR 32044 why we do not do
+   that anymore.  */
+/* { dg-final { scan-tree-dump-times "%" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "/" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34027-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34027-2.c
new file mode 100644
index 000000000..70c4561d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34027-2.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+long foo(long n, long m)
+{
+  return n - (n / m) * m;
+}
+
+/* { dg-final { scan-tree-dump "n % m" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34088.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34088.c
new file mode 100644
index 000000000..88a635d2d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34088.c
@@ -0,0 +1,24 @@
+/* PR middle-end/34088 */
+/* { dg-do compile } */
+/* { dg-options "-O -Wall -Werror" } */
+
+int F0 (int);
+int F1 (int t) { return F0(t); }
+int F2 (int t) { return F0(t); }
+
+extern int X[];
+static inline int foo(int i)
+{
+  return X[i];
+}
+
+int bar(int* p)
+{
+  int i;
+
+  while ( ({ if (foo(*p) && foo(*p)); p; }) );
+
+  return i;	/* { dg-error "is used uninitialized" } */
+}
+
+/* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34171.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34171.c
new file mode 100644
index 000000000..6013a0de6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34171.c
@@ -0,0 +1,27 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+extern char coredump;
+extern void sigemptyset (char *);
+struct sigaction
+{
+  char sa_mask;
+};
+void doSignalsSetup (void)
+{
+  static const int signals[] = {
+    1, 2, 3, 4, 6, 8, 11, 13, 14, 15, 30 , 31
+  };
+  unsigned int i, sig;
+  struct sigaction sa;
+  for (i = 0; i < sizeof (signals) / sizeof (int); i++)
+    {
+      sig = signals[i];
+      if (coredump &&
+          (sig == 4 || sig == 8 || sig == 11 || sig == 10))
+        continue;
+      sigemptyset (&sa.sa_mask);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34225.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34225.c
new file mode 100644
index 000000000..659e176ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34225.c
@@ -0,0 +1,61 @@
+/* PR target/34225 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-strict-aliasing -fstack-protector" } */
+/* { dg-require-effective-target fstack_protector } */
+
+typedef __SIZE_TYPE__ size_t;
+extern int sscanf (const char *, const char *, ...);
+struct C
+{
+  char c[240];
+};
+struct O
+{
+  char **o;
+};
+struct P
+{
+  int p1;
+  char p2[256];
+  char p3[256];
+  char p4[256];
+};
+
+extern void *s;
+extern int f1 (char *, struct C *);
+extern void f2 (void *, const char *);
+extern void f3 (char *, const char *);
+extern int f4 (int, double *, int);
+
+int
+foo (char *a[], struct O *b, int c, int d, struct P *e, int f, int *h,
+     char *l)
+{
+  int i, g = 7, m = 0, n;
+  struct C j[150];
+  double *k[150];
+  char o[100];
+
+  if (f1 (o, &j[g]) < 0)
+    g++;
+
+  while (!m)
+    {
+      f2 (s, "xxx");
+      for (i = 0; i < f; i++)
+	if ((!b->o && __builtin_strncmp (l, "abcde", 5) == 0)
+	    || (b->o && !b->o[c]))
+	  {
+	    *e[d].p4 = *e[d].p3 = *e[d].p2 = 0;
+	    sscanf (l, "%s %s %[^\n]", e[d].p3, e[d].p2, e[d].p4);
+	  }
+      for (n = 0; n < d; n++)
+	for (i = 0; i < g; i++)
+	  {
+	    f3 (a[i + 1], "foo");
+	    if (f4 (h[i], k[i], e[n].p1) < 0)
+	      f3 (a[i + 1], "bar");
+	  }
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34233.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34233.c
new file mode 100644
index 000000000..1982efaa6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34233.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math" } */
+
+double foo(void)
+{
+  return __builtin_pow (0.0, -1.5);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34263.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34263.c
new file mode 100644
index 000000000..10df9d81f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34263.c
@@ -0,0 +1,59 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* Same test as 990128-1.c.  */
+
+extern int printf (const char *,...);
+extern void abort (void);
+
+struct s { struct s *n; } *p;
+struct s ss;
+#define MAX     10
+struct s sss[MAX];
+int count = 0;
+
+void sub( struct s *p, struct s **pp );
+int look( struct s *p, struct s **pp );
+
+main()
+{
+    struct s *pp;
+    struct s *next;
+    int i;
+
+    p = &ss;
+    next = p;
+    for ( i = 0; i < MAX; i++ ) {
+        next->n = &sss[i];
+        next = next->n;
+    }
+    next->n = 0;
+
+    sub( p, &pp );
+    if (count != MAX+2)
+      abort ();
+
+    return( 0 );
+}
+
+void sub( struct s *p, struct s **pp )
+{
+   for ( ; look( p, pp ); ) {
+        if ( p )
+            p = p->n;
+        else
+            break;
+   }
+}
+
+int look( struct s *p, struct s **pp )
+{
+    for ( ; p; p = p->n )
+        ;
+    *pp = p;
+    count++;
+    return( 1 );
+}
+
+/* { dg-final { scan-tree-dump "Cleaned-up latch block of loop with single BB" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34351.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34351.c
new file mode 100644
index 000000000..f40717082
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34351.c
@@ -0,0 +1,4 @@
+/* { dg-do compile  { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-Wall" } */
+
+register int * volatile x asm ("ebx"); /* { dg-warning "optimization may eliminate reads and/or writes to register variables" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34457-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34457-1.c
new file mode 100644
index 000000000..ccd937c6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34457-1.c
@@ -0,0 +1,24 @@
+/* PR c/34457 */
+/* { dg-do compile } */
+/* { dg-require-effective-target trampolines } */
+/* { dg-options "--combine -O2" } */
+/* { dg-additional-sources "pr34457-2.c" } */
+   
+
+typedef __SIZE_TYPE__ size_t;
+extern int printf (const char *, ...);
+extern void *memset (void *, int, size_t);
+
+int bar (int (*)(), int, void *);
+
+int
+main(int argc, char **argv)
+{
+  struct s { int a; char b[argc]; };
+  int nested (struct s x) { return x.a + sizeof(x); }
+  struct s t;
+  memset (&t, 0, sizeof(t));
+  t.a = 123;
+  printf("%d\n", bar (nested, argc, &t));
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34457-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34457-2.c
new file mode 100644
index 000000000..8e251d3ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34457-2.c
@@ -0,0 +1,3 @@
+/* Additional file for PR c/34457.  */
+
+int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34668-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34668-1.c
new file mode 100644
index 000000000..5763bb610
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34668-1.c
@@ -0,0 +1,19 @@
+/* PR c/34668 */
+/* { dg-do compile } */
+/* { dg-options "--combine -O2" } */
+/* { dg-additional-sources "pr34668-2.c" } */
+
+struct optab { unsigned code; };
+extern struct optab optab_table[1];
+
+void
+init_optab (struct optab *op)
+{
+  op->code = 0xdead;
+}
+
+void
+set_conv_libfunc (void)
+{
+  init_optab (&optab_table[0]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34668-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34668-2.c
new file mode 100644
index 000000000..fab8f173f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34668-2.c
@@ -0,0 +1,5 @@
+/* PR c/34668 */
+/* { dg-do compile } */
+
+struct optab { unsigned code; };
+extern struct optab optab_table[1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34825.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34825.c
new file mode 100644
index 000000000..40061bad6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34825.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O -funsafe-math-optimizations" } */
+
+double foo(double x, double y)
+{
+  return x == y ? x/y*x/y : 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34856.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34856.c
new file mode 100644
index 000000000..6bfc70477
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34856.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -msse2" { target { i?86-*-* x86_64-*-* } } } */
+/* { dg-options "-O2 -maltivec" { target { powerpc*-*-linux* && powerpc_altivec_ok } } } */
+
+typedef unsigned __attribute__ ((__mode__ (__pointer__))) uintptr_t;
+
+#undef __vector
+#define __vector __attribute__ ((__vector_size__ (16)))
+
+typedef __vector signed char qword;
+typedef __vector uintptr_t VU;
+
+extern short g[192 + 16];
+
+void f (qword);
+
+void f1 (unsigned ctr)
+{
+  VU pin;
+
+  pin = (VU){(uintptr_t) &g[16]};
+  do
+    {
+      f ((qword) pin);
+      ctr--;
+    }
+  while (ctr);
+}
+
+/* Ignore a warning that is irrelevant to the purpose of this test.  */
+/* { dg-prune-output ".*GCC vector passed by reference.*" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34965.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34965.c
new file mode 100644
index 000000000..381e46fae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34965.c
@@ -0,0 +1,13 @@
+/* PR c++/34965 */
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+int foo (int);
+
+void
+bar (int i, int j, double k)
+{
+  foo (i && j) ();	/* { dg-error "\\(i != 0 \\&\\& j != 0\\)" } */
+  foo (!i || !j) ();	/* { dg-error "\\(i == 0 \\|\\| j == 0\\)" } */
+  foo (!i == !j) ();	/* { dg-error "\\(i != 0 \\^ j == 0\\)" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34969.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34969.c
new file mode 100644
index 000000000..02f7dd1aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34969.c
@@ -0,0 +1,15 @@
+/* PR middle-end/34969 */
+/* { dg-do compile } */
+/* { dg-options "-O -fipa-cp -ffast-math" } */
+
+double
+foo (double x)
+{
+  return x * x;
+}
+
+double
+bar (void)
+{
+  return foo (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34985.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34985.c
new file mode 100644
index 000000000..56437509d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34985.c
@@ -0,0 +1,9 @@
+/* PR34985: Warning "defined but not used" despite __attribute__((__used__)) */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Wextra -O2" } */
+static void xxyyzz (void);
+static void __attribute__((__used__)) xxyyzz(void)
+{
+}
+
+/* { dg-final { scan-assembler "xxyyzz" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34989-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34989-1.c
new file mode 100644
index 000000000..88e8d64c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34989-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "--combine -O2" } */
+/* { dg-additional-sources "pr34989-2.c" } */
+
+extern struct globals *const ptr_to_globals;
+struct globals { };
+int syslogd_main(int argc, char **argv)
+{
+ (*(struct globals**)&ptr_to_globals) = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34989-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34989-2.c
new file mode 100644
index 000000000..c2c719dc0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr34989-2.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+
+extern struct globals *const ptr_to_globals;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35045.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35045.c
new file mode 100644
index 000000000..0b2b2090a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35045.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-skip-if "" { { i?86-*-* x86_64-*-* } && { ilp32 && { ! nonpic } } } { "*" } { "" } } */
+/* { dg-options "-O2 -fgcse-after-reload" } */
+
+extern void abort (void);
+
+__attribute__((noinline)) __complex__ float
+give_neg1 (void)
+{
+  __complex__ float res;
+  __real__ res = -1.0;
+  __imag__ res = 1.0;
+  return res;
+}
+
+__attribute__((noinline)) __complex__ float
+mycacoshf (__complex__ float x)
+{
+  __complex__ float res;
+  res = give_neg1 ();
+
+  /* We have to use the positive branch.  */
+  if (__real__ res < 0.0)
+    {
+      unsigned a,b,c,d,e,f;
+      res = -res; 
+      asm __volatile__ ("" : "=r" (a), "=r" (b), "=r" (c), "=r" (d), "=r" (e), "=r" (f));
+    }
+  return res;
+}
+
+int main()
+{
+  __complex__ float res = mycacoshf(1.0);
+  if (__imag__ res >= 0.0)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35065.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35065.c
new file mode 100644
index 000000000..e5984ab0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35065.c
@@ -0,0 +1,228 @@
+/* PR debug/35065 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g -funroll-loops" } */
+typedef int vlc_bool_t;
+typedef __SIZE_TYPE__ size_t;
+typedef struct vlc_object_t vlc_object_t;
+typedef long long int64_t;
+#if(__SIZEOF_INT__ >= 4)
+typedef unsigned int uint32_t;
+#else
+typedef unsigned long uint32_t;
+#endif
+typedef unsigned char uint8_t;
+typedef int64_t mtime_t;
+typedef uint32_t vlc_fourcc_t;
+typedef struct module_t module_t;
+typedef struct es_format_t es_format_t;
+typedef struct decoder_t decoder_t;
+typedef struct decoder_sys_t decoder_sys_t;
+typedef struct block_t block_t;
+extern void* malloc (size_t);
+enum vlc_module_properties {
+  VLC_MODULE_CB_OPEN, VLC_MODULE_CB_CLOSE, VLC_MODULE_NAME, };
+struct es_format_t {
+  vlc_fourcc_t i_codec;
+  int i_extra;
+  void *p_extra;
+};
+struct block_t {
+  block_t *p_next;
+  uint32_t i_flags;
+  mtime_t i_pts;
+  mtime_t i_dts;
+  size_t i_buffer;
+  uint8_t *p_buffer;
+};
+block_t* block_New(void*, size_t);
+block_t *nal_get_annexeb(decoder_t *, uint8_t *, int);
+block_t *block_ChainGather (block_t *);
+static inline block_t *block_Duplicate( block_t *p_block ) {
+  block_t *p_dup = block_New( ((void *)0), p_block->i_buffer );
+  p_dup->i_dts = p_block->i_dts;
+  p_dup->i_pts = p_block->i_pts;
+}
+static inline void block_ChainAppend( block_t **pp_list, block_t *p_block ) {
+  if( *pp_list == ((void *)0) ) {
+  }
+  else {
+    block_t *p = *pp_list;
+    while( p->p_next ) p = p->p_next;
+    p->p_next = p_block;
+  }
+}
+struct decoder_t {
+  decoder_sys_t * p_sys;
+  es_format_t fmt_in;
+};
+typedef struct bs_s {
+  uint8_t *p;
+  uint8_t *p_end;
+  int i_left;
+} bs_t;
+static inline uint32_t bs_read( bs_t *s, int i_count ) {
+  static uint32_t i_mask[33] = {
+    0x00, 0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff};
+  int i_shr;
+  uint32_t i_result = 0;
+  while( i_count > 0 ) {
+    if( s->p >= s->p_end ) {
+      break;
+    }
+    if( ( i_shr = s->i_left - i_count ) >= 0 ) {
+      i_result |= ( *s->p >> i_shr )&i_mask[i_count];
+      s->i_left -= i_count;
+      {
+	s->i_left = 8;
+      }
+      return( i_result );
+    }
+    {
+      i_result |= (*s->p&i_mask[s->i_left]) << -i_shr;
+      i_count -= s->i_left;
+      s->p++;
+    }
+  }
+}
+static inline uint32_t bs_read1( bs_t *s ) {
+  if( s->p < s->p_end ) {
+    unsigned int i_result;
+    s->i_left--;
+    i_result = ( *s->p >> s->i_left )&0x01;
+    if( s->i_left == 0 ) {
+      s->p++;
+    }
+    return i_result;
+  }
+  return 0;
+}
+int Open ( vlc_object_t * );
+void Close( vlc_object_t * );
+__attribute__((visibility("default"))) int vlc_entry__0_9_0f ( module_t *p_module ) {
+  {
+    module_t *p_submodule = p_module;
+    if (vlc_module_set (p_submodule, VLC_MODULE_CB_OPEN, (void *)(Open)) || vlc_module_set (p_submodule, VLC_MODULE_CB_CLOSE, (void *)(Close))) goto error;
+  }
+ error:
+  return -666;
+}
+typedef struct {
+  int i_nal_type;
+  int i_nal_ref_idc;
+  int i_frame_type;
+  int i_frame_num;
+  int i_bottom_field_flag;
+  int i_idr_pic_id;
+  int i_delta_pic_order_cnt0;
+} slice_t;
+struct decoder_sys_t {
+  vlc_bool_t b_slice;
+  block_t *p_frame;
+  vlc_bool_t b_sps;
+  vlc_bool_t b_pps;
+  vlc_bool_t b_header;
+  block_t *p_sps;
+  block_t *p_pps;
+  int i_pic_order_cnt_type;
+  slice_t slice;
+};
+enum { NAL_SLICE = 1, NAL_SLICE_IDR = 5, NAL_SPS = 7, NAL_AU_DELIMITER= 9 };
+static block_t *ParseNALBlock( decoder_t *, block_t * );
+int Open( vlc_object_t *p_this ) {
+  decoder_t *p_dec = (decoder_t*)p_this;
+  decoder_sys_t *p_sys;
+  if( p_dec->fmt_in.i_codec != ( ((uint32_t)'h') | ( ((uint32_t)'2') << 8 ) | ( ((uint32_t)'6') << 16 ) | ( ((uint32_t)'4') << 24 ) ) && ( p_dec->fmt_in.i_codec != ( ((uint32_t)'a') | ( ((uint32_t)'v') << 8 ) | ( ((uint32_t)'c') << 16 ) | ( ((uint32_t)'1') << 24 ) ) || p_dec->fmt_in.i_extra < 7 ) ) {
+    return -666;
+  }
+  if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == ((void *)0) ) {
+    uint8_t *p = &((uint8_t*)p_dec->fmt_in.p_extra)[4];
+    int i_sps, i_pps;
+    int i;
+    i_sps = (*p++)&0x1f;
+    for( i = 0;
+	 i < i_sps;
+	 i++ ) {
+      int i_length = U16_AT( p );
+      block_t *p_sps = nal_get_annexeb( p_dec, p + 2, i_length );
+      ParseNALBlock( p_dec, p_sps );
+    }
+  }
+}
+static inline int bs_read_ue( bs_t *s ) {
+  int i = 0;
+  while( bs_read1( s ) == 0 && s->p < s->p_end && i < 32 ) {
+    i++;
+  }
+  return( ( 1 << i) - 1 + bs_read( s, i ) );
+}
+static inline int bs_read_se( bs_t *s ) {
+  int val = bs_read_ue( s );
+}
+block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
+{
+  decoder_sys_t *p_sys = p_dec->p_sys;
+  block_t *p_pic = ((void *)0);
+  const int i_nal_type = p_frag->p_buffer[4]&0x1f;
+  if( ( !p_sys->b_sps || !p_sys->b_pps ) && i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR ) {
+  }
+  else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR ) {
+    int i_dec = 0, i_first_mb, i_slice_type;
+    slice_t slice;
+    bs_t s;
+    i_first_mb = bs_read_ue( &s );
+    switch( (i_slice_type = bs_read_ue( &s )) ) {
+    }
+    if( p_sys->i_pic_order_cnt_type == 0 ) {
+      slice.i_delta_pic_order_cnt0 = bs_read_se( &s );
+    }
+    if( slice.i_frame_num != p_sys->slice.i_frame_num
+	|| slice.i_nal_ref_idc != p_sys->slice.i_nal_ref_idc )
+      if( (slice.i_bottom_field_flag != -1)
+	  && (slice.i_bottom_field_flag != p_sys->slice.i_bottom_field_flag) )
+	if( p_sys->i_pic_order_cnt_type == 0 && ( slice.i_nal_type != p_sys->slice.i_nal_type || slice.i_idr_pic_id != p_sys->slice.i_idr_pic_id ) )
+	  do {
+	    if( !p_sys->b_header && p_sys->slice.i_frame_type != 0x0002)
+	      break;
+	    if( p_sys->slice.i_frame_type == 0x0002 && p_sys->p_sps && p_sys->p_pps ) {
+	      block_t *p_sps = block_Duplicate( p_sys->p_sps );
+	      block_t *p_pps = block_Duplicate( p_sys->p_pps );
+	      p_sps->i_pts = p_sys->p_frame->i_pts;
+	      block_ChainAppend( &p_sps, p_pps );
+	      block_ChainAppend( &p_sps, p_sys->p_frame );
+	      p_sys->b_header = 1;
+	      p_pic = block_ChainGather( p_sps );
+	    }
+	  } while(0);
+  }
+  else if( i_nal_type == NAL_SPS ) {
+    bs_t s;
+    if( p_sys->i_pic_order_cnt_type == 0 ) {
+    }
+    else if( p_sys->i_pic_order_cnt_type == 1 ) {
+      int i_cycle;
+      i_cycle = bs_read_ue( &s );
+      while( i_cycle > 0 ) {
+	bs_read_se(&s );
+      }
+    }
+    bs_read_ue( &s );
+    if( p_sys->b_slice )
+      do {
+	if( !p_sys->b_header && p_sys->slice.i_frame_type != 0x0002)
+	  break;
+	if( p_sys->slice.i_frame_type == 0x0002
+	    && p_sys->p_sps && p_sys->p_pps )
+	  {
+	    block_t *p_sps = block_Duplicate( p_sys->p_sps );
+	    block_t *p_pps = block_Duplicate( p_sys->p_pps );
+	    p_sps->i_dts = p_sys->p_frame->i_dts;
+	    p_sps->i_pts = p_sys->p_frame->i_pts;
+	    block_ChainAppend( &p_sps, p_pps );
+	    block_ChainAppend( &p_sps, p_sys->p_frame );
+	    p_pic = block_ChainGather( p_sps );
+	  }
+	p_pic->i_flags |= p_sys->slice.i_frame_type;
+      } while(0);
+  }
+  block_ChainAppend( &p_sys->p_frame, p_frag );
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35258.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35258.c
new file mode 100644
index 000000000..d1c45a79d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35258.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-O1" } */
+
+extern void *memcpy (void *, const void *, __SIZE_TYPE__);
+extern int memcmp (const void *, const void *, __SIZE_TYPE__);
+extern void abort(void);
+
+char str[9] = "1234";
+
+void
+bar (void)
+{
+  unsigned int temp;
+  char *p = &str[2];
+
+  memcpy (&temp, &str[1], 4);
+  memcpy (p, &temp, 4);
+  str[1] = '.';
+}
+
+int main()
+{
+  bar();
+  if (memcmp (str, "1.234", 5) != 0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35264.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35264.c
new file mode 100644
index 000000000..a332efc42
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35264.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-O1" } */
+extern void abort(void);
+long long __attribute__((noinline)) get(void)
+{
+  return -2;
+}
+long long __attribute__((noinline)) get(void);
+int __attribute__((noinline)) check(void)
+{
+ long long lcn;
+
+ lcn = get();
+ if (lcn >= 0 || lcn == -1)
+  return 0;
+
+ return -1;
+}
+int main()
+{
+  if (check() == 0)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35334.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35334.c
new file mode 100644
index 000000000..d4c642e34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35334.c
@@ -0,0 +1,22 @@
+/* PR c++/35334 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+/* { dg-bogus "not supported by" "" { target *-*-* } 0 } */
+
+__complex__ unsigned int i;
+int j;
+char k;
+__complex__ double l;
+double m;
+float n;
+
+void
+foo ()
+{
+  ((__complex__ int)i)();		/* { dg-error "is not a function" } */
+  ((__complex__ int)j)();		/* { dg-error "is not a function" } */
+  ((__complex__ int)k)();		/* { dg-error "is not a function" } */
+  ((__complex__ long double)l)();	/* { dg-error "is not a function" } */
+  ((__complex__ long double)m)();	/* { dg-error "is not a function" } */
+  ((__complex__ long double)n)();	/* { dg-error "is not a function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35430.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35430.c
new file mode 100644
index 000000000..ab5e4cac8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35430.c
@@ -0,0 +1,10 @@
+/* PR c/35430 */
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare" } */
+
+void
+foo (__complex__ int i)
+{
+  i == 0u;
+  i == ~1u;	/* { dg-warning "comparison between signed and unsigned integer expressions" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35440.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35440.c
new file mode 100644
index 000000000..796d7e0a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35440.c
@@ -0,0 +1,12 @@
+/* PR c/35440 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+struct A {};
+struct B { int i; char j[2]; };
+
+void foo (void)
+{
+  (struct A){}();			/* { dg-error "called object" } */
+  (struct B){ .i = 2, .j[1] = 1 }();	/* { dg-error "called object" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35442.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35442.c
new file mode 100644
index 000000000..2bf5ce678
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35442.c
@@ -0,0 +1,14 @@
+/* PR c/35442 */
+/* { dg-bogus "not supported by" "" { target *-*-* } 0 } */
+
+typedef char A __attribute__ ((vector_size (64)));
+typedef int B __attribute__ ((vector_size (64)));
+
+void
+foo (A a)
+{
+  ((B) a) ();	/* { dg-error "is not a function" } */
+}
+
+/* Ignore a warning that is irrelevant to the purpose of this test.  */
+/* { dg-prune-output ".*GCC vector passed by reference.*" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35443.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35443.c
new file mode 100644
index 000000000..5dfc299e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35443.c
@@ -0,0 +1,9 @@
+/* PR c/35443 */
+/* { dg-options "" } */
+/* { dg-bogus "not supported by" "" { target *-*-* } 0 } */
+
+void
+foo ()
+{
+  ({ int i; i; })();	/* { dg-error "is not a function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35468.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35468.c
new file mode 100644
index 000000000..085c07307
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35468.c
@@ -0,0 +1,10 @@
+/* PR tree-optimization/35468 */
+/* { dg-do compile  }*/
+/* { dg-options "-O2 -fno-tree-dce" } */
+
+char *const f(void)
+{
+  char *const line = "/dev/ptyXX";
+  line[8] = 1;
+  return line;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35616.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35616.c
new file mode 100644
index 000000000..ad2c9e99e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35616.c
@@ -0,0 +1,43 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+typedef void (*listener_fun)(
+        int a,
+        int b,
+        int c);
+
+struct data_t
+{
+  int a;
+
+  listener_fun listener;
+
+  int b;
+  int c;
+  int d;
+};
+
+extern void abort(void);
+void function_calling_listener (struct data_t data);
+
+void function_calling_listener (struct data_t data)
+{
+  data.listener(data.a, data.c, data.d);
+}
+
+void my_listener(int a, int b, int c)
+{
+  if (a != 42 || b != 44 || c != 45)
+    abort ();
+}
+
+int main()
+{
+  struct data_t d;
+  d.a = 42;
+  d.b = 43;
+  d.c = 44;
+  d.d = 45;
+  d.listener = my_listener;
+  function_calling_listener (d);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35635.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35635.c
new file mode 100644
index 000000000..45d10a67b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35635.c
@@ -0,0 +1,90 @@
+/* PR 35635 */
+/* { dg-do compile } */
+/* { dg-options "-Wconversion -Wsign-conversion" } */
+
+struct unsigned_bit {
+  unsigned int x:1;
+} unsigned_bit;
+struct signed_bit {
+  int x:1;
+} signed_bit;
+int bar;
+int bar2;
+
+void func1()
+{
+  /* The result of boolean operators fits in unsiged int:1, thus do
+     not warn.  */
+  unsigned_bit.x = (bar != 0); /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar == 0); /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar <= 0); /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar >= 0); /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar < 0);  /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar > 0);  /* { dg-bogus "conversion" } */
+  unsigned_bit.x = !bar;       /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar || bar2); /* { dg-bogus "conversion" } */
+  unsigned_bit.x = (bar && bar2); /* { dg-bogus "conversion" } */
+
+  /* Both branches of ? fit in the destination, thus do not warn.  */
+  unsigned_bit.x = bar != 0 ? 1 : 0; /* { dg-bogus "conversion" } */
+  unsigned_bit.x = bar != 0 ? 1.0 : 0.0;  /* { dg-bogus "conversion" } */
+
+  /* At least one branch of ? does not fit in the destination, thus
+     warn.  */
+  unsigned_bit.x = bar != 0 ? 2 : 0; /* { dg-warning "conversion" } */
+  unsigned_bit.x = bar != 0 ? 0 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+}
+
+void func2()
+{
+  signed char schar_x;
+
+  /* Both branches of ? fit in the destination, thus do not warn.  */
+  schar_x = bar != 0 ? 1 : 0; /* { dg-bogus "conversion" } */
+  schar_x = bar != 0 ? 2.0 : 10; /* { dg-bogus "conversion" } */
+
+  /* At least one branch of ? does not fit in the destination, thus
+     warn.  */
+  schar_x = bar != 0 ? 2.1 : 10; /* { dg-warning "conversion" } */
+  schar_x = bar != 0 ? (signed char) 1024: -1024; /* { dg-warning "conversion" } */
+}
+
+
+
+void func3()
+{
+  unsigned char uchar_x;
+
+  /* Both branches of ? fit in the destination, thus do not warn.  */
+  uchar_x = bar != 0 ? 1 : 0;
+  uchar_x = bar != 0 ? 2.0 : 10;
+
+  /* At least one branch of ? does not fit in the destination, thus
+     warn.  */
+  uchar_x = bar != 0 ? 2.1 : 10; /* { dg-warning "conversion" } */
+  uchar_x = bar != 0 
+    ? (unsigned char) 1024 
+    : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+}
+
+void func4()
+{
+  signed_bit.x = -1; /* { dg-bogus "conversion" } */
+  signed_bit.x = bar != 0 ? -1.0 : 0.0;  /* { dg-bogus "conversion" } */
+  signed_bit.x = bar != 0 ? -1 : 0; /* { dg-bogus "conversion" } */
+
+  
+  signed_bit.x = 1;          /* { dg-warning "conversion" } */
+  signed_bit.x = (bar != 0); /* { dg-warning "conversion" } */
+  signed_bit.x = (bar == 0); /* { dg-warning "conversion" } */
+  signed_bit.x = (bar <= 0); /* { dg-warning "conversion" } */
+  signed_bit.x = (bar >= 0); /* { dg-warning "conversion" } */
+  signed_bit.x = (bar < 0);  /* { dg-warning "conversion" } */
+  signed_bit.x = (bar > 0);  /* { dg-warning "conversion" } */
+  signed_bit.x = !bar;       /* { dg-warning "conversion" } */
+  signed_bit.x = (bar || bar2); /* { dg-warning "conversion" } */
+  signed_bit.x = (bar && bar2); /* { dg-warning "conversion" } */
+  signed_bit.x = bar != 0 ? 1 : 0; /* { dg-warning "conversion" } */
+  signed_bit.x = bar != 0 ? 2 : 0; /* { dg-warning "conversion" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35701.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35701.c
new file mode 100644
index 000000000..414443097
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35701.c
@@ -0,0 +1,31 @@
+/* PR 35701 */
+/* { dg-do compile } */
+/* { dg-options "-Wconversion -Wsign-conversion" } */
+/* { dg-require-effective-target int32plus } */
+
+typedef struct _my_struct_t {
+  unsigned int small:1;
+  unsigned int big:31;
+} my_struct_t, *my_struct_p_t;
+
+void
+my_func1(unsigned int sm, unsigned int bi, my_struct_p_t msp)
+{
+  msp->small = sm; /* { dg-warning "conversion" } */
+  msp->big = bi; /* { dg-warning "conversion" } */
+}
+
+void
+my_func2(unsigned int sm, unsigned int bi, my_struct_p_t msp)
+{
+  msp->small = sm & 1U;
+  msp->big = bi & 0x7fffffffU;
+}
+
+unsigned short
+my_func3(unsigned int sm)
+{
+  unsigned short res;
+  res = sm & 0xff20U;
+  return res;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35729.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35729.c
new file mode 100644
index 000000000..a9cf2e105
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35729.c
@@ -0,0 +1,18 @@
+/* Target is restricted to x86 type architectures, so that we may
+   assume something about memory addressing modes.  */
+
+/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && nonpic } } } */
+/* { dg-options "-Os -fdump-rtl-loop2_invariant" } */
+
+const volatile int g_361 = 3L;
+volatile int g_2 = 0L;
+void func_1 (void)
+{
+  for (g_2 = 0; g_2 > 10; g_2++)
+    {
+      int l_357 = g_361;
+    }
+}
+
+/* { dg-final { scan-rtl-dump-times "Decided to move invariant" 0 "loop2_invariant" } } */
+/* { dg-final { cleanup-rtl-dump "loop2_invariant" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35736.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35736.c
new file mode 100644
index 000000000..f411bb8a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35736.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+void foo()
+{
+  while (1)
+    for (;;({ continue; }))
+      ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35742.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35742.c
new file mode 100644
index 000000000..609472792
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35742.c
@@ -0,0 +1,13 @@
+/* PR c/35742 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+/* { dg-bogus "not supported by" "" { target *-*-* } 0 } */
+
+void
+foo ()
+{
+  for (;;)
+    ({break;})();	/* { dg-error "is not a function" } */
+  for (;;)
+    ({continue;})();	/* { dg-error "is not a function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35746.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35746.c
new file mode 100644
index 000000000..e8bebf922
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35746.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int foo(int i);
+
+void bar()
+{
+  __complex__ int i;
+  X j;			/* { dg-error "undeclared.*appears.*expected" } */
+
+  if (i = foo(j))	/* { dg-error "undeclared" } */
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35899.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35899.c
new file mode 100644
index 000000000..4ce4ac589
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr35899.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/35899 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+int
+foo (void)
+{
+  int a = bar ();	/* { dg-message "note: previous implicit declaration" } */
+  return a;
+}
+
+void
+bar (void)		/* { dg-warning "conflicting types for" } */
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36015.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36015.c
new file mode 100644
index 000000000..456ec6ad9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36015.c
@@ -0,0 +1,22 @@
+/* PR target/36015 */
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+/* { dg-options "-O0 -mregparm=3" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+static int test ();
+
+int
+main (void)
+{
+  test (0, 1, 2, 3, 4, 5, 6, 7);
+  return 0;
+}
+
+static int
+test (int a, int b, int c, int d, int e, int f, int g, int h)
+{
+  if (a != 0 || b != 1 || c != 2 || d != 3
+      || e != 4 || f != 5 || g != 6 || h != 7)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36017.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36017.c
new file mode 100644
index 000000000..2af71e600
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36017.c
@@ -0,0 +1,29 @@
+/* PR rtl-optimization/36017 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern double sqrt (double);
+extern void abort (void);
+
+__attribute__((noinline)) double
+foo (double a)
+{
+  double b, c, d = 0.7;
+  if (a <= d)
+    b = sqrt (d * a);
+  else
+    {
+      c = (1.0 - d) * (1.0 - a);
+      b = c > 0 ? 1.0 - sqrt (c) : 1.0;
+    }
+  return b;
+}
+
+int
+main (void)
+{
+  double c = foo (0.5);
+  if (c > 0.5917)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36111.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36111.c
new file mode 100644
index 000000000..498c39e1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36111.c
@@ -0,0 +1,16 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic" } */
+
+typedef struct {
+  int lock;
+  int pad0_;
+} mutex_t;
+
+static mutex_t main_arena;
+
+void __malloc_check_init()
+{
+  for(;;)
+    __asm__ __volatile__ ("": "+m"(main_arena.lock) );
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36194.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36194.c
new file mode 100644
index 000000000..070a944e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36194.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort (void);
+
+__attribute__ ((noinline)) void
+f (int i)
+{
+#if(__SIZEOF_INT__ >= 4)
+  if (i != 0x87654321)
+#else
+  if (i != 0x4321)
+#endif
+    abort ();
+  asm ("");
+}
+
+__attribute__ ((noinline)) void
+g (long long a)
+{
+  f (a);
+  asm ("");
+}
+
+main ()
+{
+  g (0x1234567887654321ll);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36224.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36224.c
new file mode 100644
index 000000000..6e23559d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36224.c
@@ -0,0 +1,249 @@
+/* { dg-do run } */
+/* { dg-require-effective-target lp64 } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+#ifndef ALIGN16
+#define ALIGN16 __attribute__((__aligned__(32)))
+#endif
+
+#define I16_B0	1
+#define I16_B1	23
+#define I16_B2	345
+#define I16_B3	6789
+#define I16_B4	1011
+#define I16_B5	-12
+#define I16_B6	1314
+#define I16_B7	-1516
+#define I16_B8	-1516
+#define I16_B9	1314
+#define I16_B10	-12
+#define I16_B11	1011
+#define I16_B12	6789
+#define I16_B13	345
+#define I16_B14	23
+#define I16_B15	1
+
+#define I16_C0	2
+#define I16_C1	31567
+#define I16_C2	1112
+#define I16_C3	13
+#define I16_C4	14
+#define I16_C5	15
+#define I16_C6	-16
+#define I16_C7	17
+#define I16_C8	2
+#define I16_C9	31567
+#define I16_C10	1112
+#define I16_C11	13
+#define I16_C12	14
+#define I16_C13	15
+#define I16_C14	-16
+#define I16_C15	17
+
+union ui2 {
+  int		si[16];
+  unsigned int	ui[16];
+};
+
+union us {
+  short		 ss[16];
+  unsigned short us[16];
+};
+
+static union ui2 i32_sa ALIGN16;
+static union ui2 i32_ua ALIGN16;
+
+static union us i16_b ALIGN16 = {
+  (short)I16_B0,
+  (short)I16_B1,
+  (short)I16_B2,
+  (short)I16_B3,
+  (short)I16_B4,
+  (short)I16_B5,
+  (short)I16_B6,
+  (short)I16_B7,
+  (short)I16_B8,
+  (short)I16_B9,
+  (short)I16_B10,
+  (short)I16_B11,
+  (short)I16_B12,
+  (short)I16_B13,
+  (short)I16_B14,
+  (short)I16_B15,
+};
+
+static union us i16_c ALIGN16 = {
+  (short)I16_C0,
+  (short)I16_C1,
+  (short)I16_C2,
+  (short)I16_C3,
+  (short)I16_C4,
+  (short)I16_C5,
+  (short)I16_C6,
+  (short)I16_C7,
+  (short)I16_C8,
+  (short)I16_C9,
+  (short)I16_C10,
+  (short)I16_C11,
+  (short)I16_C12,
+  (short)I16_C13,
+  (short)I16_C14,
+  (short)I16_C15,
+};
+
+static long i32_sr[16] ALIGN16 = {
+  ((int)I16_B0)  * ((int)I16_C0),
+  ((int)I16_B1)  * ((int)I16_C1),
+  ((int)I16_B2)  * ((int)I16_C2),
+  ((int)I16_B3)  * ((int)I16_C3),
+  ((int)I16_B4)  * ((int)I16_C4),
+  ((int)I16_B5)  * ((int)I16_C5),
+  ((int)I16_B6)  * ((int)I16_C6),
+  ((int)I16_B7)  * ((int)I16_C7),
+  ((int)I16_B8)  * ((int)I16_C8),
+  ((int)I16_B9)  * ((int)I16_C9),
+  ((int)I16_B10) * ((int)I16_C10),
+  ((int)I16_B11) * ((int)I16_C11),
+  ((int)I16_B12) * ((int)I16_C12),
+  ((int)I16_B13) * ((int)I16_C13),
+  ((int)I16_B14) * ((int)I16_C14),
+  ((int)I16_B15) * ((int)I16_C15),
+};
+
+static unsigned long i32_ur[16] ALIGN16 = {
+  ((unsigned int)(unsigned short)I16_B0)  * ((unsigned int)(unsigned short)I16_C0),
+  ((unsigned int)(unsigned short)I16_B1)  * ((unsigned int)(unsigned short)I16_C1),
+  ((unsigned int)(unsigned short)I16_B2)  * ((unsigned int)(unsigned short)I16_C2),
+  ((unsigned int)(unsigned short)I16_B3)  * ((unsigned int)(unsigned short)I16_C3),
+  ((unsigned int)(unsigned short)I16_B4)  * ((unsigned int)(unsigned short)I16_C4),
+  ((unsigned int)(unsigned short)I16_B5)  * ((unsigned int)(unsigned short)I16_C5),
+  ((unsigned int)(unsigned short)I16_B6)  * ((unsigned int)(unsigned short)I16_C6),
+  ((unsigned int)(unsigned short)I16_B7)  * ((unsigned int)(unsigned short)I16_C7),
+  ((unsigned int)(unsigned short)I16_B8)  * ((unsigned int)(unsigned short)I16_C8),
+  ((unsigned int)(unsigned short)I16_B9)  * ((unsigned int)(unsigned short)I16_C9),
+  ((unsigned int)(unsigned short)I16_B10) * ((unsigned int)(unsigned short)I16_C10),
+  ((unsigned int)(unsigned short)I16_B11) * ((unsigned int)(unsigned short)I16_C11),
+  ((unsigned int)(unsigned short)I16_B12) * ((unsigned int)(unsigned short)I16_C12),
+  ((unsigned int)(unsigned short)I16_B13) * ((unsigned int)(unsigned short)I16_C13),
+  ((unsigned int)(unsigned short)I16_B14) * ((unsigned int)(unsigned short)I16_C14),
+  ((unsigned int)(unsigned short)I16_B15) * ((unsigned int)(unsigned short)I16_C15),
+};
+
+#ifndef ALIGN32
+#define ALIGN32 __attribute__((__aligned__(32)))
+#endif
+
+#define I32_B0	1
+#define I32_B1	23
+#define I32_B2	345
+#define I32_B3	6789
+#define I32_B4	101112
+#define I32_B5	-13
+#define I32_B6	141516
+#define I32_B7	-1718
+
+#define I32_C0	2
+#define I32_C1	45678910
+#define I32_C2	1112
+#define I32_C3	13
+#define I32_C4	14
+#define I32_C5	15
+#define I32_C6	-16
+#define I32_C7	17
+
+union ul {
+  long		sl[8];
+  unsigned long	ul[8];
+};
+
+union ui {
+  int		si[8];
+  unsigned int	ui[8];
+};
+
+static union ul i64_sa ALIGN32;
+static union ul i64_ua ALIGN32;
+
+static union ui i32_b ALIGN32 = {
+  (int)I32_B0,
+  (int)I32_B1,
+  (int)I32_B2,
+  (int)I32_B3,
+  (int)I32_B4,
+  (int)I32_B5,
+  (int)I32_B6,
+  (int)I32_B7,
+};
+
+static union ui i32_c ALIGN32 = {
+  (int)I32_C0,
+  (int)I32_C1,
+  (int)I32_C2,
+  (int)I32_C3,
+  (int)I32_C4,
+  (int)I32_C5,
+  (int)I32_C6,
+  (int)I32_C7,
+};
+
+static long i64_sr[8] ALIGN32 = {
+  ((long)I32_B0) * ((long)I32_C0),
+  ((long)I32_B1) * ((long)I32_C1),
+  ((long)I32_B2) * ((long)I32_C2),
+  ((long)I32_B3) * ((long)I32_C3),
+  ((long)I32_B4) * ((long)I32_C4),
+  ((long)I32_B5) * ((long)I32_C5),
+  ((long)I32_B6) * ((long)I32_C6),
+  ((long)I32_B7) * ((long)I32_C7),
+};
+
+static unsigned long i64_ur[8] ALIGN32 = {
+  ((unsigned long)(unsigned)I32_B0) * ((unsigned long)(unsigned)I32_C0),
+  ((unsigned long)(unsigned)I32_B1) * ((unsigned long)(unsigned)I32_C1),
+  ((unsigned long)(unsigned)I32_B2) * ((unsigned long)(unsigned)I32_C2),
+  ((unsigned long)(unsigned)I32_B3) * ((unsigned long)(unsigned)I32_C3),
+  ((unsigned long)(unsigned)I32_B4) * ((unsigned long)(unsigned)I32_C4),
+  ((unsigned long)(unsigned)I32_B5) * ((unsigned long)(unsigned)I32_C5),
+  ((unsigned long)(unsigned)I32_B6) * ((unsigned long)(unsigned)I32_C6),
+  ((unsigned long)(unsigned)I32_B7) * ((unsigned long)(unsigned)I32_C7),
+};
+
+
+int main ()
+{
+  int i;
+
+  /* Signed 16x16 -> 32-bit tests */
+  for (i = 0; i < 16; i++)
+    i32_sa.si[i] = ((long)i16_b.ss[i]) * ((long)i16_c.ss[i]);
+
+  for (i = 0; i < 16; i++)
+    if (i32_sa.si[i] != i32_sr[i])
+      __builtin_abort ();
+
+  /* Unsigned 16x16 -> 32-bit tests */
+  for (i = 0; i < 16; i++)
+    i32_ua.ui[i] = ((long)i16_b.us[i]) * ((long)i16_c.us[i]);
+
+  for (i = 0; i < 16; i++)
+    if (i32_ua.ui[i] != i32_ur[i])
+      __builtin_abort ();
+
+  /* Signed 32x32 -> 64-bit tests */
+  for (i = 0; i < 8; i++)
+    i64_sa.sl[i] = ((long)i32_b.si[i]) * ((long)i32_c.si[i]);
+
+  for (i = 0; i < 8; i++)
+    if (i64_sa.sl[i] != i64_sr[i])
+      __builtin_abort ();
+
+  /* Unsigned 32x32 -> 64-bit tests */
+  for (i = 0; i < 8; i++)
+    i64_ua.ul[i] = ((long)i32_b.ui[i]) * ((long)i32_c.ui[i]);
+
+  for (i = 0; i < 8; i++)
+    if (i64_ua.ul[i] != i64_ur[i])
+      __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36227.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36227.c
new file mode 100644
index 000000000..27fe00155
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36227.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wstrict-overflow=3" } */
+#if (__SIZEOF_LONG_LONG__ == __SIZEOF_POINTER__)
+typedef unsigned long long ptrcast;
+#elif (__SIZEOF_LONG__ == __SIZEOF_POINTER__)
+typedef unsigned long ptrcast;
+#elif (__SIZEOF_INT__ == __SIZEOF_POINTER__)
+typedef unsigned int ptrcast;
+#else
+#error Add target support here
+#endif
+
+volatile unsigned long *
+sat_add(volatile unsigned long *ptr, unsigned long i, volatile unsigned long *end)
+{
+  if ((ptrcast)ptr + i * sizeof(*ptr) > (ptrcast)ptr) /* { dg-bogus "pointer wraparound" } */
+    return ptr + i;
+  else
+    return end;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36300-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36300-1.c
new file mode 100644
index 000000000..e737ab7ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36300-1.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fwrapv" } */
+
+extern void abort (void);
+
+#define VALUE ((int)((long long)U1 * (long long)3) + 2)
+
+int main(void)
+{
+  long long Y, Y2;
+#if(__SIZEOF_INT__ >= 4)
+  int U1;
+#else
+  long U1;
+#endif
+  int t;
+  U1 = -2147483647-1;
+
+  Y = ((long long)(VALUE * VALUE) * 3);
+
+  t = VALUE;
+  Y2 = ((long long)(t * t) * 3);
+
+  if (Y != Y2)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36300-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36300-2.c
new file mode 100644
index 000000000..954333268
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36300-2.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+#define VALUE (unsigned int)((int)((long long)U1 * (long long)3) + 2)
+
+int main(void)
+{
+  long long Y, Y2;
+#if(__SIZEOF_INT__ >= 4)
+  int U1;
+#else
+  long U1;
+#endif
+  unsigned int t;
+
+  U1 = -2147483647-1;
+
+  Y = ((long long)(int)(VALUE * VALUE) * 3);
+
+  t = VALUE;
+  Y2 = ((long long)(int)(t * t) * 3);
+
+  if (Y != Y2)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36489.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36489.c
new file mode 100644
index 000000000..5cf221615
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36489.c
@@ -0,0 +1,22 @@
+/* PR c/36489 */
+/* { dg-do compile } */
+/* { dg-options "-Woverride-init" } */
+
+struct A { int a; int b[3]; };
+union B { int a; int b[3]; };
+int t1[10][10]
+  = { [1][2] = 11, [1][3] = 12 };
+int t2[10][10]
+  = { [1][2] = 11, [1] = { [3] = 12 } };	/* { dg-warning "initializ" } */
+int t3[10][10]
+  = { [1][2] = 11, [1][2] = 12 };		/* { dg-warning "initializ" } */
+struct A t4[2]
+  = { [0].b[0] = 1, [0].b[1] = 2, [0].b[2] = 3 };
+struct A t5[2]
+  = { [0].b[0] = 1, [0].b[1] = 2, [0].b = { 3 } }; /* { dg-warning "initializ" } */
+union B t6
+  = { .b[0] = 1, .b[1] = 2, .b[2] = 3 };
+union B t7
+  = { .b[0] = 1, .b[1] = 2, .b = { 2 } };	/* { dg-warning "initializ" } */
+union B t8
+  = { .b[0] = 1, .b[1] = 2, .b[1] = 3 };	/* { dg-warning "initializ" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36504.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36504.c
new file mode 100644
index 000000000..dbcf76648
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36504.c
@@ -0,0 +1,25 @@
+/* PR tree-optimization/36504 */
+/* { dg-do compile } */
+/* { dg-options "-O3 -fprefetch-loop-arrays -w" } */
+
+struct A { struct { int a; } b[8]; };
+struct B { int c; int d; };
+struct C { struct B d; };
+
+void bar (struct C *, int);
+
+struct B
+foo (struct C *p, struct A *e, int b)
+{
+  struct B q;
+  bar (p, e->b[b].a);
+  return q;
+}
+
+void
+baz (int b, struct A *e)
+{
+  struct C p;
+  for (; b; ++b)
+    p.d = foo (&p, e, b);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36508.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36508.c
new file mode 100644
index 000000000..304899236
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36508.c
@@ -0,0 +1,29 @@
+/* PR tree-optimization/36508 */
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-pre" } */
+
+void
+foo (short *sp)
+{
+  int k;
+  k = 1;
+#define SP0 *sp++ = 1;
+  while (1)
+    {
+      if (k > 6)
+	break;
+      SP0
+      k++;
+    }
+  k = 1;
+  while (1)
+    {
+      if (k > 6)
+	break;
+      SP0
+      k++;
+    }
+#define SP1 SP0 SP0 SP0 SP0 SP0 SP0 SP0 SP0 SP0 SP0 SP0
+#define SP2 SP1 SP1 SP1 SP1 SP1 SP1 SP1 SP1 SP1 SP1 SP1
+  SP2
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36584.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36584.c
new file mode 100644
index 000000000..7d83ece33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36584.c
@@ -0,0 +1,281 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -lm" } */
+/* { dg-options "-O2 -msse2 -mfpmath=sse" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+
+#ifdef __i386__
+#include "cpuid.h"
+#endif
+
+extern double fabs (double);
+extern void abort (void);
+
+const int MAX_ITERATIONS = 50;
+const double SMALL_ENOUGH = 1.0e-10;
+const double RELERROR = 1.0e-12;
+
+typedef struct p
+{
+  int ord;
+  double coef[7];
+}
+polynomial;
+
+static double
+polyeval (double x, int n, double *Coeffs)
+{
+  register int i;
+  double val;
+
+  val = Coeffs[n];
+  for (i = n - 1; i >= 0; i--)
+    val = val * x + Coeffs[i];
+
+  return (val);
+}
+
+static int
+regula_falsa (int order, double *coef, double a, double b, double *val)
+{
+  int its;
+  double fa, fb, x, fx, lfx;
+
+  fa = polyeval (a, order, coef);
+  fb = polyeval (b, order, coef);
+
+  if (fa * fb > 0.0)
+    return 0;
+
+  if (fabs (fa) < SMALL_ENOUGH)
+    {
+      *val = a;
+      return 1;
+    }
+
+  if (fabs (fb) < SMALL_ENOUGH)
+    {
+      *val = b;
+      return 1;
+    }
+
+  lfx = fa;
+
+  for (its = 0; its < MAX_ITERATIONS; its++)
+    {
+      x = (fb * a - fa * b) / (fb - fa);
+      fx = polyeval (x, order, coef);
+      if (fabs (x) > RELERROR)
+	{
+	  if (fabs (fx / x) < RELERROR)
+	    {
+	      *val = x;
+	      return 1;
+	    }
+	}
+      else
+	{
+	  if (fabs (fx) < RELERROR)
+	    {
+	      *val = x;
+	      return 1;
+	    }
+	}
+
+      if (fa < 0)
+	{
+	  if (fx < 0)
+	    {
+	      a = x;
+	      fa = fx;
+	      if ((lfx * fx) > 0)
+		fb /= 2;
+	    }
+	  else
+	    {
+	      b = x;
+	      fb = fx;
+	      if ((lfx * fx) > 0)
+		fa /= 2;
+	    }
+	}
+      else
+	{
+	  if (fx < 0)
+	    {
+	      b = x;
+	      fb = fx;
+	      if ((lfx * fx) > 0)
+		fa /= 2;
+	    }
+	  else
+	    {
+	      a = x;
+	      fa = fx;
+	      if ((lfx * fx) > 0)
+		fb /= 2;
+	    }
+	}
+
+      if (fabs (b - a) < RELERROR)
+	{
+	  *val = x;
+	  return 1;
+	}
+
+      lfx = fx;
+    }
+
+  return 0;
+}
+
+static int
+numchanges (int np, polynomial * sseq, double a)
+{
+  int changes;
+  double f, lf;
+  polynomial *s;
+  changes = 0;
+
+  lf = polyeval (a, sseq[0].ord, sseq[0].coef);
+
+  for (s = sseq + 1; s <= sseq + np; s++)
+    {
+      f = polyeval (a, s->ord, s->coef);
+      if (lf == 0.0 || lf * f < 0)
+	changes++;
+
+      lf = f;
+    }
+
+  return changes;
+}
+
+int
+sbisect (int np, polynomial * sseq, double min_value, double max_value,
+	 int atmin, int atmax, double *roots)
+{
+  double mid;
+  int n1, n2, its, atmid;
+
+  if ((atmin - atmax) == 1)
+    {
+      if (regula_falsa (sseq->ord, sseq->coef, min_value, max_value, roots))
+	return 1;
+      else
+	{
+	  for (its = 0; its < MAX_ITERATIONS; its++)
+	    {
+	      mid = (min_value + max_value) / 2;
+	      atmid = numchanges (np, sseq, mid);
+	      if ((atmid < atmax) || (atmid > atmin))
+		return 0;
+
+	      if (fabs (mid) > RELERROR)
+		{
+		  if (fabs ((max_value - min_value) / mid) < RELERROR)
+		    {
+		      roots[0] = mid;
+		      return 1;
+		    }
+		}
+	      else
+		{
+		  if (fabs (max_value - min_value) < RELERROR)
+		    {
+		      roots[0] = mid;
+		      return 1;
+		    }
+		}
+
+	      if ((atmin - atmid) == 0)
+		min_value = mid;
+	      else
+		max_value = mid;
+	    }
+
+	  roots[0] = mid;
+	  return 1;
+	}
+    }
+
+  for (its = 0; its < MAX_ITERATIONS; its++)
+    {
+      mid = (min_value + max_value) / 2;
+      atmid = numchanges (np, sseq, mid);
+      if ((atmid < atmax) || (atmid > atmin))
+	return 0;
+
+      if (fabs (mid) > RELERROR)
+	{
+	  if (fabs ((max_value - min_value) / mid) < RELERROR)
+	    {
+	      roots[0] = mid;
+	      return 1;
+	    }
+	}
+      else
+	{
+	  if (fabs (max_value - min_value) < RELERROR)
+	    {
+	      roots[0] = mid;
+	      return 1;
+	    }
+	}
+
+      n1 = atmin - atmid;
+      n2 = atmid - atmax;
+
+      if ((n1 != 0) && (n2 != 0))
+	{
+	  n1 = sbisect (np, sseq, min_value, mid, atmin, atmid, roots);
+	  n2 = sbisect (np, sseq, mid, max_value, atmid, atmax, &roots[n1]);
+
+	  return (n1 + n2);
+	}
+
+      if (n1 == 0)
+	min_value = mid;
+      else
+	max_value = mid;
+    }
+
+  roots[0] = mid;
+  return 1;
+}
+
+int
+main ()
+{
+  polynomial sseq[7] = {
+    {6, {0.15735259075109281, -5.1185263411378736, 1.8516070705868664,
+	 7.348009172322695, -2.2152395279161343, -2.7543325329350692, 1.0}},
+    {5, {-0.8530877235229789, 0.61720235686228875, 3.6740045861613475,
+	 -1.4768263519440896, -2.2952771107792245, 1.0}},
+    {4, {0.13072124257049417, 2.2220687798791126, -1.6299431586726509,
+	 -1.6718404582408546, 1.0}},
+    {3, {0.86776597575462633, -2.1051099695282511, -0.49008580100694688,
+	 1.0}},
+    {2, {-11.117984175064155, 10.89886635045883, 1.0}},
+    {1, {0.94453099602191237, -1.0}},
+    {0, {-0.068471716890574186}}
+  };
+
+  double roots[7];
+  int nroots;
+
+#ifdef __i386__
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  if (!(edx & bit_SSE2))
+    return 0;
+#endif
+
+  nroots = sbisect (6, sseq, 0.0, 10000000.0, 5, 1, roots);
+  if (nroots != 4)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-1.c
new file mode 100644
index 000000000..63438307e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-1.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+#include "pr36901-system.h"
+void foo(void)
+{
+  int s = sc;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-2.c
new file mode 100644
index 000000000..cee367d77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -w" } */
+#include "pr36901.h"
+void foo(void)
+{
+  int s = sc;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-3.c
new file mode 100644
index 000000000..1f3574214
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-3.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+#include "pr36901.h"
+void foo(void)
+{
+  int s = sc;
+}
+/* { dg-message "file included" "In file included" { target *-*-* } 0 } */
+/* { dg-error "ordered comparison of pointer with integer zero" "pedantic error" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-4.c
new file mode 100644
index 000000000..f1d261657
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-4.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -Wsystem-headers" } */
+#include "pr36901-system.h"
+void foo(void)
+{
+  int s = sc;
+}
+/* { dg-message "from " "In file included" { target *-*-* } 0 } */
+/* { dg-error "ordered comparison of pointer with integer zero" "pedantic error" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-system.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-system.h
new file mode 100644
index 000000000..6cc1e803d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901-system.h
@@ -0,0 +1,3 @@
+#pragma GCC system_header
+#include "pr36901.h"
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901.h
new file mode 100644
index 000000000..e08d15641
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36901.h
@@ -0,0 +1,2 @@
+int sc = (&sc > 0);
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36991.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36991.c
new file mode 100644
index 000000000..d090ba105
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36991.c
@@ -0,0 +1,12 @@
+/* PR tree-optimization/36991 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef float V __attribute__ ((vector_size (16)));
+typedef union { V v[4][4]; } U;
+
+void
+foo (float x, float y, U *z)
+{
+  z->v[1][0] = z->v[0][1] = (V) { x, y, 0, 0 };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36997.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36997.c
new file mode 100644
index 000000000..1fbb8fd69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36997.c
@@ -0,0 +1,9 @@
+/* { dg-do compile { target x86_64-*-* i?86-*-* } } */
+/* { dg-options "-std=c99 -msse2" } */
+
+typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
+__m64 _mm_add_si64 (__m64 __m1, __m64 __m2)
+{
+    return (__m64) __builtin_ia32_paddq ((long long)__m1, (long long)__m2); /* { dg-error "incompatible type" } */
+    /* { dg-message "note: expected 'long long int __vector__' but argument is of type 'long long int'" "" { target *-*-* } 7 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36998.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36998.c
new file mode 100644
index 000000000..f0669b4fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr36998.c
@@ -0,0 +1,23 @@
+/* PR rtl-optimization/36998 */
+/* { dg-do compile } */
+/* { dg-options "-Os -fasynchronous-unwind-tables" } */
+/* { dg-options "-Os -mpreferred-stack-boundary=2 -fasynchronous-unwind-tables" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+void foo (const char *, ...) __attribute__ ((noreturn));
+int bar (const char *, ...);
+extern __SIZE_TYPE__ strlen (const char *);
+int baz (char *, char *, int, void *);
+
+void
+test (char *w, int x, char *y, char *z)
+{
+  char *p, b[32];
+  for (p = y; *p; p += strlen (p) + 1)
+    {
+      baz (w, p, x, z);
+      foo ("msg1 %s", b);
+    }
+  for (p = y; *p; p += strlen (p) + 1)
+    bar (" %s", p);
+  foo ("msg2 %s", b);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37106-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37106-1.c
new file mode 100644
index 000000000..ff73b0b8d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37106-1.c
@@ -0,0 +1,27 @@
+/* PR c/37106 */
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+/* { dg-options "-O1 -fpic" { target fpic } } */
+
+#define SIZE 256
+float a[SIZE], b[SIZE], c[SIZE];
+
+void opt3 (void) __attribute__((__optimize__(3)));
+
+void
+opt3 (void)
+{
+  int i;
+
+  for (i = 0; i < SIZE; i++)
+    a[i] = b[i] + c[i];
+}
+
+void
+not_opt3 (void)
+{
+  int i;
+
+  for (i = 0; i < SIZE; i++)
+    a[i] = b[i] - c[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37106-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37106-2.c
new file mode 100644
index 000000000..81f061afa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37106-2.c
@@ -0,0 +1,27 @@
+/* PR c/37106 */
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+/* { dg-options "-O3 -fpic" { target fpic } } */
+
+#define SIZE 256
+float a[SIZE], b[SIZE], c[SIZE];
+
+void non_opt3 (void) __attribute__((__optimize__(1)));
+
+void
+not_opt3 (void)
+{
+  int i;
+
+  for (i = 0; i < SIZE; i++)
+    a[i] = b[i] - c[i];
+}
+
+void
+opt3 (void)
+{
+  int i;
+
+  for (i = 0; i < SIZE; i++)
+    a[i] = b[i] + c[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37156.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37156.c
new file mode 100644
index 000000000..e86f5950f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37156.c
@@ -0,0 +1,21 @@
+/* PR debug/37156 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+__attribute__ ((warning ("is experimental"))) int bar (int, int *, int *, int);
+
+long long foo (void)
+{
+  int n, m;
+  long long r;
+  bar (0, &n, &m, 0);	/* { dg-warning "is experimental" } */
+  r = (long long) n;
+  return r;
+}
+
+void
+baz (int n)
+{
+  int o;
+  o = foo () - n;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37171.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37171.c
new file mode 100644
index 000000000..9be44dfaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37171.c
@@ -0,0 +1,19 @@
+/* PR c/37171 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+unsigned int f1 (void) __attribute__((const));
+unsigned int f2 (void) __attribute__((__const));
+unsigned int f3 (void) __attribute__((__const__));
+
+unsigned int f4 (void)
+{
+  return f1 () + f1 () + f1 () + f1 ()
+	 + f2 () + f2 () + f2 () + f2 ()
+	 + f3 () + f3 () + f3 () + f3 ();
+}
+
+/* { dg-final { scan-tree-dump-times "= f1 \\(\\)" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "= f2 \\(\\)" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "= f3 \\(\\)" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37186.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37186.c
new file mode 100644
index 000000000..bf37757f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37186.c
@@ -0,0 +1,9 @@
+/* PR 37186 */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Werror -Wno-error=pointer-sign" } */
+
+int foo(signed char *); /* { dg-message "note: expected 'signed char \\*' but argument is of type 'unsigned char \\*'" } */
+int bar(unsigned char *p)
+{
+  return foo(p); /* { dg-warning "pointer targets in passing argument 1 of 'foo' differ in signedness" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37217.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37217.c
new file mode 100644
index 000000000..989eda2cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37217.c
@@ -0,0 +1,10 @@
+/* PR 37217 ICE with -Wconversion */
+/* { dg-do compile } */
+/* { dg-options "-Wconversion" } */
+typedef struct Tcl_ResolvedVarInfo {
+  char *re_guts;
+} regex_t;
+void TclReComp(regex_t *re)
+{
+  if (re->re_guts == ((void *)0)) ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37261.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37261.c
new file mode 100644
index 000000000..a05ada148
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37261.c
@@ -0,0 +1,15 @@
+/* PR c/37261 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+unsigned
+foo (int x)
+{
+  unsigned a = ((x & 1) | 2) & 0x80000000;	/* { dg-bogus "integer overflow in expression" } */
+  unsigned b = ((x & 2) | 2) & 0x80000000;	/* { dg-bogus "integer overflow in expression" } */
+  unsigned c = ((x & 4) | 2) & 0x80000000;	/* { dg-bogus "integer overflow in expression" } */
+  return a + b + c;
+}
+
+/* { dg-final { scan-tree-dump "return 0" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37289.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37289.c
new file mode 100644
index 000000000..61513c94e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37289.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+void f(unsigned long x);
+
+void g(long x)
+{
+  f((unsigned long)(-1-x)+1);
+}
+
+/* Make sure we do not lose the conversion.  */
+
+/* { dg-final { scan-tree-dump "-\\\(long unsigned int\\\) x" "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37353.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37353.c
new file mode 100644
index 000000000..07d73d0eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37353.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/37353 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern double exp (double);
+
+#define A exp (arg);
+#define B A A A A A A A A A A
+#define C B B B B B B B B B B
+
+void
+foo (double arg)
+{
+  C
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37438.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37438.c
new file mode 100644
index 000000000..a6e366dc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37438.c
@@ -0,0 +1,21 @@
+/* PR target/37438 */
+/* { dg-do compile } */
+/* { dg-options "-Os" } */
+/* { dg-options "-Os -march=i486" { target { { i686-*-* x86_64-*-* } && ilp32 } } } */
+
+extern int bar (unsigned long long int);
+extern int baz (const char *, unsigned int, unsigned short);
+
+int
+foo (unsigned long long int x)
+{
+  return (x & 0xff) | ((unsigned int) (x >> 12) & ~0xff);
+}
+
+int
+test (const char *v, unsigned int w, unsigned long long int x)
+{
+  unsigned short k;
+  k = ((bar (x) & 0xff) << 8) | (foo (x) & 0xff);
+  return baz (v, w, k);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37529.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37529.c
new file mode 100644
index 000000000..87361d5c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37529.c
@@ -0,0 +1,9 @@
+/* PR c/37529 */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+
+void
+foo ()
+{
+  goto *;	/* { dg-error "expected expression before" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37544.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37544.c
new file mode 100644
index 000000000..6393d2f89
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37544.c
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -msse2 -mtune=core2 -mfpmath=387" { target { i?86-*-* x86_64-*-* } } } */
+
+#ifdef __i386__
+#include "cpuid.h"
+#endif
+
+extern void abort (void);
+
+int main(void)
+{
+  double arr[1000];
+  double a, b;
+
+  int i;
+
+#ifdef __i386__
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (!(edx & bit_SSE2))
+    return 0;
+#endif
+
+  for (i = 0; i < 1000; i++)
+    arr[i] = 4294967296.0 + (double)i;
+
+  a = arr[0];
+  b = (unsigned int)((unsigned long long int)a % 4294967296ULL);
+
+  if (b >= 4294967296.0)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37561.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37561.c
new file mode 100644
index 000000000..82eca9640
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37561.c
@@ -0,0 +1,23 @@
+/* PR c++/37561 */
+/* { dg-do compile } */
+
+__PTRDIFF_TYPE__ p;
+char q;
+
+void
+foo ()
+{
+  ((char *) p)++;	/* { dg-error "lvalue" } */
+  ((char *) q)++;	/* { dg-error "lvalue" } */
+  ((char *) p)--;	/* { dg-error "lvalue" } */
+  ((char *) q)--;	/* { dg-error "lvalue" } */
+  ++(char *) p;		/* { dg-error "lvalue" } */
+  ++(char *) q;		/* { dg-error "lvalue" } */
+  --(char *) p;		/* { dg-error "lvalue" } */
+  --(char *) q;		/* { dg-error "lvalue" } */
+}
+
+/* { dg-warning "cast to pointer from integer of different size" "" { target *-*-* } 11 } */
+/* { dg-warning "cast to pointer from integer of different size" "" { target *-*-* } 13 } */
+/* { dg-warning "cast to pointer from integer of different size" "" { target *-*-* } 15 } */
+/* { dg-warning "cast to pointer from integer of different size" "" { target *-*-* } 17 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37645.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37645.c
new file mode 100644
index 000000000..ac1e5a9d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37645.c
@@ -0,0 +1,5 @@
+/* PR c/37645 */
+/* { dg-do compile } */
+
+typedef int T __attribute__((__weakref__ ("U")));	/* { dg-warning "attribute ignored" } */
+void foo (int i __attribute__((__weakref__ ("j"))));	/* { dg-warning "attribute ignored" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37663.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37663.c
new file mode 100644
index 000000000..cf482cbdc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37663.c
@@ -0,0 +1,16 @@
+/* PR tree-optimization/37663 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fwrapv" } */
+/* { dg-require-effective-target int32plus } */
+
+extern void bar (void);
+
+void
+foo (int x)
+{
+  x = 1 >= x;
+  int y = -1885403717;
+  x = x + (x != y * y);
+  if (x)
+    bar ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37772.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37772.c
new file mode 100644
index 000000000..26051c7e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37772.c
@@ -0,0 +1,20 @@
+/* PR c/37772 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+foo ()
+{
+  int i;
+  asm ();		  /* { dg-error "expected string literal before" } */
+  asm (1);		  /* { dg-error "expected string literal before" } */
+  asm (int);		  /* { dg-error "expected string literal before" } */
+  asm (: "=r" (i));	  /* { dg-error "expected string literal before" } */
+  asm (1 : "=r" (i));	  /* { dg-error "expected string literal before" } */
+  asm (int : "=r" (i));	  /* { dg-error "expected string literal before" } */
+  asm (: : "r" (i));	  /* { dg-error "expected string literal before" } */
+  asm (1 : : "r" (i));	  /* { dg-error "expected string literal before" } */
+  asm (int : : "r" (i));  /* { dg-error "expected string literal before" } */
+  asm (: : : "memory");	  /* { dg-error "expected string literal before" } */
+  asm (1 : : : "memory"); /* { dg-error "expected string literal before" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37858.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37858.c
new file mode 100644
index 000000000..4a827eebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37858.c
@@ -0,0 +1,11 @@
+/* PR middle-end/37858 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-ipa-early_local_cleanups -dv" } */
+
+int
+main (void)
+{
+  return 0;
+}
+
+/* { dg-final { cleanup-ipa-dump "early_local_cleanups" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37879.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37879.c
new file mode 100644
index 000000000..5dd252782
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37879.c
@@ -0,0 +1,28 @@
+/* PR tree-optimization/37879 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+static inline void bar (int) __attribute__ ((noreturn));
+void baz () __attribute__ ((noreturn));
+
+inline int
+foo (int i)
+{
+  return i;
+}
+
+int i = 23;
+static inline void
+bar (int j)
+{
+  if (j)
+    asm ("");
+}		/* { dg-warning "does return" } */
+
+void
+baz ()
+{
+  int j;
+  bar (foo (j = i++));
+  asm ("");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37908.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37908.c
new file mode 100644
index 000000000..d9278075e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr37908.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_char_short } */
+/* { dg-options "-Wsync-nand" } */
+/* { dg-options "-Wsync-nand -march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-Wsync-nand -mcpu=v9" { target sparc*-*-* } } */
+
+
+extern void abort (void);
+
+int main (void)
+{
+
+  short xLoc;
+  short xIn, xOut, xExpect, i = 1;
+
+  xLoc = xIn = ~ (1 << i);
+  xExpect = ~ (xIn & 0x7F);
+
+  xOut = __sync_nand_and_fetch (&xLoc, 0x7F); /* { dg-message "note: '__sync_nand_and_fetch' changed semantics in GCC 4.4" "" } */
+
+  if (xOut != xExpect)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38140.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38140.c
new file mode 100644
index 000000000..35f601008
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38140.c
@@ -0,0 +1,10 @@
+/* PR middle-end/38140 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-strict-aliasing" } */
+
+int foo (void *x)
+{
+  int (*fn) (int);
+  *(void **)&fn = x;
+  return fn (6);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38200.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38200.c
new file mode 100644
index 000000000..d5391bd88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38200.c
@@ -0,0 +1,16 @@
+/* PR middle-end/38200 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-strict-aliasing" } */
+
+typedef int (*callptr) (void);
+int foo (void **x);
+void foo2 (callptr *);
+int (*foo_ptr) (void **x) = foo;
+
+void
+bar (void)
+{
+  void *ptr;
+  foo2 ((callptr *) &ptr);
+  *(void **) &foo_ptr = ptr;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-1.c
new file mode 100644
index 000000000..17b969c7d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-1.c
@@ -0,0 +1,36 @@
+/* PR rtl-optimization/38245 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+static inline int
+f1 (int si1, int si2)
+{
+  return si2 == 0 ? si1 : si1 / si2;
+}
+
+static inline unsigned long long
+f2 (unsigned long long ui1, unsigned long long ui2)
+{
+  return ui1 % ui2;
+}
+
+unsigned char g;
+volatile unsigned int h;
+
+void
+f3 (void)
+{
+  if (!((signed char) f1 (0, f2 (g, 2123)) - 1))
+    h;
+}
+
+int
+main (void)
+{
+  f3 ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-not "% 2123" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "0 / " "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-2.c
new file mode 100644
index 000000000..299829937
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-2.c
@@ -0,0 +1,110 @@
+/* PR rtl-optimization/38245 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+void
+f1 (unsigned int a)
+{
+  if (a != 28)
+    {
+      if (4 / a == 5)
+	link_error ();
+    }
+}
+
+void
+f2 (unsigned int a)
+{
+  if (4 / a == 5)
+    link_error ();
+}
+
+void
+f3 (unsigned int a)
+{
+  if (4 / (a & 0xff) == 5)
+    link_error ();
+}
+
+void
+f4 (unsigned int a, unsigned int b)
+{
+  if ((b & 3) / ((a & 0xff) + 1) == 5)
+    link_error ();
+}
+
+void
+f5 (int a)
+{
+  if (a != 28)
+    {
+      if (4 / a == 5)
+	link_error ();
+    }
+}
+
+void
+f6 (int a)
+{
+  if (4 / a == 5)
+    link_error ();
+}
+
+void
+f7 (int a)
+{
+  if (4 / (a & 0xff) == 5)
+    link_error ();
+}
+
+void
+f8 (int a, int b)
+{
+  if ((b & 3) / ((a & 0xff) + 1) == 5)
+    link_error ();
+}
+
+void
+f9 (int a, int b)
+{
+  if (b >= 4)
+    if ((a / b) == __INT_MAX__ / 2)
+      link_error ();
+}
+
+void
+f10 (unsigned int a, unsigned int b)
+{
+  if (b >= 16)
+    if ((a / b) == __INT_MAX__ / 4)
+      link_error ();
+}
+
+void
+f11 (int a, int b)
+{
+  if (b <= -32)
+    if ((a / b) == -__INT_MAX__ / 16)
+      link_error ();
+}
+
+void
+f12 (int a, int b)
+{
+  if (a >= -6 && a <= 4)
+    if ((a / b) == -7 || (a / b) == 7)
+      link_error ();
+}
+
+void
+f13 (unsigned int a, unsigned int b)
+{
+  if (a <= 4)
+    if ((a / b) == 5)
+      link_error ();
+}
+
+/* { dg-final { scan-tree-dump-not "link_error" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-3.c
new file mode 100644
index 000000000..6ef8372a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-3.c
@@ -0,0 +1,112 @@
+/* PR rtl-optimization/38245 */
+/* { dg-do run } */
+/* { dg-additional-sources "pr38245-4.c" } */
+/* { dg-options "-O2" } */
+
+#include "pr38245-3.h"
+
+extern void abort (void);
+
+struct A { int i, j; union { short s[4]; long long l; }; char pad[512]; } a;
+int globv = 6;
+
+void __attribute__((noinline))
+f1 (void)
+{
+  a.s[2] = b1 (6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+	       6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f2 (void)
+{
+  a.s[2] = b2 (6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+	       6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f3 (void)
+{
+  struct B b = { 30, 31, { 32, 33 } };
+  a.s[2] = b3 (6, 7, 8, 9, 10, 11, 12, b, 14, b, 16, b, 18, 19, 20, 21,
+	       6, b, 8, b, 10, 11, 12, 13, 14, b, 16, b, 18, 19, 20, 21);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f4 (void)
+{
+  struct B b = { 30, 31, { 32, 33 } };
+  a.s[2] = b4 (6, 7, 8, 9, 10, 11, 12, b, 14, b, 16, b, 18, 19, 20, 21,
+	       6, b, 8, b, 10, 11, 12, 13, 14, b, 16, b, 18, 19, 20, 21);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f5 (void)
+{
+  a.s[2] = b5 (6.0, 7, 8, 9, 10, 11, 21.0, 22.0, 23.0);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f6 (void)
+{
+  a.s[2] = b6 (6.0, 7, 8, 9, 10, 11, 21.0, 22.0, 23.0);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f7 (void)
+{
+  a.s[2] = b7 (6, 7);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f8 (void)
+{
+  a.s[2] = b8 (6, 7);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f9 (void)
+{
+  a.s[2] = b9 (6, 7, 8, 9, 10, 11, 12);
+  a.l = 6;
+}
+
+void __attribute__((noinline))
+f10 (void)
+{
+  a.s[2] = b10 (6, 7, 8, 9, 10, 11, 12);
+  a.l = 6;
+}
+
+int
+main (void)
+{
+  char buf[256];
+  int i;
+  for (i = 0; i < (int) sizeof buf; i++)
+    buf[i] = i;
+  asm volatile ("" : : "r" (buf) : "memory");
+  f1 ();
+  f2 ();
+  f3 ();
+  f4 ();
+  f5 ();
+  f6 ();
+  f7 ();
+  f8 ();
+  f9 ();
+  f10 ();
+  asm volatile ("" : : "r" (buf) : "memory");
+  for (i = 0; i < (int) sizeof buf; i++)
+    if (buf[i] != (char) i)
+      abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-3.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-3.h
new file mode 100644
index 000000000..b1c2a0f67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-3.h
@@ -0,0 +1,35 @@
+/* PR rtl-optimization/38245 */
+
+struct B { long a, b; char p[32]; };
+extern int globv;
+
+extern int b1 (long long, long, long, long, long, long, long, long,
+	       long long, long, long, long, long, long, long, long,
+	       long long, long, long, long, long, long, long, long,
+	       long long, long, long, long, long, long, long, long)
+     __attribute__((pure, noinline));
+extern int b2 (long long, long, long, long, long, long, long, long,
+	       long long, long, long, long, long, long, long, long,
+	       long long, long, long, long, long, long, long, long,
+	       long long, long, long, long, long, long, long, long)
+     __attribute__((const, noinline));
+extern int b3 (long long, long, long, long, long, long, long, struct B,
+	       long long, struct B, long, struct B, long, long, long, long,
+	       long long, struct B, long, struct B, long, long, long, long,
+	       long long, struct B, long, struct B, long, long, long, long)
+     __attribute__((pure, noinline));
+extern int b4 (long long, long, long, long, long, long, long, struct B,
+	       long long, struct B, long, struct B, long, long, long, long,
+	       long long, struct B, long, struct B, long, long, long, long,
+	       long long, struct B, long, struct B, long, long, long, long)
+     __attribute__((const, noinline));
+extern int b5 () __attribute__((pure, noinline));
+extern int b6 () __attribute__((const, noinline));
+extern int b7 (int, int)
+     __attribute__((pure, noinline));
+extern int b8 (int, int)
+     __attribute__((const, noinline));
+extern int b9 (int, int, int, int, int, int, int)
+     __attribute__((pure, noinline));
+extern int b10 (int, int, int, int, int, int, int)
+     __attribute__((const, noinline));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-4.c
new file mode 100644
index 000000000..c9b3d2d8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38245-4.c
@@ -0,0 +1,107 @@
+/* PR rtl-optimization/38245 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+#include "pr38245-3.h"
+
+int
+b1 (long long a1, long a2, long a3, long a4,
+    long a5, long a6, long a7, long a8,
+    long long a9, long a10, long a11, long a12,
+    long a13, long a14, long a15, long a16,
+    long long a17, long a18, long a19, long a20,
+    long a21, long a22, long a23, long a24,
+    long long a25, long a26, long a27, long a28,
+    long a29, long a30, long a31, long a32)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10
+	 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a20
+	 + a21 + a22 + a23 + a24 + a25 + a26 + a27 + a28 + a29 + a30
+	 + a31 + a32 + globv;
+}
+
+int
+b2 (long long a1, long a2, long a3, long a4,
+    long a5, long a6, long a7, long a8,
+    long long a9, long a10, long a11, long a12,
+    long a13, long a14, long a15, long a16,
+    long long a17, long a18, long a19, long a20,
+    long a21, long a22, long a23, long a24,
+    long long a25, long a26, long a27, long a28,
+    long a29, long a30, long a31, long a32)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10
+	 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a20
+	 + a21 + a22 + a23 + a24 + a25 + a26 + a27 + a28 + a29 + a30
+	 + a31 + a32;
+}
+
+int
+b3 (long long a1, long a2, long a3, long a4,
+    long a5, long a6, long a7, struct B a8,
+    long long a9, struct B a10, long a11, struct B a12,
+    long a13, long a14, long a15, long a16,
+    long long a17, struct B a18, long a19, struct B a20,
+    long a21, long a22, long a23, long a24,
+    long long a25, struct B a26, long a27, struct B a28,
+    long a29, long a30, long a31, long a32)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8.a + a9 + a10.a
+	 + a11 + a12.a + a13 + a14 + a15 + a16 + a17 + a18.a + a19 + a20.a
+	 + a21 + a22 + a23 + a24 + a25 + a26.a + a27 + a28.a + a29 + a30
+	 + a31 + a32 + globv;
+}
+
+int
+b4 (long long a1, long a2, long a3, long a4,
+    long a5, long a6, long a7, struct B a8,
+    long long a9, struct B a10, long a11, struct B a12,
+    long a13, long a14, long a15, long a16,
+    long long a17, struct B a18, long a19, struct B a20,
+    long a21, long a22, long a23, long a24,
+    long long a25, struct B a26, long a27, struct B a28,
+    long a29, long a30, long a31, long a32)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8.a + a9 + a10.a
+	 + a11 + a12.a + a13 + a14 + a15 + a16 + a17 + a18.a + a19 + a20.a
+	 + a21 + a22 + a23 + a24 + a25 + a26.a + a27 + a28.a + a29 + a30
+	 + a31 + a32;
+}
+
+int
+b5 (double a1, int a2, int a3, int a4, int a5, int a6, double a7,
+    double a8, double a9)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + globv;
+}
+
+int
+b6 (double a1, int a2, int a3, int a4, int a5, int a6, double a7,
+    double a8, double a9)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9;
+}
+
+int
+b7 (int a1, int a2)
+{
+  return a1 + a2 + globv;
+}
+
+int
+b8 (int a1, int a2)
+{
+  return a1 + a2;
+}
+
+int
+b9 (int a1, int a2, int a3, int a4, int a5, int a6, int a7)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7 + globv;
+}
+
+int
+b10 (int a1, int a2, int a3, int a4, int a5, int a6, int a7)
+{
+  return a1 + a2 + a3 + a4 + a5 + a6 + a7;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38338.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38338.c
new file mode 100644
index 000000000..e8fcc3c45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38338.c
@@ -0,0 +1,18 @@
+/* PR middle-end/38338 */
+/* { dg-options "-O0" } */
+/* { dg-options "-O0 -fPIC" { target fpic } } */
+
+typedef void (*fnp) (void);
+
+static char
+foo (char x)
+{
+  return x;
+}
+
+static void *
+bar (char x)
+{
+  void *args = __builtin_apply_args ();
+  return __builtin_apply ((fnp) foo, args, sizeof (void *));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38364.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38364.c
new file mode 100644
index 000000000..23f72de74
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38364.c
@@ -0,0 +1,79 @@
+/* PR middle-end/38364 */
+/* { dg-do run } */
+/* { dg-options "-O2 -ftrapv" } */
+
+extern void abort (void);
+
+static inline short
+f1 (short x, short y)
+{
+  if (x > 0)
+    {
+      if (y > 0)
+	{
+	  if (x > __SHRT_MAX__ / y)
+	    return x;
+	}
+      else if (y < (-__SHRT_MAX__ - 1) / x)
+	return x;
+    }
+  else
+    {
+      if (y > 0)
+	{
+	  if (x < (-__SHRT_MAX__ - 1) / y)
+	    return x;
+	}
+      else if (x != 0 && y < __SHRT_MAX__ / x)
+	return x;
+    }
+  return x * y;
+}
+
+static inline signed char
+f2 (signed char x, signed char y)
+{
+  if (((x ^ y) & (((x ^ ((x ^ y) & (1 << (__CHAR_BIT__ - 1)))) - y) ^ y)) < 0)
+    return x;
+  return x - y;
+}
+
+unsigned int v;
+
+int
+f3 (int x, unsigned int y)
+{
+  f1 (1, 1);
+  return 1;
+}
+
+int
+f4 (unsigned short x)
+{
+  v = x;
+  return 1;
+}
+
+int
+f5 (int x)
+{
+  if (f2 (x, 1))
+    f1 (1, f4 (1));
+  return x;
+}
+
+int
+f6 (unsigned int x)
+{
+  f4 (x < (1 != f5 (0)));
+  return x;
+}
+
+int
+main (void)
+{
+  f6 (1);
+  if (v != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38615.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38615.c
new file mode 100644
index 000000000..8a818a11f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38615.c
@@ -0,0 +1,19 @@
+/* { dg-do run } */
+
+int t;
+extern void abort (void);
+
+int f(int t, const int *a)
+{
+ const int b[] = { 1, 2, 3};
+ if (!t)
+   return f(1, b);
+ return b == a;
+}
+
+int main(void)
+{
+ if (f(0, 0))
+   abort ();
+ return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38616.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38616.c
new file mode 100644
index 000000000..b4534b508
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38616.c
@@ -0,0 +1,14 @@
+/* PR middle-end/38616 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fstack-protector" } */
+/* { dg-require-effective-target fstack_protector } */
+
+#include <stdio.h> 
+
+#define BUFFER "1234567890abcdefghijklmno"
+int main (void)
+{
+  char buffer[1024]="";
+  sprintf (buffer, "%s", BUFFER);
+  return strcmp (buffer, BUFFER);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38645.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38645.c
new file mode 100644
index 000000000..3268f2ac6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38645.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int foo()
+{
+  volatile int a[1];
+  int i, *p = (int*)a;
+
+  a[0] = 1;
+  for (i = 0; i < 1; ++i)
+    if (p[i])
+      return -1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "a.0. ={v} 1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38700.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38700.c
new file mode 100644
index 000000000..bfa75b0c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38700.c
@@ -0,0 +1,11 @@
+/* PR c/38700 */
+/* { dg-do compile } */
+/* { dg-options "-O0" } */
+
+int
+foo ()
+{
+  __SIZE_TYPE__ s = __builtin_expect ((__SIZE_TYPE__)&&L, 0);
+L:
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38902.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38902.c
new file mode 100644
index 000000000..d40652624
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38902.c
@@ -0,0 +1,131 @@
+/* PR target/38902 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fstack-protector" } */
+/* { dg-require-effective-target fstack_protector } */
+
+#ifdef DEBUG
+#include <stdio.h>
+#define debug(format, args...) printf (format , ## args)
+#else
+extern int sprintf (char *, const char *, ...);
+#define debug(format, args...)
+#endif
+
+extern void abort (void);
+
+/*
+
+Copyright (C) 2009 Canonical, Ltd.
+Author: Kees Cook <kees@ubuntu.com>
+License: GPLv3
+
+http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38616
+https://bugs.launchpad.net/ubuntu/+source/gcc-4.3/+bug/316019
+http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38902
+
+gcc -O2 -fstack-protector truncate.c -o truncate
+
+    Broken:
+
+        Only the first operation fails, so create a new function for each test.
+        Source must be local (literal or stack)
+
+        __builtin_memmove
+        __builtin_memcpy
+        __builtin_strcpy  (optimized to __builtin_memcpy?)
+        sprintf (direct)  (optmized to __builtin_strcpy?)
+        sprintf (via %s)  (optmized to __builtin_strcpy?)
+
+    OK:
+        __builtin_strcat
+        sprintf (complex format)
+
+ */
+
+char *heap = "1234567890abcdefghijklmnopqrstuvwxyz";
+
+int failed = 0;
+
+#define CHECK(count, a...) \
+void test##count (void) \
+{ \
+  char *local = "1234567890abcdefghijklmnopqrstuvwxyz"; \
+  char buffer[1024]=""; \
+    a; \
+    if (__builtin_strcmp(buffer, heap) == 0) { \
+        debug("Okay(%d):\n\t%s\n", count, # a); \
+    } \
+    else { \
+        debug("Failed(%d):\n\t%s\n", count, # a); \
+	failed++; \
+    } \
+}
+
+
+CHECK( 0, __builtin_memcpy (buffer, "1234567890abcdefghijklmnopqrstuvwxyz", __builtin_strlen("1234567890abcdefghijklmnopqrstuvwxyz")+1);                                        );
+CHECK( 1, __builtin_memcpy (buffer, local, __builtin_strlen(local)+1);                );
+CHECK( 2, __builtin_memcpy (buffer, heap, __builtin_strlen(heap)+1);                );
+
+CHECK( 3, __builtin_memmove (buffer, "1234567890abcdefghijklmnopqrstuvwxyz", __builtin_strlen("1234567890abcdefghijklmnopqrstuvwxyz")+1);                                       );
+CHECK( 4, __builtin_memmove (buffer, local, __builtin_strlen(local)+1);               );
+CHECK( 5, __builtin_memmove (buffer, heap, __builtin_strlen(heap)+1);               );
+
+CHECK( 6, __builtin_strcpy (buffer, "1234567890abcdefghijklmnopqrstuvwxyz");          );
+CHECK( 7, __builtin_strcpy (buffer, local);                                      );
+CHECK( 8, __builtin_strcpy (buffer, heap);                                      );
+
+CHECK( 9,  sprintf (buffer, "1234567890abcdefghijklmnopqrstuvwxyz");         );
+CHECK(10,  sprintf (buffer, local);                                     );
+CHECK(11,  sprintf (buffer, heap);                                     );
+
+CHECK(12,  sprintf (buffer, "%s", "1234567890abcdefghijklmnopqrstuvwxyz");   );
+CHECK(13,  sprintf (buffer, "%s", local);                               );
+CHECK(14,  sprintf (buffer, "%s", heap);                               );
+
+CHECK(15, __builtin_strcat (buffer, "1234567890abcdefghijklmnopqrstuvwxyz");          );
+CHECK(16, __builtin_strcat (buffer, local);                                      );
+CHECK(17, __builtin_strcat (buffer, heap);                                       );
+
+void mongoose(void)
+{
+  char buffer[1024]="";
+  sprintf (buffer, "%s", "1234567890abcdefghijklmnopqrstuvwxyz");;
+    if (__builtin_strcmp(buffer, heap) == 0) {
+        debug("Okay(%d):\n\t%s\n", -1, "sprintf (buffer, \"%s\", \"1234567890abcdefghijklmnopqrstuvwxyz\");");
+    }
+    else {
+        debug("Failed(%d):\n\t%s\n", -1, "sprintf (buffer, \"%s\", \"1234567890abcdefghijklmnopqrstuvwxyz\");");
+	failed++;
+    }
+}
+
+int main (int argc, char *argv[])
+{
+  test0();
+  test1();
+  test2();
+  test3();
+  test4();
+  test5();
+  test6();
+  test7();
+  test8();
+  test9();
+  test10();
+  test11();
+
+  // wtf, why are these different?!
+  test12();
+  mongoose();
+
+  test13();
+  test14();
+  test15();
+  test16();
+  test17();
+
+  if (failed)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38932.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38932.c
new file mode 100644
index 000000000..4dfaffc77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38932.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+/* This variable needed only to exercise FRE instead of CCP.  */
+unsigned char g;
+
+extern void abort();
+
+void f (long long int p)
+{
+  g = 255;
+  if (p >= (-9223372036854775807LL - 1) - (signed char) g)
+    p = 1;
+
+  if (p)
+    abort ();
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38934.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38934.c
new file mode 100644
index 000000000..c05742c5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38934.c
@@ -0,0 +1,19 @@
+/* PR middle-end/38934 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu99 -w" } */
+
+/* This variable needed only to work around earlier optimizations than VRP.  */
+unsigned char g;
+
+extern void abort ();
+
+void
+f (long long int p)
+{
+  g = 255;
+  if (p >= -9223372036854775808LL - (signed char) g)
+    p = 1;
+
+  if (p)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38957.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38957.c
new file mode 100644
index 000000000..f94cd7627
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38957.c
@@ -0,0 +1,16 @@
+/* PR c/38957 */
+/* { dg-do compile } */
+
+char *
+foo (void)
+{
+  char a[2];
+  return a+1;	/* { dg-warning "returns address of local variable" } */
+}
+
+char *
+bar (void)
+{
+  char a[2];
+  return a;	/* { dg-warning "returns address of local variable" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38984.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38984.c
new file mode 100644
index 000000000..0ba727399
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr38984.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-delete-null-pointer-checks -fdump-tree-optimized" }
+ * */
+
+int f(int *p)
+{
+  int a = *p;
+  int *null = 0;
+  *null = 5;
+  return *p == a;
+}
+
+/* Currently fails because of PR38985.  */
+
+/* { dg-final { scan-tree-dump-times " = \\\*p" 2 "optimized" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-not "return 1" "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39084.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39084.c
new file mode 100644
index 000000000..6432841fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39084.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+struct color { int i; };
+static const struct color col;
+struct color * f(void)
+{
+    return (struct color *) &col;
+}
+
+struct color { int j; }; /* { dg-error "redefinition of" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39226.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39226.c
new file mode 100644
index 000000000..1442ccc14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39226.c
@@ -0,0 +1,25 @@
+/* PR target/39226 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mtune=cell -mminimal-toc" { target { powerpc*-*-* && lp64 } } } */
+
+struct A
+{
+  char *a;
+  unsigned int b : 1;
+  unsigned int c : 31;
+};
+
+struct B
+{
+  struct A *d;
+};
+
+void
+foo (struct B *x, unsigned long y)
+{
+  if (x->d[y].c)
+    return;
+  if (x->d[y].b)
+    x->d[y].a = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39343.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39343.c
new file mode 100644
index 000000000..70df59ef0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39343.c
@@ -0,0 +1,29 @@
+/* PR tree-optimization/39343 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+extern inline __attribute__ ((__always_inline__)) int
+foo (char *dest)
+{
+  return __builtin_object_size (dest, 1);
+}
+
+struct S
+{
+  union
+  {
+    struct { int a, b; char c, d; } f;
+    struct { struct { int a, b; char c, d[255]; } e; } g;
+  } u;
+};
+
+int
+main (void)
+{
+  struct S s;
+  if (foo (s.u.g.e.d) != 255)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39443.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39443.c
new file mode 100644
index 000000000..1baa63a99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39443.c
@@ -0,0 +1,18 @@
+/* PR middle-end/39443 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler-not "memcmp" } } */
+
+typedef __SIZE_TYPE__ size_t;
+
+extern int memcmp (const void *s1, const void *s2, size_t n)
+  __attribute__ ((__nothrow__, __pure__));
+extern __typeof (memcmp) memcmp __asm__ ("memory_compare");
+
+int
+test (char *s, char *t, int cnt)
+{
+  if (__builtin_expect (cnt, 0))
+    return memcmp (s, t, cnt);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39455.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39455.c
new file mode 100644
index 000000000..8e8c67034
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39455.c
@@ -0,0 +1,13 @@
+/* PR tree-optimization/39455 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -w" } */
+
+void
+foo (char *x, unsigned long y, unsigned char *z)
+{
+  unsigned int c[256], *d;
+
+  for (d = c + 1; d < c + 256; ++d)
+    *d += d[-1];
+  x[--c[z[y]]] = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39565.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39565.c
new file mode 100644
index 000000000..9c14055a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39565.c
@@ -0,0 +1,48 @@
+/* PR39565: Static variable leaves undefined symbol in object file.
+   Variables codestrs_4 and codestrs_8 should not be undefined,
+   when this program is compiled at -O2. As a basic sanity test,
+   verify that this program compiles into an executable and runs. */
+
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+extern void exit (int);
+extern int strcmp (const char *, const char *);
+
+static const union codestrs_t_4 {
+  struct {
+    char str_2[sizeof ("Illegal opcode")];
+  };
+  char str[0];
+} codestrs_4 = { {"Illegal opcode"} };
+
+static const union codestrs_t_8 {
+  struct {
+    char str_12[sizeof ("Integer divide by zero")];
+  };
+  char str[0];
+} codestrs_8 = { {"Integer divide by zero"} };
+
+const char *
+psiginfo (int pinfo)
+{
+  const char *base = ((void *)0);
+
+  switch (pinfo)
+    {
+    case 4: base = codestrs_4.str; break;
+    case 8: base = codestrs_8.str; break;
+    }
+  return base;
+}
+
+int
+main (void)
+{
+  if (strcmp (psiginfo (4), codestrs_4.str))
+    abort ();
+  if (strcmp (psiginfo (8), codestrs_8.str))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39666-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39666-1.c
new file mode 100644
index 000000000..f1ba499c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39666-1.c
@@ -0,0 +1,22 @@
+/* PR middle-end/39666 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+int
+foo (int i)
+{
+  int j;
+  switch (i)
+    {
+    case -__INT_MAX__ - 1 ... -1:
+      j = 6;
+      break;
+    case 0:
+      j = 5;
+      break;
+    case 1 ... __INT_MAX__:
+      j = 4;
+      break;
+    }
+  return j;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39666-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39666-2.c
new file mode 100644
index 000000000..3a853e60b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39666-2.c
@@ -0,0 +1,22 @@
+/* PR middle-end/39666 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+int
+foo (int i)
+{
+  int j;
+  switch (i)
+    {
+    case -__INT_MAX__ - 1 ... -1:
+      j = 6;
+      break;
+    case 0:
+      j = 5;
+      break;
+    case 2 ... __INT_MAX__:
+      j = 4;
+      break;
+    }
+  return j;
+} /* { dg-warning "may be used uninitialized" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39794.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39794.c
new file mode 100644
index 000000000..2702ba79a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39794.c
@@ -0,0 +1,33 @@
+/* PR rtl-optimization/39794 */
+/* { dg-do run } */
+/* { dg-options "-O2 -funroll-loops" } */
+
+extern void abort ();
+
+void
+foo (int *a, int n)
+{
+  int i;
+  for (i = 0; i < n; i++)
+    {
+      a[i] *= 2;
+      a[i + 1] = a[i - 1] + a[i - 2];
+    }
+}
+
+int a[16];
+int ref[16] = { 0, 1, 4, 2, 10, 12, 24, 44,
+		72, 136, 232, 416, 736, 1296, 2304, 2032 };
+
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 16; i++)
+    a[i] = i;
+  foo (a + 2, 16 - 3);
+  for (i = 0; i < 16; i++)
+    if (ref[i] != a[i])
+      abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39867.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39867.c
new file mode 100644
index 000000000..cb7972452
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr39867.c
@@ -0,0 +1,12 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+int main (void)
+{
+  int exp = -1;
+  /* Wrong folding of the LHS to an unsigned MAX leads to 4294967295 != 2.  */
+  if ((exp < 2 ? 2U : (unsigned int) exp) != 2)
+    link_error ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-1.c
new file mode 100644
index 000000000..a834a8a99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-1.c
@@ -0,0 +1,31 @@
+/* PR middle-end/40172 */
+/* { dg-do compile } */
+/* { dg-options "-Wall -W -Werror -Wlogical-op" } */
+
+struct rtx_def;
+typedef struct rtx_def *rtx; 
+
+extern int foo;
+extern int bar;
+extern int xxx;
+
+int
+test (void)
+{
+  if (((rtx) 0 != (rtx) 0) && xxx ? foo : bar)
+    return 1;
+  else if ((foo & 0) && xxx)
+    return 2;
+  else if (foo & 0)
+    return 3;
+  else if (0 && xxx)
+    return 4;
+  else if (0)
+    return 5;
+  if (((int) 0 != (int) 0) && bar ? foo : xxx)
+    return 6;
+  else if (0 != 0 && foo ? xxx : bar)
+    return 7;
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-2.c
new file mode 100644
index 000000000..17aabb8b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-2.c
@@ -0,0 +1,16 @@
+/* PR middle-end/40172 */
+/* { dg-do compile } */
+/* { dg-options "-Wall -W -Werror" } */
+
+extern int xxx;
+
+#define XXX xxx
+
+int
+test (void)
+{
+  if (!XXX && xxx)
+    return 4;
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-3.c
new file mode 100644
index 000000000..a16e22e37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40172-3.c
@@ -0,0 +1,16 @@
+/* PR middle-end/40172 */
+/* { dg-do compile */
+/* { dg-options "-Wall -W -Werror -Wlogical-op" } */
+
+extern int xxx;
+
+#define XXX xxx
+
+int
+test (void)
+{
+  if (!XXX && xxx)
+    return 4;
+  else
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-1.c
new file mode 100644
index 000000000..aae84c637
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-1.c
@@ -0,0 +1,24 @@
+/* PR middle-end/40340 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall -Wno-system-headers" } */
+
+#include "pr40340.h"
+
+static inline
+__attribute__ ((always_inline))
+void
+test (char *p)
+{
+  memset (p, 0, 6);
+}
+
+int
+main (void)
+{
+  char buf[4];
+  test (buf);
+  return 0;
+}
+
+/* { dg-warning "will always overflow destination buffer" "" { target *-*-* } 10 } */
+/* { dg-message "file included" "In file included" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-2.c
new file mode 100644
index 000000000..a0d6e084e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-2.c
@@ -0,0 +1,16 @@
+/* PR middle-end/40340 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall -Wno-system-headers" } */
+
+#include "pr40340.h"
+
+int
+main (void)
+{
+  char buf[4];
+  memset (buf, 0, 6);
+  return 0;
+}
+
+/* { dg-warning "will always overflow destination buffer" "" { target *-*-* } 10 } */
+/* { dg-message "file included" "In file included" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-3.c
new file mode 100644
index 000000000..5ef09e073
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-3.c
@@ -0,0 +1,15 @@
+/* PR middle-end/40340 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall -Wno-system-headers" } */
+
+#define TEST2
+#include "pr40340.h"
+
+int
+main (void)
+{
+  test2 ();
+  return 0;
+}
+
+/* { dg-bogus "will always overflow destination buffer" "" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-4.c
new file mode 100644
index 000000000..d3f020cad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-4.c
@@ -0,0 +1,16 @@
+/* PR middle-end/40340 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall -Wno-system-headers -g" } */
+
+#define TEST3
+#include "pr40340.h"
+
+int
+main (void)
+{
+  char buf[4];
+  test3 (buf);
+  return 0;
+}
+
+/* { dg-bogus "will always overflow destination buffer" "" { target *-*-* } 10 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-5.c
new file mode 100644
index 000000000..f50514c3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340-5.c
@@ -0,0 +1,17 @@
+/* PR middle-end/40340 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall -Wsystem-headers -g" } */
+
+#define TEST3
+#include "pr40340.h"
+
+int
+main (void)
+{
+  char buf[4];
+  test3 (buf);
+  return 0;
+}
+
+/* { dg-warning "will always overflow destination buffer" "" { target *-*-* } 10 } */
+/* { dg-message "file included" "In file included" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340.h
new file mode 100644
index 000000000..174e076b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40340.h
@@ -0,0 +1,31 @@
+#pragma GCC system_header
+typedef __SIZE_TYPE__ size_t;
+extern void *memset (void *s, int c, size_t n)
+  __attribute__ ((nothrow, nonnull (1)));
+extern inline
+__attribute__ ((always_inline, artificial, gnu_inline, nothrow))
+void *
+memset (void *dest, int ch, size_t len)
+{
+  return __builtin___memset_chk (dest, ch, len,
+				 __builtin_object_size (dest, 0));
+}
+
+#ifdef TEST2
+static void
+__attribute__ ((noinline))
+test2 (void)
+{
+  char buf[4];
+  memset (buf, 0, 6);
+}
+#endif
+
+#ifdef TEST3
+static inline void
+__attribute__ ((always_inline))
+test3 (char *p)
+{
+  memset (p, 0, 6);
+}
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40550.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40550.c
new file mode 100644
index 000000000..27935ab00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40550.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-msse" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#ifdef __i386__
+#include "cpuid.h"
+#endif
+
+typedef float v2sf __attribute__ ((vector_size (2 * sizeof(float))));
+
+static void test (void)
+{
+  v2sf a = {1.0, 0.0};
+  v2sf b = {0.0, 1.0};
+  v2sf d;
+  d = a + b;
+}
+
+int main ()
+{
+
+#ifdef __i386__
+  unsigned int eax, ebx, ecx, edx;
+
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  if (!(edx & bit_SSE))
+    return 0;
+#endif
+
+  test ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40669.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40669.c
new file mode 100644
index 000000000..cc6bbc9e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40669.c
@@ -0,0 +1,26 @@
+/* PR middle-end/40669 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math" } */
+
+double _Complex
+test (int d, int t, double *x, double *y, double *z, int n,
+      double _Complex (*fnp) (double))
+{
+  int m = n / 2;
+  double min = y[t], max = z[t], med = x[m * d + t];
+  double _Complex result = 0.0;
+
+  if (n == 0)
+    return 0.0;
+
+  if (min > med)
+    result += test (d, (t + 1) % d, x + (m + 1) * d, y, z, n - m - 1, fnp);
+  else if (max < med)
+    result += test (d, (t + 1) % d, x, y, z, m, fnp);
+  else
+    {
+      result += fnp (y[0] + x[m]);
+      result += test (d, (t + 1) % d, x + (m + 1) * d, y, z, n - m - 1, fnp);
+    }
+  return result;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40792.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40792.c
new file mode 100644
index 000000000..41f080e54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40792.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/40792 */
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+void foo (int, char *, int *);
+
+void
+bar (int *a, int *b, ...)
+{
+  int c;
+  char d[256];
+  foo (*b, d, &c);
+}
+
+static int a, b;
+
+void
+baz (int c)
+{
+  bar (&a, &b);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40861.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40861.c
new file mode 100644
index 000000000..1d955e616
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40861.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+int foo(int i)
+{
+  return (1LL >> 128 * i) && i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40946.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40946.c
new file mode 100644
index 000000000..3fd804e56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40946.c
@@ -0,0 +1,33 @@
+/* PR middle-end/40946 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+struct A
+{
+  unsigned char a1[8];
+  unsigned short a2, a3, a4, a5, a6, a7;
+};
+
+int bar (void *, const char *, int);
+char *foo (void *, int);
+
+char *
+baz (const char *x, const char *y)
+{
+  int a = sizeof (struct A) + 2 * (__builtin_strlen (y)
+				   + __builtin_strlen (x) + 24) + 16;
+  struct A *b = __builtin_malloc (a);
+  char *c;
+  int d;
+
+  b->a4 = sizeof (struct A);
+  c = ((char *) b) + b->a4;
+  d = ((char *) b) + a - c;
+  b->a2 = b->a3 = (unsigned short) bar (c, y, d); /* { dg-bogus "array subscript is above array bounds" } */
+  c += b->a2;
+  d = ((char *) b) + a - c;
+  b->a7 = b->a4 + b->a2;
+  b->a5 = b->a6 = (unsigned short) bar (c, x, d);
+  c = foo (b, a);
+  return c;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40971.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40971.c
new file mode 100644
index 000000000..31dfd5e13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr40971.c
@@ -0,0 +1,23 @@
+/* PR target/40971 */
+/* { dg-do compile } */
+/* { dg-options "-O -fstack-protector -fno-strict-aliasing" } */
+/* { dg-require-effective-target fstack_protector } */
+
+extern void bar (char *);
+
+void
+foo (int f, long a)
+{
+  {
+    char d[32768];
+    bar (d);
+  }
+  double b = f;
+  while (a)
+    {
+      char c[sizeof (double)];
+      __builtin_memcpy (c, &b, sizeof (c));
+      if (*(double *) c != 2.0)
+	break;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41033.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41033.c
new file mode 100644
index 000000000..5043be2d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41033.c
@@ -0,0 +1,24 @@
+/* { dg-options "-O1 -fno-strict-aliasing" } */
+/* PR rtl-optimization/41033 */
+
+struct X {
+  int i;
+  int j;
+};
+
+int foo(struct X *p, struct X *q)
+{
+  p->j = 1;
+  q->i = 0;
+  return p->j;
+}
+
+extern void abort (void);
+
+int main()
+{
+  struct X x;
+  if (foo (&x, (struct X *)&x.j) != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41123.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41123.c
new file mode 100644
index 000000000..076edb46e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41123.c
@@ -0,0 +1,46 @@
+/* PR middle-end/41123 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-strict-aliasing" } */
+
+struct S { char a, b, c, d, e, f, g, h; };
+struct T { int a, b; };
+
+struct S
+f1 (float _Complex x)
+{
+  return *(struct S *) & x;
+}
+
+int
+f2 (float _Complex x)
+{
+  struct S f = f1 (x);
+  return f.b;
+}
+
+struct T
+f3 (float _Complex x)
+{
+  return *(struct T *) & x;
+}
+
+int
+f4 (float _Complex x)
+{
+  struct T f = f3 (x);
+  return f.a;
+}
+
+int
+f5 (float _Complex x)
+{
+  struct T f = f3 (x);
+  return f.b;
+}
+
+struct T
+f6 (float _Complex x)
+{
+  struct T f = f3 (x);
+  return f;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41232.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41232.c
new file mode 100644
index 000000000..17ec54899
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41232.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -g" } */
+extern int atoi (const char *);
+extern int sprintf (char *, const char *, ...);
+void malloc_init() {
+  char *cptr;
+  char buf[1];
+  int tmbd = atoi(cptr);
+  if (tmbd > 0)
+    tmbd = (tmbd <= 124) ? tmbd : 124;
+   else
+    tmbd = 0;
+   sprintf(buf, "%d\n", tmbd);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41248.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41248.c
new file mode 100644
index 000000000..0d5a74919
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41248.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -g" } */
+
+struct __gcov_var {
+   unsigned int offset;
+   unsigned int buffer[(1 << 10) + 1];
+} __gcov_var;
+unsigned int * gcov_write_words (unsigned int words) {
+   unsigned int *result;
+   result = &__gcov_var.buffer[__gcov_var.offset];
+   return result;
+}
+
+struct gcov_ctr_summary { };
+struct gcov_summary {
+   unsigned int checksum;
+   struct gcov_ctr_summary ctrs[1];
+};
+void __gcov_write_unsigned (unsigned int);
+void __gcov_write_summary (unsigned int tag,
+			   const struct gcov_summary *summary)
+{
+   unsigned ix;
+   const struct gcov_ctr_summary *csum;
+   __gcov_write_unsigned (summary->checksum);
+   for (csum = summary->ctrs, ix = 1; ix--; csum++) { }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41295.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41295.c
new file mode 100644
index 000000000..fabff63c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41295.c
@@ -0,0 +1,91 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -g" } */
+
+enum reg_class
+{
+  BASE_REGS,
+  GENERAL_REGS,
+  LIM_REG_CLASSES
+};
+
+static __inline__ unsigned char
+hard_reg_set_subset_p (const unsigned long x[4], const unsigned long y[4])
+{
+  return ((x[0] & ~y[0]) == 0
+          && (x[1] & ~y[1]) == 0
+          && (x[2] & ~y[2]) == 0
+	  && (x[3] & ~y[3]) == 0);
+}
+
+static __inline__ unsigned char
+hard_reg_set_equal_p (const unsigned long x[4], const unsigned long y[4])
+{
+  return x[0] == y[0]
+         && x[1] == y[1]
+         && x[2] == y[2]
+         && x[3] == y[3];
+}
+
+extern unsigned long reg_class_contents[(int) LIM_REG_CLASSES][4];
+extern int ira_important_classes_num;
+extern enum reg_class ira_important_classes[(int) LIM_REG_CLASSES];
+extern enum reg_class ira_reg_class_intersect[(int) LIM_REG_CLASSES][(int)
+								     LIM_REG_CLASSES];
+extern unsigned char ira_reg_classes_intersect_p[(int) LIM_REG_CLASSES][(int)
+									LIM_REG_CLASSES];
+extern enum reg_class ira_reg_class_super_classes[(int) LIM_REG_CLASSES][(int)
+									 LIM_REG_CLASSES];
+static unsigned long temp_hard_regset[4];
+
+static void
+setup_reg_class_relations (void)
+{
+  int i, cl1, cl2, cl3;
+  unsigned long temp_set2[4];
+  for (cl1 = 0; cl1 < (int) LIM_REG_CLASSES; cl1++)
+    {
+      ira_reg_class_super_classes[cl1][0] = LIM_REG_CLASSES;
+      for (cl2 = 0; cl2 < (int) LIM_REG_CLASSES; cl2++)
+	{
+	  ira_reg_classes_intersect_p[cl1][cl2] = 0;
+	  {
+	    unsigned long *scan_tp_ = (temp_set2), *scan_fp_ =
+	      (reg_class_contents[cl2]);
+	    scan_tp_[1] = scan_fp_[1];
+	    scan_tp_[2] = scan_fp_[2];
+	    scan_tp_[3] = scan_fp_[3];
+	  }
+	  for (i = 0; i < ira_important_classes_num; i++)
+	    {
+	      cl3 = ira_important_classes[i];
+	      {
+		unsigned long *scan_tp_ = (temp_hard_regset), *scan_fp_ =
+		  (reg_class_contents[cl3]);
+		scan_tp_[0] = scan_fp_[0];
+		scan_tp_[1] = scan_fp_[1];
+		scan_tp_[3] = scan_fp_[3];
+	      }
+	      if (!hard_reg_set_subset_p (temp_hard_regset, temp_set2)
+		  || (hard_reg_set_equal_p (temp_hard_regset, temp_set2)
+		      && hard_reg_set_subset_p (reg_class_contents[cl3],
+						reg_class_contents[(int)
+								   ira_reg_class_intersect
+								   [cl1]
+								   [cl2]])))
+		ira_reg_class_intersect[cl1][cl2] = (enum reg_class) cl3;
+	    }
+	}
+    }
+}
+
+static void
+find_reg_class_closure (void)
+{
+  setup_reg_class_relations ();
+}
+
+void
+ira_init (void)
+{
+  find_reg_class_closure ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41470.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41470.c
new file mode 100644
index 000000000..1c029b481
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41470.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-fexceptions" } */
+void *
+af (void *a)
+{
+  return a;
+}
+void
+bf (void)
+{
+  void *p;
+  {
+    int i = 1;
+    char v[i];
+    p = af (v);
+  }
+  cf (p);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41573.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41573.c
new file mode 100644
index 000000000..52961db8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41573.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+__inline __attribute__ ((__always_inline__)) char *
+strcpy (char *__dest, __const char *__src)
+{
+  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+
+const char* get_attr(unsigned attr)
+{
+    static char tmp[256];
+
+    strcpy(tmp, "");
+    return tmp;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41574.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41574.c
new file mode 100644
index 000000000..f5ddcb2fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41574.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=armv7-a -mfloat-abi=softfp -mfpu=neon -fno-unsafe-math-optimizations -fdump-rtl-combine" { target { arm*-*-* } } } */
+/* { dg-options "-O2 -fno-unsafe-math-optimizations -fdump-rtl-combine" { target { ! arm*-*-* } } } */
+
+
+static const double one=1.0;
+
+double
+f(double x)
+{
+  return x*(one+x);
+}
+
+/* { dg-final { scan-rtl-dump-not "\\(plus:DF \\(mult:DF" "combine" } } */
+/* { dg-final { cleanup-rtl-dump "combine*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41643.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41643.c
new file mode 100644
index 000000000..7c0743da4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41643.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/41643 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dce" } */
+
+struct S { int a; };
+
+int
+f (struct S *x)
+{
+  int a = x->a;
+  if (a)
+    return f (x) + a;
+  else
+    return f (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41762.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41762.c
new file mode 100644
index 000000000..88d8172f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41762.c
@@ -0,0 +1,31 @@
+/* PR target/41762 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftracer -fsched2-use-superblocks" } */
+/* { dg-options "-O2 -ftracer -fsched2-use-superblocks -fpic" { target fpic } } */
+
+extern __SIZE_TYPE__ strlen (const char *);
+extern int f1 (void *);
+extern char *f2 (void);
+extern void f3 (int, int);
+static char *a;
+char *b, *c, *d, *e;
+
+void
+foo (void)
+{
+  int f, g, h;
+  f = (a ? strlen (a) : strlen ("abcde"));
+  f += (b ? strlen (b) : 0);
+  f += (c ? strlen (c) : 0);
+  f += (d ? strlen (d) : 0);
+  f += (e ? strlen (e) : 0);
+  h = f1 (strlen);
+  g = strlen (a);
+  f3 (g, f);
+}
+
+void
+bar (void)
+{
+  a = f2 ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41841.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41841.c
new file mode 100644
index 000000000..595bc7592
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41841.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/41841 */
+/* { dg-do compile } */
+/* { dg-options "-O -fipa-struct-reorg -fwhole-program -fipa-cp" } */
+
+typedef struct S *T;
+typedef struct { } *U;
+extern int f1 (void);
+
+static void
+f3 (U x, int y)
+{
+  T a = (T) x;
+  y && f1 ();
+}
+
+static void
+f2 (T x)
+{
+  f3 ((U) x, 1);
+}
+
+void *volatile a __attribute__((used)) = f2;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41842.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41842.c
new file mode 100644
index 000000000..fa7edd11e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41842.c
@@ -0,0 +1,8 @@
+/* PR c/41842 */
+/* { dg-do compile } */
+
+void
+f ()
+{
+  char x[g (h)];	/* { dg-error "undeclared|for each function" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41935.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41935.c
new file mode 100644
index 000000000..e6a1b2867
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr41935.c
@@ -0,0 +1,25 @@
+/* PR middle-end/41935 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+struct A { int a; int b[10]; };
+
+int
+foo (struct A *p)
+{
+  return __builtin_offsetof (struct A, b[p->a]);
+}
+
+int
+main ()
+{
+  struct A a;
+  a.a = 7;
+  if (foo (&a) != 7 * sizeof (int) + __builtin_offsetof (struct A, b))
+    abort ();
+  a.a = 2;
+  if (foo (&a) != 2 * sizeof (int) + __builtin_offsetof (struct A, b))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42078.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42078.c
new file mode 100644
index 000000000..8107ff555
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42078.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/42078 */
+/* { dg-do compile } */
+/* { dg-options "-g -O -ffast-math" } */
+
+double sqrt (double x);
+
+float
+foo (float x)
+{
+  float y = sqrt (x);
+  return x / y;
+}
+
+inline float
+bar (float x)
+{
+  float y = sqrt (x);
+  float a = y;
+  float b = y;
+  float c = y;
+  return x / y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42084.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42084.c
new file mode 100644
index 000000000..d5aad9642
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42084.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "-O1 -fno-delete-null-pointer-checks" } */
+extern void abort (void);
+int g = 0;
+static int __attribute__((noinline)) f (long long a, long long b)
+{
+  int cmp;
+  cmp = a > b;
+  if (&g == 0)
+    cmp-=2;
+  else
+    cmp++;
+  return cmp;
+}
+
+int main (void)
+{
+  int ret = f (2, 1);
+  if (ret != 2)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42215.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42215.c
new file mode 100644
index 000000000..e5a75bd30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42215.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-distribution" } */
+
+extern int A[];
+extern int B[];
+
+void f(int i)
+{
+   while (i-- > 0) {
+     A[i] = 0;
+     B[i] = 0;
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42475.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42475.c
new file mode 100644
index 000000000..a5edffa78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42475.c
@@ -0,0 +1,28 @@
+/* PR rtl-optimization/42475 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef struct { float x, y; } B;
+typedef struct { float z; } C;
+typedef struct { B b; C c; } D;
+
+B
+foo (float x, float y)
+{
+  B b = { .x = x, .y = y };
+  return b;
+}
+
+B
+bar (B b, B y)
+{
+  return foo (y.x + b.x, b.y);
+}
+
+B
+baz (D p)
+{
+  D d = { };
+  B y = bar (foo (0, (p.c.z) / 2), d.b);
+  return y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42611.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42611.c
new file mode 100644
index 000000000..c33e248ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42611.c
@@ -0,0 +1,19 @@
+/* PR other/42611 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+#define L \
+  (sizeof (__SIZE_TYPE__) == 1 ? __SCHAR_MAX__				\
+  : sizeof (__SIZE_TYPE__) == sizeof (short) ? __SHRT_MAX__		\
+  : sizeof (__SIZE_TYPE__) == sizeof (int) ? __INT_MAX__		\
+  : sizeof (__SIZE_TYPE__) == sizeof (long) ? __LONG_MAX__		\
+  : sizeof (__SIZE_TYPE__) == sizeof (long long) ? __LONG_LONG_MAX__	\
+  : __INTMAX_MAX__)
+struct S { int a; char b[L]; };
+
+void
+foo (void)
+{
+  struct S s;				/* { dg-error "is too large" } */
+  asm volatile ("" : : "r" (&s));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42662.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42662.c
new file mode 100644
index 000000000..6f416e826
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr42662.c
@@ -0,0 +1,48 @@
+/* PR debug/42662 */
+/* { dg-do compile } */
+/* { dg-options "-g -O2" } */
+
+struct S { unsigned long s[17]; };
+
+static inline void
+foo (struct S *r, struct S *a, unsigned n)
+{
+  unsigned b = n / 8;
+  r->s[0] = (b >= 1 ? : a->s[1 - b]);
+}
+
+static inline void
+bar (struct S *r, struct S *a)
+{
+  r->s[0] = a->s[0] << 1;
+}
+
+static inline void
+baz (struct S *r, struct S *a, struct S *b)
+{
+  unsigned c = 0;
+  int i;
+  for (i = 0; i < 3; ++i)
+    {
+      unsigned long d = a->s[i];
+      long e = d + b->s[i];
+      if (c)
+	++e == 0;
+      c = e < d;
+      r->s[i] = e;
+    }
+}
+
+void
+test (struct S *r, int s, int d)
+{
+  struct S u;
+  if (s)
+    {
+      bar (&u, r);
+      foo (r, r, 3);
+      baz (r, r, &u);
+    }
+  u.s[0] = d;
+  baz (r, r, &u);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8715.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8715.c
new file mode 100644
index 000000000..e45e77c09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8715.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-Wsign-compare -std=c99" } */
+
+#include <stdbool.h>
+
+int foo()
+{
+  unsigned char b = '1';
+
+  bool x = ~b; /* { dg-warning "promoted ~unsigned is always non-zero" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8788-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8788-1.c
new file mode 100644
index 000000000..74e169409
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8788-1.c
@@ -0,0 +1,20 @@
+/* PR inline-asm/8788 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef struct {
+    long x[6];
+} myjmp_buf;
+
+typedef struct {
+    myjmp_buf regs;
+} my_stack;
+
+void switch_to_stack (my_stack *stack){
+    asm (  /* { dg-error "impossible constraint" } */
+/* { dg-warning "asm operand 1" "asm operand 1" { target *-*-* } 14 } */
+        "\n"
+        : "+r" (stack->regs)
+    );
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8835-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8835-1.c
new file mode 100644
index 000000000..6e3703baa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8835-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+
+struct s {
+  char c;
+};
+
+struct s
+foo (void)
+{
+  struct s s = { 0 };
+  return s;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8927-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8927-1.c
new file mode 100644
index 000000000..218e71706
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr8927-1.c
@@ -0,0 +1,13 @@
+/* Bug 8927: undeclared identifiers should give an error on the line
+   of that identifier, not on the line of the next token.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+foo(void)
+{
+  bar /* { dg-error "undeclared|for each function" } */
+
+
+  ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr9365-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr9365-1.c
new file mode 100644
index 000000000..1c3db2fed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr9365-1.c
@@ -0,0 +1,41 @@
+/* PR target/9365
+ * Origin: marcus@mc.pp.se
+ * Testcase tweaked by dank@kegel.com
+ * gcc 3.4 coverage by joern.rennecke@superh.com
+ * [3.3 regression] [SH] segfault in gen_far_branch (config/sh/sh.c)
+ * ice-on-valid-code
+ * Not marked as xfail since it's a regression
+*/
+/* { dg-do compile } */
+/* { dg-options "-O2 -fomit-frame-pointer" } */
+
+
+void foo(int n, int *p)
+{
+	switch(n) {
+	case 100: case 110: case 120: case 130: case 140: case 150: case 160:
+	case 200: case 210: case 220: case 230: case 240: case 250: case 260:
+	case 300: case 310: case 320: case 330: case 340: case 350: case 360:
+	case 400: case 410: case 420: case 430: case 440: case 450: case 460:
+	case 500: case 510: case 520: case 530: case 540: case 550: case 560:
+	case 600: case 610: case 620: case 630: case 640: case 650: case 660:
+	case 700: case 710: case 720: case 730: case 740: case 750: case 760:
+	case 800: case 810: case 820: case 830: case 840: case 850: case 860:
+	case 900: case 910: case 920: case 930: case 940: case 950: case 960:
+		break;
+	default:
+		*p = n;
+		break;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int p;
+
+	(void) argv;
+
+	foo(argc, &p);
+
+	return p;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pr9814-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr9814-1.c
new file mode 100644
index 000000000..51b79f783
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pr9814-1.c
@@ -0,0 +1,107 @@
+/* PR tree-optimization/9814  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort(void);
+
+int test1(int x)
+{
+  if (x & 2)
+    x |= 2;
+  return x;
+}
+
+int test2(int x)
+{
+  if (!(x & 2))
+    x |= 2;
+  return x;
+}
+
+int test3(int x)
+{
+  if (x & 2)
+    x ^= 2;
+  return x;
+}
+
+int test4(int x)
+{
+  if (!(x & 2))
+    x ^= 2;
+  return x;
+}
+
+int test5(int x)
+{
+  if (x & 2)
+    x &= ~2;
+  return x;
+}
+
+int test6(int x)
+{
+  if (!(x & 2))
+    x &= ~2;
+  return x;
+}
+
+int main()
+{
+  if (test1(0) != 0)
+    abort();
+  if (test1(2) != 2)
+    abort();
+  if (test1(5) != 5)
+    abort();
+  if (test1(7) != 7)
+    abort();
+
+  if (test2(0) != 2)
+    abort();
+  if (test2(2) != 2)
+    abort();
+  if (test2(5) != 7)
+    abort();
+  if (test2(7) != 7)
+    abort();
+
+  if (test3(0) != 0)
+    abort();
+  if (test3(2) != 0)
+    abort();
+  if (test3(5) != 5)
+    abort();
+  if (test3(7) != 5)
+    abort();
+
+  if (test4(0) != 2)
+    abort();
+  if (test4(2) != 2)
+    abort();
+  if (test4(5) != 7)
+    abort();
+  if (test4(7) != 7)
+    abort();
+
+  if (test5(0) != 0)
+    abort();
+  if (test5(2) != 0)
+    abort();
+  if (test5(5) != 5)
+    abort();
+  if (test5(7) != 5)
+    abort();
+
+  if (test6(0) != 0)
+    abort();
+  if (test6(2) != 2)
+    abort();
+  if (test6(5) != 5)
+    abort();
+  if (test6(7) != 7)
+    abort();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-align-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-align-2.c
new file mode 100644
index 000000000..ac5858cab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-align-2.c
@@ -0,0 +1,66 @@
+/* { dg-do run { target *-*-solaris2.* } } */
+
+void abort (void);
+
+#pragma align 1(x1)
+#pragma align 2(x2)
+#pragma align 4(x4)
+#pragma align 8(x8,y8,z8)
+#pragma align 16(x16)
+#pragma align 32(x32)
+#pragma align 64(x64)
+#pragma align 128(x128)
+
+#define MACRO 128
+#define MACRO2(A) A
+
+#pragma align MACRO(y128)
+#pragma align MACRO2(MACRO) (z128)
+
+#pragma align 8(not_defined)
+
+#pragma align 9(odd_align)	/* { dg-warning "invalid alignment" } */
+#pragma align 256(high_align)	/* { dg-warning "invalid alignment" } */
+#pragma align -1(neg_align)	/* { dg-warning "malformed" } */
+#pragma align bad_align		/* { dg-warning "malformed" } */
+#pragma align 1(bad_align	/* { dg-warning "malformed" } */
+
+int x, x1, x2, x4, x8, y8, z8, x16, x32, x64, x128, y128, z128;
+
+#pragma align 16(x)		/* { dg-warning "must appear before" } */
+
+int
+main ()
+{
+  if (__alignof__ (x4) < 4)
+    abort ();
+
+  if (__alignof__ (x8) < 8)
+    abort ();
+
+  if (__alignof__ (y8) < 8)
+    abort ();
+
+  if (__alignof__ (z8) < 8)
+    abort ();
+
+  if (__alignof__ (x16) < 16)
+    abort ();
+
+  if (__alignof__ (x32) < 32)
+    abort ();
+
+  if (__alignof__ (x64) < 64)
+    abort ();
+
+  if (__alignof__ (x128) < 128)
+    abort ();
+
+  if (__alignof__ (y128) < 128)
+    abort ();
+
+  if (__alignof__ (z128) < 128)
+    abort (); 
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-align.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-align.c
new file mode 100644
index 000000000..c1b4ded37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-align.c
@@ -0,0 +1,47 @@
+/* Prove that HANDLE_SYSTEMV_PRAGMA alignment handling works somewhat. */
+
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* i?86-*-*bsd* *-*-solaris2.* } } */
+
+extern void abort (void);
+
+struct {
+        char one;
+        long two;
+} defaultalign;
+
+#if defined(__LP64__)
+#pragma pack(8)
+#else
+#pragma pack(4)
+#endif
+struct {
+        char one;
+        long two;
+} sixteen;
+
+#pragma pack(1)
+struct {
+        char one;
+        long two;
+} two;
+
+#pragma pack(2)
+struct {
+        char one;
+        long two;
+} three;
+
+#pragma pack()
+struct {
+        char one;
+        long two;
+} resetalign;
+
+main()
+{
+        if(sizeof(sixteen) < sizeof(defaultalign)) abort();
+        if(sizeof(two) >= sizeof(defaultalign)) abort();
+        if(sizeof(three) <= sizeof(two)) abort();
+        if(sizeof(resetalign) != sizeof(defaultalign)) abort();
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-darwin-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-darwin-2.c
new file mode 100644
index 000000000..4bbecef01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-darwin-2.c
@@ -0,0 +1,24 @@
+/* Darwin (Mac OS X) pragma exercises.  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+
+/* The mark pragma is valid at any point in the program.  Fortunately
+   the compiler only needs to ignore it.  It's also followed only
+   by pp-tokens, not necessarily real C tokens.  */
+
+void foo(void) 
+{
+  if (1) {
+    ;
+  }
+  else if (1) {
+    ;
+  }
+#pragma mark "last case" "hi"
+  else if (1) {
+    ;
+  }
+}
+
+#pragma mark 802.11x 1_2_3
+#pragma mark •••• marker ••••
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-darwin.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-darwin.c
new file mode 100644
index 000000000..f64095b0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-darwin.c
@@ -0,0 +1,70 @@
+/* Darwin (Mac OS X) pragma exercises.  */
+
+/* { dg-do run { target *-*-darwin* } } */
+/* { dg-options "-O -Wunused" } */
+
+/* The mark pragma is to help decorate IDEs.  */
+
+extern void abort(void);
+
+#pragma mark hey hey ho
+
+/* The options pragma used to do a lot, now it's only for emulating
+   m68k alignment rules in structs.  */
+
+#pragma options 23  /* { dg-warning "malformed '#pragma options'" } */
+#pragma options align  /* { dg-warning "malformed '#pragma options'" } */
+#pragma options align natural /* { dg-warning "malformed '#pragma options'" } */
+#pragma options align=45 /* { dg-warning "malformed '#pragma options'" } */
+#pragma options align=foo /* { dg-warning "malformed '#pragma options align" } */
+
+#ifndef __LP64__
+#pragma options align=mac68k
+struct s1 { short f1; int f2; };
+#endif
+#pragma options align=power
+struct s2 { short f1; int f2; };
+#ifndef __LP64__
+#pragma options align=mac68k
+struct s3 { short f1; int f2; };
+#endif
+#pragma options align=reset
+struct s4 { short f1; int f2; };
+
+#pragma options align=natural foo /* { dg-warning "junk at end of '#pragma options'" } */
+/* { dg-warning "malformed '#pragma options align={mac68k|power|reset}', ignoring" "ignoring" { target *-*-* } 34 } */
+
+/* Segment pragmas don't do anything anymore.  */
+
+#pragma segment foo
+
+int
+main ()
+{
+  int x, z;  /* { dg-warning "unused variable 'z'" } */
+  #pragma unused (x, y)
+
+#ifndef __LP64__
+  if (sizeof (struct s1) != 6)
+    abort ();
+#endif
+  if (sizeof (struct s2) != 8)
+    abort ();
+#ifndef __LP64__
+  if (sizeof (struct s3) != 6)
+    abort ();
+#endif
+  if (sizeof (struct s4) != 8)
+    abort ();
+  return 0;
+}
+
+void
+unused_err_test ()
+{
+  int a, b;
+  /* Trying to match on '(' or ')' gives regexp headaches, use . instead.  */
+#pragma unused  /* { dg-warning "missing '.' after '#pragma unused" } */
+#pragma unused (a  /* { dg-warning "missing '.' after '#pragma unused" } */
+#pragma unused (b) foo /* { dg-warning "junk at end of '#pragma unused'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-1.c
new file mode 100644
index 000000000..e110ff900
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-1.c
@@ -0,0 +1,27 @@
+/* { dg-do compile { target *-*-osf5* } } */
+/* { dg-final { scan-assembler "xyzzy_one" } } */
+/* { dg-final { scan-assembler "xyzzy_two" } } */
+/* { dg-final { scan-assembler "xyzzz_three" } } */
+/* { dg-final { scan-assembler "four" } } */
+/* { dg-final { scan-assembler-not "_four" } } */
+
+#ifndef __PRAGMA_EXTERN_PREFIX
+#error
+#endif
+
+#pragma extern_prefix "xyzzy_"
+
+extern int one(void);
+extern int two(void);
+
+#pragma extern_prefix "xyzzz_"
+
+extern int three(void);
+
+#pragma extern_prefix ""
+
+extern int four(void);
+
+int (*p[]) (void) = {
+  one, two, three, four
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-2.c
new file mode 100644
index 000000000..1151d9b4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile { target *-*-osf5* } } */
+
+#pragma extern_prefix			/* { dg-warning "malformed" } */
+#pragma extern_prefix foo		/* { dg-warning "malformed" } */
+#pragma extern_prefix "foo" 1		/* { dg-warning "junk" } */
+
+int bar; /* silence `ISO C forbids an empty translation unit' warning */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-3.c
new file mode 100644
index 000000000..a3e1e6e68
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ep-3.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target alpha*-*-osf5* } } */
+/* { dg-final { scan-assembler ",Xfoo" } } */
+
+#pragma extern_prefix "X"
+void foo(void) __attribute__((noreturn));
+void foo(void) __attribute__((noreturn));
+void bar()
+{
+  foo();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-init-fini-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-init-fini-2.c
new file mode 100644
index 000000000..91bc622a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-init-fini-2.c
@@ -0,0 +1,15 @@
+/* Tests for #pragma init and #pragma fini.  */
+
+/* { dg-do link { target *-*-solaris2.* } } */
+/* { dg-options "-fpic" } */
+
+#include <stdio.h>
+
+#pragma fini (f)
+
+void f() {
+  fprintf (stderr, "f\n");
+}
+
+int main () {
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-init-fini.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-init-fini.c
new file mode 100644
index 000000000..4013b8dd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-init-fini.c
@@ -0,0 +1,50 @@
+/* Tests for #pragma init and #pragma fini.  */
+
+/* { dg-do run { target *-*-solaris2.* } } */
+
+extern void abort ();
+
+#pragma init		/* { dg-warning "malformed" } */
+#pragma init ()		/* { dg-warning "malformed" } */
+#pragma init init_func	/* { dg-warning "malformed" } */
+
+#pragma fini		/* { dg-warning "malformed" } */
+#pragma fini ()		/* { dg-warning "malformed" } */
+#pragma fini fini_func	/* { dg-warning "malformed" } */
+
+#pragma init (init_func, init_static_func)
+
+int glob_1, glob_2;
+
+void init_func (void)
+{
+  glob_1 = 1;
+}
+
+static void init_static_func (void)
+{
+  glob_2 = 2;
+}
+
+#pragma fini (fini_func, fini_static_func)
+
+void fini_func (void)
+{
+
+}
+
+static void fini_static_func (void)
+{
+
+}
+
+int main()
+{
+  if (glob_1 != 1)
+    abort ();
+
+  if (glob_2 != 2)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-nosave_low_regs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-nosave_low_regs.c
new file mode 100644
index 000000000..c71c88cb7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-nosave_low_regs.c
@@ -0,0 +1,20 @@
+/* { dg-do compile { target { { sh-*-* sh[1234ble]*-*-* } && nonpic } } } */
+/* { dg-options "-O" } */
+extern void foo ();
+#pragma interrupt
+#pragma nosave_low_regs
+void
+isr()
+{
+  foo ();
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
+/* A call will clobber all call-saved registers, but because of
+   #pragma nosave_low_regs, r0..r7 need not be saved/restored.
+   One of these registers will also do fine to hold the function address.
+   Call-saved registers r8..r13 also don't need to be restored.  */
+/* { dg-final { scan-assembler-not "\[^f\]r\[0-9\]\[ \t\]*," } } */
+/* { dg-final { scan-assembler-not "\[^f\]r\[89\]" } } */
+/* { dg-final { scan-assembler-not "\[^f\]r1\[,0-3\]" } } */
+/* { dg-final { scan-assembler-times "macl" 2} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trap_exit.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trap_exit.c
new file mode 100644
index 000000000..00a0608cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trap_exit.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target sh-*-* sh[1234ble]*-*-* } } */
+/* { dg-options "-O" } */
+/* This test case will check whether trapa is generated only for isr.  */
+#pragma interrupt
+void isr() __attribute__ ((trap_exit (4)));
+void isr()
+{
+}
+void delay(int a)
+{
+}
+int main()
+{
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "trapa\[ \t\]\[ \t\]*#4" 1} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trapa.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trapa.c
new file mode 100644
index 000000000..2d32885db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trapa.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target { { sh-*-* sh[1234ble]*-*-* } && nonpic } } } */
+/* { dg-options "-O" } */
+extern void foo ();
+#pragma trapa
+void
+isr()
+{
+  foo ();
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
+/* No interrupt-specific saves should be needed.  /
+/* { dg-final { scan-assembler-not "r\[0-7\]\[ \t,\]\[^\n\]*r15" } } */
+/* { dg-final { scan-assembler-not "@r15\[^\n\]*r\[0-7\]\n" } } */
+/* { dg-final { scan-assembler-not "r\[8-9\]" } } */
+/* { dg-final { scan-assembler-not "r1\[,0-3\]" } } */
+/* { dg-final { scan-assembler-not "macl" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trapa2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trapa2.c
new file mode 100644
index 000000000..7b68185fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr-trapa2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target { { sh-*-* sh4*-*-* } && nonpic } } } */
+/* { dg-options "-O -m4" } */
+
+extern void foo ();
+#pragma trapa
+void
+isr()
+{
+  foo ();
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
+/* No interrupt-specific saves should be needed.
+   The function call will require to load the address first into a register,
+   then use that for a jsr or jmp.  It will also need to load a constant
+   address in order to load fpscr.  */
+/* { dg-final { scan-assembler-times "r\[0-7\]\n" 3 } } */
+/* { dg-final { scan-assembler-not "r\[8-9\]" } } */
+/* { dg-final { scan-assembler-not "r1\[,0-3\]" } } */
+/* { dg-final { scan-assembler-not "macl" } } */
+/* fpscr needs to be saved, loaded and restored.  */
+/* { dg-final { scan-assembler-times "\[^_\]fpscr" 3 } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr.c
new file mode 100644
index 000000000..e7565a682
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target h8300-*-* sh-*-* sh[1234ble]*-*-* } } */
+/* { dg-options "-O3" } */
+/* Test case will check whether rte is generated for two ISRs*/
+extern void foo();
+#pragma interrupt
+void  isr1(void)
+{
+		foo();
+}
+
+#pragma interrupt
+void  isr2(void)
+{
+		foo();
+}
+
+/* { dg-final { scan-assembler-times "rte" 2} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr2.c
new file mode 100644
index 000000000..3e2e4bb38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-isr2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile { target h8300-*-* sh-*-* sh[1234ble]*-*-* } } */
+/* { dg-options "-O" } */
+/* This test case will check whether rte is generated only for isr.  */
+#pragma interrupt
+void isr()
+{
+}
+void delay(int a)
+{
+}
+int main()
+{
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "rte" 1} } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-message.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-message.c
new file mode 100644
index 000000000..0f9c6bf44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-message.c
@@ -0,0 +1,53 @@
+/* Test that #pragma message "..." writes compiler messages. */
+
+#pragma message                  /* { dg-warning "expected a string" } */
+#pragma message 0                /* { dg-warning "expected a string" } */
+#pragma message id               /* { dg-warning "expected a string" } */
+#pragma message (                /* { dg-warning "expected a string" } */
+#pragma message (0               /* { dg-warning "expected a string" } */
+#pragma message (id              /* { dg-warning "expected a string" } */
+#pragma message ()               /* { dg-warning "expected a string" } */
+#pragma message (0)              /* { dg-warning "expected a string" } */
+#pragma message (id)             /* { dg-warning "expected a string" } */
+
+/* gcc prefixes '#pragma message ...' output with filename and line number,
+   then 'note: #pragma message: ', allowing dg-message to check output.
+   If unexpected pragma messages are printed (anything not caught by a
+   matching dg-message), dejagnu will report these as excess errors.  */
+
+#pragma message "
+/* { dg-error "missing terminating" "" { target *-*-* } 18 } */
+/* { dg-warning "expected a string" "" { target *-*-* } 18 } */
+#pragma message "Bad 1
+/* { dg-error "missing terminating" "" { target *-*-* } 21 } */
+/* { dg-warning "expected a string" "" { target *-*-* } 21 } */
+#pragma message ("Bad 2
+/* { dg-error "missing terminating" "" { target *-*-* } 24 } */
+/* { dg-warning "expected a string" "" { target *-*-* } 24 } */
+#pragma message ("Bad 3"
+/* { dg-warning "malformed '#pragma message" "" { target *-*-* } 27 } */
+
+#pragma message "" junk
+/* { dg-warning "junk at end of '#pragma message'" "" { target *-*-* } 30 } */
+
+#pragma message ("") junk
+/* { dg-warning "junk at end of '#pragma message'" "" { target *-*-* } 33 } */
+
+#pragma message ""               /* No output expected for empty messages.  */
+#pragma message ("")
+
+#pragma message "Okay 1"         /* { dg-message "Okay 1" } */
+#pragma message ("Okay 2")       /* { dg-message "Okay 2" } */
+#define THREE "3"
+#pragma message ("Okay " THREE)  /* { dg-message "Okay 3" } */
+
+/* Create a TODO() that prints a message on compilation.  */
+#define DO_PRAGMA(x) _Pragma (#x)
+#define TODO(x) DO_PRAGMA(message ("TODO - " #x))
+TODO(Okay 4)                     /* { dg-message "TODO - Okay 4" } */
+
+#if 0
+#pragma message ("Not printed")
+#endif
+
+int unused;  /* Silence `ISO C forbids an empty translation unit' warning.  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ms_struct.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ms_struct.c
new file mode 100644
index 000000000..cc7161014
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-ms_struct.c
@@ -0,0 +1,21 @@
+/* Darwin pragma for __attribute__ ((ms_struct)).  */
+
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-Wall" } */
+
+#pragma ms_struct on
+
+#pragma ms_struct off
+
+#pragma ms_struct reset
+
+#pragma ms_struct /* { dg-warning "malformed" } */
+
+#pragma ms_struct on top of spaghetti /* { dg-warning "junk" } */
+
+struct foo
+{
+  int a;
+  int b;
+  char c;
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-2.c
new file mode 100644
index 000000000..f44f8dbba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-2.c
@@ -0,0 +1,48 @@
+/* On Solaris, #pragma pack should accept macro expansion.  */
+
+/* { dg-do run { target *-*-solaris2.* } } */
+
+extern void abort (void);
+
+struct {
+        char one;
+        long two;
+} defaultalign;
+
+#define ALIGNHIGH 16
+
+#pragma pack(ALIGNHIGH)
+struct {
+        char one;
+        long two;
+} sixteen;
+
+#define ALIGN1(X) 1
+#pragma pack(ALIGN1(4))
+struct {
+        char one;
+        long two;
+} two;
+
+#define ALIGN2(X) X
+#pragma pack(ALIGN2(2))
+struct {
+        char one;
+        long two;
+} three;
+
+#define EMPTY
+#pragma pack(EMPTY)
+struct {
+        char one;
+        long two;
+} resetalign;
+
+main()
+{
+        if(sizeof(sixteen) < sizeof(defaultalign)) abort();
+        if(sizeof(two) >= sizeof(defaultalign)) abort();
+        if(sizeof(three) <= sizeof(two)) abort();
+        if(sizeof(resetalign) != sizeof(defaultalign)) abort();
+	return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-3.c
new file mode 100644
index 000000000..e276bd007
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-3.c
@@ -0,0 +1,27 @@
+/* PR c++/25294 */
+/* { dg-options "-std=gnu99" } */
+/* { dg-do run } */
+
+extern void abort (void);
+
+struct S
+{
+  char a[3];
+#pragma pack(1) /* A block comment
+		   that ends on the next line.  */
+  struct T
+  {
+    char b;
+    int c;
+  } d;
+#pragma pack /*/ */ () // C++ comment
+  int e;
+} s;
+
+int
+main ()
+{
+  if (sizeof (int) == 4 && sizeof (s) != 12)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-4.c
new file mode 100644
index 000000000..05a24e5d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-4.c
@@ -0,0 +1,8 @@
+/* PR c/28286 */
+/* { dg-do compile } */
+/* { dg-skip-if "no Pragma pack" { "avr-*-*" } { "*" } { "" } } */
+
+
+#pragma pack(0.5)         /* { dg-warning "invalid constant" } */
+#pragma pack(push,0.5)    /* { dg-warning "invalid constant" } */
+#pragma pack(push,x,0.5)  /* { dg-warning "invalid constant" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-5.c
new file mode 100644
index 000000000..897686f77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-pack-5.c
@@ -0,0 +1,10 @@
+/* Check that pragma pack overrides STRUCTURE_SIZE_BOUNDARY.  */
+/* { dg-do compile } */
+
+#pragma pack(1)
+struct S
+{
+  char a;
+};
+
+int test[sizeof(struct S) == 1 ? 1: -1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-push_macro-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-push_macro-1.c
new file mode 100644
index 000000000..ac5d059b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-push_macro-1.c
@@ -0,0 +1,26 @@
+/* Prove that HANDLE_PRAGMA_PUSH_POP_MACRO handling works somewhat. */
+
+/* { dg-do link { target *-*-mingw* } } */
+
+#define TEXT1  "ABC"
+#define TEXT2  "DEF"
+
+int main()
+{
+  if (__builtin_strcmp (TEXT1 TEXT2, "ABCDEF") != 0)
+    link_error ();
+
+#pragma push_macro("TEXT1")
+#undef TEXT1
+#define TEXT1  "XYZ"
+
+  if (__builtin_strcmp (TEXT1 TEXT2, "XYZDEF") != 0)
+    link_error ();
+
+#pragma pop_macro("TEXT1")
+
+  if (__builtin_strcmp (TEXT1 TEXT2, "ABCDEF") != 0)
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-1.c
new file mode 100644
index 000000000..9b9edadc9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile { target *-*-solaris* } } */
+/* { dg-final { scan-assembler "bar" } } */
+/* { dg-final { scan-assembler-not "foo" } } */
+
+#ifndef __PRAGMA_REDEFINE_EXTNAME
+#error 
+#endif
+
+#pragma redefine_extname foo bar
+extern int foo(void);
+int (*p)(void) = foo;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-2.c
new file mode 100644
index 000000000..e86bb87c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-2.c
@@ -0,0 +1,8 @@
+/* { dg-do compile { target *-*-solaris* } } */
+
+#pragma redefine_extname		/* { dg-warning "malformed" } */
+#pragma redefine_extname foo		/* { dg-warning "malformed" } */
+#pragma redefine_extname foo 1		/* { dg-warning "malformed" } */
+#pragma redefine_extname foo bar 2	/* { dg-warning "junk" } */
+
+int bar; /* silence `ISO C forbids an empty translation unit' warning */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-3.c
new file mode 100644
index 000000000..4a73c414b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-3.c
@@ -0,0 +1,18 @@
+/* { dg-do link { target *-*-solaris* } } */
+
+#pragma redefine_extname f1 f
+#pragma redefine_extname g1 g
+
+void f() {
+  extern int f1();
+  f1();
+}
+
+void g() {
+  g1();
+}
+
+int main () {
+  f();
+  g();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-4.c
new file mode 100644
index 000000000..9b5a26d20
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pragma-re-4.c
@@ -0,0 +1,18 @@
+/* Copyright (C) 2006 Free Software Foundation, Inc. */
+/* Contributed by Carlos O'Donell on 2006-01-27 */
+
+/* Origin: Carlos O'Donell <carlos@codesourcery.com> */
+/* { dg-do compile { target *-*-solaris* } } */
+/* { dg-final { scan-assembler "_foo" } } */
+/* { dg-final { scan-assembler-not "_foo64" } } */
+
+#define foo     _foo
+#define foo64   _foo64
+extern int foo(void);
+extern int foo64(void);
+#pragma redefine_extname foo64 foo
+int
+bar()
+{
+        return (foo64());
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/precedence-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/precedence-1.c
new file mode 100644
index 000000000..f3f1e3527
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/precedence-1.c
@@ -0,0 +1,153 @@
+/* Test precedence and associativity in expressions.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s { int *a; } *p, q, *r[2], *g();
+int *i[2];
+int j[2];
+_Complex double c[2];
+
+void
+f (void)
+{
+#define ASSERT(expr) do { char x[(expr) ? 1 : -1]; } while (0)
+  /* Postfix and unary operators and casts.  */
+  *p++;
+  *p--;
+  *p->a;
+  *q.a;
+  *r[1];
+  (*g()).a;
+  ++i[0];
+  --i[0];
+  +j[0];
+  -j[0];
+  ~j[0];
+  !j[0];
+  __real__ c[1];
+  __imag__ c[1];
+  ASSERT ((sizeof p++) == (sizeof p));
+  ASSERT ((sizeof (int) + 1) == ((sizeof (int)) + 1));
+  ASSERT ((__alignof p++) == (__alignof p));
+  ASSERT ((__alignof (int) + 1) == ((__alignof (int)) + 1));
+  ASSERT ((sizeof __extension__ 1 + 1) == ((sizeof 1) + 1));
+  /* Binary operators.  */
+  ASSERT (((_Bool) 1 * 2) == 2);
+  ASSERT (((_Bool) 8 / 4) == 0);
+  ASSERT (((_Bool) 8 % 4) == 1);
+#define ASSERT_BIN(C1, O1, C2, O2, C3, V1, V2, V3)	\
+  do {							\
+    ASSERT ((C1 O1 C2 O2 C3) == V1);			\
+    ASSERT (((C1 O1 C2) O2 C3) == V2);			\
+    ASSERT ((C1 O1 (C2 O2 C3)) == V3);			\
+  } while (0);
+  ASSERT_BIN (1, *, 2, *, 3, 6, 6, 6);
+  ASSERT_BIN (2, *, 2, /, 3, 1, 1, 0);
+  ASSERT_BIN (2, *, 2, %, 3, 1, 1, 4);
+  ASSERT_BIN (2, /, 2, *, 3, 3, 3, 0);
+  ASSERT_BIN (2, /, 2, /, 2, 0, 0, 2);
+  ASSERT_BIN (2, /, 4, %, 3, 0, 0, 2);
+  ASSERT_BIN (2, %, 2, *, 3, 0, 0, 2);
+  ASSERT_BIN (2, %, 9, /, 3, 0, 0, 2);
+  ASSERT_BIN (2, %, 4, %, 3, 2, 2, 0);
+  ASSERT_BIN (2, *, 3, +, 4, 10, 10, 14);
+  ASSERT_BIN (2, *, 3, -, 4, 2, 2, -2);
+  ASSERT_BIN (2, /, 3, +, 4, 4, 4, 0);
+  ASSERT_BIN (2, /, 3, -, 4, -4, -4, -2);
+  ASSERT_BIN (2, %, 3, +, 4, 6, 6, 2);
+  ASSERT_BIN (2, %, 3, -, 4, -2, -2, 0);
+  ASSERT_BIN (2, +, 3, *, 4, 14, 20, 14);
+  ASSERT_BIN (2, +, 3, /, 4, 2, 1, 2);
+  ASSERT_BIN (2, +, 3, %, 4, 5, 1, 5);
+  ASSERT_BIN (2, -, 3, *, 4, -10, -4, -10);
+  ASSERT_BIN (2, -, 3, /, 4, 2, 0, 2);
+  ASSERT_BIN (2, -, 4, %, 4, 2, -2, 2);
+  ASSERT_BIN (2, +, 3, +, 4, 9, 9, 9);
+  ASSERT_BIN (2, +, 3, -, 4, 1, 1, 1);
+  ASSERT_BIN (2, -, 3, +, 4, 3, 3, -5);
+  ASSERT_BIN (2, -, 3, -, 4, -5, -5, 3);
+  ASSERT_BIN (3, +, 2, <<, 4, 80, 80, 35);
+  ASSERT_BIN (3, +, 2, >>, 4, 0, 0, 3);
+  ASSERT_BIN (3, -, 2, <<, 4, 16, 16, -29);
+  ASSERT_BIN (3, -, 2, >>, 4, 0, 0, 3);
+  ASSERT_BIN (2, <<, 4, +, 3, 256, 35, 256);
+  ASSERT_BIN (2, <<, 4, -, 3, 4, 29, 4);
+  ASSERT_BIN (2, >>, 4, +, 3, 0, 3, 0);
+  ASSERT_BIN (2, >>, 4, -, 3, 1, -3, 1);
+  ASSERT_BIN (4L, <<, 2L, <<, 3L, 128L, 128L, 262144L);
+  ASSERT_BIN (4L, <<, 2L, >>, 3L, 2L, 2L, 4L);
+  ASSERT_BIN (4L, >>, 2L, <<, 3L, 8L, 8L, 0L);
+  ASSERT_BIN (4L, >>, 2L, >>, 3L, 0L, 0L, 4L);
+  ASSERT_BIN (2, <<, 5, <, 4, 0, 0, 2);
+  ASSERT_BIN (2, <<, 5, >, 4, 1, 1, 4);
+  ASSERT_BIN (2, <<, 5, <=, 4, 0, 0, 2);
+  ASSERT_BIN (2, <<, 5, >=, 4, 1, 1, 4);
+  ASSERT_BIN (2, >>, 5, <, 4, 1, 1, 2);
+  ASSERT_BIN (2, >>, 5, >, 4, 0, 0, 1);
+  ASSERT_BIN (2, >>, 5, <=, 4, 1, 1, 2);
+  ASSERT_BIN (2, >>, 5, >=, 4, 0, 0, 1);
+  ASSERT_BIN (4, <, 3, <<, 2, 1, 0, 1);
+  ASSERT_BIN (4, <, 20, >>, 2, 1, 0, 1);
+  ASSERT_BIN (4, >, 3, <<, 2, 0, 4, 0);
+  ASSERT_BIN (4, >, 3, >>, 2, 1, 0, 1);
+  ASSERT_BIN (4, <=, 3, <<, 2, 1, 0, 1);
+  ASSERT_BIN (4, <=, 20, >>, 2, 1, 0, 1);
+  ASSERT_BIN (4, >=, 3, <<, 2, 0, 4, 0);
+  ASSERT_BIN (4, >=, 3, >>, 2, 1, 0, 1);
+  ASSERT_BIN (1, <, 2, <, 3, 1, 1, 0);
+  ASSERT_BIN (1, <, 2, >, 0, 1, 1, 0);
+  ASSERT_BIN (1, <, 2, <=, 3, 1, 1, 0);
+  ASSERT_BIN (0, <, 4, >=, 3, 0, 0, 1);
+  ASSERT_BIN (1, >, 2, <, 3, 1, 1, 0);
+  ASSERT_BIN (1, >, 2, >, 3, 0, 0, 1);
+  ASSERT_BIN (1, >, 2, <=, 3, 1, 1, 0);
+  ASSERT_BIN (1, >, 2, >=, 3, 0, 0, 1);
+  ASSERT_BIN (3, <=, 2, <, 3, 1, 1, 0);
+  ASSERT_BIN (2, <=, 3, >, 0, 1, 1, 0);
+  ASSERT_BIN (2, <=, 3, <=, 4, 1, 1, 0);
+  ASSERT_BIN (2, <=, 3, >=, 1, 1, 1, 0);
+  ASSERT_BIN (0, >=, 2, <, 3, 1, 1, 0);
+  ASSERT_BIN (1, >=, 2, >, 3, 0, 0, 1);
+  ASSERT_BIN (0, >=, 2, <=, 3, 1, 1, 0);
+  ASSERT_BIN (1, >=, 2, >=, 3, 0, 0, 1);
+  ASSERT_BIN (-1, <, 2, ==, 3, 0, 0, 1);
+  ASSERT_BIN (1, <, 2, !=, 3, 1, 1, 0);
+  ASSERT_BIN (1, >, 2, ==, 3, 0, 0, 1);
+  ASSERT_BIN (1, >, 2, !=, 3, 1, 1, 0);
+  ASSERT_BIN (0, <=, 2, ==, 3, 0, 0, 1);
+  ASSERT_BIN (2, <=, 2, !=, 3, 1, 1, 0);
+  ASSERT_BIN (1, >=, 2, ==, 3, 0, 0, 1);
+  ASSERT_BIN (0, >=, 2, !=, 3, 1, 1, 0);
+  ASSERT_BIN (1, ==, 3, <, 2, 0, 1, 0);
+  ASSERT_BIN (1, ==, 3, >, 2, 1, 0, 1);
+  ASSERT_BIN (1, ==, 3, <=, 2, 0, 1, 0);
+  ASSERT_BIN (1, ==, 3, >=, 2, 1, 0, 1);
+  ASSERT_BIN (1, !=, 2, <, 3, 0, 1, 0);
+  ASSERT_BIN (1, !=, 2, >, 3, 1, 0, 1);
+  ASSERT_BIN (1, !=, 2, <=, 3, 0, 1, 0);
+  ASSERT_BIN (1, !=, 2, >=, 3, 1, 0, 1);
+  ASSERT_BIN (1, ==, 2, ==, 0, 1, 1, 0);
+  ASSERT_BIN (1, ==, 2, !=, 0, 0, 0, 1);
+  ASSERT_BIN (1, !=, 2, ==, 3, 0, 0, 1);
+  ASSERT_BIN (1, !=, 2, !=, 3, 1, 1, 0);
+  ASSERT_BIN (0, ==, 2, &, 1, 0, 0, 1);
+  ASSERT_BIN (0, !=, 2, &, 1, 1, 1, 0);
+  ASSERT_BIN (1, &, 2, ==, 0, 0, 1, 0);
+  ASSERT_BIN (1, &, 2, !=, 0, 1, 0, 1);
+  ASSERT_BIN (1, &, 2, ^, 3, 3, 3, 1);
+  ASSERT_BIN (3, ^, 2, &, 1, 3, 1, 3);
+  ASSERT_BIN (3, ^, 2, |, 1, 1, 1, 0);
+  ASSERT_BIN (3, |, 2, ^, 1, 3, 2, 3);
+  ASSERT_BIN (2, |, 0, &&, 2, 1, 1, 2);
+  ASSERT_BIN (2, &&, 0, |, 2, 1, 2, 1);
+  ASSERT_BIN (0, &&, 0, ||, 1, 1, 1, 0);
+  ASSERT_BIN (1, ||, 0, &&, 0, 1, 0, 1);
+  /* Conditional expressions.  */
+  ASSERT ((1 || 2 ? 3 : 4) == 3);
+  ASSERT ((1 || (2 ? 3 : 4)) == 1);
+  /* Assignment expressions.  */
+  p = p = p;
+  /* Expressions.  */
+  p, p = p;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c
new file mode 100644
index 000000000..59cebc52e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/prefetch-loop-arrays-1.c
@@ -0,0 +1,36 @@
+/* PR tree-optimization/28887 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -w" } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=i686 -msse -w" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+
+struct re_pattern_buffer
+{
+  size_t re_nsub;
+};
+
+typedef enum
+{
+  start_memory,
+} re_opcode_t;
+
+typedef union
+{
+  struct
+  {
+    unsigned matched_something:1;
+  } bits;
+} byte_register_info_type;
+
+void byte_re_match_2_internal (struct re_pattern_buffer *bufp)
+{
+  int mcnt;
+  size_t num_regs = bufp->re_nsub + 1;
+  byte_register_info_type *reg_info;
+  for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
+    {
+      ((reg_info[mcnt]).bits.matched_something) = 0;
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-1.c
new file mode 100644
index 000000000..a0a22ffb0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fprofile-generate=. -fdump-tree-tree_profile" } */
+/* { dg-final { scan-tree-dump " ./profile-dir-1.gcda" "tree_profile" } } */
+
+int
+main(void)
+{
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
+/* { dg-final { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-2.c
new file mode 100644
index 000000000..454f0641a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fprofile-generate -fdump-tree-tree_profile" } */
+/* { dg-final { scan-tree-dump "/profile-dir-2.gcda" "tree_profile" } } */
+
+int
+main(void)
+{
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
+/* { dg-final { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-3.c
new file mode 100644
index 000000000..29b0a5587
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-dir-3.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fprofile-generate -fprofile-dir=. -fdump-tree-tree_profile" } */
+/* { dg-final { scan-tree-dump " ./profile-dir-3.gcda" "tree_profile" } } */
+
+int
+main(void)
+{
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
+/* { dg-final { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-generate-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-generate-1.c
new file mode 100644
index 000000000..fe51754bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-generate-1.c
@@ -0,0 +1,37 @@
+/* Bug 16325.  */
+/* { dg-options "-O -fprofile-generate" } */
+
+extern void abort (void);
+
+int *p1;
+int *p2;
+int *p3;
+
+int ga = 100;
+
+int
+sub (int i, int j)
+{
+  int k;
+  int l;
+  int m;
+  int n;
+  p1 = &k;
+  p2 = &l;
+  p3 = &m;
+  k = 20;
+  l = 30;
+  m = 40;
+  n = i / j;
+  return n + ga;
+}
+
+int
+main(void)
+{
+  if (sub (99, 33) != 103)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-generate-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-generate-2.c
new file mode 100644
index 000000000..eaea065f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/profile-generate-2.c
@@ -0,0 +1,35 @@
+/* PR middle-end/23199 */
+/* Testcase by Ralf Menzel <menzel@ls6.cs.uni-dortmund.de> */
+
+/* { dg-do compile } */
+/* { dg-options "-O -fprofile-generate" } */
+
+union rtunion_def
+{
+  struct rtx_def *rt_rtx;
+};
+
+typedef union rtunion_def rtunion;
+
+struct rtx_def
+{
+  unsigned int in_struct : 1;
+  union u {
+    rtunion fld[1];
+  } u;
+};
+
+typedef struct rtx_def *rtx;
+
+static void
+check_annul_list_true_false (int annul_true_p, rtx delay_list)
+{
+  rtx temp;
+  while (1)
+    {
+      temp = delay_list;
+      rtx trial = (((temp)->u.fld[0]).rt_rtx);
+      if ((annul_true_p && (((trial))->in_struct)))
+       return;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/proto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/proto-1.c
new file mode 100644
index 000000000..62d0209b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/proto-1.c
@@ -0,0 +1,5 @@
+/* PR c/28502 */
+/* { dg-do compile } */
+
+void foo() {}      /* { dg-message "note: previous" } */
+void foo(void[]);  /* { dg-error "array of voids" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-1.c
new file mode 100644
index 000000000..2f78844fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-1.c
@@ -0,0 +1,12 @@
+/* Ensure we get clean warning results when using the pthread
+ * initialization macros.
+ *
+ * Origin: Kaveh Ghazi (ghazi@caip.rutgers.edu) 9/27/2006.
+ */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target pthread_h } */
+/* { dg-options "-Wextra -Wall" } */
+
+#include "pthread-init-common.h"
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-2.c
new file mode 100644
index 000000000..3e8a17e23
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-2.c
@@ -0,0 +1,13 @@
+/* Various Solaris versions have been known to have problems with the
+ * pthread initialization macros when __STDC__ is defined.
+ *
+ * Origin: Kaveh Ghazi (ghazi@caip.rutgers.edu) 9/27/2006.
+ */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target pthread_h } */
+/* { dg-options "-Wextra -Wall -ansi" } */
+/* { dg-options "-Wextra -Wall -ansi -D_POSIX_C_SOURCE=199506L" { target { *-*-hpux* } } } */
+
+#include "pthread-init-common.h"
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-common.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-common.h
new file mode 100644
index 000000000..723d997c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pthread-init-common.h
@@ -0,0 +1,39 @@
+/* 
+ * Common code for the pthread-init-*.c tests.
+ *
+ * Origin: Kaveh Ghazi (ghazi@caip.rutgers.edu) 9/27/2006.
+ */
+
+#define _GNU_SOURCE
+
+#include <pthread.h>
+#define UNUSED __attribute__ ((__unused__))
+
+void foo(void)
+{
+#ifdef PTHREAD_MUTEX_INITIALIZER
+  pthread_mutex_t pmutex UNUSED = PTHREAD_MUTEX_INITIALIZER;
+#endif
+#ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+  pthread_mutex_t pmutex_rc UNUSED = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+#endif
+#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+  pthread_mutex_t pmutex_ec UNUSED = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
+#endif
+#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
+  pthread_mutex_t pmutex_ad UNUSED = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP;
+#endif
+#ifdef PTHREAD_COND_INITIALIZER
+  pthread_cond_t pcond UNUSED = PTHREAD_COND_INITIALIZER;
+#endif
+#ifdef PTHREAD_RWLOCK_INITIALIZER
+  pthread_rwlock_t prwlock UNUSED = PTHREAD_RWLOCK_INITIALIZER;
+#endif
+#ifdef PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
+  pthread_rwlock_t prwlock_nrc UNUSED
+    = PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP;
+#endif
+#ifdef PTHREAD_ONCE_INIT
+  pthread_once_t ponce UNUSED = PTHREAD_ONCE_INIT;
+#endif
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-1.c
new file mode 100644
index 000000000..5c6767e8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-1.c
@@ -0,0 +1,47 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-O0 -gdwarf-2 -dA -fno-eliminate-unused-debug-types" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "__debug_pubtypes" } } */
+/* { dg-final { scan-assembler "long+\[ \t\]+0x\[0-9a-f]+\[ \t\]+\[#;]+\[ \t\]+Length of Public Type Names Info" } } */
+/* { dg-final { scan-assembler "used_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler "unused_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+
+struct used_struct 
+{
+  int key;
+  char *name;
+};
+
+struct unused_struct
+{
+  int key1;
+  int f2;
+  double f3;
+  char *f4;
+  struct unused_struct *next;
+};
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  struct used_struct *my_list;
+
+  my_list = (struct used_struct *) malloc (10 * sizeof (struct used_struct));
+  
+  for (i = 0; i < 10; i++)
+    {
+      my_list[i].key = i;
+      my_list[i].name = (char *) malloc (11);
+      sprintf (my_list[i].name, "Alice_%d", i);
+    }
+
+  for (i = 0; i < 10; i++)
+    fprintf (stdout, "Key: %d, Name: %s\n", my_list[i].key, my_list[i].name);
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-2.c
new file mode 100644
index 000000000..fec46617f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-2.c
@@ -0,0 +1,46 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "__debug_pubtypes" } } */
+/* { dg-final { scan-assembler "long+\[ \t\]+0x6a+\[ \t\]+\[#;]+\[ \t\]+Length of Public Type Names Info" } } */
+/* { dg-final { scan-assembler "used_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler-not "unused_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+struct used_struct 
+{
+  int key;
+  char *name;
+};
+
+struct unused_struct
+{
+  int key1;
+  int f2;
+  double f3;
+  char *f4;
+  struct unused_struct *next;
+};
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  struct used_struct *my_list;
+
+  my_list = (struct used_struct *) malloc (10 * sizeof (struct used_struct));
+  
+  for (i = 0; i < 10; i++)
+    {
+      my_list[i].key = i;
+      my_list[i].name = (char *) malloc (11);
+      sprintf (my_list[i].name, "Alice_%d", i);
+    }
+
+  for (i = 0; i < 10; i++)
+    fprintf (stdout, "Key: %d, Name: %s\n", my_list[i].key, my_list[i].name);
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-3.c
new file mode 100644
index 000000000..455dadf17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-3.c
@@ -0,0 +1,83 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "__debug_pubtypes" } } */
+/* { dg-final { scan-assembler "long+\[ \t\]+0x6a+\[ \t\]+\[#;]+\[ \t\]+Length of Public Type Names Info" } } */
+/* { dg-final { scan-assembler "used_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler-not "unused_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler-not "\"list_name_type\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+struct used_struct 
+{
+  int key;
+  char *name;
+};
+
+struct unused_struct
+{
+  int key1;
+  int f2;
+  double f3;
+  char *f4;
+  struct unused_struct *next;
+};
+
+void 
+foo (struct used_struct *list)
+{
+  enum list_name_type {
+    boy_name,
+    girl_name,
+    unknown
+  };
+
+  int b_count = 0;
+  int g_count = 0;
+  int i;
+  enum list_name_type *enum_list;
+
+  enum_list = (enum list_name_type *) malloc (10 * sizeof (enum list_name_type));
+  
+  for (i = 0; i < 10; i++)
+    {
+      if (strncmp (list[i].name, "Alice", 5) == 0)
+	{
+	  enum_list[i] = girl_name;
+	  g_count++;
+	}
+      else if (strncmp (list[i].name, "David", 5) == 0)
+	{
+	  enum_list[i] = boy_name;
+	  b_count++;
+	}
+      else
+	enum_list[i] = unknown;
+    }
+
+}
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  struct used_struct *my_list;
+
+  my_list = (struct used_struct *) malloc (10 * sizeof (struct used_struct));
+  
+  for (i = 0; i < 10; i++)
+    {
+      my_list[i].key = i;
+      my_list[i].name = (char *) malloc (11);
+      sprintf (my_list[i].name, "Alice_%d", i);
+    }
+
+  foo (my_list);
+
+  for (i = 0; i < 10; i++)
+    fprintf (stdout, "Key: %d, Name: %s\n", my_list[i].key, my_list[i].name);
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-4.c
new file mode 100644
index 000000000..db222da4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pubtypes-4.c
@@ -0,0 +1,96 @@
+/* { dg-do compile { target *-*-darwin* } } */
+/* { dg-options "-O0 -gdwarf-2 -dA" } */
+/* { dg-skip-if "Unmatchable assembly" { mmix-*-* } { "*" } { "" } } */
+/* { dg-final { scan-assembler "__debug_pubtypes" } } */
+/* { dg-final { scan-assembler "long+\[ \t\]+0xa1+\[ \t\]+\[#;]+\[ \t\]+Length of Public Type Names Info" } } */
+/* { dg-final { scan-assembler "used_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler-not "unused_struct\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler "\"list_name_type\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler "\"enum_list_array\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+/* { dg-final { scan-assembler "\"field_union\\\\0\"+\[ \t\]+\[#;]+\[ \t\]+external name" } } */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+struct used_struct 
+{
+  int key;
+  char *name;
+  union field_union
+  {
+    char  u_c;
+    int   u_i;
+    long  u_l;
+    double u_d;
+  } u;
+};
+
+struct unused_struct
+{
+  int key1;
+  int f2;
+  double f3;
+  char *f4;
+  struct unused_struct *next;
+};
+
+enum list_name_type {
+  boy_name,
+  girl_name,
+  unknown
+};
+
+
+typedef enum list_name_type *enum_list_array;
+
+enum_list_array enum_list;
+
+void 
+foo (struct used_struct *list)
+{
+  int b_count = 0;
+  int g_count = 0;
+  int i;
+
+  enum_list = (enum_list_array) malloc (10 * sizeof (enum list_name_type));
+
+  for (i = 0; i < 10; i++)
+    {
+      if (strncmp (list[i].name, "Alice", 5) == 0)
+	{
+	  enum_list[i] = girl_name;
+	  g_count++;
+	}
+      else if (strncmp (list[i].name, "David", 5) == 0)
+	{
+	  enum_list[i] = boy_name;
+	  b_count++;
+	}
+      else
+	enum_list[i] = unknown;
+    }
+
+}
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  struct used_struct *my_list;
+
+  my_list = (struct used_struct *) malloc (10 * sizeof (struct used_struct));
+  
+  for (i = 0; i < 10; i++)
+    {
+      my_list[i].key = i;
+      my_list[i].name = (char *) malloc (11);
+      sprintf (my_list[i].name, "Alice_%d", i);
+    }
+
+  foo (my_list);
+
+  for (i = 0; i < 10; i++)
+    fprintf (stdout, "Key: %d, Name: %s\n", my_list[i].key, my_list[i].name);
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/pure-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/pure-1.c
new file mode 100644
index 000000000..f365c8dae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/pure-1.c
@@ -0,0 +1,16 @@
+/* Regression test for PR middle-end/23584 */
+/* Verify that dereferencing a volatile element in a struct causes
+   the function not be pure.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-ipa-pure-const" } */
+
+struct test_a { volatile int a; };
+
+int func_a(struct test_a *a)
+{
+        return a->a;
+}
+
+/* { dg-final { scan-ipa-dump-not "found to be pure: func_a" "pure-const" } } */
+/* { dg-final { cleanup-ipa-dump "pure-const" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-component-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-component-1.c
new file mode 100644
index 000000000..dbf61158f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-component-1.c
@@ -0,0 +1,232 @@
+/* Test qualification of components of qualified structures or unions:
+   should have qualifiers from both the component and the structure or
+   union.  Bug 27697 from Frank Victor Fischer.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s {
+  int a;
+  int b[1];
+  int c[2][3];
+  const int d;
+  const int e[1];
+  const int f[2][3];
+};
+
+union u {
+  int a;
+  int b[1];
+  int c[2][3];
+  const int d;
+  const int e[1];
+  const int f[2][3];
+};
+
+struct cs {
+  const struct s x;
+};
+
+struct s v1;
+union u *v2;
+const struct s *v3;
+const union u v4;
+struct cs v5;
+
+void
+f (void)
+{
+  v1.a = 0;
+  v1.b[0] = 0;
+  *v1.b = 0;
+  v1.c[0][0] = 0;
+  *v1.c[0] = 0;
+  **v1.c = 0;
+  v1.d = 0; /* { dg-error "assignment of read-only" } */
+  v1.e[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v1.e = 0; /* { dg-error "assignment of read-only" } */
+  v1.f[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v1.f[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v1.f = 0; /* { dg-error "assignment of read-only" } */
+
+  v2->a = 0;
+  v2->b[0] = 0;
+  *v2->b = 0;
+  v2->c[0][0] = 0;
+  *v2->c[0] = 0;
+  **v2->c = 0;
+  v2->d = 0; /* { dg-error "assignment of read-only" } */
+  v2->e[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v2->e = 0; /* { dg-error "assignment of read-only" } */
+  v2->f[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v2->f[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v2->f = 0; /* { dg-error "assignment of read-only" } */
+
+  v3->a = 0; /* { dg-error "assignment of read-only" } */
+  v3->b[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v3->b = 0; /* { dg-error "assignment of read-only" } */
+  v3->c[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v3->c[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v3->c = 0; /* { dg-error "assignment of read-only" } */
+  v3->d = 0; /* { dg-error "assignment of read-only" } */
+  v3->e[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v3->e = 0; /* { dg-error "assignment of read-only" } */
+  v3->f[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v3->f[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v3->f = 0; /* { dg-error "assignment of read-only" } */
+
+  v4.a = 0; /* { dg-error "assignment of read-only" } */
+  v4.b[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v4.b = 0; /* { dg-error "assignment of read-only" } */
+  v4.c[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v4.c[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v4.c = 0; /* { dg-error "assignment of read-only" } */
+  v4.d = 0; /* { dg-error "assignment of read-only" } */
+  v4.e[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v4.e = 0; /* { dg-error "assignment of read-only" } */
+  v4.f[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v4.f[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v4.f = 0; /* { dg-error "assignment of read-only" } */
+
+  v5.x.a = 0; /* { dg-error "assignment of read-only" } */
+  v5.x.b[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v5.x.b = 0; /* { dg-error "assignment of read-only" } */
+  v5.x.c[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v5.x.c[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v5.x.c = 0; /* { dg-error "assignment of read-only" } */
+  v5.x.d = 0; /* { dg-error "assignment of read-only" } */
+  v5.x.e[0] = 0; /* { dg-error "assignment of read-only" } */
+  *v5.x.e = 0; /* { dg-error "assignment of read-only" } */
+  v5.x.f[0][0] = 0; /* { dg-error "assignment of read-only" } */
+  *v5.x.f[0] = 0; /* { dg-error "assignment of read-only" } */
+  **v5.x.f = 0; /* { dg-error "assignment of read-only" } */
+}
+
+void
+g (void)
+{
+  {
+    int *a = &v1.a;
+    int (*b)[1] = &v1.b;
+    int (*c)[2][3] = &v1.c;
+    int (*cc)[3] = v1.c;
+    const int (*ff)[3] = v1.c; /* { dg-warning "initialization from incompatible pointer type" } */
+    a = &v1.a;
+    b = &v1.b;
+    c = &v1.c;
+    cc = v1.c;
+    ff = v1.c; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+  {
+    const int *d = &v1.d;
+    const int (*e)[1] = &v1.e;
+    const int (*f)[2][3] = &v1.f;
+    const int (*ff)[3] = v1.f;
+    int (*cc)[3] = v1.f; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v1.d;
+    e = &v1.e;
+    f = &v1.f;
+    ff = v1.f;
+    cc = v1.f; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+
+  {
+    int *a = &v2->a;
+    int (*b)[1] = &v2->b;
+    int (*c)[2][3] = &v2->c;
+    int (*cc)[3] = v2->c;
+    const int (*ff)[3] = v2->c; /* { dg-warning "initialization from incompatible pointer type" } */
+    a = &v2->a;
+    b = &v2->b;
+    c = &v2->c;
+    cc = v2->c;
+    ff = v2->c; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+  {
+    const int *d = &v2->d;
+    const int (*e)[1] = &v2->e;
+    const int (*f)[2][3] = &v2->f;
+    const int (*ff)[3] = v2->f;
+    int (*cc)[3] = v2->f; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v2->d;
+    e = &v2->e;
+    f = &v2->f;
+    ff = v2->f;
+    cc = v2->f; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+
+  {
+    const int *d = &v3->a;
+    const int (*e)[1] = &v3->b;
+    const int (*f)[2][3] = &v3->c;
+    const int (*ff)[3] = v3->c;
+    int (*cc)[3] = v3->c; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v3->a;
+    e = &v3->b;
+    f = &v3->c;
+    ff = v3->c;
+    cc = v3->c; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+  {
+    const int *d = &v3->d;
+    const int (*e)[1] = &v3->e;
+    const int (*f)[2][3] = &v3->f;
+    const int (*ff)[3] = v3->f;
+    int (*cc)[3] = v3->f; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v3->d;
+    e = &v3->e;
+    f = &v3->f;
+    ff = v3->f;
+    cc = v3->f; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+
+  {
+    const int *d = &v4.a;
+    const int (*e)[1] = &v4.b;
+    const int (*f)[2][3] = &v4.c;
+    const int (*ff)[3] = v4.c;
+    int (*cc)[3] = v4.c; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v4.a;
+    e = &v4.b;
+    f = &v4.c;
+    ff = v4.c;
+    cc = v4.c; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+  {
+    const int *d = &v4.d;
+    const int (*e)[1] = &v4.e;
+    const int (*f)[2][3] = &v4.f;
+    const int (*ff)[3] = v4.f;
+    int (*cc)[3] = v4.f; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v4.d;
+    e = &v4.e;
+    f = &v4.f;
+    ff = v4.f;
+    cc = v4.f; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+
+  {
+    const int *d = &v5.x.a;
+    const int (*e)[1] = &v5.x.b;
+    const int (*f)[2][3] = &v5.x.c;
+    const int (*ff)[3] = v5.x.c;
+    int (*cc)[3] = v5.x.c; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v5.x.a;
+    e = &v5.x.b;
+    f = &v5.x.c;
+    ff = v5.x.c;
+    cc = v5.x.c; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+  {
+    const int *d = &v5.x.d;
+    const int (*e)[1] = &v5.x.e;
+    const int (*f)[2][3] = &v5.x.f;
+    const int (*ff)[3] = v5.x.f;
+    int (*cc)[3] = v5.x.f; /* { dg-warning "initialization from incompatible pointer type" } */
+    d = &v5.x.d;
+    e = &v5.x.e;
+    f = &v5.x.f;
+    ff = v5.x.f;
+    cc = v5.x.f; /* { dg-warning "assignment from incompatible pointer type" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-1.c
new file mode 100644
index 000000000..8151995d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-1.c
@@ -0,0 +1,22 @@
+/* Test for warnings for qualified function return types.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -Wreturn-type -Wignored-qualifiers" } */
+
+/* Qualifying a function return type makes no sense.  */
+
+const int int_fn (void); /* { dg-warning "qualifiers" "int decl" } */
+const int (*int_ptr) (void); /* { dg-warning "qualifiers" "int ptr" } */
+const int int_fn2 (void) { return 0; } /* { dg-warning "qualifiers" "int defn" } */
+
+const void void_fn (void); /* { dg-warning "qualifiers" "void decl" } */
+const void (*void_ptr) (void); /* { dg-warning "qualifiers" "void ptr" } */
+const void void_fn2 (void) { } /* { dg-warning "qualified" "void defn" } */
+
+volatile void vvoid_fn (void); /* { dg-warning "qualifiers" "void decl" } */
+volatile void (*vvoid_ptr) (void); /* { dg-warning "qualifiers" "void ptr" } */
+volatile void vvoid_fn2 (void) { } /* { dg-warning "qualified" "void defn" } */
+
+int *restrict ip_fn (void); /* { dg-warning "qualifiers" "restrict decl" } */
+int *restrict (*ip_ptr) (void); /* { dg-warning "qualifiers" "restrict ptr" } */
+int *restrict ip_fn2 (void) { return (int *)0; }; /* { dg-warning "qualifiers" "restrict defn" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-2.c
new file mode 100644
index 000000000..22a1946b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-2.c
@@ -0,0 +1,13 @@
+/* Test for warnings for qualified function return types.  -pedantic test.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+/* Qualifying a function return type makes no sense.  */
+
+/* The first two of these shouldn't warn (with just -pedantic) as long
+   as the function is not defined.  */
+
+volatile void vvoid_fn (void);
+volatile void (*vvoid_ptr) (void);
+volatile void vvoid_fn2 (void) { } /* { dg-warning "qualified" "volatile defn" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-3.c
new file mode 100644
index 000000000..e65f86d54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-3.c
@@ -0,0 +1,16 @@
+/* Test for warnings for qualified function return types.  Bug 15052
+   from Olatunji Ruwase (tjruwase at stanfordalumni.org): qualifiers
+   should not be lost when merging declarations.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int foo (); /* { dg-message "note: previous declaration" "different qualifiers" } */
+const int foo () { return 0; } /* { dg-error "conflicting types" "different qualifiers" } */
+
+void bar (void);
+volatile void bar () { } /* { dg-warning "qualified|volatile" "different qualifiers" } */
+
+volatile void baz (void);
+void baz () { } /* { dg-warning "not compatible" "different qualifiers" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-4.c
new file mode 100644
index 000000000..9b61cfebf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/qual-return-4.c
@@ -0,0 +1,10 @@
+/* Test for warnings for qualified function return types.  -pedantic
+   test.  Only the definition gets a warning for qualified void return
+   types, not other such types within the definition.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+volatile void (*y)(int);
+
+volatile void (*vvf(int x))(int) { return y; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/range-test-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/range-test-1.c
new file mode 100644
index 000000000..93a90ac71
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/range-test-1.c
@@ -0,0 +1,168 @@
+/* Test fold-const.c (fold_range_test) optimizations.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+
+#if (INT_MAX == 2147483647) && (INT_MIN == -2147483648) \
+    && (SCHAR_MIN == -128) && (SCHAR_MAX == 127) \
+    && (UCHAR_MIN == 0) && (UCHAR_MAX == 255)
+
+#ifndef T
+
+enum integers
+{
+  int_smallest = INT_MIN,
+  int_2ndsmallest = INT_MIN + 1,
+  int_3rdsmallest = INT_MIN + 2,
+  int_minus2 = -2,
+  int_minus1 = -1,
+  int_zero = 0,
+  int_one = 1,
+  int_two = 2,
+  int_3rdlargest = INT_MAX - 2,
+  int_2ndlargest = INT_MAX - 1,
+  int_largest = INT_MAX
+};
+
+int var;
+void
+check (void)
+{
+  ++var;
+}
+
+#define T(IDX, TYPE, TEST, YESARR, NOARR)				\
+void __attribute__((noinline))						\
+test##IDX (TYPE x)							\
+{									\
+  if (TEST)								\
+    check ();								\
+}
+#include "range-test-1.c"
+#undef T
+
+int
+main (void)
+{
+  int i, fails = 0;
+
+#define C ,
+#define T(IDX, TYPE, TEST, YESARR, NOARR)				\
+  {									\
+    static TYPE yesarr##IDX [] = YESARR;				\
+    static TYPE noarr##IDX [] = NOARR;					\
+    for (i = 0; i < (int) (sizeof (yesarr##IDX) / sizeof (TYPE)); ++i)	\
+      {									\
+	var = 0;							\
+	test##IDX (yesarr##IDX [i]);					\
+	if (var != 1)							\
+	  printf ("test" #IDX " failed for yesarr [%u]\n", i), ++fails;	\
+      }									\
+    var = 0;								\
+    for (i = 0; i < (int) (sizeof (noarr##IDX) / sizeof (TYPE)); ++i)	\
+      {									\
+	test##IDX (noarr##IDX [i]);					\
+	if (var != 0)							\
+	  printf ("test" #IDX " failed for noarr [%u]\n", i), ++fails;	\
+      }									\
+  }
+#include "range-test-1.c"
+#undef T
+
+  if (fails)
+    abort ();
+
+  exit (0);
+}
+
+#else
+
+/* Use `C' instead of `,' below to separate array entries.  */
+
+/* These ought to be all optimized into single comparison.  */
+T(1, unsigned int, x == 0 || x == 1,
+  { 0 C 1 }, { -1U C 2 C 12 C 35 C 0x7fffffff C 0x80000000 })
+T(2, unsigned int, x == 0 || x == -1U || x == -2U,
+  { 0 C -1U C -2U }, { -3U C -6U C 1 C 2 C 12 C 35 C 0x7fffffff C 0x80000000 })
+T(3, unsigned int, x == 0 || x == 1 || x == 2,
+  { 0 C 1 C 2 }, { -3U C -6U C -1U C -2U C 12 C 35 C 0x7fffffff C 0x80000000 })
+T(4, unsigned int, x == 3 || x == 4 || x == 5 || x == 6,
+  { 3 C 4 C 5 C 6 }, { -3U C 0 C 1 C 2 C 7 C 8 C 12 C 0x7fffffff C 0x80000000 })
+T(5, unsigned int, x == -3U || x == -4U || x == -5U || x == -6U,
+  { -3U C -4U C -5U C -6U }, { -7U C -8U C -2U C -1U C 1 C 2 C 0x7fffffff C 0x80000000 })
+T(6, unsigned int, x == -3U || x == -4U || x == -5U,
+  { -3U C -4U C -5U }, { -6U C -7U C -8U C -2U C -1U C 1 C 2 C 0x7fffffff C 0x80000000 })
+T(7, char *, x == (char *) -3UL || x == (char *) -4UL || x == (char *) -5UL,
+  { (char *) -3UL C (char *) -4UL C (char *) -5UL },
+  { (char *) -6UL C (char *) -20UL C (char *) -2UL C (char *) -1UL C (char *) 0
+    C (char *) 1UL C (char *) 35UL C (char *) 0x7fffffffUL C (char *) 0x80000000UL })
+T(8, unsigned long, x == -2UL || x == -1UL || x == 0,
+  { 0 C -1UL C -2UL }, { -3UL C -6UL C 1 C 2 C 12 C 35 C 0x7fffffff C 0x80000000 })
+T(9, unsigned long, x >= -4UL || x <= 8,
+  { -4UL C -3UL C -2UL C -1UL C 0 C 1 C 2 C 3 C 4 C 5 C 6 C 7 C 8 },
+  { -7UL C -5UL C 9 C 10 C 61 C 127 C 0x7fffffff C 0x80000000 })
+T(10, signed char, x == 0 || x == -1 || x == -2 || x == -3,
+  { 0 C -1 C -2 C -3 }, { -4 C -5 C 1 C 2 C 3 C 35 C -24 })
+T(11, int, x == 0 || x == 1,
+  { 0 C 1 }, { -1 C 2 C 12 C 35 C INT_MAX C INT_MIN })
+T(12, int, x == 0 || x == -1 || x == -2,
+  { 0 C -1 C -2 }, { -3 C -6 C 1 C 2 C 12 C 35 C INT_MAX C INT_MIN })
+T(13, int, x == 0 || x == 1 || x == 2,
+  { 0 C 1 C 2 }, { -3 C -6 C -1 C -2 C 12 C 35 C INT_MAX C INT_MIN })
+T(14, int, x == 3 || x == 4 || x == 5 || x == 6,
+  { 3 C 4 C 5 C 6 }, { -3 C 0 C 1 C 2 C 7 C 8 C 12 C INT_MAX C INT_MIN })
+T(15, int, x == -3 || x == -4 || x == -5 || x == -6,
+  { -3 C -4 C -5 C -6 }, { -7 C -8 C -2 C -1 C 1 C 2 C INT_MAX C INT_MIN })
+T(16, int, x == -3 || x == -4 || x == -5,
+  { -3 C -4 C -5 }, { -6 C -7 C -8 C -2 C -1 C 1 C 2 C INT_MAX C INT_MIN })
+T(17, unsigned int, (x >= -8U && x <= -3U) || x == -2U || x == -1U || x == 0 || x == 1 || x == 2,
+  { -8U C -7U C -6U C -5U C -4U C -3U C -2U C -1U C 0 C 1 C 2 },
+  { -9U C -10U C 3 C 4 C 12 C -54U C INT_MAX C INT_MIN })
+T(18, int, (x >= -8 && x <= -3) || x == -2 || x == -1 || x == 0 || x == 1 || x == 2,
+  { -8 C -7 C -6 C -5 C -4 C -3 C -2 C -1 C 0 C 1 C 2 },
+  { -9 C -10 C 3 C 4 C 12 C -54 C INT_MAX C INT_MIN })
+T(19, unsigned long, (x >= 0 && x <= 16) || (x >= 18 && x <= -1UL),
+  { -3UL C -6UL C -1UL C 0 C 1 C 2 C 12 C 15 C 16 C 18 C 19 C 35 C 0x7fffffff
+    C 0x80000000 }, { 17 })
+T(20, char *, x == (char *) -1UL || x == 0,
+  { (char *) -1UL C 0 }, { (char *) -6UL C (char *) -20UL C (char *) -2UL
+    C (char *) 1UL C (char *) 35UL C (char *) 0x7fffffffUL C (char *) 0x80000000UL })
+T(21, enum integers, x == int_zero || x == int_one,
+  { int_zero C int_one }, { int_minus1 C int_two C 12 C 35 C int_largest C int_smallest })
+T(22, int, x == INT_MIN || x == INT_MAX,
+  { INT_MIN C INT_MAX },
+  { -1 C 0 C 1 C INT_MAX - 1 C INT_MAX - 2 C INT_MIN + 1 C INT_MIN + 2 })
+T(23, int, x == INT_MIN + 1 || x == INT_MIN + 2 || x == INT_MIN || x == INT_MAX,
+  { INT_MIN + 1 C INT_MIN + 2 C INT_MIN C INT_MAX },
+  { -1 C 0 C 1 C INT_MAX - 1 C INT_MAX - 2 C INT_MIN + 3 C INT_MIN + 4 })
+T(24, signed char, x == SCHAR_MIN || x == SCHAR_MAX,
+  { SCHAR_MIN C SCHAR_MAX },
+  { -1 C 0 C 1 C SCHAR_MAX - 1 C SCHAR_MAX - 2 C SCHAR_MIN + 1 C SCHAR_MIN + 2 })
+T(25, enum integers, x == int_smallest || x == int_largest,
+  { int_smallest C int_largest }, { int_minus1 C int_zero C int_one
+    C int_2ndsmallest C int_2ndlargest C int_3rdsmallest C int_3rdlargest })
+
+/* This should be optimized into unconditional jump.  */
+T(o1, unsigned long, (x >= 0 && x <= 16) || (x >= 17 && x <= -1UL),
+  { -3UL C -6UL C -1UL C 0 C 1 C 2 C 12 C 15 C 16 C 17 C 18 C 19 C 35 C 0x7fffffff
+    C 0x80000000 }, { })
+T(o2, unsigned long, (x >= 0 && x <= -3UL) || (x == -2UL || x == -1UL),
+  { -3UL C -6UL C -1UL C 0 C 1 C 2 C 12 C 15 C 16 C 17 C 18 C 19 C 35 C 0x7fffffff
+    C 0x80000000 }, { })
+
+/* This should be eventually optimized into a single comparison.  */
+T(td1, unsigned char, x == 0 || x == 4 || x == 1 || x == 5 || x == 2 || x == 6 || x == 3,
+  { 0 C 1 C 2 C 3 C 4 C 5 C 6 }, { 7 C 8 C 127 C 128 C 254 C 255 })
+
+#endif
+
+#else
+int
+main (void)
+{
+  return 0;
+}
+#endif
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/readonly-loc.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/readonly-loc.c
new file mode 100644
index 000000000..c5d1c97d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/readonly-loc.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+int func()
+{
+  const int *arr;
+  const int arr2[5];
+  arr[0] = 1; /* { dg-error "assignment of read-only location" "*(arr)" } */
+  arr[1] = 1; /* { dg-error "assignment of read-only location" "*(arr + 4u)" } */
+  arr2[0] = 1; /* { dg-error "assignment of read-only location" "arr2\[0\]" } */
+  arr2[1] = 1; /* { dg-error "assignment of read-only location" "arr2\[1\]" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/real-const-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/real-const-1.c
new file mode 100644
index 000000000..3e2bbfde8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/real-const-1.c
@@ -0,0 +1,4 @@
+/* PR middle-end/21781.  */
+/* { dg-do compile } */
+
+int f[.0e200000000 == 0?1:-1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-1.c
new file mode 100644
index 000000000..6a7d8faec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-1.c
@@ -0,0 +1,102 @@
+/* Test for various situations where a new declaration of an
+   identifier conflicts with an earlier declaration which isn't in the
+   same scope.  These are all undefined behavior per C89 sections
+   6.1.2.2p7, 6.1.2.6p2, and 6.3.2.2p2/footnote 38 (C99 6.2.2p7 and
+   6.2.7p2 - implicit declarations are invalid in C99).  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic -Wall -Wno-unused" } */
+
+/* Extern at function scope, clashing with extern at file scope */
+
+extern int foo1;		/* { dg-message "note: previous" } */
+extern int bar1(int);		/* { dg-message "note: previous" } */
+
+void test1(void)
+{
+  extern double foo1;		/* { dg-error "conflict" } */
+  extern double bar1(double);	/* { dg-error "conflict" } */
+}
+
+/* Extern at file scope, clashing with extern at function scope */
+
+void test2(void)
+{
+  extern double foo2;		/* { dg-message "note: previous" } */
+  extern double bar2(double);	/* { dg-message "note: previous" } */
+}
+
+extern int foo2;		/* { dg-error "conflict" } */
+extern int bar2(int);		/* { dg-error "conflict" } */
+
+/* Extern at function scope, clashing with extern at earlier function
+   scope.  Also, don't be fooled by a typedef at file scope.  */
+
+typedef float baz3;		/* { dg-bogus } */
+
+void prime3(void)
+{
+  extern int foo3;		/* { dg-message "note: previous" } */
+  extern int bar3(int);		/* { dg-message "note: previous" } */
+  extern int baz3;		/* { dg-message "note: previous" } */
+}
+
+void test3(void)
+{
+  extern double foo3;		/* { dg-error "conflict" } */
+  extern double bar3(double);	/* { dg-error "conflict" } */
+  extern double baz3;		/* { dg-error "conflict" } */
+}
+
+/* Extern at function scope, clashing with previous implicit decl.  */
+
+void prime4(void)
+{
+  bar4();			/* { dg-warning "implicit declaration of function" } */
+}
+
+void test4(void)
+{
+  extern double bar4(double);	/* { dg-error "conflict" } */
+/* { dg-message "note: previous implicit declaration" "" { target *-*-* } 55 } */
+}
+
+/* Implicit decl, clashing with extern at previous function scope.  */
+
+void prime5(void)
+{
+  extern double bar5(double);	/* { dg-message "note: previous declaration" "" } */
+} /* { dg-message "note: previous implicit declaration" "" { target *-*-* } 68 } */
+
+void test5(void)
+{
+  bar5(1);			/* { dg-warning "implicit declaration of function" } */
+} /* { dg-error "incompatible implicit declaration" "" { target *-*-* } 73 } */
+
+/* Extern then static, both at file scope.  */
+
+extern int test6(int);		/* { dg-message "note: previous" "" } */
+static int test6(int x)		/* { dg-error "follows non-static" } */
+{ return x; }
+
+
+/* Extern then static, extern at previous function scope.  */
+
+void prime7(void)
+{
+  extern int test7(int);	/* { dg-message "note: previous" "" } */
+}
+
+static int test7(int x)		/* { dg-error "follows non-static" } */
+{ return x; }
+
+/* Implicit decl then static.  */
+
+void prime8(void)
+{
+  test8();			/* { dg-message "note: previous" "" } */
+                                /* { dg-warning "implicit" "implicit" { target *-*-* } 97 } */
+}
+
+static int test8(int x)		/* { dg-error "follows non-static" } */
+{ return x; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-10.c
new file mode 100644
index 000000000..88d804e6c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-10.c
@@ -0,0 +1,34 @@
+/* Test for multiple declarations and composite types.  Check we don't
+   ICE with nested initializers.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+static int w[];
+void
+f (void)
+{
+  extern int w[] = { 1, 2 }; /* { dg-error "has both" } */
+}
+
+int x[];
+void
+g (void)
+{
+  extern int x[] = { 3, 4, 5 }; /* { dg-error "has both" } */
+}
+
+static int y[];
+void
+h (void)
+{
+  extern int y[] = { 6 }; /* { dg-error "has both" } */
+}
+
+int z[];
+void
+i (void)
+{
+  extern int z[] = { 7 }; /* { dg-error "has both" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-11.c
new file mode 100644
index 000000000..5540e4050
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-11.c
@@ -0,0 +1,9 @@
+/* Some incompatible external linkage declarations were not diagnosed.
+   Bug 21342.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int f(int (*)[]);
+void g() { int f(int (*)[2]); } /* { dg-message "note: previous declaration of 'f' was here" } */
+int f(int (*)[3]); /* { dg-error "conflicting types for 'f'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-12.c
new file mode 100644
index 000000000..711b8a3fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-12.c
@@ -0,0 +1,9 @@
+/* Some incompatible external linkage declarations were not diagnosed.
+   Bug 21342.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern int a[];
+void f(void) { extern int a[]; extern int a[10]; } /* { dg-message "note: previous declaration of 'a' was here" } */
+extern int a[5]; /* { dg-error "conflicting types for 'a'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-13.c
new file mode 100644
index 000000000..3f05d0fb1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-13.c
@@ -0,0 +1,9 @@
+/* Some incompatible external linkage declarations were not diagnosed.
+   Bug 21342.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+extern int a[];
+void f(void) { extern int a[10]; } /* { dg-message "note: previous declaration of 'a' was here" } */
+extern int a[5]; /* { dg-error "conflicting types for 'a'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-14.c
new file mode 100644
index 000000000..b27c02441
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-14.c
@@ -0,0 +1,22 @@
+/* Some incompatible external linkage declarations were not diagnosed.
+   Bug 21342.  Test type in inner scope is correct.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int IA[];
+typedef int IA5[5];
+typedef IA *IAP;
+typedef IA5 *IA5P;
+extern IAP a[];
+void
+f (void)
+{
+  {
+    extern IA5P a[];
+    sizeof (*a[0]);
+  }
+  extern IAP a[];
+  extern IAP a[5];
+  sizeof (*a[0]); /* { dg-error "invalid application of 'sizeof' to incomplete type 'IA'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-15.c
new file mode 100644
index 000000000..d2f48bd79
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-15.c
@@ -0,0 +1,14 @@
+/* Test for ICE with redeclaration in inner scope which is accepted
+   despite incompatible type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (void)
+{
+  g(); /* { dg-message "note: previous implicit declaration of 'g' was here" } */
+  {
+    void g(); /* { dg-warning "conflicting types for 'g'" } */
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-16.c
new file mode 100644
index 000000000..560b373fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-16.c
@@ -0,0 +1,18 @@
+/* PR 21502 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int IA[];
+typedef int IA5[5];
+typedef int IA10[10];
+typedef IA *IAP;
+typedef IA5 *IA5P;
+typedef IA10 *IA10P;
+extern IAP a[];
+void
+f (void)
+{
+  extern IA5P a[];
+}
+IAP a[] = { 0 };	/* { dg-message "note: previous definition" } */
+extern IA10P a[];	/* { dg-error "conflicting types" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-2.c
new file mode 100644
index 000000000..fa0d5e447
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-2.c
@@ -0,0 +1,68 @@
+/* Test for multiple declarations of an identifier at same block
+   scope: only valid case is all extern.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+fa0 (void)
+{
+  int a0; /* { dg-message "note: previous declaration" } */
+  int a0; /* { dg-error "redeclaration" } */
+}
+
+void
+fa1 (void)
+{
+  int a1; /* { dg-message "note: previous declaration" } */
+  static int a1; /* { dg-error "redeclaration" } */
+}
+
+void
+fa2 (void)
+{
+  int a2; /* { dg-message "note: previous declaration" } */
+  extern int a2; /* { dg-error "follows declaration with no linkage" } */
+}
+
+void
+fa3 (void)
+{
+  static int a3; /* { dg-message "note: previous declaration" } */
+  int a3; /* { dg-error "redeclaration" } */
+}
+
+void
+fa4 (void)
+{
+  static int a4; /* { dg-message "note: previous declaration" } */
+  static int a4; /* { dg-error "redeclaration" } */
+}
+
+void
+fa5 (void)
+{
+  static int a5; /* { dg-message "note: previous declaration" } */
+  extern int a5; /* { dg-error "follows declaration with no linkage" } */
+}
+
+void
+fa6 (void)
+{
+  extern int a6; /* { dg-message "note: previous declaration" } */
+  int a6; /* { dg-error "follows extern declaration" } */
+}
+
+void
+fa7 (void)
+{
+  extern int a7; /* { dg-message "note: previous declaration" } */
+  static int a7; /* { dg-error "follows extern declaration" } */
+}
+
+void
+fa8 (void)
+{
+  extern int a8;
+  extern int a8;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-3.c
new file mode 100644
index 000000000..3181712f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-3.c
@@ -0,0 +1,1180 @@
+/* Test for multiple declarations and composite types.  Includes bug
+   13801.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+typedef int IA[];
+typedef int A10[10];
+
+/* Test all combinations of: a variable declared at file scope (no
+   type specifiers, or extern, or static), or just inside a function
+   (with extern), redeclared in an inner scope (with extern), and
+   redeclared in an inner scope when the previous declaration is
+   hidden (with extern, and not if the original declaration was
+   static).  Test three times: incomplete variable types; pointers to
+   incomplete types; functions returning such pointers.  */
+
+IA a0;
+void
+f0 (void)
+{
+  sizeof(a0); /* { dg-error "incomplete" } */
+  {
+    extern IA a0;
+    sizeof(a0); /* { dg-error "incomplete" } */
+    {
+      int a0;
+      {
+        extern IA a0;
+        sizeof(a0); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a0); /* { dg-error "incomplete" } */
+  }
+  sizeof(a0); /* { dg-error "incomplete" } */
+}
+extern A10 a0;
+
+IA a1;
+void
+f1 (void)
+{
+  sizeof(a1); /* { dg-error "incomplete" } */
+  {
+    extern IA a1;
+    sizeof(a1); /* { dg-error "incomplete" } */
+    {
+      int a1;
+      {
+        extern A10 a1;
+        sizeof(a1);
+      }
+    }
+    sizeof(a1); /* { dg-error "incomplete" } */
+  }
+  sizeof(a1); /* { dg-error "incomplete" } */
+}
+extern A10 a1;
+
+IA a2;
+void
+f2 (void)
+{
+  sizeof(a2); /* { dg-error "incomplete" } */
+  {
+    extern A10 a2;
+    sizeof(a2);
+    {
+      int a2;
+      {
+        extern IA a2;
+        sizeof(a2); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a2);
+  }
+  sizeof(a2); /* { dg-error "incomplete" } */
+}
+extern A10 a2;
+
+IA a3;
+void
+f3 (void)
+{
+  sizeof(a3); /* { dg-error "incomplete" } */
+  {
+    extern A10 a3;
+    sizeof(a3);
+    {
+      int a3;
+      {
+        extern A10 a3;
+        sizeof(a3);
+      }
+    }
+    sizeof(a3);
+  }
+  sizeof(a3); /* { dg-error "incomplete" } */
+}
+extern A10 a3;
+
+A10 a4;
+void
+f4 (void)
+{
+  sizeof(a4);
+  {
+    extern IA a4;
+    sizeof(a4);
+    {
+      int a4;
+      {
+        extern IA a4;
+        sizeof(a4); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a4);
+  }
+  sizeof(a4);
+}
+extern A10 a4;
+
+A10 a5;
+void
+f5 (void)
+{
+  sizeof(a5);
+  {
+    extern IA a5;
+    sizeof(a5);
+    {
+      int a5;
+      {
+        extern A10 a5;
+        sizeof(a5);
+      }
+    }
+    sizeof(a5);
+  }
+  sizeof(a5);
+}
+extern A10 a5;
+
+A10 a6;
+void
+f6 (void)
+{
+  sizeof(a6);
+  {
+    extern A10 a6;
+    sizeof(a6);
+    {
+      int a6;
+      {
+        extern IA a6;
+        sizeof(a6); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a6);
+  }
+  sizeof(a6);
+}
+extern A10 a6;
+
+A10 a7;
+void
+f7 (void)
+{
+  sizeof(a7);
+  {
+    extern A10 a7;
+    sizeof(a7);
+    {
+      int a7;
+      {
+        extern A10 a7;
+        sizeof(a7);
+      }
+    }
+    sizeof(a7);
+  }
+  sizeof(a7);
+}
+extern A10 a7;
+
+extern IA a8;
+void
+f8 (void)
+{
+  sizeof(a8); /* { dg-error "incomplete" } */
+  {
+    extern IA a8;
+    sizeof(a8); /* { dg-error "incomplete" } */
+    {
+      int a8;
+      {
+        extern IA a8;
+        sizeof(a8); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a8); /* { dg-error "incomplete" } */
+  }
+  sizeof(a8); /* { dg-error "incomplete" } */
+}
+extern A10 a8;
+
+extern IA a9;
+void
+f9 (void)
+{
+  sizeof(a9); /* { dg-error "incomplete" } */
+  {
+    extern IA a9;
+    sizeof(a9); /* { dg-error "incomplete" } */
+    {
+      int a9;
+      {
+        extern A10 a9;
+        sizeof(a9);
+      }
+    }
+    sizeof(a9); /* { dg-error "incomplete" } */
+  }
+  sizeof(a9); /* { dg-error "incomplete" } */
+}
+extern A10 a9;
+
+extern IA a10;
+void
+f10 (void)
+{
+  sizeof(a10); /* { dg-error "incomplete" } */
+  {
+    extern A10 a10;
+    sizeof(a10);
+    {
+      int a10;
+      {
+        extern IA a10;
+        sizeof(a10); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a10);
+  }
+  sizeof(a10); /* { dg-error "incomplete" } */
+}
+extern A10 a10;
+
+extern IA a11;
+void
+f11 (void)
+{
+  sizeof(a11); /* { dg-error "incomplete" } */
+  {
+    extern A10 a11;
+    sizeof(a11);
+    {
+      int a11;
+      {
+        extern A10 a11;
+        sizeof(a11);
+      }
+    }
+    sizeof(a11);
+  }
+  sizeof(a11); /* { dg-error "incomplete" } */
+}
+extern A10 a11;
+
+extern A10 a12;
+void
+f12 (void)
+{
+  sizeof(a12);
+  {
+    extern IA a12;
+    sizeof(a12);
+    {
+      int a12;
+      {
+        extern IA a12;
+        sizeof(a12); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a12);
+  }
+  sizeof(a12);
+}
+extern A10 a12;
+
+extern A10 a13;
+void
+f13 (void)
+{
+  sizeof(a13);
+  {
+    extern IA a13;
+    sizeof(a13);
+    {
+      int a13;
+      {
+        extern A10 a13;
+        sizeof(a13);
+      }
+    }
+    sizeof(a13);
+  }
+  sizeof(a13);
+}
+extern A10 a13;
+
+extern A10 a14;
+void
+f14 (void)
+{
+  sizeof(a14);
+  {
+    extern A10 a14;
+    sizeof(a14);
+    {
+      int a14;
+      {
+        extern IA a14;
+        sizeof(a14); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(a14);
+  }
+  sizeof(a14);
+}
+extern A10 a14;
+
+extern A10 a15;
+void
+f15 (void)
+{
+  sizeof(a15);
+  {
+    extern A10 a15;
+    sizeof(a15);
+    {
+      int a15;
+      {
+        extern A10 a15;
+        sizeof(a15);
+      }
+    }
+    sizeof(a15);
+  }
+  sizeof(a15);
+}
+extern A10 a15;
+
+static IA a16;
+void
+f16 (void)
+{
+  sizeof(a16); /* { dg-error "incomplete" } */
+  {
+    extern IA a16;
+    sizeof(a16); /* { dg-error "incomplete" } */
+  }
+  sizeof(a16); /* { dg-error "incomplete" } */
+}
+extern A10 a16;
+
+static IA a17;
+void
+f17 (void)
+{
+  sizeof(a17); /* { dg-error "incomplete" } */
+  {
+    extern A10 a17;
+    sizeof(a17);
+  }
+  sizeof(a17); /* { dg-error "incomplete" } */
+}
+extern A10 a17;
+
+static A10 a18;
+void
+f18 (void)
+{
+  sizeof(a18);
+  {
+    extern IA a18;
+    sizeof(a18);
+  }
+  sizeof(a18);
+}
+extern A10 a18;
+
+static A10 a19;
+void
+f19 (void)
+{
+  sizeof(a19);
+  {
+    extern A10 a19;
+    sizeof(a19);
+  }
+  sizeof(a19);
+}
+extern A10 a19;
+
+IA *b0;
+void
+g0 (void)
+{
+  sizeof(*b0); /* { dg-error "incomplete" } */
+  {
+    extern IA *b0;
+    sizeof(*b0); /* { dg-error "incomplete" } */
+    {
+      int b0;
+      {
+        extern IA *b0;
+        sizeof(*b0); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b0); /* { dg-error "incomplete" } */
+  }
+  sizeof(*b0); /* { dg-error "incomplete" } */
+}
+extern A10 *b0;
+
+IA *b1;
+void
+g1 (void)
+{
+  sizeof(*b1); /* { dg-error "incomplete" } */
+  {
+    extern IA *b1;
+    sizeof(*b1); /* { dg-error "incomplete" } */
+    {
+      int b1;
+      {
+        extern A10 *b1;
+        sizeof(*b1);
+      }
+    }
+    sizeof(*b1); /* { dg-error "incomplete" } */
+  }
+  sizeof(*b1); /* { dg-error "incomplete" } */
+}
+extern A10 *b1;
+
+IA *b2;
+void
+g2 (void)
+{
+  sizeof(*b2); /* { dg-error "incomplete" } */
+  {
+    extern A10 *b2;
+    sizeof(*b2);
+    {
+      int b2;
+      {
+        extern IA *b2;
+        sizeof(*b2); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b2);
+  }
+  sizeof(*b2); /* { dg-error "incomplete" } */
+}
+extern A10 *b2;
+
+IA *b3;
+void
+g3 (void)
+{
+  sizeof(*b3); /* { dg-error "incomplete" } */
+  {
+    extern A10 *b3;
+    sizeof(*b3);
+    {
+      int b3;
+      {
+        extern A10 *b3;
+        sizeof(*b3);
+      }
+    }
+    sizeof(*b3);
+  }
+  sizeof(*b3); /* { dg-error "incomplete" } */
+}
+extern A10 *b3;
+
+A10 *b4;
+void
+g4 (void)
+{
+  sizeof(*b4);
+  {
+    extern IA *b4;
+    sizeof(*b4);
+    {
+      int b4;
+      {
+        extern IA *b4;
+        sizeof(*b4); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b4);
+  }
+  sizeof(*b4);
+}
+extern A10 *b4;
+
+A10 *b5;
+void
+g5 (void)
+{
+  sizeof(*b5);
+  {
+    extern IA *b5;
+    sizeof(*b5);
+    {
+      int b5;
+      {
+        extern A10 *b5;
+        sizeof(*b5);
+      }
+    }
+    sizeof(*b5);
+  }
+  sizeof(*b5);
+}
+extern A10 *b5;
+
+A10 *b6;
+void
+g6 (void)
+{
+  sizeof(*b6);
+  {
+    extern A10 *b6;
+    sizeof(*b6);
+    {
+      int b6;
+      {
+        extern IA *b6;
+        sizeof(*b6); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b6);
+  }
+  sizeof(*b6);
+}
+extern A10 *b6;
+
+A10 *b7;
+void
+g7 (void)
+{
+  sizeof(*b7);
+  {
+    extern A10 *b7;
+    sizeof(*b7);
+    {
+      int b7;
+      {
+        extern A10 *b7;
+        sizeof(*b7);
+      }
+    }
+    sizeof(*b7);
+  }
+  sizeof(*b7);
+}
+extern A10 *b7;
+
+extern IA *b8;
+void
+g8 (void)
+{
+  sizeof(*b8); /* { dg-error "incomplete" } */
+  {
+    extern IA *b8;
+    sizeof(*b8); /* { dg-error "incomplete" } */
+    {
+      int b8;
+      {
+        extern IA *b8;
+        sizeof(*b8); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b8); /* { dg-error "incomplete" } */
+  }
+  sizeof(*b8); /* { dg-error "incomplete" } */
+}
+extern A10 *b8;
+
+extern IA *b9;
+void
+g9 (void)
+{
+  sizeof(*b9); /* { dg-error "incomplete" } */
+  {
+    extern IA *b9;
+    sizeof(*b9); /* { dg-error "incomplete" } */
+    {
+      int b9;
+      {
+        extern A10 *b9;
+        sizeof(*b9);
+      }
+    }
+    sizeof(*b9); /* { dg-error "incomplete" } */
+  }
+  sizeof(*b9); /* { dg-error "incomplete" } */
+}
+extern A10 *b9;
+
+extern IA *b10;
+void
+g10 (void)
+{
+  sizeof(*b10); /* { dg-error "incomplete" } */
+  {
+    extern A10 *b10;
+    sizeof(*b10);
+    {
+      int b10;
+      {
+        extern IA *b10;
+        sizeof(*b10); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b10);
+  }
+  sizeof(*b10); /* { dg-error "incomplete" } */
+}
+extern A10 *b10;
+
+extern IA *b11;
+void
+g11 (void)
+{
+  sizeof(*b11); /* { dg-error "incomplete" } */
+  {
+    extern A10 *b11;
+    sizeof(*b11);
+    {
+      int b11;
+      {
+        extern A10 *b11;
+        sizeof(*b11);
+      }
+    }
+    sizeof(*b11);
+  }
+  sizeof(*b11); /* { dg-error "incomplete" } */
+}
+extern A10 *b11;
+
+extern A10 *b12;
+void
+g12 (void)
+{
+  sizeof(*b12);
+  {
+    extern IA *b12;
+    sizeof(*b12);
+    {
+      int b12;
+      {
+        extern IA *b12;
+        sizeof(*b12); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b12);
+  }
+  sizeof(*b12);
+}
+extern A10 *b12;
+
+extern A10 *b13;
+void
+g13 (void)
+{
+  sizeof(*b13);
+  {
+    extern IA *b13;
+    sizeof(*b13);
+    {
+      int b13;
+      {
+        extern A10 *b13;
+        sizeof(*b13);
+      }
+    }
+    sizeof(*b13);
+  }
+  sizeof(*b13);
+}
+extern A10 *b13;
+
+extern A10 *b14;
+void
+g14 (void)
+{
+  sizeof(*b14);
+  {
+    extern A10 *b14;
+    sizeof(*b14);
+    {
+      int b14;
+      {
+        extern IA *b14;
+        sizeof(*b14); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*b14);
+  }
+  sizeof(*b14);
+}
+extern A10 *b14;
+
+extern A10 *b15;
+void
+g15 (void)
+{
+  sizeof(*b15);
+  {
+    extern A10 *b15;
+    sizeof(*b15);
+    {
+      int b15;
+      {
+        extern A10 *b15;
+        sizeof(*b15);
+      }
+    }
+    sizeof(*b15);
+  }
+  sizeof(*b15);
+}
+extern A10 *b15;
+
+static IA *b16;
+void
+g16 (void)
+{
+  sizeof(*b16); /* { dg-error "incomplete" } */
+  {
+    extern IA *b16;
+    sizeof(*b16); /* { dg-error "incomplete" } */
+  }
+  sizeof(*b16); /* { dg-error "incomplete" } */
+}
+extern A10 *b16;
+
+static IA *b17;
+void
+g17 (void)
+{
+  sizeof(*b17); /* { dg-error "incomplete" } */
+  {
+    extern A10 *b17;
+    sizeof(*b17);
+  }
+  sizeof(*b17); /* { dg-error "incomplete" } */
+}
+extern A10 *b17;
+
+static A10 *b18;
+void
+g18 (void)
+{
+  sizeof(*b18);
+  {
+    extern IA *b18;
+    sizeof(*b18);
+  }
+  sizeof(*b18);
+}
+extern A10 *b18;
+
+static A10 *b19;
+void
+g19 (void)
+{
+  sizeof(*b19);
+  {
+    extern A10 *b19;
+    sizeof(*b19);
+  }
+  sizeof(*b19);
+}
+extern A10 *b19;
+
+IA *c0 (void);
+void
+h0 (void)
+{
+  sizeof(*c0()); /* { dg-error "incomplete" } */
+  {
+    extern IA *c0 (void);
+    sizeof(*c0()); /* { dg-error "incomplete" } */
+    {
+      int c0;
+      {
+        extern IA *c0 (void);
+        sizeof(*c0()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c0()); /* { dg-error "incomplete" } */
+  }
+  sizeof(*c0()); /* { dg-error "incomplete" } */
+}
+A10 *c0 (void) { return 0; }
+
+IA *c1 (void);
+void
+h1 (void)
+{
+  sizeof(*c1()); /* { dg-error "incomplete" } */
+  {
+    extern IA *c1 (void);
+    sizeof(*c1()); /* { dg-error "incomplete" } */
+    {
+      int c1;
+      {
+        extern A10 *c1 (void);
+        sizeof(*c1());
+      }
+    }
+    sizeof(*c1()); /* { dg-error "incomplete" } */
+  }
+  sizeof(*c1()); /* { dg-error "incomplete" } */
+}
+A10 *c1 (void) { return 0; }
+
+IA *c2 (void);
+void
+h2 (void)
+{
+  sizeof(*c2()); /* { dg-error "incomplete" } */
+  {
+    extern A10 *c2 (void);
+    sizeof(*c2());
+    {
+      int c2;
+      {
+        extern IA *c2 (void);
+        sizeof(*c2()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c2());
+  }
+  sizeof(*c2()); /* { dg-error "incomplete" } */
+}
+A10 *c2 (void) { return 0; }
+
+IA *c3 (void);
+void
+h3 (void)
+{
+  sizeof(*c3()); /* { dg-error "incomplete" } */
+  {
+    extern A10 *c3 (void);
+    sizeof(*c3());
+    {
+      int c3;
+      {
+        extern A10 *c3 (void);
+        sizeof(*c3());
+      }
+    }
+    sizeof(*c3());
+  }
+  sizeof(*c3()); /* { dg-error "incomplete" } */
+}
+A10 *c3 (void) { return 0; }
+
+A10 *c4 (void);
+void
+h4 (void)
+{
+  sizeof(*c4());
+  {
+    extern IA *c4 (void);
+    sizeof(*c4());
+    {
+      int c4;
+      {
+        extern IA *c4 (void);
+        sizeof(*c4()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c4());
+  }
+  sizeof(*c4());
+}
+A10 *c4 (void) { return 0; }
+
+A10 *c5 (void);
+void
+h5 (void)
+{
+  sizeof(*c5());
+  {
+    extern IA *c5 (void);
+    sizeof(*c5());
+    {
+      int c5;
+      {
+        extern A10 *c5 (void);
+        sizeof(*c5());
+      }
+    }
+    sizeof(*c5());
+  }
+  sizeof(*c5());
+}
+A10 *c5 (void) { return 0; }
+
+A10 *c6 (void);
+void
+h6 (void)
+{
+  sizeof(*c6());
+  {
+    extern A10 *c6 (void);
+    sizeof(*c6());
+    {
+      int c6;
+      {
+        extern IA *c6 (void);
+        sizeof(*c6()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c6());
+  }
+  sizeof(*c6());
+}
+A10 *c6 (void) { return 0; }
+
+A10 *c7 (void);
+void
+h7 (void)
+{
+  sizeof(*c7());
+  {
+    extern A10 *c7 (void);
+    sizeof(*c7());
+    {
+      int c7;
+      {
+        extern A10 *c7 (void);
+        sizeof(*c7());
+      }
+    }
+    sizeof(*c7());
+  }
+  sizeof(*c7());
+}
+A10 *c7 (void) { return 0; }
+
+extern IA *c8 (void);
+void
+h8 (void)
+{
+  sizeof(*c8()); /* { dg-error "incomplete" } */
+  {
+    extern IA *c8 (void);
+    sizeof(*c8()); /* { dg-error "incomplete" } */
+    {
+      int c8;
+      {
+        extern IA *c8 (void);
+        sizeof(*c8()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c8()); /* { dg-error "incomplete" } */
+  }
+  sizeof(*c8()); /* { dg-error "incomplete" } */
+}
+extern A10 *c8 (void) { return 0; }
+
+extern IA *c9 (void);
+void
+h9 (void)
+{
+  sizeof(*c9()); /* { dg-error "incomplete" } */
+  {
+    extern IA *c9 (void);
+    sizeof(*c9()); /* { dg-error "incomplete" } */
+    {
+      int c9;
+      {
+        extern A10 *c9 (void);
+        sizeof(*c9());
+      }
+    }
+    sizeof(*c9()); /* { dg-error "incomplete" } */
+  }
+  sizeof(*c9()); /* { dg-error "incomplete" } */
+}
+extern A10 *c9 (void) { return 0; }
+
+extern IA *c10 (void);
+void
+h10 (void)
+{
+  sizeof(*c10()); /* { dg-error "incomplete" } */
+  {
+    extern A10 *c10 (void);
+    sizeof(*c10());
+    {
+      int c10;
+      {
+        extern IA *c10 (void);
+        sizeof(*c10()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c10());
+  }
+  sizeof(*c10()); /* { dg-error "incomplete" } */
+}
+extern A10 *c10 (void) { return 0; }
+
+extern IA *c11 (void);
+void
+h11 (void)
+{
+  sizeof(*c11()); /* { dg-error "incomplete" } */
+  {
+    extern A10 *c11 (void);
+    sizeof(*c11());
+    {
+      int c11;
+      {
+        extern A10 *c11 (void);
+        sizeof(*c11());
+      }
+    }
+    sizeof(*c11());
+  }
+  sizeof(*c11()); /* { dg-error "incomplete" } */
+}
+extern A10 *c11 (void) { return 0; }
+
+extern A10 *c12 (void);
+void
+h12 (void)
+{
+  sizeof(*c12());
+  {
+    extern IA *c12 (void);
+    sizeof(*c12());
+    {
+      int c12;
+      {
+        extern IA *c12 (void);
+        sizeof(*c12()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c12());
+  }
+  sizeof(*c12());
+}
+extern A10 *c12 (void) { return 0; }
+
+extern A10 *c13 (void);
+void
+h13 (void)
+{
+  sizeof(*c13());
+  {
+    extern IA *c13 (void);
+    sizeof(*c13());
+    {
+      int c13;
+      {
+        extern A10 *c13 (void);
+        sizeof(*c13());
+      }
+    }
+    sizeof(*c13());
+  }
+  sizeof(*c13());
+}
+extern A10 *c13 (void) { return 0; }
+
+extern A10 *c14 (void);
+void
+h14 (void)
+{
+  sizeof(*c14());
+  {
+    extern A10 *c14 (void);
+    sizeof(*c14());
+    {
+      int c14;
+      {
+        extern IA *c14 (void);
+        sizeof(*c14()); /* { dg-error "incomplete" } */
+      }
+    }
+    sizeof(*c14());
+  }
+  sizeof(*c14());
+}
+extern A10 *c14 (void) { return 0; }
+
+extern A10 *c15 (void);
+void
+h15 (void)
+{
+  sizeof(*c15());
+  {
+    extern A10 *c15 (void);
+    sizeof(*c15());
+    {
+      int c15;
+      {
+        extern A10 *c15 (void);
+        sizeof(*c15());
+      }
+    }
+    sizeof(*c15());
+  }
+  sizeof(*c15());
+}
+extern A10 *c15 (void) { return 0; }
+
+static IA *c16 (void);
+void
+h16 (void)
+{
+  sizeof(*c16()); /* { dg-error "incomplete" } */
+  {
+    extern IA *c16 (void);
+    sizeof(*c16()); /* { dg-error "incomplete" } */
+  }
+  sizeof(*c16()); /* { dg-error "incomplete" } */
+}
+static A10 *c16 (void) { return 0; }
+
+static IA *c17 (void);
+void
+h17 (void)
+{
+  sizeof(*c17()); /* { dg-error "incomplete" } */
+  {
+    extern A10 *c17 (void);
+    sizeof(*c17());
+  }
+  sizeof(*c17()); /* { dg-error "incomplete" } */
+}
+static A10 *c17 (void) { return 0; }
+
+static A10 *c18 (void);
+void
+h18 (void)
+{
+  sizeof(*c18());
+  {
+    extern IA *c18 (void);
+    sizeof(*c18());
+  }
+  sizeof(*c18());
+}
+static A10 *c18 (void) { return 0; }
+
+static A10 *c19 (void);
+void
+h19 (void)
+{
+  sizeof(*c19());
+  {
+    extern A10 *c19 (void);
+    sizeof(*c19());
+  }
+  sizeof(*c19());
+}
+static A10 *c19 (void) { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-4.c
new file mode 100644
index 000000000..80f678ec2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-4.c
@@ -0,0 +1,28 @@
+/* Test for multiple declarations and composite types, with built-in
+   functions.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -Wformat -g" } */
+
+void
+f (void)
+{
+  int printf;
+  int strcmp;
+  {
+    int printf (const char *, ...);
+    int strcmp ();
+    /* Should get format warnings even though the built-in declaration
+       isn't "visible".  */
+    printf ("%s", 1); /* { dg-warning "format" } */
+    /* The type of strcmp here should have no prototype.  */
+    if (0)
+      strcmp (1);
+    /* Likewise, implicitly declared memcmp.  */
+    if (0)
+      memcmp (1);
+  }
+}
+
+/* Should still diagnose incompatible prototype for strcmp.  */
+int strcmp (void); /* { dg-error "conflict" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-5.c
new file mode 100644
index 000000000..15b1f8c8e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-5.c
@@ -0,0 +1,19 @@
+/* Test for multiple declarations and composite types.  Diagnosis of
+   incompatible implicit declaration.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=c89" } */
+
+void
+f (void)
+{
+  long z(); /* { dg-message "note: previous implicit declaration" } */
+}
+
+void
+g (void)
+{
+  z(); /* { dg-error "incompatible" } */
+  labs(1); /* { dg-warning "incompatible" } */
+  printf("x"); /* { dg-warning "incompatible" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-6.c
new file mode 100644
index 000000000..164ec974d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-6.c
@@ -0,0 +1,24 @@
+/* Test for multiple declarations and composite types.  As in bug
+   13801.  Illustrates how bug causes correct code to be wrongly
+   diagnosed.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+typedef int IA[];
+typedef int A5[5];
+typedef int A10[10];
+
+A10 array10;
+
+A5 *ap;
+void
+f (void)
+{
+  int ap;
+  {
+    extern IA *ap;
+    /* This assignment is valid.  */
+    ap = &array10;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-7.c
new file mode 100644
index 000000000..6168562ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-7.c
@@ -0,0 +1,23 @@
+/* Test for multiple declarations and composite types.  Diagnosis of
+   completion incompatible with implicit initializer.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+int x[];
+
+void
+f (void)
+{
+  extern int x[2]; /* { dg-error "completed incompatibly" } */
+}
+
+/* The following is OK.  */
+
+int y[];
+void
+g (void)
+{
+  extern int y[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-8.c
new file mode 100644
index 000000000..9145b9fdd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-8.c
@@ -0,0 +1,23 @@
+/* Test for multiple declarations and composite types.  Diagnosis of
+   completion incompatible with implicit initializer.  */
+
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+static int x[];
+
+void
+f (void)
+{
+  extern int x[2]; /* { dg-error "completed incompatibly" } */
+}
+
+/* The following is OK.  */
+
+static int y[];
+void
+g (void)
+{
+  extern int y[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-9.c
new file mode 100644
index 000000000..6fe25800e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/redecl-9.c
@@ -0,0 +1,30 @@
+/* Test for multiple declarations and composite types, as in bug
+   13801.  Test types saved from outer scopes are up to date.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int x[];
+
+void
+f (void)
+{
+  extern int x[];
+}
+
+int x[10];
+
+void
+g (void)
+{
+  int x;
+  {
+    extern int x[10];
+  }
+}
+
+void
+h (void)
+{
+  sizeof (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/reg-vol-struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/reg-vol-struct-1.c
new file mode 100644
index 000000000..b885f9179
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/reg-vol-struct-1.c
@@ -0,0 +1,18 @@
+/* Test cases of structures with volatile fields declared register:
+   should be allowed unless register name given but explicitly taking
+   the address forbidden.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+
+/* { dg-do compile } */
+
+struct S { volatile int field; };
+
+void
+f (void)
+{
+  register struct S a;
+  register struct S b[2];
+  register struct S c __asm__("nosuchreg"); /* { dg-error "object with volatile field" "explicit reg name" } */
+  &a; /* { dg-error "address of register" "explicit address" } */
+  b; /* { dg-error "address of register" "implicit address" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-1.c
new file mode 100644
index 000000000..e36f49974
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-1.c
@@ -0,0 +1,14 @@
+/* PR/18160 */
+
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+
+/* This should yield an error even without -pedantic.  */
+/* { dg-options "-ansi" } */
+
+void g(int *);
+
+void f(void) 
+{ 
+  register int x __asm ("eax");
+  g(&x);	/* { dg-error "address of register variable" } */
+} 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-2.c
new file mode 100644
index 000000000..01816d5f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-2.c
@@ -0,0 +1,14 @@
+/* PR/18160 */
+
+/* { dg-do compile } */
+
+/* This should yield an error even without -pedantic.  */
+/* { dg-options "-ansi" } */
+
+void g(int *);
+
+void f(void) 
+{ 
+  register int x;
+  g(&x);	/* { dg-error "address of register variable" } */
+} 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-3.c
new file mode 100644
index 000000000..dc659f57f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/register-var-3.c
@@ -0,0 +1,9 @@
+/* { dg-options "" } */
+/* { dg-do compile } */
+register int r0; /* { dg-error "register name not specified" } */
+register int bp; /* { dg-error "register name not specified" } */
+register int sp; /* { dg-error "register name not specified" } */
+register int r30; /* { dg-error "register name not specified" } */
+register int toc; /* { dg-error "register name not specified" } */
+register int d0; /* { dg-error "register name not specified" } */
+register int a0; /* { dg-error "register name not specified" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-1.c
new file mode 100644
index 000000000..2507cafa5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-1.c
@@ -0,0 +1,9 @@
+/* Missing warning for falling off the end of a non-void function.
+   egcs-1.1.2 passes, egcs-ss-19990428 fails.
+   http://gcc.gnu.org/ml/gcc-bugs/1999-03n/msg00221.html */
+/* { dg-do compile } */
+/* { dg-options "-O -Wreturn-type" } */
+int
+foo(void)
+{
+} /* { dg-warning "control reaches end of non-void function" "warning for falling off end of non-void function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-2.c
new file mode 100644
index 000000000..183c6a88d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-2.c
@@ -0,0 +1,47 @@
+/* Bogus warnings claiming we fall off the end of a non-void function.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/27/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wreturn-type" } */
+
+extern void abort (void) __attribute__ ((__noreturn__));
+
+int
+foo1 (int i)
+{
+  if (i)
+    return i;
+
+  abort ();
+} /* { dg-bogus "control reaches end of non-void function" "warning for falling off end of non-void function" } */
+
+__inline__ int
+foo2 (int i)
+{
+  if (i)
+    return i;
+
+  abort ();
+} /* { dg-bogus "control reaches end of non-void function" "warning for falling off end of non-void function" } */
+
+static int
+foo3 (int i)
+{
+  if (i)
+    return i;
+
+  abort ();
+} /* { dg-bogus "control reaches end of non-void function" "warning for falling off end of non-void function" } */
+
+static __inline__ int
+foo4 (int i)
+{
+  if (i)
+    return i;
+
+  abort ();
+} /* { dg-bogus "control reaches end of non-void function" "warning for falling off end of non-void function" } */
+
+int bar (int i)
+{
+  return foo1 (i) + foo2 (i) + foo3 (i) + foo4 (i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-3.c
new file mode 100644
index 000000000..e06ba7c02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/return-type-3.c
@@ -0,0 +1,14 @@
+/* PR optimization/7189
+   This was a missing warning caused by a cfg cleanup after sibling
+   call optimization.  The return clobber insn was cleaned up and
+   the warning was never issued.  */
+/* { dg-do compile } */
+/* { dg-options "-O -foptimize-sibling-calls -Wreturn-type" } */
+
+extern void foo(void);
+
+int
+bar (void)
+{
+  foo();
+} /* { dg-warning "control reaches end of non-void function" "warning for falling off end of non-void function" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/section1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/section1.c
new file mode 100644
index 000000000..39ca969a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/section1.c
@@ -0,0 +1,5 @@
+/* PR optimization/6871 */
+/* Constant variables belong in .rodata, not .bss.  */
+/* { dg-final { scan-assembler-not "\.bss" { xfail avr-*-*} } } */
+
+const int i = 0;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sequence-pt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sequence-pt-1.c
new file mode 100644
index 000000000..3b9214233
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sequence-pt-1.c
@@ -0,0 +1,109 @@
+/* Test for sequence point warnings.  */
+/* Origin: Michael Meeks in
+   <URL:http://gcc.gnu.org/ml/gcc-patches/1998-06/msg00316.html>,
+   adapted to a testcase by Joseph Myers <jsm28@cam.ac.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "-Wsequence-point" } */
+
+struct s
+{
+  int a;
+};
+
+extern int fn (int);
+extern int fnb (int, int);
+extern int fnc (int *);
+extern int sprintf (char *, const char *, ...);
+
+typedef __SIZE_TYPE__ size_t;
+
+void
+foo (int a, int b, int n, int p, int *ptr, struct s *sptr,
+     int *ap, int *bp, int **cp, char *ans, int (*fnp[8])(int))
+{
+  int len;
+    
+  a = a++; /* { dg-warning "undefined" "sequence point warning" } */
+  a = --a; /* { dg-warning "undefined" "sequence point warning" } */
+  a = ++a + b; /* { dg-warning "undefined" "sequence point warning" } */
+  a = a-- + b; /* { dg-warning "undefined" "sequence point warning" } */
+  ap[n] = bp[n++]; /* { dg-warning "undefined" "sequence point warning" } */
+  ap[--n] = bp[n]; /* { dg-warning "undefined" "sequence point warning" } */
+  ap[++n] = bp[--n]; /* { dg-warning "undefined" "sequence point warning" } */
+  cp[n][n] = cp[n][n]++; /* { dg-warning "undefined" "sequence point warning" { xfail *-*-* } } */
+  cp[n][p] = cp[n][n++]; /* { dg-warning "undefined" "sequence point warning" } */
+  *ptr++ = (size_t)ptr++; /* { dg-warning "undefined" "sequence point warning" } */
+  sptr->a = sptr->a++; /* { dg-warning "undefined" "sequence point warning" { xfail *-*-* } } */
+  sptr->a = (size_t)(sptr++); /* { dg-warning "undefined" "sequence point warning" } */
+  *ptr++ = fn (*ptr); /* { dg-warning "undefined" "sequence point warning" } */
+  a = b = a++; /* { dg-warning "undefined" "sequence point warning" } */
+  b = a = --b; /* { dg-warning "undefined" "sequence point warning" } */
+  a = 1 + (a = 1); /* { dg-warning "undefined" "sequence point warning" } */
+  a = (a = b); /* { dg-warning "undefined" "sequence point warning" } */
+  a = (a = b) + 1; /* { dg-warning "undefined" "sequence point warning" } */
+  a = (bp[a++] = b) + 1; /* { dg-warning "undefined" "sequence point warning" } */
+  a = b++ * b++; /* { dg-warning "undefined" "sequence point warning" } */
+  a = fnb (b++, b++); /* { dg-warning "undefined" "sequence point warning" } */
+  a = (*fnp[b++]) (b++); /* { dg-warning "undefined" "sequence point warning" } */
+  a = (*fnp[b]) (b++); /* { dg-warning "undefined" "sequence point warning" } */
+  a = (*fnp[b++]) (b); /* { dg-warning "undefined" "sequence point warning" } */
+  *ap = fnc (ap++); /* { dg-warning "undefined" "sequence point warning" } */
+  (a += b) + (a += n); /* { dg-warning "undefined" "sequence point warning" } */
+  a =  (b, b++) + (b++, b); /* { dg-warning "undefined" "sequence point warning" } */
+  ap[a++] += a; /* { dg-warning "undefined" "sequence point warning" } */
+  ap[a+=1] += a; /* { dg-warning "undefined" "sequence point warning" } */
+  ap[a++] += a++; /* { dg-warning "undefined" "sequence point warning" } */
+  ap[a+=1] += a++; /* { dg-warning "undefined" "sequence point warning" } */
+  a = a++, b = a; /* { dg-warning "undefined" "sequence point warning" } */
+  b = a, a = a++; /* { dg-warning "undefined" "sequence point warning" } */
+  a = (b++ ? n : a) + b; /* { dg-warning "undefined" "sequence point warning" } */
+  b ? a = a++ : a; /* { dg-warning "undefined" "sequence point warning" } */
+  b && (a = a++); /* { dg-warning "undefined" "sequence point warning" } */
+  (a = a++) && b; /* { dg-warning "undefined" "sequence point warning" } */
+  b, (a = a++); /* { dg-warning "undefined" "sequence point warning" } */
+  (a = a++), b; /* { dg-warning "undefined" "sequence point warning" } */
+  a ^= b ^= a ^= b; /* { dg-warning "undefined" "sequence point warning" } */
+
+  a = a; /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = (a++ && 4); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = ! (a++ && 4); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = - (a++ && 4); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = (double) (a++ && 4); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  len = sprintf (ans, "%d", len++); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = fn (a++); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  b++, (b + b); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  (a = b++), (a = b++); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = (b++, b++); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = b++ && b++; /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = b++ || b++; /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = (b++ ? b++ : a); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  a = (b++ ? a : b++); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  ap[a++] += bp[b]; /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  ap[a += 1] += 1; /* { dg-bogus "undefined" "bogus sequence point warning" } */
+  *ptr < 128 ? *ptr++ : *(ptr += 2); /* { dg-bogus "undefined" "bogus sequence point warning" } */
+
+  /* The following will be represented internally with a tree consisting of
+     many duplicated SAVE_EXPRs.  This caused the previous version of the
+     sequence point warning code to fail by running out of virtual memory.  */
+  a = ((b & 1 ? 21 : 0)
+       | (b & 2 ? 22 : 0)
+       | (b & 3 ? 23 : 0)
+       | (b & 4 ? 24 : 0)
+       | (b & 5 ? 25 : 0)
+       | (b & 6 ? 26 : 0)
+       | (b & 7 ? 27 : 0)
+       | (b & 8 ? 28 : 0)
+       | (b & 9 ? 29 : 0)
+       | (b & 10 ? 30 : 0)
+       | (b & 11 ? 31 : 0)
+       | (b & 12 ? 32 : 0)
+       | (b & 13 ? 1 : 0)
+       | (b & 14 ? 2 : 0)
+       | (b & 15 ? 3 : 0)
+       | (b & 16 ? 4 : 0)
+       | (b & 17 ? 5 : 0)
+       | (b & 18 ? 6 : 0)
+       | (b & 19 ? 7 : 0)
+       | (b & 20 ? 8 : 0)
+       | (b & 21 ? 9 : 0));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sequence-pt-pr17880.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sequence-pt-pr17880.c
new file mode 100644
index 000000000..df706e577
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sequence-pt-pr17880.c
@@ -0,0 +1,54 @@
+/* PR 17880 */
+/* { dg-do compile } */
+/* { dg-options "-Wsequence-point" } */
+
+int
+foo (int x)
+{
+  unsigned int a;
+  int b;
+
+  b = (a += 5) > a;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = (a += 5) + a == 10;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = (a -= 5) > a;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = (a -= 5) + a == 10;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = a-- > a;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = a-- + a == 10;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = ++a > a;  /* { dg-warning "undefined" "sequence point warning" } */
+  b = ++a + a == 10;  /* { dg-warning "undefined" "sequence point warning" } */
+
+  if ((a += 5) > a) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if ((a += 5) + a == 10) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if ((a -= 5) > a) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if ((a -= 5) + a == 10) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if (a-- > a) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if (a-- + a == 10) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if (++a > a) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  if (++a + a == 10) return -1;  /* { dg-warning "undefined" "sequence point warning" } */
+  do {} while ((a += 5) > a);  /* { dg-warning "undefined" "sequence point warning" } */
+  while ((a += 5) > a);  /* { dg-warning "undefined" "sequence point warning" } */
+  for ((a += 5) > a;;);  /* { dg-warning "undefined" "sequence point warning" } */
+  for (b = (a += 5) > a;;);  /* { dg-warning "undefined" "sequence point warning" } */
+  for (; (a += 5) > a;);  /* { dg-warning "undefined" "sequence point warning" } */
+  for (;; b = (a += 5) > a);  /* { dg-warning "undefined" "sequence point warning" } */
+  for (;; a++ + a++);  /* { dg-warning "undefined" "sequence point warning" } */
+  if (a) a++ - a--;    /* { dg-warning "undefined" "sequence point warning" } */
+  ((a +=5) > a) ? a : b; /* { dg-warning "undefined" "sequence point warning" } */
+  return (a++ - a--); /* { dg-warning "undefined" "sequence point warning" } */
+}
+
+void bar (int i)
+{
+  int a = i++ - i++; /* { dg-warning "undefined" "sequence point warning" } */
+} 
+
+void baz (int i)
+{
+  switch (i++ + i++)  /* { dg-warning "undefined" "sequence point warning" } */
+    {
+    case 1:
+      i++ - i++;  /* { dg-warning "undefined" "sequence point warning" } */
+    case 2:
+      break;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-1.c
new file mode 100644
index 000000000..b5c84fc87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-1.c
@@ -0,0 +1,36 @@
+/* Test for bogus "variable `x' may be clobbered by longjmp" warnings.
+   Inspired by cse.c:simplify_relational_operation. */
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wclobbered -Wextra -Wall" } */
+
+#include <setjmp.h>
+
+extern void set_float_handler (jmp_buf *);
+
+#define EQ 0x01
+#define LT 0x02
+#define GT 0x04
+
+int
+compare_float (double a, double b)  /* { dg-bogus "clobbered" "spurious clobbered warning" } */
+{
+  jmp_buf handler;
+  int result;
+
+  a += 1.0;
+
+  if (setjmp (handler))
+    {
+      set_float_handler (0);
+      return 0;
+    }
+
+  set_float_handler (&handler);
+  if (a == b) result = EQ;
+  else if (a > b) result = LT;
+  else if (a < b) result = GT;
+  else result = 0;
+  set_float_handler (0);
+  return result;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-2.c
new file mode 100644
index 000000000..8ad874d52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-2.c
@@ -0,0 +1,48 @@
+/* PR middle-end/17813 */
+/* Origin: Tom Hughes <tom@compton.nu> */
+/* { dg-do run { target i?86-*-linux* x86_64-*-linux* } } */
+/* { dg-options "-O -fomit-frame-pointer" } */
+/* { dg-options "-O -fomit-frame-pointer -march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#include <setjmp.h>
+#include <signal.h>
+#include <stdlib.h>
+
+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.4.3/gcc/testsuite/gcc.dg/setjmp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-3.c
new file mode 100644
index 000000000..306861d25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-3.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+
+#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.4.3/gcc/testsuite/gcc.dg/setjmp-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-4.c
new file mode 100644
index 000000000..53bf0e872
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/setjmp-4.c
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+
+#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.4.3/gcc/testsuite/gcc.dg/short-compare-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/short-compare-1.c
new file mode 100644
index 000000000..4c470529b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/short-compare-1.c
@@ -0,0 +1,20 @@
+/* PR rtl-optimization/19296 */
+/* Origin: Falk Hueffner <falk@debian.org> */
+
+/* { dg-do run } */
+/* { dg-options "-O" } */
+/* { dg-options "-O -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern void abort(void);
+
+void f(unsigned short ad)
+{
+  if (ad >= 0x4000 && ad < 0xc000) 
+    abort();
+}
+
+int main(void)
+{
+  f(0xff00); 
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/short-compare-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/short-compare-2.c
new file mode 100644
index 000000000..0026a88c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/short-compare-2.c
@@ -0,0 +1,21 @@
+/* PR rtl-optimization/19296 */
+/* Origin: Falk Hueffner <falk@debian.org> */
+/* Testcase by Andrew Pinski <pinskia@gcc.gnu.org> */
+
+/* { dg-do run } */
+/* { dg-options "-O" } */
+/* { dg-options "-O -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern void abort();
+
+void f(unsigned short ad)
+{
+  if ((short) (ad - 0x4000) >= 0)
+    abort();
+}
+
+int main(void)
+{
+  f(0xc000);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-1.c
new file mode 100644
index 000000000..4521ace9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-1.c
@@ -0,0 +1,49 @@
+/* Simple check that sibling calls are performed from a
+   void non-leaf-function taking one int argument calling itself.
+
+   Copyright (C) 2002 Free Software Foundation Inc.
+   Contributed by Hans-Peter Nilsson  <hp@bitrange.com>  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -foptimize-sibling-calls" } */
+
+/* The option -foptimize-sibling-calls is the default, but serves as
+   marker.  Self-recursion tail calls are optimized for all targets,
+   regardless of presence of sibcall patterns.  */
+
+extern void abort (void);
+extern void exit (int);
+
+extern void recurser_void (int);
+extern void track (int);
+
+int main ()
+{
+  recurser_void (0);
+  exit (0);
+}
+
+void
+recurser_void (int n)
+{
+  if (n == 0 || n == 7)
+    track (n);
+
+  if (n == 10)
+    return;
+
+  recurser_void (n + 1);
+}
+
+void *trackpoint;
+
+void
+track (int n)
+{
+  char stackpos[1];
+
+  if (n == 0)
+    trackpoint = stackpos;
+  else if (n != 7 || trackpoint != stackpos)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-2.c
new file mode 100644
index 000000000..4c226c496
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-2.c
@@ -0,0 +1,50 @@
+/* Simple check that sibling calls are performed from a
+   void non-leaf-function taking no arguments calling itself.
+
+   Copyright (C) 2002 Free Software Foundation Inc.
+   Contributed by Hans-Peter Nilsson  <hp@bitrange.com>  */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -foptimize-sibling-calls" } */
+
+/* The option -foptimize-sibling-calls is the default, but serves as
+   marker.  Self-recursion tail calls are optimized for all targets,
+   regardless of presence of sibcall patterns.  */
+
+extern void abort (void);
+extern void exit (int);
+
+extern void recurser_void (void);
+extern void track (void);
+
+int n = 0;
+int main ()
+{
+  recurser_void ();
+  exit (0);
+}
+
+void
+recurser_void (void)
+{
+  if (n == 0 || n == 7)
+    track ();
+
+  if (n == 10)
+    return;
+  n++;
+  recurser_void ();
+}
+
+void *trackpoint;
+
+void
+track ()
+{
+  char stackpos[1];
+
+  if (n == 0)
+    trackpoint = stackpos;
+  else if (n != 7 || trackpoint != stackpos)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-3.c
new file mode 100644
index 000000000..e085bfbc7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-3.c
@@ -0,0 +1,78 @@
+/* Simple check that sibling calls are performed from a
+   void non-leaf-function taking one int argument calling a function which
+   is about the same as itself.
+
+   Copyright (C) 2002 Free Software Foundation Inc.
+   Contributed by Hans-Peter Nilsson  <hp@bitrange.com>  */
+
+/* { dg-do run { xfail { { arc-*-* avr-*-* cris-*-* crisv32-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa*-*-* } || { arm*-*-* && { ! arm32 } } } } } */
+/* -mlongcall disables sibcall patterns.  */
+/* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */
+/* { dg-options "-O2 -foptimize-sibling-calls" } */
+
+/* The option -foptimize-sibling-calls is the default, but serves as
+   marker.  This test is xfailed on targets without sibcall patterns
+   (except targets where the test does not work due to the return address
+   not saved on the regular stack).  */
+
+extern void abort (void);
+extern void exit (int);
+
+/* Sibcalls are not supported in MIPS16 mode, which has direct calls but
+   not direct jumps.  */
+#ifdef __mips
+#define ATTR __attribute__((nomips16))
+#else
+#define ATTR
+#endif
+
+static ATTR void recurser_void1 (int);
+static ATTR void recurser_void2 (int);
+extern void track (int);
+
+int main ()
+{
+  recurser_void1 (0);
+  exit (0);
+}
+
+/* The functions should get the same stack-frame, and best way to make it
+   reasonably sure is to make them have the same contents (regarding the
+   n tests).  */
+
+static void __attribute__((noinline)) ATTR
+recurser_void1 (int n)
+{
+  if (n == 0 || n == 7 || n == 8)
+    track (n);
+
+  if (n == 10)
+    return;
+
+  recurser_void2 (n + 1);
+}
+
+static void __attribute__((noinline)) ATTR
+recurser_void2 (int n)
+{
+  if (n == 0 || n == 7 || n == 8)
+    track (n);
+
+  if (n == 10)
+    return;
+
+  recurser_void1 (n + 1);
+}
+
+void *trackpoint;
+
+void
+track (int n)
+{
+  char stackpos[1];
+
+  if (n == 0)
+    trackpoint = stackpos;
+  else if ((n != 7 && n != 8) || trackpoint != stackpos)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-4.c
new file mode 100644
index 000000000..11b09d079
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-4.c
@@ -0,0 +1,79 @@
+/* Simple check that sibling calls are performed from a
+   void non-leaf-function taking no arguments calling a function which
+   is about the same as itself.
+
+   Copyright (C) 2002 Free Software Foundation Inc.
+   Contributed by Hans-Peter Nilsson  <hp@bitrange.com>  */
+
+/* { dg-do run { xfail { { arc-*-* avr-*-* cris-*-* crisv32-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa*-*-* } || { arm*-*-* && { ! arm32 } } } } } */
+/* -mlongcall disables sibcall patterns.  */
+/* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */
+/* { dg-options "-O2 -foptimize-sibling-calls" } */
+
+/* The option -foptimize-sibling-calls is the default, but serves as
+   marker.  This test is xfailed on targets without sibcall patterns
+   (except targets where the test does not work due to the return address
+   not saved on the regular stack).  */
+
+extern void abort (void);
+extern void exit (int);
+
+/* Sibcalls are not supported in MIPS16 mode, which has direct calls but
+   not direct jumps.  */
+#ifdef __mips
+#define ATTR __attribute__((nomips16))
+#else
+#define ATTR
+#endif
+
+static ATTR void recurser_void1 (void);
+static ATTR void recurser_void2 (void);
+extern void track (void);
+
+int n = 0;
+int main ()
+{
+  recurser_void1 ();
+  exit (0);
+}
+
+/* The functions should get the same stack-frame, and best way to make it
+   reasonably sure is to make them have the same contents (regarding the
+   n tests).  */
+
+static void __attribute__((noinline)) ATTR
+recurser_void1 (void)
+{
+  if (n == 0 || n == 7 || n == 8)
+    track ();
+
+  if (n == 10)
+    return;
+  n++;
+  recurser_void2 ();
+}
+
+static void __attribute__((noinline)) ATTR
+recurser_void2 (void)
+{
+  if (n == 0 || n == 7 || n == 8)
+    track ();
+
+  if (n == 10)
+    return;
+  n++;
+  recurser_void1 ();
+}
+
+void *trackpoint;
+
+void
+track ()
+{
+  char stackpos[1];
+
+  if (n == 0)
+    trackpoint = stackpos;
+  else if ((n != 7 && n != 8) || trackpoint != stackpos)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-6.c
new file mode 100644
index 000000000..6f2f21881
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-6.c
@@ -0,0 +1,46 @@
+/* A simple check to see whether indirect calls are
+   being sibcall optimized on targets that do support
+   this notion, i.e. have the according call patterns
+   in place.
+
+   Copyright (C) 2002 Free Software Foundation Inc.
+   Contributed by Andreas Bauer <baueran@in.tum.de>  */
+
+/* { dg-do run { target i?86-*-* x86_64-*-* s390*-*-* } } */
+/* { dg-skip-if "" { { i?86-*-* x86_64-*-* } && { ilp32 && { ! nonpic } } } { "*" } { "" } } */
+/* { dg-options "-O2 -foptimize-sibling-calls" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int foo (int);
+int bar (int);
+
+int (*ptr) (int);
+int *f_addr;
+
+int
+main ()
+{
+  ptr = bar;
+  foo (7);
+  exit (0);
+}
+
+int
+bar (b)
+     int b;
+{
+  if (f_addr == (int*) __builtin_return_address (0))
+    return b;
+  else
+    abort ();
+}
+
+int
+foo (f)
+     int f;
+{
+  f_addr = (int*) __builtin_return_address (0);
+  return (*ptr)(f);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-7.c
new file mode 100644
index 000000000..6d59ca339
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-7.c
@@ -0,0 +1,46 @@
+/* Simple check that tail recursive call optimization is also
+   controlled by -foptimize-sibling-calls.
+
+   Copyright (C) 2006 Free Software Foundation Inc.
+   Original test by Hans-Peter Nilsson  <hp@bitrange.com>  */
+
+/* On IA64 the call frame is allocated on the register stack, not the
+   normal stack.  */
+
+/* { dg-do run { target { ! "ia64-*-*" } } } */
+/* { dg-options "-O2 -fno-optimize-sibling-calls" } */
+
+
+extern void abort (void);
+
+extern void recurser_void (int);
+extern void track (int);
+
+int main (void)
+{
+  recurser_void (0);
+  return 0;
+}
+
+void recurser_void (int n)
+{
+  if (n == 0 || n == 7)
+    track (n);
+
+  if (n == 10)
+    return;
+
+  recurser_void (n + 1);
+}
+
+void *trackpoint;
+
+void track (int n)
+{
+  char stackpos[1];
+
+  if (n == 0)
+    trackpoint = stackpos;
+  else if (n != 7 || trackpoint == stackpos)
+    abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-8.c
new file mode 100644
index 000000000..767040fd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sibcall-8.c
@@ -0,0 +1,30 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -foptimize-sibling-calls" } */
+
+typedef struct {
+  int data[4];
+} arr16_t;
+
+int result = 0;
+
+void func2(int i, int j, arr16_t arr)
+{
+  result = (arr.data[0] != 1
+	    || arr.data[1] != 2
+	    || arr.data[2] != 3
+	    || arr.data[3] != 4);
+}
+
+void func1(int i, int j, int k, arr16_t a)
+{
+  func2(i, j, a);
+}
+
+int main(int argc, const char *argv[])
+{
+  arr16_t arr = {{1, 2, 3, 4}};
+    
+  func1(0, 0, 0, arr);
+  return result;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-1.c
new file mode 100644
index 000000000..e00e1dd69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-1.c
@@ -0,0 +1,62 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+/* Origin: Aldy Hernandez <aldyh@redhat.com>.  */
+/* Purpose: Program to test generic SIMD support.  */
+
+typedef int __attribute__((vector_size (16))) v4si;
+typedef short __attribute__((vector_size (16))) v8hi;
+typedef int __attribute__((vector_size (8))) v2si;
+typedef unsigned int __attribute__((vector_size (16))) uv4si;
+
+v4si a, b;
+v2si c, d;
+v8hi e;
+uv4si f;
+
+long long foo;
+int foo1;
+short foo2 __attribute__((vector_size (8)));
+
+void
+hanneke ()
+{
+  /* Assignment.  */
+  a = b;
+
+  /* Assignment of different types.  */
+  b = c; /* { dg-error "incompatible types when assigning" } */
+  d = a; /* { dg-error "incompatible types when assigning" } */
+
+  /* Casting between SIMDs of the same size.  */
+  e = (typeof (e)) a;
+
+  /* Different signed SIMD assignment.  */
+  f = a; /* { dg-message "note: use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts" } */
+  /* { dg-error "incompatible types when assigning" "" { target *-*-* } 35 } */
+
+  /* Casted different signed SIMD assignment.  */
+  f = (uv4si) a;
+
+  /* Assignment between scalar and SIMD of different size.  */
+  foo = a; /* { dg-error "incompatible types when assigning" } */
+
+  /* Casted assignment between scalar and SIMD of same size.  */
+  foo = (typeof (foo)) foo2;
+
+  /* Casted assignment between scalar and SIMD of different size.  */
+  foo1 = (typeof (foo1)) foo2; /* { dg-error "can't convert between vector values of different size" } */
+
+  /* Operators on compatible SIMD types.  */
+  a += b + b;
+  a -= b;
+  a *= b;
+  a /= b;
+  a = -b;
+
+  /* Operators on incompatible SIMD types.  */
+  a = b + c; /* { dg-error "invalid operands to binary +" } */
+  a = b - c; /* { dg-error "invalid operands to binary -" } */
+  a = b * c; /* { dg-error "invalid operands to binary *" } */
+  a = b / c; /* { dg-error "invalid operands to binary /" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-1b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-1b.c
new file mode 100644
index 000000000..56d94b91c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-1b.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+/* Origin: Aldy Hernandez <aldyh@redhat.com>.  */
+/* Purpose: Program to test generic SIMD support.  */
+
+typedef int __attribute__((vector_size (16))) v4si;
+typedef int __attribute__((vector_size (8))) v2si;
+
+v4si a, b;
+v2si c, d;
+
+void
+hanneke ()
+{
+  /* Operators on compatible SIMD types.  */
+  a %= b; /* { dg-error "invalid operands to binary %" } */
+  c &= d;
+  a |= b;
+  c ^= d;
+  a >>= b; /* { dg-error "invalid operands to binary >>" } */
+  c <<= d; /* { dg-error "invalid operands to binary <<" } */
+  a = +b;
+  c = ~d;
+
+  /* Operators on incompatible SIMD types.  */
+  a = b % c; /* { dg-error "invalid operands to binary" } */
+  a = b % c; /* { dg-error "invalid operands to binary" } */
+  d = c & b; /* { dg-error "invalid operands to binary" } */
+  a = b | c; /* { dg-error "invalid operands to binary" } */
+  d = c ^ b; /* { dg-error "invalid operands to binary" } */
+  a = b >> c; /*  { dg-error "invalid operands to binary" } */
+  a = b >> c; /* { dg-error "invalid operands to binary" } */
+  d = c << b; /* { dg-error "invalid operands to binary" } */
+  d = c << b; /* { dg-error "invalid operands to binary" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-2.c
new file mode 100644
index 000000000..13e1caba6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-2.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+/* Origin: Aldy Hernandez <aldyh@redhat.com>.  */
+/* Purpose: Program to test generic SIMD support.  */
+
+typedef float __attribute__((vector_size(8))) v2sf;
+typedef float __attribute__((vector_size(16))) v4sf;
+typedef double __attribute__((vector_size(16))) v2df;
+
+v4sf a, b;
+v2sf c, d;
+v2df e;
+
+double foo;
+float foo1;
+v2sf foo2;
+
+void
+hanneke ()
+{
+  /* Assignment.  */
+  a = b;
+
+  /* Assignment of different types.  */
+  b = c; /* { dg-error "incompatible types when assigning" } */
+  d = a; /* { dg-error "incompatible types when assigning" } */
+
+  /* Casting between SIMDs of the same size.  */
+  e = (typeof (e)) a;
+
+  /* Assignment between scalar and SIMD of different size.  */
+  foo = a; /* { dg-error "incompatible types when assigning" } */
+
+  /* Casted assignment between scalar and SIMD of same size.  */
+  foo = (typeof (foo)) foo2; /* { dg-error "aggregate value used where a float was expected" } */
+
+  /* Casted assignment between scalar and SIMD of different size.  */
+  foo1 = (typeof (foo1)) foo2; /* { dg-error "aggregate value used where a float was expected" } */
+
+  /* Operators on compatible SIMD types.  */
+  a += b + b;
+  a -= b;
+  a *= b;
+  a /= b;
+  a = +b;
+  c = -d;
+
+  /* Operators on incompatible SIMD types.  */
+  a = b + c; /* { dg-error "invalid operands to binary" } */
+  a = b - c; /* { dg-error "invalid operands to binary" } */
+  a = b * c; /* { dg-error "invalid operands to binary" } */
+  a = b / c; /* { dg-error "invalid operands to binary" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-3.c
new file mode 100644
index 000000000..790b1e51e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-maltivec" { target { powerpc*-*-* && powerpc_altivec_ok } } } */
+
+__attribute__ ((vector_size (2))) signed char v1, v2, v3;
+void
+one (void)
+{
+  v1 = v2 + v3;
+}
+
+__attribute__ ((vector_size (8))) signed char v4, v5, v6;
+void
+two (void)
+{
+  v4 = v5 + v6;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-4.c
new file mode 100644
index 000000000..f7b28d452
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-4.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+
+typedef int myint;
+
+float __attribute__((vector_size(16))) b;
+int __attribute__((vector_size(16))) d;
+myint __attribute__((vector_size(16))) d2;
+unsigned int __attribute__((vector_size(16))) e;
+
+void foo()
+{
+	b + d; /* { dg-error "invalid operands to binary" } */
+	d += e;
+	d2 += d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-5.c
new file mode 100644
index 000000000..cb0ecf898
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-5.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu89" } */
+
+/* Ensure that we don't need a typedef to initialize a vector type.  */
+#define vector __attribute__ ((vector_size (8)))
+vector char x = (vector char) {1,2,3,4,5,6,7,8}; /* { dg-bogus "initializer" } */
+vector char y = (vector short) {1,2,3,4}; /* { dg-message "note: use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts" } */
+  /* { dg-error "incompatible types when initializing" "" { target *-*-* } 7 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-6.c
new file mode 100644
index 000000000..969697994
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/simd-6.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -std=gnu99" } */
+
+/* Ensure that we don't need a typedef to initialize a vector type.  */
+#define vector __attribute__ ((vector_size (8)))
+vector char x = (vector char) {1,2,3,4,5,6,7,8}; /* { dg-bogus "initializer" } */
+vector char y = (vector short) {1,2,3,4}; /* { dg-message "note: use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts" } */
+  /* { dg-error "incompatible types when initializing" "" { target *-*-* } 7 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/single-precision-constant.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/single-precision-constant.c
new file mode 100644
index 000000000..ffd893d93
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/single-precision-constant.c
@@ -0,0 +1,26 @@
+/* Test that double precision constants are correctly handled 
+   when code is compiled with -fsingle-precision-constant */
+/* Origin: Carlos O'Donell <carlos@codesourcery.com> */
+
+/* { dg-do run } */
+/* { dg-options "-fsingle-precision-constant" } */
+/* { dg-add-options c99_runtime } */
+
+#include <math.h>
+#include <float.h>
+
+#include "builtins-config.h"
+
+int main (void)
+{
+  int result = 0;
+  double local_DBL_MAX = DBL_MAX; 
+  double local_DBL_MIN = DBL_MIN;
+#ifdef HAVE_C99_RUNTIME
+  if (isinf (local_DBL_MAX))
+    result |= 1;
+#endif
+  if (local_DBL_MIN <= 0.0)
+    result |= 1;
+  return result;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sizeof-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sizeof-1.c
new file mode 100644
index 000000000..9541a4c27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sizeof-1.c
@@ -0,0 +1,4 @@
+/* PR c/27718 */
+/* { dg-do compile } */
+
+int i = sizeof(struct A[]);  /* { dg-error "incomplete" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sizeof-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sizeof-2.c
new file mode 100644
index 000000000..018ed740a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sizeof-2.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+
+
+void foo()
+{
+  sizeof(,); /* { dg-error "expected expression before" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/smod-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/smod-1.c
new file mode 100644
index 000000000..8ff60de13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/smod-1.c
@@ -0,0 +1,25 @@
+/* PR middle-end/18045 */
+/* Contributed by Eric Botcazou <ebotcazou@libertysurf.fr> */
+
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+/* { dg-options "-std=c99 -mtune=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#include <limits.h>
+
+extern void abort(void);
+
+long long smod16(long long x)
+{
+  return x % 16;
+}
+
+int main(void)
+{
+#if LLONG_MAX > 2147483647L
+  if (smod16 (0xFFFFFFFF) != 0xF)
+    abort ();
+#endif
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-1.c
new file mode 100644
index 000000000..d915ef54f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-1.c
@@ -0,0 +1,38 @@
+/* The same test as loop-3c.c.  It failed on ia64
+   due to not handling of subreg in the lhs that is fixed.  */
+/* { dg-do run } */
+/* { dg-options "-O2 -fmodulo-sched -fmodulo-sched-allow-regmoves -w" } */
+
+
+#include <limits.h>
+
+void * a[255];
+
+f (m)
+{
+  int i;
+  int sh = 0x100;
+  i = m;
+  do
+    {
+      a[sh >>= 1] = ((unsigned)i << 3)  + (char*)a;
+      i += 4;
+    }
+  while (i < INT_MAX/2 + 1 + 4 * 4);
+}
+
+main ()
+{
+  a[0x10] = 0;
+  a[0x08] = 0;
+  f (INT_MAX/2 + INT_MAX/4 + 2);
+  if (a[0x10] || a[0x08])
+    abort ();
+  a[0x10] = 0;
+  a[0x08] = 0;
+  f (INT_MAX/2 + 1);
+  if (! a[0x10] || a[0x08])
+    abort ();
+  exit (0);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-2.c
new file mode 100644
index 000000000..04d0482ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-2.c
@@ -0,0 +1,36 @@
+/* The same test as 921011-1.c.  It can fails on gcc 4.1 due to a dfs
+   traversal of the loops after versioning.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fmodulo-sched -fdump-rtl-sms" } */
+
+
+void
+fun (nb)
+     int nb;
+{
+  int th, h, em, nlwm, nlwS, nlw, sy;
+
+  while (nb--)
+    while (h--)
+      {
+	nlw = nlwm;
+	while (nlw)
+	  {
+	    if (nlwS == 1)
+	      {
+	      }
+	    else
+	      if (nlwS == 1)
+		{
+		}
+	    nlwS--; nlw--;
+	  }
+	if (em)
+	  nlwS--;
+	if (++sy == th)
+	  sy = 0;
+      }
+}
+
+/* { dg-final { cleanup-rtl-dump "sms" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-3.c
new file mode 100644
index 000000000..66792b599
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-3.c
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fmodulo-sched -funroll-loops" } */
+
+extern void abort (void);
+
+int X[1000]={0};
+int Y[1000]={0};
+
+extern void abort (void);
+
+int
+foo (int len, long a)
+{
+  int i;
+  long res = a;
+
+  len = 1000;
+  for (i = 0; i < len; i++)
+    res += X[i]* Y[i];
+
+  if (res != 601)
+    abort ();
+
+}
+
+int
+main ()
+{
+  X[0] = Y[1] = 2;
+  Y[0] = X[1] = 21;
+  X[2] = Y[3] = 3;
+  Y[2] = X[3] = 31;
+  X[4] = Y[5] = 4;
+  Y[4] = X[5] = 41;
+
+  foo (6, 3);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-4.c
new file mode 100644
index 000000000..04e89bb25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-4.c
@@ -0,0 +1,35 @@
+/* Inspired from sbitmap_a_or_b_and_c_cg function in sbitmap.c.  */
+/* { dg-do run } */
+/* { dg-options "-O2 -fmodulo-sched -fmodulo-sched-allow-regmoves" } */
+
+extern void abort (void);
+
+int a[5] = { 0, 1, 0, 0, 0 };
+int b[5] = { 0, 1, 0, 1, 0 };
+int c[5] = { 0, 0, 1, 1, 0 };
+int dst[5] = { 0, 0, 0, 0, 0 };
+
+void
+foo (int size, int *ap, int *bp, int *cp, int *dstp)
+{
+  unsigned int i, n = size;
+  int changed = 0;
+
+  for (i = 0; i < n; i++)
+    {
+      const int tmp = *ap++ | (*bp++ & *cp++);
+      changed |= *dstp ^ tmp;
+      *dstp++ = tmp;
+    }
+
+  if (changed == 0)
+    abort ();
+}
+
+int
+main ()
+{
+  foo (5, a, b, c, dst);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-5.c
new file mode 100644
index 000000000..9c2e0165c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-5.c
@@ -0,0 +1,47 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fmodulo-sched -fmodulo-sched-allow-regmoves -funroll-loops" } */
+/* This is the same test as loop-2e.c test.  It is related to a fix in
+   the generation of the prolog and epilog.  */
+
+extern void abort (void);
+
+void f (int *p, int **q)
+{
+  int i;
+  for (i = 0; i < 40; i++)
+    {
+      *q++ = &p[i];
+    }
+}
+
+int main ()
+{
+  void *p;
+  int *q[40];
+  __SIZE_TYPE__ start;
+
+  /* Find the signed middle of the address space.  */
+  if (sizeof(start) == sizeof(int))
+    start = (__SIZE_TYPE__) __INT_MAX__;
+  else if (sizeof(start) == sizeof(long))
+    start = (__SIZE_TYPE__) __LONG_MAX__;
+  else if (sizeof(start) == sizeof(long long))
+    start = (__SIZE_TYPE__) __LONG_LONG_MAX__;
+  else
+    return 0;
+
+  /* Arbitrarily align the pointer.  */
+  start &= -32;
+
+  /* Pretend that's good enough to start address arithmetic.  */
+  p = (void *)start;
+
+  /* Verify that GIV replacement computes the correct results.  */
+  q[39] = 0;
+  f (p, q);
+  if (q[39] != (int *)p + 39)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-6.c
new file mode 100644
index 000000000..3fe8ecda1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-6.c
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fmodulo-sched " } */
+
+extern void abort (void);
+
+void foo (int * __restrict__ a, int * __restrict__ b, int * __restrict__ c)
+{
+   int i;
+   for(i = 0; i < 100; i+=4)
+     {
+       a[i] = b[i] * c[i];
+       a[i+1] = b[i+1] * c[i+1];
+       a[i+2] = b[i+2] * c[i+2];
+       a[i+3] = b[i+3] * c[i+3];
+     }
+}   
+
+
+int a[100], b[100], c[100];
+int main()
+{
+  int i, res;
+  for(i = 0; i < 100; i++)
+    {
+      b[i] = c[i] = i;
+    }  
+  foo(a, b, c);
+  
+  res = 0;  
+  for(i = 0; i < 100; i++)
+    {
+      res += a[i];
+    }
+  if(res != 328350)
+    abort();
+  
+  return 0;        
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-7.c
new file mode 100644
index 000000000..7c4810d86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-7.c
@@ -0,0 +1,41 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fmodulo-sched -fstrict-aliasing " } */
+
+extern void abort (void);
+
+void foo (int * __restrict__ a, int * __restrict__ b, short * c) 
+{
+   int i;
+   for(i = 0; i < 100; i+=4)
+     {
+       a[i] = b[i] * c[i];
+       a[i+1] = b[i+1] * c[i+1];
+       a[i+2] = b[i+2] * c[i+2];
+       a[i+3] = b[i+3] * c[i+3];
+     }
+}   
+
+int a[100], b[100];
+short c[100];
+
+int main()
+{
+  int i, res;
+  for(i = 0; i < 100; i++)
+    {
+      b[i] = c[i] = i;
+    }  
+  foo(a, b, c);
+  
+  res = 0;  
+  for(i = 0; i < 100; i++)
+    {
+      res += a[i];
+    }
+  if(res != 328350)
+    abort();
+  
+  return 0;        
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-antideps.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-antideps.c
new file mode 100644
index 000000000..85976d641
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sms-antideps.c
@@ -0,0 +1,38 @@
+/*  This test is a reduced test case for a bug that caused
+    bootstrapping with -fmodulo-sched.  Related to a broken anti-dep
+    that was not fixed by reg-moves.  */
+
+ /* { dg-do run } */
+ /* { dg-options "-O2 -fmodulo-sched -fmodulo-sched-allow-regmoves" } */
+
+#include <stdlib.h>
+
+unsigned long long
+foo (long long ixi, unsigned ctr)
+{
+  unsigned long long irslt = 1;
+  long long ix = ixi;
+
+  for (; ctr; ctr--)
+    {
+      irslt *= ix;
+      ix *= ix;
+    }
+
+  if (irslt != 14348907)
+    abort ();
+  return irslt;
+}
+
+
+int
+main ()
+{
+  unsigned long long res;
+
+  res = foo (3, 4);
+  return 0;
+}
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/20000419-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/20000419-2.c
new file mode 100644
index 000000000..4a228eb1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/20000419-2.c
@@ -0,0 +1,18 @@
+/* A static function with a global alias should not get 'defined but
+   not used' warnings.  Exposed by Linux kernel.  */
+/* { dg-do compile } */
+/* { dg-require-alias "" } */
+/* { dg-options "-Wall" } */
+
+extern void do_something (void);
+extern void do_something_else (void);
+
+static int
+init_foobar(void)  /* { dg-bogus "defined but not used" "not used warning" } */
+{
+  do_something();
+  do_something_else();
+  return 0;
+}
+
+int init_module(void) __attribute__((alias("init_foobar")));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/alias-1.c
new file mode 100644
index 000000000..6798c5be4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/alias-1.c
@@ -0,0 +1,18 @@
+/* { dg-do link } */
+/* { dg-require-alias "" } */
+
+#include <stdlib.h>
+
+extern int foo(void) __attribute__((alias("bar")));
+
+int bar(void) {
+    return 1;
+}
+
+int main(void) {
+
+    if (foo())
+        exit(0);
+    else
+        abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/alias-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/alias-2.c
new file mode 100644
index 000000000..4cc8ce150
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/alias-2.c
@@ -0,0 +1,19 @@
+/* PR 3997 */
+/* { dg-do run } */
+/* { dg-require-alias "" } */
+
+extern void abort (void);
+extern void exit (int);
+
+void foo(void)
+{
+  exit(0);
+}
+
+static void bar(void) __attribute__((alias("foo")));
+
+int main()
+{
+  bar();
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/gcsec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/gcsec-1.c
new file mode 100644
index 000000000..ef1434fbe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/gcsec-1.c
@@ -0,0 +1,29 @@
+/* AIX gld supports garbage collection. But AIX gcc does not support 
+   -ffunction-sections or -fdata-sections.  */
+/* { dg-do run { xfail rs6000-*-aix* powerpc*-*-aix* } } */
+/* { dg-require-gc-sections "" } */
+
+/* { dg-options "-ffunction-sections -fdata-sections -Wl,--gc-sections" } */
+/* { dg-options "-ffunction-sections -fdata-sections -Wl,--gc-sections -static" { target static } } */
+
+#include <stdlib.h>
+
+static int unusedint=5;
+
+static int usedint=1;
+
+int unused(void) {
+    return 1;
+}
+
+int foo(void) {
+    return usedint;
+}
+
+int main(void) {
+
+    if (foo())
+        exit(0);
+    else
+        abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/mips-abi.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/mips-abi.exp
new file mode 100644
index 000000000..3af47be51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/mips-abi.exp
@@ -0,0 +1,104 @@
+#   Copyright (C) 2002, 2004, 2007 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 test checks whether MIPS ELF configurations pass the right
+# ABI flags to the assembler.  An ABI flag should always be passed
+# unless MEABI is selected.
+
+load_lib gcc-dg.exp
+
+# Only run this test on MIPS ELF targets
+if {![istarget mips*-*-*] || [gcc_target_object_format] != "elf"} {
+    return
+}
+
+# A list of all assembler ABI flags.
+set asm_abi_flags {-mabi=32 -mabi=n32 -mabi=64 -mabi=o64 -mabi=eabi}
+
+# Try to assemble mips-abi.s (an empty file), passing -v in order to
+# get the assembler command line.  Check whether an appropriate ABI
+# flag is passed.
+#
+# NAME is a name for the pass/fail line.
+# ABIS is a list of acceptable assembler ABI flags, or "" if no
+#   ABI flag is expected.
+# FLAGS is a list of options for gcc.
+proc check_mips_abi {name abis flags} {
+    global srcdir subdir
+
+    lappend flags "-v"
+    set lines [gcc_target_compile "$srcdir/$subdir/mips-abi.s" \
+				  "mips-abi.o" object \
+				  [list "additional_flags=$flags"]]
+    set good 0
+    set bad 0
+    foreach line [split $lines "\n"] {
+	# Find the assembler command line.
+	if {[string first "$srcdir/$subdir/mips-abi.s" $line] >= 0} {
+	    foreach arg [split $line " "] {
+		# Count the number of matching and non-matching
+		# ABI options.
+		if {[lsearch -exact $abis $arg] >= 0} {
+		    incr good
+		} elseif {[string match "-mabi=*" $arg]} {
+		    incr bad
+		}
+	    }
+	}
+    }
+    if {$good == ($abis != "") && $bad == 0} {
+	pass "mips-abi $name"
+    } else {
+	fail "mips-abi $name"
+    }
+}
+
+# Collect the default target flags.
+set default_flags ""
+set target [target_info name]
+if {[info exists CFLAGS_FOR_TARGET]} {
+    append default_flags " $CFLAGS_FOR_TARGET"
+}
+if {[board_info $target exists cflags]} {
+    append default_flags " [board_info $target cflags]"
+}
+if {[board_info $target exists multilib_flags]} {
+    append default_flags " [board_info $target multilib_flags]"
+}
+
+# See whether the default command line specifies an ABI.
+set default_abi ""
+foreach flag $default_flags {
+    if {[string match "-mabi=*" $flag]} {
+	set default_abi $flag
+    }
+}
+
+# If the command line does specify an ABI, just check for the
+# appropriate assembler flag.
+if {$default_abi != ""} {
+    check_mips_abi "command line" $default_abi ""
+} else {
+    # An ABI should be passed to the assembler by default.
+    # It doesn't seem worthwhile to duplicate the
+    # configuration to ABI logic here, so just accept any ABI.
+    check_mips_abi "default" $asm_abi_flags ""
+
+    # See whether passing a -mabi flag does the right thing.
+    foreach abi $asm_abi_flags {
+	check_mips_abi $abi $abi $abi
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/mips-abi.s b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/mips-abi.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/mips-abi.s
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/special.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/special.exp
new file mode 100644
index 000000000..bb6ef85bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/special.exp
@@ -0,0 +1,32 @@
+#   Copyright (C) 2001, 2003, 2007 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/>.
+
+# Please email any bugs, comments, and/or additions to this file to:
+# jlarmour@redhat.com
+
+# This file was written by Jonathan Larmour (jlarmour@redhat.com).
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+dg-init
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*\[1-9\].c]] \
+	"" ""
+dg-finish
+
+### EOF special.exp
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-1.c
new file mode 100644
index 000000000..fd45acdc7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-1.c
@@ -0,0 +1,20 @@
+/* { dg-do run { xfail { hppa*-*-hpux* && { ! hppa*64*-*-* } } } } */
+/* { dg-require-weak "" } */
+/* { dg-additional-sources weak-1a.c } */
+/* See PR target/23387 for hppa xfail details.  */
+
+#include <stdlib.h>
+
+int foo(void) __attribute__((weak));
+
+int foo(void) {
+    return 0;
+}
+
+int main(void) {
+
+    if (foo())
+        exit(0);
+    else
+        abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-1a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-1a.c
new file mode 100644
index 000000000..2a7dbba3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-1a.c
@@ -0,0 +1,3 @@
+int foo(void) {
+    return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2.c
new file mode 100644
index 000000000..b93a8ef9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-require-weak "" } */
+/* { dg-additional-sources "weak-2a.c weak-2b.c" } */
+
+#include <stdlib.h>
+
+extern int foo(void);
+
+int main(void) {
+
+    if (foo())
+        exit(0);
+    else
+        abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2a.c
new file mode 100644
index 000000000..52d3e08a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2a.c
@@ -0,0 +1,5 @@
+int foo(void) __attribute__((weak));
+
+int foo(void) {
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2b.c
new file mode 100644
index 000000000..2a7dbba3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/weak-2b.c
@@ -0,0 +1,3 @@
+int foo(void) {
+    return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-1.c
new file mode 100644
index 000000000..9d97b8e12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-1.c
@@ -0,0 +1,19 @@
+/* { dg-do link } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+
+#include <stdlib.h>
+
+extern int foo(void) __attribute__((weak, alias("bar")));
+
+int bar(void) {
+    return 1;
+}
+
+int main(void) {
+
+    if (foo())
+        exit(0);
+    else
+        abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2.c
new file mode 100644
index 000000000..c36024632
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-additional-sources "wkali-2a.c wkali-2b.c" } */
+
+#include <stdlib.h>
+
+extern int foo(void);
+
+int main(void) {
+
+    if (foo())
+        exit(0);
+    else
+        abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2a.c
new file mode 100644
index 000000000..79dde1455
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2a.c
@@ -0,0 +1,7 @@
+/* { dg-do run } */
+
+extern int foo(void) __attribute__((weak, alias("bar_a")));
+
+int bar_a(void) {
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2b.c
new file mode 100644
index 000000000..84f389e84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/special/wkali-2b.c
@@ -0,0 +1,7 @@
+/* { dg-do run } */
+
+extern int foo(void) __attribute__((alias("bar_b")));
+
+int bar_b(void) {
+    return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/spill-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/spill-1.c
new file mode 100644
index 000000000..b85942e87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/spill-1.c
@@ -0,0 +1,15 @@
+/* This caused an ICE during register spilling when targeting thumb.
+   There are 8 registers available for arithmetic operations (r0-r7)
+   r7 is the frame pointer, and r0-r3 are used to pass arguments.
+   Combine was extending the lives of the arguments (in r0-r3) up until the
+   call to z. This leaves only 3 regs free which isn't enough to preform the
+   doubleword addition.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-omit-frame-pointer" } */
+void z(int);
+int foo(int a, int b, int c, int d, long long *q) 
+{ 
+  *q=*q+1; 
+  z (a+b+c+d); 
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ssp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ssp-1.c
new file mode 100644
index 000000000..5467f4dc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ssp-1.c
@@ -0,0 +1,23 @@
+/* { dg-do run { target native } } */
+/* { dg-options "-fstack-protector" } */
+/* { dg-require-effective-target fstack_protector } */
+
+#include <stdlib.h>
+
+void
+__stack_chk_fail (void)
+{
+  exit (0); /* pass */
+}
+
+int main ()
+{
+  int i;
+  char foo[255];
+
+  // smash stack
+  for (i = 0; i <= 400; i++)
+    foo[i] = 42;
+
+  return 1; /* fail */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ssp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ssp-2.c
new file mode 100644
index 000000000..9a7ac3206
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ssp-2.c
@@ -0,0 +1,29 @@
+/* { dg-do run { target native } } */
+/* { dg-options "-fstack-protector" } */
+/* { dg-options "-fstack-protector -Wl,-multiply_defined,suppress" { target *-*-darwin* } } */
+/* { dg-require-effective-target fstack_protector } */
+
+#include <stdlib.h>
+
+void
+__stack_chk_fail (void)
+{
+  exit (0); /* pass */
+}
+
+void
+overflow()
+{
+  int i = 0;
+  char foo[30];
+
+  /* Overflow buffer.  */
+  for (i = 0; i < 50; i++)
+      foo[i] = 42;
+}
+
+int main (void)
+{
+  overflow ();
+  return 1; /* fail */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-1.c
new file mode 100644
index 000000000..fdd62528d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-1.c
@@ -0,0 +1,11 @@
+/* Test diagnostic for GNU extension: statement expressions.  Test
+   with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+int
+f (void)
+{
+  return ({ 1; });
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-2.c
new file mode 100644
index 000000000..524e8ac87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-2.c
@@ -0,0 +1,11 @@
+/* Test diagnostic for GNU extension: statement expressions.  Test
+   with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic" } */
+
+int
+f (void)
+{
+  return ({ 1; }); /* { dg-warning "ISO C forbids braced-groups within expressions" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-3.c
new file mode 100644
index 000000000..6ef7e069e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-3.c
@@ -0,0 +1,11 @@
+/* Test diagnostic for GNU extension: statement expressions.  Test
+   with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors" } */
+
+int
+f (void)
+{
+  return ({ 1; }); /* { dg-error "ISO C forbids braced-groups within expressions" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-1.c
new file mode 100644
index 000000000..57ab34eaa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-1.c
@@ -0,0 +1,404 @@
+/* Test for labels in statement expressions: bugs 772 and 17913.
+   goto statements must not jump into statement expressions.
+
+   This tests all combinations of label and goto locations in a given
+   function.  Each combination is tested twice, once with just that
+   label and goto and once with many others in order to exercise the
+   different code paths involved with excess labels.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void f0 (void) {  goto a; a:({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa0 (void) { p0A:goto p0A; goto a; a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f1 (void) {  goto a; ({ a:({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa1 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f2 (void) {  goto a; ({ ({a:0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa2 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f3 (void) {  goto a; ({ ({0;}); a:({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa3 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f4 (void) {  goto a; ({ ({0;}); ({a:0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa4 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f5 (void) {  goto a; ({ ({0;}); ({0;}); a:0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa5 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f6 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa6 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f7 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa7 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f8 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa8 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f9 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa9 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f10 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa10 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f11 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa11 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f12 (void) {  goto a; ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa12 (void) { p0A:goto p0A; goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f13 (void) { a: goto a; ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa13 (void) { a: goto a; P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f14 (void) { a:({  goto a; ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa14 (void) { a:({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f15 (void) { ({  goto a; a:({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa15 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f16 (void) { ({  goto a; ({a:0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa16 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f17 (void) { ({  goto a; ({0;}); a:({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa17 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f18 (void) { ({  goto a; ({0;}); ({a:0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa18 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f19 (void) { ({  goto a; ({0;}); ({0;}); a:0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa19 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f20 (void) { ({  goto a; ({0;}); ({0;}); 0;}); a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa20 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f21 (void) { ({  goto a; ({0;}); ({0;}); 0;}); ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa21 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f22 (void) { ({  goto a; ({0;}); ({0;}); 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa22 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f23 (void) { ({  goto a; ({0;}); ({0;}); 0;}); ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa23 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f24 (void) { ({  goto a; ({0;}); ({0;}); 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa24 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f25 (void) { ({  goto a; ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa25 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f26 (void) { ({  goto a; ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa26 (void) { P0A:goto P0A;({ p01A:goto p01A; goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f27 (void) { ({ a: goto a; ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa27 (void) { P0A:goto P0A;({ a: goto a; P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f28 (void) { a:({ ({ goto a; 0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa28 (void) { a:({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f29 (void) { ({ a:({ goto a; 0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa29 (void) { P0A:goto P0A;({ a:({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f30 (void) { ({ ({ goto a; a:0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa30 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f31 (void) { ({ ({ goto a; 0;}); a:({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa31 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f32 (void) { ({ ({ goto a; 0;}); ({a:0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa32 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f33 (void) { ({ ({ goto a; 0;}); ({0;}); a:0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa33 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f34 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa34 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f35 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa35 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f36 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa36 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f37 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa37 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f38 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa38 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f39 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa39 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f40 (void) { ({ ({ goto a; 0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa40 (void) { P0A:goto P0A;({ P01A:goto P01A;({p012A:goto p012A; goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f41 (void) { ({ ({a: goto a; 0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa41 (void) { P0A:goto P0A;({ P01A:goto P01A;({a: goto a; P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f42 (void) { a:({ ({0;});  goto a; ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa42 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f43 (void) { ({ a:({0;});  goto a; ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa43 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f44 (void) { ({ ({a:0;});  goto a; ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa44 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f45 (void) { ({ ({0;});  goto a; a:({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa45 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f46 (void) { ({ ({0;});  goto a; ({a:0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa46 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f47 (void) { ({ ({0;});  goto a; ({0;}); a:0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa47 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f48 (void) { ({ ({0;});  goto a; ({0;}); 0;}); a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa48 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f49 (void) { ({ ({0;});  goto a; ({0;}); 0;}); ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa49 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f50 (void) { ({ ({0;});  goto a; ({0;}); 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa50 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f51 (void) { ({ ({0;});  goto a; ({0;}); 0;}); ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa51 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f52 (void) { ({ ({0;});  goto a; ({0;}); 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa52 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f53 (void) { ({ ({0;});  goto a; ({0;}); 0;}); ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa53 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f54 (void) { ({ ({0;});  goto a; ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa54 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); p01B:goto p01B; goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f55 (void) { ({ ({0;}); a: goto a; ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa55 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a: goto a; P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f56 (void) { a:({ ({0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa56 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f57 (void) { ({ a:({0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa57 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f58 (void) { ({ ({a:0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa58 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f59 (void) { ({ ({0;}); a:({ goto a; 0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa59 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f60 (void) { ({ ({0;}); ({ goto a; a:0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa60 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f61 (void) { ({ ({0;}); ({ goto a; 0;}); a:0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa61 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f62 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa62 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f63 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa63 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f64 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa64 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f65 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa65 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f66 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa66 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f67 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa67 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f68 (void) { ({ ({0;}); ({ goto a; 0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa68 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({p013A:goto p013A; goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f69 (void) { ({ ({0;}); ({a: goto a; 0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa69 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a: goto a; P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f70 (void) { a:({ ({0;}); ({0;});  goto a; 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa70 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f71 (void) { ({ a:({0;}); ({0;});  goto a; 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa71 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f72 (void) { ({ ({a:0;}); ({0;});  goto a; 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa72 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f73 (void) { ({ ({0;}); a:({0;});  goto a; 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa73 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f74 (void) { ({ ({0;}); ({a:0;});  goto a; 0;}); ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa74 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f75 (void) { ({ ({0;}); ({0;});  goto a; a:0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa75 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f76 (void) { ({ ({0;}); ({0;});  goto a; 0;}); a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa76 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f77 (void) { ({ ({0;}); ({0;});  goto a; 0;}); ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa77 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f78 (void) { ({ ({0;}); ({0;});  goto a; 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa78 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f79 (void) { ({ ({0;}); ({0;});  goto a; 0;}); ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa79 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f80 (void) { ({ ({0;}); ({0;});  goto a; 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa80 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f81 (void) { ({ ({0;}); ({0;});  goto a; 0;}); ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa81 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f82 (void) { ({ ({0;}); ({0;});  goto a; 0;}); ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa82 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); p01C:goto p01C; goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f83 (void) { ({ ({0;}); ({0;}); a: goto a; 0;}); ({ ({0;}); ({0;}); 0;}); 0; }
+void fa83 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a: goto a; P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f84 (void) { a:({ ({0;}); ({0;}); 0;});  goto a; ({ ({0;}); ({0;}); 0;}); 0; }
+void fa84 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f85 (void) { ({ a:({0;}); ({0;}); 0;});  goto a; ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa85 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f86 (void) { ({ ({a:0;}); ({0;}); 0;});  goto a; ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa86 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f87 (void) { ({ ({0;}); a:({0;}); 0;});  goto a; ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa87 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f88 (void) { ({ ({0;}); ({a:0;}); 0;});  goto a; ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa88 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f89 (void) { ({ ({0;}); ({0;}); a:0;});  goto a; ({ ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa89 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f90 (void) { ({ ({0;}); ({0;}); 0;});  goto a; a:({ ({0;}); ({0;}); 0;}); 0; }
+void fa90 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f91 (void) { ({ ({0;}); ({0;}); 0;});  goto a; ({ a:({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa91 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f92 (void) { ({ ({0;}); ({0;}); 0;});  goto a; ({ ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa92 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f93 (void) { ({ ({0;}); ({0;}); 0;});  goto a; ({ ({0;}); a:({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa93 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f94 (void) { ({ ({0;}); ({0;}); 0;});  goto a; ({ ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa94 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f95 (void) { ({ ({0;}); ({0;}); 0;});  goto a; ({ ({0;}); ({0;}); a:0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa95 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f96 (void) { ({ ({0;}); ({0;}); 0;});  goto a; ({ ({0;}); ({0;}); 0;}); a:0; }
+void fa96 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); p0B:goto p0B; goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f97 (void) { ({ ({0;}); ({0;}); 0;}); a: goto a; ({ ({0;}); ({0;}); 0;}); 0; }
+void fa97 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a: goto a; P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f98 (void) { a:({ ({0;}); ({0;}); 0;}); ({  goto a; ({0;}); ({0;}); 0;}); 0; }
+void fa98 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f99 (void) { ({ a:({0;}); ({0;}); 0;}); ({  goto a; ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa99 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f100 (void) { ({ ({a:0;}); ({0;}); 0;}); ({  goto a; ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa100 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f101 (void) { ({ ({0;}); a:({0;}); 0;}); ({  goto a; ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa101 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f102 (void) { ({ ({0;}); ({a:0;}); 0;}); ({  goto a; ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa102 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f103 (void) { ({ ({0;}); ({0;}); a:0;}); ({  goto a; ({0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa103 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f104 (void) { ({ ({0;}); ({0;}); 0;}); a:({  goto a; ({0;}); ({0;}); 0;}); 0; }
+void fa104 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f105 (void) { ({ ({0;}); ({0;}); 0;}); ({  goto a; a:({0;}); ({0;}); 0;}); 0; }
+void fa105 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f106 (void) { ({ ({0;}); ({0;}); 0;}); ({  goto a; ({a:0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa106 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f107 (void) { ({ ({0;}); ({0;}); 0;}); ({  goto a; ({0;}); a:({0;}); 0;}); 0; }
+void fa107 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f108 (void) { ({ ({0;}); ({0;}); 0;}); ({  goto a; ({0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa108 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f109 (void) { ({ ({0;}); ({0;}); 0;}); ({  goto a; ({0;}); ({0;}); a:0;}); 0; }
+void fa109 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f110 (void) { ({ ({0;}); ({0;}); 0;}); ({  goto a; ({0;}); ({0;}); 0;}); a:0; }
+void fa110 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ p02A:goto p02A; goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f111 (void) { ({ ({0;}); ({0;}); 0;}); ({ a: goto a; ({0;}); ({0;}); 0;}); 0; }
+void fa111 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a: goto a; P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f112 (void) { a:({ ({0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); 0; }
+void fa112 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f113 (void) { ({ a:({0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa113 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f114 (void) { ({ ({a:0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa114 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f115 (void) { ({ ({0;}); a:({0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa115 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f116 (void) { ({ ({0;}); ({a:0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa116 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f117 (void) { ({ ({0;}); ({0;}); a:0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa117 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f118 (void) { ({ ({0;}); ({0;}); 0;}); a:({ ({ goto a; 0;}); ({0;}); 0;}); 0; }
+void fa118 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f119 (void) { ({ ({0;}); ({0;}); 0;}); ({ a:({ goto a; 0;}); ({0;}); 0;}); 0; }
+void fa119 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f120 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({ goto a; a:0;}); ({0;}); 0;}); 0; }
+void fa120 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f121 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); a:({0;}); 0;}); 0; }
+void fa121 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f122 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa122 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f123 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); a:0;}); 0; }
+void fa123 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f124 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({ goto a; 0;}); ({0;}); 0;}); a:0; }
+void fa124 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({p024A:goto p024A; goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f125 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({a: goto a; 0;}); ({0;}); 0;}); 0; }
+void fa125 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a: goto a; P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f126 (void) { a:({ ({0;}); ({0;}); 0;}); ({ ({0;});  goto a; ({0;}); 0;}); 0; }
+void fa126 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f127 (void) { ({ a:({0;}); ({0;}); 0;}); ({ ({0;});  goto a; ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa127 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f128 (void) { ({ ({a:0;}); ({0;}); 0;}); ({ ({0;});  goto a; ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa128 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f129 (void) { ({ ({0;}); a:({0;}); 0;}); ({ ({0;});  goto a; ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa129 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f130 (void) { ({ ({0;}); ({a:0;}); 0;}); ({ ({0;});  goto a; ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa130 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f131 (void) { ({ ({0;}); ({0;}); a:0;}); ({ ({0;});  goto a; ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa131 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f132 (void) { ({ ({0;}); ({0;}); 0;}); a:({ ({0;});  goto a; ({0;}); 0;}); 0; }
+void fa132 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f133 (void) { ({ ({0;}); ({0;}); 0;}); ({ a:({0;});  goto a; ({0;}); 0;}); 0; }
+void fa133 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f134 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({a:0;});  goto a; ({0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa134 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f135 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;});  goto a; a:({0;}); 0;}); 0; }
+void fa135 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f136 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;});  goto a; ({a:0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa136 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f137 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;});  goto a; ({0;}); a:0;}); 0; }
+void fa137 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f138 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;});  goto a; ({0;}); 0;}); a:0; }
+void fa138 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); p02B:goto p02B; goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f139 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); a: goto a; ({0;}); 0;}); 0; }
+void fa139 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a: goto a; P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f140 (void) { a:({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); 0; }
+void fa140 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f141 (void) { ({ a:({0;}); ({0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa141 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f142 (void) { ({ ({a:0;}); ({0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa142 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f143 (void) { ({ ({0;}); a:({0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa143 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f144 (void) { ({ ({0;}); ({a:0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa144 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f145 (void) { ({ ({0;}); ({0;}); a:0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa145 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f146 (void) { ({ ({0;}); ({0;}); 0;}); a:({ ({0;}); ({ goto a; 0;}); 0;}); 0; }
+void fa146 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f147 (void) { ({ ({0;}); ({0;}); 0;}); ({ a:({0;}); ({ goto a; 0;}); 0;}); 0; }
+void fa147 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f148 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({a:0;}); ({ goto a; 0;}); 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa148 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f149 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); a:({ goto a; 0;}); 0;}); 0; }
+void fa149 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f150 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({ goto a; a:0;}); 0;}); 0; }
+void fa150 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f151 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); a:0;}); 0; }
+void fa151 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f152 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({ goto a; 0;}); 0;}); a:0; }
+void fa152 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({p025A:goto p025A; goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f153 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({a: goto a; 0;}); 0;}); 0; }
+void fa153 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a: goto a; P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f154 (void) { a:({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;});  goto a; 0;}); 0; }
+void fa154 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f155 (void) { ({ a:({0;}); ({0;}); 0;}); ({ ({0;}); ({0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa155 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f156 (void) { ({ ({a:0;}); ({0;}); 0;}); ({ ({0;}); ({0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa156 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f157 (void) { ({ ({0;}); a:({0;}); 0;}); ({ ({0;}); ({0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa157 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f158 (void) { ({ ({0;}); ({a:0;}); 0;}); ({ ({0;}); ({0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa158 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f159 (void) { ({ ({0;}); ({0;}); a:0;}); ({ ({0;}); ({0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa159 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f160 (void) { ({ ({0;}); ({0;}); 0;}); a:({ ({0;}); ({0;});  goto a; 0;}); 0; }
+void fa160 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f161 (void) { ({ ({0;}); ({0;}); 0;}); ({ a:({0;}); ({0;});  goto a; 0;}); 0; }
+void fa161 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f162 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({a:0;}); ({0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa162 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f163 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); a:({0;});  goto a; 0;}); 0; }
+void fa163 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f164 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({a:0;});  goto a; 0;}); 0; } /* { dg-error "jump into statement expression" } */
+void fa164 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f165 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;});  goto a; a:0;}); 0; }
+void fa165 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; a:0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f166 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;});  goto a; 0;}); a:0; }
+void fa166 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); p02C:goto p02C; goto a; P02C:goto P02C;0;}); a:0;P0D:goto P0D; }
+void f167 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); a: goto a; 0;}); 0; }
+void fa167 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a: goto a; P02C:goto P02C;0;}); P0C:goto P0C;0;P0D:goto P0D; }
+void f168 (void) { a:({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;});  goto a; 0; }
+void fa168 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; }
+void f169 (void) { ({ a:({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa169 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f170 (void) { ({ ({a:0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa170 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f171 (void) { ({ ({0;}); a:({0;}); 0;}); ({ ({0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa171 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f172 (void) { ({ ({0;}); ({a:0;}); 0;}); ({ ({0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa172 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f173 (void) { ({ ({0;}); ({0;}); a:0;}); ({ ({0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa173 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f174 (void) { ({ ({0;}); ({0;}); 0;}); a:({ ({0;}); ({0;}); 0;});  goto a; 0; }
+void fa174 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; }
+void f175 (void) { ({ ({0;}); ({0;}); 0;}); ({ a:({0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa175 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f176 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({a:0;}); ({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa176 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f177 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); a:({0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa177 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f178 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({a:0;}); 0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa178 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f179 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); a:0;});  goto a; 0; } /* { dg-error "jump into statement expression" } */
+void fa179 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); p0C:goto p0C; goto a; P0C:goto P0C;0;P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f180 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;});  goto a; a:0; }
+void fa180 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); p0C:goto p0C; goto a; a:0;P0D:goto P0D; }
+void f181 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a: goto a; 0; }
+void fa181 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a: goto a; P0C:goto P0C;0;P0D:goto P0D; }
+void f182 (void) { a:({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; goto a;  }
+void fa182 (void) { a:({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; }
+void f183 (void) { ({ a:({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa183 (void) { P0A:goto P0A;({ a:({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f184 (void) { ({ ({a:0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa184 (void) { P0A:goto P0A;({ P01A:goto P01A;({a:0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f185 (void) { ({ ({0;}); a:({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa185 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); a:({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f186 (void) { ({ ({0;}); ({a:0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa186 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({a:0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f187 (void) { ({ ({0;}); ({0;}); a:0;}); ({ ({0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa187 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); a:0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f188 (void) { ({ ({0;}); ({0;}); 0;}); a:({ ({0;}); ({0;}); 0;}); 0; goto a;  }
+void fa188 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); a:({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; }
+void f189 (void) { ({ ({0;}); ({0;}); 0;}); ({ a:({0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa189 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ a:({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f190 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({a:0;}); ({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa190 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({a:0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f191 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); a:({0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa191 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); a:({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f192 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({a:0;}); 0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa192 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({a:0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f193 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); a:0;}); 0; goto a;  } /* { dg-error "jump into statement expression" } */
+void fa193 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); a:0;}); P0C:goto P0C;0;p0D:goto p0D; goto a; P0D:goto P0D; } /* { dg-error "jump into statement expression" } */
+void f194 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); a:0; goto a;  }
+void fa194 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); a:0;p0D:goto p0D; goto a; P0D:goto P0D; }
+void f195 (void) { ({ ({0;}); ({0;}); 0;}); ({ ({0;}); ({0;}); 0;}); 0;a: goto a;  }
+void fa195 (void) { P0A:goto P0A;({ P01A:goto P01A;({P012A:goto P012A;0;}); P01B:goto P01B;({P013A:goto P013A;0;}); P01C:goto P01C;0;}); P0B:goto P0B;({ P02A:goto P02A;({P024A:goto P024A;0;}); P02B:goto P02B;({P025A:goto P025A;0;}); P02C:goto P02C;0;}); P0C:goto P0C;0;a: goto a; P0D:goto P0D; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-2.c
new file mode 100644
index 000000000..35b96e830
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-2.c
@@ -0,0 +1,27 @@
+/* Test for labels in statement expressions: bugs 772 and 17913.
+   switch statements must not jump into statement expressions.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (int a)
+{
+  switch (a)
+    {
+    case 0:
+    case 1:
+      ({
+      case 2: /* { dg-error "case label in statement expression not containing enclosing switch statement" } */
+      default: /* { dg-error "'default' label in statement expression not containing enclosing switch statement" } */
+	switch (a)
+	  {
+	  case 3:
+	  default:
+	    ;
+	  }
+	0;
+      });
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-3.c
new file mode 100644
index 000000000..7b1515f89
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/stmt-expr-label-3.c
@@ -0,0 +1,8 @@
+/* Test for labels in statement expressions: bugs 772 and 17913.
+   Test the particular case of bug 17913.  */
+
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void f(void) { 1 ? 1 : ({ a : 1; 1; }); goto a; } /* { dg-error "jump into statement expression" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-1.c
new file mode 100644
index 000000000..1ff96f458
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-1.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return i - 5 < 10;
+}
+
+/* { dg-final { scan-tree-dump-not "-[ ]*5" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-2.c
new file mode 100644
index 000000000..c1ec195e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-2.c.  */
+
+/* We can only simplify the division when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return (i * 100) / 10;
+}
+
+/* { dg-final { scan-tree-dump-not "100" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-3.c
new file mode 100644
index 000000000..f179324a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-3.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i, int j)
+{
+  return i + 100 < j + 1000;
+}
+
+/* { dg-final { scan-tree-dump-not "1000" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-4.c
new file mode 100644
index 000000000..c89db2193
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-4.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-4.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (int i)
+{
+  return i + 1 > i;
+}
+
+/* We expect to see "<bb N>"; confirm that, so that we know to count
+   it in the real test.  */
+/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times ">|<" 2 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-5.c
new file mode 100644
index 000000000..816bfe440
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-5.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-optimized" } */
+
+/* We can only unroll when using strict overflow semantics.  */
+
+int foo (int i)
+{
+  int index;
+  int r=0;
+ 
+  for (index = i; index <= i+4; index+=2) 
+    r++;
+ 
+  return r;
+}
+
+/* { dg-final { scan-tree-dump "return 3" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-6.c
new file mode 100644
index 000000000..ec1266d1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/strict-overflow-6.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -O2 -fdump-tree-final_cleanup" } */
+
+/* Source: Ian Lance Taylor.  Dual of no-strict-overflow-7.c.  */
+
+/* We can only simplify the conditional when using strict overflow
+   semantics.  */
+
+int
+foo (char* p)
+{
+  return p + 1000 < p;
+}
+
+/* { dg-final { scan-tree-dump-not "\[+\]\[ \]*1000" "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/string-opt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/string-opt-1.c
new file mode 100644
index 000000000..bc0f30098
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/string-opt-1.c
@@ -0,0 +1,11 @@
+/* Ensure mempcpy is not "optimized" into memcpy followed by addition.  */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void *
+fn (char *x, char *y, int z)
+{
+  return __builtin_mempcpy (x, y, z);
+}
+
+/* { dg-final { scan-assembler-not "memcpy" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-alias-1.c
new file mode 100644
index 000000000..6cfadcf2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-alias-1.c
@@ -0,0 +1,22 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+struct S {
+   int a[3];
+   int x;
+};
+
+extern void link_error(void);
+static int i;
+
+int main()
+{
+  struct S s;
+
+  s.x = 0;
+  s.a[i] = 1;
+  if (s.x != 0)
+    link_error ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-by-value-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-by-value-1.c
new file mode 100644
index 000000000..addf253d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-by-value-1.c
@@ -0,0 +1,83 @@
+/* Test structure passing by value.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+#define T(N)					\
+struct S##N { unsigned char i[N]; };		\
+struct S##N g1s##N, g2s##N, g3s##N;		\
+						\
+void						\
+init##N (struct S##N *p, int i)			\
+{						\
+  int j;					\
+  for (j = 0; j < N; j++)			\
+    p->i[j] = i + j;				\
+}						\
+						\
+void						\
+check##N (struct S##N *p, int i)		\
+{						\
+  int j;					\
+  for (j = 0; j < N; j++)			\
+    if (p->i[j] != i + j) abort ();		\
+}						\
+						\
+void						\
+test##N (struct S##N s1, struct S##N s2,	\
+	 struct S##N s3)			\
+{						\
+  check##N (&s1, 64);				\
+  check##N (&s2, 128);				\
+  check##N (&s3, 192);				\
+}						\
+						\
+void						\
+test2_##N (struct S##N s1, struct S##N s2)	\
+{						\
+  test##N (s1, g2s##N, s2);			\
+}						\
+						\
+void						\
+testit##N (void)				\
+{						\
+  init##N (&g1s##N, 64);			\
+  check##N (&g1s##N, 64);			\
+  init##N (&g2s##N, 128);			\
+  check##N (&g2s##N, 128);			\
+  init##N (&g3s##N, 192);			\
+  check##N (&g3s##N, 192);			\
+  test##N (g1s##N, g2s##N, g3s##N);		\
+  test2_##N (g1s##N, g3s##N);			\
+}
+
+extern void abort (void);
+extern void exit (int);
+
+T(0) T(1) T(2) T(3) T(4) T(5) T(6) T(7)
+T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15)
+T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23)
+T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31)
+T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39)
+T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47)
+T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55)
+T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63)
+
+#undef T
+
+int
+main ()
+{
+#define T(N) testit##N ();
+
+T(0) T(1) T(2) T(3) T(4) T(5) T(6) T(7)
+T(8) T(9) T(10) T(11) T(12) T(13) T(14) T(15)
+T(16) T(17) T(18) T(19) T(20) T(21) T(22) T(23)
+T(24) T(25) T(26) T(27) T(28) T(29) T(30) T(31)
+T(32) T(33) T(34) T(35) T(36) T(37) T(38) T(39)
+T(40) T(41) T(42) T(43) T(44) T(45) T(46) T(47)
+T(48) T(49) T(50) T(51) T(52) T(53) T(54) T(55)
+T(56) T(57) T(58) T(59) T(60) T(61) T(62) T(63)
+
+#undef T
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-by-value-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-by-value-2.c
new file mode 100644
index 000000000..8d5d0bb01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-by-value-2.c
@@ -0,0 +1,15 @@
+/* This testcase caused a sanity check to abort on SPARC64
+   because of a discrepancy between two functions involved
+   in the calculation of structure layout.  */
+
+/* { dg-do compile } */
+
+struct S { float f1; int i1; int i2; float f2; };
+
+extern void foo(struct S);
+
+void bar(void)
+{
+  struct S s;
+  foo(s);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-1.c
new file mode 100644
index 000000000..779746567
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-1.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for empty structures and unions.  Test with no
+   special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s0 {};
+union u0 {};
+struct s1 { int : 1; };
+union u1 { int : 1; };
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-2.c
new file mode 100644
index 000000000..1f06a1b17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-2.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for empty structures and unions.  Test with
+   -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+struct s0 {}; /* { dg-warning "struct has no members" } */
+union u0 {}; /* { dg-warning "union has no members" } */
+struct s1 { int : 1; }; /* { dg-warning "struct has no named members" } */
+union u1 { int : 1; }; /* { dg-warning "union has no named members" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-3.c
new file mode 100644
index 000000000..6e5baa9cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-empty-3.c
@@ -0,0 +1,10 @@
+/* Test diagnostics for empty structures and unions.  Test with
+   -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+struct s0 {}; /* { dg-error "struct has no members" } */
+union u0 {}; /* { dg-error "union has no members" } */
+struct s1 { int : 1; }; /* { dg-error "struct has no named members" } */
+union u1 { int : 1; }; /* { dg-error "union has no named members" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-in-proto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-in-proto-1.c
new file mode 100644
index 000000000..162ba914a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-in-proto-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+int foo(struct S { int i; } s) {
+  return sizeof(struct S); /* { dg-bogus "incomplete type" "S visible here" } */
+}
+int bar(void) {
+  return sizeof(struct S); /* { dg-error "incomplete type" "not here" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-incompl-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-incompl-1.c
new file mode 100644
index 000000000..c32b2d538
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-incompl-1.c
@@ -0,0 +1,7 @@
+/* PR c/26818 */
+/* { dg-do compile } */
+
+struct __attribute__ ((packed)) A
+{
+  struct B b; /* { dg-error "incomplete" } */
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-parse-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-parse-1.c
new file mode 100644
index 000000000..9ceac8afa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-parse-1.c
@@ -0,0 +1,11 @@
+/* Copyright (C) 2006 Free Software Foundation, Inc. */
+/* Contributed by Carlos O'Donell on 2006-03-31 */
+
+/* This code caused the C frontend to loop 
+   forever exhausting all system memory, or ICE */
+/* Origin: Carlos O'Donell <carlos@codesourcery.com> */
+
+/* { dg-options "-std=c99" } */
+struct s { int a; int b; struct t c; }; /* { dg-error "field 'c' has incomplete type" } */
+struct s d = { .b = 0 };
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-parse-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-parse-2.c
new file mode 100644
index 000000000..559411a19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-parse-2.c
@@ -0,0 +1,13 @@
+/* PR c/35437 */
+/* { dg-do "compile" } */
+
+struct A
+{
+  int i;
+  struct A a; /* { dg-error "has incomplete type" } */
+};
+
+void foo()
+{
+  struct A b = { 0 };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-1.c
new file mode 100644
index 000000000..23c9e9813
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-1.c
@@ -0,0 +1,47 @@
+/* { dg-do run { target hppa*-*-* } } */
+/* { dg-options { -O2 } { target hppa*-*-* } } */
+extern void abort (void);
+extern void exit (int);
+typedef struct {
+        int             x;
+        int             y;
+}               point_t;
+
+int main(int argc, char *argv[]);
+int printPoints(point_t a, point_t b);
+point_t toPoint(int x1, int y1);
+
+int
+main(int argc, char *argv[])
+{
+
+        if (printPoints(toPoint(0, 0), toPoint(1000, 1000)) != 1)
+                abort();
+        else
+                exit(0);
+
+        return 0;
+}
+
+int
+printPoints(point_t a, point_t b)
+{
+        if (a.x != 0
+            || a.y != 0
+            || b.x != 1000
+            || b.y != 1000)
+                return 0;
+        else
+                return 1;
+}
+
+point_t
+toPoint(int x1, int y1)
+{
+        point_t         p;
+
+        p.x = x1;
+        p.y = y1;
+
+        return p;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-2.c
new file mode 100644
index 000000000..0d9b86f6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-2.c
@@ -0,0 +1,15 @@
+/* Simplified by Alexandre Oliva <oliva@lsd.ic.unicamp.br>
+   from bug report by Helmut Jarausch <jarausch@igpm.rwth-aachen.de>
+
+   Copyright (C) 1999 Free Software Foundation  */
+
+/* { dg-do compile } */
+/* { dg-options "-O3 -w" } */
+
+struct {
+  unsigned i[4];
+} foo() {}
+ 
+void bar() {
+  foo();           
+}  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-3.c
new file mode 100644
index 000000000..0be43b6d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-3.c
@@ -0,0 +1,112 @@
+/* PR middle-end/31309 */
+/* Origin: Peeter Joot <peeterj@ca.ibm.com> */
+
+/* { dg-do run { target *-*-linux* } } */
+
+#include <sys/mman.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+
+#if defined(STACK_SIZE) && (STACK_SIZE < 128*1024)
+ #define CHUNK_SIZE 4096
+#else
+ #define CHUNK_SIZE 16384
+#endif
+
+unsigned long ossAlignX(unsigned long i, unsigned long X)
+{
+   return ((i + (X - 1)) & ~(unsigned long) (X - 1));
+}
+
+struct STRUCT_6_BYTES
+{
+   unsigned char slot[sizeof(unsigned short)];
+   unsigned char page[sizeof(unsigned int)];
+};
+
+struct SQLU_DICT_INFO_0
+{
+   void *pBlah;
+   char bSomeFlag1;
+   char bSomeFlag2;
+   struct STRUCT_6_BYTES dRID;
+};
+
+struct SQLU_DATAPART_0
+{
+   struct SQLU_DICT_INFO_0 *pDictRidderInfo;
+};
+
+struct XXX
+{
+   struct SQLU_DATAPART_0 *m_pDatapart;
+};
+
+struct STRUCT_6_BYTES INIT_6_BYTES_ZERO()
+{
+   struct STRUCT_6_BYTES ridOut = {{0,0}, {0,0,0,0}};
+   return ridOut;
+}
+
+void Initialize(struct XXX *this, int iIndex)
+{
+   struct SQLU_DICT_INFO_0 *pDictRidderInfo
+     = this->m_pDatapart[iIndex].pDictRidderInfo;
+   pDictRidderInfo->bSomeFlag1 = 0;
+   pDictRidderInfo->bSomeFlag2 = 0;
+   pDictRidderInfo->dRID = INIT_6_BYTES_ZERO();
+}
+
+int main(void)
+{
+   int rc;
+
+   struct stuff
+   {
+      char c0[CHUNK_SIZE-sizeof(struct XXX)];
+      struct XXX o;
+      char c1[CHUNK_SIZE*2-sizeof(struct SQLU_DATAPART_0)];
+      struct SQLU_DATAPART_0 dp;
+      char c2[CHUNK_SIZE*2-sizeof(struct SQLU_DICT_INFO_0)];
+      struct SQLU_DICT_INFO_0 di;
+      char c3[CHUNK_SIZE];
+   };
+
+   char buf[sizeof(struct stuff)+CHUNK_SIZE];
+   struct stuff *u
+     = (struct stuff *)ossAlignX((unsigned long)&buf[0], CHUNK_SIZE);
+
+   /* This test assumes system memory page
+      size of CHUNK_SIZE bytes or less.  */
+   if (sysconf(_SC_PAGESIZE) > CHUNK_SIZE)
+     return 0;
+
+   memset(u, 1, sizeof(struct stuff));
+   u->c1[0] = '\xAA';
+   u->c2[0] = '\xBB';
+   u->c3[0] = '\xCC';
+
+   rc = mprotect(u->c1, CHUNK_SIZE, PROT_NONE);
+   if (rc == -1)
+      printf("mprotect:c1: %d: %d(%s)\n", rc, errno, strerror(errno));
+
+   rc = mprotect(u->c2, CHUNK_SIZE, PROT_NONE);
+   if (rc == -1)
+      printf("mprotect:c2: %d: %d(%s)\n", rc, errno, strerror(errno));
+
+   rc = mprotect(u->c3, CHUNK_SIZE, PROT_NONE);
+   if (rc == -1)
+      printf("mprotect:c3: %d: %d(%s)\n", rc, errno, strerror(errno));
+
+   u->o.m_pDatapart = &u->dp;
+   u->dp.pDictRidderInfo = &u->di;
+   Initialize(&u->o, 0);
+
+   mprotect(u->c1, CHUNK_SIZE, PROT_READ|PROT_WRITE);
+   mprotect(u->c2, CHUNK_SIZE, PROT_READ|PROT_WRITE);
+   mprotect(u->c3, CHUNK_SIZE, PROT_READ|PROT_WRITE);
+
+   return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-libc.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-libc.c
new file mode 100644
index 000000000..723e1cd02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-ret-libc.c
@@ -0,0 +1,16 @@
+/* Test evolved from source from Simona Perri <perri@mat.unical.it>
+   and Gerald Pfeifer<pfeifer@dbai.tuwien.ac.at>.
+
+   Copyright (C) 2003 Free Software Foundation  */
+
+/* { dg-do run } */
+
+#include <stdlib.h>
+
+int main ()
+{
+  div_t d = div (20, 5);
+  if ((d.quot != 4) || (d.rem))
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-1.c
new file mode 100644
index 000000000..8ac90eaee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-1.c
@@ -0,0 +1,19 @@
+/* Test diagnostics for missing and extra semicolons in structures.
+   Test with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+struct s0 { ; };
+struct s1 {
+  int a;
+  ;
+  int b;
+};
+struct s2 {
+  ;
+  int c
+}; /* { dg-warning "no semicolon at end of struct or union" } */
+struct s3 {
+  int d
+}; /* { dg-warning "no semicolon at end of struct or union" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-2.c
new file mode 100644
index 000000000..3708e534f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-2.c
@@ -0,0 +1,20 @@
+/* Test diagnostics for missing and extra semicolons in structures.
+   Test with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+struct s0 { ; }; /* { dg-warning "extra semicolon in struct or union specified" } */
+/* { dg-warning "struct has no members" "empty" { target *-*-* } 7 } */
+struct s1 {
+  int a;
+  ; /* { dg-warning "extra semicolon in struct or union specified" } */
+  int b;
+};
+struct s2 {
+  ; /* { dg-warning "extra semicolon in struct or union specified" } */
+  int c
+}; /* { dg-warning "no semicolon at end of struct or union" } */
+struct s3 {
+  int d
+}; /* { dg-warning "no semicolon at end of struct or union" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-3.c
new file mode 100644
index 000000000..da0f237a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct-semi-3.c
@@ -0,0 +1,20 @@
+/* Test diagnostics for missing and extra semicolons in structures.
+   Test with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+struct s0 { ; }; /* { dg-error "extra semicolon in struct or union specified" } */
+/* { dg-error "struct has no members" "empty" { target *-*-* } 7 } */
+struct s1 {
+  int a;
+  ; /* { dg-error "extra semicolon in struct or union specified" } */
+  int b;
+};
+struct s2 {
+  ; /* { dg-error "extra semicolon in struct or union specified" } */
+  int c
+}; /* { dg-error "no semicolon at end of struct or union" } */
+struct s3 {
+  int d
+}; /* { dg-error "no semicolon at end of struct or union" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/struct-reorg.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/struct-reorg.exp
new file mode 100644
index 000000000..9a1797f3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/struct-reorg.exp
@@ -0,0 +1,74 @@
+#   Copyright (C) 2007, 2008, 2009 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 this program; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# Test the functionality of programs compiled with profile-directed structure
+# rearrangement using -fprofile-generate followed by -fprofile-use.
+
+load_lib gcc-dg.exp
+load_lib target-supports.exp
+
+set STRUCT_REORG_CFLAGS "-O3 -fipa-struct-reorg -fdump-ipa-all -fwhole-program -combine -fipa-type-escape"
+
+# Initialize `dg'.
+dg-init
+
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/wo_prof_*.c]] "" $STRUCT_REORG_CFLAGS
+
+dg-final
+
+# Some targets don't support tree profiling.
+if { ![check_profiling_available ""] } {
+    return
+}
+
+# The procedures in profopt.exp need these parameters.
+set tool gcc
+set prof_ext "gcda"
+
+# Override the list defined in profopt.exp.
+set PROFOPT_OPTIONS [list {}]
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+# Load support procs.
+load_lib profopt.exp
+
+# These are globals used by profopt-execute.  The first is options
+# needed to generate profile data, the second is options to use the
+# profile data.
+set common "-O3 -fwhole-program -combine -fipa-type-escape"
+set profile_option [concat $common " -fprofile-generate"]
+set feedback_option [concat $common " -fprofile-use -fipa-struct-reorg -fdump-ipa-all"]
+
+foreach src [lsort [glob -nocomplain $srcdir/$subdir/w_prof_*.c]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $src] then {
+        continue
+    }
+    profopt-execute $src
+}
+
+set feedback_option [concat $feedback_option " --param struct-reorg-cold-struct-ratio=30"]
+
+foreach src [lsort [glob -nocomplain $srcdir/$subdir/w_ratio_*.c]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $src] then {
+        continue
+    }
+    profopt-execute $src
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_global_array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_global_array.c
new file mode 100644
index 000000000..cbfd0bc72
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_global_array.c
@@ -0,0 +1,30 @@
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#define N 1000
+str_t A[N];
+
+int
+main ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      A[i].a = 0;
+    }
+
+  for (i = 0; i < N; i++)
+    if (A[i].a != 0) 
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_global_var.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_global_var.c
new file mode 100644
index 000000000..c51648c4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_global_var.c
@@ -0,0 +1,43 @@
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+str_t *p;
+
+int
+main ()
+{
+  int i, sum;
+
+  p = malloc (N * sizeof (str_t));
+  if (p == NULL)
+    return 0;
+  for (i = 0; i < N; i++)
+    p[i].b = i;
+
+  for (i = 0; i < N; i++)
+    p[i].a = p[i].b + 1;
+
+  for (i = 0; i < N; i++)
+    if (p[i].a != p[i].b + 1)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_local_array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_local_array.c
new file mode 100644
index 000000000..1a798e399
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_local_array.c
@@ -0,0 +1,38 @@
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+main ()
+{
+  int i;
+  str_t A[N];
+
+  for (i = 0; i < N; i++)
+    {
+      A[i].a = 0;
+    }
+
+  for (i = 0; i < N; i++)
+    if (A[i].a != 0) 
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_local_var.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_local_var.c
new file mode 100644
index 000000000..82f24a1a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_local_var.c
@@ -0,0 +1,41 @@
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+main ()
+{
+  int i, sum;
+
+  str_t * p = malloc (N * sizeof (str_t));
+  if (p == NULL)
+    return 0;
+  for (i = 0; i < N; i++)
+    p[i].b = i;
+
+  for (i = 0; i < N; i++)
+    p[i].a = p[i].b + 1;
+
+  for (i = 0; i < N; i++)
+    if (p[i].a != p[i].b + 1)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_single_str_global.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_single_str_global.c
new file mode 100644
index 000000000..b2223c88b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_single_str_global.c
@@ -0,0 +1,33 @@
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  int b;
+}str_t;
+
+#define N 3
+
+str_t str;
+
+int
+main ()
+{
+  int i;
+  int res = 1<<(1<<N);
+  str.a = 2;
+
+  for (i = 0; i < N; i++)
+      str.a = str.a * str.a;
+  
+  if (str.a != res)
+    abort ();
+
+  /* POSIX ignores all but the 8 low-order bits, but other
+     environments may not.  */
+  return (str.a & 255);
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_two_strs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_two_strs.c
new file mode 100644
index 000000000..308c30e4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_prof_two_strs.c
@@ -0,0 +1,66 @@
+#include <stdlib.h>
+
+typedef struct
+{
+  int a;
+  float b;
+}str_t1;
+
+typedef struct
+{
+  int c;
+  float d;
+}str_t2;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 16000
+#define N 1000
+#else
+#define N (STACK_SIZE/16)
+#endif
+#else
+#define N 1000
+#endif
+
+str_t1 *p1;
+str_t2 *p2;
+int num;
+
+void
+foo (void)
+{
+  int i;
+
+  for (i=0; i < num; i++)
+    p2[i].c = 2;
+}
+
+int
+main ()
+{
+  int i, r;
+
+  r = rand ();
+  num = r > N ? N : r; 
+  p1 = malloc (num * sizeof (str_t1));
+  p2 = malloc (num * sizeof (str_t2));
+
+  if (p1 == NULL || p2 == NULL)
+    return 0;
+
+  for (i = 0; i < num; i++)
+    p1[i].a = 1;
+
+  foo ();
+
+  for (i = 0; i < num; i++)
+    if (p1[i].a != 1 || p2[i].c != 2)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 2" "ipa_struct_reorg" } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_ratio_cold_str.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_ratio_cold_str.c
new file mode 100644
index 000000000..19de595e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/w_ratio_cold_str.c
@@ -0,0 +1,43 @@
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  int b;
+}str_t1;
+
+typedef struct
+{
+  float a;
+  float b;
+}str_t2;
+
+#define N1 1000
+#define N2 100
+str_t1 A1[N1];
+str_t2 A2[N2];
+
+int
+main ()
+{
+  int i;
+
+  for (i = 0; i < N1; i++)
+    A1[i].a = 0;
+
+  for (i = 0; i < N2; i++)
+    A2[i].a = 0;
+
+  for (i = 0; i < N1; i++)
+    if (A1[i].a != 0) 
+      abort ();
+
+  for (i = 0; i < N2; i++)
+    if (A2[i].a != 0) 
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final-use { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" } } */
+/* { dg-final-use { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_array_field.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_array_field.c
new file mode 100644
index 000000000..12c217aad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_array_field.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct basic
+{
+  int a;
+  int b[10];
+} type_struct;
+
+type_struct *str1;
+
+int main()
+{
+  int i;
+
+  str1 = malloc (10 * sizeof (type_struct));
+
+  for (i=0; i<=9; i++)
+    str1[i].a = str1[i].b[0];
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_array_through_pointer.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_array_through_pointer.c
new file mode 100644
index 000000000..303afb72b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_array_through_pointer.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+main ()
+{
+  int i;
+  str_t A[N];
+  str_t *p = A;
+
+  for (i = 0; i < N; i++)
+    p[i].a = 0;
+
+  for (i = 0; i < N; i++)
+    if (p[i].a != 0)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Currently str_t escapes due to incorrect ipa-type-escape analysis.  */
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail *-*-* } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_double_malloc.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_double_malloc.c
new file mode 100644
index 000000000..b1508eec5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_double_malloc.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+
+typedef struct test_struct
+{
+  int a;
+  int b;
+} type_struct;
+
+typedef type_struct **struct_pointer2;
+
+struct_pointer2 str1;
+
+int main()
+{
+  int i, j;
+
+  str1 = malloc (2 * sizeof (type_struct *));
+
+  for (i = 0; i <= 1; i++)
+    str1[i] = malloc (2 * sizeof (type_struct));
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_arg_to_local.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_arg_to_local.c
new file mode 100644
index 000000000..43ca58b9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_arg_to_local.c
@@ -0,0 +1,46 @@
+/* { dg-options "-O3 -fno-inline -fipa-type-escape -fdump-ipa-all -fipa-struct-reorg -fwhole-program -combine" } */
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+struct str
+{
+  int a;
+  float b;
+};
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+foo (struct str * p_str)
+{
+  static int sum = 0;
+
+  sum = sum + p_str->a;
+  return sum;
+}
+
+int
+main ()
+{
+  int i, sum;
+  struct str * p = malloc (N * sizeof (struct str));
+  if (p == NULL)
+    return 0;
+  for (i = 0; i < N; i++)
+    sum = foo (p+i);
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "is passed to local function...Excluded." "ipa_struct_reorg" } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_return.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_return.c
new file mode 100644
index 000000000..26944fe10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_return.c
@@ -0,0 +1,33 @@
+/* { dg-options "-O3 -fno-inline -fipa-type-escape -fdump-ipa-all -fipa-struct-reorg -fwhole-program -combine" } */
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+
+struct A {
+  int d;
+};
+
+struct A a;
+
+struct A foo ()
+{
+  a.d = 5;
+  return a;
+}
+
+int
+main ()
+{
+  a.d = 0;
+  foo ();
+
+  if (a.d != 5)
+    abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "is return type of function...Excluded" "ipa_struct_reorg" } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_str_init.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_str_init.c
new file mode 100644
index 000000000..5f634fc11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_str_init.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  int b;
+}str_t;
+
+#define N 2
+
+str_t A[2] = {{1,1},{2,2}};
+
+int
+main ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    A[i].b = A[i].a;
+
+  for (i = 0; i < N; i++)
+    if (A[i].b != A[i].a)
+      abort ();
+  
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "is initialized...Excluded" "ipa_struct_reorg" } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_array.c
new file mode 100644
index 000000000..55a644e19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_array.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#define N 1000
+
+typedef struct 
+{
+  str_t A[N];
+  int c;
+}str_with_substr_t;
+
+str_with_substr_t a;
+
+int
+main ()
+{
+  int i;
+  
+  for (i = 0; i < N; i++)
+    a.A[i].b = 0;
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "is a field in the structure" "ipa_struct_reorg" } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_pointer.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_pointer.c
new file mode 100644
index 000000000..8e5463245
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_pointer.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 16000
+#define N 1000
+#else
+#define N (STACK_SIZE/16)
+#endif
+#else
+#define N 1000
+#endif
+
+typedef struct 
+{
+  str_t * sub_str;
+  int c;
+}str_with_substr_t;
+
+int
+main (void)
+{
+  int i;
+  str_with_substr_t A[N];
+  str_t a[N];
+
+  for (i=0; i < N; i++)
+    A[i].sub_str = &(a[i]);
+
+  for (i=0; i < N; i++)
+    A[i].sub_str->a = 5;
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "is a field in the structure" "ipa_struct_reorg" } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_value.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_value.c
new file mode 100644
index 000000000..bade31539
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_escape_substr_value.c
@@ -0,0 +1,46 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+
+typedef struct 
+{
+  str_t sub_str;
+  int c;
+}str_with_substr_t;
+
+int
+main ()
+{
+  int i;
+  str_with_substr_t A[N];
+
+  for (i = 0; i < N; i++)
+    A[i].sub_str.a = 5;
+
+  for (i = 0; i < N; i++)
+    if (A[i].sub_str.a != 5)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "is a field in the structure" "ipa_struct_reorg" } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_global_array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_global_array.c
new file mode 100644
index 000000000..4ffd4b5a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_global_array.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#define N 1000
+str_t A[N];
+
+int
+main ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      A[i].a = 0;
+    }
+
+  for (i = 0; i < N; i++)
+    if (A[i].a != 0) 
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_global_var.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_global_var.c
new file mode 100644
index 000000000..4c00d0243
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_global_var.c
@@ -0,0 +1,46 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+str_t *p;
+
+int
+main ()
+{
+  int i, sum;
+
+  p = malloc (N * sizeof (str_t));
+  if (p == NULL)
+    return 0;
+  for (i = 0; i < N; i++)
+    p[i].b = i;
+
+  for (i = 0; i < N; i++)
+    p[i].b = p[i].a + 1;
+
+  for (i = 0; i < N; i++)
+    if (p[i].b != p[i].a + 1)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_local_array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_local_array.c
new file mode 100644
index 000000000..3d92da405
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_local_array.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+main ()
+{
+  int i;
+  str_t A[N];
+
+  for (i = 0; i < N; i++)
+    {
+      A[i].a = 0;
+    }
+
+  for (i = 0; i < N; i++)
+    if (A[i].a != 0) 
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_local_var.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_local_var.c
new file mode 100644
index 000000000..a6fd7be43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_local_var.c
@@ -0,0 +1,44 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+main ()
+{
+  int i, sum;
+
+  str_t * p = malloc (N * sizeof (str_t));
+  if (p == NULL)
+    return 0;
+  for (i = 0; i < N; i++)
+    p[i].b = i;
+
+  for (i = 0; i < N; i++)
+    p[i].b = p[i].a + 1;
+
+  for (i = 0; i < N; i++)
+    if (p[i].b != p[i].a + 1)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_malloc_size_var.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_malloc_size_var.c
new file mode 100644
index 000000000..04b8b6621
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_malloc_size_var.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 8000
+#define N 1000
+#else
+#define N (STACK_SIZE/8)
+#endif
+#else
+#define N 1000
+#endif
+
+int
+main ()
+{
+  int i, num;
+
+  num = rand();
+  num = num > N ? N : num; 
+  str_t * p = malloc (num * sizeof (str_t));
+
+  if (p == 0)
+    return 0;
+
+  for (i = 0; i < num; i++)
+    p[i].b = i;
+
+  for (i = 0; i < num; i++)
+    p[i].a = p[i].b + 1;
+
+  for (i = 0; i < num; i++)
+    if (p[i].a != p[i].b + 1)
+      abort ();
+  
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_mult_field_peeling.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_mult_field_peeling.c
new file mode 100644
index 000000000..8f116df4d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_mult_field_peeling.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  float b;
+  int c;
+  float d;
+}str_t;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 1600
+#define N 100
+#else
+#define N (STACK_SIZE/16)
+#endif
+#else
+#define N 100
+#endif
+
+int 
+main ()
+{
+  int i;
+  str_t *p = malloc (N * sizeof (str_t));
+  if (p == NULL)
+    return 0;
+  for (i = 0; i < N; i++)
+    p[i].a = 5;
+
+  for (i = 0; i < N; i++)
+    if (p[i].a != 5)      
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* The structure str_t is erroneously peeled into 4 structures instead of 2.  */
+/* { dg-final { scan-ipa-dump "the number of new types is 2" "ipa_struct_reorg" { xfail *-*-* } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_global.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_global.c
new file mode 100644
index 000000000..22193f2ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_global.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  int b;
+}str_t;
+
+#define N 3
+
+str_t str;
+
+int
+main ()
+{
+  int i;
+  int res = 1<<(1<<N);
+  str.a = 2;
+
+  for (i = 0; i < N; i++)
+    str.a = str.a * str.a;
+  
+  if (str.a != res)
+    abort ();
+
+  /* POSIX ignores all but the 8 low-order bits, but other
+     environments may not.  */
+  return (str.a & 255);
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_local.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_local.c
new file mode 100644
index 000000000..e17ca56ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_local.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  int b;
+}str_t;
+
+#define N 3
+
+int
+main ()
+{
+  int i;
+  int res = 1<<(1<<N);
+  str_t str;
+  
+  str.a = 2;
+
+  for (i = 0; i < N; i++)
+    str.a = str.a * str.a;
+  
+  if (str.a != res)
+    abort ();
+
+  /* POSIX ignores all but the 8 low-order bits, but other
+     environments may not.  */
+  return (str.a & 255);
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "No structures to transform" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_pointer.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_pointer.c
new file mode 100644
index 000000000..bd70dfb63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_single_str_pointer.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+typedef struct
+{
+  int a;
+  int *b;
+}str_t;
+
+#define N 3
+
+str_t *p;
+
+int
+main ()
+{
+  str_t str;
+  int i;
+  int res = 1 << (1 << N);
+  p = &str;
+  str.a = 2;
+ 
+  p->b = &(p->a);
+
+  for (i=0; i < N; i++)
+    p->a = *(p->b)*(*(p->b));
+
+  if (p->a != res)
+    abort ();
+  
+  /* POSIX ignores all but the 8 low-order bits, but other
+     environments may not.  */
+  return (p->a & 255);
+}
+
+/*--------------------------------------------------------------------------*/
+/* The access &(p->a) is handled incorrectly in ipa-struct-reorg.c.  */
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 1" "ipa_struct_reorg" { xfail *-*-* } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_two_strs.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_two_strs.c
new file mode 100644
index 000000000..24dae5598
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/struct/wo_prof_two_strs.c
@@ -0,0 +1,68 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+
+#include <stdlib.h>
+
+typedef struct
+{
+  int a;
+  float b;
+}str_t1;
+
+typedef struct
+{
+  int c;
+  float d;
+}str_t2;
+
+#ifdef STACK_SIZE
+#if STACK_SIZE > 16000
+#define N 1000
+#else
+#define N (STACK_SIZE/16)
+#endif
+#else
+#define N 1000
+#endif
+
+str_t1 *p1;
+str_t2 *p2;
+int num;
+
+void
+foo (void)
+{
+  int i;
+
+  for (i=0; i < num; i++)
+    p2[i].c = 2;
+}
+
+int
+main ()
+{
+  int i, r;
+
+  r = rand ();
+  num = r > N ? N : r; 
+  p1 = malloc (num * sizeof (str_t1));
+  p2 = malloc (num * sizeof (str_t2));
+
+  if (p1 == NULL || p2 == NULL)
+    return 0;
+
+  for (i = 0; i < num; i++)
+    p1[i].a = 1;
+
+  foo ();
+
+  for (i = 0; i < num; i++)
+    if (p1[i].a != 1 || p2[i].c != 2)
+      abort ();
+
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+/* { dg-final { scan-ipa-dump "Number of structures to transform is 2" "ipa_struct_reorg" { xfail { "avr-*-*" } } } } */
+/* { dg-final { cleanup-ipa-dump "*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-1.c
new file mode 100644
index 000000000..1879790dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-fpic -O2" } */
+
+void f (char *s)
+{
+  for (;;)
+    {
+      int t = 6;
+      switch (t)
+	{
+	case 2:
+	  *s = '2';
+	case 6: case 4: case 3: case 1:
+	  break;
+	}
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-2.c
new file mode 100644
index 000000000..cedb69f7b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-2.c
@@ -0,0 +1,10 @@
+/* PR c/9262 */
+/* Originator: Rasmus Hahn <rassahah@neofonie.de> */
+/* { dg-do compile } */
+
+int foo(int i)
+{
+  switch (i)
+    case 3:
+      return 1,
+}  /* { dg-error "parse error|syntax error|expected" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-3.c
new file mode 100644
index 000000000..593c42d8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-3.c
@@ -0,0 +1,12 @@
+/* PR c/9262 */
+/* Originator: Rasmus Hahn <rassahah@neofonie.de> */
+/* { dg-do compile } */
+
+int foo(int i)
+{
+  switch (i)
+    case 3:
+      return 1;
+    case 4:      /* { dg-error "not within a switch statement" } */
+      return 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-4.c
new file mode 100644
index 000000000..f2d85300d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-4.c
@@ -0,0 +1,24 @@
+/* PR middle-end/17657 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern signed char foo(int);
+
+void bar (void)
+{
+  signed char tmp = foo (0);
+  int t1 = tmp;
+  switch (t1)
+    {
+    case 1: foo (1); break;
+    case 2: foo (2); break;
+    case 3: foo (3); break;
+    case 4: foo (4); break;
+    case 5: foo (5); break;
+    case 6: foo (6); break;
+    case 7: foo (7); break;
+    case 255: foo (8); break;
+    default: break;
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-5.c
new file mode 100644
index 000000000..5a5849069
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-5.c
@@ -0,0 +1,75 @@
+/* Test diagnostics for switch statements and labels therein.  Test
+   with no special options.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void
+f (int a, double d, void *p)
+{
+  switch (d) /* { dg-error "switch quantity not an integer" } */
+    {
+    }
+  switch (p) /* { dg-error "switch quantity not an integer" } */
+    {
+    }
+  switch (a)
+    {
+    case (void *)0: ; /* { dg-error "pointers are not permitted as case values" } */
+    }
+  switch (a)
+    {
+    case (double)0: ; /* { dg-error "case label does not reduce to an integer constant" } */
+    }
+  switch (a)
+    {
+    case (char)0: ;
+    }
+  switch (a)
+    {
+    case 0 ... 0: ;
+    }
+  switch (a)
+    {
+    case 0 ... -1: ; /* { dg-warning "empty range specified" } */
+    }
+  switch (a)
+    {
+    case 0 ... -2: ; /* { dg-warning "empty range specified" } */
+    }
+  switch (a)
+    {
+    case 0:
+    default: /* { dg-error "this is the first default label" } */
+    case 1:
+    default: ; /* { dg-error "multiple default labels in one switch" } */
+    }
+  switch (a)
+    {
+    case 0: /* { dg-error "previously used here" } */
+    case 1:
+    case 0: ; /* { dg-error "duplicate case value" } */
+    }
+ case 1: ; /* { dg-error "case label not within a switch statement" } */
+ default: ; /* { dg-error "'default' label not within a switch statement" } */
+   break; /* { dg-error "break statement not within loop or switch" } */
+   continue; /* { dg-error "continue statement not within a loop" } */
+   switch (a)
+     {
+     case a: ; /* { dg-error "case label does not reduce to an integer constant" } */
+     }
+   switch (a)
+     {
+     case 0: /* { dg-error "this is the first entry overlapping that value" } */
+     case -1 ... 1: /* { dg-error "duplicate \\(or overlapping\\) case value" } */
+     case 2 ... 3: /* { dg-error "previously used here" } */
+     case 2: /* { dg-error "duplicate case value" } */
+     case 4 ... 7: /* { dg-error "this is the first entry overlapping that value" } */
+     case 6 ... 9: ; /* { dg-error "duplicate \\(or overlapping\\) case value" } */
+     }
+   switch (a)
+     {
+     case 0:
+       continue; /* { dg-error "continue statement not within a loop" } */
+     }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-6.c
new file mode 100644
index 000000000..25d1d96b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-6.c
@@ -0,0 +1,14 @@
+/* Test diagnostics for switch statements and labels therein.  Test
+   for case ranges with -pedantic.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+void
+f (int a)
+{
+  switch (a)
+    {
+    case 0 ... 0: ; /* { dg-warning "range expressions in switch statements are non-standard" } */
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-7.c
new file mode 100644
index 000000000..29cb82569
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-7.c
@@ -0,0 +1,14 @@
+/* Test diagnostics for switch statements and labels therein.  Test
+   for case ranges with -pedantic-errors.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors" } */
+
+void
+f (int a)
+{
+  switch (a)
+    {
+    case 0 ... 0: ; /* { dg-error "range expressions in switch statements are non-standard" } */
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-8.c
new file mode 100644
index 000000000..fcb3f602e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-8.c
@@ -0,0 +1,10 @@
+/* PR middle-end/18493 */
+/* { dg-do link } */
+
+int main() {
+goto bug;
+switch(0) {
+bug: return 0;
+}
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-9.c
new file mode 100644
index 000000000..2ae89d095
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-9.c
@@ -0,0 +1,25 @@
+/* PR middle-end/18859 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void foo(int a)
+{
+  switch (a)
+  {
+    case 0 ... -1:  /* { dg-warning "empty range" } */
+      a = a+2;
+      break;
+
+    case 1 ... 2:
+      a = 0;
+      break;
+
+    case 3 ... 4:
+      a = 1;
+      break;
+
+    case 5 ... 6:
+      a = 0;
+      break;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-A.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-A.c
new file mode 100644
index 000000000..3bc04c017
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-A.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+void foo()
+{
+  switch (,) { } /* { dg-error "expected expression before" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-1.c
new file mode 100644
index 000000000..04ca4e367
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-1.c
@@ -0,0 +1,47 @@
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+
+extern void abort (void);
+extern void exit (int);
+
+/* Check that out-of-bounds case warnings work in the case that the
+   testing expression is promoted.  */
+int
+foo1 (unsigned char i)
+{
+  switch (i)
+    {
+    case -1:   /* { dg-warning "case label value is less than minimum value for type" } */
+      return 1;
+    case 256:  /* { dg-warning "case label value exceeds maximum value for type" } */
+      return 2;
+    default:
+      return 3;
+    }
+}
+
+/* Like above, but for case ranges that need to be satured.  */
+int
+foo2 (unsigned char i)
+{
+  switch (i)
+    {
+    case -1 ... 1:   /* { dg-warning "lower value in case label range less than minimum value for type" } */
+      return 1;
+    case 254 ... 256:  /* { dg-warning "upper value in case label range exceeds maximum value for type" } */
+      return 2;
+    default:
+      return 3;
+    }
+}
+
+int
+main (void)
+{
+  if (foo1 (10) != 3)
+    abort ();
+  if (foo2 (10) != 3)
+    abort ();
+  exit (0);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-2.c
new file mode 100644
index 000000000..7778b66e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-2.c
@@ -0,0 +1,26 @@
+/* This should not warn about the case label being out of range.  */
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+foo (unsigned int i)
+{
+  switch (i)
+  {
+    case 123456123456ULL: /* { dg-warning "large integer implicitly truncated to unsigned type" } */
+      return 0;
+    default:
+      return 3;
+  }
+}
+
+int
+main (void)
+{
+  if (foo (10) != 3)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-3.c
new file mode 100644
index 000000000..e13b4f58a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/switch-warn-3.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-Wswitch-enum" } */
+
+enum a { a0, a1, a2, a3 };
+
+int error(enum a aa)
+{
+  switch ( aa )
+  {
+  case a0 ... a3:
+    return 1;
+  }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-1.c
new file mode 100644
index 000000000..f8cabe47a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-1.c
@@ -0,0 +1,40 @@
+/* Validate that the __sync builtins are overloaded properly.  */
+/* { dg-do compile } */
+/* { dg-options "-Werror" } */
+
+#define TEST1(TYPE, BUILTIN)		\
+void t_##TYPE##BUILTIN(TYPE *p)		\
+{					\
+  __typeof(BUILTIN(p, 1)) *pp;		\
+  pp = p;				\
+}
+
+#define TEST2(BUILTIN)		\
+  TEST1(int, BUILTIN)		\
+  TEST1(long, BUILTIN)
+
+TEST2(__sync_fetch_and_add)
+TEST2(__sync_fetch_and_sub)
+TEST2(__sync_fetch_and_or)
+TEST2(__sync_fetch_and_and)
+TEST2(__sync_fetch_and_xor)
+TEST2(__sync_fetch_and_nand)
+
+TEST2(__sync_add_and_fetch)
+TEST2(__sync_sub_and_fetch)
+TEST2(__sync_or_and_fetch)
+TEST2(__sync_and_and_fetch)
+TEST2(__sync_xor_and_fetch)
+TEST2(__sync_nand_and_fetch)
+
+TEST2(__sync_lock_test_and_set)
+
+#define TEST3(TYPE)					\
+void t_##TYPE##__sync_val_compare_and_swap(TYPE *p)	\
+{							\
+  __typeof(__sync_val_compare_and_swap(p, 1, 2)) *pp;	\
+  pp = p;						\
+}
+
+TEST3(int)
+TEST3(long)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-2.c
new file mode 100644
index 000000000..7794ffd9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-2.c
@@ -0,0 +1,105 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_char_short } */
+/* { dg-options "-ansi" } */
+/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */
+
+/* { dg-message "note: '__sync_fetch_and_nand' changed semantics in GCC 4.4" "" { target *-*-* } 0 } */
+/* { dg-message "note: '__sync_nand_and_fetch' changed semantics in GCC 4.4" "" { target *-*-* } 0 } */
+
+/* Test functionality of the intrinsics for 'short' and 'char'.  */
+
+extern void abort (void);
+extern void *memcpy (void *, const void *, __SIZE_TYPE__);
+
+static char AI[18];
+static char init_qi[18] = { 3,5,7,9,0,0,0 ,0  ,-1,0,0,-1,0,0  ,-1,0,0,-1 };
+static char test_qi[18] = { 3,5,7,9,1,4,22,-12,7 ,8,9,~7,1,-12,7 ,8,9,~7 };
+
+static void
+do_qi (void)
+{
+  if (__sync_fetch_and_add(AI+4, 1) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AI+5, 4) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AI+6, 22) != 0)
+    abort ();
+  if (__sync_fetch_and_sub(AI+7, 12) != 0)
+    abort ();
+  if (__sync_fetch_and_and(AI+8, 7) != (char)-1)
+    abort ();
+  if (__sync_fetch_and_or(AI+9, 8) != 0)
+    abort ();
+  if (__sync_fetch_and_xor(AI+10, 9) != 0)
+    abort ();
+  if (__sync_fetch_and_nand(AI+11, 7) != (char)-1)
+    abort ();
+
+  if (__sync_add_and_fetch(AI+12, 1) != 1)
+    abort ();
+  if (__sync_sub_and_fetch(AI+13, 12) != (char)-12)
+    abort ();
+  if (__sync_and_and_fetch(AI+14, 7) != 7)
+    abort ();
+  if (__sync_or_and_fetch(AI+15, 8) != 8)
+    abort ();
+  if (__sync_xor_and_fetch(AI+16, 9) != 9)
+    abort ();
+  if (__sync_nand_and_fetch(AI+17, 7) != (char)~7)
+    abort ();
+}
+
+static short AL[18];
+static short init_hi[18] = { 3,5,7,9,0,0,0 ,0  ,-1,0,0,-1,0,0  ,-1,0,0,-1 };
+static short test_hi[18] = { 3,5,7,9,1,4,22,-12,7 ,8,9,~7,1,-12,7 ,8,9,~7 };
+
+static void
+do_hi (void)
+{
+  if (__sync_fetch_and_add(AL+4, 1) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AL+5, 4) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AL+6, 22) != 0)
+    abort ();
+  if (__sync_fetch_and_sub(AL+7, 12) != 0)
+    abort ();
+  if (__sync_fetch_and_and(AL+8, 7) != -1)
+    abort ();
+  if (__sync_fetch_and_or(AL+9, 8) != 0)
+    abort ();
+  if (__sync_fetch_and_xor(AL+10, 9) != 0)
+    abort ();
+  if (__sync_fetch_and_nand(AL+11, 7) != -1)
+    abort ();
+
+  if (__sync_add_and_fetch(AL+12, 1) != 1)
+    abort ();
+  if (__sync_sub_and_fetch(AL+13, 12) != -12)
+    abort ();
+  if (__sync_and_and_fetch(AL+14, 7) != 7)
+    abort ();
+  if (__sync_or_and_fetch(AL+15, 8) != 8)
+    abort ();
+  if (__sync_xor_and_fetch(AL+16, 9) != 9)
+    abort ();
+  if (__sync_nand_and_fetch(AL+17, 7) != ~7)
+    abort ();
+}
+
+int main()
+{
+  memcpy(AI, init_qi, sizeof(init_qi));
+  memcpy(AL, init_hi, sizeof(init_hi));
+
+  do_qi ();
+  do_hi ();
+
+  if (memcmp (AI, test_qi, sizeof(test_qi)))
+    abort ();
+  if (memcmp (AL, test_hi, sizeof(test_hi)))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-3.c
new file mode 100644
index 000000000..f91240503
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/sync-3.c
@@ -0,0 +1,102 @@
+/* { dg-do run } */
+/* { dg-require-effective-target sync_char_short } */
+/* { dg-options "-ansi" } */
+/* { dg-options "-march=i486" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-mcpu=v9" { target sparc*-*-* } } */
+
+/* Test functionality of the intrinsics for 'short' and 'char'.  */
+
+extern void abort (void);
+extern void *memcpy (void *, const void *, __SIZE_TYPE__);
+
+static char AI[18] __attribute__((__aligned__ (4)));
+static char init_qi[18] = { 3,5,7,9,0,0,0 ,0  ,-1,0,0,-1,0,0  ,-1,0,0,-1 };
+static char test_qi[18] = { 3,5,7,9,1,4,22,-12,7 ,8,9,~7,1,-12,7 ,8,9,~7 };
+
+static void
+do_qi (void)
+{
+  if (__sync_fetch_and_add(AI+4, 1) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AI+5, 4) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AI+6, 22) != 0)
+    abort ();
+  if (__sync_fetch_and_sub(AI+7, 12) != 0)
+    abort ();
+  if (__sync_fetch_and_and(AI+8, 7) != (char)-1)
+    abort ();
+  if (__sync_fetch_and_or(AI+9, 8) != 0)
+    abort ();
+  if (__sync_fetch_and_xor(AI+10, 9) != 0)
+    abort ();
+  if (__sync_fetch_and_nand(AI+11, 7) != (char)-1) /* { dg-message "note: '__sync_fetch_and_nand' changed semantics in GCC 4.4" "" } */
+    abort ();
+
+  if (__sync_add_and_fetch(AI+12, 1) != 1)
+    abort ();
+  if (__sync_sub_and_fetch(AI+13, 12) != (char)-12)
+    abort ();
+  if (__sync_and_and_fetch(AI+14, 7) != 7)
+    abort ();
+  if (__sync_or_and_fetch(AI+15, 8) != 8)
+    abort ();
+  if (__sync_xor_and_fetch(AI+16, 9) != 9)
+    abort ();
+  if (__sync_nand_and_fetch(AI+17, 7) != (char)~7) /* { dg-message "note: '__sync_nand_and_fetch' changed semantics in GCC 4.4" "" } */
+    abort ();
+}
+
+static short AL[18];
+static short init_hi[18] = { 3,5,7,9,0,0,0 ,0  ,-1,0,0,-1,0,0  ,-1,0,0,-1 };
+static short test_hi[18] = { 3,5,7,9,1,4,22,-12,7 ,8,9,~7,1,-12,7 ,8,9,~7 };
+
+static void
+do_hi (void)
+{
+  if (__sync_fetch_and_add(AL+4, 1) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AL+5, 4) != 0)
+    abort ();
+  if (__sync_fetch_and_add(AL+6, 22) != 0)
+    abort ();
+  if (__sync_fetch_and_sub(AL+7, 12) != 0)
+    abort ();
+  if (__sync_fetch_and_and(AL+8, 7) != -1)
+    abort ();
+  if (__sync_fetch_and_or(AL+9, 8) != 0)
+    abort ();
+  if (__sync_fetch_and_xor(AL+10, 9) != 0)
+    abort ();
+  if (__sync_fetch_and_nand(AL+11, 7) != -1)
+    abort ();
+
+  if (__sync_add_and_fetch(AL+12, 1) != 1)
+    abort ();
+  if (__sync_sub_and_fetch(AL+13, 12) != -12)
+    abort ();
+  if (__sync_and_and_fetch(AL+14, 7) != 7)
+    abort ();
+  if (__sync_or_and_fetch(AL+15, 8) != 8)
+    abort ();
+  if (__sync_xor_and_fetch(AL+16, 9) != 9)
+    abort ();
+  if (__sync_nand_and_fetch(AL+17, 7) != ~7)
+    abort ();
+}
+
+int main()
+{
+  memcpy(AI, init_qi, sizeof(init_qi));
+  memcpy(AL, init_hi, sizeof(init_hi));
+
+  do_qi ();
+  do_hi ();
+
+  if (memcmp (AI, test_qi, sizeof(test_qi)))
+    abort ();
+  if (memcmp (AL, test_hi, sizeof(test_hi)))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tg-tests.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/tg-tests.h
new file mode 100644
index 000000000..ce9cfb866
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tg-tests.h
@@ -0,0 +1,148 @@
+/* Test various type-generic builtins by calling "main_tests()".  */
+
+#define FP_NAN 1
+#define FP_INFINITE 2
+#define FP_NORMAL 3
+#define FP_SUBNORMAL 4
+#define FP_ZERO 5
+#define fpclassify(X) __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, (X))
+
+void __attribute__ ((__noinline__))
+foo_1 (float f, double d, long double ld,
+       int res_unord, int res_isnan, int res_isinf,
+       int res_isinf_sign, int res_isfin, int res_isnorm,
+       int classification)
+{
+  if (__builtin_isunordered (f, 0) != res_unord)
+    __builtin_abort ();
+  if (__builtin_isunordered (0, f) != res_unord)
+    __builtin_abort ();
+  if (__builtin_isunordered (d, 0) != res_unord)
+    __builtin_abort ();
+  if (__builtin_isunordered (0, d) != res_unord)
+    __builtin_abort ();
+  if (__builtin_isunordered (ld, 0) != res_unord)
+    __builtin_abort ();
+  if (__builtin_isunordered (0, ld) != res_unord)
+    __builtin_abort ();
+
+  if (__builtin_isnan (f) != res_isnan)
+    __builtin_abort ();
+  if (__builtin_isnan (d) != res_isnan)
+    __builtin_abort ();
+  if (__builtin_isnan (ld) != res_isnan)
+    __builtin_abort ();
+  if (__builtin_isnanf (f) != res_isnan)
+    __builtin_abort ();
+  if (__builtin_isnanl (ld) != res_isnan)
+    __builtin_abort ();
+
+  if (__builtin_isinf (f) != res_isinf)
+    __builtin_abort ();
+  if (__builtin_isinf (d) != res_isinf)
+    __builtin_abort ();
+  if (__builtin_isinf (ld) != res_isinf)
+    __builtin_abort ();
+  if (__builtin_isinff (f) != res_isinf)
+    __builtin_abort ();
+  if (__builtin_isinfl (ld) != res_isinf)
+    __builtin_abort ();
+
+  if (__builtin_isinf_sign (f) != res_isinf_sign)
+    __builtin_abort ();
+  if (__builtin_isinf_sign (d) != res_isinf_sign)
+    __builtin_abort ();
+  if (__builtin_isinf_sign (ld) != res_isinf_sign)
+    __builtin_abort ();
+
+  if (__builtin_isnormal (f) != res_isnorm)
+    __builtin_abort ();
+  if (__builtin_isnormal (d) != res_isnorm)
+    __builtin_abort ();
+  if (__builtin_isnormal (ld) != res_isnorm)
+    __builtin_abort ();
+
+  if (__builtin_isfinite (f) != res_isfin)
+    __builtin_abort ();
+  if (__builtin_isfinite (d) != res_isfin)
+    __builtin_abort ();
+  if (__builtin_isfinite (ld) != res_isfin)
+    __builtin_abort ();
+
+  if (__builtin_finitef (f) != res_isfin)
+    __builtin_abort ();
+  if (__builtin_finite (f) != res_isfin)
+    __builtin_abort ();
+  if (__builtin_finite (d) != res_isfin)
+    __builtin_abort ();
+  if (__builtin_finitel (d) != res_isfin)
+    __builtin_abort ();
+  if (__builtin_finitel (ld) != res_isfin)
+    __builtin_abort ();
+
+  /* Subnormals can abruptly underflow to zero in unsafe math
+     mode, so bypass testing these numbers if necessary.  */
+#ifdef UNSAFE
+  if (classification != FP_SUBNORMAL)
+#endif
+    {
+      if (fpclassify(f) != classification)
+	__builtin_abort ();
+      if (fpclassify(d) != classification)
+	__builtin_abort ();
+      if (fpclassify(ld) != classification)
+	__builtin_abort ();
+    }
+}
+
+void __attribute__ ((__noinline__))
+foo (float f, double d, long double ld,
+     int res_unord, int res_isnan, int res_isinf,
+     int res_isfin, int res_isnorm, int classification)
+{
+  foo_1 (f, d, ld, res_unord, res_isnan, res_isinf, res_isinf, res_isfin, res_isnorm, classification);
+  /* Try all the values negated as well.  */
+  foo_1 (-f, -d, -ld, res_unord, res_isnan, res_isinf, -res_isinf, res_isfin, res_isnorm, classification);
+}
+
+int __attribute__ ((__noinline__))
+main_tests (void)
+{
+  volatile float f;
+  volatile double d;
+  volatile long double ld;
+  
+  /* Test NaN.  */
+  f = __builtin_nanf(""); d = __builtin_nan(""); ld = __builtin_nanl("");
+  foo(f, d, ld, /*unord=*/ 1, /*isnan=*/ 1, /*isinf=*/ 0, /*isfin=*/ 0, /*isnorm=*/ 0, FP_NAN);
+
+  /* Test infinity.  */
+  f = __builtin_inff(); d = __builtin_inf(); ld = __builtin_infl();
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 1, /*isfin=*/ 0, /*isnorm=*/ 0, FP_INFINITE);
+
+  /* Test zero.  */
+  f = 0; d = 0; ld = 0;
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 0, FP_ZERO);
+
+  /* Test one.  */
+  f = 1; d = 1; ld = 1;
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 1, FP_NORMAL);
+
+  /* Test minimum values.  */
+  f = __FLT_MIN__; d = __DBL_MIN__; ld = __LDBL_MIN__;
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 1, FP_NORMAL);
+
+  /* Test subnormal values.  */
+  f = __FLT_MIN__/2; d = __DBL_MIN__/2; ld = __LDBL_MIN__/2;
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 0, FP_SUBNORMAL);
+
+  /* Test maximum values.  */
+  f = __FLT_MAX__; d = __DBL_MAX__; ld = __LDBL_MAX__;
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 0, /*isfin=*/ 1, /*isnorm=*/ 1, FP_NORMAL);
+
+  /* Test overflow values.  */
+  f = __FLT_MAX__*2; d = __DBL_MAX__*2; ld = __LDBL_MAX__*2;
+  foo(f, d, ld, /*unord=*/ 0, /*isnan=*/ 0, /*isinf=*/ 1, /*isfin=*/ 0, /*isnorm=*/ 0, FP_INFINITE);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_common_c.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_common_c.h
new file mode 100644
index 000000000..72acdbb5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_common_c.h
@@ -0,0 +1,56 @@
+
+#ifndef TEST_COMMON_C_H
+#define TEST_COMMON_C_H
+
+
+#if defined(__GNUC__) && defined(__SUPPORT_TS_ANNOTATION__)
+
+#define LOCKABLE            __attribute__ ((lockable))
+#define SCOPED_LOCKABLE     __attribute__ ((scoped_lockable))
+#define GUARDED_BY(x)       __attribute__ ((guarded_by(x))) 
+#define GUARDED_VAR         __attribute__ ((guarded)) 
+#define PT_GUARDED_BY(x)    __attribute__ ((point_to_guarded_by(x)))
+#define PT_GUARDED_VAR      __attribute__ ((point_to_guarded))
+#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__)))
+#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__)))
+#define EXCLUSIVE_LOCK_FUNCTION(...)   __attribute__ ((exclusive_lock(__VA_ARGS__)))
+#define SHARED_LOCK_FUNCTION(...)      __attribute__ ((shared_lock(__VA_ARGS__)))
+#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock(__VA_ARGS__)))
+#define SHARED_TRYLOCK_FUNCTION(...)    __attribute__ ((shared_trylock(__VA_ARGS__)))
+#define UNLOCK_FUNCTION(...)            __attribute__ ((unlock(__VA_ARGS__)))
+#define LOCK_RETURNED(x)    __attribute__ ((lock_returned(x)))
+#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__)))
+#define EXCLUSIVE_LOCKS_REQUIRED(...) \
+  __attribute__ ((exclusive_locks_required(__VA_ARGS__)))
+#define SHARED_LOCKS_REQUIRED(...) \
+  __attribute__ ((shared_locks_required(__VA_ARGS__)))
+#define NO_THREAD_SAFETY_ANALYSIS  __attribute__ ((no_thread_safety_analysis))
+
+#else
+
+#define LOCKABLE
+#define SCOPED_LOCKABLE
+#define GUARDED_BY(x)
+#define GUARDED_VAR
+#define PT_GUARDED_BY(x)
+#define PT_GUARDED_VAR
+#define ACQUIRED_AFTER(...)
+#define ACQUIRED_BEFORE(...)
+#define EXCLUSIVE_LOCK_FUNCTION(...)
+#define SHARED_LOCK_FUNCTION(...)
+#define EXCLUSIVE_TRYLOCK_FUNCTION(...)
+#define SHARED_TRYLOCK_FUNCTION(...)
+#define UNLOCK_FUNCTION(...)
+#define LOCK_RETURNED(x)
+#define LOCKS_EXCLUDED(...)
+#define EXCLUSIVE_LOCKS_REQUIRED(...)
+#define SHARED_LOCKS_REQUIRED(...)
+#define NO_THREAD_SAFETY_ANALYSIS
+
+#endif // defined(__GNUC__) && defined(SUPPORT_TS_ANNOTATION)
+
+struct LOCKABLE Mutex {
+  int mu_;
+};
+
+#endif // TEST_COMMON_C_H
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-23.c
new file mode 100644
index 000000000..e00eb57ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-23.c
@@ -0,0 +1,38 @@
+/* Test guarded_by/pt_guarded_by annotations with unsupported or unrecognized
+   lock names/expressions.  */
+/* { dg-do compile } */
+/* { dg-options "-Wthread-safety -Wthread-unsupported-lock-name -O" } */
+
+#include "thread_annot_common_c.h"
+
+int pthread_mutex_lock(struct Mutex *mu, int i) EXCLUSIVE_LOCK_FUNCTION(1);
+int pthread_mutex_unlock(struct Mutex *mu) UNLOCK_FUNCTION(1);
+int pthread_mutex_trylock() EXCLUSIVE_TRYLOCK_FUNCTION(0, t->mu1); /* { dg-warning "Unsupported argument of 'exclusive_trylock' attribute ignored" } */
+
+struct Bar {
+  float x_ GUARDED_BY(((mu1_))); /* { dg-warning "'guarded_by' attribute downgraded to 'guarded'" } */
+  struct Mutex mu1_ ACQUIRED_AFTER(mu2);
+  float a_ GUARDED_BY(foo_->mu_); /* { dg-warning "'guarded_by' attribute downgraded to 'guarded'" } */
+};
+
+int p GUARDED_BY(a->mu); /* { dg-warning "'guarded_by' attribute downgraded to 'guarded'" } */
+int *r PT_GUARDED_BY(f1.mu_); /* { dg-warning "'point_to_guarded_by' attribute downgraded to 'point_to_guarded'" } */
+
+struct Bar *b1;
+struct Mutex *mu3;
+
+int foo(int i, int j, struct Mutex *mu) EXCLUSIVE_LOCKS_REQUIRED(3)
+{
+  int *q PT_GUARDED_BY(mu);
+  int t = *q;
+  *q = 4;
+  return t;
+}
+
+int main()
+{
+  pthread_mutex_lock(&b1->mu1_, 2);
+  p = *r + 5;
+  b1->x_ = 3;
+  pthread_mutex_unlock(&b1->mu1_);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-24.c
new file mode 100644
index 000000000..a2d86279e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-24.c
@@ -0,0 +1,44 @@
+/* Test lock/trylock/unlock annotations with unsupported or unrecognized lock
+   names/expressions.  */
+/* { dg-do compile } */
+/* { dg-options "-Wthread-safety -Wthread-unsupported-lock-name -O" } */
+
+#include "thread_annot_common_c.h"
+
+int pthread_mutex_lock(int i) EXCLUSIVE_LOCK_FUNCTION(((&f)->mu)); /* { dg-warning "Unsupported argument of 'exclusive_lock' attribute ignored" } */
+int pthread_mutex_unlock() UNLOCK_FUNCTION(f[0].mu); /* { dg-warning "Unsupported argument of 'unlock' attribute ignored" } */
+int pthread_mutex_trylock() EXCLUSIVE_TRYLOCK_FUNCTION(0, t->mu1); /* { dg-warning "Unsupported argument of 'exclusive_trylock' attribute ignored" } */
+
+struct Mutex *mu3;
+int p GUARDED_BY(mu3);
+int r GUARDED_BY(mu3);
+
+void my_lock() EXCLUSIVE_LOCK_FUNCTION(mu3);
+void my_unlock() UNLOCK_FUNCTION(mu3);
+
+static int foo(int i, int j, struct Mutex *mu) EXCLUSIVE_LOCKS_REQUIRED(3)
+{
+  int *q PT_GUARDED_BY(mu);
+  int t = *q;
+  *q = 4;
+  pthread_mutex_unlock();
+  /* Since the annotation on pthread_mutex_unlock contains an
+     unrecognized lock name, the analysis would conservatively disable
+     the check for mismatched lock acquire/release. Therefore even though
+     my_unlock is trying to release mu3 which is never acquired, we don't
+     emit a warning.  */
+  my_unlock();
+  return t;
+}
+
+int main()
+{
+  my_lock();
+  foo(2, 3, mu3);
+  my_unlock();
+  pthread_mutex_lock(2);
+  p = r + 5;
+  /* Because the annotation on pthread_mutex_lock contains an unrecognized
+     lock, we don't emit a warning even though there is no corresponding
+     unlock call.  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-25.c
new file mode 100644
index 000000000..b38522a80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-25.c
@@ -0,0 +1,46 @@
+/* Test function lock requirement annotations with unsupported or unrecognized
+   lock names/expressions.  */
+/* { dg-do compile } */
+/* { dg-options "-Wthread-safety -Wthread-unsupported-lock-name -O" } */
+
+#include "thread_annot_common_c.h"
+
+int pthread_mutex_lock(int i) EXCLUSIVE_LOCK_FUNCTION(((&f)->mu)); /* { dg-warning "Unsupported argument of 'exclusive_lock' attribute ignored" } */
+int pthread_mutex_unlock() UNLOCK_FUNCTION(f[0].mu); /* { dg-warning "Unsupported argument of 'unlock' attribute ignored" } */
+int pthread_mutex_trylock() EXCLUSIVE_TRYLOCK_FUNCTION(0, t->mu1); /* { dg-warning "Unsupported argument of 'exclusive_trylock' attribute ignored" } */
+
+struct Mutex *mu3;
+int p GUARDED_BY(mu3);
+int r GUARDED_BY(mu3);
+
+void my_lock() EXCLUSIVE_LOCK_FUNCTION(mu3);
+void my_unlock() UNLOCK_FUNCTION(mu3);
+
+extern void foo(int i, int j, struct Mutex *mu) EXCLUSIVE_LOCKS_REQUIRED(3);
+
+void foo(int i, int j, struct Mutex *mu) LOCKS_EXCLUDED(t->mu3)
+{ /* { dg-warning "Unsupported argument of 'locks_excluded' attribute ignored" } */
+  int *q PT_GUARDED_BY(mu);
+  my_lock();
+  p = *q;
+  *q = 4;
+  my_unlock();
+}
+
+int bar() SHARED_LOCKS_REQUIRED(y->mu); /* { dg-warning "Unsupported argument of 'shared_locks_required' attribute ignored" } */
+
+int bar()
+{
+  int t = r;
+  return t;
+}
+
+main()
+{
+  foo(2, 3, mu3); /* { dg-warning "Calling function 'foo' requires lock 'mu3'" } */
+  my_lock();
+  foo(2, 3, mu3);
+  bar();
+  my_unlock();
+  bar(); /* { dg-warning "Calling function 'bar' requires a lock" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-26.c
new file mode 100644
index 000000000..0fd70e324
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-26.c
@@ -0,0 +1,27 @@
+/* Test lock annotations applied to function definitions.  */
+/* { dg-do compile } */
+/* { dg-options "-Wthread-safety -O" } */
+
+#include "thread_annot_common_c.h"
+
+struct Mutex mu1;
+struct Mutex mu2 ACQUIRED_AFTER(mu1);
+
+static int foo(int i) EXCLUSIVE_LOCKS_REQUIRED(mu2);
+
+int bar(int i) LOCKS_EXCLUDED(mu1)
+{
+  return i;
+}
+
+static int foo(int i) SHARED_LOCKS_REQUIRED(mu1)
+{
+  return bar(i); /* { dg-warning "Cannot call function 'bar' with lock 'mu1' held" } */
+}
+
+main()
+{
+  foo(2); /* { dg-warning "Calling function 'foo' requires lock 'mu2'" } */
+}
+
+/* { dg-warning "Calling function 'foo' requires lock 'mu1'" "" { target *-*-* } 24 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-27.c
new file mode 100644
index 000000000..2d7dda346
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-27.c
@@ -0,0 +1,37 @@
+/* Test lock annotations applied to function definitions. This is a "good"
+   test that should not incur any compilation warnings.  */
+/* { dg-do compile } */
+/* { dg-options "-Wthread-safety -O" } */
+
+#include "thread_annot_common_c.h"
+
+int pthread_mutex_lock(struct Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(1);
+int pthread_mutex_unlock(struct Mutex *mu) UNLOCK_FUNCTION(1);
+
+struct Mutex mu1;
+struct Mutex mu2 ACQUIRED_AFTER(mu1);
+
+static int foo(int i) EXCLUSIVE_LOCKS_REQUIRED(mu2);
+
+int bar(int i) LOCKS_EXCLUDED(mu2)
+{
+  return i;
+}
+
+static int foo(int i) SHARED_LOCKS_REQUIRED(mu1)
+{
+  int result;
+  pthread_mutex_unlock(&mu2);
+  result = bar(i);
+  pthread_mutex_lock(&mu2);
+  return result;
+}
+
+main()
+{
+  pthread_mutex_lock(&mu1);
+  pthread_mutex_lock(&mu2);
+  foo(2);
+  pthread_mutex_unlock(&mu2);
+  pthread_mutex_unlock(&mu1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-42.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-42.c
new file mode 100644
index 000000000..0439b265d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/thread_annot_lock-42.c
@@ -0,0 +1,31 @@
+// Test support of multiple lock attributes of the same kind on a decl.
+// { dg-do compile }
+// { dg-options "-Wthread-safety -O" }
+
+#include "thread_annot_common_c.h"
+
+struct Mutex mu1, mu2, mu3;
+
+int x GUARDED_BY(mu1) GUARDED_BY(mu3); // { dg-warning "ignored" }
+int y;
+
+void f2() LOCKS_EXCLUDED(mu1) LOCKS_EXCLUDED(mu2) LOCKS_EXCLUDED(mu3);
+
+void f2()
+{
+  y = 2;
+}
+
+void f1() EXCLUSIVE_LOCKS_REQUIRED(mu2) EXCLUSIVE_LOCKS_REQUIRED(mu1)
+{
+  x = 5;
+  f2(); // { dg-warning "Cannot call function 'f2' with lock 'mu1' held" }
+}
+
+void func()
+{
+  f1(); // { dg-warning "Calling function 'f1' requires lock 'mu2'" }
+}
+
+// { dg-warning "Cannot call function 'f2' with lock 'mu2' held" "" { target *-*-* } 22 }
+// { dg-warning "Calling function 'f1' requires lock 'mu1'" "" { target *-*-* } 27 }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/titype-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/titype-1.c
new file mode 100644
index 000000000..31c01a681
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/titype-1.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+
+/* Not all platforms support TImode integers.  */
+#if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64)
+typedef int TItype __attribute__ ((mode (TI)));
+#else
+typedef long TItype;
+#endif
+
+#include <stdarg.h>
+
+extern void abort(void);
+
+
+void foo(int i, ...)
+{
+  TItype q;
+  va_list va;
+
+  va_start(va, i);
+  q = va_arg(va, TItype);
+  va_end(va);
+
+  if (q != 5)
+    abort();
+}
+
+int main(void)
+{
+  TItype q = 5;
+
+  foo(1, q);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/alias-1.c
new file mode 100644
index 000000000..722ad2154
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/alias-1.c
@@ -0,0 +1,24 @@
+/* { dg-do link } */
+/* { dg-require-alias "" } */
+/* { dg-require-visibility "" } */
+/* { dg-require-effective-target tls_runtime } */
+/* Test that encode_section_info handles the change from externally
+   defined to locally defined (via hidden).   Extracted from glibc.  */
+
+struct __res_state {
+	char x[123];
+};
+
+extern __thread struct __res_state bar
+  __attribute__ ((tls_model ("initial-exec")));
+
+int main()
+{
+  bar.x[0] = 0;
+  return 0;
+}
+
+__thread struct __res_state foo;
+extern __thread struct __res_state bar
+  __attribute__ ((alias ("foo")))
+  __attribute__ ((visibility ("hidden")));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/alpha-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/alpha-1.c
new file mode 100644
index 000000000..1f0d6eda1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/alpha-1.c
@@ -0,0 +1,10 @@
+/* Make sure that we honor initial-exec.  */
+/* { dg-do compile { target alpha*-*-* } } */
+/* { dg-options "" } */
+/* { dg-require-effective-target tls_native } */
+
+static __thread int xyzzy __attribute__ ((tls_model ("initial-exec")));
+int foo(void) { return xyzzy; }
+
+/* { dg-final { scan-assembler "gottprel" } } */
+/* { dg-final { scan-assembler-not "tprel(lo|hi|16)" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/asm-1.c
new file mode 100644
index 000000000..b77e550d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/asm-1.c
@@ -0,0 +1,8 @@
+/* { dg-options "-Werror" } */
+/* { dg-require-effective-target tls } */
+__thread int i;
+
+int foo ()
+{
+  asm volatile ("" :: "m" (&i));  /* { dg-error "directly addressable" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/debug-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/debug-1.c
new file mode 100644
index 000000000..67d7be69c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/debug-1.c
@@ -0,0 +1,5 @@
+/* { dg-do assemble } */
+/* { dg-options "-g" } */
+/* { dg-require-effective-target tls } */
+
+__thread int i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-1.c
new file mode 100644
index 000000000..56b570c94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-1.c
@@ -0,0 +1,12 @@
+/* Valid __thread specifiers.  */
+/* { dg-require-effective-target tls } */
+
+__thread int g1;
+extern __thread int g2;
+static __thread int g3;
+
+void foo()
+{
+  extern __thread int l1;
+  static __thread int l2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-2.c
new file mode 100644
index 000000000..8276cb3be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-2.c
@@ -0,0 +1,22 @@
+/* Invalid __thread specifiers.  */
+/* { dg-require-effective-target tls } */
+
+__thread extern int g1;		/* { dg-error "'__thread' before 'extern'" } */
+__thread static int g2;		/* { dg-error "'__thread' before 'static'" } */
+__thread __thread int g3;	/* { dg-error "duplicate '__thread'" } */
+typedef __thread int g4;	/* { dg-error "'__thread' used with 'typedef'" } */
+
+void foo()
+{
+  __thread int l1;		/* { dg-error "implicitly auto and declared '__thread'" } */
+  auto __thread int l2;		/* { dg-error "'__thread' used with 'auto'" } */
+  __thread extern int l3;	/* { dg-error "'__thread' before 'extern'" } */
+  register __thread int l4;	/* { dg-error "'__thread' used with 'register'" } */
+}
+
+__thread void f1 ();		/* { dg-error "invalid storage class for function" } */
+extern __thread void f2 ();	/* { dg-error "invalid storage class for function" } */
+static __thread void f3 ();	/* { dg-error "invalid storage class for function" } */
+__thread void f4 () { }		/* { dg-error "function definition declared '__thread'" } */
+
+void bar(__thread int p1);	/* { dg-error "storage class specified for parameter" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-3.c
new file mode 100644
index 000000000..1a7994c69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-3.c
@@ -0,0 +1,11 @@
+/* Report invalid extern and __thread combinations.  */
+/* { dg-require-effective-target tls } */
+
+extern int j;		/* { dg-message "note: previous declaration" } */
+__thread int j;		/* { dg-error "follows non-thread-local" } */
+
+extern __thread int i;	/* { dg-message "note: previous declaration" } */
+int i;			/* { dg-error "follows thread-local" } */
+
+extern __thread int k;	/* This is fine.  */
+__thread int k;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-4.c
new file mode 100644
index 000000000..fed2f3acc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-4.c
@@ -0,0 +1,11 @@
+/* Invalid __thread specifiers.  As diag-4.c but some cases in
+   different orders.  */
+/* { dg-require-effective-target tls } */
+
+__thread typedef int g4;	/* { dg-error "'__thread' used with 'typedef'" } */
+
+void foo()
+{
+  __thread auto int l2;		/* { dg-error "'__thread' used with 'auto'" } */
+  __thread register int l4;	/* { dg-error "'__thread' used with 'register'" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-5.c
new file mode 100644
index 000000000..ac78cb295
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-5.c
@@ -0,0 +1,4 @@
+/* __thread specifiers on empty declarations.  */
+/* { dg-require-effective-target tls } */
+
+__thread struct foo; /* { dg-warning "useless '__thread' in empty declaration" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-6.c
new file mode 100644
index 000000000..71b0b9524
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/diag-6.c
@@ -0,0 +1,8 @@
+/* Invalid tls_model attributes.  PR 35435.  */
+/* { dg-require-effective-target tls } */
+
+int v __attribute__((tls_model("initial-exec"))); /* { dg-warning "attribute ignored" } */
+typedef int X __attribute__((tls_model("initial-exec"))); /* { dg-warning "attribute ignored" } */
+void f(int x __attribute__((tls_model("initial-exec")))); /* { dg-warning "attribute ignored" } */
+__thread int a __attribute__((tls_model(1))); /* { dg-error "tls_model argument not a string" } */
+__thread int b __attribute__((tls_model("unknown"))); /* { dg-error "tls_model argument must be one of" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/emutls-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/emutls-1.c
new file mode 100644
index 000000000..a0dea5094
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/emutls-1.c
@@ -0,0 +1,21 @@
+/* { dg-do run { target *-wrs-vxworks } } */
+/* { dg-require-effective-target tls } */
+
+/* vxworks' TLS model requires no extra padding on the tls proxy
+   objects.  */
+
+__thread int i;
+__thread int j;
+
+extern int __tls__i;
+extern int __tls__j;
+
+int main ()
+{
+  int delta = ((char *)&__tls__j - (char *)&__tls__i);
+
+  if (delta < 0)
+    delta = -delta;
+  
+  return delta != 12;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/init-1.c
new file mode 100644
index 000000000..fa4208dce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/init-1.c
@@ -0,0 +1,5 @@
+/* Invalid initializations.  */
+/* { dg-require-effective-target tls } */
+
+extern __thread int i;
+int *p = &i;	/* { dg-error "initializer element is not constant" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/nonpic-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/nonpic-1.c
new file mode 100644
index 000000000..9c592a985
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/nonpic-1.c
@@ -0,0 +1,72 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftls-model=initial-exec" } */
+/* { dg-require-effective-target tls } */
+
+extern __thread long e1;
+extern __thread int e2;
+static __thread long s1;
+static __thread int s2;
+
+long *ae1 (void)
+{
+  return &e1;
+}
+
+int *ae2 (void)
+{
+  return &e2;
+}
+
+long *as1 (void)
+{
+  return &s1;
+}
+
+int *as2 (void)
+{
+  return &s2;
+}
+
+long ge1 (void)
+{
+  return e1;
+}
+
+int ge2 (void)
+{
+  return e2;
+}
+
+long gs1 (void)
+{
+  return s1;
+}
+
+int gs2 (void)
+{
+  return s2;
+}
+
+long ge3 (void)
+{
+  return e1 + e2;
+}
+
+long gs3 (void)
+{
+  return s1 + s2;
+}
+
+long ge4 (void)
+{
+  if (0)
+    return e1;
+  return e2;
+}
+
+long gs4 (void)
+{
+  if (0)
+    return s1;
+  return s2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-1.c
new file mode 100644
index 000000000..f96bb6768
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-1.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fPIC" } */
+/* { dg-options "-O2 -fPIC -mtune=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-require-effective-target fpic } */
+
+extern __thread int thr;
+
+static int x;
+
+static void
+bar (void)
+{
+  x = 1;
+}
+
+static void
+#ifdef __i386__
+__attribute__ ((regparm (3)))
+#endif
+foo (const char *x, void *y, int *z)
+{
+  bar ();
+}
+
+void
+test (const char *x, void *y)
+{
+  foo (x, y, &thr);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-10.c
new file mode 100644
index 000000000..15dc68610
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-10.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O3 -fpic" } */
+/* { dg-require-effective-target tls } */
+
+/* The web pass was creating unrecognisable pic_load_dot_plus_four insns
+   on ARM.  */
+
+__thread int a_thread_local;
+void *
+spin (int n)
+{
+  int i;
+  for (i = 0; i <= n; i++)
+    {
+      a_thread_local += i;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-11.c
new file mode 100644
index 000000000..373964525
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-11.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-require-effective-target tls_runtime } */
+
+extern void abort (void);
+extern void *memset (void *, int, __SIZE_TYPE__);
+
+struct A
+{
+  char pad[48];
+  int i;
+  int pad2;
+  int j;
+};
+__thread struct A a;
+
+int *
+__attribute__((noinline))
+foo (void)
+{
+  return &a.i;
+}
+
+int
+main (void)
+{
+  int *p = foo ();
+  memset (&a, 0, sizeof (a));
+  a.i = 6;
+  a.j = 8;
+  if (p[0] != 6 || p[1] != 0 || p[2] != 8)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-12.c
new file mode 100644
index 000000000..7c6e73430
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-12.c
@@ -0,0 +1,50 @@
+/* PR target/29198 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fpic" } */
+/* { dg-require-effective-target tls_runtime } */
+/* { dg-require-effective-target fpic } */
+
+extern void abort (void);
+
+int f2 (int, int, int, int);
+struct s { char b[4]; };
+__thread struct s thra[2];
+
+void
+__attribute__((noinline))
+f1 (int a1, int a2)
+{
+  int i, j;
+  for (i = 0; i < 4; i++)
+    {
+      int tot = 0;
+      for (j = 0; j < 4; j++)
+	tot += f2 (a1, a2, i, j);
+      *(&thra[0].b[0] + i) = tot;
+    }
+}
+
+int
+__attribute__((noinline))
+f2 (int a, int b, int c, int d)
+{
+  return a + b + c + d;
+}
+
+int
+main (void)
+{
+  f1 (0, 0);
+  if (thra[0].b[0] != 6
+      || thra[0].b[1] != 10
+      || thra[0].b[2] != 14
+      || thra[0].b[3] != 18)
+    abort ();
+  f1 (2, 3);
+  if (thra[0].b[0] != 26
+      || thra[0].b[1] != 30
+      || thra[0].b[2] != 34
+      || thra[0].b[3] != 38)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-13.c
new file mode 100644
index 000000000..aadfb288f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-13.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls_native } */
+
+__thread struct
+{
+  int a;
+  char b[32];
+} thr;
+
+int
+main ()
+{
+  __builtin_strcpy (thr.b, "abcd");
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-14.c
new file mode 100644
index 000000000..2549c8967
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-14.c
@@ -0,0 +1,28 @@
+/* This testcase generated invalid assembly on ARM Thumb-2.  Two
+   PIC additions of pc were combined, but the deleted label was still
+   used.  */
+/* { dg-do assemble } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls_native } */
+
+struct __res_state
+{
+  int options;
+};
+extern __thread struct __res_state *__resp
+  __attribute__ ((tls_model ("initial-exec")));
+
+void foo (void);
+
+int main(void)
+{
+  int count, total = 0;
+
+  for (count = 0; count < 10; count++)
+    {
+      if (((*__resp).options & 0x00000001) == 0)
+	foo ();
+      (*__resp).options &= ~((0x00000002 | 0x00000200 | 0x00000080));
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-15.c
new file mode 100644
index 000000000..bebee8a49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-15.c
@@ -0,0 +1,24 @@
+/* PR target/42564 */
+/* This used to ICE on the SPARC because of an unrecognized TLS pattern.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -fPIC" } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-require-effective-target fpic } */
+
+extern void *memset(void *s, int c, __SIZE_TYPE__ n);
+
+struct S1 { int i; };
+
+struct S2
+{
+  int ver;
+  struct S1 s;
+};
+
+static __thread struct S2 m;
+
+void init(void)
+{
+  memset(&m.s, 0, sizeof(m.s));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-2.c
new file mode 100644
index 000000000..0980fab61
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-2.c
@@ -0,0 +1,55 @@
+/* This testcase generated invalid assembly on IA-32,
+   since %gs:0 memory load was not exposed to the compiler
+   as memory load and mem to mem moves are not possible
+   on IA-32.  */
+/* { dg-do link } */
+/* { dg-options "-O2 -ftls-model=initial-exec" } */
+/* { dg-options "-O2 -ftls-model=initial-exec -march=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-require-effective-target tls_runtime  } */
+
+__thread int thr;
+
+struct A
+{
+  unsigned int a, b, c, d, e;
+};
+
+int bar (int x, unsigned long y, void *z)
+{
+  return 0;
+}
+
+int
+foo (int x, int y, const struct A *z)
+{
+  struct A b;
+  int d;
+
+  b = *z;
+  d = bar (x, y, &b);
+  if (d == 0 && y == 0x5402)
+    {
+      int e = thr;
+      d = bar (x, 0x5401, &b);
+      if (d)
+	{
+	  thr = e;
+	  d = 0;
+	}
+      else if ((z->c & 0600) != (b.c & 0600)
+	       || ((z->c & 060) && ((z->c & 060) != (b.c & 060))))
+	{
+	  thr = 22;
+	  d = -1;
+	}
+    }
+
+  return d;
+}
+
+int main (void)
+{
+  foo (1, 2, 0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-3.c
new file mode 100644
index 000000000..61f5bdbba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-3.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fpic" } */
+/* { dg-options "-O2 -fpic -mregparm=3" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-require-effective-target fpic } */
+
+extern __thread int i, j, k;
+extern void bar(int *, int *, int *);
+void foo(void)
+{
+  bar(&i, &j, &k);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-4.c
new file mode 100644
index 000000000..3d7953b47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-4.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls_native } */
+
+struct A
+{
+  int a1;
+  int a2;
+};
+
+extern __thread const unsigned char *tcc1, **tcc2;
+
+extern inline const unsigned char ** __attribute__ ((const))
+foo (void)
+{
+  const unsigned char **a = &tcc1;
+  if (*a == 0)
+    *a = *tcc2 + 128;
+  return a;
+}
+
+extern inline int
+bar (const struct A *x)
+{
+  int a;
+
+  if (x->a2 & 8)
+    return 0;
+  a = x->a1;
+  return a > 0 && ((*foo ())[a] & 64);
+}
+
+int
+baz (const struct A *x, char *y)
+{
+  const struct A *a;
+
+  for (a = x; !!a->a1; a++)
+    if (! (x->a2 & 8))
+      if (bar (a))
+	{
+	  *y++ = a->a1;
+	  if (x->a1)
+	    *y++ = ':';
+	  *y = '\0';
+	}
+  return 0;
+}
+
+/* Verify tcc1 and tcc2 variables show up only in the TLS access sequences.  */
+/* { dg-final { scan-assembler "tcc1@" { target i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-assembler "tcc2@" { target i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-assembler-not "tcc1\[^@\]" { target i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-assembler-not "tcc2\[^@\]" { target i?86-*-* x86_64-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-5.c
new file mode 100644
index 000000000..0ae9f075d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-5.c
@@ -0,0 +1,110 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls } */
+/* Sched1 moved {load_tp} pattern between strlen call and the copy
+   of the hard return value to its pseudo.  This resulted in a
+   reload abort, since the hard register was not spillable.  */
+
+extern __thread int __libc_errno __attribute__ ((tls_model ("initial-exec")));
+
+struct stat64
+  {
+    long dummy[4];
+  };
+typedef __SIZE_TYPE__ size_t;
+typedef unsigned long long uint64_t;
+typedef int __mode_t;
+
+extern size_t strlen (__const char *__s) __attribute__ ((__pure__));
+extern int strcmp (__const char *__s1, __const char *__s2)
+     __attribute__ ((__pure__));
+
+extern int __open64 (__const char *__file, int __oflag, ...);
+extern int __open (__const char *__file, int __oflag, ...);
+extern int __mkdir (__const char *__path, __mode_t __mode);
+extern int __lxstat64 (int __ver, __const char *__filename,
+                       struct stat64 *__stat_buf) ;
+
+static const char letters[] =
+"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+int
+__gen_tempname (char *tmpl, int kind)
+{
+  int len;
+  char *XXXXXX;
+  static uint64_t value;
+  uint64_t random_time_bits;
+  unsigned long count;
+  int fd = -1;
+  int save_errno = __libc_errno;
+  struct stat64 st;
+  unsigned long attempts_min = 62L * 62L * 62L;
+  unsigned long attempts = attempts_min < 238328 ? 238328 : attempts_min;
+
+  len = strlen (tmpl);
+  if (len < 6 || strcmp(&tmpl[len - 6], "XXXXXX"))
+    {
+      (__libc_errno = (22));
+      return -1;
+    }
+
+  XXXXXX = &tmpl[len - 6];
+
+  for (count = 0; count < attempts; value += 7777, ++count)
+    {
+      uint64_t v = value;
+
+      XXXXXX[0] = letters[v % 62];
+      v /= 62;
+      XXXXXX[1] = letters[v % 62];
+      v /= 62;
+      XXXXXX[2] = letters[v % 62];
+      v /= 62;
+      XXXXXX[3] = letters[v % 62];
+      v /= 62;
+      XXXXXX[4] = letters[v % 62];
+      v /= 62;
+      XXXXXX[5] = letters[v % 62];
+
+      switch (kind)
+        {
+        case 0:
+          fd = __open (tmpl, 02 | 01000 | 04000, 0400 | 0200);
+          break;
+
+        case 1:
+          fd = __open64 (tmpl, 02 | 01000 | 04000, 0400 | 0200);
+          break;
+
+        case 2:
+          fd = __mkdir (tmpl, 0400 | 0200 | 0100);
+          break;
+
+        case 3:
+          if (__lxstat64 (2, tmpl, &st) < 0)
+            {
+              if (__libc_errno == 2)
+                {
+                  (__libc_errno = (save_errno));
+                  return 0;
+                }
+              else
+
+                return -1;
+            }
+          continue;
+        }
+
+      if (fd >= 0)
+        {
+          (__libc_errno = (save_errno));
+          return fd;
+        }
+      else if (__libc_errno != 17)
+        return -1;
+    }
+
+  (__libc_errno = (17));
+  return -1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-6.c
new file mode 100644
index 000000000..8a01c019c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-6.c
@@ -0,0 +1,71 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct A
+{
+  char a;
+  int b;
+  long long c;
+};
+extern __thread struct A a1, a2, a3, a4;
+extern struct A *f1a (void);
+extern struct A *f2a (void);
+extern struct A *f3a (void);
+extern struct A *f4a (void);
+extern struct A *f5a (void);
+extern struct A *f6a (void);
+extern struct A *f7a (void);
+extern struct A *f8a (void);
+extern struct A *f9a (void);
+extern struct A *f10a (void);
+extern int f1b (void);
+extern int f2b (void);
+extern int f3b (void);
+extern int f4b (void);
+extern int f5b (void);
+extern int f6b (void);
+extern int f7b (void);
+extern int f8b (void);
+extern int f9b (void);
+extern int f10b (void);
+extern void check1 (void);
+extern void check2 (void);
+__thread int dummy = 12;
+__thread struct A local = { 1, 2, 3 };
+
+int
+main (void)
+{
+  struct A *p;
+
+  if (local.a != 1 || local.b != 2 || local.c != 3)
+    abort ();
+  if (a1.a != 4 || a1.b != 5 || a1.c != 6)
+    abort ();
+  if (a2.a != 22 || a2.b != 23 || a2.c != 24)
+    abort ();
+  if (a3.a != 10 || a3.b != 11 || a3.c != 12)
+    abort ();
+  if (a4.a != 25 || a4.b != 26 || a4.c != 27)
+    abort ();
+  check1 ();
+  check2 ();
+  if (f1a () != &a1 || f2a () != &a2 || f3a () != &a3 || f4a () != &a4)
+    abort ();
+  p = f5a (); if (p->a != 16 || p->b != 16 + 1 || p->c != 16 + 2)
+    abort ();
+  p = f6a (); if (p->a != 19 || p->b != 19 + 1 || p->c != 19 + 2)
+    abort ();
+  if (f7a () != &a2 || f8a () != &a4)
+    abort ();
+  p = f9a (); if (p->a != 28 || p->b != 28 + 1 || p->c != 28 + 2)
+    abort ();
+  p = f10a (); if (p->a != 31 || p->b != 31 + 1 || p->c != 31 + 2)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-7.c
new file mode 100644
index 000000000..d3e81f45e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-7.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fPIC" } */
+/* { dg-require-effective-target tls_native } */
+/* { dg-require-effective-target fpic } */
+
+static __thread void *baz [4] __attribute__((tls_model ("initial-exec")));
+void foo (void)
+{
+  void **u = (void **) baz;
+  
+  u[0] = 0;
+  u[1] = 0;
+}
+
+/* { dg-final { scan-assembler-not "\[48\]\\+baz" { target i?86-*-* x86_64-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-8.c
new file mode 100644
index 000000000..a73311153
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-8.c
@@ -0,0 +1,14 @@
+/* PR 18910 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls } */
+
+static __thread void *foo [2];
+void
+test1 (void)
+{
+  unsigned int s;
+
+  for (s = 0; s < 2; ++s)
+    foo [s] = &foo[s];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-9.c
new file mode 100644
index 000000000..49aa9085f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/opt-9.c
@@ -0,0 +1,9 @@
+/* PR 21412 */
+/* { dg-do compile */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O2 -fPIC" } */
+/* { dg-require-effective-target tls } */
+
+struct S { int x[10]; };
+extern __thread struct S s;
+int *foo() { return &s.x[2]; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pic-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pic-1.c
new file mode 100644
index 000000000..9108b58aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pic-1.c
@@ -0,0 +1,73 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O2 -fpic -ftls-model=global-dynamic" } */
+/* { dg-require-effective-target tls } */
+
+extern __thread long e1;
+extern __thread int e2;
+static __thread long s1;
+static __thread int s2;
+
+long *ae1 (void)
+{
+  return &e1;
+}
+
+int *ae2 (void)
+{
+  return &e2;
+}
+
+long *as1 (void)
+{
+  return &s1;
+}
+
+int *as2 (void)
+{
+  return &s2;
+}
+
+long ge1 (void)
+{
+  return e1;
+}
+
+int ge2 (void)
+{
+  return e2;
+}
+
+long gs1 (void)
+{
+  return s1;
+}
+
+int gs2 (void)
+{
+  return s2;
+}
+
+long ge3 (void)
+{
+  return e1 + e2;
+}
+
+long gs3 (void)
+{
+  return s1 + s2;
+}
+
+long ge4 (void)
+{
+  if (0)
+    return e1;
+  return e2;
+}
+
+long gs4 (void)
+{
+  if (0)
+    return s1;
+  return s2;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pr24428-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pr24428-2.c
new file mode 100644
index 000000000..a0ceecc06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pr24428-2.c
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls_runtime } */
+
+__thread double thrtest[81];
+int main ()
+{
+  double *p, *e;
+  e = &thrtest[81];
+  for (p = &thrtest[0]; p < e; ++p)
+    *p = 1.0;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pr24428.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pr24428.c
new file mode 100644
index 000000000..ecb747ede
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/pr24428.c
@@ -0,0 +1,12 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target tls_runtime } */
+
+__thread double thrtest[81];
+int main ()
+{
+  int i;
+  for (i = 0; i < 81; i++)
+    thrtest[i] = 1.0;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/section-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/section-1.c
new file mode 100644
index 000000000..1ca2ffb90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/section-1.c
@@ -0,0 +1,12 @@
+/* Verify that we get errors for trying to put TLS data in 
+   sections which can't work.  */
+/* { dg-require-effective-target tls_native } */
+
+#define A(X)	__attribute__((section(X)))
+
+__thread int i A("foo");		/* Ok */
+
+__thread int j A(".data");  /* { dg-error "causes a section type conflict" "conflict with .data section" { xfail *-*-* } } */
+
+int k A("bar");
+__thread int l A("bar");  /* { dg-error "causes a section type conflict" "conflict with user-defined section" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/section-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/section-2.c
new file mode 100644
index 000000000..8f11def96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/section-2.c
@@ -0,0 +1,8 @@
+/* Verify that we get errors for trying to put TLS data in 
+   sections which can't work.  */
+/* { dg-require-effective-target tls } */
+/* { dg-do compile { target *-*-vxworks } } */
+
+#define A(X)	__attribute__((section(X)))
+
+__thread int i A("foo"); /* { dg-error "cannot be overridden" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/struct-1.c
new file mode 100644
index 000000000..fbe3e3c10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/struct-1.c
@@ -0,0 +1,34 @@
+/* This testcase ICEd on IA-32 because the backend was inconsistent whether
+   to allow addends for @dtpoff relocs or not.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-O2 -fpic" } */
+/* { dg-require-effective-target tls } */
+
+struct S {
+  int s0, s1, s2, s3;
+};
+static __thread struct S x;
+extern void abort (void);
+extern void exit (int);
+
+void
+foo (struct S *s)
+{
+  s->s2 = 231;
+}
+
+void
+bar (void)
+{
+  if (x.s0 == 231 || x.s2 != 231)
+    abort ();
+}
+
+int
+main ()
+{
+  foo (&x);
+  bar ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/tls.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/tls.exp
new file mode 100644
index 000000000..890e05e55
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/tls.exp
@@ -0,0 +1,36 @@
+#   Copyright (C) 2002, 2005, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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-4.4.3/gcc/testsuite/gcc.dg/tls/trivial.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/trivial.c
new file mode 100644
index 000000000..96b8e49a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tls/trivial.c
@@ -0,0 +1,3 @@
+/* { dg-require-effective-target tls } */
+
+__thread int i;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/20080716-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/20080716-1.c
new file mode 100644
index 000000000..91fcd2b00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/20080716-1.c
@@ -0,0 +1,58 @@
+/* { dg-do run } */
+/* { dg-require-effective-target lp64 } */
+
+typedef unsigned long size_t;
+struct tree_base
+{
+  int code;
+};
+struct tree_decl_minimal
+{
+  struct tree_base base;
+  const char *name;
+};
+typedef union tree_node {
+  struct tree_base base;
+  struct tree_decl_minimal decl_minimal;
+} *tree;
+struct tree_overload
+{
+  struct tree_base common;
+  tree function;
+};
+typedef struct VEC_tree_base { unsigned num; unsigned alloc; tree vec[1]; } VEC_tree_base;
+typedef struct VEC_tree_gc { VEC_tree_base base; } VEC_tree_gc;
+static __inline__ unsigned VEC_tree_base_length (const VEC_tree_base *vec_)
+{ return vec_ ? vec_->num : 0; }
+static __inline__ int VEC_tree_base_iterate (const VEC_tree_base *vec_, unsigned ix_, tree *ptr)
+{
+  if (vec_ && ix_ < vec_->num) { *ptr = vec_->vec[ix_]; return 1; } else { *ptr = 0; return 0; }
+} 
+extern void abort (void);
+void __attribute__((noinline)) foo (size_t x)
+{
+  if (x != 18446744073709551614UL)
+    abort ();
+}
+void
+resort_type_method_vec (VEC_tree_gc *method_vec)
+{
+  int len = (VEC_tree_base_length(((method_vec) ? &(method_vec)->base : 0)));
+  size_t slot;
+  tree fn;
+
+  for (slot = 2;
+       (VEC_tree_base_iterate(((method_vec) ? &(method_vec)->base : 0),slot,&(fn)));
+       ++slot)
+    if (!(((((((fn)->base.code) == 225) ? (((struct tree_overload*)(fn))->function) : (fn)))->decl_minimal.name)))
+      break;
+
+  if (len - slot > 1)
+    foo (len - slot);
+}
+
+int main ()
+{
+  resort_type_method_vec ((void *)0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/asm-subreg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/asm-subreg-1.c
new file mode 100644
index 000000000..b935f1344
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/asm-subreg-1.c
@@ -0,0 +1,15 @@
+/* PR middle-end/20491 */
+
+/* { dg-do compile } */
+/* { dg-skip-if "" { hppa*64*-*-* } "*" "" } */
+
+/* Combine used to introduce invalid subregs for the asm input, and
+   we'd crash later on, when removing all subregs.  */
+
+volatile unsigned short _const_32 [4] = {1,2,3,4};
+void
+evas_common_convert_yuv_420p_601_rgba()
+{
+  __asm__ __volatile__ ("" : : "X" (*_const_32));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/badshift.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/badshift.c
new file mode 100644
index 000000000..7288a3745
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/badshift.c
@@ -0,0 +1,29 @@
+/* PR rtl-optimization/20532 */
+
+/* { dg-do run } */
+/* { dg-options "" } */
+/* { dg-options "-march=i386" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+/* We used to optimize the DImode shift-by-32 to zero because in combine
+   we turned:
+
+     (v << 31) + (v << 31)
+
+   into:
+
+     (v * (((HOST_WIDE_INT)1 << 31) + ((HOST_WIDE_INT)1 << 31)))
+
+   With a 32-bit HOST_WIDE_INT, the coefficient overflowed to zero.  */
+
+unsigned long long int badshift(unsigned long long int v)
+{
+        return v << 31 << 1;
+}
+
+extern void abort ();
+
+int main() {
+  if (badshift (1) == 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c
new file mode 100644
index 000000000..bd383a2b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-attr-1.c
@@ -0,0 +1,435 @@
+/* Copyright (C) 2003, 2005  Free Software Foundation.
+
+   Verify that the `const' function attribute is applied to various
+   builtins and that these functions are optimized away by the
+   compiler under the appropriate circumstances.
+
+   Written by Kaveh Ghazi, 2003-08-04.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+
+/* These are helper macros to test combinations of functions.  We test
+   foo() != foo() with the same arguments, and expect the compiler to
+   optimize away these tests of const functions.  */
+
+/* Just test the __builtin_ functions.  */
+#define BUILTIN_TEST1(FN, TYPE) \
+extern void link_failure_builtin_##FN(void); \
+void test_builtin_##FN(TYPE x) \
+{ if (__builtin_##FN(x) != __builtin_##FN(x)) link_failure_builtin_##FN(); }
+
+/* Just test the __builtin_ functions.  */
+#define BUILTIN_TEST2(FN, TYPE) \
+extern void link_failure_builtin_##FN(void); \
+void test_builtin_##FN(TYPE x, TYPE y) \
+{ if (__builtin_##FN(x,y) != __builtin_##FN(x,y)) link_failure_builtin_##FN(); }
+
+/* Also test the regular (non-__builtin_) function.  */
+#define TEST1(FN, TYPE, RTYPE) \
+BUILTIN_TEST1(FN, TYPE) \
+extern void link_failure_##FN(void); \
+extern RTYPE FN(TYPE); \
+void test_##FN(TYPE x) { if (FN(x) != FN(x)) link_failure_##FN(); }
+
+/* Test the __builtin_ functions taking void arguments (with the "f"
+   and "l" variants).  */
+#define BUILTIN_FPTEST0(FN) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(void) \
+{ if (__builtin_##FN() != __builtin_##FN()) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(void) \
+{ if (__builtin_##FN##f() != __builtin_##FN##f()) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(void) \
+{ if (__builtin_##FN##l() != __builtin_##FN##l()) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking one FP argument (with the "f"
+   and "l" variants).  */
+#define BUILTIN_FPTEST1(FN) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(double d) \
+{ if (__builtin_##FN(d) != __builtin_##FN(d)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(float f) \
+{ if (__builtin_##FN##f(f) != __builtin_##FN##f(f)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(long double ld) \
+{ if (__builtin_##FN##l(ld) != __builtin_##FN##l(ld)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking one argument of supplied type
+   (with the "f" and "l" variants).  */
+#define BUILTIN_FPTEST1ARG(FN, TYPE) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(TYPE x) \
+{ if (__builtin_##FN(x) != __builtin_##FN(x)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(TYPE x) \
+{ if (__builtin_##FN##f(x) != __builtin_##FN##f(x)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(TYPE x) \
+{ if (__builtin_##FN##l(x) != __builtin_##FN##l(x)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking two FP arguments (with the "f"
+   and "l" variants).  */
+#define BUILTIN_FPTEST2(FN) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(double d1, double d2) \
+{ if (__builtin_##FN(d1,d2) != __builtin_##FN(d1,d2)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(float f1, float f2) \
+{ if (__builtin_##FN##f(f1,f2) != __builtin_##FN##f(f1,f2)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(long double ld1, long double ld2) \
+{ if (__builtin_##FN##l(ld1,ld2) != __builtin_##FN##l(ld1,ld2)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking two arguments, the first one
+   is of a supplied type and the second one one is of FP type (with
+   the "f" and "l" variants).  */
+#define BUILTIN_FPTEST2ARG1(FN, TYPE) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(TYPE x, double d) \
+{ if (__builtin_##FN(x,d) != __builtin_##FN(x,d)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(TYPE x, float f) \
+{ if (__builtin_##FN##f(x,f) != __builtin_##FN##f(x,f)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(TYPE x, long double ld) \
+{ if (__builtin_##FN##l(x,ld) != __builtin_##FN##l(x,ld)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking two arguments, the first one
+   is of FP type and the second one one is of a supplied type (with
+   the "f" and "l" variants).  */
+#define BUILTIN_FPTEST2ARG2(FN, TYPE) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(double d, TYPE x) \
+{ if (__builtin_##FN(d,x) != __builtin_##FN(d,x)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(float f, TYPE x) \
+{ if (__builtin_##FN##f(f,x) != __builtin_##FN##f(f,x)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(long double ld, TYPE x) \
+{ if (__builtin_##FN##l(ld,x) != __builtin_##FN##l(ld,x)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking three FP arguments (with the
+   "f" and "l" variants).  */
+#define BUILTIN_FPTEST3(FN) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(double d1, double d2, double d3) \
+{ if (__builtin_##FN(d1,d2,d3) != __builtin_##FN(d1,d2,d3)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(float f1, float f2, float f3) \
+{ if (__builtin_##FN##f(f1,f2,f3) != __builtin_##FN##f(f1,f2,f3)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(long double ld1, long double ld2, long double ld3) \
+{ if (__builtin_##FN##l(ld1,ld2,ld3) != __builtin_##FN##l(ld1,ld2,ld3)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking one complex argument (with the
+   "f" and "l" variants).  */
+#define BUILTIN_CPTEST1(FN) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(_Complex double d) \
+{ if (__builtin_##FN(d) != __builtin_##FN(d)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(_Complex float f) \
+{ if (__builtin_##FN##f(f) != __builtin_##FN##f(f)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(_Complex long double ld) \
+{ if (__builtin_##FN##l(ld) != __builtin_##FN##l(ld)) link_failure_builtin_##FN##l(); }
+
+/* Test the __builtin_ functions taking two complex arguments (with
+   the "f" and "l" variants).  */
+#define BUILTIN_CPTEST2(FN) \
+extern void link_failure_builtin_##FN(void); \
+extern void link_failure_builtin_##FN##f(void); \
+extern void link_failure_builtin_##FN##l(void); \
+void test_builtin_##FN(_Complex double d1, _Complex double d2) \
+{ if (__builtin_##FN(d1,d2) != __builtin_##FN(d1,d2)) link_failure_builtin_##FN(); } \
+void test_builtin_##FN##f(_Complex float f1, _Complex float f2) \
+{ if (__builtin_##FN##f(f1,f2) != __builtin_##FN##f(f1,f2)) link_failure_builtin_##FN##f(); } \
+void test_builtin_##FN##l(_Complex long double ld1, _Complex long double ld2) \
+{ if (__builtin_##FN##l(ld1,ld2) != __builtin_##FN##l(ld1,ld2)) link_failure_builtin_##FN##l(); }
+
+/* These macros additionally test the non-__builtin_ functions.  */
+
+/* Test the functions taking one FP argument (with the "f" and "l"
+   variants) and returning that type.  */
+#define FPTEST1(FN) \
+BUILTIN_FPTEST1(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(double); \
+extern float FN##f(float); \
+extern long double FN##l(long double); \
+void test_##FN(double d) \
+{ if (FN(d) != FN(d)) link_failure_##FN(); } \
+void test_##FN##f(float f) \
+{ if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
+void test_##FN##l(long double ld) \
+{ if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking one FP argument (with the "f" and "l"
+   variants) and returning TYPE.  */
+#define FPTEST1T(FN, TYPE) \
+BUILTIN_FPTEST1(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern TYPE FN(double); \
+extern TYPE FN##f(float); \
+extern TYPE FN##l(long double); \
+void test_##FN(double d) \
+{ if (FN(d) != FN(d)) link_failure_##FN(); } \
+void test_##FN##f(float f) \
+{ if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
+void test_##FN##l(long double ld) \
+{ if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking two FP arguments (with the "f" and "l"
+   variants).  */
+#define FPTEST2(FN) \
+BUILTIN_FPTEST2(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(double, double); \
+extern float FN##f(float, float); \
+extern long double FN##l(long double, long double); \
+void test_##FN(double d1, double d2) \
+{ if (FN(d1,d2) != FN(d1,d2)) link_failure_##FN(); } \
+void test_##FN##f(float f1, float f2) \
+{ if (FN##f(f1,f2) != FN##f(f1,f2)) link_failure_##FN##f(); } \
+void test_##FN##l(long double ld1, long double ld2) \
+{ if (FN##l(ld1,ld2) != FN##l(ld1,ld2)) link_failure_##FN##l(); }
+
+/* Test the functions taking two arguments, the first one is of a
+   supplied type and the second one one is of FP type (with the "f"
+   and "l" variants).  */
+#define FPTEST2ARG1(FN, TYPE) \
+BUILTIN_FPTEST2ARG1(FN, TYPE) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(TYPE, double); \
+extern float FN##f(TYPE, float); \
+extern long double FN##l(TYPE, long double); \
+void test_##FN(TYPE x, double d) \
+{ if (FN(x,d) != FN(x,d)) link_failure_##FN(); } \
+void test_##FN##f(TYPE x, float f) \
+{ if (FN##f(x,f) != FN##f(x,f)) link_failure_##FN##f(); } \
+void test_##FN##l(TYPE x, long double ld) \
+{ if (FN##l(x,ld) != FN##l(x,ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking two arguments, the first one is of FP
+   type and the second one one is of a supplied type (with the "f" and
+   "l" variants).  */
+#define FPTEST2ARG2(FN, TYPE) \
+BUILTIN_FPTEST2ARG2(FN, TYPE) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(double, TYPE); \
+extern float FN##f(float, TYPE); \
+extern long double FN##l(long double, TYPE); \
+void test_##FN(double d, TYPE x) \
+{ if (FN(d,x) != FN(d,x)) link_failure_##FN(); } \
+void test_##FN##f(float f, TYPE x) \
+{ if (FN##f(f,x) != FN##f(f,x)) link_failure_##FN##f(); } \
+void test_##FN##l(long double ld, TYPE x) \
+{ if (FN##l(ld,x) != FN##l(ld,x)) link_failure_##FN##l(); }
+
+/* Test the functions taking three FP arguments (with the "f" and "l"
+   variants).  */
+#define FPTEST3(FN) \
+BUILTIN_FPTEST3(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(double, double, double); \
+extern float FN##f(float, float, float); \
+extern long double FN##l(long double, long double, long double); \
+void test_##FN(double d1, double d2, double d3) \
+{ if (FN(d1,d2,d3) != FN(d1,d2,d3)) link_failure_##FN(); } \
+void test_##FN##f(float f1, float f2, float f3) \
+{ if (FN##f(f1,f2,f3) != FN##f(f1,f2,f3)) link_failure_##FN##f(); } \
+void test_##FN##l(long double ld1, long double ld2, long double ld3) \
+{ if (FN##l(ld1,ld2,ld3) != FN##l(ld1,ld2,ld3)) link_failure_##FN##l(); }
+
+/* Test the functions taking one complex argument (with the "f" and
+   "l" variants) and returning that type.  */
+#define CPTEST1(FN) \
+BUILTIN_CPTEST1(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern _Complex double FN(_Complex double); \
+extern _Complex float FN##f(_Complex float); \
+extern _Complex long double FN##l(_Complex long double); \
+void test_##FN(_Complex double d) \
+{ if (FN(d) != FN(d)) link_failure_##FN(); } \
+void test_##FN##f(_Complex float f) \
+{ if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
+void test_##FN##l(_Complex long double ld) \
+{ if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking one complex argument (with the "f" and
+   "l" variants) and returning the real type.  */
+#define CPTEST1R(FN) \
+BUILTIN_CPTEST1(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern double FN(_Complex double); \
+extern float FN##f(_Complex float); \
+extern long double FN##l(_Complex long double); \
+void test_##FN(_Complex double d) \
+{ if (FN(d) != FN(d)) link_failure_##FN(); } \
+void test_##FN##f(_Complex float f) \
+{ if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
+void test_##FN##l(_Complex long double ld) \
+{ if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
+
+/* Test the functions taking two complex arguments (with the "f" and
+   "l" variants).  */
+#define CPTEST2(FN) \
+BUILTIN_CPTEST2(FN) \
+extern void link_failure_##FN(void); \
+extern void link_failure_##FN##f(void); \
+extern void link_failure_##FN##l(void); \
+extern _Complex double FN(_Complex double, _Complex double); \
+extern _Complex float FN##f(_Complex float, _Complex float); \
+extern _Complex long double FN##l(_Complex long double, _Complex long double); \
+void test_##FN(_Complex double d1, _Complex double d2) \
+{ if (FN(d1,d2) != FN(d1,d2)) link_failure_##FN(); } \
+void test_##FN##f(_Complex float f1, _Complex float f2) \
+{ if (FN##f(f1,f2) != FN##f(f1,f2)) link_failure_##FN##f(); } \
+void test_##FN##l(_Complex long double ld1, _Complex long double ld2) \
+{ if (FN##l(ld1,ld2) != FN##l(ld1,ld2)) link_failure_##FN##l(); }
+
+
+/* Test the math builtins.  */
+FPTEST1            (acos)
+FPTEST1            (acosh)
+FPTEST1            (asin)
+FPTEST1            (asinh)
+FPTEST1            (atan)
+FPTEST2            (atan2)
+FPTEST1            (atanh)
+FPTEST1            (cbrt)
+FPTEST1            (ceil)
+FPTEST2            (copysign)
+FPTEST1            (cos)
+FPTEST1            (cosh)
+FPTEST2            (drem)
+FPTEST1            (erf)
+FPTEST1            (erfc)
+FPTEST1            (exp)
+FPTEST1            (exp10)
+FPTEST1            (exp2)
+FPTEST1            (expm1)
+FPTEST1            (fabs)
+FPTEST2            (fdim)
+FPTEST1            (floor)
+FPTEST3            (fma)
+FPTEST2            (fmax)
+FPTEST2            (fmin)
+FPTEST2            (fmod)
+BUILTIN_FPTEST0    (huge_val)
+FPTEST2            (hypot)
+FPTEST1T           (ilogb, int)
+BUILTIN_FPTEST0    (inf) /* { dg-warning "does not support infinity" "INF unsupported" { target vax-*-* pdp11-*-* spu-*-* } } */
+FPTEST1            (j0)
+FPTEST1            (j1)
+FPTEST2ARG1        (jn, int)
+FPTEST2ARG2        (ldexp, int)
+BUILTIN_FPTEST1    (llceil)
+BUILTIN_FPTEST1    (llfloor)
+FPTEST1T           (llrint, long long)
+FPTEST1T           (llround, long long)
+FPTEST1            (log)
+FPTEST1            (log10)
+FPTEST1            (log1p)
+FPTEST1            (log2)
+FPTEST1            (logb)
+BUILTIN_FPTEST1    (lceil)
+BUILTIN_FPTEST1    (lfloor)
+FPTEST1T           (lrint, long)
+FPTEST1T           (lround, long)
+BUILTIN_FPTEST1ARG (nan, char *)
+BUILTIN_FPTEST1ARG (nans, char *)
+FPTEST1            (nearbyint)
+FPTEST2            (nextafter)
+FPTEST2ARG2        (nexttoward, long double)
+FPTEST2            (pow)
+FPTEST1            (pow10)
+FPTEST2            (remainder)
+FPTEST1            (rint)
+FPTEST1            (round)
+FPTEST2            (scalb)
+FPTEST2ARG2        (scalbn, int)
+FPTEST2ARG2        (scalbln, long int)
+FPTEST1            (significand)
+FPTEST1            (sin)
+FPTEST1            (sinh)
+FPTEST1            (sqrt)
+FPTEST1            (tan)
+FPTEST1            (tanh)
+FPTEST1            (tgamma)
+FPTEST1            (trunc)
+FPTEST1            (y0)
+FPTEST1            (y1)
+FPTEST2ARG1        (yn, int)
+
+/* Test the complex math builtins.  */
+/*CPTEST1 (cabs) See http://gcc.gnu.org/ml/gcc-patches/2003-09/msg00040.html */
+CPTEST1 (cacos)
+CPTEST1 (cacosh)
+CPTEST1R (carg)
+CPTEST1 (casin)
+CPTEST1 (casinh)
+CPTEST1 (catan)
+CPTEST1 (catanh)
+CPTEST1 (ccos)
+CPTEST1 (ccosh)
+CPTEST1 (cexp)
+CPTEST1R (cimag)
+CPTEST1 (clog)
+CPTEST1 (conj)
+CPTEST2 (cpow)
+CPTEST1 (cproj)
+CPTEST1R (creal)
+CPTEST1 (csin)
+CPTEST1 (csinh)
+CPTEST1 (csqrt)
+CPTEST1 (ctan)
+CPTEST1 (ctanh)
+
+typedef __INTMAX_TYPE__ intmax_t;
+
+/* Various other const builtins.  */
+TEST1         (abs, int, int)
+BUILTIN_TEST1 (clz, int)
+BUILTIN_TEST1 (clzl, long)
+BUILTIN_TEST1 (clzll, long long)
+BUILTIN_TEST1 (ctz, int)
+BUILTIN_TEST1 (ctzl, long)
+BUILTIN_TEST1 (ctzll, long long)
+TEST1         (ffs, int, int)
+TEST1         (ffsl, long, int)
+TEST1         (ffsll, long long, int)
+TEST1         (imaxabs, intmax_t, intmax_t)
+TEST1         (labs, long, long)
+TEST1         (llabs, long long, long long)
+BUILTIN_TEST1 (parity, int)
+BUILTIN_TEST1 (parityl, long)
+BUILTIN_TEST1 (parityll, long long)
+BUILTIN_TEST1 (popcount, int)
+BUILTIN_TEST1 (popcountl, long)
+BUILTIN_TEST1 (popcountll, long long)
+
+int main(void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-1.c
new file mode 100644
index 000000000..f13d29e67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-1.c
@@ -0,0 +1,149 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that built-in math function conversion to smaller FP types
+   is correctly performed by the compiler.
+
+   Written by Kaveh Ghazi, 2004-03-17.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "../builtins-config.h"
+
+/* This check is necessary when converting to a C99 function.  */
+#ifdef HAVE_C99_RUNTIME
+#define C99CODE(CODE) (CODE)
+#define MAYBEC99(CODE, C99) (CODE)
+#else
+#define C99CODE(CODE) 0
+#define MAYBEC99(CODE, C99) (!(C99) && (CODE))
+#endif
+
+void test(double d1, float f1, long double ld1)
+{
+  /* Test converting math builtins to narrower FP types based on a
+     narrowing cast on the outside of the call.  MATHFN is the
+     function to test, and C99 is 0/1 depending on whether the
+     `double' version of MATHFN is a C99 function.  The optimization
+     is only performed if the replacement function is actually
+     narrower in width, so check that first.  */
+#define OUTER_CAST1(MATHFN, C99) \
+ extern void link_failure_outer_##MATHFN##l_##MATHFN##_1(void); \
+ extern void link_failure_outer_##MATHFN##l_##MATHFN##_2(void); \
+ extern void link_failure_outer_##MATHFN##l_##MATHFN##f_1(void); \
+ extern void link_failure_outer_##MATHFN##l_##MATHFN##f_2(void); \
+ extern void link_failure_outer_##MATHFN##_##MATHFN##f_1(void); \
+ extern void link_failure_outer_##MATHFN##_##MATHFN##f_2(void); \
+ if (sizeof (long double) > sizeof (double) \
+     && MAYBEC99 ((double) __builtin_##MATHFN##l((double)ld1) != __builtin_##MATHFN(ld1), C99)) \
+    link_failure_outer_##MATHFN##l_##MATHFN##_1(); \
+ if (sizeof (long double) > sizeof (double) \
+     && MAYBEC99 ((double) __builtin_##MATHFN##l(d1) != __builtin_##MATHFN(d1), C99)) \
+    link_failure_outer_##MATHFN##l_##MATHFN##_1(); \
+ if (sizeof (long double) > sizeof (double) \
+     && MAYBEC99 ((double) __builtin_##MATHFN##l(f1) != __builtin_##MATHFN(f1), C99)) \
+    link_failure_outer_##MATHFN##l_##MATHFN##_2(); \
+ if (sizeof (long double) > sizeof (float) \
+     && C99CODE ((float) __builtin_##MATHFN##l((float) ld1) != __builtin_##MATHFN##f(ld1))) \
+    link_failure_outer_##MATHFN##l_##MATHFN##f_1(); \
+ if (sizeof (long double) > sizeof (float) \
+     && C99CODE ((float) __builtin_##MATHFN##l((float) d1) != __builtin_##MATHFN##f(d1))) \
+    link_failure_outer_##MATHFN##l_##MATHFN##f_1(); \
+ if (sizeof (long double) > sizeof (float) \
+     && C99CODE ((float) __builtin_##MATHFN##l(f1) != __builtin_##MATHFN##f(f1))) \
+    link_failure_outer_##MATHFN##l_##MATHFN##f_2(); \
+ if (sizeof (double) > sizeof (float) \
+     && C99CODE ((float) __builtin_##MATHFN((float) ld1) != __builtin_##MATHFN##f(ld1))) \
+    link_failure_outer_##MATHFN##_##MATHFN##f_1(); \
+ if (sizeof (double) > sizeof (float) \
+     && C99CODE ((float) __builtin_##MATHFN((float) d1) != __builtin_##MATHFN##f(d1))) \
+    link_failure_outer_##MATHFN##_##MATHFN##f_1(); \
+ if (sizeof (double) > sizeof (float) \
+     && C99CODE ((float) __builtin_##MATHFN(f1) != __builtin_##MATHFN##f(f1))) \
+    link_failure_outer_##MATHFN##_##MATHFN##f_2()
+
+  /* Test converting math builtins to narrower FP types based on if
+     the argument is a narrower type (perhaps implicitly) cast to a
+     wider one.  */
+#define INNER_CAST1(MATHFN, C99) \
+ extern void link_failure_inner_##MATHFN##l_##MATHFN(void); \
+ extern void link_failure_inner_##MATHFN##l_##MATHFN##f(void); \
+ extern void link_failure_inner_##MATHFN##_##MATHFN##f(void); \
+ if (sizeof (long double) > sizeof (double) \
+     && MAYBEC99 (__builtin_##MATHFN##l(d1) != (long double) __builtin_##MATHFN(d1), C99)) \
+    link_failure_inner_##MATHFN##l_##MATHFN(); \
+ if (sizeof (long double) > sizeof (float) \
+     && C99CODE (__builtin_##MATHFN##l(f1) != (long double) __builtin_##MATHFN##f(f1))) \
+    link_failure_inner_##MATHFN##l_##MATHFN##f(); \
+ if (sizeof (long double) > sizeof (float) \
+     && C99CODE (__builtin_##MATHFN##l((double)f1) != (long double) __builtin_##MATHFN##f(f1))) \
+    link_failure_inner_##MATHFN##l_##MATHFN##f(); \
+ if (sizeof (double) > sizeof (float) \
+     && C99CODE (__builtin_##MATHFN(f1) != (double) __builtin_##MATHFN##f(f1))) \
+    link_failure_inner_##MATHFN##_##MATHFN##f()
+
+
+#ifdef __OPTIMIZE__
+  OUTER_CAST1 (acos, /*C99=*/ 0);
+  OUTER_CAST1 (acosh, /*C99=*/ 1);
+  OUTER_CAST1 (asin, /*C99=*/ 1);
+  OUTER_CAST1 (asinh, /*C99=*/ 1);
+  OUTER_CAST1 (atan, /*C99=*/ 0);
+  OUTER_CAST1 (atanh, /*C99=*/ 1);
+  OUTER_CAST1 (cbrt, /*C99=*/ 1);
+  OUTER_CAST1 (cos, /*C99=*/ 0);
+  OUTER_CAST1 (cosh, /*C99=*/ 0);
+  OUTER_CAST1 (erf, /*C99=*/ 1);
+  OUTER_CAST1 (erfc, /*C99=*/ 1);
+  OUTER_CAST1 (exp, /*C99=*/ 0);
+  OUTER_CAST1 (exp2, /*C99=*/ 1);
+  OUTER_CAST1 (expm1, /*C99=*/ 1);
+  OUTER_CAST1 (fabs, /*C99=*/ 0);
+  OUTER_CAST1 (log, /*C99=*/ 0);
+  OUTER_CAST1 (log10, /*C99=*/ 0);
+  OUTER_CAST1 (log1p, /*C99=*/ 1);
+  OUTER_CAST1 (log2, /*C99=*/ 1);
+  OUTER_CAST1 (logb, /*C99=*/ 1);
+  OUTER_CAST1 (sin, /*C99=*/ 0);
+  OUTER_CAST1 (sinh, /*C99=*/ 0);
+  OUTER_CAST1 (sqrt, /*C99=*/ 0);
+  OUTER_CAST1 (tan, /*C99=*/ 0);
+  OUTER_CAST1 (tanh, /*C99=*/ 0);
+  OUTER_CAST1 (tgamma, /*C99=*/ 1);
+
+  INNER_CAST1 (ceil, /*C99=*/ 0);
+  OUTER_CAST1 (ceil, /*C99=*/ 0);
+  INNER_CAST1 (floor, /*C99=*/ 0);
+  OUTER_CAST1 (floor, /*C99=*/ 0);
+  INNER_CAST1 (lceil, /*C99=*/ 1);
+  OUTER_CAST1 (lceil, /*C99=*/ 1);
+  INNER_CAST1 (lfloor, /*C99=*/ 1);
+  OUTER_CAST1 (lfloor, /*C99=*/ 1);
+  INNER_CAST1 (lrint, /*C99=*/ 1);
+  OUTER_CAST1 (lrint, /*C99=*/ 1);
+  INNER_CAST1 (lround, /*C99=*/ 1);
+  OUTER_CAST1 (lround, /*C99=*/ 1);
+  INNER_CAST1 (llceil, /*C99=*/ 1);
+  OUTER_CAST1 (llceil, /*C99=*/ 1);
+  INNER_CAST1 (llfloor, /*C99=*/ 1);
+  OUTER_CAST1 (llfloor, /*C99=*/ 1);
+  INNER_CAST1 (llrint, /*C99=*/ 1);
+  OUTER_CAST1 (llrint, /*C99=*/ 1);
+  INNER_CAST1 (llround, /*C99=*/ 1);
+  OUTER_CAST1 (llround, /*C99=*/ 1);
+  INNER_CAST1 (nearbyint, /*C99=*/ 1);
+  OUTER_CAST1 (nearbyint, /*C99=*/ 1);
+  INNER_CAST1 (rint, /*C99=*/ 1);
+  OUTER_CAST1 (rint, /*C99=*/ 1);
+  INNER_CAST1 (round, /*C99=*/ 1);
+  OUTER_CAST1 (round, /*C99=*/ 1);
+  INNER_CAST1 (trunc, /*C99=*/ 1);
+  OUTER_CAST1 (trunc, /*C99=*/ 1);
+#endif /* __OPTIMIZE__ */
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-2.c
new file mode 100644
index 000000000..167ecddcb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-2.c
@@ -0,0 +1,78 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that built-in math function conversion into integer rounding
+   functions is correctly performed by the compiler.
+
+   Written by Kaveh ghazi, 2004-04-26.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "../builtins-config.h"
+
+/* Macro to do all FP type combinations.  The second half tests
+   narrowing the FP type.  */
+#define TEST_FP2FIXED(FN1, FN2) \
+  extern void link_error_##FN1##_##FN2(void); \
+  extern void link_error_##FN1##f_##FN2##f(void); \
+  extern void link_error_##FN1##l_##FN2##l(void); \
+  extern void link_error_##FN1##_l##FN2(void); \
+  extern void link_error_##FN1##f_l##FN2##f(void); \
+  extern void link_error_##FN1##l_l##FN2##l(void); \
+  if ((long)__builtin_##FN1(d) != __builtin_##FN2(d)) \
+    link_error_##FN1##_##FN2(); \
+  if ((long)__builtin_##FN1##f(f) != __builtin_##FN2##f(f)) \
+    link_error_##FN1##f_##FN2##f(); \
+  if ((long)__builtin_##FN1##l(ld) != __builtin_##FN2##l(ld)) \
+    link_error_##FN1##l_##FN2##l(); \
+  if ((long long)__builtin_##FN1(d) != __builtin_l##FN2(d)) \
+    link_error_##FN1##_l##FN2(); \
+  if ((long long)__builtin_##FN1##f(f) != __builtin_l##FN2##f(f)) \
+    link_error_##FN1##f_l##FN2##f(); \
+  if ((long long)__builtin_##FN1##l(ld) != __builtin_l##FN2##l(ld)) \
+    link_error_##FN1##l_l##FN2##l(); \
+  extern void link_error_##FN1##_##FN2##f(void); \
+  extern void link_error_##FN1##l_##FN2(void); \
+  extern void link_error_##FN1##l_##FN2##f(void); \
+  extern void link_error_##FN1##_l##FN2##f(void); \
+  extern void link_error_##FN1##l_l##FN2(void); \
+  extern void link_error_##FN1##l_l##FN2##f(void); \
+  if (sizeof(double) > sizeof(float) \
+      && (long)__builtin_##FN1(f) != __builtin_##FN2##f(f)) \
+    link_error_##FN1##_##FN2##f(); \
+  if (sizeof(long double) > sizeof(double) \
+      && (long)__builtin_##FN1##l(d) != __builtin_##FN2(d)) \
+    link_error_##FN1##l_##FN2(); \
+  if (sizeof(long double) > sizeof(float) \
+      && (long)__builtin_##FN1##l(f) != __builtin_##FN2##f(f)) \
+    link_error_##FN1##l_##FN2##f(); \
+  if (sizeof(double) > sizeof(float) \
+      && (long long)__builtin_##FN1(f) != __builtin_l##FN2##f(f)) \
+    link_error_##FN1##_l##FN2##f(); \
+  if (sizeof(long double) > sizeof(double) \
+      && (long long)__builtin_##FN1##l(d) != __builtin_l##FN2(d)) \
+    link_error_##FN1##l_l##FN2(); \
+  if (sizeof(long double) > sizeof(float) \
+      && (long long)__builtin_##FN1##l(f) != __builtin_l##FN2##f(f)) \
+    link_error_##FN1##l_l##FN2##f()
+
+void __attribute__ ((__noinline__)) foo (double d, float f, long double ld)
+{
+#ifdef __OPTIMIZE__
+# ifdef HAVE_C99_RUNTIME
+  /* The resulting transformation functions are all C99.  */
+  TEST_FP2FIXED (ceil, lceil);
+  TEST_FP2FIXED (floor, lfloor);
+  TEST_FP2FIXED (round, lround);
+  TEST_FP2FIXED (nearbyint, lrint);
+  TEST_FP2FIXED (rint, lrint);
+# endif
+#endif
+}
+
+int main()
+{
+  foo (1.0, 2.0, 3.0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-3.c
new file mode 100644
index 000000000..2034b4190
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-3.c
@@ -0,0 +1,61 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that builtin math functions (with fixed point return types)
+   are converted to smaller FP types correctly by the compiler.
+
+   Written by Kaveh Ghazi, 2004-05-01.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "../builtins-config.h"
+
+#define PROTOTYPE1_RET(FN, RET) \
+  extern RET FN(double); \
+  extern RET FN##f(float); \
+  extern RET FN##l(long double);
+
+/* Test converting math builtins to narrower FP types based on if the
+   argument is a narrower type (perhaps implicitly) cast to a wider
+   one.  */
+#define INNER_CAST1(MATHFN, RET) \
+ PROTOTYPE1_RET (MATHFN, RET); \
+ extern void link_failure_inner_##MATHFN##l_##MATHFN(void); \
+ extern void link_failure_inner_##MATHFN##l_##MATHFN##f(void); \
+ extern void link_failure_inner_##MATHFN##_##MATHFN##f(void); \
+ if (sizeof (long double) > sizeof (double) \
+     && MATHFN##l(d1) != MATHFN(d1)) \
+    link_failure_inner_##MATHFN##l_##MATHFN(); \
+ if (sizeof (long double) > sizeof (float) \
+     && MATHFN##l(f1) != MATHFN##f(f1)) \
+    link_failure_inner_##MATHFN##l_##MATHFN##f(); \
+ if (sizeof (long double) > sizeof (float) \
+     && MATHFN##l((double)f1) != MATHFN##f(f1)) \
+    link_failure_inner_##MATHFN##l_##MATHFN##f(); \
+ if (sizeof (double) > sizeof (float) \
+     && MATHFN(f1) != MATHFN##f(f1)) \
+    link_failure_inner_##MATHFN##_##MATHFN##f()
+
+void __attribute__ ((__noinline__)) test (double d1, float f1)
+{
+#ifdef __OPTIMIZE__
+#ifdef HAVE_C99_RUNTIME
+  /* We're converting to implicitly generated C99 functions.  */
+  INNER_CAST1 (__builtin_lceil, long);
+  INNER_CAST1 (__builtin_llceil, long long);
+  INNER_CAST1 (__builtin_lfloor, long);
+  INNER_CAST1 (__builtin_llfloor, long long);
+  INNER_CAST1 (lround, long);
+  INNER_CAST1 (llround, long long);
+  INNER_CAST1 (lrint, long);
+  INNER_CAST1 (llrint, long long);
+#endif /* HAVE_C99_RUNTIME */
+#endif /* __OPTIMIZE__ */
+}
+
+int main (void)
+{
+  test (1, 2);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-4.c
new file mode 100644
index 000000000..3dc47ad1e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-convert-4.c
@@ -0,0 +1,36 @@
+/* Copyright (C) 2007  Free Software Foundation.
+
+   Verify that nearbyint isn't transformed into e.g. rint or lrint
+   when -ftrapping-math is set.
+
+   Written by Kaveh ghazi, 2007-03-04.  */
+
+/* { dg-do compile } */
+/* { dg-options "-ftrapping-math -fdump-tree-original" } */
+/* { dg-add-options c99_runtime } */
+
+#include "../builtins-config.h"
+
+extern void bar (long);
+
+#define TESTIT(FUNC) do { \
+  bar (__builtin_##FUNC(d)); \
+  bar (__builtin_##FUNC##f(f)); \
+  bar (__builtin_##FUNC##l(ld)); \
+} while (0)
+
+void __attribute__ ((__noinline__)) foo (double d, float f, long double ld)
+{
+  TESTIT(nearbyint);
+}
+
+int main()
+{
+  foo (1.0, 2.0, 3.0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "nearbyint " 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "nearbyintf" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "nearbyintl" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c
new file mode 100644
index 000000000..ad6fc1c60
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c
@@ -0,0 +1,44 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that built-in ctype function attributes are correctly set by
+   the compiler.
+
+   Written by Kaveh Ghazi, 2004-03-23.  */
+
+/* { dg-do link } */
+
+
+void test(int i)
+{
+  /* All of these ctype functions should be const/pure and thus
+     eliminated.  */
+#define TEST_CTYPE(FN) \
+  extern int FN(int); \
+  extern void link_failure_##FN(void); \
+  if (FN(i) != FN(i)) \
+    link_failure_##FN()
+  
+#ifdef __OPTIMIZE__
+  TEST_CTYPE(isalnum);
+  TEST_CTYPE(isalpha);
+  TEST_CTYPE(isascii);
+  TEST_CTYPE(isblank);
+  TEST_CTYPE(iscntrl);
+  TEST_CTYPE(isdigit);
+  TEST_CTYPE(isgraph);
+  TEST_CTYPE(islower);
+  TEST_CTYPE(isprint);
+  TEST_CTYPE(ispunct);
+  TEST_CTYPE(isspace);
+  TEST_CTYPE(isupper);
+  TEST_CTYPE(isxdigit);
+  TEST_CTYPE(toascii);
+  TEST_CTYPE(tolower);
+  TEST_CTYPE(toupper);
+#endif /* __OPTIMIZE__ */
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c
new file mode 100644
index 000000000..7046aad65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c
@@ -0,0 +1,107 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that built-in ctype transformations are done correctly by
+   the compiler.
+
+   Written by Kaveh Ghazi, 2004-04-05.  */
+
+/* { dg-do link } */
+
+extern void link_failure_var(void);
+
+void test(int i)
+{
+  /* All of these ctype calls should compile-time evaluate to true.  */
+#define TEST_CTYPE_CST_TRUE(FN, VALUE) \
+  extern void link_failure_##FN##_cst_true(void); \
+  extern int FN(int); \
+  if (! FN(VALUE)) \
+    link_failure_##FN##_cst_true()
+
+  /* All of these ctype calls should compile-time evaluate to false.  */
+#define TEST_CTYPE_CST_FALSE(FN, VALUE) \
+  extern void link_failure_##FN##_cst_false(void); \
+  extern int FN(int); \
+  if (FN(VALUE)) \
+    link_failure_##FN##_cst_false()
+  
+  /* All of these ctype calls should compile-time evaluate to true.  */
+#define TEST_TOCTYPE_CST_TRUE(FN, VALUE) \
+  extern void link_failure_##FN##_cst_true(void); \
+  extern int FN(int); \
+  if (FN(VALUE) != (VALUE)) \
+    link_failure_##FN##_cst_true()
+
+  /* All of these ctype calls should compile-time evaluate to false.  */
+#define TEST_TOCTYPE_CST_FALSE(FN, VALUE) \
+  extern void link_failure_##FN##_cst_false(void); \
+  extern int FN(int); \
+  if (FN(VALUE) == (VALUE)) \
+    link_failure_##FN##_cst_false()
+  
+#ifdef __OPTIMIZE__
+  TEST_CTYPE_CST_TRUE (isascii, 0);
+  TEST_CTYPE_CST_TRUE (isascii, 1);
+  TEST_CTYPE_CST_TRUE (isascii, 126);
+  TEST_CTYPE_CST_TRUE (isascii, 127);
+
+  TEST_CTYPE_CST_FALSE (isascii, -1);
+  TEST_CTYPE_CST_FALSE (isascii, 128);
+  TEST_CTYPE_CST_FALSE (isascii, 129);
+  TEST_CTYPE_CST_FALSE (isascii, 255);
+  TEST_CTYPE_CST_FALSE (isascii, 256);
+  TEST_CTYPE_CST_FALSE (isascii, 257);
+  TEST_CTYPE_CST_FALSE (isascii, 10000);
+  TEST_CTYPE_CST_FALSE (isascii, __INT_MAX__);
+  
+  /* This ctype call should transform into another expression.  */
+  if (isascii(i) != ((i & ~0x7f) == 0))
+    link_failure_var();
+
+  TEST_TOCTYPE_CST_TRUE (toascii, 0);
+  TEST_TOCTYPE_CST_TRUE (toascii, 1);
+  TEST_TOCTYPE_CST_TRUE (toascii, 126);
+  TEST_TOCTYPE_CST_TRUE (toascii, 127);
+
+  TEST_TOCTYPE_CST_FALSE (toascii, -1);
+  TEST_TOCTYPE_CST_FALSE (toascii, 128);
+  TEST_TOCTYPE_CST_FALSE (toascii, 129);
+  TEST_TOCTYPE_CST_FALSE (toascii, 255);
+  TEST_TOCTYPE_CST_FALSE (toascii, 256);
+  TEST_TOCTYPE_CST_FALSE (toascii, 10000);
+  TEST_TOCTYPE_CST_FALSE (toascii, __INT_MAX__);
+
+  /* This ctype call should transform into another expression.  */
+  if (toascii(i) != (i & 0x7f))
+    link_failure_var();
+
+  TEST_CTYPE_CST_TRUE (isdigit, '0');
+  TEST_CTYPE_CST_TRUE (isdigit, '1');
+  TEST_CTYPE_CST_TRUE (isdigit, '2');
+  TEST_CTYPE_CST_TRUE (isdigit, '3');
+  TEST_CTYPE_CST_TRUE (isdigit, '4');
+  TEST_CTYPE_CST_TRUE (isdigit, '5');
+  TEST_CTYPE_CST_TRUE (isdigit, '6');
+  TEST_CTYPE_CST_TRUE (isdigit, '7');
+  TEST_CTYPE_CST_TRUE (isdigit, '8');
+  TEST_CTYPE_CST_TRUE (isdigit, '9');
+
+  TEST_CTYPE_CST_FALSE (isdigit, '0'-1);
+  TEST_CTYPE_CST_FALSE (isdigit, '9'+1);
+  TEST_CTYPE_CST_FALSE (isdigit, -1);
+  TEST_CTYPE_CST_FALSE (isdigit, 0);
+  TEST_CTYPE_CST_FALSE (isdigit, 255);
+  TEST_CTYPE_CST_FALSE (isdigit, 256);
+  TEST_CTYPE_CST_FALSE (isdigit, 10000);
+  TEST_CTYPE_CST_FALSE (isdigit, __INT_MAX__);
+  
+  /* This ctype call should transform into another expression.  */
+  if (isdigit(i) != ((unsigned)i - '0' <= 9))
+    link_failure_var();
+#endif /* __OPTIMIZE__ */
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c
new file mode 100644
index 000000000..4d7de84cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-explog-1.c
@@ -0,0 +1,233 @@
+/* Copyright (C) 2003, 2004  Free Software Foundation.
+
+   Verify that built-in math function constant folding of log & exp is
+   correctly performed by the compiler.
+
+   Written by Kaveh Ghazi, 2003-09-05.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+
+/* Define "e" with as many bits as found in builtins.c:dconste.  */
+#define M_E  2.7182818284590452353602874713526624977572470936999595749669676277241
+#define M_EF 2.7182818284590452353602874713526624977572470936999595749669676277241F
+#define M_EL 2.7182818284590452353602874713526624977572470936999595749669676277241L
+/* Precision for comparison tests.  */
+#define PREC  (sizeof (float) < sizeof (double) ? 0.0000001 : PRECF)
+#define PRECF 0.0001F
+#define PRECL (sizeof (float) < sizeof (long double)	\
+	       ? 0.0000000000001L : PRECF)
+#define PROTOTYPE(FN) extern double FN(double); extern float FN##f(float); \
+  extern long double FN##l(long double);
+#define PROTOTYPE2(FN) extern double FN(double, double); \
+  extern float FN##f(float, float); \
+  extern long double FN##l(long double, long double);
+
+PROTOTYPE(exp)
+PROTOTYPE(exp2)
+PROTOTYPE(exp10)
+PROTOTYPE(log)
+PROTOTYPE(log2)
+PROTOTYPE(log10)
+PROTOTYPE(pow10)
+PROTOTYPE(sqrt)
+PROTOTYPE(cbrt)
+PROTOTYPE2(pow)
+
+void test(double d1, double d2, float f1, float f2,
+	  long double ld1, long double ld2)
+{
+  /* Test logN(1) -> 0.  */
+#define LOG_1(LOG) \
+ extern void link_failure_##LOG##_1(void); \
+ if (LOG(1.0) != 0.0 || LOG##f(1.0F) != 0.0F || LOG##l(1.0L) != 0.0L) \
+    link_failure_##LOG##_1()
+
+  LOG_1(log);
+  LOG_1(log2);
+  LOG_1(log10);
+  
+  /* Test logN(N) -> 1.  */
+#define LOG_N(LOG, BASE) \
+ extern void link_failure_##LOG##_N(void); \
+ if (LOG(BASE) != 1.0 || LOG##f(BASE##F) != 1.0F || LOG##l(BASE##L) != 1.0L) \
+    link_failure_##LOG##_N()
+
+  LOG_N(log, M_E);
+  LOG_N(log2, 2.0);
+  LOG_N(log10, 10.0);
+
+  /* Test logN(expN(x)) -> x.  */
+#define LOGEXP_SAME(LOG, EXP) \
+ extern void link_failure_##LOG##_##EXP##_same(void); \
+ if (LOG(EXP(d1)) != d1 || LOG##f(EXP##f(f1)) != f1 \
+  || LOG##l(EXP##l(ld1)) != ld1) link_failure_##LOG##_##EXP##_same()
+
+  LOGEXP_SAME(log,exp);
+  LOGEXP_SAME(log2,exp2);
+  LOGEXP_SAME(log10,exp10);
+  LOGEXP_SAME(log10,pow10);
+
+  /* Test logN(expM(x)) -> x*logN(M).  */
+#define LOGEXP(LOG, EXP, BASE) \
+ extern void link_failure_##LOG##_##EXP(void); \
+ if (LOG(EXP(d1)) != d1*LOG(BASE) || LOG##f(EXP##f(f1)) != f1*LOG##f(BASE##F) \
+  || LOG##l(EXP##l(ld1)) != ld1*LOG##l(BASE##L)) link_failure_##LOG##_##EXP()
+
+  LOGEXP(log,exp,M_E);
+  LOGEXP(log,exp2,2.0);
+  LOGEXP(log,exp10,10.0);
+  LOGEXP(log,pow10,10.0);
+  LOGEXP(log2,exp,M_E);
+  LOGEXP(log2,exp2,2.0);
+  LOGEXP(log2,exp10,10.0);
+  LOGEXP(log2,pow10,10.0);
+  LOGEXP(log10,exp,M_E);
+  LOGEXP(log10,exp2,2.0);
+  LOGEXP(log10,exp10,10.0);
+  LOGEXP(log10,pow10,10.0);
+  
+  /* Test logN(sqrt(x)) -> 0.5*logN(x).  */
+#define LOG_SQRT(LOG) \
+ extern void link_failure_##LOG##_sqrt(void); \
+ if (LOG(sqrt(d1)) != 0.5*LOG(d1) || LOG##f(sqrtf(f1)) != 0.5F*LOG##f(f1) \
+  || LOG##l(sqrtl(ld1)) != 0.5L*LOG##l(ld1)) link_failure_##LOG##_sqrt()
+    
+  LOG_SQRT(log);
+  LOG_SQRT(log2);
+  LOG_SQRT(log10);
+  
+  /* Test sqrt(expN(x)) -> expN(x*0.5).  */
+#define SQRT_EXP(EXP) \
+ extern void link_failure_sqrt_##EXP(void); \
+ if (sqrt(EXP(d1)) != EXP(d1*0.5) || sqrtf(EXP##f(f1)) != EXP##f(f1*0.5F) \
+  || sqrtl(EXP##l(ld1)) != EXP##l(ld1*0.5L)) link_failure_sqrt_##EXP()
+    
+  SQRT_EXP(exp);
+  SQRT_EXP(exp2);
+  SQRT_EXP(exp10);
+  SQRT_EXP(pow10);
+  
+  /* Test logN(cbrt(x)) -> (1/3)*logN(x).  */
+#define LOG_CBRT(LOG) \
+ extern void link_failure_##LOG##_cbrt(void); \
+ if (LOG(cbrt(d1)) != (1.0/3)*LOG(d1) \
+  || LOG##f(cbrtf(f1)) != (1.0F/3)*LOG##f(f1) \
+  || LOG##l(cbrtl(ld1)) != (1.0L/3)*LOG##l(ld1)) link_failure_##LOG##_cbrt()
+    
+  LOG_CBRT(log);
+  LOG_CBRT(log2);
+  LOG_CBRT(log10);
+  
+  /* Test cbrt(expN(x)) -> expN(x/3).  */
+#define CBRT_EXP(EXP) \
+ extern void link_failure_cbrt_##EXP(void); \
+ if (cbrt(EXP(d1)) != EXP(d1/3.0) || cbrtf(EXP##f(f1)) != EXP##f(f1/3.0F) \
+  || cbrtl(EXP##l(ld1)) != EXP##l(ld1/3.0L)) link_failure_cbrt_##EXP()
+    
+  CBRT_EXP(exp);
+  CBRT_EXP(exp2);
+  CBRT_EXP(exp10);
+  CBRT_EXP(pow10);
+  
+  /* Test logN(pow(x,y)) -> y*logN(x).  */
+#define LOG_POW(LOG, POW) \
+ extern void link_failure_##LOG##_##POW(void); \
+ if (LOG(POW(d1,d2)) != d2*LOG(d1) || LOG##f(POW##f(f1,f2)) != f2*LOG##f(f1) \
+  || LOG##l(POW##l(ld1,ld2)) != ld2*LOG##l(ld1)) link_failure_##LOG##_##POW()
+  
+  LOG_POW(log,pow);
+  LOG_POW(log2,pow);
+  LOG_POW(log10,pow);
+
+  /* Test pow(expN(x),y)) -> expN(x*y).  */
+#define POW_EXP(POW, EXP) \
+ extern void link_failure_##POW##_##EXP(void); \
+ if (POW(EXP(d1),d2) != EXP(d1*d2) || POW##f(EXP##f(f1),f2) != EXP##f(f1*f2) \
+  || POW##l(EXP##l(ld1),ld2) != EXP##l(ld1*ld2)) link_failure_##POW##_##EXP()
+  
+  POW_EXP(pow, exp);
+  POW_EXP(pow, exp2);
+  POW_EXP(pow, exp10);
+  POW_EXP(pow, pow10);
+
+  /* Test expN(0) -> 1.  */
+#define EXP_0(EXP) \
+ extern void link_failure_##EXP##_0(void); \
+ if (EXP(0.0) != 1.0 || EXP##f(0.0F) != 1.0F || EXP##l(0.0L) != 1.0L) \
+  link_failure_##EXP##_0()
+
+  EXP_0(exp);
+  EXP_0(exp2);
+  EXP_0(exp10);
+  EXP_0(pow10);
+  
+  /* Test expN(1) -> N.  */
+#define EXP_N(EXP, BASE) \
+ extern void link_failure_##EXP##_N(void); \
+ if (EXP(1.0) != BASE || EXP##f(1.0F) != BASE##F || EXP##l(1.0L) != BASE##L) \
+  link_failure_##EXP##_N()
+
+  EXP_N(exp, M_E);
+  EXP_N(exp2, 2.0);
+  EXP_N(exp10, 10.0);
+  EXP_N(pow10, 10.0);
+
+  /* Test expN(integer) -> N*N*N*...  */
+#define EXP_INT(EXP, BASE) \
+ extern void link_failure_##EXP##_INT(void); \
+ if (EXP(5.0) < (BASE)*(BASE)*(BASE)*(BASE)*(BASE) - PREC \
+  || EXP(5.0) > (BASE)*(BASE)*(BASE)*(BASE)*(BASE) + PREC \
+  || EXP##f(5.0F) < (BASE##F)*(BASE##F)*(BASE##F)*(BASE##F)*(BASE##F) -PRECF \
+  || EXP##f(5.0F) > (BASE##F)*(BASE##F)*(BASE##F)*(BASE##F)*(BASE##F) +PRECF \
+  || EXP##l(5.0L) < (BASE##L)*(BASE##L)*(BASE##L)*(BASE##L)*(BASE##L) -PRECL \
+  || EXP##l(5.0L) > (BASE##L)*(BASE##L)*(BASE##L)*(BASE##L)*(BASE##L) +PRECL) \
+   link_failure_##EXP##_INT()
+
+  EXP_INT(exp, M_E);
+  EXP_INT(exp2, 2.0);
+  EXP_INT(exp10, 10.0);
+  EXP_INT(pow10, 10.0);
+
+  /* Test expN(logN(x)) -> x.  */
+#define EXPLOG_SAME(EXP, LOG) \
+ extern void link_failure_##EXP##_##LOG##_same(void); \
+ if (EXP(LOG(d1)) != d1 || EXP##f(LOG##f(f1)) != f1 \
+  || EXP##l(LOG##l(ld1)) != ld1) link_failure_##EXP##_##LOG##_same()
+
+  EXPLOG_SAME(exp, log);
+  EXPLOG_SAME(exp2, log2);
+  EXPLOG_SAME(exp10, log10);
+  EXPLOG_SAME(pow10, log10);
+
+  /* Test expN(x)*expN(y)) -> expN(x+y).  */
+#define EXPXEXP(EXP) \
+ extern void link_failure_##EXP##X##EXP(void); \
+ if (EXP(d1)*EXP(d2) != EXP(d1+d2) || EXP##f(f1)*EXP##f(f2) != EXP##f(f1+f2) \
+  || EXP##l(ld1)*EXP##l(ld2) != EXP##l(ld1+ld2)) link_failure_##EXP##X##EXP()
+
+  EXPXEXP(exp);
+  EXPXEXP(exp2);
+  EXPXEXP(exp10);
+  EXPXEXP(pow10);
+
+  /* Test x/expN(y) -> x*expN(-y).  */
+  /* Test expN(x)/expN(y) -> expN(x-y).  */
+#define DIVEXP(EXP) \
+ extern void link_failure_div1_##EXP(void); \
+ if (d1/EXP(d2) != d1*EXP(-d2) || f1/EXP##f(f2) != f1*EXP##f(-f2) \
+  || ld1/EXP##l(ld2) != ld1*EXP##l(-ld2)) link_failure_div1_##EXP(); \
+ extern void link_failure_div2_##EXP(void); \
+ if (EXP(d1)/EXP(d2) != EXP(d1-d2) || EXP##f(f1)/EXP##f(f2) != EXP##f(f1-f2) \
+  || EXP##l(ld1)/EXP##l(ld2) != EXP##l(ld1-ld2)) link_failure_div2_##EXP()
+
+  DIVEXP(exp);
+  DIVEXP(exp2);
+  DIVEXP(exp10);
+  DIVEXP(pow10);
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-frexp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-frexp-1.c
new file mode 100644
index 000000000..3ef23648a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-frexp-1.c
@@ -0,0 +1,137 @@
+/* Copyright (C) 2007  Free Software Foundation.
+
+   Verify that built-in folding of frexp is correctly performed by the
+   compiler.
+
+   Origin: Kaveh R. Ghazi,  February 21, 2007.  */
+
+/* { dg-do link } */
+/* { dg-options "-fno-finite-math-only" { target sh*-*-* } } */
+/* In order to fold algebraic exprs below, targets with "composite"
+   floating point formats need -funsafe-math-optimizations.  */
+/* { dg-options "-funsafe-math-optimizations" { target mips*-*-irix6* powerpc*-*-* } } */
+
+extern void link_error(int);
+
+/* Return TRUE if the sign of X != sign of Y.  This is important when
+   comparing signed zeros.  */
+#define CKSGN_F(X,Y) \
+  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+#define CKSGN(X,Y) \
+  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+#define CKSGN_L(X,Y) \
+  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+
+/* We can only check the exponent when optimizing since we rely on
+   other optimizations to propagate the value.  TRUE means an error
+   occurred.  */
+#ifdef __OPTIMIZE__
+#define CKEXP(X,Y) X != Y
+#else
+#define CKEXP(X,Y) 0
+#endif
+
+/* Test that frexp(ARG,&i) == RES && i == EXP.  Check the sign in
+   case we get -0.0.  */
+#define TESTIT_FREXP(ARG,RES,EXP) do { \
+  int i = 12345; \
+  if (__builtin_frexpf(ARG##f,&i) != RES##f \
+      || CKEXP(i,EXP) \
+      || CKSGN_F(__builtin_frexpf(ARG##f,&i),RES##f)) \
+    link_error(__LINE__); \
+  i = 12345; \
+  if (__builtin_frexp(ARG,&i) != RES \
+      || CKEXP(i,EXP) \
+      || CKSGN(__builtin_frexp(ARG,&i),RES)) \
+    link_error(__LINE__); \
+  i = 12345; \
+  if (__builtin_frexpl(ARG##l,&i) != RES##l \
+      || CKEXP(i,EXP) \
+      || CKSGN_L(__builtin_frexpl(ARG##l,&i),RES##l)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNCRES(frexp(NEG FUNCARG(ARGARG),&i)) is false.  Check
+   the sign as well.  Ensure side-effects are evaluated in i.  */
+#ifndef __SPU__
+#define TESTIT_FREXP2(NEG,FUNCARG,ARGARG,FUNCRES) do { \
+  int i=5; \
+  if (!__builtin_##FUNCRES##f(__builtin_frexpf(NEG __builtin_##FUNCARG##f(ARGARG),&i)) \
+      || CKSGN_F(__builtin_frexpf(NEG __builtin_##FUNCARG##f(ARGARG),(i++,&i)), NEG __builtin_##FUNCARG##f(ARGARG)) \
+      || CKEXP(i,6)) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES(__builtin_frexp(NEG __builtin_##FUNCARG(ARGARG),&i)) \
+      || CKSGN(__builtin_frexp(NEG __builtin_##FUNCARG(ARGARG),(i++,&i)), NEG __builtin_##FUNCARG(ARGARG)) \
+      || CKEXP(i,7)) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES##l(__builtin_frexpl(NEG __builtin_##FUNCARG##l(ARGARG),&i)) \
+      || CKSGN_L(__builtin_frexpl(NEG __builtin_##FUNCARG##l(ARGARG),(i++,&i)), NEG __builtin_##FUNCARG##l(ARGARG)) \
+      || CKEXP(i,8)) \
+    link_error(__LINE__); \
+  } while (0)
+#else
+#define TESTIT_FREXP2(NEG,FUNCARG,ARGARG,FUNCRES) do { \
+  int i=6; \
+  /* SPU single-precision floating point format does not support Inf or Nan.  */ \
+  if (!__builtin_##FUNCRES(__builtin_frexp(NEG __builtin_##FUNCARG(ARGARG),&i)) \
+      || CKSGN(__builtin_frexp(NEG __builtin_##FUNCARG(ARGARG),(i++,&i)), NEG __builtin_##FUNCARG(ARGARG)) \
+      || CKEXP(i,7)) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES##l(__builtin_frexpl(NEG __builtin_##FUNCARG##l(ARGARG),&i)) \
+      || CKSGN_L(__builtin_frexpl(NEG __builtin_##FUNCARG##l(ARGARG),(i++,&i)), NEG __builtin_##FUNCARG##l(ARGARG)) \
+      || CKEXP(i,8)) \
+    link_error(__LINE__); \
+  } while (0)
+#endif
+
+void __attribute__ ((__noinline__))
+foo(void)
+{
+  /* Test that frexp(ARG1,&i) -> ARG2 && i == ARG3.  */
+  TESTIT_FREXP (-0x1p40, -0.5, 41);
+  TESTIT_FREXP (-0x1p30, -0.5, 31);
+  TESTIT_FREXP (-0x1p20, -0.5, 21);
+  TESTIT_FREXP (-0x1p10, -0.5, 11);
+  TESTIT_FREXP (-0x1p5, -0.5, 6);
+  TESTIT_FREXP (-100/3.0, -100/192.0, 6);
+  TESTIT_FREXP (-1.5, -0.75, 1);
+  TESTIT_FREXP (-1.0, -0.5, 1);
+  TESTIT_FREXP (-1/3.0, -2/3.0, -1);
+  TESTIT_FREXP (-1/9.0, -8/9.0, -3);
+  TESTIT_FREXP (-0x1p-5, -0.5, -4);
+  TESTIT_FREXP (-0x1p-10, -0.5, -9);
+  TESTIT_FREXP (-0x1p-20, -0.5, -19);
+  TESTIT_FREXP (-0x1p-30, -0.5, -29);
+  TESTIT_FREXP (-0x1p-40, -0.5, -39);
+  TESTIT_FREXP (-0.0, -0.0, 0);
+  TESTIT_FREXP (0.0, 0.0, 0);
+  TESTIT_FREXP (0x1p-40, 0.5, -39);
+  TESTIT_FREXP (0x1p-30, 0.5, -29);
+  TESTIT_FREXP (0x1p-20, 0.5, -19);
+  TESTIT_FREXP (0x1p-10, 0.5, -9);
+  TESTIT_FREXP (0x1p-5, 0.5, -4);
+  TESTIT_FREXP (1/9.0, 8/9.0, -3);
+  TESTIT_FREXP (1/3.0, 2/3.0, -1);
+  TESTIT_FREXP (1.0, 0.5, 1);
+  TESTIT_FREXP (1.5, 0.75, 1);
+  TESTIT_FREXP (100/3.0, 100/192.0, 6);
+  TESTIT_FREXP (0x1p5, 0.5, 6);
+  TESTIT_FREXP (0x1p10, 0.5, 11);
+  TESTIT_FREXP (0x1p20, 0.5, 21);
+  TESTIT_FREXP (0x1p30, 0.5, 31);
+  TESTIT_FREXP (0x1p40, 0.5, 41);
+
+  /* Test for frexp(+-Inf,&i) -> +-Inf and frexp(+-NaN,&i) -> +-NaN.
+     Exponent is left unspecified, but we test for side-effects.  */
+  TESTIT_FREXP2 ( ,inf, , isinf);
+  TESTIT_FREXP2 (- ,inf, , isinf);
+  TESTIT_FREXP2 ( ,nan, "", isnan);
+  TESTIT_FREXP2 (- ,nan, "", isnan);
+}
+
+int main()
+{
+  foo ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-integral-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-integral-1.c
new file mode 100644
index 000000000..522646dd5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-integral-1.c
@@ -0,0 +1,69 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that integral FP expressions are optimized.
+
+   Written by Kaveh Ghazi, 2004-03-16.  */
+
+/* { dg-do link } */
+/* We need -ffinite-math-only so that we can fold "foo != foo", where
+   foo is a floating point expression.  We need -fno-math-errno so
+   that various math functions are marked const/pure and can be
+   folded.  */
+/* { dg-options "-ffinite-math-only -fno-math-errno" } */
+
+extern int link_failure (int);
+
+/* Test that the various FP truncation builtins detect integral
+   arguments.  */
+#define CHECK_FN(MATHFN) \
+ if (__builtin_##MATHFN(i1) != i1) link_failure (__LINE__); \
+ if (__builtin_##MATHFN##f(i1) != i1) link_failure (__LINE__); \
+ if (__builtin_##MATHFN##l(i1) != i1) link_failure (__LINE__);
+
+#define CHECK_FN_RET(MATHFN, RET) \
+ if (__builtin_##MATHFN(i1) != (RET)(double)i1) link_failure (__LINE__); \
+ if (__builtin_##MATHFN##f(i1) != (RET)(float)i1) link_failure (__LINE__); \
+ if (__builtin_##MATHFN##l(i1) != (RET)(long double)i1) link_failure (__LINE__);
+
+  /* Check that various other integral expressions are detected.  */
+#define CHECK_EXPR(EXPR,NAME) \
+ if (__builtin_ceill(EXPR) != (EXPR)) link_failure (__LINE__); \
+ if (__builtin_lroundl(EXPR) != (long)(long double)(EXPR)) link_failure (__LINE__);
+
+void __attribute__ ((__noinline__)) test (int i1, int i2)
+{
+  CHECK_FN(ceil);
+  CHECK_FN(floor);
+  CHECK_FN(nearbyint);
+  CHECK_FN(rint);
+  CHECK_FN(round);
+  CHECK_FN(trunc);
+  CHECK_FN_RET(lround, long);
+  CHECK_FN_RET(llround, long long);
+  CHECK_FN_RET(lrint, long);
+  CHECK_FN_RET(llrint, long long);
+  CHECK_FN_RET(lceil, long);
+  CHECK_FN_RET(llceil, long long);
+  CHECK_FN_RET(lfloor, long);
+  CHECK_FN_RET(llfloor, long long);
+
+  CHECK_EXPR (5.0, REAL_CST);
+  CHECK_EXPR (5.0F, REAL_CSTf);
+  CHECK_EXPR (5.0L, REAL_CSTl);
+  CHECK_EXPR ((double)i1, FLOAT_EXPR);
+  CHECK_EXPR ((float)i1, FLOAT_EXPRf);
+  CHECK_EXPR ((long double)i1, FLOAT_EXPRl);
+  CHECK_EXPR (__builtin_fabs(i1), ABS_EXPR);
+  CHECK_EXPR (__builtin_fabsf(i1), ABS_EXPRf);
+  CHECK_EXPR (__builtin_fabsl(i1), ABS_EXPRl);
+  CHECK_EXPR (((void)i1,(double)i2), COMPOUND_EXPR);
+  CHECK_EXPR ((double)i1+i2, PLUS_EXPR);
+  CHECK_EXPR ((double)i1-i2, MINUS_EXPR);
+  CHECK_EXPR ((double)i1*i2, MULT_EXPR);
+}
+
+int main (void)
+{
+  test (1, 2);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c
new file mode 100644
index 000000000..6dc2326ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c
@@ -0,0 +1,56 @@
+/* Copyright (C) 2008  Free Software Foundation.
+
+   Verify that __builtin_isinf_sign folds correctly.
+
+   Origin: Kaveh R. Ghazi,  May 17, 2008.  */
+
+/* { dg-do link } */
+
+/* All references to link_error should go away at compile-time.  */
+extern void link_error(int);
+
+void __attribute__ ((__noinline__))
+foo (float f, double d, long double ld)
+{
+  /* Test the generic expansion of isinf_sign.  */
+
+  if (__builtin_isinf_sign(f)
+      != (__builtin_isinf(f) ? (__builtin_signbitf(f) ? -1 : 1) : 0))
+    link_error (__LINE__);
+  if (__builtin_isinf_sign(d)
+      != (__builtin_isinf(d) ? (__builtin_signbit(d) ? -1 : 1) : 0))
+    link_error (__LINE__);
+  if (__builtin_isinf_sign(ld)
+      != (__builtin_isinf(ld) ? (__builtin_signbitl(ld) ? -1 : 1) : 0))
+    link_error (__LINE__);
+
+  /* In boolean contexts, GCC will fold the inner conditional
+     expression to 1.  So isinf_sign folds to plain isinf.  */
+
+  if ((_Bool)__builtin_isinf_sign(f) != (__builtin_isinf(f) != 0))
+    link_error (__LINE__);
+  if ((_Bool)__builtin_isinf_sign(d) != (__builtin_isinf(d) != 0))
+    link_error (__LINE__);
+  if ((_Bool)__builtin_isinf_sign(ld) != (__builtin_isinf(ld) != 0))
+    link_error (__LINE__);
+
+  if ((__builtin_isinf_sign(f) != 0) != (__builtin_isinf(f) != 0))
+    link_error (__LINE__);
+  if ((__builtin_isinf_sign(d) != 0) != (__builtin_isinf(d) != 0))
+    link_error (__LINE__);
+  if ((__builtin_isinf_sign(ld) != 0) != (__builtin_isinf(ld) != 0))
+    link_error (__LINE__);
+
+  if ((__builtin_isinf_sign(f) ? 5 : 6) != (__builtin_isinf(f) ? 5 : 6))
+    link_error (__LINE__);
+  if ((__builtin_isinf_sign(d) ? 5 : 6) != (__builtin_isinf(d) ? 5 : 6))
+    link_error (__LINE__);
+  if ((__builtin_isinf_sign(ld) ? 5 : 6) != (__builtin_isinf(ld) ? 5 : 6))
+    link_error (__LINE__);
+}
+
+int main (void)
+{
+  foo (1, 2, 3);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ldexp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ldexp-1.c
new file mode 100644
index 000000000..94560a8ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-ldexp-1.c
@@ -0,0 +1,216 @@
+/* Copyright (C) 2007  Free Software Foundation.
+
+   Verify that built-in folding of ldexp et al. is correctly performed
+   by the compiler.
+
+   Origin: Kaveh R. Ghazi,  February 17, 2007.  */
+
+/* { dg-do link } */
+/* { dg-options "-fno-finite-math-only" { target sh*-*-* } } */
+
+extern void link_error(int);
+
+/* Return TRUE if the sign of X != sign of Y.  This is important when
+   comparing signed zeros.  */
+#define CKSGN_F(X,Y) \
+  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+#define CKSGN(X,Y) \
+  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+#define CKSGN_L(X,Y) \
+  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+
+/* Test that FUNC(ARG1,ARG2) == RES.  Check the sign for -0.0.  */
+#define TESTIT(FUNC,ARG1,ARG2,RES) do { \
+  if (__builtin_##FUNC##f(ARG1##f,ARG2) != RES##f \
+      || CKSGN_F(__builtin_##FUNC##f(ARG1##f,ARG2),RES##f)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG1,ARG2) != RES \
+      || CKSGN(__builtin_##FUNC(ARG1,ARG2),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG1##l,ARG2) != RES##l \
+      || CKSGN_L(__builtin_##FUNC##l(ARG1##l,ARG2),RES##l)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that (long)FUNC(ARG1,ARG2) == (long)RES.  The cast is
+   necessary when RES is not a constant.  */
+#define TESTIT2(FUNC,ARG1,ARG2,RES) do { \
+  if ((long)__builtin_##FUNC##f(ARG1##f,ARG2) != (long)RES##f) \
+    link_error(__LINE__); \
+  if ((long)__builtin_##FUNC(ARG1,ARG2) != (long)RES) \
+    link_error(__LINE__); \
+  if ((long)__builtin_##FUNC##l(ARG1##l,ARG2) != (long)RES##l) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNCRES(FUNC(NEG FUNCARG(ARGARG),ARG2)) is false.  Check
+   the sign as well.  */
+#ifndef __SPU__
+#define TESTIT3(FUNC,NEG,FUNCARG,ARGARG,ARG2,FUNCRES) do { \
+  if (!__builtin_##FUNCRES##f(__builtin_##FUNC##f(NEG __builtin_##FUNCARG##f(ARGARG),ARG2)) \
+      || CKSGN_F(__builtin_##FUNC##f(NEG __builtin_##FUNCARG##f(ARGARG),ARG2), NEG __builtin_##FUNCARG##f(ARGARG))) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG),ARG2)) \
+      || CKSGN(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG),ARG2), NEG __builtin_##FUNCARG(ARGARG))) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES##l(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG),ARG2)) \
+      || CKSGN_L(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG),ARG2), NEG __builtin_##FUNCARG##l(ARGARG))) \
+    link_error(__LINE__); \
+  } while (0)
+#else
+#define TESTIT3(FUNC,NEG,FUNCARG,ARGARG,ARG2,FUNCRES) do { \
+  /* SPU single-precision floating point format does not support Inf or Nan.  */ \
+  if (!__builtin_##FUNCRES(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG),ARG2)) \
+      || CKSGN(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG),ARG2), NEG __builtin_##FUNCARG(ARGARG))) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES##l(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG),ARG2)) \
+      || CKSGN_L(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG),ARG2), NEG __builtin_##FUNCARG##l(ARGARG))) \
+    link_error(__LINE__); \
+  } while (0)
+#endif
+
+/* Using foo==MIN/MAX float values, test that FUNC(foo,EXP) == foo*exp2(EXP),
+   and also that FUNC(foo,-EXP) == foo*exp2(-EXP).  */
+#define TESTIT4(FUNC,EXP) do { \
+  if (__builtin_##FUNC##f(__FLT_MIN__,EXP) != __FLT_MIN__*__builtin_exp2f(EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##f(-__FLT_MIN__,EXP) != -__FLT_MIN__*__builtin_exp2f(EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(__DBL_MIN__,EXP) != __DBL_MIN__*__builtin_exp2(EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(-__DBL_MIN__,EXP) != -__DBL_MIN__*__builtin_exp2(EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(__LDBL_MIN__,EXP) != __LDBL_MIN__*__builtin_exp2l(EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(-__LDBL_MIN__,EXP) != -__LDBL_MIN__*__builtin_exp2l(EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##f(__FLT_MAX__,-EXP) != __FLT_MAX__*__builtin_exp2f(-EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##f(-__FLT_MAX__,-EXP) != -__FLT_MAX__*__builtin_exp2f(-EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(__DBL_MAX__,-EXP) != __DBL_MAX__*__builtin_exp2(-EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(-__DBL_MAX__,-EXP) != -__DBL_MAX__*__builtin_exp2(-EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(__LDBL_MAX__,-EXP) != __LDBL_MAX__*__builtin_exp2l(-EXP)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(-__LDBL_MAX__,-EXP) != -__LDBL_MAX__*__builtin_exp2l(-EXP)) \
+    link_error(__LINE__); \
+  } while (0)
+
+void __attribute__ ((__noinline__))
+foo(float xf, double x, long double xl, int i, long l)
+{
+  /* f(0.0, i) -> 0.0 and f(-0.0, i) -> -0.0.  */
+  TESTIT (ldexp, 0.0, i, 0.0);
+  TESTIT (ldexp, -0.0, i, -0.0);
+  TESTIT (scalbn, 0.0, i, 0.0);
+  TESTIT (scalbn, -0.0, i, -0.0);
+  TESTIT (scalbln, 0.0, l, 0.0);
+  TESTIT (scalbln, -0.0, l, -0.0);
+  
+  /* f(x,0) -> x.  */
+  TESTIT2 (ldexp, x, 0, x);
+  TESTIT2 (scalbn, x, 0, x);
+  TESTIT2 (scalbln, x, 0, x);
+
+  /* f(Inf,i) -> Inf and f(NaN,i) -> NaN.  */
+  TESTIT3 (ldexp, , inf, , i, isinf);
+  TESTIT3 (ldexp, -, inf, , i, isinf);
+  TESTIT3 (ldexp, , nan, "", i, isnan);
+  TESTIT3 (ldexp, -, nan, "", i, isnan);
+
+  TESTIT3 (scalbn, , inf, , i, isinf);
+  TESTIT3 (scalbn, -, inf, , i, isinf);
+  TESTIT3 (scalbn, , nan, "", i, isnan);
+  TESTIT3 (scalbn, -, nan, "", i, isnan);
+
+  TESTIT3 (scalbln, , inf, , i, isinf);
+  TESTIT3 (scalbln, -, inf, , i, isinf);
+  TESTIT3 (scalbln, , nan, "", i, isnan);
+  TESTIT3 (scalbln, -, nan, "", i, isnan);
+
+  /* Evaluate when both arguments are constant.  */
+  TESTIT (ldexp, 5.0, 3, 40.0);
+  TESTIT (ldexp, -5.0, 3, -40.0);
+  TESTIT (ldexp, 5.0, -3, 0.625);
+  TESTIT (ldexp, -5.0, -3, -0.625);
+
+  TESTIT (ldexp, 1000.0, 5, 32000.0);
+  TESTIT (ldexp, -1000.0, 5, -32000.0);
+  TESTIT (ldexp, 1000.0, -5, 31.25);
+  TESTIT (ldexp, -1000.0, -5, -31.25);
+
+  /* f(x,N) -> x*exp2(N), using MIN/MAX constants for x and constant N.  */
+  TESTIT4 (ldexp, 1);
+  TESTIT4 (ldexp, 2);
+  TESTIT4 (ldexp, 3);
+  TESTIT4 (ldexp, 5);
+  TESTIT4 (ldexp, 9);
+  TESTIT4 (ldexp, 10);
+  TESTIT4 (ldexp, 12);
+  TESTIT4 (ldexp, 18);
+  TESTIT4 (ldexp, 25);
+  TESTIT4 (ldexp, 50);
+  TESTIT4 (ldexp, 75);
+  TESTIT4 (ldexp, 100);
+  TESTIT4 (ldexp, 123);
+
+  /* These are folded when float radix is two.  */
+#if __FLT_RADIX__ == 2
+  TESTIT (scalbn, 5.0, 3, 40.0);
+  TESTIT (scalbn, -5.0, 3, -40.0);
+  TESTIT (scalbn, 5.0, -3, 0.625);
+  TESTIT (scalbn, -5.0, -3, -0.625);
+
+  TESTIT (scalbn, 1000.0, 5, 32000.0);
+  TESTIT (scalbn, -1000.0, 5, -32000.0);
+  TESTIT (scalbn, 1000.0, -5, 31.25);
+  TESTIT (scalbn, -1000.0, -5, -31.25);
+
+  TESTIT4 (scalbn, 1);
+  TESTIT4 (scalbn, 2);
+  TESTIT4 (scalbn, 3);
+  TESTIT4 (scalbn, 5);
+  TESTIT4 (scalbn, 9);
+  TESTIT4 (scalbn, 10);
+  TESTIT4 (scalbn, 12);
+  TESTIT4 (scalbn, 18);
+  TESTIT4 (scalbn, 25);
+  TESTIT4 (scalbn, 50);
+  TESTIT4 (scalbn, 75);
+  TESTIT4 (scalbn, 100);
+  TESTIT4 (scalbn, 123);
+
+  TESTIT (scalbln, 5.0, 3, 40.0);
+  TESTIT (scalbln, -5.0, 3, -40.0);
+  TESTIT (scalbln, 5.0, -3, 0.625);
+  TESTIT (scalbln, -5.0, -3, -0.625);
+
+  TESTIT (scalbln, 1000.0, 5, 32000.0);
+  TESTIT (scalbln, -1000.0, 5, -32000.0);
+  TESTIT (scalbln, 1000.0, -5, 31.25);
+  TESTIT (scalbln, -1000.0, -5, -31.25);
+
+  TESTIT4 (scalbln, 1);
+  TESTIT4 (scalbln, 2);
+  TESTIT4 (scalbln, 3);
+  TESTIT4 (scalbln, 5);
+  TESTIT4 (scalbln, 9);
+  TESTIT4 (scalbln, 10);
+  TESTIT4 (scalbln, 12);
+  TESTIT4 (scalbln, 18);
+  TESTIT4 (scalbln, 25);
+  TESTIT4 (scalbln, 50);
+  TESTIT4 (scalbln, 75);
+  TESTIT4 (scalbln, 100);
+  TESTIT4 (scalbln, 123);
+#endif
+}
+
+int main()
+{
+  foo (0, 0, 0, 0, 0);
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-logb-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-logb-1.c
new file mode 100644
index 000000000..25d0f9106
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-logb-1.c
@@ -0,0 +1,192 @@
+/* Copyright (C) 2007  Free Software Foundation.
+
+   Verify that built-in folding of logb, ilogb and significand is
+   correctly performed by the compiler.
+
+   Origin: Kaveh R. Ghazi,  February 22, 2007.  */
+
+/* { dg-do link } */
+/* { dg-options "-fno-finite-math-only" { target sh*-*-* } } */
+/* In order to fold algebraic exprs below, targets with "composite"
+   floating point formats need -funsafe-math-optimizations.  */
+/* { dg-options "-funsafe-math-optimizations" { target mips*-*-irix6* powerpc*-*-* } } */
+
+extern void link_error(int);
+
+/* Return TRUE if the sign of X != sign of Y.  This is important when
+   comparing signed zeros.  */
+#define CKSGN_F(X,Y) \
+  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+#define CKSGN(X,Y) \
+  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+#define CKSGN_L(X,Y) \
+  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+
+/* Test that FUNC(ARG) == RES.  Check the sign in case we get -0.0.  */
+#define TESTIT(FUNC,ARG,RES) do { \
+  if (__builtin_##FUNC##f(ARG##f) != RES##f \
+      || CKSGN_F(__builtin_##FUNC##f(ARG##f),RES##f)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG) != RES \
+      || CKSGN(__builtin_##FUNC(ARG),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG##l) != RES##l \
+      || CKSGN_L(__builtin_##FUNC##l(ARG##l),RES##l)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(ARG) == RES.  RES is an int so it can't be -0.0.  */
+#define TESTIT2(FUNC,ARG,RES) do { \
+  if (__builtin_##FUNC##f(ARG##f) != RES) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG) != RES) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG##l) != RES) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test if FUNCRES(FUNC(NEG FUNCARG(ARGARG))) is false.  Check the
+   sign as well.  */
+#ifndef __SPU__
+#define TESTIT3(FUNC,NEG,FUNCARG,ARGARG,FUNCRES) do { \
+  if (!__builtin_##FUNCRES##f(__builtin_##FUNC(NEG __builtin_##FUNCARG##f(ARGARG))) \
+      || CKSGN_F(__builtin_##FUNC##f(NEG __builtin_##FUNCARG##f(ARGARG)), NEG __builtin_##FUNCARG##f(ARGARG))) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG))) \
+      || CKSGN(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG)), NEG __builtin_##FUNCARG(ARGARG))) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES##l(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG))) \
+      || CKSGN_L(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG)), NEG __builtin_##FUNCARG##l(ARGARG))) \
+    link_error(__LINE__); \
+  } while (0)
+#else
+#define TESTIT3(FUNC,NEG,FUNCARG,ARGARG,FUNCRES) do { \
+  /* SPU single-precision floating point format does not support Inf or Nan.  */ \
+  if (!__builtin_##FUNCRES(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG))) \
+      || CKSGN(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG)), NEG __builtin_##FUNCARG(ARGARG))) \
+    link_error(__LINE__); \
+  if (!__builtin_##FUNCRES##l(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG))) \
+      || CKSGN_L(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG)), NEG __builtin_##FUNCARG##l(ARGARG))) \
+    link_error(__LINE__); \
+  } while (0)
+#endif
+
+void __attribute__ ((__noinline__))
+foo(void)
+{
+  /* If radix == 2, test that logb(ARG2) -> ARG3.  */
+#if __FLT_RADIX__ == 2
+  TESTIT (logb, -0x1p40, 40.0);
+  TESTIT (logb, -0x1p30, 30.0);
+  TESTIT (logb, -0x1p20, 20.0);
+  TESTIT (logb, -0x1p10, 10.0);
+  TESTIT (logb, -0x1p5, 5.0);
+  TESTIT (logb, -100/3.0, 5.0);
+  TESTIT (logb, -2.0, 1.0);
+  TESTIT (logb, -1.5, 0.0);
+  TESTIT (logb, -1.0, 0.0);
+  TESTIT (logb, -1/3.0, -2.0);
+  TESTIT (logb, -1/9.0, -4.0);
+  TESTIT (logb, -0x1p-5, -5.0);
+  TESTIT (logb, -0x1p-10, -10.0);
+  TESTIT (logb, -0x1p-20, -20.0);
+  TESTIT (logb, -0x1p-30, -30.0);
+  TESTIT (logb, -0x1p-40, -40.0);
+
+  TESTIT (logb, 0x1p-40, -40.0);
+  TESTIT (logb, 0x1p-30, -30.0);
+  TESTIT (logb, 0x1p-20, -20.0);
+  TESTIT (logb, 0x1p-10, -10.0);
+  TESTIT (logb, 0x1p-5, -5.0);
+  TESTIT (logb, 1/9.0, -4.0);
+  TESTIT (logb, 1/3.0, -2.0);
+  TESTIT (logb, 1.0, 0.0);
+  TESTIT (logb, 1.5, 0.0);
+  TESTIT (logb, 2.0, 1.0);
+  TESTIT (logb, 100/3.0, 5.0);
+  TESTIT (logb, 0x1p5, 5.0);
+  TESTIT (logb, 0x1p10, 10.0);
+  TESTIT (logb, 0x1p20, 20.0);
+  TESTIT (logb, 0x1p30, 30.0);
+  TESTIT (logb, 0x1p40, 40.0);
+#endif
+
+  /* If radix == 2, test that ilogb(ARG2) -> ARG3.  */
+#if __FLT_RADIX__ == 2
+  TESTIT2 (ilogb, -0x1p40, 40);
+  TESTIT2 (ilogb, -0x1p30, 30);
+  TESTIT2 (ilogb, -0x1p20, 20);
+  TESTIT2 (ilogb, -0x1p10, 10);
+  TESTIT2 (ilogb, -0x1p5, 5);
+  TESTIT2 (ilogb, -100/3.0, 5);
+  TESTIT2 (ilogb, -2.0, 1);
+  TESTIT2 (ilogb, -1.5, 0);
+  TESTIT2 (ilogb, -1.0, 0);
+  TESTIT2 (ilogb, -1/3.0, -2);
+  TESTIT2 (ilogb, -1/9.0, -4);
+  TESTIT2 (ilogb, -0x1p-5, -5);
+  TESTIT2 (ilogb, -0x1p-10, -10);
+  TESTIT2 (ilogb, -0x1p-20, -20);
+  TESTIT2 (ilogb, -0x1p-30, -30);
+  TESTIT2 (ilogb, -0x1p-40, -40);
+
+  TESTIT2 (ilogb, 0x1p-40, -40);
+  TESTIT2 (ilogb, 0x1p-30, -30);
+  TESTIT2 (ilogb, 0x1p-20, -20);
+  TESTIT2 (ilogb, 0x1p-10, -10);
+  TESTIT2 (ilogb, 0x1p-5, -5);
+  TESTIT2 (ilogb, 1/9.0, -4);
+  TESTIT2 (ilogb, 1/3.0, -2);
+  TESTIT2 (ilogb, 1.0, 0);
+  TESTIT2 (ilogb, 1.5, 0);
+  TESTIT2 (ilogb, 2.0, 1);
+  TESTIT2 (ilogb, 100/3.0, 5);
+  TESTIT2 (ilogb, 0x1p5, 5);
+  TESTIT2 (ilogb, 0x1p10, 10);
+  TESTIT2 (ilogb, 0x1p20, 20);
+  TESTIT2 (ilogb, 0x1p30, 30);
+  TESTIT2 (ilogb, 0x1p40, 40);
+#endif
+
+  /* If radix == 2, test that significand(ARG2) -> ARG3.  Zero always
+     folds regardless of the radix.  */
+  TESTIT (significand, -0.0, -0.0);
+  TESTIT (significand, 0.0, 0.0);
+
+#if __FLT_RADIX__ == 2
+  TESTIT (significand, -0x1p5, -1.0);
+  TESTIT (significand, -100/3.0, -100/96.0);
+  TESTIT (significand, -1.5, -1.5);
+  TESTIT (significand, -1.0, -1.0);
+  TESTIT (significand, -1/3.0, -4/3.0);
+  TESTIT (significand, -1/9.0, -16/9.0);
+  TESTIT (significand, -0x1p-5, -1.0);
+
+  TESTIT (significand, 0x1p-5, 1.0);
+  TESTIT (significand, 1/9.0, 16/9.0);
+  TESTIT (significand, 1/3.0, 4/3.0);
+  TESTIT (significand, 1.0, 1.0);
+  TESTIT (significand, 1.5, 1.5);
+  TESTIT (significand, 100/3.0, 100/96.0);
+  TESTIT (significand, 0x1p5, 1.0);
+#endif
+
+  /* Test for f(+-Inf) -> +-Inf and f(+-NaN) -> +-NaN, regardless of
+     the radix.  */
+  TESTIT3 (logb, ,inf, , isinf);
+  TESTIT3 (logb, - ,inf, , isinf);
+  TESTIT3 (logb,  ,nan, "", isnan);
+  TESTIT3 (logb, - ,nan, "", isnan);
+
+  TESTIT3 (significand, ,inf, , isinf);
+  TESTIT3 (significand, - ,inf, , isinf);
+  TESTIT3 (significand,  ,nan, "", isnan);
+  TESTIT3 (significand, - ,nan, "", isnan);
+}
+
+int main()
+{
+  foo ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-1.c
new file mode 100644
index 000000000..d052f5347
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-1.c
@@ -0,0 +1,186 @@
+/* Copyright (C) 2002, 2003, 2004  Free Software Foundation.
+
+   Verify that built-in math function constant folding of constant
+   arguments is correctly performed by the compiler.
+
+   Written by Roger Sayle, 16th August 2002.  */
+
+/* { dg-do link } */
+
+extern double atan (double);
+extern float atanf (float);
+extern long double atanl (long double);
+extern double cbrt (double);
+extern float cbrtf (float);
+extern long double cbrtl (long double);
+extern double cos (double);
+extern float cosf (float);
+extern long double cosl (long double);
+extern double exp (double);
+extern float expf (float);
+extern long double expl (long double);
+extern double log (double);
+extern float logf (float);
+extern long double logl (long double);
+extern double pow (double, double);
+extern float powf (float, float);
+extern long double powl (long double, long double);
+extern double sin (double);
+extern float sinf (float);
+extern long double sinl (long double);
+extern double sqrt (double);
+extern float sqrtf (float);
+extern long double sqrtl (long double);
+extern double tan (double);
+extern float tanf (float);
+extern long double tanl (long double);
+
+/* All references to link_error should go away at compile-time.  */
+extern void link_error(void);
+
+void test (float f, double d, long double ld)
+{
+  if (sqrt (0.0) != 0.0)
+    link_error ();
+
+  if (sqrt (1.0) != 1.0)
+    link_error ();
+
+  if (cbrt (0.0) != 0.0)
+    link_error ();
+
+  if (cbrt (1.0) != 1.0)
+    link_error ();
+
+  if (cbrt (-1.0) != -1.0)
+    link_error ();
+
+  if (exp (0.0) != 1.0)
+    link_error ();
+
+  if (exp (1.0) <= 2.71 || exp (1.0) >= 2.72)
+    link_error ();
+
+  if (log (1.0) != 0.0)
+    link_error ();
+
+  if (sin (0.0) != 0.0)
+    link_error ();
+
+  if (cos (0.0) != 1.0)
+    link_error ();
+
+  if (tan (0.0) != 0.0)
+    link_error ();
+
+  if (atan (0.0) != 0.0)
+    link_error ();
+
+  if (4.0*atan (1.0) <= 3.14 || 4.0*atan (1.0) >= 3.15)
+    link_error ();
+
+  if (pow (d, 0.0) != 1.0)
+    link_error ();
+
+  if (pow (1.0, d) != 1.0)
+    link_error ();
+
+
+  if (sqrtf (0.0F) != 0.0F)
+    link_error ();
+
+  if (sqrtf (1.0F) != 1.0F)
+    link_error ();
+
+  if (cbrtf (0.0F) != 0.0F)
+    link_error ();
+
+  if (cbrtf (1.0F) != 1.0F)
+    link_error ();
+
+  if (cbrtf (-1.0F) != -1.0F)
+    link_error ();
+
+  if (expf (0.0F) != 1.0F)
+    link_error ();
+
+  if (expf (1.0F) <= 2.71F || expf (1.0F) >= 2.72F)
+    link_error ();
+
+  if (logf (1.0F) != 0.0F)
+    link_error ();
+
+  if (sinf (0.0F) != 0.0F)
+    link_error ();
+
+  if (cosf (0.0F) != 1.0F)
+    link_error ();
+
+  if (tanf (0.0F) != 0.0F)
+    link_error ();
+
+  if (atanf (0.0F) != 0.0F)
+    link_error ();
+
+  if (4.0F*atanf (1.0F) <= 3.14F || 4.0F*atanf (1.0F) >= 3.15F)
+    link_error ();
+
+  if (powf (f, 0.0F) != 1.0F)
+    link_error ();
+
+  if (powf (1.0F, f) != 1.0F)
+    link_error ();
+
+
+  if (sqrtl (0.0L) != 0.0L)
+    link_error ();
+
+  if (sqrtl (1.0L) != 1.0L)
+    link_error ();
+
+  if (cbrtl (0.0L) != 0.0L)
+    link_error ();
+
+  if (cbrtl (1.0L) != 1.0L)
+    link_error ();
+
+  if (cbrtl (-1.0L) != -1.0L)
+    link_error ();
+
+  if (expl (0.0L) != 1.0L)
+    link_error ();
+
+  if (expl (1.0L) <= 2.71L || expl (1.0L) >= 2.72L)
+    link_error ();
+
+  if (logl (1.0L) != 0.0L)
+    link_error ();
+
+  if (sinl (0.0L) != 0.0L)
+    link_error ();
+
+  if (cosl (0.0L) != 1.0L)
+    link_error ();
+
+  if (tanl (0.0L) != 0.0L)
+    link_error ();
+
+  if (atanl (0.0) != 0.0L)
+    link_error ();
+
+  if (4.0L*atanl (1.0L) <= 3.14L || 4.0L*atanl (1.0L) >= 3.15L)
+    link_error ();
+
+  if (powl (ld, 0.0L) != 1.0L)
+    link_error ();
+
+  if (powl (1.0L, ld) != 1.0L)
+    link_error ();
+}
+
+int main()
+{
+  test (3.0, 3.0F, 3.0L);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-2.c
new file mode 100644
index 000000000..5c402873a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-2.c
@@ -0,0 +1,400 @@
+/* Copyright (C) 2006, 2007  Free Software Foundation.
+
+   Test things that should block GCC from optimizing compile-time
+   constants passed to a builtin transcendental function.
+
+   Origin: Kaveh R. Ghazi,  October 22, 2006.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+extern void foof (float);
+extern void foo (double);
+extern void fool (long double);
+
+#define TESTIT(FUNC, ARG) do { \
+  foof (__builtin_##FUNC##f (ARG##F)); \
+  foo (__builtin_##FUNC (ARG)); \
+  fool (__builtin_##FUNC##l (ARG##L)); \
+} while (0)
+
+#define TESTIT2(FUNC, ARG1, ARG2) do { \
+  foof (__builtin_##FUNC##f (ARG1##F, ARG2##F)); \
+  foo (__builtin_##FUNC (ARG1, ARG2)); \
+  fool (__builtin_##FUNC##l (ARG1##L, ARG2##L)); \
+} while (0)
+
+#define TESTIT2_I1(FUNC, ARG1, ARG2) do { \
+  foof (__builtin_##FUNC##f (ARG1, ARG2##F)); \
+  foo (__builtin_##FUNC (ARG1, ARG2)); \
+  fool (__builtin_##FUNC##l (ARG1, ARG2##L)); \
+} while (0)
+
+#define TESTIT2_I2ALL(FUNC, ARGF, MAXF, ARGD, MAXD, ARGLD, MAXLD) do { \
+  foof (__builtin_##FUNC##f (ARGF, MAXF)); \
+  foo (__builtin_##FUNC (ARGD, MAXD)); \
+  fool (__builtin_##FUNC##l (ARGLD, MAXLD)); \
+} while (0)
+
+#define TESTIT2_I2(FUNC, ARG1, ARG2) do { \
+  foof (__builtin_##FUNC##f (ARG1##F, ARG2)); \
+  foo (__builtin_##FUNC (ARG1, ARG2)); \
+  fool (__builtin_##FUNC##l (ARG1##L, ARG2)); \
+} while (0)
+
+#define TESTIT_REMQUO(ARG1, ARG2) do { \
+  int quo; \
+  foof (__builtin_remquof (ARG1##F, ARG2##F, &quo)); \
+  foo (__builtin_remquo (ARG1, ARG2, &quo)); \
+  fool (__builtin_remquol (ARG1##L, ARG2##L, &quo)); \
+} while (0)
+
+#define TESTIT_REENT(FUNC,ARG1) do { \
+  int sg; \
+  foof (__builtin_##FUNC##f_r (ARG1##F, &sg)); \
+  foo (__builtin_##FUNC##_r (ARG1, &sg)); \
+  fool (__builtin_##FUNC##l_r (ARG1##L, &sg)); \
+} while (0)
+
+void bar()
+{
+  /* An argument of NaN is not evaluated at compile-time.  */
+#ifndef __SPU__
+  foof (__builtin_exp2f (__builtin_nanf("")));
+#endif
+  foo (__builtin_exp2 (__builtin_nan("")));
+  fool (__builtin_exp2l (__builtin_nanl("")));
+
+  /* An argument of Inf/-Inf is not evaluated at compile-time.  */
+#ifndef __SPU__
+  foof (__builtin_exp2f (__builtin_inff()));
+#endif
+  foo (__builtin_exp2 (__builtin_inf()));
+  fool (__builtin_exp2l (__builtin_infl()));
+#ifndef __SPU__
+  foof (__builtin_exp2f (-__builtin_inff()));
+#endif
+  foo (__builtin_exp2 (-__builtin_inf()));
+  fool (__builtin_exp2l (-__builtin_infl()));
+
+  /* Result overflows MPFR, which in version 2.2.x has 30 exponent bits.  */
+  TESTIT (exp2, 0x1p50);
+  /* Result underflows MPFR, which in version 2.2.x has 30 exponent bits.  */
+  TESTIT (exp2, -0x1p50);
+
+  /* Result overflows GCC's REAL_VALUE_TYPE, which has 26 exponent bits.  */
+  TESTIT (exp2, 0x1p28);
+  /* Result underflows GCC's REAL_VALUE_TYPE, which has 26 exponent bits.  */
+  TESTIT (exp2, -0x1p28);
+  
+  /* Result overflows (even an extended) C double's mode.  */
+  TESTIT (exp2, 0x1p24);
+  /* Result underflows (even an extended) C double's mode.  */
+  TESTIT (exp2, -0x1p24);
+
+  /* Ensure that normal arguments/results are folded.  */
+  TESTIT (exp2, 1.5);
+  TESTIT (exp2, -1.5);
+  
+  /* The asin arg must be [-1 ... 1] inclusive.  */
+  TESTIT (asin, -1.5);
+  TESTIT (asin, 1.5);
+
+  /* The acos arg must be [-1 ... 1] inclusive.  */
+  TESTIT (acos, -1.5);
+  TESTIT (acos, 1.5);
+  
+  /* The acosh arg must be [1 ... Inf] inclusive.  */
+  TESTIT (acosh, 0.5);
+
+  /* The atanh arg must be [-1 ... 1] EXclusive.  */
+  TESTIT (atanh, -1.0);
+  TESTIT (atanh, 1.0);
+
+  /* The log* arg must be [0 ... Inf] EXclusive.  */
+  TESTIT (log, -1.0);
+  TESTIT (log, 0.0);
+  TESTIT (log, -0.0);
+  
+  TESTIT (log2, -1.0);
+  TESTIT (log2, 0.0);
+  TESTIT (log2, -0.0);
+  
+  TESTIT (log10, -1.0);
+  TESTIT (log10, 0.0);
+  TESTIT (log10, -0.0);
+  
+  /* The log1p arg must be [-1 ... Inf] EXclusive.  */
+  TESTIT (log1p, -2.0);
+  TESTIT (log1p, -1.0);
+
+  /* The tgamma arg errors with zero or negative integers.  */
+  TESTIT (tgamma, 0.0);
+  TESTIT (tgamma, -0.0);
+  TESTIT (tgamma, -1.0);
+  TESTIT (tgamma, -2.0);
+  TESTIT (tgamma, -3.0);
+
+  /* An argument of NaN is not evaluated at compile-time.  */
+#ifndef __SPU__
+  foof (__builtin_powf (__builtin_nanf(""), 2.5F));
+#endif
+  foo (__builtin_pow (__builtin_nan(""), 2.5));
+  fool (__builtin_powl (__builtin_nanl(""), 2.5L));
+#ifndef __SPU__
+  foof (__builtin_powf (2.5F, __builtin_nanf("")));
+#endif
+  foo (__builtin_pow (2.5, __builtin_nan("")));
+  fool (__builtin_powl (2.5L, __builtin_nanl("")));
+
+  /* An argument of Inf/-Inf is not evaluated at compile-time.  */
+#ifndef __SPU__
+  foof (__builtin_powf (__builtin_inff(), 2.5F));
+#endif
+  foo (__builtin_pow (__builtin_inf(), 2.5));
+  fool (__builtin_powl (__builtin_infl(), 2.5L));
+#ifndef __SPU__
+  foof (__builtin_powf (-__builtin_inff(), 2.5F));
+#endif
+  foo (__builtin_pow (-__builtin_inf(), 2.5));
+  fool (__builtin_powl (-__builtin_infl(), 2.5L));
+#ifndef __SPU__
+  foof (__builtin_powf (2.5F, __builtin_inff()));
+#endif
+  foo (__builtin_pow (2.5, __builtin_inf()));
+  fool (__builtin_powl (2.5L, __builtin_infl()));
+#ifndef __SPU__
+  foof (__builtin_powf (2.5F, -__builtin_inff()));
+#endif
+  foo (__builtin_pow (2.5, -__builtin_inf()));
+  fool (__builtin_powl (2.5L, -__builtin_infl()));
+
+  /* Check for Inv/NaN return values.  */
+  TESTIT2 (pow, -0.0, -4.5); /* Returns Inf */
+  TESTIT2 (pow, 0.0, -4.5); /* Returns Inf */
+  TESTIT2 (pow, -3.0, -4.5); /* Returns NaN */
+
+  /* Check for overflow/underflow.  */
+  foof (__builtin_powf (__FLT_MAX__, 3.5F));
+  foo (__builtin_pow (__DBL_MAX__, 3.5));
+  fool (__builtin_powl (__LDBL_MAX__, 3.5L));
+  TESTIT2 (pow, 2.0, 0x1p50);
+  foof (__builtin_powf (__FLT_MAX__, -3.5F));
+  foo (__builtin_pow (__DBL_MAX__, -3.5));
+  fool (__builtin_powl (__LDBL_MAX__, -3.5L));
+  TESTIT2 (pow, 2.0, -0x1p50);
+  
+  foof (__builtin_fmaf (__FLT_MAX__, __FLT_MAX__, 0.0F));
+  foof (__builtin_fmaf (__FLT_MAX__, 1.0F, __FLT_MAX__));
+  foof (__builtin_fmaf (__FLT_MIN__, __FLT_MIN__, 0.0F));
+  
+  foo (__builtin_fma (__DBL_MAX__, __DBL_MAX__, 0.0));
+  foo (__builtin_fma (__DBL_MAX__, 1.0, __DBL_MAX__));
+  foo (__builtin_fma (__DBL_MIN__, __DBL_MIN__, 0.0));
+  
+  fool (__builtin_fmal (__LDBL_MAX__, __LDBL_MAX__, 0.0L));
+  fool (__builtin_fmal (__LDBL_MAX__, 1.0L, __LDBL_MAX__));
+  fool (__builtin_fmal (__LDBL_MIN__, __LDBL_MIN__, 0.0L));
+
+  /* The sqrt arg must be [0 ... Inf] inclusive.  */
+  TESTIT (sqrt, -0.5);
+  TESTIT (sqrt, -0.0);
+  TESTIT (sqrt, 0.0);
+
+  /* Check for overflow/underflow.  */
+
+  /* These adjustments are too big.  */
+#define FLT_EXP_ADJ (2*(__FLT_MAX_EXP__-__FLT_MIN_EXP__)+1)
+#define DBL_EXP_ADJ (2*(__DBL_MAX_EXP__-__DBL_MIN_EXP__)+1)
+#define LDBL_EXP_ADJ (2*(__LDBL_MAX_EXP__-__LDBL_MIN_EXP__)+1)
+
+  TESTIT2_I2 (ldexp, 1.0, __INT_MAX__);
+  TESTIT2_I2 (ldexp, 1.0, -__INT_MAX__-1);
+  TESTIT2_I2 (ldexp, -1.0, __INT_MAX__);
+  TESTIT2_I2 (ldexp, -1.0, -__INT_MAX__-1);
+  TESTIT2_I2ALL (ldexp, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
+		 DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
+  TESTIT2_I2ALL (ldexp, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
+		 -DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
+  TESTIT2_I2ALL (ldexp, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
+		 __DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
+  TESTIT2_I2ALL (ldexp, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
+		 __DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
+
+  TESTIT2_I2 (scalbn, 1.0, __INT_MAX__);
+  TESTIT2_I2 (scalbn, 1.0, -__INT_MAX__-1);
+  TESTIT2_I2 (scalbn, -1.0, __INT_MAX__);
+  TESTIT2_I2 (scalbn, -1.0, -__INT_MAX__-1);
+  TESTIT2_I2ALL (scalbn, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
+		 DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
+  TESTIT2_I2ALL (scalbn, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
+		 -DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
+  TESTIT2_I2ALL (scalbn, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
+		 __DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
+  TESTIT2_I2ALL (scalbn, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
+		 __DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
+
+  TESTIT2_I2 (scalbln, 1.0, __LONG_MAX__);
+  TESTIT2_I2 (scalbln, 1.0, -__LONG_MAX__-1);
+  TESTIT2_I2 (scalbln, -1.0, __LONG_MAX__);
+  TESTIT2_I2 (scalbln, -1.0, -__LONG_MAX__-1);
+  TESTIT2_I2ALL (scalbln, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
+		 DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
+  TESTIT2_I2ALL (scalbln, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
+		 -DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
+  TESTIT2_I2ALL (scalbln, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
+		 __DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
+  TESTIT2_I2ALL (scalbln, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
+		 __DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
+
+  TESTIT (logb, 0.0);
+  TESTIT (logb, -0.0);
+
+  TESTIT (ilogb, 0.0);
+  TESTIT (ilogb, -0.0);
+
+#ifndef __SPU__
+  foof (__builtin_ilogbf (__builtin_inff()));
+#endif
+  foo (__builtin_ilogb (__builtin_inf()));
+  fool (__builtin_ilogbl (__builtin_infl()));
+#ifndef __SPU__
+  foof (__builtin_ilogbf (-__builtin_inff()));
+#endif
+  foo (__builtin_ilogb (-__builtin_inf()));
+  fool (__builtin_ilogbl (-__builtin_infl()));
+
+#ifndef __SPU__
+  foof (__builtin_ilogbf (__builtin_nanf("")));
+#endif
+  foo (__builtin_ilogb (__builtin_nan("")));
+  fool (__builtin_ilogbl (__builtin_nanl("")));
+#ifndef __SPU__
+  foof (__builtin_ilogbf (-__builtin_nanf("")));
+#endif
+  foo (__builtin_ilogb (-__builtin_nan("")));
+  fool (__builtin_ilogbl (-__builtin_nanl("")));
+
+  /* The y* arg must be [0 ... Inf] EXclusive.  */
+  TESTIT (y0, -1.0);
+  TESTIT (y0, 0.0);
+  TESTIT (y0, -0.0);
+
+  TESTIT (y1, -1.0);
+  TESTIT (y1, 0.0);
+  TESTIT (y1, -0.0);
+
+  TESTIT2_I1 (yn, 2, -1.0);
+  TESTIT2_I1 (yn, 2, 0.0);
+  TESTIT2_I1 (yn, 2, -0.0);
+
+  TESTIT2_I1 (yn, -3, -1.0);
+  TESTIT2_I1 (yn, -3, 0.0);
+  TESTIT2_I1 (yn, -3, -0.0);
+
+  /* The second argument of remquo/remainder/drem must not be 0.  */
+  TESTIT_REMQUO (1.0, 0.0);
+  TESTIT_REMQUO (1.0, -0.0);
+  TESTIT2 (remainder, 1.0, 0.0);
+  TESTIT2 (remainder, 1.0, -0.0);
+  TESTIT2 (drem, 1.0, 0.0);
+  TESTIT2 (drem, 1.0, -0.0);
+
+  /* The argument to lgamma* cannot be zero or a negative integer.  */
+  TESTIT_REENT (lgamma, -4.0); /* lgamma_r */
+  TESTIT_REENT (lgamma, -3.0); /* lgamma_r */
+  TESTIT_REENT (lgamma, -2.0); /* lgamma_r */
+  TESTIT_REENT (lgamma, -1.0); /* lgamma_r */
+  TESTIT_REENT (lgamma, -0.0); /* lgamma_r */
+  TESTIT_REENT (lgamma, 0.0); /* lgamma_r */
+  
+  TESTIT_REENT (gamma, -4.0); /* gamma_r */
+  TESTIT_REENT (gamma, -3.0); /* gamma_r */
+  TESTIT_REENT (gamma, -2.0); /* gamma_r */
+  TESTIT_REENT (gamma, -1.0); /* gamma_r */
+  TESTIT_REENT (gamma, -0.0); /* gamma_r */
+  TESTIT_REENT (gamma, 0.0); /* gamma_r */
+}
+
+/* { dg-final { scan-tree-dump-times "exp2 " 9 "original" } } */
+/* { dg-final { scan-tree-dump-times "exp2f" 9 "original" { target { ! { spu*-*-* } } } } } */
+/* { dg-final { scan-tree-dump-times "exp2f" 6 "original" { target { spu*-*-* } } } } */
+/* { dg-final { scan-tree-dump-times "exp2l" 9 "original" } } */
+/* { dg-final { scan-tree-dump-times "asin " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "asinf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "asinl" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "acos " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "acosf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "acosl" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "acosh " 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "acoshf" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "acoshl" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "atanh " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "atanhf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "atanhl" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "log " 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "logf" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "logl" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log2 " 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log2f" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log2l" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log10 " 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log10f" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log10l" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "log1p " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "log1pf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "log1pl" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "tgamma " 5 "original" } } */
+/* { dg-final { scan-tree-dump-times "tgammaf" 5 "original" } } */
+/* { dg-final { scan-tree-dump-times "tgammal" 5 "original" } } */
+/* { dg-final { scan-tree-dump-times "pow " 13 "original" } } */
+/* { dg-final { scan-tree-dump-times "powf" 13 "original" { target { ! { spu*-*-* } } } } } */
+/* { dg-final { scan-tree-dump-times "powf" 7 "original" { target { spu*-*-* } } } } */
+/* { dg-final { scan-tree-dump-times "powl" 13 "original" } } */
+/* { dg-final { scan-tree-dump-times "fma " 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "fmaf" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "fmal" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "sqrt " 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "sqrtf" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "sqrtl" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "ldexp " 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "ldexpf" 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "ldexpl" 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "scalbn " 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "scalbnf" 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "scalbnl" 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "scalbln " 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "scalblnf" 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "scalblnl" 8 "original" } } */
+/* { dg-final { scan-tree-dump-times "_logb " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "_logbf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "_logbl" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "ilogb " 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "ilogbf" 6 "original" { target { ! { spu*-*-* } } } } } */
+/* { dg-final { scan-tree-dump-times "ilogbf" 2 "original" { target { spu*-*-* } } } } */
+/* { dg-final { scan-tree-dump-times "ilogbl" 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "y0 " 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "y0f" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "y0l" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "y1 " 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "y1f" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "y1l" 3 "original" } } */
+/* { dg-final { scan-tree-dump-times "yn " 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "ynf" 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "ynl" 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "remquo " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "remquof" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "remquol" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "remainder " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "remainderf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "remainderl" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "drem " 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "dremf" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "dreml" 2 "original" } } */
+/* { dg-final { scan-tree-dump-times "lgamma_r " 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "lgammaf_r" 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "lgammal_r" 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "_gamma_r " 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "_gammaf_r" 6 "original" } } */
+/* { dg-final { scan-tree-dump-times "_gammal_r" 6 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-3.c
new file mode 100644
index 000000000..896edccaa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-3.c
@@ -0,0 +1,374 @@
+/* Copyright (C) 2006  Free Software Foundation.
+
+   Verify that built-in math function constant folding of constant
+   arguments is correctly performed by the compiler.
+
+   Origin: Kaveh R. Ghazi,  October 23, 2006.  */
+
+/* { dg-do link } */
+
+/* Define "e" with as many bits as found in builtins.c:dconste.  */
+#define M_E  2.7182818284590452353602874713526624977572470936999595749669676277241
+
+/* All references to link_error should go away at compile-time.  */
+extern void link_error(int);
+
+/* Return TRUE if the sign of X != sign of Y.  This is important when
+   comparing signed zeros.  */
+#define CKSGN_F(X,Y) \
+  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+#define CKSGN(X,Y) \
+  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+#define CKSGN_L(X,Y) \
+  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+
+/* Test that FUNC(ARG) == (RES).  */
+#define TESTIT(FUNC,ARG,RES) do { \
+  if (__builtin_##FUNC##f(ARG##F) != RES##F \
+      || CKSGN_F(__builtin_##FUNC##f(ARG##F),RES##F)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG) != RES \
+      || CKSGN(__builtin_##FUNC(ARG),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG##L) != RES##L \
+      || CKSGN_L(__builtin_##FUNC##l(ARG##L),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Range test, check that (LOW) < FUNC(ARG) < (HI).  */
+#define TESTIT_R(FUNC,ARG,LOW,HI) do { \
+  if (__builtin_##FUNC##f(ARG) <= (LOW) || __builtin_##FUNC##f(ARG) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG) <= (LOW) || __builtin_##FUNC(ARG) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG) <= (LOW) || __builtin_##FUNC##l(ARG) >= (HI)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(ARG1, ARG2) == (RES).  */
+#define TESTIT2(FUNC,ARG1,ARG2,RES) do { \
+  if (__builtin_##FUNC##f(ARG1##F, ARG2##F) != RES##F \
+      || CKSGN_F(__builtin_##FUNC##f(ARG1##F,ARG2##F),RES##F)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG1, ARG2) != RES \
+      || CKSGN(__builtin_##FUNC(ARG1,ARG2),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG1##L, ARG2##L) != RES##L \
+      || CKSGN_L(__builtin_##FUNC##l(ARG1##L,ARG2##L),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Range test, check that (LOW) < FUNC(ARG1,ARG2) < (HI).  */
+#define TESTIT2_R(FUNC,ARG1,ARG2,LOW,HI) do { \
+  if (__builtin_##FUNC##f(ARG1, ARG2) <= (LOW) \
+      || __builtin_##FUNC##f(ARG1, ARG2) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG1, ARG2) <= (LOW) \
+      || __builtin_##FUNC(ARG1, ARG2) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG1, ARG2) <= (LOW) \
+      || __builtin_##FUNC##l(ARG1, ARG2) >= (HI)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(ARG1, ARG2, ARG3) == (RES).  */
+#define TESTIT3(FUNC,ARG1,ARG2,ARG3,RES) do { \
+  if (__builtin_##FUNC##f(ARG1##F, ARG2##F, ARG3##F) != RES##F \
+      || CKSGN_F(__builtin_##FUNC##f(ARG1##F,ARG2##F,ARG3##F),RES##F)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG1, ARG2, ARG3) != RES \
+      || CKSGN(__builtin_##FUNC(ARG1,ARG2,ARG3),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG1##L, ARG2##L, ARG3##L) != RES##L \
+      || CKSGN_L(__builtin_##FUNC##l(ARG1##L,ARG2##L,ARG3##L),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that for FUNC(ARG, &ARG_S, &ARG_C);
+   assert (ARG_S == RES_S && ARG_C == RES_C);.  */
+#define TESTIT_2P(FUNC,ARG,ARG_S,ARG_C,RES_S,RES_C) do { \
+  __builtin_##FUNC##f(ARG##F, &ARG_S##f, &ARG_C##f); \
+  if (ARG_S##f != (RES_S##F) || ARG_C##f != (RES_C##F)) \
+    link_error(__LINE__); \
+  __builtin_##FUNC(ARG, &ARG_S, &ARG_C); \
+  if (ARG_S != (RES_S) || ARG_C != (RES_C)) \
+    link_error(__LINE__); \
+  __builtin_##FUNC##l(ARG##L, &ARG_S##l, &ARG_C##l); \
+  if (ARG_S##l != (RES_S##L) || ARG_C##l != (RES_C##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that for FUNC(ARG, &ARG_S, &ARG_C);
+   assert (LOW_S < ARG_S < HI_S && LOW_C < ARG_C < HI_C);.  */
+#define TESTIT_2P_R(FUNC,ARG,ARG_S,ARG_C,LOW_S,HI_S,LOW_C,HI_C) do { \
+  __builtin_##FUNC##f(ARG##F, &ARG_S##f, &ARG_C##f); \
+  if (ARG_S##f <= (LOW_S##F) || ARG_S##f >= (HI_S##F) \
+      || ARG_C##f <= (LOW_C##F) || ARG_C##f >= (HI_C##F)) \
+    link_error(__LINE__); \
+  __builtin_##FUNC(ARG, &ARG_S, &ARG_C); \
+  if (ARG_S <= (LOW_S) || ARG_S >= (HI_S) \
+      || ARG_C <= (LOW_C) || ARG_C >= (HI_C)) \
+    link_error(__LINE__); \
+  __builtin_##FUNC##l(ARG##L, &ARG_S##l, &ARG_C##l); \
+  if (ARG_S##l <= (LOW_S##L) || ARG_S##l >= (HI_S##L) \
+      || ARG_C##l <= (LOW_C##L) || ARG_C##l >= (HI_C##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+int main (void)
+{
+#ifdef __OPTIMIZE__
+  float sf, cf, oneF = 1.0F;
+  double s, c, one = 1.0;
+  long double sl, cl, oneL = 1.0L;
+#endif
+
+  TESTIT_R (asin, -1.0, -3.15/2.0, -3.14/2.0); /* asin(-1) == -pi/2 */
+  TESTIT (asin, 0.0, 0.0); /* asin(0) == 0 */
+  TESTIT (asin, -0.0, -0.0); /* asin(-0) == -0 */
+  TESTIT_R (asin, 1.0, 3.14/2.0, 3.15/2.0); /* asin(1) == pi/2 */
+
+  TESTIT_R (acos, -1.0, 3.14, 3.15); /* acos(-1) == pi */
+  TESTIT_R (acos, 0.0, 3.14/2.0, 3.15/2.0); /* acos(0) == pi/2 */
+  TESTIT_R (acos, -0.0, 3.14/2.0, 3.15/2.0); /* acos(-0) == pi/2 */
+  TESTIT (acos, 1.0, 0.0); /* acos(1) == 0 */
+
+  TESTIT_R (atan, -1.0, -3.15/4.0, -3.14/4.0); /* atan(-1) == -pi/4 */
+  TESTIT (atan, 0.0, 0.0); /* atan(0) == 0 */
+  TESTIT (atan, -0.0, -0.0); /* atan(-0) == -0 */
+  TESTIT_R (atan, 1.0, 3.14/4.0, 3.15/4.0); /* atan(1) == pi/4 */
+
+  TESTIT_R (asinh, -1.0, -0.89, -0.88); /* asinh(-1) == -0.881... */
+  TESTIT (asinh, 0.0, 0.0); /* asinh(0) == 0 */
+  TESTIT (asinh, -0.0, -0.0); /* asinh(-0) == -0 */
+  TESTIT_R (asinh, 1.0, 0.88, 0.89); /* asinh(1) == 0.881... */
+
+  TESTIT (acosh, 1.0, 0.0); /* acosh(1) == 0. */
+  TESTIT_R (acosh, 2.0, 1.31, 1.32); /* acosh(2) == 1.316... */
+
+  TESTIT_R (atanh, -0.5, -0.55, -0.54); /* atanh(-0.5) == -0.549... */
+  TESTIT (atanh, 0.0, 0.0); /* atanh(0) == 0 */
+  TESTIT (atanh, -0.0, -0.0); /* atanh(-0) == -0 */
+  TESTIT_R (atanh, 0.5, 0.54, 0.55); /* atanh(0.5) == 0.549... */
+
+  TESTIT_R (sin, -1.0, -0.85, -0.84); /* sin(-1) == -0.841... */
+  TESTIT (sin, 0.0, 0.0); /* sin(0) == 0 */
+  TESTIT (sin, -0.0, -0.0); /* sin(-0) == -0 */
+  TESTIT_R (sin, 1.0, 0.84, 0.85); /* sin(1) == 0.841... */
+
+  TESTIT_R (cos, -1.0, 0.54, 0.55); /* cos(-1) == 0.5403... */
+  TESTIT (cos, 0.0, 1.0); /* cos(0) == 1 */
+  TESTIT (cos, -0.0, 1.0); /* cos(-0) == 1 */
+  TESTIT_R (cos, 1.0, 0.54, 0.55); /* cos(1) == 0.5403... */
+
+  TESTIT_R (tan, -1.0, -1.56, 1.55); /* tan(-1) == -1.557... */
+  TESTIT (tan, 0.0, 0.0); /* tan(0) == 0 */
+  TESTIT (tan, -0.0, -0.0); /* tan(-0) == -0 */
+  TESTIT_R (tan, 1.0, 1.55, 1.56); /* tan(1) == 1.557... */
+
+#ifdef __OPTIMIZE__
+  /* These tests rely on propagating the variables s, c and one, which
+     happens only when optimization is turned on.  */
+  TESTIT_2P_R (sincos, -1.0, s, c, -0.85, -0.84, 0.54, 0.55); /* (s==-0.841..., c==0.5403...) */
+  TESTIT_2P (sincos, 0.0, s, c, 0.0, 1.0); /* (s==0, c==1) */
+  TESTIT_2P (sincos, -0.0, s, c, -0.0, 1.0); /* (s==-0, c==1) */
+  TESTIT_2P_R (sincos, 1.0, s, c, 0.84, 0.85, 0.54, 0.55); /* (s==0.841..., c==0.5403...) */
+  TESTIT_2P_R (sincos, one, s, c, 0.84, 0.85, 0.54, 0.55); /* (s==0.841..., c==0.5403...) */
+  TESTIT_2P_R (sincos, -one, s, c, -0.85, -0.84, 0.54, 0.55); /* (s==-0.841..., c==0.5403...) */
+#endif
+  
+  TESTIT_R (sinh, -1.0, -1.18, -1.17); /* sinh(-1) == -1.175... */
+  TESTIT (sinh, 0.0, 0.0); /* sinh(0) == 0 */
+  TESTIT (sinh, -0.0, -0.0); /* sinh(-0) == -0 */
+  TESTIT_R (sinh, 1.0, 1.17, 1.18); /* sinh(1) == 1.175... */
+
+  TESTIT_R (cosh, -1.0, 1.54, 1.55); /* cosh(-1) == 1.543... */
+  TESTIT (cosh, 0.0, 1.0); /* cosh(0) == 1 */
+  TESTIT (cosh, -0.0, 1.0); /* cosh(-0) == 1 */
+  TESTIT_R (cosh, 1.0, 1.54, 1.55); /* cosh(1) == 1.543... */
+
+  TESTIT_R (tanh, -1.0, -0.77, -0.76); /* tanh(-1) == -0.761... */
+  TESTIT (tanh, -0.0, -0.0); /* tanh(-0) == -0 */
+  TESTIT (tanh, 0.0, 0.0); /* tanh(0) == 0 */
+  TESTIT_R (tanh, 1.0, 0.76, 0.77); /* tanh(1) == 0.761... */
+
+  TESTIT_R (exp, -1.0, 0.36, 0.37); /* exp(-1) == 1/e */
+  TESTIT (exp, -0.0, 1.0); /* exp(-0) == 1 */
+  TESTIT (exp, 0.0, 1.0); /* exp(0) == 1 */
+  TESTIT_R (exp, 1.0, 2.71, 2.72); /* exp(1) == e */
+
+  TESTIT (exp2, -1.0, 0.5); /* exp2(-1) == 1/2 */
+  TESTIT (exp2, -0.0, 1.0); /* exp2(-0) == 1 */
+  TESTIT (exp2, 0.0, 1.0); /* exp2(0) == 1 */
+  TESTIT (exp2, 1.0, 2.0); /* exp2(1) == 2 */
+
+  TESTIT (exp10, -1.0, 0.1); /* exp10(-1) == 1/10 */
+  TESTIT (exp10, -0.0, 1.0); /* exp10(-0) == 1 */
+  TESTIT (exp10, 0.0, 1.0); /* exp10(0) == 1 */
+  TESTIT (exp10, 1.0, 10.0); /* exp10(1) == 10 */
+
+  TESTIT (pow10, -1.0, 0.1); /* pow10(-1) == 1/10 */
+  TESTIT (pow10, -0.0, 1.0); /* pow10(-0) == 1 */
+  TESTIT (pow10, 0.0, 1.0); /* pow10(0) == 1 */
+  TESTIT (pow10, 1.0, 10.0); /* pow10(1) == 10 */
+
+  TESTIT_R (expm1, -1.0, -0.64, -0.63); /* expm1(-1) == 1/e - 1 */
+  TESTIT (expm1, -0.0, -0.0); /* expm1(-0) == 0 */
+  TESTIT (expm1, 0.0, 0.0); /* expm1(0) == 0 */
+  TESTIT_R (expm1, 1.0, 1.71, 1.72); /* expm1(1) == e - 1 */
+
+  TESTIT (log, 1.0, 0.0); /* log(1) == 0 */
+  TESTIT_R (log, M_E, 0.99, 1.01); /* log(e) == 1.000... */
+  TESTIT_R (log, M_E*M_E, 1.99, 2.01); /* log(e*e) == 2.000... */
+
+  TESTIT (log2, 1.0, 0.0); /* log2(1) == 0 */
+  TESTIT (log2, 2.0, 1.0); /* log2(2) == 1 */
+  TESTIT (log2, 4.0, 2.0); /* log2(4) == 2 */
+
+  TESTIT (log10, 1.0, 0.0); /* log10(1) == 0 */
+  TESTIT (log10, 10.0, 1.0); /* log10(10) == 1 */
+  TESTIT (log10, 100.0, 2.0); /* log10(100) == 2 */
+
+  TESTIT (log1p, 0.0, 0.0); /* log1p(0) == 0 */
+  TESTIT (log1p, -0.0, -0.0); /* log1p(-0) == -0 */
+  TESTIT_R (log1p, M_E-1, 0.99, 1.01); /* log1p(e-1) == 1.000... */
+  TESTIT_R (log1p, M_E*M_E-1, 1.99, 2.01); /* log1p(e*e-1) == 2.000... */
+
+  TESTIT (cbrt, -0.0, -0.0); /* cbrt(-0) == -0 */
+  TESTIT (cbrt, 0.0, 0.0); /* cbrt(0) == 0 */
+  TESTIT (cbrt, 1.0, 1.0); /* cbrt(1) == 1 */
+  TESTIT (cbrt, -1.0, -1.0); /* cbrt(-1) == -1 */
+  TESTIT (cbrt, 8.0, 2.0); /* cbrt(8) == 2 */
+  TESTIT (cbrt, -8.0, -2.0); /* cbrt(-8) == -2 */
+
+  TESTIT (erf, -0.0, -0.0); /* erf(-0) == -0 */
+  TESTIT (erf, 0.0, 0.0); /* erf(0) == 0 */
+  TESTIT_R (erf, 1.0, 0.84, 0.85); /* erf(1) == 0.842... */
+  TESTIT_R (erf, -1.0, -0.85, -0.84); /* erf(-1) == -0.842... */
+
+  TESTIT (erfc, -0.0, 1.0); /* erfc(-0) == 1 */
+  TESTIT (erfc, 0.0, 1.0); /* erfc(0) == 1 */
+  TESTIT_R (erfc, 1.0, 0.15, 0.16); /* erfc(1) == 0.157... */
+  TESTIT_R (erfc, -1.0, 1.84, 1.85); /* erfc(-1) == 1.842... */
+
+  TESTIT_R (tgamma, -4.5, -0.061, -0.060); /* tgamma(-4.5) == -0.06001... */
+  TESTIT_R (tgamma, -3.5, 0.27, 0.28); /* tgamma(-3.5) == 0.27008... */
+  TESTIT_R (tgamma, -2.5, -0.95, -0.94); /* tgamma(-2.5) == -0.945... */
+  TESTIT_R (tgamma, -1.5, 2.36, 2.37); /* tgamma(-1.5) == 2.363... */
+  TESTIT_R (tgamma, -0.5, -3.55, -3.54); /* tgamma(-0.5) == -3.544... */
+  TESTIT_R (tgamma, 0.5, 1.77, 1.78); /* tgamma(0.5) == 1.772... */
+  TESTIT (tgamma, 1.0, 1.0); /* tgamma(1) == 1 */
+  TESTIT_R (tgamma, 1.5, 0.88, 0.89); /* tgamma(1.5) == 0.886... */
+  TESTIT (tgamma, 2.0, 1.0); /* tgamma(2) == 1 */
+  TESTIT_R (tgamma, 2.5, 1.32, 1.33); /* tgamma(2.5) == 1.329... */
+  TESTIT (tgamma, 3.0, 2.0); /* tgamma(3) == 2 */
+  TESTIT_R (tgamma, 3.5, 3.32, 3.33); /* tgamma(3.5) == 3.323... */
+  TESTIT (tgamma, 4.0, 6.0); /* tgamma(4) == 6 */
+  TESTIT_R (tgamma, 4.5, 11.63, 11.64); /* tgamma(4.5) == 11.631... */
+
+  TESTIT2 (pow, 3.0, 4.0, 81.0); /* pow(3,4) == 81 */
+  TESTIT2 (pow, -3.0, 5.0, -243.0); /* pow(-3,5) == -243 */
+  TESTIT2 (pow, 16.0, 0.25, 2.0); /* pow(16,1/4) == 2 */
+  TESTIT2 (pow, 4.0, -2.0, 0.0625); /* pow(4,-2) == 1/16 */
+  TESTIT2 (pow, -2.0, -3.0, -0.125); /* pow(-2,-3) == -1/8 */
+  TESTIT2_R (pow, -1.5, -3.0, -0.297, -0.296); /* pow(-1.5,-3) == -1/3.375 */
+
+  TESTIT2 (hypot, 0.0, 0.0, 0.0); /* hypot(0,0) == 0 */
+  TESTIT2 (hypot, -0.0, 0.0, 0.0); /* hypot(-0,0) == 0 */
+  TESTIT2 (hypot, 0.0, -0.0, 0.0); /* hypot(0,-0) == 0 */
+  TESTIT2 (hypot, -0.0, -0.0, 0.0); /* hypot(-0,-0) == 0 */
+  TESTIT2 (hypot, 3.0, 4.0, 5.0); /* hypot(3,4) == 5 */
+  TESTIT2 (hypot, -3.0, 4.0, 5.0); /* hypot(-3,4) == 5 */
+  TESTIT2 (hypot, 3.0, -4.0, 5.0); /* hypot(3,-4) == 5 */
+  TESTIT2 (hypot, -3.0, -4.0, 5.0); /* hypot(-3,-4) == 5 */
+  TESTIT2_R (hypot, 4.0, 5.0, 6.40, 6.41); /* hypot(4,5) == 6.403... */
+
+  TESTIT2 (atan2, 0.0, 0.0, 0.0); /* atan2(0,0) == 0 */
+  TESTIT2 (atan2, -0.0, 0.0, -0.0); /* atan2(-0,0) == -0 */
+  TESTIT2_R (atan2, 0.0, -0.0, 3.14, 3.15); /* atan2(0,-0) == pi */
+  TESTIT2_R (atan2, -0.0, -0.0, -3.15, -3.14); /* atan2(-0,-0) == -pi */
+  TESTIT2_R (atan2, 0.0, -1.0, 3.14, 3.15); /* atan2(0,-1) == pi */
+  TESTIT2_R (atan2, -0.0, -1.0, -3.15, -3.14); /* atan2(-0,-1) == -pi */
+  TESTIT2 (atan2, 0.0, 1.0, 0.0); /* atan2(0,1) == 0 */
+  TESTIT2 (atan2, -0.0, 1.0, -0.0); /* atan2(-0,1) == -0 */
+  TESTIT2_R (atan2, -1.0, 0.0, -1.58, -1.57); /* atan2(-1,0) == -pi/2 */
+  TESTIT2_R (atan2, 1.0, 0.0, 1.57, 1.58); /* atan2(1,0) == pi/2 */
+
+  TESTIT2 (fdim, 0.0, 0.0, 0.0); /* fdim(0,0) == 0 */
+  TESTIT2 (fdim, -0.0, 0.0, 0.0); /* fdim(-0,0) == 0 */
+  TESTIT2 (fdim, 0.0, -0.0, 0.0); /* fdim(0,-0) == 0 */
+  TESTIT2 (fdim, -0.0, -0.0, 0.0); /* fdim(-0,-0) == 0 */
+  TESTIT2 (fdim, 5.0, 5.0, 0.0); /* fdim(5,5) == 0 */
+  TESTIT2 (fdim, 5.0, 6.0, 0.0); /* fdim(5,6) == 0 */
+  TESTIT2 (fdim, 6.0, 5.0, 1.0); /* fdim(6,5) == 1 */
+  TESTIT2 (fdim, -5.0, -6.0, 1.0); /* fdim(-5,-6) == 1 */
+  TESTIT2 (fdim, -6.0, -5.0, 0.0); /* fdim(-6,-5) == 0 */
+
+  TESTIT2 (fmin, 5.0, 6.0, 5.0); /* fmin(5,6) == 5 */
+  TESTIT2 (fmin, 6.0, 5.0, 5.0); /* fmin(6,5) == 5 */
+  TESTIT2 (fmin, -5.0, -6.0, -6.0); /* fmin(-5,-6) == -6 */
+  TESTIT2 (fmin, -6.0, -5.0, -6.0); /* fmin(-6,-5) == -6 */
+  TESTIT2 (fmin, -0.0, 0.0, -0.0); /* fmin(-0,0) == -0 */
+  TESTIT2 (fmin, 0.0, -0.0, -0.0); /* fmin(-0,0) == -0 */
+
+  TESTIT2 (fmax, 5.0, 6.0, 6.0); /* fmax(5,6) == 6 */
+  TESTIT2 (fmax, 6.0, 5.0, 6.0); /* fmax(6,5) == 6 */
+  TESTIT2 (fmax, -5.0, -6.0, -5.0); /* fmax(-5,-6) == -5 */
+  TESTIT2 (fmax, -6.0, -5.0, -5.0); /* fmax(-6,-5) == -5 */
+  TESTIT2 (fmax, -0.0, 0.0, 0.0); /* fmax(-0,0) == 0 */
+  TESTIT2 (fmax, 0.0, -0.0, 0.0); /* fmax(-0,0) == 0 */
+
+  TESTIT3 (fma, 2.0, 3.0, 4.0, 10.0); /* fma(2,3,4) == 10 */
+  TESTIT3 (fma, 2.0, -3.0, 4.0, -2.0); /* fma(2,-3,4) == -2 */
+  TESTIT3 (fma, 2.0, 3.0, -4.0, 2.0); /* fma(2,3,-4) == 2 */
+  TESTIT3 (fma, 2.0, -3.0, -4.0, -10.0); /* fma(2,-3,-4) == -10 */
+  TESTIT3 (fma, -2.0, -3.0, -4.0, 2.0); /* fma(-2,-3,-4) == 2 */
+  TESTIT3 (fma, 6.0, -0.0, 0.0, 0.0); /* fma(6,-0,0) == 0 */
+  TESTIT3 (fma, -0.0, 6.0, 0.0, 0.0); /* fma(-0,6,0) == 0 */
+  TESTIT3 (fma, 6.0, -0.0, -0.0, -0.0); /* fma(6,-0,-0) == -0 */
+  TESTIT3 (fma, -0.0, 6.0, -0.0, -0.0); /* fma(-0,6,-0) == -0 */
+  TESTIT3 (fma, 0.0, 0.0, 0.0, 0.0); /* fma(0,0,0) == 0 */
+  TESTIT3 (fma, -0.0, 0.0, 0.0, 0.0); /* fma(-0,0,0) == 0 */
+  TESTIT3 (fma, 0.0, -0.0, 0.0, 0.0); /* fma(0,-0,0) == 0 */
+  TESTIT3 (fma, -0.0, -0.0, 0.0, 0.0); /* fma(-0,-0,0) == 0 */
+  TESTIT3 (fma, 0.0, 0.0, -0.0, 0.0); /* fma(0,0,-0) == 0 */
+  TESTIT3 (fma, -0.0, 0.0, -0.0, -0.0); /* fma(-0,0,-0) == -0 */
+  TESTIT3 (fma, 0.0, -0.0, -0.0, -0.0); /* fma(0,-0,-0) == -0 */
+  TESTIT3 (fma, -0.0, -0.0, -0.0, 0.0); /* fma(-0,-0,-0) == 0 */
+
+  if (__builtin_fmaf(__FLT_MAX__, 2.0F, -__FLT_MAX__) != __FLT_MAX__)
+    link_error (__LINE__);
+  if (__builtin_fmaf(2.0F,__FLT_MAX__, -__FLT_MAX__) != __FLT_MAX__)
+    link_error (__LINE__);
+  if (__builtin_fmaf(__FLT_MIN__, 0.5F, __FLT_MIN__) != __FLT_MIN__*1.5F)
+    link_error (__LINE__);
+  if (__builtin_fmaf(0.5F,__FLT_MIN__, __FLT_MIN__) != __FLT_MIN__*1.5F)
+    link_error (__LINE__);
+
+  if (__builtin_fma(__DBL_MAX__, 2.0, -__DBL_MAX__) != __DBL_MAX__)
+    link_error (__LINE__);
+  if (__builtin_fma(2.0,__DBL_MAX__, -__DBL_MAX__) != __DBL_MAX__)
+    link_error (__LINE__);
+  if (__builtin_fma(__DBL_MIN__, 0.5, __DBL_MIN__) != __DBL_MIN__*1.5)
+    link_error (__LINE__);
+  if (__builtin_fma(0.5,__DBL_MIN__, __DBL_MIN__) != __DBL_MIN__*1.5)
+    link_error (__LINE__);
+
+  if (__builtin_fmal(__LDBL_MAX__, 2.0L, -__LDBL_MAX__) != __LDBL_MAX__)
+    link_error (__LINE__);
+  if (__builtin_fmal(2.0L,__LDBL_MAX__, -__LDBL_MAX__) != __LDBL_MAX__)
+    link_error (__LINE__);
+  if (__builtin_fmal(__LDBL_MIN__, 0.5L, __LDBL_MIN__) != __LDBL_MIN__*1.5L)
+    link_error (__LINE__);
+  if (__builtin_fmal(0.5L,__LDBL_MIN__, __LDBL_MIN__) != __LDBL_MIN__*1.5L)
+    link_error (__LINE__);
+
+  TESTIT (sqrt, -0.0, -0.0); /* sqrt(-0) == -0 */
+  TESTIT (sqrt, 0.0, 0.0); /* sqrt(0) == 0 */
+  TESTIT (sqrt, 1.0, 1.0); /* sqrt(1) == 1 */
+  TESTIT (sqrt, 4.0, 2.0); /* sqrt(4) == 2 */
+  TESTIT_R (sqrt, 1.5, 1.22, 1.23); /* sqrt(1.5) == 1.224... */
+  TESTIT_R (sqrt, 2.0, 1.41, 1.42); /* sqrt(2) == 1.414... */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-4.c
new file mode 100644
index 000000000..d47e13933
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-math-4.c
@@ -0,0 +1,311 @@
+/* Copyright (C) 2007  Free Software Foundation.
+
+   Verify that built-in math function constant folding of constant
+   arguments is correctly performed by the compiler.  This testcase is
+   for functionality that was available as of mpfr-2.3.0.
+
+   Origin: Kaveh R. Ghazi,  April 23, 2007.  */
+
+/* { dg-do link } */
+
+/* All references to link_error should go away at compile-time.  */
+extern void link_error(int);
+
+/* Return TRUE if the sign of X != sign of Y.  This is important when
+   comparing signed zeros.  */
+#define CKSGN_F(X,Y) \
+  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+#define CKSGN(X,Y) \
+  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+#define CKSGN_L(X,Y) \
+  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+
+/* Test that FUNC(ARG) == (RES).  */
+#define TESTIT(FUNC,ARG,RES) do { \
+  if (__builtin_##FUNC##f(ARG##F) != RES##F \
+      || CKSGN_F(__builtin_##FUNC##f(ARG##F),RES##F)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG) != RES \
+      || CKSGN(__builtin_##FUNC(ARG),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG##L) != RES##L \
+      || CKSGN_L(__builtin_##FUNC##l(ARG##L),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Range test, check that (LOW) < FUNC(ARG) < (HI).  */
+#define TESTIT_R(FUNC,ARG,LOW,HI) do { \
+  if (__builtin_##FUNC##f(ARG) <= (LOW) || __builtin_##FUNC##f(ARG) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG) <= (LOW) || __builtin_##FUNC(ARG) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG) <= (LOW) || __builtin_##FUNC##l(ARG) >= (HI)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(ARG1, ARG2) == (RES).  */
+#define TESTIT2(FUNC,ARG1,ARG2,RES) do { \
+  if (__builtin_##FUNC##f(ARG1, ARG2##F) != RES##F \
+      || CKSGN_F(__builtin_##FUNC##f(ARG1,ARG2##F),RES##F)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG1, ARG2) != RES \
+      || CKSGN(__builtin_##FUNC(ARG1,ARG2),RES)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG1, ARG2##L) != RES##L \
+      || CKSGN_L(__builtin_##FUNC##l(ARG1,ARG2##L),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Range test, check that (LOW) < FUNC(ARG1,ARG2) < (HI).  */
+#define TESTIT2_R(FUNC,ARG1,ARG2,LOW,HI) do { \
+  if (__builtin_##FUNC##f(ARG1, ARG2##F) <= (LOW) \
+      || __builtin_##FUNC##f(ARG1, ARG2##F) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(ARG1, ARG2) <= (LOW) \
+      || __builtin_##FUNC(ARG1, ARG2) >= (HI)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(ARG1, ARG2##L) <= (LOW) \
+      || __builtin_##FUNC##l(ARG1, ARG2##L) >= (HI)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that remquo(ARG0, ARG1, &ARG_Q) == RES and ARG_Q == RES_Q.
+   Also test remainder/drem (ARG0,ARG1) == RES.  */
+#define TESTIT2_REMQUO(ARG0,ARG1,ARG_Q,RES,RES_Q) do { \
+  ARG_Q = 12345; \
+  if (__builtin_remquof(ARG0##F, ARG1##F, &ARG_Q) != RES##F \
+      || CKSGN_F(__builtin_remquof(ARG0##F, ARG1##F, &ARG_Q),RES##F) \
+      || ARG_Q != RES_Q \
+      || __builtin_remainderf(ARG0##F, ARG1##F) != RES##F \
+      || CKSGN_F(__builtin_remainderf(ARG0##F, ARG1##F),RES##F) \
+      || __builtin_dremf(ARG0##F, ARG1##F) != RES##F \
+      || CKSGN_F(__builtin_dremf(ARG0##F, ARG1##F),RES##F)) \
+    link_error(__LINE__); \
+  ARG_Q = 12345; \
+  if (__builtin_remquo(ARG0, ARG1, &ARG_Q) != RES \
+      || CKSGN(__builtin_remquo(ARG0, ARG1, &ARG_Q),RES) \
+      || ARG_Q != RES_Q \
+      || __builtin_remainder(ARG0, ARG1) != RES \
+      || CKSGN(__builtin_remainder(ARG0, ARG1),RES) \
+      || __builtin_drem(ARG0, ARG1) != RES \
+      || CKSGN(__builtin_drem(ARG0, ARG1),RES)) \
+    link_error(__LINE__); \
+  ARG_Q = 12345; \
+  if (__builtin_remquol(ARG0##L, ARG1##L, &ARG_Q) != RES##L \
+      || CKSGN_L(__builtin_remquol(ARG0##L, ARG1##L, &ARG_Q),RES##L) \
+      || ARG_Q != RES_Q \
+      || __builtin_remainderl(ARG0##L, ARG1##L) != RES##L \
+      || CKSGN_L(__builtin_remainderl(ARG0##L, ARG1##L),RES##L) \
+      || __builtin_dreml(ARG0##L, ARG1##L) != RES##L \
+      || CKSGN_L(__builtin_dreml(ARG0##L, ARG1##L),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(ARG,&SG) == (RES) && SG == RES_SG.  */
+#define TESTIT_LGAMMA_REENT(FUNC,ARG,RES,RES_SG) do { \
+  int sg; \
+  sg = 123; \
+  if (__builtin_##FUNC##f_r(ARG##F,&sg) != RES##F \
+      || sg != RES_SG \
+      || CKSGN_F(__builtin_##FUNC##f_r(ARG##F,&sg),RES##F)) \
+    link_error(__LINE__); \
+  sg = 123; \
+  if (__builtin_##FUNC##_r(ARG,&sg) != RES \
+      || sg != RES_SG \
+      || CKSGN(__builtin_##FUNC##_r(ARG,&sg),RES)) \
+    link_error(__LINE__); \
+  sg = 123; \
+  if (__builtin_##FUNC##l_r(ARG##L,&sg) != RES##L \
+      || sg != RES_SG \
+      || CKSGN_L(__builtin_##FUNC##l_r(ARG##L,&sg),RES##L)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Range test, check that (LOW) < FUNC(ARG,&SG) < (HI), and also test
+   that SG == RES_SG.  */
+#define TESTIT_LGAMMA_REENT_R(FUNC,ARG,LOW,HI,RES_SG) do { \
+  int sg; \
+  sg = 123; \
+  if (__builtin_##FUNC##f_r(ARG,&sg) <= (LOW) || __builtin_##FUNC##f_r(ARG,&sg) >= (HI) \
+      || sg != RES_SG) \
+    link_error(__LINE__); \
+  sg = 123; \
+  if (__builtin_##FUNC##_r(ARG,&sg) <= (LOW) || __builtin_##FUNC##_r(ARG,&sg) >= (HI) \
+      || sg != RES_SG) \
+    link_error(__LINE__); \
+  sg = 123; \
+  if (__builtin_##FUNC##l_r(ARG,&sg) <= (LOW) || __builtin_##FUNC##l_r(ARG,&sg) >= (HI) \
+      || sg != RES_SG) \
+    link_error(__LINE__); \
+  } while (0)
+
+int main (void)
+{
+#ifdef __OPTIMIZE__
+  int q;
+#endif
+
+  TESTIT (j0, 0.0, 1.0); /* j0(0) == 1 */
+  TESTIT (j0, -0.0, 1.0); /* j0(-0) == 1 */
+  TESTIT_R (j0, 1.0, 0.765, 0.766); /* j0(1) == 0.7651... */
+  TESTIT_R (j0, -1.0, 0.765, 0.766); /* j0(-1) == 0.7651... */
+
+  TESTIT (j1, 0.0, 0.0); /* j1(0) == 0 */
+  TESTIT (j1, -0.0, -0.0); /* j1(-0) == -0 */
+  TESTIT_R (j1, 1.0, 0.44, 0.45); /* j1(1) == 0.440... */
+  TESTIT_R (j1, -1.0, -0.45, -0.44); /* j1(-1) == -0.440... */
+
+  TESTIT2 (jn, 5, 0.0, 0.0); /* jn(5,0) == 0 */
+  TESTIT2 (jn, 5, -0.0, -0.0); /* jn(5,-0) == -0 */
+  TESTIT2 (jn, 6, 0.0, 0.0); /* jn(6,0) == 0 */
+  TESTIT2 (jn, 6, -0.0, 0.0); /* jn(6,-0) == 0 */
+
+  TESTIT2 (jn, -5, 0.0, -0.0); /* jn(-5,0) == -0 */
+  TESTIT2 (jn, -5, -0.0, 0.0); /* jn(-5,-0) == 0 */
+  TESTIT2 (jn, -6, 0.0, 0.0); /* jn(-6,0) == 0 */
+  TESTIT2 (jn, -6, -0.0, 0.0); /* jn(-6,-0) == 0 */
+
+  TESTIT2_R (jn, 2, 1.0, 0.11, 0.12); /* jn(2,1) == 0.114... */
+  TESTIT2_R (jn, 2, -1.0, 0.11, 0.12); /* jn(2,-1) == 0.114... */
+  TESTIT2_R (jn, 3, 5.0, 0.36, 0.37); /* jn(3,5) == 0.364... */
+  TESTIT2_R (jn, 3, -5.0, -0.37, -0.36); /* jn(3,-5) == -0.364... */
+
+  TESTIT2_R (jn, -2, 1.0, 0.11, 0.12); /* jn(-2,1) == 0.114... */
+  TESTIT2_R (jn, -2, -1.0, 0.11, 0.12); /* jn(-2,-1) == 0.114... */
+  TESTIT2_R (jn, -3, 5.0, -0.37, -0.36); /* jn(-3,5) == -0.364... */
+  TESTIT2_R (jn, -3, -5.0, 0.36, 0.37); /* jn(-3,-5) == 0.364... */
+
+  TESTIT2_R (jn, 4, 3.5, 0.20, 0.21); /* jn(4,3.5) == 0.204... */
+  TESTIT2_R (jn, 4, -3.5, 0.20, 0.21); /* jn(4,-3.5) == 0.204... */
+  TESTIT2_R (jn, 5, 4.6, 0.20, 0.21); /* jn(5,4.6) == 0.207... */
+  TESTIT2_R (jn, 5, -4.6, -0.21, -0.20); /* jn(5,-4.6) == -0.207... */
+
+  TESTIT2_R (jn, -4, 3.5, 0.20, 0.21); /* jn(-4,3.5) == 0.204... */
+  TESTIT2_R (jn, -4, -3.5, 0.20, 0.21); /* jn(-4,-3.5) == 0.204... */
+  TESTIT2_R (jn, -5, 4.6, -0.21, -0.20); /* jn(-5,4.6) == -0.207... */
+  TESTIT2_R (jn, -5, -4.6, 0.20, 0.21); /* jn(-5,-4.6) == 0.207... */
+
+  TESTIT_R (y0, 5.0, -0.31, -0.30); /* y0(5) == -0.308... */
+  TESTIT_R (y0, 0.1, -1.54, -1.53); /* y0(0.1) == -1.534... */
+
+  TESTIT_R (y1, 5.0, 0.14, 0.15); /* y1(5) == 0.147... */
+  TESTIT_R (y1, 0.1, -6.46, -6.45); /* y1(0.1) == -6.458... */
+
+  TESTIT2_R (yn, -1, 3.0, -0.33, -0.32); /* yn(-1,3) == -0.324... */
+  TESTIT2_R (yn, -1, 0.25, 2.70, 2.71); /* yn(-1,0.25) == 2.704... */
+
+  TESTIT2_R (yn, 2, 4.0, 0.21, 0.22); /* yn(2,4) == 0.215... */
+  TESTIT2_R (yn, 2, 0.9, -1.95, -1.94); /* yn(2,0.9) == -1.945... */
+  TESTIT2_R (yn, -2, 4.0, 0.21, 0.22); /* yn(-2,4) == 0.215... */
+  TESTIT2_R (yn, -2, 0.9, -1.95, -1.94); /* yn(-2,0.9) == -1.945... */
+
+  TESTIT2_R (yn, 3, 6.0, 0.32, 0.33); /* yn(3,6) == 0.328... */
+  TESTIT2_R (yn, 3, 0.89, -8.03, -8.02); /* yn(3,0.89) == -8.020... */
+  TESTIT2_R (yn, -3, 8.0, -0.03, -0.02); /* yn(-3,8) == -0.026... */
+  TESTIT2_R (yn, -3, 0.99, 5.98, 5.99); /* yn(-3,0.99) == 5.982... */
+
+#ifdef __OPTIMIZE__
+  /* These tests rely on propagating the variable q, which happens
+     only when optimization is turned on.  This macro also tests
+     remainder/drem.  */
+  TESTIT2_REMQUO (0.0, 1.0, q, 0.0, 0); /* remquo(0,1,&q)==0, q==0 */
+  TESTIT2_REMQUO (1.0, 1.0, q, 0.0, 1); /* remquo(1,1,&q)==0, q==1 */
+  TESTIT2_REMQUO (2.0, 1.0, q, 0.0, 2); /* remquo(2,1,&q)==0, q==2 */
+  TESTIT2_REMQUO (-0.0, 1.0, q, -0.0, 0); /* remquo(-0,1,&q)==-0, q==0 */
+  TESTIT2_REMQUO (-1.0, 1.0, q, -0.0, -1); /* remquo(-1,1,&q)==-0, q==-1 */
+  TESTIT2_REMQUO (-2.0, 1.0, q, -0.0, -2); /* remquo(-2,1,&q)==-0, q==-2 */
+
+  TESTIT2_REMQUO (0.0, -1.0, q, 0.0, 0); /* remquo(0,-1,&q)==0, q==0 */
+  TESTIT2_REMQUO (1.0, -1.0, q, 0.0, -1); /* remquo(1,-1,&q)==0, q==-1 */
+  TESTIT2_REMQUO (2.0, -1.0, q, 0.0, -2); /* remquo(2,-1,&q)==0, q==-2 */
+  TESTIT2_REMQUO (-0.0, -1.0, q, -0.0, 0); /* remquo(-0,-1,&q)==-0, q==0 */
+  TESTIT2_REMQUO (-1.0, -1.0, q, -0.0, 1); /* remquo(-1,-1,&q)==-0, q==1 */
+  TESTIT2_REMQUO (-2.0, -1.0, q, -0.0, 2); /* remquo(-2,-1,&q)==-0, q==2 */
+
+  TESTIT2_REMQUO (1.0, 2.0, q, 1.0, 0); /* remquo(1,2,&q)==1, q==0 */
+  TESTIT2_REMQUO (3.0, 2.0, q, -1.0, 2); /* remquo(3,2,&q)==-1, q==2 */
+  TESTIT2_REMQUO (5.0, 2.0, q, 1.0, 2); /* remquo(5,2,&q)==1, q==2 */
+  TESTIT2_REMQUO (-1.0, 2.0, q, -1.0, 0); /* remquo(-1,2,&q)==-1, q==0 */
+  TESTIT2_REMQUO (-3.0, 2.0, q, 1.0, -2); /* remquo(-3,2,&q)==1, q==-2 */
+  TESTIT2_REMQUO (-5.0, 2.0, q, -1.0, -2); /* remquo(-5,2,&q)==-1, q==-2 */
+
+  TESTIT2_REMQUO (1.0, -2.0, q, 1.0, 0); /* remquo(1,-2,&q)==1, q==0 */
+  TESTIT2_REMQUO (3.0, -2.0, q, -1.0, -2); /* remquo(3,-2,&q)==-1, q==-2 */
+  TESTIT2_REMQUO (5.0, -2.0, q, 1.0, -2); /* remquo(5,-2,&q)==1, q==-2 */
+  TESTIT2_REMQUO (-1.0, -2.0, q, -1.0, 0); /* remquo(-1,-2,&q)==-1, q==0 */
+  TESTIT2_REMQUO (-3.0, -2.0, q, 1.0, 2); /* remquo(-3,-2,&q)==1, q==2 */
+  TESTIT2_REMQUO (-5.0, -2.0, q, -1.0, 2); /* remquo(-5,-2,&q)==-1, q==2 */
+
+  /* Test that the maximum possible value can be generated into the
+     int quotient, and check for wrap around (modulo) when that value
+     is exceeded.  We can only check for this when the mantissa has
+     enough bits to hold an INT_MAX value with complete precision.  */
+
+#define MAXIT(FUNC,X,R) do { \
+  q = 12345; \
+  if (__builtin_##FUNC((X), 1, &q) != 0 || q != (R)) \
+    link_error (__LINE__); \
+} while (0)
+  
+  if (sizeof(int)*__CHAR_BIT__ <= __FLT_MANT_DIG__)
+  {
+    MAXIT(remquof, __INT_MAX__-1.0F, __INT_MAX__-1);
+    MAXIT(remquof, __INT_MAX__+0.0F, __INT_MAX__);
+    MAXIT(remquof, __INT_MAX__+1.0F, 0);
+    MAXIT(remquof, __INT_MAX__+2.0F, 1);
+
+    MAXIT(remquof, -(__INT_MAX__-1.0F), -(__INT_MAX__-1));
+    MAXIT(remquof, -(__INT_MAX__+0.0F), -__INT_MAX__);
+    MAXIT(remquof, -(__INT_MAX__+1.0F), 0);
+    MAXIT(remquof, -(__INT_MAX__+2.0F), -1);
+  }
+
+  if (sizeof(int)*__CHAR_BIT__ <= __DBL_MANT_DIG__)
+  {
+    MAXIT(remquo, __INT_MAX__-1.0, __INT_MAX__-1);
+    MAXIT(remquo, __INT_MAX__+0.0, __INT_MAX__);
+    MAXIT(remquo, __INT_MAX__+1.0, 0);
+    MAXIT(remquo, __INT_MAX__+2.0, 1);
+
+    MAXIT(remquo, -(__INT_MAX__-1.0), -(__INT_MAX__-1));
+    MAXIT(remquo, -(__INT_MAX__+0.0), -__INT_MAX__);
+    MAXIT(remquo, -(__INT_MAX__+1.0), 0);
+    MAXIT(remquo, -(__INT_MAX__+2.0), -1);
+  }
+
+  if (sizeof(int)*__CHAR_BIT__ <= __LDBL_MANT_DIG__)
+  {
+    MAXIT(remquo, __INT_MAX__-1.0L, __INT_MAX__-1);
+    MAXIT(remquo, __INT_MAX__+0.0L, __INT_MAX__);
+    MAXIT(remquo, __INT_MAX__+1.0L, 0);
+    MAXIT(remquo, __INT_MAX__+2.0L, 1);
+
+    MAXIT(remquol, -(__INT_MAX__-1.0L), -(__INT_MAX__-1));
+    MAXIT(remquol, -(__INT_MAX__+0.0L), -__INT_MAX__);
+    MAXIT(remquol, -(__INT_MAX__+1.0L), 0);
+    MAXIT(remquol, -(__INT_MAX__+2.0L), -1);
+  }
+
+  /* These tests rely on propagating the variable sg which contains
+     signgam.  This happens only when optimization is turned on.  */
+  TESTIT_LGAMMA_REENT_R (lgamma, -2.5, -0.06, -0.05, -1); /* lgamma_r(-2.5) == -0.056... */
+  TESTIT_LGAMMA_REENT_R (lgamma, -1.5, 0.86, 0.87, 1); /* lgamma_r(-1.5) == 0.860... */
+  TESTIT_LGAMMA_REENT_R (lgamma, -0.5, 1.26, 1.27, -1); /* lgamma_r(-0.5) == 1.265... */
+  TESTIT_LGAMMA_REENT_R (lgamma, 0.5, 0.57, 0.58, 1); /* lgamma_r(0.5) == 0.572... */
+  TESTIT_LGAMMA_REENT (lgamma, 1.0, 0.0, 1); /* lgamma_r(1) == 0 */
+  TESTIT_LGAMMA_REENT_R (lgamma, 1.5, -0.13, -0.12, 1); /* lgamma_r(1.5) == -0.120... */
+  TESTIT_LGAMMA_REENT (lgamma, 2.0, 0.0, 1); /* lgamma_r(2) == 0 */
+  TESTIT_LGAMMA_REENT_R (lgamma, 2.5, 0.28, 0.29, 1); /* lgamma_r(2.5) == 0.284... */
+
+  TESTIT_LGAMMA_REENT_R (gamma, -2.5, -0.06, -0.05, -1); /* gamma_r(-2.5) == -0.056... */
+  TESTIT_LGAMMA_REENT_R (gamma, -1.5, 0.86, 0.87, 1); /* gamma_r(-1.5) == 0.860... */
+  TESTIT_LGAMMA_REENT_R (gamma, -0.5, 1.26, 1.27, -1); /* gamma_r(-0.5) == 1.265... */
+  TESTIT_LGAMMA_REENT_R (gamma, 0.5, 0.57, 0.58, 1); /* gamma_r(0.5) == 0.572... */
+  TESTIT_LGAMMA_REENT (gamma, 1.0, 0.0, 1); /* gamma_r(1) == 0 */
+  TESTIT_LGAMMA_REENT_R (gamma, 1.5, -0.13, -0.12, 1); /* gamma_r(1.5) == -0.120... */
+  TESTIT_LGAMMA_REENT (gamma, 2.0, 0.0, 1); /* gamma_r(2) == 0 */
+  TESTIT_LGAMMA_REENT_R (gamma, 2.5, 0.28, 0.29, 1); /* gamma_r(2.5) == 0.284... */
+#endif
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-minmax-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-minmax-1.c
new file mode 100644
index 000000000..13831ad3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-minmax-1.c
@@ -0,0 +1,128 @@
+/* Copyright (C) 2006  Free Software Foundation.
+
+   Verify that built-in math function folding of fmin/fmax is
+   correctly performed by the compiler.
+
+   Origin: Kaveh R. Ghazi,  November 13, 2006.  */
+
+/* { dg-do link } */
+/* { dg-options "-fno-math-errno" } */
+
+/* All references to link_error should go away at compile-time.  */
+extern void link_error(int);
+
+#define DECLARE(FUNC) \
+  extern float FUNC##f (float); \
+  extern double FUNC (double); \
+  extern long double FUNC##l (long double)
+#define DECLARE2(FUNC) \
+  extern float FUNC##f (float, float); \
+  extern double FUNC (double, double); \
+  extern long double FUNC##l (long double, long double)
+
+DECLARE2(fmin);
+DECLARE2(fmax);
+DECLARE(fabs);
+extern int pure(int) __attribute__ ((__pure__));
+
+/* Test that FUNC(x,x) == x.  We cast to (long) so "!=" folds.  */
+#define TEST_EQ(FUNC) do { \
+  if ((long)FUNC##f(xf,xf) != (long)xf) \
+    link_error(__LINE__); \
+  if ((long)FUNC(x,x) != (long)x) \
+    link_error(__LINE__); \
+  if ((long)FUNC##l(xl,xl) != (long)xl) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(purefn,purefn) == purefn.  We cast to (long) so "!=" folds.  */
+#define TEST_EQ_PURE(FUNC) do { \
+  if ((long)FUNC##f(pure(i),pure(i)) != (long)FUNC##f(pure(i),pure(i))) \
+    link_error(__LINE__); \
+  if ((long)FUNC(pure(i),pure(i)) != (long)FUNC(pure(i),pure(i))) \
+    link_error(__LINE__); \
+  if ((long)FUNC##l(pure(i),pure(i)) != (long)FUNC##l(pure(i),pure(i))) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FIXFUNC(FUNC(int1,int2)) == (TYPE)FUNC(int1,int2),
+   i.e. FIXFUNC should be folded away and replaced with a cast.  */
+#define TEST_FIXFUNC(FUNC,FIXFUNC,TYPE) do { \
+  if (FIXFUNC##f(FUNC##f(i,j)) != (TYPE)FUNC##f(i,j)) \
+    link_error(__LINE__); \
+  if (FIXFUNC(FUNC(i,j)) != (TYPE)FUNC(i,j)) \
+    link_error(__LINE__); \
+  if (FIXFUNC##l(FUNC##l(i,j)) != (TYPE)FUNC##l(i,j)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(int1,int2) has an integer return type.  */
+#define TEST_INT(FUNC) do { \
+  TEST_FIXFUNC(FUNC,__builtin_lround,long); \
+  TEST_FIXFUNC(FUNC,__builtin_llround,long long); \
+  TEST_FIXFUNC(FUNC,__builtin_lrint,long); \
+  TEST_FIXFUNC(FUNC,__builtin_llrint,long long); \
+  TEST_FIXFUNC(FUNC,__builtin_lceil,long); \
+  TEST_FIXFUNC(FUNC,__builtin_llceil,long long); \
+  TEST_FIXFUNC(FUNC,__builtin_lfloor,long); \
+  TEST_FIXFUNC(FUNC,__builtin_llfloor,long long); \
+  } while (0)
+
+/* Test that (long)fabs(FUNC(fabs(x),fabs(y))) ==
+   (long)FUNC(fabs(x),fabs(y)).  We cast to (long) so "!=" folds.  */
+#define TEST_NONNEG(FUNC) do { \
+  if ((long)fabsf(FUNC##f(fabsf(xf),fabsf(yf))) != (long)FUNC##f(fabsf(xf),fabsf(yf))) \
+    link_error(__LINE__); \
+  if ((long)fabs(FUNC(fabs(x),fabs(y))) != (long)FUNC(fabs(x),fabs(y))) \
+    link_error(__LINE__); \
+  if ((long)fabsl(FUNC##l(fabsl(xl),fabsl(yl))) != (long)FUNC##l(fabsl(xl),fabsl(yl))) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(NaN,x) == x.  We cast to (long) so "!=" folds.  Set
+   parameter SIGNAL to `s' for testing signaling NaN.  */
+#define TEST_NAN(FUNC,SIGNAL) do { \
+  if ((long)FUNC##f(__builtin_nan##SIGNAL##f(""),xf) != (long)xf) \
+    link_error(__LINE__); \
+  if ((long)FUNC##f(xf,__builtin_nan##SIGNAL##f("")) != (long)xf) \
+    link_error(__LINE__); \
+  if ((long)FUNC(__builtin_nan##SIGNAL(""),x) != (long)x) \
+    link_error(__LINE__); \
+  if ((long)FUNC(x,__builtin_nan##SIGNAL("")) != (long)x) \
+    link_error(__LINE__); \
+  if ((long)FUNC##l(__builtin_nan##SIGNAL##l(""),xl) != (long)xl) \
+    link_error(__LINE__); \
+  if ((long)FUNC##l(xl,__builtin_nan##SIGNAL##l("")) != (long)xl) \
+    link_error(__LINE__); \
+  } while (0)
+
+void __attribute__ ((__noinline__))
+     foo (float xf, double x, long double xl,
+	  float yf, double y, long double yl,
+	  int i, int j)
+{
+  TEST_EQ(fmin);
+  TEST_EQ(fmax);
+
+#ifdef __OPTIMIZE__
+  TEST_EQ_PURE(fmin);
+  TEST_EQ_PURE(fmax);
+#endif
+
+  TEST_INT(fmin);
+  TEST_INT(fmax);
+  
+  TEST_NONNEG(fmin);
+  TEST_NONNEG(fmax);
+
+  TEST_NAN(fmin,);
+  TEST_NAN(fmax,);
+  TEST_NAN(fmin,s);
+  TEST_NAN(fmax,s);
+}
+
+int main()
+{
+  foo (1,1,1,1,1,1,1,1);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c
new file mode 100644
index 000000000..05e16ac2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c
@@ -0,0 +1,195 @@
+/* Copyright (C) 2007  Free Software Foundation.
+
+   Verify that built-in folding of modf is correctly performed by the
+   compiler.
+
+   Origin: Kaveh R. Ghazi,  February 23, 2007.  */
+
+/* { dg-do link } */
+/* { dg-options "-fno-finite-math-only" { target sh*-*-* } } */
+/* { dg-options "-funsafe-math-optimizations -fsigned-zeros -fno-associative-math" { target powerpc-*-darwin* powerpc*-*-linux* } } */
+
+extern void link_error(int);
+
+/* Return TRUE if the sign of X != sign of Y.  This is important when
+   comparing signed zeros.  */
+#define CKSGN_F(X,Y) \
+  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+#define CKSGN(X,Y) \
+  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+#define CKSGN_L(X,Y) \
+  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+
+/* We use these macros if we can only check these when optimizing.  In
+   some cases we rely on other optimizations to propagate the value
+   and fold away certain constructs.  Likewise for the sign testing.
+   TRUE means an error occurred.  */
+#ifdef __OPTIMIZE__
+#define CKRES(X) (X)
+#define CKIPTR(X,Y) X != Y
+#define CKSGN_IPTR_F(X,Y) CKSGN_F(X,Y)
+#define CKSGN_IPTR(X,Y) CKSGN(X,Y)
+#define CKSGN_IPTR_L(X,Y) CKSGN_L(X,Y)
+#else
+#define CKRES(X) 0
+#define CKIPTR(X,Y) 0
+#define CKSGN_IPTR_F(X,Y) 0
+#define CKSGN_IPTR(X,Y) 0
+#define CKSGN_IPTR_L(X,Y) 0
+#endif
+
+/* Test that modf(ARG1,&iptr) == FRACRES && iptr == INTRES.  Check the
+   sign in case we get -0.0.  */
+#define TESTIT_MODF(ARG,INTRES,FRACRES) do { \
+  float iptrf = 0.5; double iptr = 0.5; long double iptrl = 0.5; \
+  if (__builtin_modff(ARG##f,&iptrf) != FRACRES##f \
+      || CKIPTR(iptrf,INTRES##f) \
+      || CKSGN_F(__builtin_modff(ARG##f,&iptrf),FRACRES##f) \
+      || CKSGN_IPTR_F(iptrf,INTRES##f)) \
+    link_error(__LINE__); \
+  if (__builtin_modf(ARG,&iptr) != FRACRES \
+      || CKIPTR(iptr,INTRES) \
+      || CKSGN(__builtin_modf(ARG,&iptr),FRACRES) \
+      || CKSGN_IPTR(iptr,INTRES)) \
+    link_error(__LINE__); \
+  if (__builtin_modfl(ARG##l,&iptrl) != FRACRES##l \
+      || CKIPTR(iptrl,INTRES##l) \
+      || CKSGN_L(__builtin_modfl(ARG##l,&iptrl),FRACRES##l) \
+      || CKSGN_IPTR_L(iptrl,INTRES##l)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that modf(NEG FUNCARG(ARGARG, &iptr)) == FRACRES &&
+   FUNCRES(iptr) is true.  Check the sign of both as well.  This is
+   for checking an argument of Inf.  */
+#ifndef __SPU__
+#define TESTIT_MODF2(NEG,FUNCARG,ARGARG,FUNCRES,FRACRES) do { \
+  float iptrf = 0.5; double iptr = 0.5; long double iptrl = 0.5; \
+  if (__builtin_modff(NEG __builtin_##FUNCARG##f(ARGARG),&iptrf) != FRACRES##f \
+      || CKSGN_F(__builtin_modff(NEG __builtin_##FUNCARG##f(ARGARG),&iptrf), FRACRES##f) \
+      || CKIPTR(!__builtin_##FUNCRES##f(iptrf),0) \
+      || CKSGN_IPTR_F(iptrf,FRACRES##f)) \
+    link_error(__LINE__); \
+  if (__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr) != FRACRES \
+      || CKSGN(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr), FRACRES) \
+      || CKIPTR(!__builtin_##FUNCRES(iptr),0) \
+      || CKSGN_IPTR(iptr,FRACRES)) \
+    link_error(__LINE__); \
+  if (__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl) != FRACRES##l \
+      || CKSGN_L(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl), FRACRES##l) \
+      || CKIPTR(!__builtin_##FUNCRES##l(iptrl),0) \
+      || CKSGN_IPTR_L(iptrl,FRACRES##l)) \
+    link_error(__LINE__); \
+  } while (0)
+#else
+#define TESTIT_MODF2(NEG,FUNCARG,ARGARG,FUNCRES,FRACRES) do { \
+  /* SPU single-precision floating point format does not support Inf or Nan.  */ \
+  double iptr = 0.5; long double iptrl = 0.5; \
+  if (__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr) != FRACRES \
+      || CKSGN(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr), FRACRES) \
+      || CKIPTR(!__builtin_##FUNCRES(iptr),0) \
+      || CKSGN_IPTR(iptr,FRACRES)) \
+    link_error(__LINE__); \
+  if (__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl) != FRACRES##l \
+      || CKSGN_L(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl), FRACRES##l) \
+      || CKIPTR(!__builtin_##FUNCRES##l(iptrl),0) \
+      || CKSGN_IPTR_L(iptrl,FRACRES##l)) \
+    link_error(__LINE__); \
+  } while (0)
+#endif
+
+/* Test that FUNCRES(modf(NEG FUNCARG(ARGARG, &iptr))) is true &&
+   FUNCRES(iptr) is true.  Check the sign of both as well.  This is
+   for checking an argument of NaN.  */
+#ifndef __SPU__
+#define TESTIT_MODF3(NEG,FUNCARG,ARGARG,FUNCRES) do { \
+  float iptrf = 0.5; double iptr = 0.5; long double iptrl = 0.5; \
+  if (CKRES(!__builtin_##FUNCRES##f(__builtin_modff(NEG __builtin_##FUNCARG##f(ARGARG),&iptrf))) \
+      || CKSGN_F(__builtin_modff(NEG __builtin_##FUNCARG##f(ARGARG),&iptrf), NEG 1) \
+      || CKIPTR(!__builtin_##FUNCRES##f(iptrf),0) \
+      || CKSGN_IPTR_F(iptrf,NEG 1)) \
+    link_error(__LINE__); \
+  if (CKRES(!__builtin_##FUNCRES(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr))) \
+      || CKSGN(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr), NEG 1) \
+      || CKIPTR(!__builtin_##FUNCRES(iptr),0) \
+      || CKSGN_IPTR(iptr,NEG 1)) \
+    link_error(__LINE__); \
+  if (CKRES(!__builtin_##FUNCRES##l(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl))) \
+      || CKSGN_L(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl), NEG 1) \
+      || CKIPTR(!__builtin_##FUNCRES##l(iptrl),0) \
+      || CKSGN_IPTR_L(iptrl,NEG 1)) \
+    link_error(__LINE__); \
+  } while (0)
+#else
+#define TESTIT_MODF3(NEG,FUNCARG,ARGARG,FUNCRES) do { \
+  /* SPU single-precision floating point format does not support Inf or Nan.  */ \
+  double iptr = 0.5; long double iptrl = 0.5; \
+  if (CKRES(!__builtin_##FUNCRES(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr))) \
+      || CKSGN(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr), NEG 1) \
+      || CKIPTR(!__builtin_##FUNCRES(iptr),0) \
+      || CKSGN_IPTR(iptr,NEG 1)) \
+    link_error(__LINE__); \
+  if (CKRES(!__builtin_##FUNCRES##l(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl))) \
+      || CKSGN_L(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl), NEG 1) \
+      || CKIPTR(!__builtin_##FUNCRES##l(iptrl),0) \
+      || CKSGN_IPTR_L(iptrl,NEG 1)) \
+    link_error(__LINE__); \
+  } while (0)
+#endif
+
+void __attribute__ ((__noinline__))
+foo(void)
+{
+  /* Test that modf(ARG1,&iptr) -> ARG3 && iptr == ARG2.  */
+  TESTIT_MODF (0x1p10F+0.5, 0x1p10, 0.5);
+  TESTIT_MODF (0x1p10F+0x1p-10, 0x1p10, 0x1p-10);
+  TESTIT_MODF (12345678L/17.0, 726216.0, -726216L+12345678L/17.0);
+  TESTIT_MODF (555.555, 555.0, -555+555.555);
+  TESTIT_MODF (5000/11.0, 454.0, -454+5000/11.0);
+  TESTIT_MODF (1000/7.0, 142.0, -142+1000/7.0);
+  TESTIT_MODF (123/7.0, 17.0, -17+123/7.0);
+  TESTIT_MODF (117/7.0, 16.0, -16+117/7.0);
+  TESTIT_MODF (5.5, 5.0, 0.5);
+  TESTIT_MODF (1.5, 1.0, 0.5);
+  TESTIT_MODF (4/3.0, 1.0, -1+4/3.0);
+  TESTIT_MODF (1.0, 1.0, 0.0);
+  TESTIT_MODF (0.5, 0.0, 0.5);
+  TESTIT_MODF (4/9.0, 0.0, 4/9.0);
+  TESTIT_MODF (1/3.0, 0.0, 1/3.0);
+  TESTIT_MODF (1/9.0, 0.0, 1/9.0);
+  TESTIT_MODF (0.0, 0.0, 0.0);
+
+  TESTIT_MODF (-0.0, -0.0, -0.0);
+  TESTIT_MODF (-1/9.0, -0.0, -1/9.0);
+  TESTIT_MODF (-1/3.0, -0.0, -1/3.0);
+  TESTIT_MODF (-4/9.0, -0.0, -4/9.0);
+  TESTIT_MODF (-0.5, -0.0, -0.5);
+  TESTIT_MODF (-1.0, -1.0, -0.0);
+  TESTIT_MODF (-4/3.0, -1.0, 1-4/3.0);
+  TESTIT_MODF (-1.5, -1.0, -0.5);
+  TESTIT_MODF (-5.5, -5.0, -0.5);
+  TESTIT_MODF (-117/7.0, -16.0, 16-117/7.0);
+  TESTIT_MODF (-123/7.0, -17.0, 17-123/7.0);
+  TESTIT_MODF (-1000/7.0, -142.0, 142-1000/7.0);
+  TESTIT_MODF (-5000/11.0, -454.0, 454-5000/11.0);
+  TESTIT_MODF (-555.555, -555.0, 555-555.555);
+  TESTIT_MODF (-12345678L/17.0, -726216.0, 726216L-12345678L/17.0);
+  TESTIT_MODF (-0x1p10F-0x1p-10, -0x1p10, -0x1p-10);
+  TESTIT_MODF (-0x1p10F-0.5, -0x1p10, -0.5);
+
+  
+  /* Test for modf(+-Inf,&i) -> (i=+-0.0, +-Inf).  */
+  TESTIT_MODF2 ( ,inf, , isinf, 0.0);
+  TESTIT_MODF2 (- ,inf, , isinf, -0.0);
+
+  /* Test for and modf(+-NaN,&i) -> (i=+-NaN, +-NaN).  */
+  TESTIT_MODF3 ( ,nan, "", isnan);
+  TESTIT_MODF3 (- ,nan, "", isnan);
+}
+
+int main()
+{
+  foo();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-nonneg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-nonneg-1.c
new file mode 100644
index 000000000..8a3286a59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-nonneg-1.c
@@ -0,0 +1,180 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that GCC can determine which built-in functions produce a
+   nonnegative result.
+
+   Written by Kaveh Ghazi, 2004-03-10.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+
+#define PROTOTYPE_RTYPE(FN,RTYPE) extern RTYPE FN(double); \
+  extern RTYPE FN##f(float); \
+  extern RTYPE FN##l(long double);
+#define PROTOTYPE(FN) extern double FN(double); extern float FN##f(float); \
+  extern long double FN##l(long double);
+#define PROTOTYPE2(FN) extern double FN(double, double); \
+  extern float FN##f(float, float); \
+  extern long double FN##l(long double, long double);
+#define CPROTOTYPE1(FN) extern double FN(_Complex double); \
+  extern float FN##f(_Complex float); \
+  extern long double FN##l(_Complex long double);
+#define CPROTOTYPE1(FN) extern double FN(_Complex double); \
+  extern float FN##f(_Complex float); \
+  extern long double FN##l(_Complex long double);
+#define IPROTOTYPE(FN) extern int FN(int); extern int FN##l(long); \
+  extern int FN##ll(long long);
+#define PROTOTYPE2TYPE2(FN,A2TYPE) extern double FN(double, A2TYPE); \
+  extern float FN##f(float, A2TYPE); \
+  extern long double FN##l(long double, A2TYPE);
+#define PROTOTYPE2_A2FPTR(FN) extern double FN(double, double *); \
+  extern float FN##f(float, float *); \
+  extern long double FN##l(long double, long double *);
+
+extern int signbit (double);
+extern int signbitf (float);
+extern int signbitl (long double);
+
+void test(double d1, double d2, float f1, float f2,
+	  long double ld1, long double ld2)
+{
+  /* These are always nonnegative.  */
+
+#define TEST1(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE(FN) \
+ if (signbit(FN(d1)) || signbitf(FN##f(f1)) || signbitl(FN##l(ld1))) \
+   link_failure_##FN()
+
+#define TEST2(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE2(FN) \
+ if (signbit(FN(d1,d2)) || signbitf(FN##f(f1,f2)) || signbitl(FN##l(ld1,ld2))) \
+   link_failure_##FN()
+
+#define CTEST1(FN) \
+ extern void link_failure_##FN (void); CPROTOTYPE1(FN) \
+ if (signbit(FN(d1)) || signbitf(FN##f(f1)) || signbitl(FN##l(ld1))) \
+   link_failure_##FN()
+
+#define ITEST1(FN) \
+ extern void link_failure_##FN (void); IPROTOTYPE(FN) \
+ if (signbit(FN(d1)) || signbitf(FN##l(f1)) || signbitl(FN##ll(ld1))) \
+   link_failure_##FN()
+
+  TEST1 (acos);
+  TEST1 (acosh);
+  CTEST1 (cabs);
+  TEST1 (cosh);
+  TEST1 (erfc);
+  TEST1 (exp);
+  TEST1 (exp10);
+  TEST1 (exp2);
+  TEST1 (fabs);
+  TEST2 (fdim);
+  TEST2 (hypot);
+  TEST1 (pow10);
+  TEST1 (sqrt);
+  ITEST1 (ffs);
+  ITEST1 (__builtin_parity);
+  ITEST1 (__builtin_popcount);
+
+  /* These are nonnegative if the first argument is.  */
+#define ARG1TEST1(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE(FN) \
+ if (signbit(FN(fabs(d1))) || signbitf(FN##f(fabsf(f1))) \
+     || signbitl(FN##l(fabsl(ld1)))) \
+   link_failure_##FN()
+
+  /* Same, but allow specifying the return type.  */
+#define ARG1TEST1_RTYPE(FN,RTYPE) \
+ extern void link_failure_##FN (void); PROTOTYPE_RTYPE(FN,RTYPE) \
+ if (signbit(FN(fabs(d1))) || signbitf(FN##f(fabsf(f1))) \
+     || signbitl(FN##l(fabsl(ld1)))) \
+   link_failure_##FN()
+
+  /* These are nonnegative if the first argument is.  */
+#define ARG1TEST2(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE2(FN) \
+ if (signbit(FN(fabs(d1),d2)) || signbitf(FN##f(fabsf(f1),f2)) \
+     || signbitl(FN##l(fabsl(ld1),ld2))) \
+   link_failure_##FN()
+
+  /* These are nonnegative if the second argument is.  */
+#define ARG2TEST2(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE2(FN) \
+ if (signbit(FN(d1,fabs(d2))) || signbitf(FN##f(f1,fabsf(f2))) \
+     || signbitl(FN##l(ld1,fabsl(ld2)))) \
+   link_failure_##FN()
+
+  /* These are nonnegative if the first OR second argument is.  */
+#define ARG2TESTor(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE2(FN) \
+ if (signbit(FN(fabs(d1),d2)) || signbitf(FN##f(fabsf(f1),f2)) \
+     || signbitl(FN##l(fabsl(ld1),ld2)) || signbit(FN(d1,fabs(d2))) \
+     || signbitf(FN##f(f1,fabsf(f2))) || signbitl(FN##l(ld1,fabsl(ld2)))) \
+   link_failure_##FN()
+
+  /* These are nonnegative if the first AND second argument is.  */
+#define ARG2TESTand(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE2(FN) \
+ if (signbit(FN(fabs(d1),fabs(d2))) || signbitf(FN##f(fabsf(f1),fabsf(f2))) \
+     || signbitl(FN##l(fabsl(ld1),fabsl(ld2)))) \
+   link_failure_##FN()
+
+  /* These are nonnegative if the first argument is, 2nd arg is an int.  */
+#define ARG1TEST2_A2INT(FN, INTTYPE) \
+ extern void link_failure_##FN (void); PROTOTYPE2TYPE2(FN, INTTYPE) \
+ if (signbit(FN(fabs(d1),d2)) || signbitf(FN##f(fabsf(f1),f2)) \
+     || signbitl(FN##l(fabsl(ld1),ld2))) \
+   link_failure_##FN()
+
+  /* These are nonnegative if the first argument is, specify 2nd arg.  */
+#define ARG2TEST1_A2FPTR(FN) \
+ extern void link_failure_##FN (void); PROTOTYPE2_A2FPTR(FN) \
+ if (signbit(FN(fabs(d1),&d2)) || signbitf(FN##f(fabsf(f1),&f2)) \
+     || signbitl(FN##l(fabsl(ld1),&ld2))) \
+   link_failure_##FN()
+
+  ARG1TEST1 (asinh);
+  ARG1TEST1 (atan);
+  ARG1TEST1 (atanh);
+  ARG1TEST1 (cbrt);
+  ARG1TEST1 (ceil);
+  ARG1TEST1 (erf);
+  ARG1TEST1 (expm1);
+  ARG1TEST1 (floor);
+  ARG1TEST2 (fmod);
+  ARG1TEST2_A2INT (ldexp, int);
+  ARG1TEST1_RTYPE (__builtin_llceil, long long);
+  ARG1TEST1_RTYPE (__builtin_llfloor, long long);
+  ARG1TEST1_RTYPE (llrint, long long);
+  ARG1TEST1_RTYPE (llround, long long);
+  ARG1TEST1_RTYPE (__builtin_lceil, long);
+  ARG1TEST1_RTYPE (__builtin_lfloor, long);
+  ARG1TEST1_RTYPE (lrint, long);
+  ARG1TEST1_RTYPE (lround, long);
+  /* The modf* functions aren't ever "const" or "pure" even with
+     -ffast-math so they won't be eliminated and yield a link failure.  */
+  /* ARG2TEST1_A2FPTR (modf);*/
+  ARG1TEST1 (nearbyint);
+  ARG1TEST2 (pow);
+  ARG1TEST1 (rint);
+  ARG1TEST1 (round);
+  ARG1TEST2 (scalb);
+  ARG1TEST2_A2INT (scalbln, long);
+  ARG1TEST2_A2INT (scalbn, int);
+  ARG1TEST1_RTYPE (signbit, int);
+  ARG1TEST1 (significand);
+  ARG1TEST1 (sinh);
+  ARG1TEST1 (tanh);
+  ARG1TEST1 (trunc);
+
+  ARG2TESTor (fmax);
+  ARG2TESTand (fmin);
+  ARG2TEST2 (copysign);
+
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-noret-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-noret-1.c
new file mode 100644
index 000000000..d3e97701f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-noret-1.c
@@ -0,0 +1,79 @@
+/* Test for builtin noreturn attributes.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-options "-multiply_defined suppress" { target powerpc-*-darwin* } } */
+/* { dg-do link } */
+/* { dg-require-weak "" } */
+
+extern void abort (void);
+extern void exit (int);
+extern void _exit (int);
+extern void _Exit (int);
+
+extern void tabort (void);
+extern void texit (void);
+extern void t_exit (void);
+extern void t_Exit (void);
+
+extern void link_failure (void);
+
+/* Some libcs have _exit and/or _Exit, and won't allow it to be re-defined,
+   so make it weak.  */
+#pragma weak _exit
+#pragma weak _Exit
+
+int
+main (void)
+{
+  volatile int i = 0;
+  if (i)
+    tabort ();
+  if (i)
+    texit ();
+  if (i)
+    t_exit ();
+  if (i)
+    t_Exit ();
+  exit (0);
+}
+
+void
+tabort (void)
+{
+  abort ();
+  link_failure ();
+}
+
+void
+texit (void)
+{
+  exit (1);
+  link_failure ();
+}
+
+void
+t_exit (void)
+{
+  _exit (1);
+  link_failure ();
+}
+
+/* Some non-Unix libcs might not have _exit.  */
+void
+_exit (int i)
+{
+  abort ();
+}
+
+void
+t_Exit (void)
+{
+  _Exit (1);
+  link_failure ();
+}
+
+/* Some libcs might not have _Exit.  */
+void
+_Exit (int i)
+{
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c
new file mode 100644
index 000000000..1103e3d81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-noret-2.c
@@ -0,0 +1,89 @@
+/* Test for builtin noreturn attributes when the visible declarations
+   are function-local.  Modified from builtin-noret-1.c by Zack Weinberg
+   <zack@codesourcery.com>.  */
+/* { dg-options "-multiply_defined suppress" { target powerpc-*-darwin* } } */
+/* { dg-do link } */
+/* { dg-require-weak "" } */
+
+extern void tabort (void);
+extern void texit (void);
+extern void t_exit (void);
+extern void t_Exit (void);
+
+extern void link_failure (void);
+
+int
+main (void)
+{
+  volatile int i = 0;
+  extern void exit (int);
+  if (i)
+    tabort ();
+  if (i)
+    texit ();
+  if (i)
+    t_exit ();
+  if (i)
+    t_Exit ();
+  exit (0);
+}
+
+void
+tabort (void)
+{
+  extern void abort (void);
+  abort ();
+  link_failure ();
+}
+
+void
+texit (void)
+{
+  extern void exit (int);
+  exit (1);
+  link_failure ();
+}
+
+void
+t_exit (void)
+{
+  extern void _exit (int);
+  /* Some non-Unix libcs have _exit, and won't allow it to be re-defined,
+     so make it weak.  */
+#pragma weak _exit
+  _exit (1);
+  link_failure ();
+}
+
+/* Some non-Unix libcs might not have _exit.  */
+/* Some non-Unix libcs have _exit, and won't allow it to be re-defined,
+   so make it weak.  */
+#pragma weak _exit
+void
+_exit (int i)
+{
+  extern void abort (void);
+  abort ();
+}
+
+void
+t_Exit (void)
+{
+  extern void _Exit (int);
+  /* Some libcs have _Exit, and won't allow it to be re-defined,
+     so make it weak.  */
+#pragma weak _Exit
+  _Exit (1);
+  link_failure ();
+}
+
+/* Some libcs might not have _Exit.  */
+/* Some libcs have _Exit, and won't allow it to be re-defined,
+   so make it weak.  */
+#pragma weak _Exit
+void
+_Exit (int i)
+{
+  extern void abort (void);
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-pow-mpfr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-pow-mpfr-1.c
new file mode 100644
index 000000000..6206b9ee3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-pow-mpfr-1.c
@@ -0,0 +1,19 @@
+/* Version 2.2.0 of MPFR had bugs in pow underflow/overflow.  This
+   test checks to see if that buggy version was installed.  The
+   problem is NOT fixed with the version 2.2.0 "cumulative patch".
+   However it is fixed in version 2.2.1 and presumably later MPFR
+   versions.
+
+   Origin: Kaveh R. Ghazi 12/17/2006.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-original" } */
+
+extern double testit()
+{
+  /* This underflows and therefore gcc should not fold it.  */
+  return __builtin_pow (0.11, 1.0e38);
+}
+
+/* { dg-final { scan-tree-dump "pow" "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-power-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-power-1.c
new file mode 100644
index 000000000..d1403c46c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-power-1.c
@@ -0,0 +1,113 @@
+/* Copyright (C) 2004  Free Software Foundation.
+
+   Verify that built-in folding of various math "power" functions is
+   correctly performed by the compiler.
+
+   Written by Kaveh Ghazi, 2004-03-11.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+/* { dg-add-options c99_runtime } */
+
+#include "../builtins-config.h"
+
+#ifdef HAVE_C99_RUNTIME
+#define C99CODE(CODE) CODE
+#else
+#define C99CODE(CODE) 0
+#endif
+
+#define PROTOTYPE(FN) extern double FN(double); extern float FN##f(float); \
+  extern long double FN##l(long double);
+#define PROTOTYPE2(FN) extern double FN(double, double); \
+  extern float FN##f(float, float); \
+  extern long double FN##l(long double, long double);
+
+PROTOTYPE(fabs)
+PROTOTYPE(sqrt)
+PROTOTYPE(cbrt)
+PROTOTYPE2(pow)
+
+void test(double d1, double d2, double d3,
+	  float f1, float f2, float f3,
+	  long double ld1, long double ld2, long double ld3)
+{
+  /* Test N1root(N2root(x)) -> pow(x,1/(N1*N2)).  */
+  /* E.g. sqrt(cbrt(x)) -> pow(x,1/6).  */
+  /* The `ABS' argument is `fabs' when the transformation only works
+     for nonnegative arguments.  Otherwise it's blank.  */
+#define ROOT_ROOT(FN1,N1,FN2,N2,ABS) \
+ extern void link_failure_##FN1##_##FN2(void); \
+ if (FN1(FN2(ABS(d1))) != pow(ABS(d1),1.0/(N1*N2)) \
+     || C99CODE (FN1##f(FN2##f(ABS(f1))) != powf(ABS(f1),1.0F/(N1*N2))) \
+     || C99CODE (FN1##l(FN2##l(ABS(ld1))) != powl(ABS(ld1),1.0L/(N1*N2)))) \
+    link_failure_##FN1##_##FN2()
+
+  ROOT_ROOT(sqrt,2,sqrt,2,);
+  ROOT_ROOT(sqrt,2,cbrt,3,);
+  ROOT_ROOT(cbrt,3,sqrt,2,);
+  ROOT_ROOT(cbrt,3,cbrt,3,fabs);
+
+  /* Test pow(Nroot(x),y) -> pow(x,y/N).  */
+  /* The `ABS' argument is `fabs' when the transformation only works
+     for nonnegative arguments.  Otherwise it's blank.  */
+#define POW_ROOT(FN,N,ABS) \
+ extern void link_failure_pow_##FN(void); \
+ if (pow(FN(ABS(d1)), d2) != pow(ABS(d1),d2/N) \
+     || powf(FN##f(ABS(f1)),f2) != powf(ABS(f1),f2/N) \
+     || powl(FN##l(ABS(ld1)),ld2) != powl(ABS(ld1),ld2/N)) \
+    link_failure_pow_##FN()
+
+  POW_ROOT(sqrt,2,);
+  POW_ROOT(cbrt,3,fabs);
+
+  /* Test Nroot(pow(x,y)) -> pow(x,y/N).  */
+  /* The `ABS' argument is `fabs' when the transformation only works
+     for nonnegative arguments.  Otherwise it's blank.  */
+#define ROOT_POW(FN,N,ABS) \
+ extern void link_failure_##FN##_pow(void); \
+ if (FN(pow(ABS(d1), d2)) != pow(ABS(d1),d2/N) \
+     || FN##f(powf(ABS(f1),f2)) != powf(ABS(f1),f2/N) \
+     || FN##l(powl(ABS(ld1),ld2)) != powl(ABS(ld1),ld2/N)) \
+    link_failure_##FN##_pow()
+
+  ROOT_POW(sqrt,2,fabs);
+  ROOT_POW(cbrt,3,fabs);
+
+  /* Test pow(pow(x,y),z) -> pow(x,y*z).  */
+#define POW_POW \
+ extern void link_failure_pow_pow(void); \
+ if (pow(pow(fabs(d1), d2), d3) != pow(fabs(d1),d2*d3) \
+     || powf(powf(fabs(f1),f2),f3) != powf(fabs(f1),f2*f3) \
+     || powl(powl(fabs(ld1),ld2),ld3) != powl(fabs(ld1),ld2*ld3)) \
+    link_failure_pow_pow()
+
+  POW_POW;
+
+  /* Test Nroot(x)*Nroot(y) -> Nroot(x*y).  */
+#define ROOT_X_ROOT(FN) \
+ extern void link_failure_root_x_root(void); \
+ if (FN(d1)*FN(d2) != FN(d1*d2) \
+     || FN##f(f1)*FN##f(f2) != FN##f(f1*f2) \
+     || FN##l(ld1)*FN##l(ld2) != FN##l(ld1*ld2)) \
+    link_failure_root_x_root()
+
+  ROOT_X_ROOT(sqrt);
+  ROOT_X_ROOT(cbrt);
+  
+  /* Test pow(x,y)*pow(x,z) -> pow(x,y+z).  */
+#define POW_X_POW \
+ extern void link_failure_pow_x_pow(void); \
+ if (pow(d1,d2)*pow(d1,d3) != pow(d1,d2+d3) \
+     || powf(f1,f2)*powf(f1,f3) != powf(f1,f2+f3) \
+     || powl(ld1,ld2)*powl(ld1,ld3) != powl(ld1,ld2+ld3)) \
+    link_failure_pow_x_pow()
+
+  POW_X_POW;
+  
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-rounding-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-rounding-1.c
new file mode 100644
index 000000000..816cffc04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-rounding-1.c
@@ -0,0 +1,120 @@
+/* Copyright (C) 2004 Free Software Foundation.
+
+   Check that constant folding of the rounding math functions doesn't
+   break anything and produces the expected results.
+
+   Written by Kaveh Ghazi, 2004-04-29.  */
+
+/* { dg-do link } */
+
+extern int link_error (int);
+
+#define TEST(FN, VALUE, RESULT) \
+  if (__builtin_##FN (VALUE) != RESULT) link_error (__LINE__); \
+  if (__builtin_##FN##f (VALUE) != RESULT) link_error (__LINE__); \
+  if (__builtin_##FN##l (VALUE) != RESULT) link_error (__LINE__); \
+
+int
+main (void)
+{
+  TEST(trunc,   0, 0);
+  TEST(floor,   0, 0);
+  TEST(ceil,    0, 0);
+  TEST(round,   0, 0);
+  TEST(lround,  0, 0);
+  TEST(llround, 0, 0);
+  TEST(lfloor,  0, 0);
+  TEST(llfloor, 0, 0);
+  TEST(lceil,  0, 0);
+  TEST(llceil, 0, 0);
+  
+  TEST(trunc,   6, 6);
+  TEST(floor,   6, 6);
+  TEST(ceil,    6, 6);
+  TEST(round,   6, 6);
+  TEST(lround,  6, 6);
+  TEST(llround, 6, 6);
+  TEST(lfloor,  6, 6);
+  TEST(llfloor, 6, 6);
+  TEST(lceil,  6, 6);
+  TEST(llceil, 6, 6);
+  
+  TEST(trunc,   -8, -8);
+  TEST(floor,   -8, -8);
+  TEST(ceil,    -8, -8);
+  TEST(round,   -8, -8);
+  TEST(lround,  -8, -8);
+  TEST(llround, -8, -8);
+  TEST(lfloor,  -8, -8);
+  TEST(llfloor, -8, -8);
+  TEST(lceil,  -8, -8);
+  TEST(llceil, -8, -8);
+  
+  TEST(trunc,   3.2, 3);
+  TEST(floor,   3.2, 3);
+  TEST(ceil,    3.2, 4);
+  TEST(round,   3.2, 3);
+  TEST(lround,  3.2, 3);
+  TEST(llround, 3.2, 3);
+  TEST(lfloor,  3.2, 3);
+  TEST(llfloor, 3.2, 3);
+  TEST(lceil,  3.2, 4);
+  TEST(llceil, 3.2, 4);
+
+  TEST(trunc,   -2.8, -2);
+  TEST(floor,   -2.8, -3);
+  TEST(ceil,    -2.8, -2);
+  TEST(round,   -2.8, -3);
+  TEST(lround,  -2.8, -3);
+  TEST(llround, -2.8, -3);
+  TEST(lfloor,  -2.8, -3);
+  TEST(llfloor, -2.8, -3);
+  TEST(lceil,  -2.8, -2);
+  TEST(llceil, -2.8, -2);
+
+  TEST(trunc,   0.01, 0);
+  TEST(floor,   0.01, 0);
+  TEST(ceil,    0.01, 1);
+  TEST(round,   0.01, 0);
+  TEST(lround,  0.01, 0);
+  TEST(llround, 0.01, 0);
+  TEST(lfloor,  0.01, 0);
+  TEST(llfloor, 0.01, 0);
+  TEST(lceil,  0.01, 1);
+  TEST(llceil, 0.01, 1);
+
+  TEST(trunc,   -0.7, 0);
+  TEST(floor,   -0.7, -1);
+  TEST(ceil,    -0.7, 0);
+  TEST(round,   -0.7, -1);
+  TEST(lround,  -0.7, -1);
+  TEST(llround, -0.7, -1);
+  TEST(lfloor,  -0.7, -1);
+  TEST(llfloor, -0.7, -1);
+  TEST(lceil,  -0.7, 0);
+  TEST(llceil, -0.7, 0);
+
+  TEST(trunc,   2.5, 2);
+  TEST(floor,   2.5, 2);
+  TEST(ceil,    2.5, 3);
+  TEST(round,   2.5, 3);
+  TEST(lround,  2.5, 3);
+  TEST(llround, 2.5, 3);
+  TEST(lfloor,  2.5, 2);
+  TEST(llfloor, 2.5, 2);
+  TEST(lceil,  2.5, 3);
+  TEST(llceil, 2.5, 3);
+
+  TEST(trunc,   -1.5, -1);
+  TEST(floor,   -1.5, -2);
+  TEST(ceil,    -1.5, -1);
+  TEST(round,   -1.5, -2);
+  TEST(lround,  -1.5, -2);
+  TEST(llround, -1.5, -2);
+  TEST(lfloor,  -1.5, -2);
+  TEST(llfloor, -1.5, -2);
+  TEST(lceil,  -1.5, -1);
+  TEST(llceil, -1.5, -1);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-sin-mpfr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-sin-mpfr-1.c
new file mode 100644
index 000000000..359728708
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-sin-mpfr-1.c
@@ -0,0 +1,29 @@
+/* Version 2.2.0 of MPFR had bugs in sin rounding.  This test checks
+   to see if that buggy version was installed.  The problem is fixed
+   in version 2.2.1 and presumably later MPFR versions.
+
+   Origin: Kaveh R. Ghazi 10/23/2006.  */
+
+/* { dg-do link } */
+
+extern void link_error (int, double, double);
+
+#define TESTIT(ARG,RES) do { \
+  if (sizeof (double) == 8 && __builtin_sin(ARG) != RES) \
+    link_error(__LINE__, __builtin_sin(ARG), RES); \
+  } while (0);
+
+int main()
+{
+  TESTIT (-0x1.c0016155c4da3p-1, -0x1.88fc58bcf030dp-1);
+
+  TESTIT (0x1.30654d85c2756p-2, 0x1.2beeb9de27a79p-2);
+
+  TESTIT (0x1.fe68ccaa8e201p+2, 0x1.fc3f0c54e97a7p-1);
+
+  /* This case should always pass.  */
+  TESTIT (0.0, 0.0);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-symmetric-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-symmetric-1.c
new file mode 100644
index 000000000..4834d8e2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-symmetric-1.c
@@ -0,0 +1,111 @@
+/* Copyright (C) 2006  Free Software Foundation.
+
+   Verify that built-in math function folding of symmetric even and
+   odd functions is correctly performed by the compiler.
+
+   Origin: Kaveh R. Ghazi,  November 09, 2006.  */
+
+/* { dg-do link } */
+/* { dg-options "-ffast-math" } */
+
+/* All references to link_error should go away at compile-time.  */
+extern void link_error(int);
+
+/* Test that FUNC(-ARG) == FUNC(ARG).  */
+#define TESTIT_EVEN(FUNC) do { \
+  if (__builtin_##FUNC##f(-xf) != __builtin_##FUNC##f(xf)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(-x) != __builtin_##FUNC(x)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(-xl) != __builtin_##FUNC##l(xl)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(-ARG) == FUNC(ARG), where ARG has a complex type.  */
+#define TESTIT_EVEN_C(FUNC) do { \
+  if (__builtin_##FUNC##f(-cxf) != __builtin_##FUNC##f(cxf)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC(-cx) != __builtin_##FUNC(cx)) \
+    link_error(__LINE__); \
+  if (__builtin_##FUNC##l(-cxl) != __builtin_##FUNC##l(cxl)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that FUNC(-VAR) == FUNC(VAR), where VAR has an int type.  */
+#define TESTIT_EVEN_I(FUNC,VAR) do { \
+  if (__builtin_##FUNC(-VAR) != __builtin_##FUNC(VAR)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that -FUNC(ARG) == FUNC(-ARG).  */
+#define TESTIT_ODD(FUNC) do { \
+  if (-__builtin_##FUNC##f(-xf) != __builtin_##FUNC##f(xf)) \
+    link_error(__LINE__); \
+  if (-__builtin_##FUNC(-x) != __builtin_##FUNC(x)) \
+    link_error(__LINE__); \
+  if (-__builtin_##FUNC##l(-xl) != __builtin_##FUNC##l(xl)) \
+    link_error(__LINE__); \
+  } while (0)
+
+/* Test that -FUNC(ARG) == FUNC(-ARG), where ARG has a complex type.  */
+#define TESTIT_ODD_C(FUNC) do { \
+  if (-__builtin_##FUNC##f(-cxf) != __builtin_##FUNC##f(cxf)) \
+    link_error(__LINE__); \
+  if (-__builtin_##FUNC(-cx) != __builtin_##FUNC(cx)) \
+    link_error(__LINE__); \
+  if (-__builtin_##FUNC##l(-cxl) != __builtin_##FUNC##l(cxl)) \
+    link_error(__LINE__); \
+  } while (0)
+
+void foo (float xf, double x, long double xl,
+	  __complex__ float cxf, __complex__ double cx, __complex__ long double cxl,
+	  int i, long l, long long ll, __INTMAX_TYPE__ im)
+{
+  TESTIT_EVEN(cos);
+  TESTIT_EVEN(cosh);
+  TESTIT_EVEN(fabs);
+
+  TESTIT_EVEN_C(ccos);
+  TESTIT_EVEN_C(ccosh);
+  TESTIT_EVEN_C(cabs);
+
+  TESTIT_EVEN_I(abs, i);
+  TESTIT_EVEN_I(imaxabs, im);
+  TESTIT_EVEN_I(labs, l);
+  TESTIT_EVEN_I(llabs, ll);
+
+  TESTIT_ODD(asin);
+  TESTIT_ODD(asinh);
+  TESTIT_ODD(atan);
+  TESTIT_ODD(atanh);
+  TESTIT_ODD(cbrt);
+  TESTIT_ODD(erf);
+  TESTIT_ODD(llrint);
+  TESTIT_ODD(llround);
+  TESTIT_ODD(lrint);
+  TESTIT_ODD(lround);
+  TESTIT_ODD(nearbyint);
+  TESTIT_ODD(rint);
+  TESTIT_ODD(round);
+  TESTIT_ODD(sin);
+  TESTIT_ODD(sinh);
+  TESTIT_ODD(tan);
+  TESTIT_ODD(tanh);
+  TESTIT_ODD(trunc);
+
+  TESTIT_ODD_C(casin);
+  TESTIT_ODD_C(casinh);
+  TESTIT_ODD_C(catan);
+  TESTIT_ODD_C(catanh);
+  TESTIT_ODD_C(cproj);
+  TESTIT_ODD_C(csin);
+  TESTIT_ODD_C(csinh);
+  TESTIT_ODD_C(ctan);
+  TESTIT_ODD_C(ctanh);
+}
+
+int main()
+{
+  foo (1,1,1,1,1,1,1,1,1,1);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c
new file mode 100644
index 000000000..5b4371e14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c
@@ -0,0 +1,57 @@
+/* Copyright (C) 2004, 2005  Free Software Foundation.
+
+   Verify that built-in wctype function attributes are correctly set
+   by the compiler.
+
+   Written by Kaveh Ghazi, 2004-03-25.  */
+
+/* { dg-do link } */
+
+/* Use the target type definitions if we can.  */ 
+#ifndef __WINT_TYPE__
+#define __WINT_TYPE__ int
+#endif
+
+#ifndef __WCHAR_TYPE__
+#define __WCHAR_TYPE__ int
+#endif
+
+void test(int i)
+{
+  /* All of these ctype functions should be const/pure and thus
+     eliminated.  */
+#define TEST_IS_WCTYPE(FN) \
+  extern int FN(__WINT_TYPE__); \
+  extern void link_failure_##FN(void); \
+  if (FN(i) != FN(i)) \
+    link_failure_##FN()
+
+#define TEST_TO_WCTYPE(FN) \
+  extern __WINT_TYPE__ FN(__WINT_TYPE__); \
+  extern void link_failure_##FN(void); \
+  if (FN(i) != FN(i)) \
+    link_failure_##FN()
+
+  
+#ifdef __OPTIMIZE__
+  TEST_IS_WCTYPE(iswalnum);
+  TEST_IS_WCTYPE(iswalpha);
+  TEST_IS_WCTYPE(iswblank);
+  TEST_IS_WCTYPE(iswcntrl);
+  TEST_IS_WCTYPE(iswdigit);
+  TEST_IS_WCTYPE(iswgraph);
+  TEST_IS_WCTYPE(iswlower);
+  TEST_IS_WCTYPE(iswprint);
+  TEST_IS_WCTYPE(iswpunct);
+  TEST_IS_WCTYPE(iswspace);
+  TEST_IS_WCTYPE(iswupper);
+  TEST_IS_WCTYPE(iswxdigit);
+  TEST_TO_WCTYPE(towlower);
+  TEST_TO_WCTYPE(towupper);
+#endif /* __OPTIMIZE__ */
+}
+
+int main (void)
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/calleesave-sse.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/calleesave-sse.c
new file mode 100644
index 000000000..292791c72
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/calleesave-sse.c
@@ -0,0 +1,43 @@
+/* { dg-do run } */
+/* { dg-options "-fno-omit-frame-pointer" } */
+
+#define alloca __builtin_alloca
+extern void abort (void);
+
+__attribute__ ((noinline)) static double
+bar (double a, double b, double c, double d, char *h)
+{
+  *h = 0;
+  return a * b + b + c;
+}
+
+__attribute__ ((noinline)) static int
+boo (double a, double b, double c, double d)
+{
+  return c * b + a + b;
+}
+
+__attribute__ ((noinline)) static double
+foo (double a, double b, double c, double d)
+{
+ int aa = boo (b, c, d, a);
+ return bar (a, b, c, d, (char *) alloca (aa))
+	+ bar (d, c, b, a, (char *) alloca (aa));
+}
+
+int main ()
+{
+  double a = 2.0, b = 3.0, c = 4.0, d = 5.0;
+  double r1, r2;
+  int aa;
+
+  aa = boo (b, c, d, a);
+  r1 = bar (a, b, c, d, (char *) alloca (aa))
+       + bar (d, c, b, a, (char *) alloca (aa));
+  r2 = foo (a, b, c, d);
+
+  if (r1 != r2)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/complex-alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/complex-alias-1.c
new file mode 100644
index 000000000..6ab4ca078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/complex-alias-1.c
@@ -0,0 +1,29 @@
+/* Accesses to complex numbers were sometimes marked as scalar and
+   sometimes as struct accesses.  */
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+
+extern void abort (void);
+static double _Complex *fp_cxd(double _Complex *cx) {
+  return cx;
+}
+
+int main( ) {
+  double _Complex cx = 4.0 + 3.0*(__extension__ 1.0iF);
+  double _Complex cx43 = 4.0 + 3.0*(__extension__ 1.0iF);
+  double _Complex cx11 = 1.0 + 1.0*(__extension__ 1.0iF);
+
+  *fp_cxd(&cx) *= cx11;
+  *fp_cxd(&cx) /= cx11;
+
+  double r_cx = __real__(cx);
+  double i_cx = __imag__(cx);
+  double r_cx43 = __real__(cx43);
+  double i_cx43 = __imag__(cx43);
+
+  if( (r_cx == r_cx43) && (i_cx == i_cx43) ) { 
+    return 0;
+  } else {
+    abort ();
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/cris-asm-mof-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/cris-asm-mof-1.c
new file mode 100644
index 000000000..5ebde5ed5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/cris-asm-mof-1.c
@@ -0,0 +1,36 @@
+/* { dg-do compile { target cris-*-* crisv32-*-* } } */
+/* { dg-skip-if "" { cris*-*-* } { "-march*" } { "" } } */
+/* { dg-options "-O2 -march=v10" } */
+/* { dg-final { scan-assembler "in-asm: .mof" } } */
+/* { dg-final { scan-assembler "out-asm: .mof" } } */
+/* { dg-final { scan-assembler "in2-asm: .mof" } } */
+/* { dg-final { scan-assembler "out2-asm: .mof" } } */
+
+unsigned int
+in (unsigned int i)
+{
+  register int i0 asm ("mof") = i;
+  asm ("in-asm: %0" : : "x" (i0));
+}
+
+unsigned int
+out (void)
+{
+  register int o asm ("mof");
+  asm ("out-asm: %0" : "=x" (o));
+  return o;
+}
+
+unsigned int
+in2 (unsigned int i)
+{
+  asm ("in2-asm: %0" : : "h" (i));
+}
+
+unsigned int
+out2 (void)
+{
+  unsigned int o;
+  asm ("out2-asm: %0" : "=h" (o));
+  return o;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/cris-volatile-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/cris-volatile-1.c
new file mode 100644
index 000000000..6b19852c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/cris-volatile-1.c
@@ -0,0 +1,72 @@
+/* Copyright (C) 2003  Free Software Foundation.
+   Check that size-optimizations for move insns (specifically peephole
+   optimizations) aren't applied to volatile objects in the CRIS port.
+   Origin: Hans-Peter Nilsson.  */
+/* { dg-do compile { target cris-*-* crisv32-*-* } } */
+/* { dg-final { scan-assembler-not {movu\...\[} } } */
+/* { dg-final { scan-assembler-not {move\.[^d].\[} } } */
+/* { dg-final { scan-assembler-not {and\.[^d].\[} } } */
+/* { dg-final { scan-assembler-not {or\.[^d].\[} } } */
+
+static const unsigned long c = 0x0000FF00;
+unsigned long
+a1 (void)
+{
+  unsigned long m;
+  m = *(volatile unsigned long*) 0xb00000c8;
+  m &= c;
+  return m;
+}
+extern volatile unsigned long xx;
+unsigned long
+a2 (void)
+{
+  unsigned long m;
+  m = xx;
+  m &= c;
+  return m;
+}
+extern volatile unsigned long yy[];
+unsigned long
+a3 (void)
+{
+  unsigned long m;
+  m = yy[3];
+  m &= 0xfe00;
+  return m;
+}
+unsigned long
+ac1 (void)
+{
+  unsigned long m;
+  m = *(volatile unsigned long*) 0xb00000c8;
+  m &= 0xfe00;
+  return m;
+}
+extern volatile unsigned long xx;
+unsigned long
+ac2 (void)
+{
+  unsigned long m;
+  m = xx;
+  m &= 0xfe00;
+  return m;
+}
+extern volatile unsigned long yy[];
+unsigned long
+ac3 (void)
+{
+  unsigned long m;
+  m = yy[3];
+  m &= 0xfe00;
+  return m;
+}
+extern volatile unsigned long yy[];
+unsigned long
+oc3 (void)
+{
+  unsigned long m;
+  m = yy[3];
+  m |= ~0xf;
+  return m;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/dg-torture.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/dg-torture.exp
new file mode 100644
index 000000000..b151c2e07
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/dg-torture.exp
@@ -0,0 +1,7 @@
+# This harness is for tests that should be run at all optimisation levels.
+
+load_lib gcc-dg.exp
+
+dg-init
+gcc-dg-runtest [lsort [glob $srcdir/$subdir/*.c]] ""
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-double.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-double.c
new file mode 100644
index 000000000..39ec3cde1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-double.c
@@ -0,0 +1,18 @@
+/* Test floating-point conversions.  Standard types and double.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "" } */
+
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, double, DBL_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, double, DBL_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, double, DBL_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, double, DBL_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, double, DBL_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float.c
new file mode 100644
index 000000000..7fca1df7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float.c
@@ -0,0 +1,18 @@
+/* Test floating-point conversions.  Standard types and float.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "" } */
+
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, float, FLT_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, float, FLT_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, float, FLT_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, float, FLT_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, float, FLT_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-timode.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-timode.c
new file mode 100644
index 000000000..8318f8ad8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-timode.c
@@ -0,0 +1,15 @@
+/* Test floating-point conversions.  __float128 type with TImode.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "" } */
+
+#include "fp-int-convert.h"
+
+#define FLOAT128_MANT_DIG 113
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, __float128, FLOAT128_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float128.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float128.c
new file mode 100644
index 000000000..bc5e5adeb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float128.c
@@ -0,0 +1,19 @@
+/* Test floating-point conversions.  __float128 type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "" } */
+
+#include "fp-int-convert.h"
+
+#define FLOAT128_MANT_DIG 113
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, __float128, FLOAT128_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, __float128, FLOAT128_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, __float128, FLOAT128_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, __float128, FLOAT128_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, __float128, FLOAT128_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float80-timode.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float80-timode.c
new file mode 100644
index 000000000..5b9bb706c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float80-timode.c
@@ -0,0 +1,16 @@
+/* Test floating-point conversions.  __float80 type with TImode.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "" } */
+/* { dg-options "-mmmx" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#include "fp-int-convert.h"
+
+#define FLOAT80_MANT_DIG 64
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, __float80, FLOAT80_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float80.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float80.c
new file mode 100644
index 000000000..3e25f904d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-float80.c
@@ -0,0 +1,19 @@
+/* Test floating-point conversions.  __float80 type.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run { target i?86-*-* x86_64-*-* ia64-*-* } } */
+/* { dg-options "" } */
+
+#include "fp-int-convert.h"
+
+#define FLOAT80_MANT_DIG 64
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, __float80, FLOAT80_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, __float80, FLOAT80_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, __float80, FLOAT80_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, __float80, FLOAT80_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, __float80, FLOAT80_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-long-double.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-long-double.c
new file mode 100644
index 000000000..bb189a34c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-long-double.c
@@ -0,0 +1,18 @@
+/* Test floating-point conversions.  Standard types and long double.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "" } */
+
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, long double, LDBL_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, long double, LDBL_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, long double, LDBL_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, long double, LDBL_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, long double, LDBL_MANT_DIG);
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-timode.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-timode.c
new file mode 100644
index 000000000..3a60d01ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert-timode.c
@@ -0,0 +1,21 @@
+/* Test floating-point conversions.  TImode types.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "" } */
+
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, float, FLT_MANT_DIG);
+  TEST_I_F(TItype, UTItype, double, DBL_MANT_DIG);
+  /* Disable the long double tests when using IBM Extended Doubles.
+     They have variable precision, but constants calculated by gcc's
+     real.c assume fixed precision.  */
+#if DBL_MANT_DIG != LDBL_MANT_DIG  && LDBL_MANT_DIG != 106
+  TEST_I_F(TItype, UTItype, long double, LDBL_MANT_DIG);
+#endif
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert.h
new file mode 100644
index 000000000..8c1968e9b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/fp-int-convert.h
@@ -0,0 +1,89 @@
+/* Test floating-point conversions.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+
+#include <limits.h>
+extern void abort (void);
+extern void exit (int);
+
+/* Not all platforms support TImode integers; logic as in
+   gcc.dg/titype-1.c.  */
+#if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64)
+typedef int TItype __attribute__ ((mode (TI)));
+typedef unsigned int UTItype __attribute__ ((mode (TI)));
+#else
+typedef long TItype;
+typedef unsigned long UTItype;
+#endif
+
+/* TEST_I_F(I, U, F, P) tests conversions between the pair of signed
+   and unsigned integer types I and U and the floating-point type F,
+   where P is the binary precision of the floating point type.  We
+   test conversions of the values 0, 1, 0x7...f, 0x8...0, 0xf...f.  We
+   also test conversions of values half way inbetween two
+   representable values (rounding both ways), just above half way, and
+   just below half way.  */
+#define TEST_I_F(I, U, F, P)					\
+do {								\
+  TEST_I_F_VAL (I, F, (I)0, 1);					\
+  TEST_I_F_VAL (I, F, (I)1, 1);					\
+  TEST_I_F_VAL (I, F, (I)(((U)~(U)0) >> 1), P_OK1 (P, I));	\
+  TEST_I_F_VAL (I, F, (I)(U)~(((U)~(U)0) >> 1), 1);		\
+  TEST_I_F_VAL (I, F, (I)(U)~(U)0, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, HVAL0S (P, I), P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, HVAL0S (P, I) + 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, HVAL0S (P, I) - 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, HVAL1S (P, I), P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, HVAL1S (P, I) + 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, HVAL1S (P, I) - 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, -HVAL0S (P, I), P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, -HVAL0S (P, I) + 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, -HVAL0S (P, I) - 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, -HVAL1S (P, I), P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, -HVAL1S (P, I) + 1, P_OK (P, I));		\
+  TEST_I_F_VAL (I, F, -HVAL1S (P, I) - 1, P_OK (P, I));		\
+  TEST_I_F_VAL (U, F, (U)0, 1);					\
+  TEST_I_F_VAL (U, F, (U)1, 1);					\
+  TEST_I_F_VAL (U, F, (U)(((U)~(U)0) >> 1), P_OK1 (P, U));	\
+  TEST_I_F_VAL (U, F, (U)~(((U)~(U)0) >> 1), 1);		\
+  TEST_I_F_VAL (U, F, (U)~(U)0, P_OK (P, U));			\
+  TEST_I_F_VAL (U, F, HVAL0U (P, U), P_OK (P, U));		\
+  TEST_I_F_VAL (U, F, HVAL0U (P, U) + 1, P_OK (P, U));		\
+  TEST_I_F_VAL (U, F, HVAL0U (P, U) - 1, P_OK (P, U));		\
+  TEST_I_F_VAL (U, F, HVAL1U (P, U), P_OK (P, U));		\
+  TEST_I_F_VAL (U, F, HVAL1U (P, U) + 1, P_OK (P, U));		\
+  TEST_I_F_VAL (U, F, HVAL1U (P, U) - 1, P_OK (P, U));		\
+} while (0)
+
+#define P_OK(P, T) ((P) >= sizeof(T) * CHAR_BIT)
+#define P_OK1(P, T) ((P) >= sizeof(T) * CHAR_BIT - 1)
+#define HVAL0U(P, U) (U)(P_OK (P, U)					 \
+			 ? (U)1						 \
+			 : (((U)1 << (sizeof(U) * CHAR_BIT - 1))	 \
+			    + ((U)1 << (sizeof(U) * CHAR_BIT - 1 - P))))
+#define HVAL1U(P, U) (U)(P_OK (P, U)					 \
+			 ? (U)1						 \
+			 : (((U)1 << (sizeof(U) * CHAR_BIT - 1))	 \
+			    + ((U)3 << (sizeof(U) * CHAR_BIT - 1 - P))))
+#define HVAL0S(P, S) (S)(P_OK1 (P, S)					 \
+			 ? (S)1						 \
+			 : (((S)1 << (sizeof(S) * CHAR_BIT - 2))	 \
+			    + ((S)1 << (sizeof(S) * CHAR_BIT - 2 - P))))
+#define HVAL1S(P, S) (S)(P_OK1 (P, S)					 \
+			 ? (S)1						 \
+			 : (((S)1 << (sizeof(S) * CHAR_BIT - 2))	 \
+			    + ((S)3 << (sizeof(S) * CHAR_BIT - 2 - P))))
+
+#define TEST_I_F_VAL(IT, FT, VAL, PREC_OK)		\
+do {							\
+  static volatile IT ivin, ivout;			\
+  static volatile FT fv1, fv2;				\
+  ivin = (VAL);						\
+  fv1 = (VAL);						\
+  fv2 = ivin;						\
+  ivout = fv2;						\
+  if (ivin != (VAL)					\
+      || ((PREC_OK) && ivout != ivin)			\
+      || ((PREC_OK) && ivout != (VAL))			\
+      || fv1 != (VAL) || fv2 != (VAL) || fv1 != fv2)	\
+    abort ();						\
+} while (0)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/inline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/inline-1.c
new file mode 100644
index 000000000..c7144ca68
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/inline-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "--param ggc-min-heapsize=0 --param ggc-min-expand=0" } */
+/* This used to ICE because we forgot to update the statement after folding
+   and the eh info. */
+/* PR tree-opt/30385 */
+
+static inline void g(int t)
+{
+ int a;
+ while (a < f())
+  ;
+}
+void h(int t)
+{
+ g(t);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/ipa-pta-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/ipa-pta-1.c
new file mode 100644
index 000000000..10963973c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/ipa-pta-1.c
@@ -0,0 +1,40 @@
+/* { dg-do compile { target { nonpic } } } */
+/* { dg-options "-fipa-pta -fdump-ipa-pta" } */
+/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */
+
+struct X { char x; char y; };
+
+void bar (char *p);
+
+void test1 (char a, char b, char c, char d, char e, char f, char g, char h)
+{
+  char *p = &a;
+  p++;
+  bar (p);
+}
+
+void test2 (struct X a, char b, char c, char d, char e, char f, char g, char h)
+{
+  char *p = &a.x;
+  p++;
+  bar (p);
+}
+
+void test3 (struct X a, char b, char c, char d, char e, char f, char g, char h)
+{
+  char *p = &a.y;
+  bar (p);
+}
+
+void test4 (int a, char b, char c, char d, char e, char f, char g, char h)
+{
+  char *p = (char *)&a;
+  p++;
+  p++;
+  p++;
+  p++;
+  bar (p);
+}
+
+/* { dg-final { scan-ipa-dump "bar.arg0 = { test4.arg0 test3.arg0 test2.arg0 test1.arg0 }" "pta" } } */
+/* { dg-final { cleanup-ipa-dump "pta" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-clobber-at.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-clobber-at.c
new file mode 100644
index 000000000..7f936984a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-clobber-at.c
@@ -0,0 +1,4 @@
+/* "$1" used to be mapped to the internal frame pointer.  */
+/* { dg-do compile { target mips*-*-* } } */
+/* { dg-options "" } */
+int foo () { asm volatile ("#" ::: "$1"); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-div-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-div-1.c
new file mode 100644
index 000000000..6345000fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-div-1.c
@@ -0,0 +1,9 @@
+/* Check that hard-float MIPS code doesn't use library calls for 1.0/x.  */
+/* { dg-options "-fno-delayed-branch" } */
+/* { dg-do compile { target mips*-*-* } } */
+
+float f1 (float x) { return 1.0f / x; }
+double f2 (double x) { return 1.0 / x; }
+
+/* { dg-final { scan-assembler-not {lwc1.*__divsf3} } } */
+/* { dg-final { scan-assembler-not {ldc1.*__divdf3} } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-hilo-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-hilo-2.c
new file mode 100644
index 000000000..dbe949307
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-hilo-2.c
@@ -0,0 +1,27 @@
+/* Due to a reload inheritance bug, the asm statement in f() would be passed
+   the low part of u.ll on little-endian 32-bit targets.  */
+/* { dg-do run { target mips*-*-* } } */
+
+extern void abort (void);
+extern void exit (int);
+
+unsigned int g;
+
+unsigned __attribute__ ((nomips16)) long long f (unsigned int x)
+{
+  union { unsigned long long ll; unsigned int parts[2]; } u;
+
+  u.ll = ((unsigned long long) x * x);
+  asm ("mflo\t%0" : "=r" (g) : "l" (u.parts[1]));
+  return u.ll;
+}
+
+int __attribute__ ((nomips16)) main ()
+{
+  union { unsigned long long ll; unsigned int parts[2]; } u;
+
+  u.ll = f (0x12345678);
+  if (g != u.parts[1])
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c
new file mode 100644
index 000000000..8ffd4d848
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/mips-sdata-1.c
@@ -0,0 +1,10 @@
+/* Check that sdata-accesses are applied regardless of size or ABI.  */
+/* { dg-options -mexplicit-relocs } */
+/* { dg-do compile { target mips*-*-elf* } } */
+
+struct s { int x[4]; };
+struct s my_struct __attribute__((__section__(".sdata")));
+
+int f() { return my_struct.x[0]; }
+
+/* { dg-final { scan-assembler {gp_?rel\(my_struct} } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/nested-fn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/nested-fn-1.c
new file mode 100644
index 000000000..99e852344
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/nested-fn-1.c
@@ -0,0 +1,74 @@
+/* PR middle-end/15345, c/16450 */
+/* Test whether unused nested functions aren't emitted into the assembly.  */
+/* { dg-do compile } */
+/* { dg-options "-g0" } */
+/* { dg-require-effective-target trampolines } */
+
+int
+fn1 (int x)
+{
+  int i = x;
+  inline __attribute__((always_inline)) int
+  should_not_appear1 (void)
+  {
+    return i;
+  }
+  return should_not_appear1 ();
+}
+
+int
+fn2 (int x)
+{
+  int i = x;
+  inline __attribute__((always_inline)) int
+  should_not_appear2 (void)
+  {
+    return i;
+  }
+  return x;
+}
+
+extern void check (void *p);
+
+int
+fn3 (int x)
+{
+  int i = x;
+  inline int
+  should_appear1 (void)
+  {
+    char *p = __builtin_alloca (i);
+    check (p);
+    return i;
+  }
+  return should_appear1 ();
+}
+
+int
+fn4 (int x)
+{
+  int i = x;
+  inline int
+  should_not_appear3 (void)
+  {
+    char *p = __builtin_alloca (i);
+    check (p);
+    return i;
+  }
+  return 0 ? should_not_appear3 () : 1;
+}
+
+int
+fn5 (int x)
+{
+  int i = x;
+  inline int
+  should_appear2 (void)
+  {
+    return i;
+  }
+  check (should_appear2);
+  return i;
+}
+
+/* { dg-final { scan-assembler-not "should_not_appear" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr16104-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr16104-1.c
new file mode 100644
index 000000000..018a1bac7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr16104-1.c
@@ -0,0 +1,88 @@
+/* PR rtl-optimization/16104 */
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse2" } */
+
+#include "cpuid.h"
+
+extern void abort (void);
+
+typedef int V2SI __attribute__ ((vector_size (8)));
+typedef unsigned int V2USI __attribute__ ((vector_size (8)));
+typedef short V2HI __attribute__ ((vector_size (4)));
+typedef unsigned int V2UHI __attribute__ ((vector_size (4)));
+
+int
+test1 (void)
+{
+  return (long long) (V2SI) 0LL;
+}
+
+int
+test2 (V2SI x)
+{
+  return (long long) x;
+}
+
+V2SI
+test3 (void)
+{
+  return (V2SI) (long long) (int) (V2HI) 0;
+}
+
+V2SI
+test4 (V2HI x)
+{
+  return (V2SI) (long long) (int) x;
+}
+
+V2SI
+test5 (V2USI x)
+{
+  return (V2SI) x;
+}
+
+void
+__attribute__ ((noinline))
+do_test (void)
+{
+  if (sizeof (short) != 2 || sizeof (int) != 4 || sizeof (long long) != 8)
+    return;
+
+  if (test1 () != 0)
+    abort ();
+
+  V2SI x = { 2, 2 };
+  if (test2 (x) != 2)
+    abort ();
+
+  union { V2SI x; int y[2]; V2USI z; long long l; } u;
+  u.x = test3 ();
+  if (u.y[0] != 0 || u.y[1] != 0)
+    abort ();
+
+  V2HI y = { 4, 4 };
+  union { V2SI x; long long y; } v;
+  v.x = test4 (y);
+  if (v.y != 0x40004)
+    abort ();
+
+  V2USI z = { 6, 6 };
+  u.x = test5 (z);
+  if (u.y[0] != 6 || u.y[1] != 6)
+    abort ();
+}
+
+int
+main (void)
+{
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    do_test ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr17526.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr17526.c
new file mode 100644
index 000000000..58b479143
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr17526.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-fno-pcc-struct-return" { target i?86-*-* } } */
+
+void abort(void);
+
+typedef struct { int i; } A;
+
+A __attribute__((noinline))
+foo(void)
+{
+    A a = { -1 };
+    return a;
+}
+
+void __attribute__((noinline))
+bar(A *p)
+{
+    *p = foo();
+}
+
+int main(void)
+{
+    A a;
+    bar(&a);
+    if (a.i != -1) abort();
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr17933-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr17933-1.c
new file mode 100644
index 000000000..02c597b0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr17933-1.c
@@ -0,0 +1,14 @@
+/* PR rtl-optimization/17933.
+   Test-case from the ObjC test-suite, execute/class_self-2.m,
+   translated to C from and reduced by Andrew Pinski.  */
+
+struct d
+{ int a; };
+void abort(void);
+typedef struct d (*f) (int i);
+f ff(void);
+void test1()
+{
+  f t = ff();
+  t(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr18582-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr18582-1.c
new file mode 100644
index 000000000..619593905
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr18582-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse3" } */
+typedef char v16qi __attribute__((vector_size (16)));
+typedef float v4sf __attribute__((vector_size (16)));
+typedef double v2df __attribute__((vector_size (16)));
+
+extern char ca[];
+extern float fa[];
+extern double da[];
+
+extern v16qi cva[];
+extern v4sf fva[];
+extern v2df dva[];
+
+void
+foo (void)
+{
+  cva[0] = __builtin_ia32_loaddqu (ca);
+  cva[0] = __builtin_ia32_lddqu (ca);
+
+  fva[0] = __builtin_ia32_loadups (fa);
+
+  dva[0] = __builtin_ia32_loadupd (da);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr19462-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr19462-1.c
new file mode 100644
index 000000000..8e140356f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr19462-1.c
@@ -0,0 +1,56 @@
+/* { dg-do compile } */
+/* PR rtl-optimization/19462
+   Delayed branch bug: return insns generated in presence of
+   current_function_epilogue_delay_list.  See also PR target/7042.  */
+
+/* The test is from newlib/libc/string/wcscspn.c, which has the following
+   copyright and licensing notice, which by inclusion this file supposedly
+   complies with:
+
+ * Copyright (c)1999 Citrus Project,
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.  */
+
+
+unsigned long
+wcscspn(const long *s, const long *set)
+{
+  const long *p;
+  const long *q;
+
+  p = s;
+  while (*p)
+    {
+      q = set;
+      while (*q)
+        {
+          if (*p == *q)
+            goto done;
+          q++;
+        }
+      p++;
+    }
+
+done:
+  return (p - s);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr19683-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr19683-1.c
new file mode 100644
index 000000000..05bf17418
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr19683-1.c
@@ -0,0 +1,42 @@
+/* From PR rtl-optimization/19683.  On little-endian MIPS targets,
+   reload would incorrectly inherit the high part of the multiplication
+   result.  */
+/* { dg-do run { target mips*-*-* } } */
+
+extern void abort (void);
+extern void exit (int);
+
+#define REPEAT10(X, Y)					\
+  X(Y##0); X(Y##1); X(Y##2); X(Y##3); X(Y##4);		\
+  X(Y##5); X(Y##6); X(Y##7); X(Y##8); X(Y##9)
+
+#define REPEAT30(X) REPEAT10 (X, 0); REPEAT10 (X, 1); REPEAT10 (X, 2)
+#define IN(X) unsigned int x##X = ptr[0]
+#define OUT(X) ptr[0] = x##X
+
+union u { unsigned long long ll; unsigned int i[2]; };
+
+unsigned int __attribute__ ((nomips16))
+foo (volatile unsigned int *ptr)
+{
+  union u u;
+  int result;
+
+  u.ll = (unsigned long long) ptr[0] * ptr[0];
+  REPEAT30 (IN);
+  REPEAT30 (OUT);
+  asm ("#" : "=l" (result) : "l" (u.i[1]));
+  return result;
+}
+
+int __attribute__ ((nomips16))
+main (void)
+{
+  unsigned int array[] = { 1000 * 1000 * 1000 };
+  union u u;
+
+  u.ll = (unsigned long long) array[0] * array[0];
+  if (foo (array) != u.i[1])
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr20314-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr20314-1.c
new file mode 100644
index 000000000..8a69c2dca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr20314-1.c
@@ -0,0 +1,56 @@
+/* PR inline-asm/20314 */
+/* { dg-do compile { target i?86-*-* x86_64-*-* powerpc*-*-* ia64-*-* } } */
+
+int
+f1 (void)
+{
+  int x = 4, y;
+  __asm__ volatile ("" : "+r,r" (x), "=r,r" (y)
+		       : "%r,r" (x), "m,r" (8), "r,r" (2));
+  return x;
+}
+
+int
+f2 (void)
+{
+  int x = 4, y;
+  __asm__ volatile ("" : "=r,r" (x), "=r,r" (y)
+		       : "%0,0" (x), "m,r" (8), "r,r" (2));
+  return x;
+}
+
+int
+f3 (void)
+{
+  int x = 4, y;
+  __asm__ volatile ("" : "+r,r" (x), "=r,r" (y)
+		       : "%m,r" (8), "r,r" (2));
+  return x;
+}
+
+int
+f4 (void)
+{
+  int x = 4, y;
+  __asm__ volatile ("" : "+r" (x), "=r" (y)
+		       : "r" (x), "r" (8), "r" (2));
+  return x;
+}
+
+int
+f5 (void)
+{
+  int x = 4, y;
+  __asm__ volatile ("" : "=r" (x), "=r" (y)
+		       : "0" (x), "r" (8), "r" (2));
+  return x;
+}
+
+int
+f6 (void)
+{
+  int x = 4, y;
+  __asm__ volatile ("" : "+r" (x), "=r" (y)
+		       : "r" (8), "r" (2));
+  return x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr20314-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr20314-2.c
new file mode 100644
index 000000000..8185218c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr20314-2.c
@@ -0,0 +1,47 @@
+/* PR inline-asm/20314 */
+/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-do compile { target ia64-*-* powerpc*-*-* } } */
+
+int a, b, c, d, e, f, g, h, i, j, k, l;
+
+void
+f1 (void)
+{
+  __asm__ volatile (""
+		    : [a] "+r" (a), [b] "+r" (b), [c] "+r" (c), [d] "+r" (d),
+		      [e] "+r" (e), [f] "+r" (f), [g] "+r" (g), [h] "+r" (h),
+		      [i] "+r" (i), [j] "+r" (j), [k] "+r" (k), [l] "+r" (l));
+}
+
+void
+f2 (void)
+{
+  __asm__ volatile (""
+		    : [a] "+r,m" (a), [b] "+r,m" (b), [c] "+r,m" (c), [d] "+r,m" (d),
+		      [e] "+r,m" (e), [f] "+r,m" (f), [g] "+r,m" (g), [h] "+r,m" (h),
+		      [i] "+r,m" (i), [j] "+r,m" (j), [k] "+r,m" (k), [l] "+r,m" (l));
+}
+
+void
+f3 (void)
+{
+  __asm__ volatile (""
+		    : [a] "=r" (a), [b] "=r" (b), [c] "=r" (c), [d] "=r" (d),
+		      [e] "=r" (e), [f] "=r" (f), [g] "=r" (g), [h] "=r" (h),
+		      [i] "=r" (i), [j] "=r" (j), [k] "=r" (k), [l] "=r" (l)
+		    : "[a]" (a), "[b]" (b), "[c]" (c), "[d]" (d),
+		      "[e]" (e), "[f]" (f), "[g]" (g), "[h]" (h),
+		      "[i]" (i), "[j]" (j), "[k]" (k), "[l]" (l));
+}
+
+void
+f4 (void)
+{
+  __asm__ volatile (""
+		    : [a] "=r,m" (a), [b] "=r,m" (b), [c] "=r,m" (c), [d] "=r,m" (d),
+		      [e] "=r,m" (e), [f] "=r,m" (f), [g] "=r,m" (g), [h] "=r,m" (h),
+		      [i] "=r,m" (i), [j] "=r,m" (j), [k] "=r,m" (k), [l] "=r,m" (l)
+		    : "[a],m" (a), "[b],m" (b), "[c],m" (c), "[d],m" (d),
+		      "[e],m" (e), "[f],m" (f), "[g],m" (g), "[h],m" (h),
+		      "[i],m" (i), "[j],m" (j), "[k],m" (k), "[l],m" (l));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr21817-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr21817-1.c
new file mode 100644
index 000000000..d90d3239c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr21817-1.c
@@ -0,0 +1,16 @@
+/* hppa*-*-hpux* needs -fno-common so that value can be given a 16
+   byte alignment.  */
+
+/* { dg-do compile } */
+/* { dg-options "-fno-common" { target { hppa*-*-hpux* } } } */
+
+typedef float v4sf __attribute__((vector_size(16)));
+v4sf value;
+void foo(void)
+{
+  unsigned int band;
+  for(band=0; band < 2; band++)
+    {
+      value += (v4sf){1e9f,1e9f,1e9f,1e9f};
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr23424-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr23424-1.c
new file mode 100644
index 000000000..91950d77a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr23424-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+extern char *x;
+extern void foo (void);
+void f (char *s, char *se, char *mp, char *y)
+{
+  while (s != se)
+    {
+      char *p;
+      foo ();
+      p = s + *mp;
+      *y++ = *p;
+      s = p;
+    }
+
+  x = s;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24257.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24257.c
new file mode 100644
index 000000000..d685df63d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24257.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-fgcse -fgcse-sm" } */
+
+typedef struct A {
+    int buf, left;
+} A;
+
+static void flush(A *s, int n)
+{
+    s->buf <<= n;
+
+    while (s->left < 32) {
+        s->buf <<= 8;
+        s->left += 8;
+    }
+
+    s->buf=0;
+}
+
+void oof(A *s, int n)
+{
+    s->buf = n;
+    s->left = n;
+
+    flush(s, n);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-1.c
new file mode 100644
index 000000000..331c55ec3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-1.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+typedef long
+(*bla)(int *node);
+
+static long F2(void *tree, long blk, bla after_node_func)
+{
+ long call_result = 0;
+ int *node;
+
+
+ if (call_result = after_node_func(node))
+  goto error_free_node;
+
+ T(node);
+ return 0;
+
+error_free_node:
+ T(node);
+error:
+ return call_result;
+}
+
+long F1(void *tree)
+{
+ return F2(tree, F3(tree), (void *)0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-2.c
new file mode 100644
index 000000000..e48d3b31c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-2.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+
+typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
+typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef u_int32_t db_pgno_t;
+typedef struct __db DB;
+typedef struct __db_env DB_ENV;
+typedef struct __db_mpoolfile DB_MPOOLFILE;
+typedef struct __dbc DBC;
+struct __db {
+    DB_MPOOLFILE *mpf;
+    db_pgno_t meta_pgno;
+    struct __cq_aq {
+    } s_links;
+};
+struct __db_env {
+    struct {
+    } xa_txn;
+    u_int32_t flags;
+};
+typedef enum { MU_REMOVE, MU_RENAME, MU_OPEN } mu_action;
+typedef struct __dbpginfo {
+    u_int8_t type;
+} PAGE;
+int __db_master_update(mdbp, sdbp, txn, subdb, type, action, newname, flags)
+  DB *mdbp, *sdbp;
+{
+    DB_ENV *dbenv;
+    DBC *dbc, *ndbc;
+    PAGE *p, *r;
+    int modify, ret, t_ret;
+    if ((ret = __db_cursor(mdbp, txn, &dbc,
+			   (((dbenv)->flags & (0x0000002))
+			    && modify) ? 35 : 0)) != 0)
+	goto err;
+    switch (action) {
+	case MU_REMOVE:
+	    if ((ret = __memp_fget(mdbp->mpf, &sdbp->meta_pgno, 0, &p)) != 0)
+		goto err;
+	    if ((((PAGE *)p)->type) == 9) {
+		if ((ret = __db_free(dbc, r)) != 0) { }
+	    }
+	    if ((ret = __db_free(dbc, p)) != 0) {
+		p = ((void *)0);
+		goto err;
+	    }
+	    p = ((void *)0);
+    }
+ err:
+    if (ndbc != ((void *)0) && (t_ret = __db_c_close(ndbc)) != 0 && ret == 0)
+	ret = t_ret;
+    return (ret);
+}
+ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-3.c
new file mode 100644
index 000000000..778068268
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-3.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+long fff(int*);
+
+long F2(int *node)
+{
+ long call_result = 0;
+
+ if (call_result = fff(node))
+  goto error_free_node;
+
+ T(node);
+ return 0;
+
+error_free_node:
+ T(node);
+ return call_result;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-4.c
new file mode 100644
index 000000000..a66801661
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24626-4.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-fmodulo-sched" } */
+
+int foo(short* vec1, short* vec2, short* vec3,int len )
+{
+        int temp,i;
+        for (i=0; i<len; i++) {
+                 temp = vec1[i] * 2;
+                 temp += vec2[i] * 3 ;
+                 vec3[i] = temp;
+        }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24750-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24750-1.c
new file mode 100644
index 000000000..58b1ea2ef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24750-1.c
@@ -0,0 +1,73 @@
+extern void free (void *);
+extern int unknown;
+extern int n0;
+extern short *s0;
+extern int n1;
+extern short *s1;
+extern short *s2;
+extern int *n2;
+extern int *n3;
+extern int n4;
+extern short *n5;
+extern int *n6;
+extern int n7;
+extern char *unc;
+
+void
+f (short *sp)
+{
+  int j = 0;
+  int i = 0;
+  int n8 = 0;
+  int n9 = 0;
+  short *s3 = sp;
+  short s4 = (short) unknown;
+  short s5 = (short) unknown;
+  char *c0 = unc;
+  int n10 = 0;
+  int n11 = 0;
+  int u0 = unknown;
+  int k = 0;
+
+  for (n8 = 1; n8 <= n7; n8++)
+    {
+      for (i = 1; i <= n0; i++)
+	c0[i] = 0;
+      for (i = 1; i <= u0; i++) { }
+      for (i = sp[0]; i != -32767; i = sp[i])
+	if (s4 == u0)
+	  for (j = 1; j <= u0; j++)
+	    if (!c0[s3[j]])
+	      break;
+    }
+  for (n9 = 1; n9 <= n0; n9++) s1[unknown + n9] = n9;
+  for (i = 1; i <= n1; i++)
+    for (j = 1; j <= s4; j++)
+      s3[j] = s1[s3[j]];
+  for (n8 = 1; n8 <= n7; n8++)
+    for (i = 1; i <= s5; i++)
+      s3[i] = s1[s3[i]];
+  for (n9 = 1; n9 <= n0; n9++) sp[s1[n9]] = unknown;
+  for (n10 = 2; n10 < n4; n10++) { }
+  for (k = 1; k <= unknown; k++)
+    {
+      s4 = s0[n5[u0]];
+      for (i = 1; i <= s4; i++) { }
+      for (j = 1; j <= s4; j++)
+	if (n2[1] != 0)
+	  if (i == unknown)
+	    unknown = n3[unknown];
+      n6[u0] = n10;
+    }
+  for (k = n7; k >= n11; k--)
+    if (n2[k] == -32767)
+      break;
+  free (c0);
+
+  for (i = 1; i <= n7; i++)
+    {
+      for (j = 1; j <= s4; j++) { }
+      for (n8 = s2[unknown]; n8 != -32767; n8 = s2[n8]) { }
+      for (j = 1; j <= s5; j++) { }
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24912-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24912-1.c
new file mode 100644
index 000000000..947175f9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr24912-1.c
@@ -0,0 +1,10 @@
+void foo(void);
+void
+bar (unsigned char *p)
+{
+  int j;
+  j = *(p) ;
+  j += ((signed char) (*p) ) << 8;
+  if (j)
+    foo();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25183.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25183.c
new file mode 100644
index 000000000..0157b806c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25183.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+enum err {
+  err_IO = 0x8a450000, /* { dg-warning "int" } */
+  err_NM,
+  err_EOF,
+  err_SE,
+  err_PT
+};
+static enum err E_;
+int error()
+{
+  switch (E_) {
+    case err_IO : break; 
+    case err_NM : break; 
+    case err_EOF : break;
+    case err_SE : break; 
+    case err_PT : break; 
+    default : return 0;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25481.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25481.c
new file mode 100644
index 000000000..3072e5ecb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25481.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+struct s {
+  int *blah;
+};
+
+static struct s array[] = {
+  { 0 }
+};
+
+void
+foo (struct s *p)
+{
+  unsigned int n = 1;
+  struct s *q = &array[n];
+  while (p < q)
+    p++;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25654.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25654.c
new file mode 100644
index 000000000..03761e93c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25654.c
@@ -0,0 +1,37 @@
+/* { dg-do run } */
+
+extern void abort (void) __attribute__((noreturn));
+
+union setconflict
+{
+  short a[20];
+  int b[10];
+};
+
+int
+main ()
+{
+  int sum = 0;
+  {
+    union setconflict a;
+    short *c;
+    c = a.a;
+    asm ("": "=r" (c):"0" (c));
+    *c = 0;
+    asm ("": "=r" (c):"0" (c));
+    sum += *c;
+  }
+  {
+    union setconflict a;
+    int *c;
+    c = a.b;
+    asm ("": "=r" (c):"0" (c));
+    *c = 1;
+    asm ("": "=r" (c):"0" (c));
+    sum += *c;
+  }
+
+  if (sum != 1)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25706-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25706-1.c
new file mode 100644
index 000000000..49bb32722
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25706-1.c
@@ -0,0 +1,35 @@
+/* { dg-do assemble } */
+/* Invalid assembly generated due to port bug.  */
+struct tcp_opt {
+ unsigned int window_clamp;
+ unsigned int rcv_ssthresh;
+ unsigned short advmss;
+};
+extern int sysctl_tcp_app_win;
+void tcp_init_buffer_space(struct tcp_opt *tp, int maxwin)
+{
+  if (tp->window_clamp >= maxwin)
+    if (sysctl_tcp_app_win && maxwin>4*tp->advmss)
+      tp->window_clamp
+	= ({
+	  int _x = maxwin;
+	  typeof(4*tp->advmss) _y = (4*tp->advmss);
+	  _x > _y ? _x : _y;
+	});
+
+  if (sysctl_tcp_app_win
+      && tp->window_clamp > 2*tp->advmss
+      && tp->window_clamp + tp->advmss > maxwin)
+    tp->window_clamp
+      = ({
+	unsigned short _x = maxwin;
+	unsigned short _y = (maxwin-tp->advmss);
+	_x > _y ? _x : _y;
+      });
+  tp->rcv_ssthresh
+    = ({
+      unsigned int _x = (tp->rcv_ssthresh);
+      unsigned int _y = (tp->window_clamp);
+      _x < _y ? _x : _y;
+    });
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25718-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25718-1.c
new file mode 100644
index 000000000..8333a33a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25718-1.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* PR 25718: invalid constant operand to the "bound" insn; error at
+   assembly time.  We'll make sure the code is correct to: run a few
+   example values.  */
+
+extern void exit (int);
+extern void abort (void);
+unsigned __attribute__ ((__noinline__)) foo(unsigned a)
+{
+  unsigned l;
+  l = (a >= (~0u - 512) ? (~0u - 512) : a);
+  return l;
+}
+
+int
+main (void)
+{
+  if (foo ((unsigned) -512) != (unsigned) -513
+      || foo ((unsigned) -514) != (unsigned) -514
+      || foo ((unsigned) -513) != (unsigned) -513
+      || foo ((unsigned) -1) != (unsigned) -513
+      || foo (513) != 513
+      || foo (0) != 0)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25947-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25947-1.c
new file mode 100644
index 000000000..8af6f8d46
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr25947-1.c
@@ -0,0 +1,22 @@
+/* PR target/25947: define_split in cris.md caused unrecognized insn.  */
+/* { dg-options "-fpic" { target fpic } } */
+/* { dg-skip-if "requires unsupported run-time relocation" { spu-*-* } { "-O0" } { "" } } */
+
+extern char *rl_line_buffer;
+extern int rl_point;
+extern int rl_end;
+static const char *vi_motion = " hl^$0ftFT;,%wbeWBE|";
+void
+rl_vi_complete (int ignore, int key)
+{
+  if ((rl_point < rl_end)
+      &&
+      (!(((rl_line_buffer[rl_point]) == ' ')
+	 || ((rl_line_buffer[rl_point]) == '\t'))))
+    {
+      if (!
+	  (((rl_line_buffer[rl_point + 1]) == ' ')
+	   || ((rl_line_buffer[rl_point + 1]) == '\t')))
+	rl_vi_end_word (1, 'E');
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26222.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26222.c
new file mode 100644
index 000000000..b580db673
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26222.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-tree-pre -fno-tree-loop-im" } */
+
+void putShort (int, int);
+
+int t2;
+void f(int t1)
+{
+  int clutOffset = 52 + 256 * 3 * 2;
+  int x, y, z;
+  for (x = 0; x < 16; x++)
+    for (y = 0; y < 16; y++)
+      for (z = 0; z < 16; z++)
+        {
+          int offset = clutOffset + z * 6 + y * 16 * 6 + x * 16 * 16 * 6;
+          double xf = ((double) x) / ((double) 16 - 1.0);
+          double tt = xf;
+          putShort(offset, tt);
+        } 
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26258.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26258.c
new file mode 100644
index 000000000..e9acd55cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26258.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+
+extern void abort(void);
+
+typedef struct Foo { int a; int b; }  Foo;
+
+Foo foo(Foo first, Foo last, _Bool ret_first)
+{
+  Foo t;
+  Foo *t1 = (ret_first ? &first : &last);
+  first.a = 2;
+  last.b = 3;
+  t.a = t1->a;
+  t.b = t1->b;
+  t.a += first.a;
+  t.b += last.b;
+  return t;
+}
+
+int main()
+{
+  Foo first = (Foo){1, 2};
+  Foo last = (Foo){3, 4};
+  Foo ret = foo(first, last, 0);
+  if (ret.b != 6)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26515.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26515.c
new file mode 100644
index 000000000..a051e2e53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26515.c
@@ -0,0 +1,27 @@
+/* { dg-options "-march=v10" { target cris*-*-* } } */
+struct i
+{
+  long long i_size;
+  struct a *i_mapping;
+};
+struct p
+{
+  struct a *mapping;
+  long index;
+};
+extern void b (struct p*, unsigned);
+extern void u (struct p*);
+void
+block_page_mkwrite (struct i *i, struct p *p)
+{
+  unsigned end = 0;
+  long long size = 0;
+  size = i->i_size;
+  if ((p->mapping != i->i_mapping))
+    goto out_unlock;
+  if (((p->index + 1) << 13) > size)
+    end = size & ~(~(((1UL) << 13) - 1));
+  b (p, end);
+out_unlock:
+  u (p);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26565.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26565.c
new file mode 100644
index 000000000..d45272df3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26565.c
@@ -0,0 +1,30 @@
+/* { dg-do run } */
+/* m32c is already packed.  */
+/* { dg-skip-if "" { "m32c-*-*" } { "*" } { "" } } */
+
+void *memcpy(void *dest, const void *src, __SIZE_TYPE__ n);
+
+struct timeval {
+    long tv_sec;
+};
+
+struct outdata {
+    long align;
+    char seq;
+    struct timeval tv __attribute__((packed)); /* { dg-warning "attribute ignored" "" { target default_packed } } */
+};
+
+void send_probe(struct outdata *outdata, struct timeval *tp) __attribute__((noinline));
+void send_probe(struct outdata *outdata, struct timeval *tp)
+{
+    memcpy(&outdata->tv, tp, sizeof outdata->tv);
+}
+
+struct timeval t;
+struct outdata outdata;
+
+int main()
+{
+  send_probe(&outdata, &t);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26587.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26587.c
new file mode 100644
index 000000000..ad5d60f3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26587.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-require-effective-target int32plus } */
+
+extern void abort(void);
+typedef unsigned int BF_word;
+typedef BF_word BF_key[16 + 2];
+static struct {
+    BF_key P;
+} BF_current;
+int main(void)
+{   
+    BF_word L;
+    BF_word tmp4, *ptr;
+    BF_word i;
+    for (i = 0; i < 16 + 2; i++)
+        BF_current.P[i] = i * 0x98765432;
+    L = 0;
+    ptr = BF_current.P;
+    do {
+        ptr += 2;
+        L ^= BF_current.P[0];
+        tmp4 = L >> 24;
+        L = tmp4 ^ BF_current.P[16 + 1];
+        *(ptr - 2) = L;
+    } while (ptr < &BF_current.P[16 + 2]);
+    if (L != 0x1fdb9752)
+        abort();
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26630.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26630.c
new file mode 100644
index 000000000..96bab36a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26630.c
@@ -0,0 +1,12 @@
+/* { dg-do run } */
+/* { dg-require-effective-target int32plus } */
+
+extern void abort(void);
+int main()
+{
+  int a1 = 40000;
+  int c1 = ( ((int)(short)(a1-10000)) + 10000)*2;
+  if (c1 != 80000)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26672.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26672.c
new file mode 100644
index 000000000..b13b5dcae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26672.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+
+int printf(const char *format, ...);
+extern const char help_string[];
+void app_opts(void) {
+    printf("%s", help_string);
+}
+const char help_string[] = "foo\n";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26763-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26763-1.c
new file mode 100644
index 000000000..37054e7a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26763-1.c
@@ -0,0 +1,18 @@
+/* { dg-do run } */
+
+extern void abort(void);
+
+int try (int *a)
+{
+  return a + -1 > a;
+}
+
+int main(void)
+{
+  int bla[100];
+
+  if (try (bla + 50))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26763-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26763-2.c
new file mode 100644
index 000000000..d8155fb08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26763-2.c
@@ -0,0 +1,18 @@
+/* { dg-do run } */
+
+extern void abort(void);
+
+int try (char *a, int d)
+{
+  return a + d > a;
+}
+
+int main(void)
+{
+  char bla[100];
+
+  if (try (bla + 50, -1))
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26869.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26869.c
new file mode 100644
index 000000000..6743319d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26869.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+_Complex float f (_Complex float b, _Complex float c)
+{
+  _Complex float a = 1.0 + 0.0i;
+  return a / c;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26898-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26898-1.c
new file mode 100644
index 000000000..619412929
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26898-1.c
@@ -0,0 +1,15 @@
+/* { dg-do link } */
+/* { dg-options "-fstrict-overflow" } */
+
+#include <limits.h>
+
+extern void link_error(void);
+int main()
+{
+  int i0, i1;
+  if (!(i0 + 1 < i1 + 1 == i0 < i1))
+    link_error ();
+  if (!(i0 + INT_MIN < i1 - INT_MAX == i0 < i1 - -1))
+    link_error ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26898-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26898-2.c
new file mode 100644
index 000000000..508fde4ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26898-2.c
@@ -0,0 +1,12 @@
+/* { dg-do run } */
+
+#include <limits.h>
+
+int a = 0, b = INT_MAX - 1;
+extern void abort(void);
+int main()
+{
+  if (a - 1 > b + 1)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26998.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26998.c
new file mode 100644
index 000000000..d50c34473
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr26998.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+
+int decCompareOp (int result)
+{
+    if (result != (int)0x80000000)
+    {
+        result = -result;
+        return (result > 0);
+    }
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27116-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27116-2.c
new file mode 100644
index 000000000..9c748b245
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27116-2.c
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+
+extern void abort(void);
+
+int main (void)
+{
+    volatile long int n;
+    n = -2;
+
+    if ((-2147483647L - 1L) / (-n) != -1073741824L)
+	abort ();
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27116.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27116.c
new file mode 100644
index 000000000..70eeb1a86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27116.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+
+extern void abort(void);
+
+int f(int a, int b)
+{
+  return (-1 - a) / (-b);
+}
+
+int main()
+{
+  if (f(__INT_MAX__, 2) != __INT_MAX__/2 + 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27136.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27136.c
new file mode 100644
index 000000000..32b7bf123
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27136.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math" } */
+
+void foo()
+{
+  double x;
+
+  for (x = 2; x < 10; x *= x)
+    ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27184.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27184.c
new file mode 100644
index 000000000..cfb6ed2a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27184.c
@@ -0,0 +1,22 @@
+/* Copyright 2006 Free Software Foundation */
+
+/* Make sure a and a1 alias each other.
+   Incomplete array types used to not be unified, which broke aliasing.  */
+
+/* { dg-do run } */
+
+typedef long atype[];
+typedef long atype1[];
+int NumSift (atype *a, atype1 *a1)
+{
+  (*a)[0] = 0;
+  (*a1)[0] = 1;
+  return (*a)[0];
+}
+int main(void)
+{
+  long a[2];
+  if (!NumSift(&a, &a))
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27302-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27302-2.c
new file mode 100644
index 000000000..5c201b3d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27302-2.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-fstrict-overflow" } */
+
+extern void link_error (void);
+
+void test0 (int a, int b)
+{
+  if ((a < b) != (b > a))
+    link_error ();
+
+  if ((a - 1 < b) != (a <= b))
+    link_error ();
+  if ((a - 2 < b) != (a - 1 <= b))
+    link_error ();
+  if ((a + -1 < b) != (a <= b))
+    link_error ();
+  if ((a + -2 < b) != (a + -1 <= b))
+    link_error ();
+
+  if ((a + 1 > b) != (a >= b))
+    link_error ();
+  if ((a + 2 > b) != (a + 1 >= b))
+    link_error ();
+  if ((a - -1 > b) != (a >= b))
+    link_error ();
+  if ((a - -2 > b) != (a - -1 >= b))
+    link_error ();
+
+  if ((a + 1 <= b) != (a < b))
+    link_error ();
+  if ((a + 2 <= b) != (a + 1 < b))
+    link_error ();
+  if ((a - -1 <= b) != (a < b))
+    link_error ();
+  if ((a - -2 <= b) != (a - -1 < b))
+    link_error ();
+
+  if ((a - 1 >= b) != (a > b))
+    link_error ();
+  if ((a - 2 >= b) != (a - 1 > b))
+    link_error ();
+  if ((a + -1 >= b) != (a > b))
+    link_error ();
+  if ((a + -2 >= b) != (a + -1 > b))
+    link_error ();
+}
+
+int main()
+{
+  test0 (1, 2);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27302.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27302.c
new file mode 100644
index 000000000..0e41fc385
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27302.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+
+extern void link_error (void);
+
+void test0 (int a, int b)
+{
+  if ((a < b) != (b > a))
+    link_error ();
+}
+
+int main()
+{
+  test0 (1, 2);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27409.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27409.c
new file mode 100644
index 000000000..430e6c8cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27409.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+
+typedef struct {
+        struct { } z;
+} thang_t;
+
+struct {
+        short           e;
+        thang_t         f;
+        int g;
+} my_struct;
+
+void function(int blaz)
+{
+  thang_t *fp = &my_struct.f;
+  foo(fp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27603.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27603.c
new file mode 100644
index 000000000..8cb0235ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27603.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+
+void exit (int);
+void abort (void);
+int a;
+int main()
+{
+  int j;
+  for (j = 0; j < 6; j++)
+  {
+    if ((unsigned)j - 3 <= 1)
+      exit (0);
+    a = 1000 * (6 - j);
+  }
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27743.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27743.c
new file mode 100644
index 000000000..47d70457c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27743.c
@@ -0,0 +1,16 @@
+/* { dg-do run { target { stdint_types } } } */
+
+#include <stdint.h>
+extern void abort(void);
+
+int32_t bar (int32_t a)
+{
+  return ((uint32_t) ((a) >> 2)) >> 15;
+}
+
+int main()
+{
+  if (bar (0xffff3000) != 0x1ffff)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27773.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27773.c
new file mode 100644
index 000000000..e30e540ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr27773.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+
+_Complex float f(_Complex float a, float b)
+{
+  return a - a*b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28045.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28045.c
new file mode 100644
index 000000000..f2d16646c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28045.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+
+extern void abort(void);
+struct a
+{
+   unsigned int bits : 1;
+   signed long val : ((sizeof(long) * 8) - 1);
+};
+int Fnegate (struct a b)
+{
+  if ((-((long)b.val)) <= ((long) ((1UL << ((sizeof(long) * 8) - 2)) -1UL))
+      && (-((long)b.val)) >= (-(((long) ((1UL << ((sizeof(long) * 8) - 2)) -1UL))) - 1))
+     return 0 ;
+  abort ();
+}
+int main ()
+{
+  struct a b = {1, 1};
+  Fnegate (b);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28230.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28230.c
new file mode 100644
index 000000000..5ecc0c716
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28230.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-options "-fwrapv" } */
+
+void foo( unsigned long long bb, unsigned short tn, unsigned e, unsigned* w );
+void foo( unsigned long long bb, unsigned short tn, unsigned e, unsigned* w )
+{
+        unsigned n = tn + bb;
+        do {
+                e = (e > n) ? e : *w;
+                n -= (e > n) ? n : e;
+                if (*w)
+                        *w = 0;
+        } while ( n );
+}
+int main()
+{
+        unsigned w = 0;
+        foo( 0, 0, 0, &w );
+        return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28268.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28268.c
new file mode 100644
index 000000000..f143c0804
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28268.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+
+int __attribute__((vector_size(8))) a;
+
+void foo()
+{
+    a += a*a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28814.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28814.c
new file mode 100644
index 000000000..cc3c9f6ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28814.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target { ilp32 || lp64 } } } */
+
+struct w49
+{
+  union
+  {
+  }
+  value;
+};
+f9887 (struct w49 a23040)
+{
+  unsigned long r9887;
+  if (((struct structure_type24753 *) (r9887 - 1)) == ((void *) 0))
+    {
+      backtrace ("stalin.sc", 7222, 248274);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28900.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28900.c
new file mode 100644
index 000000000..75555f46e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr28900.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-ftree-vectorize" } */
+
+int synths_ ( float * rc)
+{
+  float r1, r2;
+  int i;
+  for (i = 0; i < 128; ++i)
+    {
+      r2 = rc[i];
+      r1 = ((r2) <= (.99f) ? (r2) : (.99f));
+      rc[i] = ((r1) >= (-.99f) ? (r1) : (-.99f));
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29119.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29119.c
new file mode 100644
index 000000000..63e5d8693
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29119.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+void ldt_add_entry(void)
+{
+   __asm__ ("" :: "m"(({unsigned __v; __v;})));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29446.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29446.c
new file mode 100644
index 000000000..5571c71e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29446.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+
+void f(_Bool D917, int j0, int ubound1, int ubound5)
+{
+  int i, j = j0;
+  int (*abc)[3];
+  i = 1;
+  while (1)
+    {
+       if (j <= 3)
+         while (1)
+           {
+              if (i != j)
+                {
+                  if (ubound1 <= 0)
+                    return;
+                  (*abc)[1] = 0;
+                }
+               else
+                 {
+                    if (j > ubound1)
+                      return;
+                    if (ubound5 <= 0)
+                      return;
+                  }
+               j = j + 1;
+               if (D917)
+                 break;
+           }
+    i = i + 1;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29584.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29584.c
new file mode 100644
index 000000000..4cb51d275
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr29584.c
@@ -0,0 +1,28 @@
+/* PR middle-end/29584 */
+/* { dg-do compile { target { ilp32 || lp64 } } } */
+
+extern void *foo1 (void);
+extern void foo2 (void);
+extern void foo3 (void *, void *);
+extern int foo4 (void);
+
+void
+bar (void)
+{
+  int i;
+  void *s;
+  for (i = 1; i < 4; i++)
+    {
+      if (foo4 ())
+	foo2 ();
+      switch (0x8000000UL + i * 0x400)
+	{
+	case 0x80000000UL ... 0x80000000UL + 0x3a000000UL - 1:
+	  s = 0;
+	  break;
+	default:
+	  s = foo1 ();
+	}
+      foo3 ((void *) (0x8000000UL + i * 0x400), s);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30313.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30313.c
new file mode 100644
index 000000000..aefeb7866
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30313.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+static inline void bar(){}
+
+struct S
+{
+#if __INT_MAX__ == 32767
+  signed int i: 16;
+#elif __INT_MAX__ == 2147483647
+  signed int i: 32;
+#elif __INT_MAX__ == 9223372036854775807
+  signed int i: 64;
+#else
+#error Please add support for your target here
+#endif
+};
+
+int main()
+{
+  struct S x = {32};
+  sizeof(x.i+0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-1.c
new file mode 100644
index 000000000..64ee7e44e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-1.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+
+#include <limits.h>
+extern void abort (void);
+
+int f(int a, int b)
+{
+  if (a > INT_MAX - 15) return 0;
+  if (b > INT_MAX - 15) return 0;
+
+  int c = (a - 20) + (b - 20);
+  return c > INT_MAX - 15;
+}
+
+int main()
+{
+  if (f (INT_MAX - 15, 41) != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-2.c
new file mode 100644
index 000000000..d8b678d53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-2.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+
+#include <limits.h>
+extern void abort (void);
+
+int f(unsigned int a, unsigned int b)
+{
+  if (a > INT_MAX - 15) return 0;
+  if (b > INT_MAX - 15) return 0;
+
+  int c = (a - 20) + (b - 20);
+  return c > INT_MAX - 15;
+}
+
+int main()
+{
+  if (f (INT_MAX - 15, 41) != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-3.c
new file mode 100644
index 000000000..ae96ba39f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30364-3.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-fwrapv" } */
+
+#include <limits.h>
+extern void abort (void);
+
+int f(int a, int b)
+{
+  if (a > INT_MAX - 15) return 0;
+  if (b > INT_MAX - 15) return 0;
+
+  int c = (a - 20) + (b - 20);
+  return c > INT_MAX - 15;
+}
+
+int main()
+{
+  if (f (INT_MAX - 15, 41) != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30375.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30375.c
new file mode 100644
index 000000000..ea63f97c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30375.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "--param max-aliased-vops=0" } */
+
+typedef struct _s {
+    int a;
+    int b;
+    int c;
+    int d;
+} s;
+
+extern void abort(void);
+
+void __attribute__((noinline)) g(s *p)
+{
+  if (p->d != 0)
+    abort ();
+}
+
+char *c = (void*)0;
+void __attribute__((noinline)) f(void) { if (c) *c = 1; }
+
+void test_signed_msg_encoding(void)
+{
+    s signInfo = { sizeof(signInfo), 0 };
+
+    signInfo.b = 1;
+    signInfo.c = 0;
+    g(&signInfo);
+    signInfo.d = 1;
+    f();
+}
+
+int main()
+{
+  test_signed_msg_encoding ();
+  test_signed_msg_encoding ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30665-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30665-1.c
new file mode 100644
index 000000000..4650408d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30665-1.c
@@ -0,0 +1,24 @@
+/* PR target/30665: bug in cris.md peephole2 condition.
+   Testcase for trunk.  */
+/* { dg-do run } */
+
+extern void abort (void);
+extern void exit (int);
+
+int  __attribute__ ((__noinline__)) f (unsigned *p, int *x)
+{
+  int y = *p++ & 0xfff;
+  *x++ = y;
+  *x = *p;
+  return y;
+}
+
+int main (void)
+{
+  unsigned u[2] = { 0x3aad, 0x5ad1 };
+  int x[2] = {17689, 23456};
+
+  if (f (u, x) != 0xaad || x[0] != 0xaad || x[1] != 0x5ad1)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30665-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30665-2.c
new file mode 100644
index 000000000..a2cbf024c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr30665-2.c
@@ -0,0 +1,57 @@
+/* PR target/30665: bug in cris.md peephole2 condition.
+   Original reduced testcase (fails on 3.2.1 derivate, not on trunk).  */
+/* { dg-do run } */
+
+extern void abort (void);
+extern void exit (int);
+
+struct t
+{
+  unsigned int a : 12;
+  unsigned int b  : 12;
+  unsigned int dummy1 : 8;
+};
+
+struct area
+{
+  int xa;
+  int xb;
+};
+
+struct c
+{
+  struct area ii;
+};
+
+static struct c c;
+
+void  __attribute__ ((__noinline__)) g(int a)
+{
+  if (a != 79)
+    abort ();
+}
+
+void  __attribute__ ((__noinline__)) h(struct t tt)
+{
+  if (tt.a != 20 || tt.b != 79)
+    abort ();
+}
+
+void __attribute__ ((__noinline__)) s(void);
+
+int main(int argc, char **argv)
+{
+  c.ii.xa = 20;
+  c.ii.xb = 79;
+
+  s();
+
+  exit (0);
+}
+
+void __attribute__ ((__noinline__)) s(void)
+{
+  struct t ii_x = { .a = c.ii.xa, .b = c.ii.xb };
+  g(c.ii.xb);
+  h(ii_x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr31115.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr31115.c
new file mode 100644
index 000000000..1395a34b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr31115.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+
+extern void exit(int);
+extern void abort();
+void foo (int e1)
+{
+  if (e1 < 0)
+    {
+      e1 = -e1;
+      if (e1 >>= 4)
+        {
+          if (e1 >= 1 << 5)
+            exit(0);
+        }
+    }
+}
+
+int main()
+{
+  foo(-(1<<9));
+  abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr31254.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr31254.c
new file mode 100644
index 000000000..cec301273
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr31254.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+struct timespec
+{
+  long tv_sec;
+  long tv_nsec;
+};
+struct inode
+{
+  struct timespec i_atime;
+  struct timespec i_mtime;
+};
+struct afs_vnode
+{
+  struct inode vfs_inode;
+};
+static inline
+  struct inode *AFS_VNODE_TO_I (struct afs_vnode *vnode)
+{
+  return &vnode->vfs_inode;
+};
+afs_inode_map_status (struct afs_vnode *vnode)
+{
+  struct inode *inode = AFS_VNODE_TO_I (vnode);
+  inode->i_atime = inode->i_mtime;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr32897.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr32897.c
new file mode 100644
index 000000000..3dc43ece0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr32897.c
@@ -0,0 +1,27 @@
+/* { dg-options "-G0" { target mips*-*-* } } */
+
+volatile int g[32];
+long long gll;
+double gd;
+
+#define MULTI(X) \
+	X( 1), X( 2), X( 3), X( 4), X( 5), X( 6), X( 7), X( 8), X( 9), X(10), \
+	X(11), X(12), X(13), X(14), X(15), X(16), X(17), X(18), X(19), X(20), \
+	X(21), X(22), X(23), X(24), X(25), X(26), X(27), X(28), X(29), X(30)
+
+#define DECLARE(INDEX) x##INDEX
+#define COPY_IN(INDEX) x##INDEX = g[INDEX]
+#define COPY_OUT(INDEX) g[INDEX] = x##INDEX
+
+void
+test (int n)
+{
+  union { long long l; double d; } u = { 0x12345678 };
+  gll = u.l;
+  int MULTI (DECLARE);
+  MULTI (COPY_IN);
+  MULTI (COPY_OUT);
+  MULTI (COPY_OUT);
+  MULTI (COPY_OUT);
+  gd = u.d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33560.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33560.c
new file mode 100644
index 000000000..5b2359b3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33560.c
@@ -0,0 +1,30 @@
+/* { dg-do run } */
+/* { dg-options "--param max-aliased-vops=0" } */
+
+struct T
+{
+  int a, b;
+} t;
+
+__attribute__((noinline)) struct T *f (struct T *p)
+{
+  struct T *q = __builtin_malloc (sizeof (struct T));
+  *q = *p;
+  return q;
+}
+
+int main (void)
+{
+  struct T *p;
+
+  t.a = 1;
+  t.b = 2;
+  p = f (&t);
+  t.a = 3;
+
+  if (p->a != 1)
+    __builtin_abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33563.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33563.c
new file mode 100644
index 000000000..47907db7e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33563.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "--param max-aliased-vops=0" } */
+
+struct T
+{
+  int a, b;
+} t, q;
+
+int main (void)
+{
+  struct T *p;
+
+  t.a = 1;
+  t.b = 2;
+  q = t;
+  t.a = 3;
+
+  if (q.a != 1)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33655.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33655.c
new file mode 100644
index 000000000..2f9da65ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33655.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+typedef struct {
+    unsigned long attr;
+    int chars[2];
+} cchar_t;
+typedef struct _win_st {
+    cchar_t _bkgrnd;
+} WINDOW;
+void render_char(WINDOW *win, cchar_t ch)
+{
+    if ((ch).chars[0] == L' '
+        && (ch).chars[1] == L'\0')
+        win->_bkgrnd = ch;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33848.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33848.c
new file mode 100644
index 000000000..c3b85e9e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33848.c
@@ -0,0 +1,43 @@
+/* &&foo should be hoisted, but on most targets, excess register pressure
+   forces it to be rematerialized before "data != &&foo".  On targets that
+   have a "branch if registers are equal" instruction, this leads to the
+   branch having two LABEL_REFs: one for the branch target and one for
+   &&foo.  When reloading &&foo into a register, reload would wrongly
+   say that &&foo was the target of the branch, and the real target would
+   then be removed as dead.  */
+/* { dg-do link } */
+#define NVARS 30
+#define MULTI(X) \
+  X( 0), X( 1), X( 2), X( 3), X( 4), X( 5), X( 6), X( 7), X( 8), X( 9), \
+  X(10), X(11), X(12), X(13), X(14), X(15), X(16), X(17), X(18), X(19), \
+  X(20), X(21), X(22), X(23), X(24), X(25), X(26), X(27), X(28), X(29)
+
+#define DECLARE(INDEX) i##INDEX = gv[INDEX]
+#define COPY(INDEX) gv[INDEX] = i##INDEX
+
+volatile int gv[NVARS];
+void *volatile data;
+
+int
+main (void)
+{
+  __label__ foo;
+
+  if (gv[0] == 1)
+    goto foo;
+  data = &&foo;
+  do
+    {
+      int MULTI (DECLARE);
+      MULTI (COPY);
+      MULTI (COPY);
+      MULTI (COPY);
+      if (data != &&foo)
+	gv[0] = 1;
+      else
+	gv[1] = 2;
+    }
+  while (gv[0] > 0);
+ foo:
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33870.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33870.c
new file mode 100644
index 000000000..519efd3a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr33870.c
@@ -0,0 +1,30 @@
+/* { dg-do run } */
+/* { dg-options "--param max-aliased-vops=1" } */
+
+struct X {
+  int i;
+  int a[4];
+} m;
+
+int a[4];
+
+int __attribute__((noinline)) foo(int b)
+{
+  int (*p)[4] = b ? &a : &m.a;
+  a[3] = 0;
+  (*p)[3] = 1;
+  return (*p)[3] + (*p)[2] + (*p)[1] + a[0] + a[3];
+}
+
+extern void abort (void);
+
+int main()
+{
+  int i;
+  for (i = 0; i < 4; ++i)
+    a[i] = 0;
+  if (foo(1) != 2)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr34174-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr34174-1.c
new file mode 100644
index 000000000..0f1ed067f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr34174-1.c
@@ -0,0 +1,44 @@
+/* { dg-do run } */
+/* Based on PR target/27386 testcase by Joerg Wunsch.  */
+
+extern void abort (void);
+extern void exit (int);
+
+#if __INT_MAX__ >= 9223372036854775807LL
+typedef unsigned int uint64_t;
+#elif __LONG_MAX__ >= 9223372036854775807LL
+typedef unsigned long int uint64_t;
+#elif __LONG_LONG_MAX__ >= 9223372036854775807LL
+typedef unsigned long long int uint64_t;
+#else
+int
+main (void)
+{
+  exit (0);
+}
+#endif
+
+uint64_t a, b, c;
+
+int
+foo (uint64_t x, uint64_t y, uint64_t z, int i)
+{
+  a = x;
+  b = y;
+  c = z;
+  return 2 * i;
+}
+
+int
+main (void)
+{
+  if (foo (1234512345123ull, 3456734567345ull, 7897897897897ull, 42) != 84)
+    abort ();
+  if (a != 1234512345123ull)
+    abort ();
+  if (b != 3456734567345ull)
+    abort ();
+  if (c != 7897897897897ull)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr34330.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr34330.c
new file mode 100644
index 000000000..0ed2f9fb3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr34330.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target pthread } */
+/* { dg-options "-ftree-parallelize-loops=4 -ftree-vectorize" } */
+
+struct T
+{
+  int t;
+  struct { short s1, s2, s3, s4; } *s;
+};
+
+void
+foo (int *a, int *b, int *c, int *d, struct T *e)
+{
+  int i;
+  for (i = 0; i < e->t; i++)
+    {
+      e->s[i].s1 = a[i];
+      e->s[i].s2 = b[i];
+      e->s[i].s3 = c[i];
+      e->s[i].s4 = d[i];
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35227.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35227.c
new file mode 100644
index 000000000..d951d250f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35227.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+
+mandel(double _Complex C)
+{
+  int py;
+  C = (__extension__ 1.0iF) * (double)py;
+  return cabs(C);  /* { dg-warning "incompatible" } */
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35400.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35400.c
new file mode 100644
index 000000000..285dc72e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35400.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-Wtype-limits" } */
+
+struct A
+{
+  struct A *p;
+};
+
+int foo(const struct A *q)
+{
+  return q->p == q;
+}
+
+void bar(int);
+
+void baz()
+{
+  struct A a;
+
+  while (foo(&a))
+    bar(foo(&a));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-1.c
new file mode 100644
index 000000000..c88241bcb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-1.c
@@ -0,0 +1,8 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse2" } */
+
+typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
+
+#define TYPE __m128
+
+#include "pr35771.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-2.c
new file mode 100644
index 000000000..d036f396e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-2.c
@@ -0,0 +1,8 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse2" } */
+
+typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__));
+
+#define TYPE __m128d
+
+#include "pr35771.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-3.c
new file mode 100644
index 000000000..b76c569f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771-3.c
@@ -0,0 +1,8 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse2" } */
+
+typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
+
+#define TYPE __m128i
+
+#include "pr35771.h"
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771.h
new file mode 100644
index 000000000..01c248751
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35771.h
@@ -0,0 +1,40 @@
+typedef TYPE __attribute__((aligned(1))) unaligned;
+
+#include "cpuid.h"
+
+extern void abort (void);
+
+
+TYPE  __attribute__((noinline))
+foo (TYPE a1, TYPE a2, TYPE a3, TYPE a4,
+     TYPE a5, TYPE a6, TYPE a7, TYPE a8,
+     int b1, int b2, int b3, int b4, int b5, int b6, int b7, unaligned y)
+{
+  return y;
+}
+
+void
+do_test (void)
+{
+  unaligned x;
+  TYPE y = { 0 };
+  x = y; 
+  y = foo (y, y, y, y, y, y, y, y, 1, 2, 3, 4, 5, 6, -1, x);
+  if (__builtin_memcmp (&y, &x, sizeof (y)) != 0)
+    abort ();
+}
+
+int
+main (void)
+{
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    do_test ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35833.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35833.c
new file mode 100644
index 000000000..2e740f29f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35833.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "-ftree-vrp" } */
+
+struct S {struct S *field;};
+struct S True, False, Z;
+static inline int f(void) {return 1;}
+static inline int g(struct S **obj) {
+   return f() && *obj == &Z;
+}
+struct S **h(struct S **x) {
+   if (x)
+      return g(x) ? &True.field : &False.field;
+   else
+      return &True.field;
+}
+extern void abort (void);
+int main()
+{
+  if (h(&False.field) != &False.field)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35842.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35842.c
new file mode 100644
index 000000000..05b26d84c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr35842.c
@@ -0,0 +1,12 @@
+/* { dg-do compile { target { *-*-mingw* } } } */
+extern __attribute__((dllimport)) const int SSL_ImplementedCiphers[];
+extern void SSL_GetCipherSuiteInfo(int cipherSuite);
+void nsCipherInfo(int SSL_NumImplementedCiphers)
+{
+  int i;
+  for (i = 0; i < SSL_NumImplementedCiphers; ++i)
+    {
+      const int i_id = SSL_ImplementedCiphers[i];
+      SSL_GetCipherSuiteInfo(i_id);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36066.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36066.c
new file mode 100644
index 000000000..0e1d1ce30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36066.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-funsafe-loop-optimizations -ftree-vrp" } */
+
+typedef int FLAC__int32;
+typedef int FLAC__bool;
+typedef struct { } FLAC__Subframe;
+typedef enum { FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT = 0,  FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE = 1,  FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE = 2,  FLAC__CHANNEL_ASSIGNMENT_MID_SIDE = 3 } FLAC__ChannelAssignment;
+typedef struct {
+  struct FLAC__StreamEncoderProtected *protected_;
+  struct FLAC__StreamEncoderPrivate *private_;
+} FLAC__StreamEncoder;
+typedef struct FLAC__StreamEncoderProtected {
+  FLAC__bool loose_mid_side_stereo;
+  unsigned channels;
+  unsigned blocksize;
+} FLAC__StreamEncoderProtected;
+typedef struct FLAC__StreamEncoderPrivate {
+  FLAC__int32 *integer_signal[(8u)];
+  FLAC__Subframe subframe_workspace_mid_side[2][2];
+  unsigned best_subframe_mid_side[2];
+  unsigned loose_mid_side_stereo_frame_count;
+} FLAC__StreamEncoderPrivate;
+static void get_wasted_bits_(FLAC__int32 signal[], unsigned samples)
+{
+  unsigned i;
+  FLAC__int32 x = 0;
+  for(i = 0; i < samples && !(x&1); i++)
+    x |= signal[i];
+}
+FLAC__Subframe * process_subframes_(FLAC__StreamEncoder *encoder, unsigned *bits)
+{
+  unsigned channel;
+  FLAC__Subframe *left_subframe = 0;
+  FLAC__ChannelAssignment channel_assignment;
+  for(channel = 0; channel < encoder->protected_->channels; channel++)
+      get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize);
+  if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0)
+      channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
+  else {
+      FLAC__ChannelAssignment ca = (FLAC__ChannelAssignment)1;
+      unsigned min_bits = bits[0];
+      for(channel_assignment = (FLAC__ChannelAssignment)0; (int)ca <= 3; ca = (FLAC__ChannelAssignment)((int)ca + 1))
+	  if(bits[ca] < min_bits)
+	      channel_assignment = ca;
+  }
+  switch(channel_assignment) {
+      case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
+      case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
+      case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+      case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
+	  left_subframe = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]];
+  }
+  return left_subframe;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36227.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36227.c
new file mode 100644
index 000000000..462b2c4f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36227.c
@@ -0,0 +1,17 @@
+/* { dg-do run { target { stdint_types } } } */
+
+#include <stdint.h>
+extern void abort (void);
+int main()
+{
+  int i = 1;
+  int *p = &i;
+  uintptr_t iptr;
+
+  iptr = (uintptr_t)p - (uintptr_t)&iptr;
+  p = (int *)((uintptr_t)&iptr + iptr);
+  if (*p != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36244.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36244.c
new file mode 100644
index 000000000..b1b14be18
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36244.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target pthread } */
+/* { dg-options "-O3 -ftree-parallelize-loops=4" } */
+
+struct p7prior_s {
+  int   mnum;        /* number of mat emission Dirichlet mixtures */
+  float mq[200];     /* probabilities of mnum components          */
+  float m[200][20];  /* match emission terms per mix component    */
+};
+
+struct p7prior_s *default_amino_prior(void);
+struct p7prior_s *P7AllocPrior(void);
+
+struct p7prior_s *
+default_amino_prior(void)
+{
+  struct p7prior_s *pri;
+  int x, q;
+
+  static float defmq[5] = {
+    0.178091, 0.056591, 0.0960191, 0.0781233, 0.0834977 };
+ static float defm[5][6] = {
+    { 0.270671, 0.039848, 0.017576, 0.016415, 0.014268, 0.216147 },
+    { 0.021465, 0.010300, 0.011741, 0.010883, 0.385651, 0.029156 },
+    { 0.561459, 0.045448, 0.438366, 0.764167, 0.087364, 0.583402 },
+    { 0.070143, 0.011140, 0.019479, 0.094657, 0.013162, 0.073732 },
+    { 0.041103, 0.014794, 0.005610, 0.010216, 0.153602, 0.012049 }
+  };
+
+  pri = P7AllocPrior();
+  pri->mnum  = 5;
+  for (q = 0; q < pri->mnum; q++)
+    {
+      pri->mq[q] = defmq[q];
+      for (x = 0; x < 6; x++)
+        pri->m[q][x] = defm[q][x];
+    }
+  return pri;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-1.c
new file mode 100644
index 000000000..9cd02c57a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-1.c
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-options "-fno-tree-sra" } */
+
+extern void abort (void);
+struct Bar {
+    struct Foo {
+	int *p;
+    } x;
+    int *q;
+};
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo(struct Foo f)
+{
+  *f.p = 0;
+}
+int main()
+{
+  int a, b;
+  a = 0;
+  b = 1;
+  struct Bar f;
+  f.x = bar (&b);
+  f.q = &a;
+  foo(f.x);
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-10.c
new file mode 100644
index 000000000..ed7017728
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-10.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+
+#if (__SIZEOF_LONG_LONG__ == __SIZEOF_POINTER__)
+typedef unsigned long long uintptr_t;
+#elif (__SIZEOF_LONG__ == __SIZEOF_POINTER__)
+typedef unsigned long uintptr_t;
+#elif (__SIZEOF_INT__ == __SIZEOF_POINTER__)
+typedef unsigned int uintptr_t;
+#else
+#error Add target support here
+#endif
+
+void __attribute__((noinline))
+foo(uintptr_t l)
+{
+  int *p = (int *)l;
+  *p = 1;
+}
+
+extern void abort (void);
+int main()
+{
+  int b = 0;
+  uintptr_t l = (uintptr_t)&b;
+  foo(l);
+  if (b != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-2.c
new file mode 100644
index 000000000..2653182a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-2.c
@@ -0,0 +1,37 @@
+/* { dg-do run } */
+/* { dg-options "-fno-tree-sra" } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+};
+struct Bar {
+    struct Foo *x;
+    int *q;
+};
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo(struct Foo f)
+{
+  *f.p = 0;
+}
+int main()
+{
+  int a, b;
+  a = 0;
+  b = 1;
+  struct Bar f;
+  struct Foo g = bar (&b);
+  f.x = &g;
+  f.q = &a;
+  foo(*f.x);
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-3.c
new file mode 100644
index 000000000..d5ad93e1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-3.c
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+};
+struct Bar {
+    struct Foo *x;
+    int *q;
+};
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo(struct Foo f)
+{
+  *f.p = 0;
+}
+int main()
+{
+  int a, b;
+  a = 0;
+  b = 1;
+  struct Bar f;
+  struct Foo g = bar (&b);
+  f.x = &g;
+  f.q = &a;
+  foo(*f.x);
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-4.c
new file mode 100644
index 000000000..5f3b83349
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-4.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+    int *q;
+};
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo(struct Foo f)
+{
+  *f.p = 0;
+}
+int main()
+{
+  int a, b;
+  a = 0;
+  b = 1;
+  struct Foo f;
+  f = bar (&b);
+  f.q = &a;
+  foo(f);
+  if (b != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-5.c
new file mode 100644
index 000000000..0061ef418
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-5.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-fno-tree-sra" } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+    int *q;
+};
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo(struct Foo f)
+{
+  *f.p = 0;
+}
+int main()
+{
+  int a, b;
+  a = 0;
+  b = 1;
+  struct Foo f;
+  f = bar (&b);
+  f.q = &a;
+  foo(f);
+  if (b != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-6.c
new file mode 100644
index 000000000..c55e3ff3f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-6.c
@@ -0,0 +1,30 @@
+/* { dg-do run } */
+/* { dg-options "-fno-tree-sra" } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+} x;
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo()
+{
+  *x.p = 0;
+}
+int main()
+{
+  int b;
+  b = 1;
+  struct Foo g = bar (&b);
+  x = g;
+  foo();
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-7.c
new file mode 100644
index 000000000..103694e15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-7.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+} x;
+struct Foo __attribute__((noinline))
+bar(int *p)
+{
+  struct Foo f;
+  f.p = p;
+  return f;
+}
+void __attribute__((noinline))
+foo()
+{
+  *x.p = 0;
+}
+int main()
+{
+  int b;
+  b = 1;
+  struct Foo g = bar (&b);
+  x = g;
+  foo();
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-8.c
new file mode 100644
index 000000000..9f77ea137
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-8.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-fno-tree-sra" } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+} x;
+void __attribute__((noinline))
+foo()
+{
+  *x.p = 0;
+}
+int main()
+{
+  int b;
+  struct Foo g;
+  b = 1;
+  g.p = &b;
+  x = g;
+  foo();
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-9.c
new file mode 100644
index 000000000..5588eadae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36373-9.c
@@ -0,0 +1,23 @@
+/* { dg-do run } */
+
+extern void abort (void);
+struct Foo {
+    int *p;
+} x;
+void __attribute__((noinline))
+foo()
+{
+  *x.p = 0;
+}
+int main()
+{
+  int b;
+  struct Foo g;
+  b = 1;
+  g.p = &b;
+  x = g;
+  foo();
+  if (b != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36400.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36400.c
new file mode 100644
index 000000000..bd9f35a5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36400.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+struct barstruct { char const* some_string; };
+
+void changethepointer(struct barstruct***);
+
+void baz()
+{
+  struct barstruct bar1;
+  struct barstruct* barptr = &bar1;
+  struct barstruct** barptr2 = &barptr;
+  changethepointer(&barptr2);
+  barptr->some_string = "Everything OK";
+}
+
+/* { dg-final { scan-assembler "Everything OK" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36891.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36891.c
new file mode 100644
index 000000000..31f7e1731
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36891.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-ffast-math" } */
+/* { dg-options "-ffast-math -msse" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+#define __vector __attribute__((vector_size(16) ))
+__vector float f(void);
+void g(__vector float);
+void RRB( __vector float vdist, __vector float vx)
+{
+  int detail;
+  for(detail = 0; detail < 5;++detail)
+  {
+   __vector float frand = f();
+   __vector float pullperc =  frand/ vdist;
+   __vector float pullx =  vx * pullperc;
+   g(pullx);
+  }
+}
+
+/* Ignore a warning that is irrelevant to the purpose of this test.  */
+/* { dg-prune-output ".*GCC vector returned by reference.*" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36978.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36978.c
new file mode 100644
index 000000000..cd1af4ebc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr36978.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-funswitch-loops" } */
+
+unsigned short status;
+void foo (const _Bool flag)
+{
+  if (status == 2 || status == 7)
+    {
+      while (status != 2 && (status != 7 || !flag))
+	{
+	}
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37731-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37731-1.c
new file mode 100644
index 000000000..5c156b1f9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37731-1.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+
+extern void abort ();
+
+unsigned long long xh = 1;
+
+int
+main ()
+{
+  unsigned long long yh = 0xffffffffull;
+  unsigned long long z = xh * yh;
+
+  if (z != yh)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37731-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37731-2.c
new file mode 100644
index 000000000..a7f8f1e02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37731-2.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+
+extern void abort ();
+
+long long xh = 1;
+
+int
+main ()
+{
+  long long yh = 0xffffffffll;
+  long long z = xh * yh;
+
+  if (z != yh)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37868.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37868.c
new file mode 100644
index 000000000..50fa90300
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37868.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-fno-strict-aliasing" } */
+/* { dg-skip-if "unaligned access" { sparc*-*-* } "*" "" } */
+
+extern void abort (void);
+
+struct X {
+  unsigned char pad : 4;
+  unsigned int a : 32;
+  unsigned int b : 24;
+  unsigned int c : 6;
+} __attribute__((packed));
+
+int main (void)
+{
+  struct X x;
+  unsigned int bad_bits;
+
+  x.pad = -1;
+  x.a = -1;
+  x.b = -1;
+  x.c = -1;
+
+  bad_bits = ((unsigned int)-1) ^ *(1+(unsigned int *) &x);
+  if (bad_bits != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37969.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37969.c
new file mode 100644
index 000000000..cbb6f0598
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr37969.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-funswitch-loops" } */
+
+void foo(double);
+void CreateDefaultTexture(double mnMinimum, double mnMaximum,
+			  unsigned short nCreateWhat)
+{
+  double d = 0.0;
+  for(;;)
+    {
+      if(nCreateWhat & (0x0001)
+	 && mnMinimum != 0.0)
+	d = mnMinimum;
+      if(nCreateWhat & (0x0002)
+	 && mnMaximum != 0.0)
+	d = mnMaximum;
+      foo(d);
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38271.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38271.c
new file mode 100644
index 000000000..2c64a9b34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38271.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+struct xxx {
+    short a;
+    short b;
+    void *c;
+};
+
+void bar(struct xxx);
+
+void foo(struct xxx *p, int i)
+{
+  struct xxx s0 = *p;
+  struct xxx s = s0;
+  if (s.a) i++;
+  bar(s);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38405.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38405.c
new file mode 100644
index 000000000..3f93445cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38405.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+
+extern void abort ();
+extern int printf (char *__format, ...);
+
+struct vpiBinaryConst {
+ int signed_flag :1;
+ int sized_flag :1;
+};
+
+int binary_get(int code, struct vpiBinaryConst *rfp)
+{
+ switch (code) {
+  case 1:
+   return rfp->signed_flag ? 1 : 0;
+  default:
+   printf("error: %d not supported\n", code);
+   return code;
+ }
+}
+
+int main(void)
+{
+ struct vpiBinaryConst x={1,0};
+ int y=binary_get(1, &x);
+ if (y!=1)
+   abort ();
+ return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38774.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38774.c
new file mode 100644
index 000000000..d6d7fcb0f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38774.c
@@ -0,0 +1,16 @@
+/* PR rtl-optimization/38774 */
+/* { dg-do compile } */
+/* { dg-options "" } */
+/* { dg-options "-march=i686" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+extern int bar (void);
+volatile int g;
+
+int
+foo (void)
+{
+  int a = 1 >= bar ();
+  if ((1 > 9223372036854775807LL - a && 1 - a ? : 1 + a) & 1)
+    return g;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38948.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38948.c
new file mode 100644
index 000000000..98ed493cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr38948.c
@@ -0,0 +1,101 @@
+/* { dg-options "-fno-tree-sra" } */
+/* { dg-options "-fno-tree-sra -march=v32" { target cris-*-* } } */
+typedef unsigned char byte;
+typedef unsigned int uint;
+typedef int bool;
+typedef struct gs_const_string_s
+{
+  const byte *data;
+}
+gs_const_string;
+struct gs_matrix_s
+{
+  float xx, xy, yx, yy, tx, ty;
+};
+typedef struct gs_matrix_s gs_matrix;
+typedef long fixed;
+typedef struct gs_fixed_point_s
+{
+  fixed x, y;
+}
+gs_fixed_point;
+typedef struct gs_matrix_fixed_s
+{
+  int x;
+}
+gs_matrix_fixed;
+static int
+append_simple (const byte * glyph, const gs_matrix_fixed * pmat, void * ppath)
+{
+  int numContours =
+    (int) (((((uint) ((glyph)[0]) << 8) + (glyph)[1]) ^ 0x8000) - 0x8000);
+  const byte *pends = glyph + 10;
+  int code = 0;
+  {
+    uint i = 0;
+    uint np = 0;
+    gs_fixed_point pt = {0};
+    uint reps = 0;
+    for (i = 0, np = 0; i < numContours; ++i)
+      {
+	bool move = ((bool) 1);
+	uint last_point =
+	  (((uint) ((pends + i * 2)[0]) << 8) + (pends + i * 2)[1]);
+	int off_curve = 0;
+	gs_fixed_point cpoints[3];
+	for (; np <= last_point; --reps, ++np)
+	  {
+	    if (move)
+	      {
+		cpoints[0] = pt;
+		move = ((bool) 0);
+	      }
+	    else
+	      {
+		switch (off_curve++)
+		  {
+		  default:
+		    cpoints[2].x = ((cpoints[1].x + pt.x) / 2);
+		    cpoints[2].y = ((cpoints[1].y + pt.y) / 2);
+		    code =
+		      gx_path_add_curve_notes (ppath,
+					       ((cpoints[0].x +
+						 2 * cpoints[1].x) / 3),
+					       ((cpoints[0].y +
+						 2 * cpoints[1].y) / 3),
+					       ((2 * cpoints[1].x +
+						 cpoints[2].x) / 3),
+					       ((2 * cpoints[1].y +
+						 cpoints[2].y) / 3),
+					       cpoints[2].x, cpoints[2].y,
+					       0);
+		    cpoints[0] = cpoints[2];
+		  case 0:
+		    cpoints[1] = pt;
+		  }
+	      }
+	  }
+      }
+  }
+}
+int
+append_outline (uint glyph_index, const gs_matrix_fixed *pmat, void *ppath)
+{
+  gs_const_string glyph_string = {0};
+  int numContours = 0;
+  numContours =
+    (int) (((((uint) ((glyph_string.data)[0]) << 8) +
+	     (glyph_string.data)[1]) ^ 0x8000) - 0x8000);
+  if (numContours >= 0)
+    return append_simple (glyph_string.data, pmat, ppath);
+  {
+    uint flags = 0;
+    do
+      {
+	gs_matrix_fixed mat = {0};
+	gs_matrix scale_mat = {0};
+	gs_matrix_multiply (&scale_mat, (const gs_matrix *) &mat, (gs_matrix *) & mat);
+      }
+    while (flags & 32);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074-2.c
new file mode 100644
index 000000000..89f7ebf8c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074-2.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-require-effective-target stdint_types } */
+/* { dg-options "-fdump-tree-alias" } */
+/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */
+
+#include <stdint.h>
+
+int i;
+uintptr_t __attribute__((noinline,const)) bar(int ***p) { return (uintptr_t)p; }
+void __attribute__((noinline))
+foo(void)
+{
+  int *y;
+  int **a = &y, **x;
+  int ***p;
+  uintptr_t b;
+  b = bar(&a);
+  p = (int ***)b;
+  x = *p;
+  *x = &i; /* *ANYTHING = &i has to make sure that y points to i.  */
+  *y = 0;
+}
+extern void abort (void);
+int main()
+{
+  i = 1;
+  foo ();
+  if (i != 0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "y.._., name memory tag: NMT..., is dereferenced, points-to vars: { i }" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074-3.c
new file mode 100644
index 000000000..7c7604826
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074-3.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-require-effective-target stdint_types } */
+
+#include <stdint.h>
+
+uintptr_t __attribute__((noinline,const)) bar(int ***p) { return (uintptr_t)p; }
+extern void abort (void);
+int main()
+{
+  int i, j;
+  int *y = &j;
+  int **a = &y, **x;
+  int ***p;
+  uintptr_t b;
+  b = bar(&a);
+  p = (int ***)b;
+  x = *p;
+  *x = &i;
+  i = 1;
+  *y = 0;
+  if (i != 0)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074.c
new file mode 100644
index 000000000..ec8befb77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39074.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-fdump-tree-alias" } */
+/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */
+
+typedef __PTRDIFF_TYPE__ intptr_t;
+
+int i;
+void __attribute__((noinline))
+foo(long b, intptr_t q)
+{
+  int *y;
+  int **a = &y, **x;
+  int ***p;
+  if (b)
+    p = (int ***)q;
+  else
+    p = &a;
+  x = *p;
+  *x = &i;  /* *ANYTHING = &i has to make sure that y points to i.  */
+  *y = 0;
+}
+extern void abort (void);
+int main()
+{
+  i = 1;
+  foo (0, 0);
+  if (i != 0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "y.._., name memory tag: NMT..., is dereferenced, points-to vars: { i }" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39132.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39132.c
new file mode 100644
index 000000000..f6e2907e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39132.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-ftree-loop-distribution" } */
+
+extern void abort(void);
+
+struct epic_private
+{
+  unsigned int *rx_ring;
+  unsigned int rx_skbuff[5];
+};
+
+int
+main (void)
+{
+  struct epic_private ep;
+  unsigned int rx_ring[5];
+  int i;
+
+  ep.rx_skbuff[0] = 5;
+
+  ep.rx_ring = rx_ring;
+
+  for (i = 0; i < 5; i++)
+    {
+      ep.rx_ring[i] = i;
+      ep.rx_skbuff[i] = 0;
+    }
+
+  if (ep.rx_skbuff[0] != 0)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39204.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39204.c
new file mode 100644
index 000000000..1389a52ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39204.c
@@ -0,0 +1,131 @@
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+__extension__ typedef signed long long int __int64_t;
+__extension__ typedef unsigned long long int __uint64_t;
+__extension__ typedef long long int __quad_t;
+__extension__ typedef unsigned long long int __u_quad_t;
+__extension__ typedef __u_quad_t __dev_t;
+__extension__ typedef unsigned int __uid_t;
+__extension__ typedef unsigned int __gid_t;
+__extension__ typedef unsigned long int __ino_t;
+__extension__ typedef __u_quad_t __ino64_t;
+__extension__ typedef unsigned int __mode_t;
+__extension__ typedef unsigned int __nlink_t;
+__extension__ typedef long int __off_t;
+__extension__ typedef __quad_t __off64_t;
+__extension__ typedef int __pid_t;
+__extension__ typedef struct {
+    int __val[2];
+} __fsid_t;
+__extension__ typedef long int __clock_t;
+__extension__ typedef unsigned int __id_t;
+typedef struct _IO_FILE FILE;
+typedef struct _IO_FILE __FILE;
+typedef struct {
+    int __count;
+    union   {
+	unsigned int __wch;
+	char __wchb[4];
+    }
+    __value;
+} __mbstate_t;
+typedef struct {
+    __off_t __pos;
+    __mbstate_t __state;
+} _G_fpos_t;
+typedef struct {
+    __off64_t __pos;
+    __mbstate_t __state;
+} _G_fpos64_t;
+typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
+typedef struct _IO_FILE _IO_FILE;
+extern struct _IO_FILE_plus _IO_2_1_stderr_;
+extern int fputs (__const char *__restrict __s, FILE * __restrict __stream);
+extern char *strstr (__const char *__haystack, __const char *__needle)
+     __attribute__ ((__nonnull__ (1, 2)));
+     extern char *rindex (__const char *__s, int __c)   __attribute__ ((__nonnull__ (1)));
+extern size_t strlen (__const char *__s) __attribute__ ((__nothrow__))
+     __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+     char *mystrlwr (char *string);
+     char *m_replace_filename (const char *path, const char *filename);
+     typedef struct LINE {
+	 char *text;
+	 struct LINE *next;
+	 int flags;
+     } LINE;
+typedef struct TOC {
+    char *text;
+    char *alt;
+    struct TOC *next;
+    int root;
+    int texinfoable;
+    int htmlable;
+    int otherfile;
+} TOC;
+static int _empty_count;
+extern char *_word_substitution[256];
+static void _output_sorted_nested_toc (TOC ** list, unsigned int num_items);
+static char *_do_text_substitution (char *input);
+static int _toc_scmp (const void *e1, const void *e2)
+{
+  TOC *t1 = *((TOC **) e1);
+  TOC *t2 = *((TOC **) e2);
+  return mystricmp (t1->text, t2->text);
+}
+static void _output_buffered_text (void) { if (_empty_count) ; }
+void _post_process_filename (char *filename)
+{
+  int code_scanning = 0;
+  char *new_filename, *p;
+  char *line;
+  FILE *f1 = 0, *f2 = 0;
+  if (!new_filename || strlen (new_filename) < 2)
+    new_filename[strlen (filename) - 1] = 'x';
+  if (!f1 || !f2)
+    while ((line = m_fgets (f1)))
+      {
+	line = _do_text_substitution (line);
+	fputs (line, f2);
+      }
+  if (remove (filename))
+    cancel:
+	if (f1)
+	  if (f2)
+	    if (new_filename)
+	      ;
+}
+static void _close_html_file (FILE * file)
+{
+  int f;
+  for (f = 0; _word_substitution[f]; f++)
+    ;
+}
+static __attribute__((always_inline))
+char * _do_text_substitution (char *input)
+{
+  int start, end, middle, f;
+  char *temp, *found, *reader;
+  for (f = 0; _word_substitution[f]; f++)
+    {
+      reader = input;
+      while ((found = strstr (reader, _word_substitution[f])))
+	{
+	  start = found - input;
+	  input = temp;
+	  reader = temp + start + middle;
+	}
+    }
+  return input;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39241.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39241.c
new file mode 100644
index 000000000..860a04d73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39241.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+static inline int
+foo (float f)
+{
+  return *((int *) &f) - 1;
+}
+
+float
+bar (float x, float y, float *z)
+{
+  float c = y < 0.002f ? 0.002f : y;
+  float d = x < c ? c : x;
+  return z[foo (c)] + z[foo (d * 255.0f)];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39678.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39678.c
new file mode 100644
index 000000000..5411fbbc1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39678.c
@@ -0,0 +1,27 @@
+/* PR target/39678 */
+/* { dg-do run } */
+/* { dg-options "-Wno-psabi" } */
+
+struct X {
+  signed char c;
+  __complex__ float val;
+};
+
+struct X __attribute__((noinline))
+foo (float *p)
+{
+  struct X x;
+  x.c = -3;
+  __real x.val = p[0];
+  __imag x.val = p[1];
+  return x;
+}
+extern void abort (void);
+float a[2] = { 3., -2. };
+int main()
+{
+  struct X x = foo(a);
+  if (x.c != -3 || __real x.val != a[0] || __imag x.val != a[1])
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39829.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39829.c
new file mode 100644
index 000000000..da15a56e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39829.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+void foo (void * DAG_temp117584)
+{
+  char  uA;
+  void* pA;
+  void* pB;
+  void* pC;
+  do {
+      int DAG_temp117585;
+      int DAG_temp117586;
+      void ** __indir_union1 = (void**)DAG_temp117584;
+      DAG_temp117585 = (long)*__indir_union1;
+      DAG_temp117586 = DAG_temp117585;
+      if ( DAG_temp117586 != (int)268435456 )
+	pA = (void*)&uA;
+      pB = (void*)&pA;
+      pC = pB;
+      union __block_indir0_u {  struct {  long val; }  __indir_struct; }
+      * __indir_union = (union __block_indir0_u*)pC;
+      f(__indir_union->__indir_struct.val);
+
+      DAG_temp117584 += 64;
+  } while (1);
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39855.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39855.c
new file mode 100644
index 000000000..6d75c38a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39855.c
@@ -0,0 +1,24 @@
+/* PR c/39855 */
+/* { dg-do run { target { int32plus } } } */
+
+extern void abort (void);
+
+int i, j, k;
+
+int
+foo (void)
+{
+  return ++i;
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || sizeof (int) != 4)
+    return 0;
+  j = foo () << 30 << 2;
+  k = (unsigned) foo () >> 16 >> 16;
+  if (i != 2 || j != 0 || k != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39903-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39903-1.c
new file mode 100644
index 000000000..1a67dd795
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39903-1.c
@@ -0,0 +1,24 @@
+/* PR target/39903 */
+/* { dg-do run } */
+/* { dg-options "-Wno-psabi" } */
+
+struct X {
+  double d;
+  double b[];
+};
+
+struct X __attribute__((noinline))
+foo (double d)
+{
+  struct X x;
+  x.d = d;
+  return x;
+}
+extern void abort (void);
+int main()
+{
+  struct X x = foo(3.0);
+  if (x.d != 3.0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39903-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39903-2.c
new file mode 100644
index 000000000..0cd74029b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr39903-2.c
@@ -0,0 +1,24 @@
+/* PR target/39903 */
+/* { dg-do run } */
+/* { dg-options "-Wno-psabi" } */
+
+struct X {
+  float d;
+  float b[];
+};
+
+struct X __attribute__((noinline))
+foo (float d)
+{
+  struct X x;
+  x.d = d;
+  return x;
+}
+extern void abort (void);
+int main()
+{
+  struct X x = foo(3.0);
+  if (x.d != 3.0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40328.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40328.c
new file mode 100644
index 000000000..e378e63c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40328.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-tree-sra" } */
+
+_Complex float foo(void)
+{
+  _Complex float a[64] = {};
+  _Complex float x;
+  x =  a[1];
+  return x;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-1.c
new file mode 100644
index 000000000..cb2510e88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse4" } */
+#include <nmmintrin.h>
+__m128i load (char *);
+char *
+foo (char *p1, char *p2,
+     int bmsk, __m128i mask1, __m128i mask2)
+{
+  int len = 0;
+  __m128i frag1, frag2;
+  int  cmp_s;
+  if( !p2[0]) return p1;
+  if( !p1[0] ) return NULL;
+  frag2 = load (p2); 
+  frag1 = load (p1);
+  frag2 = _mm_blendv_epi8(frag2, mask2, mask1);
+  frag1 = _mm_blendv_epi8(frag1, mask2, mask1);
+  cmp_s = _mm_cmpistrs(frag2, frag1, 0x0c);
+  if( cmp_s )
+    __asm("bsfl %[bmsk], %[len]" : [len] "=r" (len) : [bmsk] "r" (bmsk) );
+  return p1 + len;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-2.c
new file mode 100644
index 000000000..b0414bbea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-2.c
@@ -0,0 +1,27 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse4" } */
+#include <nmmintrin.h>
+__m128i load (char *);
+char *
+foo (const unsigned char *s1, const unsigned char *s2,
+     int bmsk, __m128i frag2)
+{
+  int len = 0;
+  char *p1 = (char  *) s1;
+  char *p2 = (char  *) s2;
+  __m128i frag1, fruc, mask;
+  int cmp_c, cmp_s;
+  if( !p2[0]) return (char *) s1;
+  if( !p1[0] ) return NULL;
+  if( p2[1]) frag2 = load (p2); 
+  frag1 = load (p1);
+  fruc = _mm_loadu_si128 ((__m128i *) s1);
+  mask = _mm_cmpistrm(fruc, frag2, 0x44);
+  frag2 = _mm_blendv_epi8(frag2, mask, mask);
+  frag1 = _mm_blendv_epi8(frag1, mask, mask);
+  cmp_c = _mm_cmpistrc(frag2, frag1, 0x0c);
+  cmp_s = _mm_cmpistrs(frag2, frag1, 0x0c);
+  if( cmp_s  & cmp_c  )
+    __asm("bsfl %[bmsk], %[len]" : [len] "=r" (len) : [bmsk] "r" (bmsk) );
+  return p2 + len;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-3.c
new file mode 100644
index 000000000..5c4c361de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-3.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse4" } */
+#include <nmmintrin.h>
+__m128i load (char *);
+char *
+foo (char *p1, char *p2,
+     int bmsk, __m128i mask1, __m128i mask2)
+{
+  int len = 0;
+  __m128i frag1, frag2;
+  int  cmp_s;
+  if( !p2[0]) return p1;
+  if( !p1[0] ) return NULL;
+  frag2 = load (p2); 
+  frag1 = load (p1);
+  frag2 = _mm_blendv_epi8(frag2, mask2, mask1);
+  frag1 = _mm_blendv_epi8(frag1, mask1, mask2);
+  cmp_s = _mm_cmpistrs(frag2, frag1, 0x0c);
+  if( cmp_s )
+    __asm("bsfl %[bmsk], %[len]" : [len] "=r" (len) : [bmsk] "r" (bmsk) );
+  return p1 + len;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-4.c
new file mode 100644
index 000000000..f9d0e5095
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr40470-4.c
@@ -0,0 +1,29 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-msse4" } */
+#include <nmmintrin.h>
+__m128i load (char *);
+char *
+foo (const unsigned char *s1, const unsigned char *s2,
+     int bmsk, __m128i frag2)
+{
+  int len = 0;
+  char *p1 = (char  *) s1;
+  char *p2 = (char  *) s2;
+  __m128i frag1, fruc1, fruc2, mask1, mask2;
+  int cmp_c, cmp_s;
+  if( !p2[0]) return (char *) s1;
+  if( !p1[0] ) return NULL;
+  if( p2[1]) frag2 = load (p2); 
+  frag1 = load (p1);
+  fruc1 = _mm_loadu_si128 ((__m128i *) s1);
+  fruc2 = _mm_loadu_si128 ((__m128i *) s2);
+  mask1 = _mm_cmpistrm(fruc1, frag2, 0x44);
+  mask2 = _mm_cmpistrm(fruc2, frag1, 0x14);
+  frag2 = _mm_blendv_epi8(frag2, mask1, mask2);
+  frag1 = _mm_blendv_epi8(frag1, mask2, mask1);
+  cmp_c = _mm_cmpistrc(frag2, frag1, 0x0c);
+  cmp_s = _mm_cmpistrs(frag2, frag1, 0x0c);
+  if( cmp_s  & cmp_c  )
+    __asm("bsfl %[bmsk], %[len]" : [len] "=r" (len) : [bmsk] "r" (bmsk) );
+  return p2 + len;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41094.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41094.c
new file mode 100644
index 000000000..2a4e9616c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41094.c
@@ -0,0 +1,19 @@
+/* { dg-do run } */
+/* { dg-options "-ffast-math" } */
+
+#include <math.h>
+
+extern void abort (void);
+
+double foo(void)
+{
+  double x = -4.0;
+  return pow (x * x, 0.25);
+}
+
+int main()
+{
+  if (foo() != 2.0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41261.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41261.c
new file mode 100644
index 000000000..8e601555c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41261.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-fprofile-arcs" } */
+
+extern void relocate_kernel();
+void machine_kexec(void *control_page)
+{ 
+  __builtin_memcpy(control_page, relocate_kernel, 2048);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41555.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41555.c
new file mode 100644
index 000000000..c201fda0c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr41555.c
@@ -0,0 +1,119 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+
+#include <stdint.h>
+#include <limits.h>
+
+extern void abort (void);
+
+static uint64_t safe_div_func_uint64_t_u_u (uint64_t _ui1, uint64_t _ui2)
+{
+  if (_ui2==0) return _ui1;
+  return _ui1 / _ui2;
+}
+
+static int64_t safe_div_func_int64_t_s_s (int64_t _si1, int64_t _si2)
+{
+  if (_si2==0 || (_si1==INT64_MIN && _si2==-1)) return _si1;
+  return _si1 / _si2;
+}
+
+#define safe_add_macro_int8_t_s_s(si1,si2) \
+                ((((((int8_t)(si1))>((int8_t)0)) && (((int8_t)(si2))>((int8_t)0)) && (((int8_t)(si1)) > ((INT8_MAX)-((int8_t)(si2))))) \
+                  || ((((int8_t)(si1))<((int8_t)0)) && (((int8_t)(si2))<((int8_t)0)) && (((int8_t)(si1)) < ((INT8_MIN)-((int8_t)(si2)))))) \
+                 ? ((int8_t)(si1)) \
+                 : (((int8_t)(si1)) + ((int8_t)(si2))) \
+                 ) 
+
+static int8_t
+safe_add_func_int8_t_s_s(int8_t _si1, int8_t _si2)
+{
+  return safe_add_macro_int8_t_s_s(_si1,_si2);
+}
+
+#define safe_rshift_macro_uint64_t_u_s(left,right) \
+        (((((int)(right)) < ((uint64_t)0)) \
+                         || (((int)(right)) >= sizeof(uint64_t)*CHAR_BIT)) \
+                        ? ((uint64_t)(left)) \
+                        : (((uint64_t)(left)) >> ((int)(right))))
+
+static uint64_t
+safe_rshift_func_uint64_t_u_s(uint64_t _left, int _right)
+{
+  return safe_rshift_macro_uint64_t_u_s(_left,_right);
+}
+
+#define safe_mul_macro_int32_t_s_s(si1,si2) \
+  ((((((int32_t)(si1)) > ((int32_t)0)) && (((int32_t)(si2)) > ((int32_t)0)) && (((int32_t)(si1)) > ((INT32_MAX) / ((int32_t)(si2))))) || \
+  ((((int32_t)(si1)) > ((int32_t)0)) && (((int32_t)(si2)) <= ((int32_t)0)) && (((int32_t)(si2)) < ((INT32_MIN) / ((int32_t)(si1))))) || \
+  ((((int32_t)(si1)) <= ((int32_t)0)) && (((int32_t)(si2)) > ((int32_t)0)) && (((int32_t)(si1)) < ((INT32_MIN) / ((int32_t)(si2))))) || \
+  ((((int32_t)(si1)) <= ((int32_t)0)) && (((int32_t)(si2)) <= ((int32_t)0)) && (((int32_t)(si1)) != ((int32_t)0)) && (((int32_t)(si2)) < ((INT32_MAX) / ((int32_t)(si1)))))) \
+  ? ((int32_t)(si1)) \
+  : ((int32_t)(si1)) * ((int32_t)(si2)))
+
+static int32_t
+safe_mul_func_int32_t_s_s (int32_t _si1, int32_t _si2)
+{
+  return safe_mul_macro_int32_t_s_s(_si1,_si2);
+}
+
+static int8_t g_39;
+static volatile uint8_t g_46;
+static uint8_t g_47;
+static uint8_t *g_62;
+static uint8_t g_79;
+static int8_t g_101 = -1L;
+static uint8_t *g_114;
+static uint8_t *g_126;
+static uint8_t g_133;
+
+static uint16_t func_35 (int32_t * p_36, uint64_t p_37, uint32_t p_38);
+static uint16_t func_35 (int32_t * p_36, uint64_t p_37, uint32_t p_38)
+{
+  if (g_62 != 0)
+    abort ();
+  for (g_39 = 1; g_39 < 0; g_39 = 1)
+    {
+    }
+  return 1;
+}
+
+static int32_t func_19 (int32_t p_20);
+static int32_t func_19 (int32_t p_20)
+{
+  if (1 !=
+      safe_div_func_uint64_t_u_u ((safe_div_func_int64_t_s_s (p_20, 1)),
+                                  g_101))
+    {
+      func_35 (0, 1 <= (safe_add_func_int8_t_s_s (g_47, g_46)) > p_20 < 1, 1);
+      g_133 = 1;
+      if (g_114 != 0)
+	abort ();
+      if (g_126 != 0)
+	abort ();
+    }
+  return 1;
+}
+
+static uint8_t func_2 (int32_t p_6);
+static uint8_t func_2 (int32_t p_6)
+{
+  for (1; p_6 > 1; 1)
+    return 0;
+  func_19 (g_79);
+  if (safe_mul_func_int32_t_s_s
+      ((0, 1 < (safe_rshift_func_uint64_t_u_s (1 ^ p_6, 1))),
+       (func_35 (&p_6, 1, 1) < 1)))
+    {
+    }
+  return 1;
+}
+
+int main (void)
+{
+  func_2 (1);
+  if (g_133 != 1)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr42667.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr42667.c
new file mode 100644
index 000000000..eac80014b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pr42667.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+extern int strlen(const char *);
+void WriteTextDots(int len);
+
+void OnDisplay(char * string)
+{
+  if (!string)
+    string = "(none)";
+  WriteTextDots(strlen(string));
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pta-ptrarith-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pta-ptrarith-1.c
new file mode 100644
index 000000000..2a8dc9e30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pta-ptrarith-1.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-fdump-tree-alias" } */
+/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */
+
+struct Foo {
+  int *p;
+};
+
+void __attribute__((noinline))
+foo (void *p)
+{
+  struct Foo *f = (struct Foo *)p - 1;
+  *f->p = 0;
+}
+
+int bar (void)
+{
+  struct Foo f;
+  int i = 1;
+  f.p = &i;
+  foo (&f + 1);
+  return i;
+}
+extern void abort (void);
+int main()
+{
+  if (bar () != 0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "ESCAPED = { ESCAPED NONLOCAL f .* i }" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pta-ptrarith-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pta-ptrarith-2.c
new file mode 100644
index 000000000..fb5b2e15e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/pta-ptrarith-2.c
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fdump-tree-alias" } */
+/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */
+
+struct Foo {
+  int **p;
+  int **q;
+};
+
+int __attribute__((noinline))
+bar (void)
+{
+  struct Foo f;
+  int j, i = 1;
+  char *p;
+  int *x = &i;
+  int *y = &j;
+  f.p = &y;
+  f.q = &x;
+  p = (char *)&f;
+  for (j = 0; j < sizeof (int *); ++j)
+    p++;
+  return ***(int ***)p;
+}
+extern void abort (void);
+int main()
+{
+  if (bar () != 1)
+    abort ();
+  return 0;
+}
+
+/* In theory = { i } is the correct solution.  But it's not easy to scan
+   for that reliably, so just use what we create now.  */
+/* { dg-final { scan-tree-dump "= { i j }" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/reassoc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/reassoc-1.c
new file mode 100644
index 000000000..f0c9014cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/reassoc-1.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+
+int x;
+
+int __attribute__((noinline))
+foo(int a, int b, int w)
+{
+  int tmp1 = a * w;
+  int tmp2 = b * w;
+  x = tmp1;
+  return tmp1 + tmp2;
+}
+
+extern void abort (void);
+
+int main()
+{
+  if (foo(1, 2, 3) != 9)
+    abort ();
+  if (x != 3)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c
new file mode 100644
index 000000000..1370f63c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-1.c
@@ -0,0 +1,44 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c
new file mode 100644
index 000000000..b52dcf065
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-2.c
@@ -0,0 +1,56 @@
+/* PR middle-end/37009 */
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-msse2" } */
+
+#include <emmintrin.h>
+#include "cpuid.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 };
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    foo (x, x, x, 5);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c
new file mode 100644
index 000000000..47f3607c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-3.c
@@ -0,0 +1,56 @@
+/* PR middle-end/37009 */
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-msse2" } */
+
+#include <emmintrin.h>
+#include "cpuid.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 };
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    foo (x, x, x, x, 5);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/alloca-4.c
new file mode 100644
index 000000000..0ff0d02c4
--- /dev/null
+++ b/gcc-4.4.3/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 "-m32 -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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-1.c
new file mode 100644
index 000000000..38b384e7c
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
new file mode 100644
index 000000000..a1ba20fce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-2.c
@@ -0,0 +1,30 @@
+/* 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 } */
+   
+
+#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-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-3.c
new file mode 100644
index 000000000..1335d0902
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c
new file mode 100644
index 000000000..8b0ff4aff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-apply-4.c
@@ -0,0 +1,30 @@
+/* PR tree-optimization/20076 */
+/* { dg-do run } */
+/* { dg-xfail-run-if "b/2070963" { { i?86-*-* x86_64-*-* } && { ilp32 } } { "*" } { "" } } */
+
+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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/builtin-return-1.c
new file mode 100644
index 000000000..75c9acdf7
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/check.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/check.h
new file mode 100644
index 000000000..af1988512
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/comp-goto-1.c
new file mode 100644
index 000000000..7558f01e2
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/fastcall-1.c
new file mode 100644
index 000000000..d1cda1010
--- /dev/null
+++ b/gcc-4.4.3/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-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c
new file mode 100644
index 000000000..284daad0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/global-1.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c
new file mode 100644
index 000000000..11e71c60a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/inline-1.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c
new file mode 100644
index 000000000..fd51b5f71
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/inline-2.c
@@ -0,0 +1,45 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c
new file mode 100644
index 000000000..4e2c8729a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-1.c
@@ -0,0 +1,44 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c
new file mode 100644
index 000000000..d54e3b92c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-2.c
@@ -0,0 +1,45 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c
new file mode 100644
index 000000000..373299185
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-3.c
@@ -0,0 +1,62 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c
new file mode 100644
index 000000000..60322fc62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-4.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-5.c
new file mode 100644
index 000000000..95eba0482
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/nested-6.c
new file mode 100644
index 000000000..d853825fe
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-1.c
new file mode 100644
index 000000000..263d4486c
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-2.c
new file mode 100644
index 000000000..5a64d5419
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-3.c
new file mode 100644
index 000000000..3afc8cc6a
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-4.c
new file mode 100644
index 000000000..3673f1ac3
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c
new file mode 100644
index 000000000..08ca95d76
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/non-local-goto-5.c
@@ -0,0 +1,11 @@
+/* { dg-do run } */
+
+#if !defined (NO_LABEL_VALUES) && !defined (NO_TRAMPOLINES)
+extern void abort (void);
+extern void exit (int);
+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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c
new file mode 100644
index 000000000..1bff181c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-1.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-2.c
new file mode 100644
index 000000000..9a039eb2b
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/pr16660-3.c
new file mode 100644
index 000000000..1c1ddd1dd
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c
new file mode 100644
index 000000000..7417324e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/push-1.c
@@ -0,0 +1,59 @@
+/* PR middle-end/37010 */
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-msse2 -mpreferred-stack-boundary=2" } */
+
+#include <emmintrin.h>
+#include "cpuid.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 };
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    {
+      foo (x, x, x, x, 5);
+
+      if (__builtin_memcmp (&r, &x, sizeof (r)))
+	abort ();
+    }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/regparm-1.c
new file mode 100644
index 000000000..9dac024cc
--- /dev/null
+++ b/gcc-4.4.3/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-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c
new file mode 100644
index 000000000..163e54c59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/ret-struct-1.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-1.c
new file mode 100644
index 000000000..6ab67e395
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c
new file mode 100644
index 000000000..c93ffa867
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-2.c
@@ -0,0 +1,46 @@
+/* { dg-do run { target i?86-*-linux* 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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-3.c
new file mode 100644
index 000000000..fee0d281f
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/setjmp-4.c
new file mode 100644
index 000000000..d1671223a
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/sibcall-1.c
new file mode 100644
index 000000000..8c174758f
--- /dev/null
+++ b/gcc-4.4.3/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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp
new file mode 100644
index 000000000..3574e4dc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/stackalign.exp
@@ -0,0 +1,52 @@
+# 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
+# <http://www.gnu.org/licenses/>.
+
+# This harness is for tests that should be run at all optimisation levels.
+
+load_lib gcc-dg.exp
+
+# Only run on targets which support automatic stack alignment.
+if { ![check_effective_target_automatic_stack_alignment] } then {
+    return
+}
+
+set additional_flags ""
+if { [istarget i?86*-*-*] || [istarget x86_64-*-*] } then {
+    lappend additional_flags "-mstackrealign"
+    lappend additional_flags "-mpreferred-stack-boundary=5"
+}
+
+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 { [istarget i?86*-*-*] || [istarget x86_64-*-*] } 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-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c
new file mode 100644
index 000000000..79e373348
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/struct-1.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c
new file mode 100644
index 000000000..62b236522
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-1.c
@@ -0,0 +1,59 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c
new file mode 100644
index 000000000..00b723b0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-2.c
@@ -0,0 +1,65 @@
+/* { dg-do run } */
+
+#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.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c
new file mode 100644
index 000000000..cac206499
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/stackalign/vararg-3.c
@@ -0,0 +1,84 @@
+/* PR middle-end/37009 */
+/* { dg-do run { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+/* { dg-options "-msse2" } */
+
+#include <stdarg.h>
+#include <emmintrin.h>
+#include "cpuid.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 };
+  unsigned int eax, ebx, ecx, edx;
+ 
+  if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx))
+    return 0;
+
+  /* Run SSE2 test only if host has SSE2 support.  */
+  if (edx & bit_SSE2)
+    foo ("foo", 5, 5.0, x);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/tree-loop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/tree-loop-1.c
new file mode 100644
index 000000000..1d3869178
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/tree-loop-1.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/20640 */
+
+/* After unrolling the loop, we'd turn some conditional branches into
+   unconditional ones, but branch redirection would fail to compute
+   the PHI args for the PHI nodes in the replacement edge
+   destination, so they'd remain NULL causing crashes later on.  */
+
+/* { dg-do compile } */
+
+static int a = 0;
+extern int foo (void);
+extern int *bar (void) __attribute__ ((__const__));
+
+void
+test (int x)
+{
+  int b = 10;
+  while (foo () == -1 && *bar () == 4 && b > 0)
+    --b;
+  a = x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/type-generic-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/type-generic-1.c
new file mode 100644
index 000000000..96b5d01e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/torture/type-generic-1.c
@@ -0,0 +1,13 @@
+/* Do the type-generic tests.  Unlike pr28796-2.c, we test these
+   without any fast-math flags.  */
+
+/* { dg-do run } */
+/* { dg-options "-mieee" { target alpha*-*-* sh*-*-* } } */
+/* { dg-skip-if "No Inf/NaN support" { spu-*-* } } */
+
+#include "../tg-tests.h"
+
+int main(void)
+{
+  return main_tests ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/trampoline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/trampoline-1.c
new file mode 100644
index 000000000..e3dcf573a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/trampoline-1.c
@@ -0,0 +1,52 @@
+/* PR target/12865 */
+/* Origin: Waldek Hebisch <hebisch@math.uni.wroc.pl> */
+
+/* { dg-do run } */
+/* { dg-require-effective-target trampolines } */
+/* { dg-options "-O2" } */
+
+/* This used to fail on various versions of Solaris 2 because the
+   trampoline couldn't be made executable.  */
+
+extern void abort(void);
+extern double fabs(double);
+
+void foo (void)
+{
+  const int correct[1100] = {1, 0, -2, 0, 1, 0, 1, -1, -10, -30, -67};
+  int i;
+
+  double x1 (void) {return 1; }
+  double x2 (void) {return -1;}
+  double x3 (void) {return -1;}
+  double x4 (void) {return 1; }
+  double x5 (void) {return 0; }
+
+  typedef double pfun(void);
+
+  double a (int k, pfun x1, pfun x2, pfun x3, pfun x4, pfun x5)
+  {
+    double b (void)
+    {
+      k = k - 1;
+      return a (k, b, x1, x2, x3, x4 );
+    }
+
+    if (k <= 0)
+      return x4 () + x5 ();
+    else
+      return b ();
+  }
+
+  for (i=0; i<=10; i++)
+  {
+    if (fabs(a( i, x1, x2, x3, x4, x5 ) - correct [i]) > 0.1)
+      abort();
+  }
+}
+
+int main (void)
+{
+  foo ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-1.c
new file mode 100644
index 000000000..2360912e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-1.c
@@ -0,0 +1,85 @@
+/* PR c/20043 */
+/* { dg-compile } */
+/* { dg-options "-std=gnu99" } */
+
+extern void f0 (int *);
+extern void f0 (int *__restrict);
+
+extern void f1 (int *__restrict);
+extern void f1 (int *);
+
+typedef union { int *i; long *l; } U2
+  __attribute__((transparent_union));
+extern void f2 (U2);
+extern void f2 (int *);
+
+typedef union { int *__restrict i; long *__restrict l; } U3
+  __attribute__((transparent_union));
+extern void f3 (U3);
+extern void f3 (int *__restrict);
+
+extern void f4 (U3);
+extern void f4 (int *);
+
+extern void f5 (U2);
+extern void f5 (int *__restrict);
+
+typedef union { long *l; int *i; } U6
+  __attribute__((transparent_union));
+extern void f6 (U6);
+extern void f6 (int *);
+
+typedef union { long *__restrict l; int *__restrict i; } U7
+  __attribute__((transparent_union));
+extern void f7 (U7);
+extern void f7 (int *__restrict);
+
+extern void f8 (U7);
+extern void f8 (int *);
+
+extern void f9 (U6);
+extern void f9 (int *__restrict);
+
+extern void f10 (U2);
+extern void f11 (U3);
+extern void f12 (U6);
+extern void f13 (U7);
+
+int i;
+long l;
+
+int
+main (void)
+{
+  f0 (&i);
+  f0 (&l);	/* { dg-warning "passing argument 1 of 'f0' from incompatible pointer type" } */
+  f1 (&i);
+  f1 (&l);	/* { dg-warning "passing argument 1 of 'f1' from incompatible pointer type" } */
+  f2 (&i);
+  f2 (&l);	/* { dg-warning "passing argument 1 of 'f2' from incompatible pointer type" } */
+  f3 (&i);
+  f3 (&l);	/* { dg-warning "passing argument 1 of 'f3' from incompatible pointer type" } */
+  f4 (&i);
+  f4 (&l);	/* { dg-warning "passing argument 1 of 'f4' from incompatible pointer type" } */
+  f5 (&i);
+  f5 (&l);	/* { dg-warning "passing argument 1 of 'f5' from incompatible pointer type" } */
+  f6 (&i);
+  f6 (&l);	/* { dg-warning "passing argument 1 of 'f6' from incompatible pointer type" } */
+  f7 (&i);
+  f7 (&l);	/* { dg-warning "passing argument 1 of 'f7' from incompatible pointer type" } */
+  f8 (&i);
+  f8 (&l);	/* { dg-warning "passing argument 1 of 'f8' from incompatible pointer type" } */
+  f9 (&i);
+  f9 (&l);	/* { dg-warning "passing argument 1 of 'f9' from incompatible pointer type" } */
+  f10 (&i);
+  f10 (&l);
+  f11 (&i);
+  f11 (&l);
+  f12 (&i);
+  f12 (&l);
+  f13 (&i);
+  f13 (&l);
+  return 0;
+}
+
+/* { dg-message "note: expected '\[^\n'\]*' but argument is of type '\[^\n'\]*'" "note: expected" { target *-*-* } 0 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-2.c
new file mode 100644
index 000000000..09fbb4d97
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-2.c
@@ -0,0 +1,18 @@
+/* PR c/20043 */
+/* { dg-compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef union { int *i; long *l; } U
+  __attribute__((transparent_union));
+
+extern void f0 (U);		/* { dg-message "note: previous declaration" } */
+extern void f0 (void *);	/* { dg-error "conflicting types" } */
+
+extern void f1 (U);		/* { dg-message "note: previous declaration" } */
+extern void f1 (unsigned long);	/* { dg-error "conflicting types" } */
+
+extern void f2 (void *);	/* { dg-message "note: previous declaration" } */
+extern void f2 (U);		/* { dg-error "conflicting types" } */
+
+extern void f3 (unsigned long);	/* { dg-message "note: previous declaration" } */
+extern void f3 (U);		/* { dg-error "conflicting types" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-3.c
new file mode 100644
index 000000000..25d186956
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-3.c
@@ -0,0 +1,22 @@
+/* Test for ICEs on invalid transparent unions (empty or no named
+   members).  Bug 21213.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+enum e { A };
+
+union __attribute__((__transparent_union__)) ue1 { enum e; }; /* { dg-warning "declaration does not declare anything" } */
+/* { dg-warning "union cannot be made transparent" "" { target *-*-* } 9 } */
+union ue2 { enum e; } __attribute__((__transparent_union__)); /* { dg-warning "declaration does not declare anything" } */
+/* { dg-warning "union cannot be made transparent" "" { target *-*-* } 11 } */
+
+union __attribute__((__transparent_union__)) ui1 { int; }; /* { dg-warning "declaration does not declare anything" } */
+/* { dg-warning "union cannot be made transparent" "" { target *-*-* } 14 } */
+union ui2 { int; } __attribute__((__transparent_union__)); /* { dg-warning "declaration does not declare anything" } */
+/* { dg-warning "union cannot be made transparent" "" { target *-*-* } 16 } */
+
+union __attribute__((__transparent_union__)) u1 { };
+/* { dg-warning "union cannot be made transparent" "" { target *-*-* } 19 } */
+union u2 { } __attribute__((__transparent_union__));
+/* { dg-warning "union cannot be made transparent" "" { target *-*-* } 21 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-4.c
new file mode 100644
index 000000000..f661cf2cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-4.c
@@ -0,0 +1,9 @@
+/* Test for ICE on transparent union with function pointer and
+   -pedantic.  Bug 22240.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-pedantic" } */
+
+typedef union { union w *u; int *i; } H __attribute__ ((transparent_union));
+void (*h) (H);
+void g (int *s) { h (s); } /* { dg-warning "ISO C prohibits argument conversion to union type" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-5.c
new file mode 100644
index 000000000..47e245e24
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/transparent-union-5.c
@@ -0,0 +1,37 @@
+/* PR 24255 */
+/* { dg-do run } */
+/* { dg-options "-O" } */
+
+extern void abort (void);
+
+union wait { int w_status; };
+
+typedef union
+{
+  union wait *uptr;
+  int *iptr;
+} WAIT_STATUS __attribute__ ((__transparent_union__));
+
+int status;
+union wait wstatus;
+
+void __attribute__((noinline))
+test1 (WAIT_STATUS s)
+{
+  if (s.iptr != &status)
+    abort ();
+}
+
+void __attribute__((noinline))
+test2 (WAIT_STATUS s)
+{
+  if (s.uptr != &wstatus)
+    abort ();
+}
+
+int main()
+{
+  test1 (&status);
+  test2 (&wstatus);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/bb-reorg.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/bb-reorg.c
new file mode 100644
index 000000000..4d17ee222
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/bb-reorg.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target ilp32 } */
+/* { dg-require-effective-target freorder } */
+/* { dg-options "-O2 -freorder-blocks-and-partition" } */
+
+#include <string.h>
+
+#define SIZE 1000
+int t0 = 0;
+const char *t2[SIZE];
+char buf[SIZE];
+
+void
+foo (void)
+{
+  char *s = buf;
+  t0 = 1;
+
+  for (;;)
+    {
+      if (*s == '\0')
+	break;
+      else
+	{
+	  t2[t0] = s;
+	  t0++;
+	}
+      *s++ = '\0';
+    }
+  t2[t0] = NULL;
+}
+
+
+int
+main ()
+{
+  strcpy (buf, "hello");
+  foo ();
+  return 0; 
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/ic-misattribution-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/ic-misattribution-1.c
new file mode 100644
index 000000000..c36dd8dd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/ic-misattribution-1.c
@@ -0,0 +1,19 @@
+/* { dg-options "-O2 -fdump-tree-tree_profile" } */
+/* { dg-additional-sources "ic-misattribution-1a.c" } */
+
+extern void other_caller (void);
+
+void
+callee (void)
+{
+  return;
+}
+
+void
+caller(void (*func) (void))
+{
+  func ();
+}
+
+/* { dg-final-use { scan-tree-dump "hist->count 1 hist->all 1" "tree_profile" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/ic-misattribution-1a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/ic-misattribution-1a.c
new file mode 100644
index 000000000..2139972ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/ic-misattribution-1a.c
@@ -0,0 +1,22 @@
+/* { dg-options "-DEMPTY" } */
+/* This file is only needed in combination with ic-misattribution-1.c
+   but there's no easy way to make this file ignored. */
+extern void callee (void);
+extern void caller (void (*func) (void));
+
+typedef void (*func_t) (void);
+func_t func;
+
+int
+main ()
+{
+#ifdef EMPTY
+#else
+  func = callee;
+  caller (callee);
+  func ();
+#endif
+  return 0;
+}
+
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/indir-call-prof.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/indir-call-prof.c
new file mode 100644
index 000000000..101b9725f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/indir-call-prof.c
@@ -0,0 +1,45 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+
+static int a1 (void)
+{
+    return 10;
+}
+
+static int a2 (void)
+{
+    return 0;
+}
+
+typedef int (*tp) (void);
+
+static tp aa [] = {a2, a1, a1, a1, a1};
+
+void setp (int (**pp) (void), int i)
+{
+  if (!i)
+    *pp = aa [i];
+  else
+    *pp = aa [(i & 2) + 1];
+}
+
+int
+main (void)
+{
+  int (*p) (void);
+  int  i;
+
+  for (i = 0; i < 10; i ++)
+    {
+	setp (&p, i);
+	p ();
+    }
+  
+  return 0;
+}
+
+/* { dg-final-use { scan-tree-dump "Indirect call -> direct call.* a1 transformation on insn" "tree_profile"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */                                                                                
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */                                                                                              
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
+                                                                                           
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/inliner-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/inliner-1.c
new file mode 100644
index 000000000..8d7c87919
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/inliner-1.c
@@ -0,0 +1,38 @@
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int a;
+int b[100];
+void abort (void);
+
+inline void
+cold_function ()
+{
+  int i;
+  for (i = 0; i < 99; i++)
+    if (b[i] / (b[i+1] + 1))
+      abort ();
+}
+
+inline void
+hot_function ()
+{
+  int i;
+  for (i = 0; i < 99; i++)
+    if (b[i] / (b[i+1] + 1))
+      abort ();
+}
+
+main ()
+{
+  if (a)
+    cold_function ();
+  else
+    hot_function ();
+  return 0;
+}
+
+/* cold function should be inlined, while hot function should not.  
+   Look for "cold_function () [tail call];" call statement not for the
+   declaration or other apperances of the string in dump.  */
+/* { dg-final-use { scan-tree-dump "cold_function ..;" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "hot_function ..;" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr26570.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr26570.c
new file mode 100644
index 000000000..5dd78e3d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr26570.c
@@ -0,0 +1,13 @@
+/* { dg-options "-O2" } */
+
+unsigned test (unsigned a, unsigned b)
+{
+  return a / b;
+}
+
+int main()
+{
+  return test (6, 3) - 2;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr32773.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr32773.c
new file mode 100644
index 000000000..24ed96030
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr32773.c
@@ -0,0 +1,17 @@
+/* { dg-options "-O" } */
+/* { dg-options "-O -m4" { target sh-*-* } } */
+
+void foo (int *p)
+{
+  if (p)
+    *p = 0;
+}
+
+int main()
+{
+  int x;
+  foo (&x);
+  return 0;
+}
+
+/* { dg-final { cleanup-coverage-files } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr34999.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr34999.c
new file mode 100644
index 000000000..9f513b024
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/pr34999.c
@@ -0,0 +1,46 @@
+/* Same test as built-in-setjmp.c.  Includes the case where
+   the source block of a crossing fallthru edge ends with a call.  */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-require-effective-target freorder } */
+/* { dg-options "-O2 -freorder-blocks-and-partition" } */
+
+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 = (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.4.3/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c
new file mode 100644
index 000000000..e7c8c66da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/prof-robust-1.c
@@ -0,0 +1,21 @@
+/* { dg-options "-O2 -w" } */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef _PROFILE_USE
+int foo(int x) {
+  return 3 * x;
+}
+#endif
+
+int x = 1000;
+
+int main(int argc, char *argv[]) {
+  int i;
+  int sum = 0;
+  for (i = 0; i < x; i++)
+    sum += i;
+  printf("%d\n", sum);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/stringop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/stringop-1.c
new file mode 100644
index 000000000..b57715efc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/stringop-1.c
@@ -0,0 +1,21 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+int a[1000];
+int b[1000];
+int size=1;
+int max=10000;
+main()
+{
+  int i;
+  for (i=0;i<max; i++)
+    {
+      __builtin_memcpy (a, b, size * sizeof (a[0]));
+      asm("");
+    }
+   return 0;
+}
+/* { dg-final-use { scan-tree-dump "Single value 4 stringop" "tree_profile"} } */
+/* Really this ought to simplify into assignment, but we are not there yet.  */
+/* a[0] = b[0] is what we fold the resulting memcpy into.  */
+/* { dg-final-use { scan-tree-dump "a.0. = b.0." "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c
new file mode 100644
index 000000000..3e7bd542e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/stringop-2.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+int a[1000];
+int b[1000];
+int size=1;
+int max=10000;
+main()
+{
+  int i;
+  for (i=0;i<max; i++)
+    {
+      __builtin_memset (a, 10, size * sizeof (a[0]));
+      asm("");
+    }
+   return 0;
+}
+/* { dg-final-use { scan-tree-dump "Single value 4 stringop" "tree_profile"} } */
+/* Really this ought to simplify into assignment, but we are not there yet.  */
+/* { dg-final-use { scan-tree-dump "memset.*4\\)" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/tracer-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/tracer-1.c
new file mode 100644
index 000000000..7654a533c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/tracer-1.c
@@ -0,0 +1,18 @@
+/* { dg-options "-O2 -ftracer -fdump-tree-tracer" } */
+main ()
+{
+  int i;
+  int a, b, c;
+  for (i = 0; i < 1000; i++)
+    {
+      if (i % 17)
+	a++;
+      else
+	b++;
+      c++;
+    }
+  return 0;
+}
+/* Superblock formation should produce two copies of the increment of c */
+/* { dg-final-generate { scan-tree-dump-times "goto <bb 6>;" 2 "tracer" } } */
+/* { dg-final-use { cleanup-tree-dump "tracer" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/tree-prof.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/tree-prof.exp
new file mode 100644
index 000000000..9da5485b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/tree-prof.exp
@@ -0,0 +1,54 @@
+# Copyright (C) 2001, 2002, 2004, 2005, 2007, 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
+# <http://www.gnu.org/licenses/>.
+
+# Test the functionality of programs compiled with profile-directed block
+# ordering using -fprofile-generate followed by -fbranch-use.
+
+load_lib target-supports.exp
+
+# Some targets don't support tree profiling.
+if { ![check_profiling_available ""] } {
+    return
+}
+
+# The procedures in profopt.exp need these parameters.
+set tool gcc
+set prof_ext "gcda"
+
+# Override the list defined in profopt.exp.
+set PROFOPT_OPTIONS [list {}]
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+# Load support procs.
+load_lib profopt.exp
+
+# These are globals used by profopt-execute.  The first is options
+# needed to generate profile data, the second is options to use the
+# profile data.
+set profile_option "-fprofile-generate -D_PROFILE_GENERATE"
+set feedback_option "-fprofile-use -D_PROFILE_USE"
+
+foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.c]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $src] then {
+        continue
+    }
+    profopt-execute $src
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-cunroll-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-cunroll-2.c
new file mode 100644
index 000000000..d559b9245
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-cunroll-2.c
@@ -0,0 +1,21 @@
+
+/* { dg-options "-O2 -fdump-tree-optimized-blocks" } */
+int a[8];
+__attribute__ ((noinline))
+int t()
+{
+	int i;
+	for (i = 0; i < 3; i++)
+		if (a[i])
+			break;
+	return i;
+}
+main ()
+{
+  int i;
+  for (i = 0; i < 1000; i++)
+    t ();
+  return 0;
+}
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
new file mode 100644
index 000000000..b132e5ab7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-loopch.c
@@ -0,0 +1,21 @@
+/* { dg-options "-O2 -fdump-tree-tree_profile-blocks -fdump-tree-optimized-blocks" } */
+int max = 33333;
+int a[8];
+int
+main ()
+{
+  int i;
+  for (i = 0; i < max; i++)
+    {
+      a[i % 8]++;
+    }
+  return 0;
+}
+/* Loop header copying will peel away the initial conditional, so the loop body
+   is once reached directly from entry point of function, rest via loopback
+   edge.  */
+/* { dg-final-use { scan-tree-dump "count:33333" "tree_profile"} } */
+/* { dg-final-use { scan-tree-dump "count:33332" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-tailcall.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-tailcall.c
new file mode 100644
index 000000000..285491445
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/update-tailcall.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -fdump-tree-tailc -fdump-tree-optimized" } */
+__attribute__ ((noinline))
+int factorial(int x)
+{
+   if (x == 1)
+     return 1;
+   else
+     return x*factorial(--x);
+}
+int gbl;
+int
+main()
+{
+   gbl = factorial(100);
+   return 0;
+}
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "tailc"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "tailc" } } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-1.c
new file mode 100644
index 000000000..dfe994ffe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-1.c
@@ -0,0 +1,22 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+int a[1000];
+int b = 256;
+int c = 257;
+main ()
+{
+  int i;
+  int n;
+  for (i = 0; i < 1000; i++)
+    {
+      if (i % 17)
+	n = c;
+      else n = b;
+      a[i] /= n;
+    }
+  return 0;
+}
+/* { dg-final-use { scan-tree-dump "Div.mod by constant n=257 transformation on insn" "tree_profile"} } */
+/* { dg-final-use { scan-tree-dump "if \\(n != 257\\)" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-2.c
new file mode 100644
index 000000000..66b0614c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-2.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+unsigned int a[1000];
+unsigned int b = 256;
+unsigned int c = 1024;
+unsigned int d = 17;
+main ()
+{
+  int i;
+  unsigned int n;
+  for (i = 0; i < 1000; i++)
+    {
+	    a[i]=100*i;
+    }
+  for (i = 0; i < 1000; i++)
+    {
+      if (i % 2)
+	n = b;
+      else if (i % 3)
+	n = c;
+      else
+	n = d;
+      a[i] %= n;
+    }
+  return 0;
+}
+/* { dg-final-use { scan-tree-dump "Mod power of 2 transformation on insn" "tree_profile"} } */
+/* This is part of code checking that n is power of 2, so we are sure that the transformation
+   didn't get optimized out.  */
+/* { dg-final-use { scan-tree-dump "n \\+ 0xffff" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-3.c
new file mode 100644
index 000000000..f233d670c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-3.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+unsigned int a[1000];
+unsigned int b = 257;
+unsigned int c = 1023;
+unsigned int d = 19;
+main ()
+{
+  int i;
+  unsigned int n;
+  for (i = 0; i < 1000; i++)
+    {
+	    a[i]=18;
+    }
+  for (i = 0; i < 1000; i++)
+    {
+      if (i % 2)
+	n = b;
+      else if (i % 3)
+	n = c;
+      else
+	n = d;
+      a[i] %= n;
+    }
+  return 0;
+}
+/* { dg-final-use { scan-tree-dump "Mod subtract transformation on insn" "tree_profile"} } */
+/* This is part of code checking that n is greater than the divisor so we are sure that it
+   didn't get optimized out.  */
+/* { dg-final-use { scan-tree-dump "if \\(n \\>" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-4.c
new file mode 100644
index 000000000..86418e05e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-4.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+unsigned int a[1000];
+unsigned int b = 999;
+unsigned int c = 1002;
+unsigned int d = 1003;
+main ()
+{
+  int i;
+  unsigned int n;
+  for (i = 0; i < 1000; i++)
+    {
+	    a[i]=1000+i;
+    }
+  for (i = 0; i < 1000; i++)
+    {
+      if (i % 2)
+	n = b;
+      else if (i % 3)
+	n = c;
+      else
+	n = d;
+      a[i] %= n;
+    }
+  return 0;
+}
+/* { dg-final-use { scan-tree-dump "Mod subtract transformation on insn" "tree_profile"} } */
+/* This is part of code checking that n is greater than the divisor so we are sure that it
+   didn't get optimized out.  */
+/* { dg-final-use { scan-tree-dump "if \\(n \\>" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-5.c
new file mode 100644
index 000000000..095fb06b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-5.c
@@ -0,0 +1,17 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-tree_profile" } */
+int a[1000];
+int b=997;
+main()
+{
+	int i;
+	for (i = 0; i < 1000; i++)
+		if (a[i])
+			a[i]/=b;
+		else
+			a[i]/=b;
+	return 0;
+}
+/* { dg-final-use { scan-tree-dump "Div.mod by constant b.*=997 transformation on insn" "tree_profile"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-6.c
new file mode 100644
index 000000000..c439fcffe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-6.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+char a[1000];
+char b[1000];
+int size=1000;
+__attribute__ ((noinline))
+t(int size)
+{
+  __builtin_memcpy(a,b,size);
+}
+int
+main()
+{
+  int i;
+  for (i=0; i < size; i++)
+    t(i);
+  return 0;
+}
+/* { dg-final-use { scan-tree-dump "Average value sum:499500" "optimized"} } */
+/* { dg-final-use { scan-tree-dump "IOR value" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-7.c
new file mode 100644
index 000000000..bb79c19d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/val-prof-7.c
@@ -0,0 +1,26 @@
+/* { dg-options "-O2 -fdump-tree-tree_profile -mtune=core2" } */
+/* { dg-skip-if "" { ! { i?86-*-* x86_64-*-* } } { "*" } { "" } } */
+
+#include <strings.h>
+
+int foo(int len)
+{
+  char array[1000];
+  bzero(array, len);
+  return 0;
+}
+
+int main() {
+  int i;
+  for (i = 0; i < 1000; i++)
+    {
+      if (i > 990)
+	foo(16);
+      else
+	foo(8);
+    }
+  return 0;
+}
+
+/* { dg-final-use { scan-tree-dump "Single value 8 stringop transformation on bzero" "tree_profile"} } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/wcoverage-mismatch.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/wcoverage-mismatch.c
new file mode 100644
index 000000000..e4231057f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-prof/wcoverage-mismatch.c
@@ -0,0 +1,20 @@
+/* { dg-options "-O2 -Wno-coverage-mismatch" } */
+
+int __attribute__((noinline)) bar (void)
+{
+}
+
+int foo (int i)
+{
+#ifdef _PROFILE_USE
+  if (i)
+    bar ();
+#endif
+  return 0;
+}
+
+int main(int argc, char **argv)
+{
+  foo (argc);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030530-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030530-2.c
new file mode 100644
index 000000000..3d4ba4f91
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030530-2.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+ 
+
+typedef struct rs6000_stack {
+  int first_gp_reg_save;
+} rs6000_stack_t;
+extern char regs_ever_live[113];
+extern rs6000_stack_t *rs6000_stack_info (void);
+void
+rs6000_emit_prologue (int i, rs6000_stack_t *info)
+{
+  if (regs_ever_live[info->first_gp_reg_save + i] || i+info->first_gp_reg_save)
+    gen_rtx_REG (info->first_gp_reg_save + i);
+}
+
+/* There should be precisely one load of first_gp_reg_save.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "first_gp_reg_save" 1 "dom2"} } */
+
+/* There should be precisely one addition.  If there is more than one, then
+   the dominator optimizations failed, most likely due to not handling
+   commutative operands correctly.  */
+/* { dg-final { scan-tree-dump-times "\\+" 1 "dom2"} } */
+ 
+/* { dg-final { cleanup-tree-dump "dom2" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030611-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030611-1.c
new file mode 100644
index 000000000..fac91be70
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030611-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+ 
+extern int square (int) __attribute__ ((__const__));
+shit(int a)
+{
+  return square (a) + square (a);
+
+}
+
+/* There should be precisely one call to square.   If there is more than one,
+   then the dominator optimizations failed to remove the redundant call.  */
+/* { dg-final { scan-tree-dump-times "square" 1 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030703-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030703-1.c
new file mode 100644
index 000000000..fa5992372
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030703-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+  
+extern void abort (void);
+extern int blah[];
+
+foo(int index)
+{
+  if (blah [(unsigned int)index] != 0)
+    abort ();
+  if (blah [(unsigned int)index] != 0)
+    abort ();
+}
+
+/* There should be precisely one load of blah.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "blah" 1 "dom2"} } */
+ 
+/* There should be exactly one IF conditional.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030703-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030703-2.c
new file mode 100644
index 000000000..4a64b90db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030703-2.c
@@ -0,0 +1,44 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+
+union tree_node;
+typedef union tree_node *tree;
+extern const char tree_code_type[];
+
+union tree_node
+{
+  int code;
+  long pointer_alias_set;
+};
+
+long
+get_alias_set (t)
+     tree t;
+{
+  if (tree_code_type[t->code])
+    abort ();
+  if (t->pointer_alias_set)
+    {
+      tree __t = t;
+      if (tree_code_type[__t->code])
+	abort ();
+    }
+}
+
+/* There should be precisely one load of {t,__t}->code.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "->code" 1 "dom2"} } */
+                                                                                
+/* There should be precisely one load of tree_code_type.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "tree_code_type" 1 "dom2"} } */
+
+/* There should be one IF conditional.  If 'tree_code_type[t->code]' is
+   zero, then the third if() conditional is unnecessary.  That should cause
+   the call to abort() to be removed, which in turn causes the whole second
+   if() to disappear.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030708-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030708-1.c
new file mode 100644
index 000000000..b3be8a939
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030708-1.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+extern void abort (void);
+struct rtx_def;
+typedef struct rtx_def *rtx;
+enum rtx_code
+{
+  CALL_INSN,
+  EXPR_LIST,
+  NOTE,
+  LAST = 256
+};
+
+struct rtx_def
+{
+
+  enum rtx_code code:16;
+};
+
+int
+nonlocal_mentioned_p (x)
+     rtx x;
+{
+  if (x->code == CALL_INSN)
+    {
+      rtx const _rtx = ((x));
+      if (_rtx->code != CALL_INSN
+	  && _rtx->code != NOTE
+	  && _rtx->code != EXPR_LIST)
+	abort ();
+    }
+
+  blah (&x);
+}
+
+/* There should be no casts to a short unsigned int since the entire
+   set of conditionals should optimize away.  */
+/* { dg-final { scan-tree-dump-times "\\(short unsigned int\\)" 0 "dom2"} } */
+                                                                                
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2"} } */
+                                                                                
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-1.c
new file mode 100644
index 000000000..686ca76a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+                                                                                
+static int copying_arguments;
+
+int
+foo ()
+{
+  unsigned int regno;
+  if (regno < 53 && copying_arguments)
+    if (regno >= 53)
+	return 1;
+}
+
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-2.c
new file mode 100644
index 000000000..f99598d73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-2.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-cddce2" } */
+  
+struct rtx_def;
+typedef struct rtx_def *rtx;
+union tree_node;
+typedef union tree_node *tree;
+typedef struct mem_attrs
+{
+  int  foo;
+
+} mem_attrs;
+union rtunion_def
+{
+  mem_attrs *rtmem;
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  rtunion fld[1];
+};
+struct tree_decl
+{
+  rtx rtl;
+};
+union tree_node
+{
+  struct tree_decl decl;
+};
+void *
+get_alias_set (t)
+     tree t;
+{
+  long set;
+  if (t->decl.rtl)
+    return (t->decl.rtl->fld[1].rtmem 
+	    ? 0
+	    : (((t->decl.rtl ? t->decl.rtl: (make_decl_rtl (t, 0), t->decl.rtl)))->fld[1]).rtmem);
+  return (void*)-1;
+}
+
+/* There should be precisely one load of ->decl.rtl.  If there is
+   more than, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "->decl\\.rtl" 1 "cddce2"} } */
+  
+/* There should be no loads of .rtmem since the complex return statement
+   is just "return 0".  */
+/* { dg-final { scan-tree-dump-times ".rtmem" 0 "cddce2"} } */
+  
+/* There should be one IF statement (the complex return statement should
+   collapse down to a simple return 0 without any conditionals).  */
+/* { dg-final { scan-tree-dump-times "if " 1 "cddce2"} } */
+
+/* { dg-final { cleanup-tree-dump "cddce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-3.c
new file mode 100644
index 000000000..4f9847852
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030709-3.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+  
+extern void abort (void);
+
+union tree_node;
+typedef union tree_node *tree;
+enum tree_code
+{
+  TREE_VEC = 20,
+};
+struct tree_common
+{
+  int code;
+};
+struct tree_type
+{
+  tree binfo;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_type type;
+};
+void
+record_component_aliases (type)
+     tree type;
+{
+  const tree __z = type->type.binfo;
+  if (type->type.binfo->common.code != TREE_VEC)
+    abort ();
+
+  if (__z->common.code != TREE_VEC)
+    abort ();
+}
+
+/* There should be precisely one load of type.binfo.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "type\\.binfo" 1 "dom2"} } */
+ 
+/* There should be precisely one load of common.code.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "common\\.code" 1 "dom2"} } */
+ 
+/* There should be one IF conditional.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c
new file mode 100644
index 000000000..c344d48e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+union tree_node;
+typedef union tree_node *tree;
+struct tree_vec
+{
+  int length;
+  tree a[1];
+};
+struct tree_type
+{
+  tree binfo;
+};
+union tree_node
+{
+  struct tree_type type;
+  struct tree_vec vec;
+};
+void
+record_component_aliases (type)
+     tree type;
+{
+  if (type->type.binfo->vec.length)
+    abort ();
+  for (; ((
+	    {
+	    const tree __z = type->type.binfo;
+	    if (type->type.binfo->vec.length)
+	    abort ();
+ type->type.binfo->vec.a[4];}
+	  )->vec.length);)
+    {
+      if (4 >= type->type.binfo->vec.length)
+	abort ();
+      blah ();
+    }
+}
+
+/* The call to blah should have been eliminated.  If the call is not
+   eliminated, then dominator optimizations failed and it'll be
+   impossible to delete other unnecessary code.  */
+/* { dg-final { scan-tree-dump-not "blah \\(\\)" "dom2" } } */
+  
+/* There should be two IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "dom2"} } */
+                                                                                
+/* There should be a single load of type.binfo.  */
+/* { dg-final { scan-tree-dump-times "type\\.binfo" 1 "dom2"} } */
+
+/* There should be two loads of vec.length.  */
+/* { dg-final { scan-tree-dump-times "vec.length" 2 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-1.c
new file mode 100644
index 000000000..1855580d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-1.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+ 
+extern void abort (void);
+
+union tree_node;
+typedef union tree_node *tree;
+struct tree_vec
+{
+          int length;
+            tree a[1];
+};
+struct tree_type
+{
+          tree binfo;
+};
+union tree_node
+{
+          struct tree_type type;
+            struct tree_vec vec;
+};
+
+void
+record_component_aliases (type)
+     tree type;
+{
+  int i;
+  if (4 >= type->type.binfo->vec.length)
+    abort ();
+  for (; i < ((
+                {
+                const tree __t = type->type.binfo;
+                if (4 >= __t->vec.length)
+                abort (); type->type.binfo->vec.a[4];}
+              )->vec.length);)
+    {
+      if (4 >= type->type.binfo->vec.length)
+        abort ();
+      blah ();
+    }
+}
+
+/* The call to blah can not be eliminated.  */
+/* { dg-final { scan-tree-dump-times "blah \\(\\)" 1 "dom2" } } */
+   
+/* There should be four IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 4 "dom2"} } */
+                                                                                
+/* There should be two loads of type.binfo.  */
+/* { dg-final { scan-tree-dump-times "type\\.binfo" 2 "dom2"} } */
+ 
+/* There should be four loads of vec.length.  */
+/* { dg-final { scan-tree-dump-times "vec.length" 4 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-2.c
new file mode 100644
index 000000000..44dd25355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-2.c
@@ -0,0 +1,69 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dom2" } */
+  
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtvec_def;
+typedef struct rtvec_def *rtvec;
+union tree_node;
+typedef union tree_node *tree;
+typedef struct mem_attrs
+{
+  long alias;
+}
+mem_attrs;
+union rtunion_def
+{
+  mem_attrs *rtmem;
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  int code;
+  rtunion fld[1];
+};
+struct tree_decl
+{
+  rtx rtl;
+};
+union tree_node
+{
+  struct tree_decl decl;
+};
+long
+get_alias_set (t,z)
+     tree t;
+     rtx z;
+{
+  if (t->decl.rtl && (((t->decl.rtl ? z
+                        : (make_decl_rtl (t, 0), t->decl.rtl)))->code))
+    return (((((t->decl.rtl ? z : (make_decl_rtl (t, 0), t->decl.rtl)))->
+              fld[1]).rtmem) == 0 ? 0 : (((((
+                                               {
+                                               t;}
+                                            )->decl.
+                                            rtl ? z : (make_decl_rtl (t, 0),
+                                                       t->decl.rtl)))->
+                                          fld[1]).rtmem)->alias);
+}
+
+/* The calls to make_decl_rtl should be eliminated
+/* { dg-final { scan-tree-dump-not "make_decl_rtl \\(\\)" "dom2" } } */
+    
+/* There should be three IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 3 "dom2"} } */
+                                                                                
+/* There should be one loads of decl.rtl.  */
+/* { dg-final { scan-tree-dump-times "decl\\.rtl" 1 "dom2"} } */
+  
+/* There should be one load of code.  */
+/* { dg-final { scan-tree-dump-times "code" 1 "dom2"} } */
+
+/* There should be one load of rtmem.  */
+/* { dg-final { scan-tree-dump-times "rtmem" 1 "dom2"} } */
+
+/* There should be one load of alias.  */
+/* { dg-final { scan-tree-dump-times "->alias" 1 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c
new file mode 100644
index 000000000..ec04e1754
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c
@@ -0,0 +1,61 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+  
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtvec_def;
+typedef struct rtvec_def *rtvec;
+union tree_node;
+typedef union tree_node *tree;
+typedef struct mem_attrs
+{
+  long alias;
+}
+mem_attrs;
+union rtunion_def
+{
+  mem_attrs *rtmem;
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  int code;
+  rtunion fld[1];
+};
+struct tree_decl
+{
+  rtx rtl;
+};
+union tree_node
+{
+  struct tree_decl decl;
+};
+long
+get_alias_set (t)
+     tree t;
+{
+  if (t->decl.rtl != (void *) 0)
+    return (((t->decl.rtl->fld[1]).rtmem) ==
+            0 ? 0
+            : ((((t->decl.
+                  rtl ? 0 : (make_decl_rtl (t, ((void *) 0)),
+                             t->decl.rtl)))->fld[1]).rtmem)->alias);
+}
+
+/* The calls to make_decl_rtl should be eliminated.  */
+/* { dg-final { scan-tree-dump-not "make_decl_rtl \\(\\)" "dom2" } } */
+    
+/* There should be two IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "dom2"} } */
+                                                                                
+/* There should be one load of decl.rtl.  */
+/* { dg-final { scan-tree-dump-times "decl\\.rtl" 1 "dom2"} } */
+  
+/* There should be two loads of rtmem.  */
+/* { dg-final { scan-tree-dump-times "rtmem" 2 "dom2"} } */
+
+/* There should be one load of alias.  */
+/* { dg-final { scan-tree-dump-times "->alias" 1 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030714-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030714-1.c
new file mode 100644
index 000000000..397036f25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030714-1.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+   
+struct rtx_def;
+typedef struct rtx_def *rtx;
+enum rtx_code
+{
+  REG,
+  LAST_AND_UNUSED_RTX_CODE = 256
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  enum rtx_code code:16;
+  unsigned frame_related:1;
+};
+
+rtx
+find_base_value (src)
+     rtx src;
+{
+  rtx temp;
+  rtx src_0, src_2;
+  rtx src_1, src_3;
+
+  if ((src_0->code == REG) && (({src_2;})->frame_related))
+    return find_base_value (src_0);
+  if ((src_1->code == REG) && (({ src_3;})->frame_related))
+    return find_base_value (src_1);
+  if (src_0->code == REG)
+    find_base_value (src_0);
+  if (src_1->code == REG)
+    find_base_value (src_1);
+}
+
+
+/* There should be no casts to short unsigned int.  */
+/* { dg-final { scan-tree-dump-times "\\(short unsigned int\\)" 0 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030714-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030714-2.c
new file mode 100644
index 000000000..cac648687
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030714-2.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+   
+
+union tree_node;
+typedef union tree_node *tree;
+extern const char tree_code_type[];
+struct tree_common
+{
+  int code;
+  tree type;
+};
+struct tree_exp
+{
+  tree operands[1];
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_exp exp;
+};
+long
+get_alias_set (t)
+     tree t;
+{
+  if (tree_code_type[t->common.code] != 't' && t->common.type == 0)
+    return 0;
+  if (tree_code_type[t->common.code] != 't')
+    {
+      while (t->exp.operands[0])
+        t = t->exp.operands[0];
+    }
+}
+
+/* There should be exactly three IF conditionals if we thread jumps
+   properly.  */
+/* { dg-final { scan-tree-dump-times "if " 3 "dom2"} } */
+ 
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030728-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030728-1.c
new file mode 100644
index 000000000..1ad2c6365
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030728-1.c
@@ -0,0 +1,47 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+    
+
+union tree_node;
+typedef union tree_node *tree;
+
+enum tree_code
+{
+  ARRAY_TYPE,
+  LAST_AND_UNUSED_TREE_CODE
+};
+
+struct tree_common
+{
+  enum tree_code code:8;
+};
+
+
+
+
+
+union tree_node
+{
+  struct tree_common common;
+};
+
+
+
+
+int
+objects_must_conflict_p (t1, t2)
+     tree t1, t2;
+{
+
+  if ((t1->common.code == ARRAY_TYPE) != (t2
+                                          && t2->common.code == ARRAY_TYPE))
+    return 11;
+
+
+  return foo (t2 ? get_alias_set (t2) : 0);
+}
+
+/* There should be two assignments of variables to the value zero.  */
+/* { dg-final { scan-tree-dump-times " = 0" 2 "final_cleanup"} } */
+ 
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030729-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030729-1.c
new file mode 100644
index 000000000..59b48397c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030729-1.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+union tree_node;
+typedef union tree_node *tree;
+
+
+enum tree_code
+{
+  SET_TYPE,
+  RECORD_TYPE,
+  LAST_AND_UNUSED_TREE_CODE
+};
+extern const char tree_code_type[];
+
+struct tree_common
+{
+
+  enum tree_code code:8;
+};
+
+
+
+
+
+union tree_node
+{
+  struct tree_common common;
+};
+
+readonly_fields_p (type)
+     tree type;
+{
+
+  if (type->common.code != RECORD_TYPE)
+    return;
+
+  if (tree_code_type[type->common.code] != 't')
+    abort ();
+
+  return;
+}
+
+/* A good optimizer would realize that the cast to (unsigned int) is
+   useless as the earlier cast of the same value of (unsigned char) will
+   always produce the same result.  */
+/* { dg-final { scan-tree-dump-times "\\(unsigned int\\)" 0 "dom2"} } */
+ 
+/* There should be one load of ->common.code.  We currently fail this
+   because we load from ->common.code using different types.  */
+/* { dg-final { scan-tree-dump-times "common\.code" 1 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030730-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030730-1.c
new file mode 100644
index 000000000..bb474ff4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030730-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dom2" } */
+     
+extern void exit (int);
+extern void *ggc_alloc (__SIZE_TYPE__);
+typedef struct dw_attr_struct *dw_attr_ref;
+typedef struct dw_attr_struct
+{
+  int dw_attr;
+}
+dw_attr_node;
+void
+foo (int attr_kind, unsigned long offset)
+{
+  dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
+  attr->dw_attr = attr_kind;
+  if (attr != 0)
+    exit (0);
+}
+
+/* There should be no IF conditionals, unless target has fno-delete-null-pointer-checks  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump "if " "dom2" { target { keeps_null_pointer_checks } } } } */
+     
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030730-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030730-2.c
new file mode 100644
index 000000000..1768d4523
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030730-2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dom2" } */
+     
+extern void exit (int);
+extern void *ggc_alloc (__SIZE_TYPE__);
+typedef struct dw_attr_struct *dw_attr_ref;
+typedef struct dw_attr_struct
+{
+  int dw_attr;
+}
+dw_attr_node;
+void
+foo (int attr_kind, unsigned long offset)
+{
+  dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
+  attr->dw_attr = attr_kind;
+  if (attr != ((void *)0))
+    exit (0);
+}
+
+/* There should be no IF conditionals, unless target has fno-delete-null-pointer-checks  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump "if " "dom2" { target { keeps_null_pointer_checks } } } } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030731-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030731-1.c
new file mode 100644
index 000000000..a16f49dbb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030731-1.c
@@ -0,0 +1,67 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+  
+extern void abort (void);
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtvec_def;
+typedef struct rtvec_def *rtvec;
+union tree_node;
+typedef union tree_node *tree;
+struct rtx_def
+{
+  int code;
+  int mode;
+  unsigned int in_struct:1;
+};
+struct tree_common
+{
+  int code;
+};
+struct tree_decl
+{
+  rtx rtl;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_decl decl;
+};
+rtx
+store_expr (exp, target, want_value)
+     tree exp;
+     rtx target;
+     int want_value;
+{
+  if (exp->common.code == 42)
+    abort ();
+  else if (queued_subexp_p (target))
+    {
+      blah (target->mode);
+      if (target->code)
+        abort ();
+    }
+  else
+    {
+      if (target->code && (__extension__({target;})->in_struct));
+    }
+
+  if ((target != (exp->decl.rtl
+		  ? (exp->decl.rtl
+		     ? exp->decl.rtl
+		     : (make_decl_rtl (exp, 0), exp->decl.rtl))
+		  : 0))
+      && expr_size (exp))
+    ;
+}
+
+/* All paths to the test "target != 0" occuring in the final IF statement
+   dereference target.  Thus target can not have the value zero at that
+   point and the test should have been eliminated.  */
+/* ??? The dominator walker (A) doesn't merge this data at joins and
+   (B) only looks at immediate dominators, and only queued_subexp_p
+   immediately dominates the comparison in question.  We need something
+   stronger.  */
+/* { dg-final { scan-tree-dump-times "target.*!= 0" 0 "dom2" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030731-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030731-2.c
new file mode 100644
index 000000000..8300320c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030731-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dce1" } */
+
+void
+bar (int i, int partial, int args_addr)
+{
+  int offset = 0;
+  if (args_addr == 0)
+    offset = 0;
+  if (i >= offset)
+    foo ();
+}
+
+/* There should be only one IF conditional since the first does nothing
+   useful.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "dce1"} } */
+/* { dg-final { cleanup-tree-dump "dce1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-1.c
new file mode 100644
index 000000000..84344e36c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-1.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+    
+struct rtx_def;
+typedef struct rtx_def *rtx;
+
+
+
+union rtunion_def
+{
+  int rtint;
+};
+typedef union rtunion_def rtunion;
+
+
+
+struct rtx_def
+{
+  rtunion fld[1];
+
+};
+
+static int *uid_cuid;
+static int max_uid_cuid;
+
+rtx
+bar (rtx r)
+{
+  rtx place = r;
+
+  if (place->fld[0].rtint <= max_uid_cuid
+      && (place->fld[0].rtint > max_uid_cuid ? insn_cuid (place) :
+	  uid_cuid[place->fld[0].rtint]))
+    return r;
+  
+  return 0;
+}
+
+/* There should be two IF conditionals.  One tests <= max_uid_cuid, the
+   other tets the value in uid_cuid.  If either is false the jumps
+   are threaded to the return 0.  Which in turn means the path
+   which combines the result of those two tests into a new test
+   must always be true and it is optimized appropriately.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-10.c
new file mode 100644
index 000000000..fe5e859ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-10.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+     
+
+extern const unsigned char mode_size[];
+unsigned int
+subreg_highpart_offset (outermode, innermode)
+     int outermode, innermode;
+{
+  unsigned int offset = 0;
+  int difference = (mode_size[innermode] - mode_size[outermode]);
+  if (difference > 0)
+    {
+        offset += difference % (0 ? 8 : 4);
+	offset += difference / 4 * 4;
+    }
+  return offset;
+}
+
+/* There should be one mask with the value 3.  */
+/* { dg-final { scan-tree-dump-times " \& 3" 1 "vrp1"} } */
+  
+/* There should be one right shift by 2 places.  */
+/* { dg-final { scan-tree-dump-times " >> 2" 1 "vrp1"} } */
+
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-11.c
new file mode 100644
index 000000000..0711053bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-11.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtx_def
+{
+  int code;
+};
+foo (reg)
+     rtx reg;
+{
+  reg->code = 42;
+  if (reg->code != 42)
+    abort ();
+}
+                                                                                
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-2.c
new file mode 100644
index 000000000..a12d71840
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-2.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-vrp -fdump-tree-dom2" } */
+     
+extern void abort (void);
+
+oof ()
+{
+  int live_head;
+  int * live = &live_head;
+
+  if (live)
+   bitmap_clear (live);
+}
+
+foo(int n)
+{
+  int *space = (int *)__builtin_alloca (n);
+
+  if (space == 0)
+    abort ();
+  else
+    bar (space);
+}
+
+                                                                               
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2" } } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-3.c
new file mode 100644
index 000000000..9a3c23163
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-3.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+                                                                                
+typedef unsigned int cppchar_t;
+cppchar_t
+cpp_parse_escape (pstr, limit, wide)
+     const unsigned char **pstr;
+     const unsigned char *limit;
+     int wide;
+{
+  cppchar_t i = 0;
+  int overflow = 0;
+  cppchar_t mask = ~0;
+
+   while (*pstr < limit)
+     {
+       overflow |= i ^ (i << 4 >> 4);
+       i = oof ();
+     }
+   if (overflow |  (i != (i & mask)))
+     foo();
+}
+
+/* There should be precisely three IF statements.  If there is
+   more than two, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "if " 3 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-5.c
new file mode 100644
index 000000000..424b5583b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-5.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+struct rtx_def;
+typedef struct rtx_def *rtx;
+
+
+struct rtx_def
+{
+
+  int code;
+  unsigned int unchanging:1;
+
+};
+static rtx current_sym_addr;
+
+int
+foo ()
+{
+  if (current_sym_addr->code == 42
+      && (({
+	       rtx _rtx = current_sym_addr;
+	       if (((_rtx)->code) != 42)
+	         abort ();
+	       _rtx;}
+	   )->unchanging))
+    return 0;
+}
+
+/* There should be precisely one load of ->code.  If there is
+   more than, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "->code" 1 "dom2"} } */
+
+/* There should be two IF statements.  One for 'current_sym_addr->code == 42'.
+   The other one for '(EXPR)->unchanging'.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "dom2"} } */
+
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-6.c
new file mode 100644
index 000000000..8a6506b3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-6.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+     
+
+void
+foo (distance, i, j)
+     int distance[13][13];
+     int i, j;
+{
+ if (distance[i][j] < 0)
+   distance[i][0] = ((distance[i][j]) < 0 ? -(distance[i][j])  : (distance[i][j]));
+}
+
+void
+foo2 (distance, i, j)
+     int distance[13][13];
+     int i, j;
+{
+ if (distance[i][j] <= 0)
+   distance[i][0] = ((distance[i][j]) < 0 ? -(distance[i][j])  : (distance[i][j]));
+}
+
+void
+foo3 (distance, i, j)
+     int distance[13][13];
+     int i, j;
+{
+ if (distance[i][j] > 0)
+   distance[i][0] = ((distance[i][j]) < 0 ? -(distance[i][j])  : (distance[i][j]));
+}
+
+void
+foo4 (distance, i, j)
+     double distance[13][13];
+     int i, j;
+{
+ if (distance[i][j] >= 0)
+   distance[i][0] = ((distance[i][j]) < 0 ? -(distance[i][j])  : (distance[i][j]));
+}
+
+/* There should be no ABS_EXPR.  */
+/* { dg-final { scan-tree-dump-times "ABS_EXPR " 0 "vrp1"} } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-7.c
new file mode 100644
index 000000000..f9f5fb798
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-7.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+  
+extern void abort (void);
+
+union tree_node;
+typedef union tree_node *tree;
+struct tree_common
+{
+  int code;
+};
+struct tree_list
+{
+  tree purpose;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_list list;
+};
+void
+simplify_condition (cond_p)
+     tree *cond_p;
+{
+  tree decl;
+  tree cond = *cond_p;
+  if (cond->common.code != 42)
+    abort ();
+  decl = cond->list.purpose;
+  if (cond->common.code != 42)
+    abort ();
+  c_simplify_stmt (&decl);
+}
+
+/* There should be exactly one IF conditional.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-8.c
new file mode 100644
index 000000000..77fd3e59a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-8.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+                                                                                
+struct die_struct;
+typedef struct die_struct *dw_die_ref;
+typedef struct dw_loc_list_struct *dw_loc_list_ref;
+enum dw_val_class
+{
+  dw_val_class_loc_list,
+};
+typedef struct dw_val_struct
+{
+  enum dw_val_class val_class;
+  union dw_val_struct_union
+    {
+      dw_loc_list_ref val_loc_list;
+    }
+  v;
+}
+dw_val_node;
+typedef struct dw_attr_struct *dw_attr_ref;
+typedef struct dw_attr_struct
+{
+  dw_val_node dw_attr_val;
+}
+dw_attr_node;
+
+extern __inline__ enum dw_val_class
+AT_class (a)
+     dw_attr_ref a;
+{
+  return a->dw_attr_val.val_class;
+}
+
+extern __inline__ dw_loc_list_ref
+AT_loc_list (a)
+     dw_attr_ref a;
+{
+  if (AT_class (a) == dw_val_class_loc_list)
+    return a->dw_attr_val.v.val_loc_list;
+}
+
+void
+output_location_lists (die)
+     dw_die_ref die;
+{
+  dw_die_ref c;
+  dw_attr_ref d_attr;
+    if (AT_class (d_attr) == dw_val_class_loc_list)
+      output_loc_list (AT_loc_list (d_attr));
+}
+
+/* There should be exactly one IF conditional, in output_location_lists.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-9.c
new file mode 100644
index 000000000..4f0b7cbaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030807-9.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+static void
+bar ()
+{
+  const char *label2 = (*"*.L_sfnames_b" == '*') + "*.L_sfnames_b";
+  oof (label2);
+}
+
+void
+ooof ()
+{
+  if (""[0] == 0)
+    foo();
+}
+
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030808-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030808-1.c
new file mode 100644
index 000000000..27e2c7105
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030808-1.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-cddce2" } */
+      
+extern void abort (void);
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+enum rtx_code
+{
+  UNKNOWN,
+  CODE_LABEL,
+  NOTE,
+  LAST_AND_UNUSED_RTX_CODE = 256
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  enum rtx_code code:16;
+};
+void
+delete_dead_jumptables ()
+{
+  rtx insn, next;
+  if (insn->code == CODE_LABEL)
+    {
+      rtx const _rtx = insn;
+      if (_rtx->code != CODE_LABEL && _rtx->code != NOTE)
+	abort ();
+    }
+  ;
+}
+
+/* There should be no loads of ->code.  If any exist, then we failed to
+   optimize away all the IF statements and the statements feeding
+   their conditions.  */
+/* { dg-final { scan-tree-dump-times "->code" 0 "cddce2"} } */
+   
+/* There should be no IF statements.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "cddce2"} } */
+
+/* { dg-final { cleanup-tree-dump "cddce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-1.c
new file mode 100644
index 000000000..aad53c339
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+   
+extern void abort (void);
+
+com(int *blah)
+{
+  int z = *blah;
+  if (z == 256)
+    {
+      oof (z);
+      abort ();
+    }
+  return *blah;
+}
+
+/* There should be precisely one load of blah.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "\\*blah" 1 "dom2"} } */
+  
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-2.c
new file mode 100644
index 000000000..7f60b2783
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+    
+extern void abort (void);
+
+void
+foo (int value)
+{
+  switch (value)
+    {
+    case 42:
+	      if (value != 42)
+		abort ();
+    case 50:
+      blah ();
+    }
+}
+
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2"} } */
+ 
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-3.c
new file mode 100644
index 000000000..2746415e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-3.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+    
+extern void abort (void);
+
+void
+foo (int value)
+{
+  switch (value)
+    {
+    case 40:
+    case 42:
+	      if (value != 42)
+		abort ();
+    case 50:
+      blah ();
+    }
+}
+
+/* There should be one IF conditional.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "dom2"} } */
+ 
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-4.c
new file mode 100644
index 000000000..2c2142cbc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-4.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2 -fdump-tree-optimized" } */
+    
+extern void abort (void);
+union tree_node;
+typedef union tree_node *tree;
+extern const char tree_code_type[];
+struct tree_common
+{
+  int code;
+};
+struct tree_decl 
+{
+  long pointer_alias_set;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_decl decl;
+};
+long
+blah (decl, set)
+     tree decl;
+     long set;
+{
+  decl->decl.pointer_alias_set = set;
+  if (tree_code_type[decl->common.code] != 'd')
+    abort ();
+  record_alias_subset (decl->decl.pointer_alias_set);
+  if (set != -1)
+    set = 0; 
+  return set;
+}
+
+/* There should be precisely one reference to pointer_alias_set.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "pointer_alias_set" 1 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
+
+/* The assignment set = -1 in the ELSE clause of the last IF
+   statement should be removed by the final cleanup phase.  */
+/* { dg-final { scan-tree-dump-times "set = -1" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-5.c
new file mode 100644
index 000000000..41aa1482d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-5.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2 -fdump-tree-optimized" } */
+    
+extern void abort (void);
+union tree_node;
+typedef union tree_node *tree;
+extern const char tree_code_type[];
+struct tree_common
+{
+  int code;
+};
+struct tree_decl 
+{
+  long pointer_alias_set;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_decl decl;
+};
+long
+blah (decl, set)
+     tree decl;
+     long set;
+{
+  decl->decl.pointer_alias_set = oof();
+  if (tree_code_type[decl->common.code] != 'd')
+    abort ();
+  record_alias_subset (decl->decl.pointer_alias_set);
+  if (set != -1)
+    set = 0; 
+  return set;
+}
+
+/* There should be precisely one reference to pointer_alias_set.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* { dg-final { scan-tree-dump-times "pointer_alias_set" 1 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
+
+/* The assignment set = -1 in the ELSE clause of the last IF
+   statement should be removed by the final cleanup phase.  */
+/* { dg-final { scan-tree-dump-times "set = -1" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-6.c
new file mode 100644
index 000000000..170526547
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-6.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+union tree_node;
+typedef union tree_node *tree;
+enum tree_code
+{
+  LAST_AND_UNUSED_TREE_CODE
+};
+extern const char tree_code_type[];
+struct tree_common
+{
+  enum tree_code code:8;
+};
+struct tree_type
+{
+  double alias_set;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_type type;
+};
+long
+foo (t, set)
+     tree t;
+     double set;
+{
+  if (tree_code_type[t->common.code] != 't')
+    abort ();
+
+  t->type.alias_set = set;
+
+  if (t->common.code == 42)
+    return 1;
+  else
+    return 0;
+}
+/* There should be precisely one load of common.code.  If there is
+   more than one, then the dominator optimizations failed.  */
+/* ??? Will fail until we properly distinguish member stores.  At
+   present the write to type.alias_set kills the previous load.  */
+/* { dg-final { scan-tree-dump-times "common.code" 1 "dom2" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-7.c
new file mode 100644
index 000000000..711bab251
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030814-7.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+extern void abort (void);
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtvec_def;
+typedef struct rtvec_def *rtvec;
+union tree_node;
+typedef union tree_node *tree;
+struct tree_common
+{
+  int code;
+};
+union tree_node
+{
+  struct tree_common common;
+};
+extern tree current_function_decl;
+struct cgraph_rtl_info
+{
+  _Bool pure_function;
+};
+struct cgraph_rtl_info *cgraph_rtl_info (tree);
+void
+mark_constant_function (void)
+{
+  rtx insn;
+  int nonlocal_memory_referenced;
+
+  if (current_function_decl->common.code != 42)
+    abort ();
+
+  cgraph_rtl_info (current_function_decl)->pure_function = 1;
+}
+
+/* current_function_decl should be loaded once into a temporary
+   and the temporary used as the argument to cgraph_rtl_info.
+   This if we find current_function_decl used as an argument, then
+   we have failed.  */
+/* { dg-final { scan-tree-dump-times "\\(current_function_decl\\)" 0 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030820-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030820-1.c
new file mode 100644
index 000000000..4b659ca34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030820-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+/* A test for unreachable blocks removal -- bind_expr whose entry is
+   unreachable, but it contains reachable statements.  */   
+
+void foo(void)
+{
+  if (1)
+    {
+      goto bla;
+    }
+  else
+    {
+xxx:
+	{
+bla:
+	  bar ();
+	  return;
+	}
+      goto xxx;
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030820-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030820-2.c
new file mode 100644
index 000000000..9ca9fbb59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030820-2.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+/* A test for variables getting out of their scope in copy propagation.  */
+
+void foo(void)
+{
+  int k;
+
+  goto forward;
+back:
+  bla (k);
+  return;
+
+forward:
+    {
+      int i = bar ();
+
+      k = i;
+
+      goto back;
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030821-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030821-1.c
new file mode 100644
index 000000000..5de503ed6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030821-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom1 -fdump-tree-optimized" } */
+
+void foo(int k)
+{
+  int i = 1;
+  void *label;
+
+  label = k ? &&x : &&y;
+
+  if (k == 1)
+    goto *label;
+
+  i = 0;
+  goto z;
+z:
+x:
+  if (i)
+    dont_remove ();
+y: ;
+}
+
+/* { dg-final { scan-tree-dump-times "dont_remove \\(\\)" 1 "optimized"} } */
+
+/* We should have folded away the goto &x  */
+/* { dg-final { scan-tree-dump-times "goto &x" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030824-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030824-1.c
new file mode 100644
index 000000000..da1389e91
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030824-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+struct A
+{
+  int a,b;
+};
+
+int foo (int x, int y)
+{
+  int i, j;
+  struct A a,b;
+
+  a.a = x;
+  b.b = y;
+  j = a.a;
+  i = b.b;
+  return i + j;
+}
+
+/* The addition should be optimized into 'y+x'.  */
+/* { dg-final { scan-tree-dump-times "\[xy\] \\+ \[xy]" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030824-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030824-2.c
new file mode 100644
index 000000000..1b8bc4814
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030824-2.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+struct A
+{
+  int a,b;
+};
+
+int foo (int x, int y)
+{
+  int i, j;
+  struct A a;
+
+  a.a = x;
+  a.b = y;
+  j = a.a;
+  i = a.b;
+  return i + j;
+}
+
+/* This function should be optimized into 'return y+x'.  */
+/* { dg-final { scan-tree-dump-times "return \[xy\] \\+ \[xy\]" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030825-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030825-1.c
new file mode 100644
index 000000000..de34acaec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030825-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+void bla(void);
+
+void
+foo(int c, int d)
+{
+  goto skip;
+
+ebef:
+  goto xxx;
+
+skip:
+
+  if (c)
+    {
+xxx:;
+    if (!c)
+      bla ();
+    }
+    
+  if (d)
+    goto ebef;
+}
+
+/* Bla should not be optimized away.  */
+/* { dg-final { scan-tree-dump-times "bla" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030907-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030907-1.c
new file mode 100644
index 000000000..a36472d39
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030907-1.c
@@ -0,0 +1,30 @@
+/* PR optimization/12198
+
+   This was a miscompilation of a switch expressions because
+   the "Case Ranges" extension wasn't handled in tree-cfg.c.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int main() 
+{ 
+   int i; 
+   i = 2; 
+   switch (i) 
+      { 
+      case 1 ... 5: 
+         goto L1; 
+      default: 
+         abort (); 
+         goto L1; 
+      } 
+   L1: 
+   exit(0); 
+}
+
+/* The abort() call clearly is unreachable.  */
+/* { dg-final { scan-tree-dump-times "abort" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030907-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030907-2.c
new file mode 100644
index 000000000..47d60946e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030907-2.c
@@ -0,0 +1,30 @@
+/* PR optimization/12109
+
+   This would ICE in tree-ssa-dce.c:process_worklist() when
+   the function was expecting an SSA_NAME but found a VAR_DECL.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-dce" } */
+
+void *do_it(void * dest, const void * src);
+double *create_float(void);
+
+void parse_rvalue(void **DataPtr)
+{
+  double local = 0.0;
+  int terms = 1;
+
+  *DataPtr = create_float();
+  
+  switch (terms)
+    {
+    case 1:
+      *((double *)*DataPtr) = local;
+      break;
+      
+    case 2:
+      do_it(*DataPtr, &local);
+      break;
+    }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-1.c
new file mode 100644
index 000000000..eb1f5ec7d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+  
+
+extern int board[];
+
+void
+findbestextension (int blah, int blah2)
+{
+  int defval;
+  defval = def_val (board[blah2]);
+  if (blah)
+    defval = 0;
+  foo (defval);
+}
+
+/* The argument to "foo" should be a variable, not a constant.  */
+/* { dg-final { scan-tree-dump-times "foo .defval" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-2.c
new file mode 100644
index 000000000..2c08050c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-2.c
@@ -0,0 +1,40 @@
+/* This test was causing an ICE in DCE because we were allowing void *
+   pointers to have a memory tag, which we were copying when doing copy
+   propagation.  Since void * can never be de-referenced, its memory tag
+   was never renamed.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-dominator-opts" } */
+
+typedef __SIZE_TYPE__ size_t;
+typedef union tree_node *tree;
+struct operands_d
+{
+  tree *def_op;
+};
+
+void
+gt_ggc_mx_operands_d (void *x_p)
+{
+  struct operands_d *const x = (struct operands_d *) x_p;
+  if ((*x).def_op != ((void *) 0))
+    {
+      size_t i0;
+      do
+	{
+	  const void *const a__ = ((*x).def_op);
+	  if (a__ != ((void *) 0) && a__ != (void *) 1)
+	    ggc_set_mark (a__);
+	}
+      while (0);
+      for (i0 = 0; i0 < (size_t) (1); i0++)
+	{
+	  do
+	    {
+	      if ((void *) (*x).def_op[i0] != ((void *) 0))
+		gt_ggc_mx_lang_tree_node ((*x).def_op[i0]);
+	    }
+	  while (0);
+	}
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-3.c
new file mode 100644
index 000000000..e74bd08da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030917-3.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+extern int printf (const char *, ...); 
+
+main ()
+{
+  int variable = 0;
+  int p = 1;
+  while (1)
+    {
+      if (p)
+        break;
+      variable = variable + 1;
+      if (variable == 10)
+        break;
+    }
+  printf("%d\n", variable);
+}
+
+
+/* The argument to "printf" should be a constant, not a variable.  */
+/* { dg-final { scan-tree-dump-times "printf.*, 0" 1 "ccp1"} } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030918-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030918-1.c
new file mode 100644
index 000000000..719ea65f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030918-1.c
@@ -0,0 +1,15 @@
+/* The compiler was failing to adjust pointer dereferences into array
+   references after propagating &equot[0] into p.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-dominator-opts" } */
+
+static unsigned short equot[(6 +3)];
+int
+foo (num)
+     unsigned short num[];
+{
+  unsigned short *p = &equot[0];
+  *p++ = num[0];
+  *p++ = num[1];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030920-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030920-1.c
new file mode 100644
index 000000000..e27764aec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030920-1.c
@@ -0,0 +1,112 @@
+/* Jump threading was creating FALLTHRU edges out of blocks ending in
+   GOTO_EXPR.  */
+
+extern int frame_pointer_needed;
+
+struct value_data_entry
+{
+  unsigned int mode;
+  unsigned int oldest_regno;
+  unsigned int next_regno;
+};
+
+struct value_data
+{
+  struct value_data_entry e[53];
+  unsigned int max_value_regs;
+};
+
+struct rtx_def
+{
+  unsigned int code: 16;
+  unsigned int mode : 8;
+  unsigned int jump : 1;
+  unsigned int call : 1;
+  unsigned int unchanging : 1;
+  unsigned int volatil : 1;
+  unsigned int in_struct : 1;
+  unsigned int used : 1;
+  unsigned integrated : 1;
+  unsigned frame_related : 1;
+  int fld[1];
+};
+
+typedef struct rtx_def *rtx;
+
+enum machine_mode { VOIDmode, BImode, QImode, HImode, SImode, DImode,
+    TImode, OImode, PQImode, PHImode, PSImode, PDImode, QFmode, HFmode,
+    TQFmode, SFmode, DFmode, XFmode, TFmode, QCmode, HCmode, SCmode,
+    DCmode, XCmode, TCmode, CQImode, CHImode, CSImode, CDImode, CTImode,
+    COImode, V1DImode, V2QImode, V2HImode, V2SImode, V2DImode, V4QImode,
+    V4HImode, V4SImode, V4DImode, V8QImode, V8HImode, V8SImode, V8DImode,
+    V16QImode, V2HFmode, V2SFmode, V2DFmode, V4HFmode, V4SFmode, V4DFmode,
+    V8HFmode, V8SFmode, V8DFmode, V16SFmode, BLKmode, CCmode, CCGCmode,
+    CCGOCmode, CCNOmode, CCZmode, CCFPmode, CCFPUmode, MAX_MACHINE_MODE };
+
+enum mode_class { MODE_RANDOM, MODE_INT, MODE_FLOAT, MODE_PARTIAL_INT, MODE_CC,
+    MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT,
+    MODE_VECTOR_INT, MODE_VECTOR_FLOAT,
+    MAX_MODE_CLASS};
+
+extern const unsigned char mode_size[(int) MAX_MACHINE_MODE];
+extern const enum mode_class mode_class[(int) MAX_MACHINE_MODE];
+
+extern int target_flags;
+
+static void
+copy_value (rtx dest, rtx src, struct value_data *vd)
+{
+  unsigned int dr = (((dest)->fld[0]));
+  unsigned int sr = (((src)->fld[0]));
+  unsigned int dn, sn;
+  unsigned int i;
+
+
+
+  if (sr == dr)
+    return;
+
+
+
+  if (dr == 7)
+    return;
+
+
+  if (frame_pointer_needed && dr == 6)
+    return;
+
+
+  dn = (((dr) >= 8 && (dr) <= (8 + 7)) || (((dr) >= (20 + 1) && (dr) <= ((20 + 1) + 7)) || ((dr) >= (((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) && (dr) <= ((((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) + 7))) || ((dr) >= (((20 + 1) + 7) + 1) && (dr) <= ((((20 + 1) + 7) + 1) + 7)) ? (((mode_class[(int) (((enum machine_mode) (dest)->mode))]) == MODE_COMPLEX_INT || (mode_class[(int) (((enum machine_mode) (dest)->mode))]) == MODE_COMPLEX_FLOAT) ? 2 : 1) : ((((enum machine_mode) (dest)->mode)) == TFmode ? ((target_flags & 0x00100000) ? 2 : 3) : (((enum machine_mode) (dest)->mode)) == TCmode ? ((target_flags & 0x00100000) ? 4 : 6) : (((mode_size[(int) (((enum machine_mode) (dest)->mode))]) + ((target_flags & 0x00100000) ? 8 : 4) - 1) / ((target_flags & 0x00100000) ? 8 : 4))));
+  sn = (((sr) >= 8 && (sr) <= (8 + 7)) || (((sr) >= (20 + 1) && (sr) <= ((20 + 1) + 7)) || ((sr) >= (((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) && (sr) <= ((((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) + 7))) || ((sr) >= (((20 + 1) + 7) + 1) && (sr) <= ((((20 + 1) + 7) + 1) + 7)) ? (((mode_class[(int) (((enum machine_mode) (dest)->mode))]) == MODE_COMPLEX_INT || (mode_class[(int) (((enum machine_mode) (dest)->mode))]) == MODE_COMPLEX_FLOAT) ? 2 : 1) : ((((enum machine_mode) (dest)->mode)) == TFmode ? ((target_flags & 0x00100000) ? 2 : 3) : (((enum machine_mode) (dest)->mode)) == TCmode ? ((target_flags & 0x00100000) ? 4 : 6) : (((mode_size[(int) (((enum machine_mode) (dest)->mode))]) + ((target_flags & 0x00100000) ? 8 : 4) - 1) / ((target_flags & 0x00100000) ? 8 : 4))));
+  if ((dr > sr && dr < sr + sn)
+      || (sr > dr && sr < dr + dn))
+    return;
+
+
+
+
+  if (vd->e[sr].mode == VOIDmode)
+    set_value_regno (sr, vd->e[dr].mode, vd);
+  else if (sn < (unsigned int) (((sr) >= 8 && (sr) <= (8 + 7)) || (((sr) >= (20 + 1) && (sr) <= ((20 + 1) + 7)) || ((sr) >= (((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) && (sr) <= ((((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) + 7))) || ((sr) >= (((20 + 1) + 7) + 1) && (sr) <= ((((20 + 1) + 7) + 1) + 7)) ? (((mode_class[(int) (vd->e[sr].mode)]) == MODE_COMPLEX_INT || (mode_class[(int) (vd->e[sr].mode)]) == MODE_COMPLEX_FLOAT) ? 2 : 1) : ((vd->e[sr].mode) == TFmode ? ((target_flags & 0x00100000) ? 2 : 3) : (vd->e[sr].mode) == TCmode ? ((target_flags & 0x00100000) ? 4 : 6) : (((mode_size[(int) (vd->e[sr].mode)]) + ((target_flags & 0x00100000) ? 8 : 4) - 1) / ((target_flags & 0x00100000) ? 8 : 4))))
+    && ((mode_size[(int) (vd->e[sr].mode)]) > ((target_flags & 0x00100000) ? 8 : 4)
+        ? 0 : 0))
+    return;
+
+
+
+
+  else if (sn > (unsigned int) (((sr) >= 8 && (sr) <= (8 + 7)) || (((sr) >= (20 + 1) && (sr) <= ((20 + 1) + 7)) || ((sr) >= (((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) && (sr) <= ((((((((20 + 1) + 7) + 1) + 7) + 1) + 7) + 1) + 7))) || ((sr) >= (((20 + 1) + 7) + 1) && (sr) <= ((((20 + 1) + 7) + 1) + 7)) ? (((mode_class[(int) (vd->e[sr].mode)]) == MODE_COMPLEX_INT || (mode_class[(int) (vd->e[sr].mode)]) == MODE_COMPLEX_FLOAT) ? 2 : 1) : ((vd->e[sr].mode) == TFmode ? ((target_flags & 0x00100000) ? 2 : 3) : (vd->e[sr].mode) == TCmode ? ((target_flags & 0x00100000) ? 4 : 6) : (((mode_size[(int) (vd->e[sr].mode)]) + ((target_flags & 0x00100000) ? 8 : 4) - 1) / ((target_flags & 0x00100000) ? 8 : 4)))))
+    return;
+
+
+
+  vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
+
+  for (i = sr; vd->e[i].next_regno != (~(unsigned int) 0); i = vd->e[i].next_regno)
+    continue;
+  vd->e[i].next_regno = dr;
+
+
+  validate_value_data (vd);
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030922-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030922-1.c
new file mode 100644
index 000000000..96db1bd1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030922-1.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+  
+extern void abort (void);
+
+union tree_node;
+typedef union tree_node *tree;
+enum tree_code
+{
+  BIND_EXPR,
+};
+struct tree_common
+{
+  enum tree_code code:8;
+};
+union tree_node
+{
+  struct tree_common common;
+};
+tree
+voidify_wrapper_expr (tree wrapper)
+{
+  switch (wrapper->common.code)
+    {
+    case BIND_EXPR:
+      if (wrapper->common.code != BIND_EXPR)
+        abort ();
+    }
+}
+
+
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c
new file mode 100644
index 000000000..9a787bd21
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20030922-2.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom1" } */
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtx_def
+{
+  int bb;
+};
+int *block_to_bb;
+int target_bb;
+
+int
+rgn_rank (rtx insn1, rtx insn2)
+{
+  if (block_to_bb[insn1->bb] != block_to_bb[insn2->bb])
+    if (block_to_bb[insn2->bb] == target_bb
+	&& block_to_bb[insn1->bb] != target_bb)
+      return 1;
+}
+
+/* There should be two IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "dom1" } } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031015-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031015-1.c
new file mode 100644
index 000000000..102715c01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031015-1.c
@@ -0,0 +1,18 @@
+/* With tree-ssa, gcc.dg/20000724-1.c failed because we missed
+   a VOP of x in the asm statement.  */
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-alias-vops" } */
+
+struct s { int a; };
+
+int
+main(void)
+{
+  struct s x = { 0 };
+  asm volatile ("" : : "r" (&x) : "memory");
+  return 0;
+}
+
+/* The VDEF comes from the initial assignment and the asm.  */
+/* { dg-final { scan-tree-dump-times "DEF" 2 "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c
new file mode 100644
index 000000000..117cddf12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031021-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+struct A
+{
+  int i : 8;
+};
+
+signed char c1, c2;
+struct A a;
+
+int main()
+{
+  a.i = c1;
+  c2 = a.i;
+  return a.i;
+}
+
+/* We should only store to a.i, not load from it.  */
+/* { dg-final { scan-tree-dump-times "a.i" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031022-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031022-1.c
new file mode 100644
index 000000000..27de6e90e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031022-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom1" } */
+ 
+typedef struct edge_def
+{
+  int z;
+} *edge;
+typedef struct basic_block_def
+{
+  edge pred;
+} *basic_block;
+extern struct basic_block_def entry_exit_blocks[2];
+void
+blah (int arf)
+{
+  edge e;
+  e = (&entry_exit_blocks[1])->pred;
+  for ( ; ;)
+    if (arf)
+      break;
+  commit_edge_insertions ();
+  e = (&entry_exit_blocks[1])->pred;
+  foo (e);
+}
+
+/* There should be one load from entry_exit_blocks[1].pred.  */
+/* { dg-final { scan-tree-dump-times "entry_exit_blocks.1..pred" 1 "dom1"} } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031031-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031031-1.c
new file mode 100644
index 000000000..baca2a00a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031031-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+/* This program requires the SSA renamer to be run after the second DOM
+   pass.  Test provided by Falk Hueffner as Bugzilla #12825.  */
+
+struct floppy_raw_cmd {
+  int flags, track;
+} *raw_cmd, default_raw_cmd;
+
+void
+setup_format_params (void)
+{
+  raw_cmd = &default_raw_cmd;
+  raw_cmd->track = 0;
+  raw_cmd->flags = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-1.c
new file mode 100644
index 000000000..fea5aaf08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* Check for dead stores to an array.  */
+
+void foo (int testarray[])
+{
+  testarray[0] = 0;
+  testarray[0]++;
+  if (testarray[0] != 1)
+    link_error ();
+}
+
+/* There should be only one reference to "testarray" and one in the function header.  */
+/* { dg-final { scan-tree-dump-times "testarray" 2 "optimized" } } */
+
+/* There should be no link_error calls.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-2.c
new file mode 100644
index 000000000..73dd4ff2e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-2.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* Check for dead stores to a struct.  */
+
+struct s
+{
+  char d;
+  int a, b;
+  double m;
+};
+
+void foo (struct s* teststruct)
+{
+  teststruct->a = 0;
+  teststruct->a++;
+  if (teststruct->a != 1)
+    link_error ();
+}
+
+/* There should be only one reference to "teststruct" and one in the function header.  */
+/* { dg-final { scan-tree-dump-times "teststruct" 2 "optimized" } } */
+
+/* There should be no link_error calls.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-3.c
new file mode 100644
index 000000000..4d1919a6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-3.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* Check for cprop on array elements.  */
+
+void foo (int testarray[])
+{
+  testarray[0] = 0;
+  testarray[1] = 1;
+  testarray[0]++;
+  testarray[1]++;
+  if (testarray[0] != 1)
+    link_error ();
+  if (testarray[1] != 2)
+    link_error ();
+}
+
+/* There should be no link_error calls.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-4.c
new file mode 100644
index 000000000..d72788691
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-4.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* Check for cprop on fields of the same struct.  */
+
+struct s
+{
+  char d;
+  int a, b;
+  double m;
+};
+
+
+void foo (struct s*  r)
+{
+  r->a = 0;
+  r->b = 1;
+  r->a++;
+  r->b++;
+  if (r->a != 1)
+    link_error ();
+  if (r->b != 2)
+    link_error ();
+}
+
+/* There should be no link_error calls.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-5.c
new file mode 100644
index 000000000..b066ab6ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-5.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* Check for cprop on different fields of same type structs.  */
+
+struct s
+{
+  char d;
+  int a, b;
+  double m;
+};
+
+void foo2 (struct s*  r, struct s*  p)
+{
+  r->a = 0;
+  p->b = 1;
+  r->a++;
+  p->b++;
+  if (r->a != 1)
+    link_error ();
+  if (p->b != 2)
+    link_error ();
+}
+
+/* There should be no link_error calls.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-6.c
new file mode 100644
index 000000000..51fcd9788
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031106-6.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fno-tree-sra -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* Check for copyprop on structs.  */
+
+struct s
+{
+  char d;
+  int a, b;
+  double m;
+};
+
+struct s foo (struct s r)
+{
+  struct s temp_struct1;
+  struct s temp_struct2;
+  struct s temp_struct3;
+  temp_struct1 = r;
+  temp_struct2 = temp_struct1;
+  temp_struct3 = temp_struct2;
+  return temp_struct3;
+}
+
+/* There should be no references to any of "temp_struct*"
+   temporaries.  */
+/* { dg-final { scan-tree-dump-times "temp_struct" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031113-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031113-1.c
new file mode 100644
index 000000000..865915f4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031113-1.c
@@ -0,0 +1,32 @@
+/* PR optimization/12640
+
+   We used to get into an infinite loop while trying to
+   figure out `strlen (resultString)'.  This showed up as
+   a stack overflow while compiling tk.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1" } */ 
+
+extern __SIZE_TYPE__ strlen (const char *);
+
+int i; 
+
+static void 
+SendEventProc (char *resultString) 
+{ 
+  char *p; 
+ 
+  resultString = ""; 
+  while (*p == '-') 
+    { 
+      if (p[2] == ' ') 
+	{ 
+	  resultString = p + 3; 
+	} 
+    } 
+  for (;;) 
+    { 
+      i = strlen (resultString) + 1; 
+    } 
+}
+ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031216-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031216-1.c
new file mode 100644
index 000000000..0e97833fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20031216-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+void
+foo (int b)
+{
+  int a;
+  a = b + 2;
+  a--;
+  a--;
+  if (a != b)
+    link_error ();
+}
+
+/* The comparison should be eliminated, there should be no reference
+   to link_error.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040121-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040121-1.c
new file mode 100644
index 000000000..6225bcdc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040121-1.c
@@ -0,0 +1,28 @@
+
+
+/* Test that (p!=0) + (q!=0) is computed as int,
+    not boolean */
+/* { dg-options "-O3" } */
+/* { dg-do run } */
+extern void abort (void);
+char *foo(char *p, char *q) {
+    int x = (p !=0) + (q != 0);
+    if (x==2)  return "a"; else return 0;
+}
+extern char *bar(char*, char*) __attribute__((noinline));
+char *bar(char *first, char *last)
+{
+   int y;
+   if (!first)  return last;
+   if (!last)   return first;
+   if (*first == 'a')
+     return foo(first, last);
+   return 0;
+}
+main() {
+   char *p = "a", *q = "b";
+   if (p)
+     if (bar(p,q))
+       return 0;
+   abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040204-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040204-1.c
new file mode 100644
index 000000000..d7aea1b84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040204-1.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/*
+  test that a condition  is propagated  inside an if
+*/
+
+void test5 (int x)
+{
+  extern int foo (int);
+  if (x == 0)
+    foo (x);
+  else if (x == 0 )
+    link_error ();
+}
+
+void test55 (int x, int y)
+{
+  int u;
+  if (x == 5 && y)
+    {
+      u = x + 22;
+      if (u != 27)
+        link_error ();
+    }
+}
+
+/* There should be not link_error calls, if there is any the
+   optimization has failed */
+/* ??? Ug.  This one may or may not fail based on how fold decides
+   that the && should be emitted (based on BRANCH_COST).  Fix this
+   by teaching dom to look through && and register all components
+   as true.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" { xfail { ! "powerpc*-*-* cris-*-* crisv32-*-* mmix-*-* mips*-*-* m68k*-*-*" } } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040209-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040209-1.c
new file mode 100644
index 000000000..087715322
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040209-1.c
@@ -0,0 +1,52 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+typedef union tree_node *tree;
+
+struct tree_common
+{
+  tree chain;
+};
+
+struct tree_decl
+{
+  struct tree_common common;
+  tree name;
+};
+
+
+union tree_node
+{
+  struct tree_common common;
+  struct tree_decl decl;
+};
+
+int pedantic;
+
+void
+finish_struct (tree t, tree fieldlist, tree attributes)
+{
+  union tree_node * x;
+
+  if (pedantic)
+    {
+      x = fieldlist;
+      if (x->decl.name == 0)
+	{
+	  while (x)
+	    x = x->common.chain;
+	  foo (fieldlist);
+	}
+    }
+
+  x = fieldlist;
+  if (x)
+    {
+      do
+	{
+	  x = x->common.chain;
+	} while (x != 0);
+    }
+  
+  bar1 (&fieldlist);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040210-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040210-1.c
new file mode 100644
index 000000000..990cb8075
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040210-1.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-phiopt1-details" } */
+ 
+
+void abort(void);
+void exit(int);
+
+int x, y;
+
+static void __attribute__ ((noinline))
+init_xy(void)
+{
+  x = 3;
+  y = 2;
+}
+
+void
+test4(void)
+{
+  init_xy();
+  if ((x < y ? x++ : y++) != 2)
+    abort ();
+}
+
+int
+main(){
+  test4 ();
+  exit (0);
+}
+
+/* Should have no more than two ifs left after straightening.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "phiopt1"} } */
+/* { dg-final { cleanup-tree-dump "phiopt1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040211-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040211-1.c
new file mode 100644
index 000000000..34a592679
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040211-1.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-cddce2" } */
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+extern const char rtx_class[];
+union rtunion_def
+{
+  rtx rtx;
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  int code;
+  rtunion fld[1];
+};
+static int
+can_move_up (rtx insn, int n_insns)
+{
+  while (n_insns > 0)
+    {
+      insn = (((insn)->fld[1]).rtx);
+      if (((rtx_class[(int) (((insn)->code))]) == 'i'))
+        n_insns--;
+    }
+  return n_insns <= 0;
+}
+int
+com (rtx insn, int blah)
+{
+  if (!can_move_up (insn, blah))
+    foo ();
+}
+
+/* Cddce cannot remove possibly infinite loops and there is no way how to
+   determine whether the loop in can_move_up ends.  */
+/* { dg-final { scan-tree-dump "if " "cddce2"} } */
+/* { dg-final { cleanup-tree-dump "cddce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040216-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040216-1.c
new file mode 100644
index 000000000..c770340a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040216-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dse1-details" } */
+ 
+foo(int *z, int *y, int xx)
+{
+  *z = 1;
+  if (xx)
+    xx = 20;
+  else
+   xx = 30;
+  *z = 2;
+  *z = 3;
+  return xx;
+}
+
+/* We should convert two COND_EXPRs into straightline code.  */
+/* { dg-final { scan-tree-dump-times "Deleted dead store" 2 "dse1"} } */
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040302-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040302-1.c
new file mode 100644
index 000000000..8b80128cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040302-1.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+/* Test for .GLOBAL_VAR not being renamed into SSA after alias analysis.
+   provided by Dale Johannesen in PR 14266.  */
+
+void foo() { bar (); }
+main () { foo (); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040305-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040305-1.c
new file mode 100644
index 000000000..8e9f61da6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040305-1.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-cddce2 -fdump-tree-forwprop1-details" } */
+  
+int abarney[2];
+int afred[1];
+ 
+void foo(int edx, int eax)
+{
+  if (eax == 100)
+    {
+      if (edx == 1)
+        {
+          abarney[0] = 5;
+          abarney[1] = 6;
+        }
+    }
+  if (eax == 100)
+    {
+      if (-- edx == 0)
+        afred[0] = 2;
+    }
+}
+ 
+
+/* Verify that we did a forward propagation.  */
+/* { dg-final { scan-tree-dump-times "Replaced" 1 "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
+
+/* After cddce we should have two IF statements remaining as the other
+   two tests can be threaded.  */
+/* { dg-final { scan-tree-dump-times "if " 2 "cddce2"} } */
+/* { dg-final { cleanup-tree-dump "cddce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040313-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040313-1.c
new file mode 100644
index 000000000..0ad144c03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040313-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+/* Test provided by Volker Reichelt in PR 14553.  The redundant PHI
+   node elimination pass was not using the right API functions to
+   propagate pointers, which resulted in dereferenced pointers that
+   did not have memory tags associated with them.  */
+
+void foo(int* p)
+{
+    int i;
+    for (i=1; i>0; --i, ++p)
+        *p=0;
+}
+
+void bar(int* p) { foo(p); }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040319-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040319-1.c
new file mode 100644
index 000000000..d6e544971
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040319-1.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+/* Test derived from PR 14643.  When a function has no addressable
+   variables but 2 or more pointers have conflicting memory tags, they
+   were not being processed by the type based alias analyzer,
+   resulting in optimizations removing a non-redundant load.  */
+
+extern void abort (void);
+
+struct bar { int count;  int *arr;};
+
+void foo (struct bar *b)
+{
+  b->count = 0;
+  *(b->arr) = 2;
+  if (b->count == 0)	/* b->count can't be assumed to be 0 here.  */
+    abort ();
+}
+
+main ()
+{
+  struct bar x;
+  x.arr = &x.count;
+  foo (&x);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040324-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040324-1.c
new file mode 100644
index 000000000..be718aba6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040324-1.c
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+/* Ensure that BIT_FIELD_REFs gets the appropriate VUSE.
+   Contributed by Paolo Bonzini  <bonzini@gnu.org>.
+
+   This testcase actually never triggered in the CVS repo, but it did
+   in my local tree and it seems worth testing.  In this test, the if's
+   are folded to BIT_FIELD_REFs but the VUSEs were erroneously left out.
+   Therefore, DOM did not see that i was modified between the two ifs
+   and optimized away the second if.  */
+
+extern void abort (void);
+extern void exit (int);
+
+struct x
+{
+  unsigned b:1;
+  unsigned c:1;
+};
+
+struct x i = { 1, 1 };
+
+int
+main ()
+{
+  i.b = 1;
+  if (i.b == 1 && i.c == 0)
+    exit (0);
+  i.c = 0;
+  if (i.b == 1 && i.c == 0)
+    exit (0);
+  abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040326-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040326-1.c
new file mode 100644
index 000000000..4be6049e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040326-1.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O2 -fno-inline-functions" } */
+/* { dg-do run } */
+/* When there are no call-clobbered variables, we should still create
+   a .GLOBAL_VAR to model the side effects of functions.  Without it,
+   we were moving the call to Faref() inside the second call to
+   Faset().  */
+extern void abort (void);
+extern void exit (int);
+
+main ()
+{
+  int table, c, elt;
+  int tem = Faref (table, elt);
+  Faset (table, elt, c);
+  Faset (table, c, tem);/* tem cannot be replaced with Faref (table, elt) */
+  exit (0);
+}
+
+int j = 0;
+
+int __attribute__ ((noinline)) Faref (table, elt)
+{
+  j = 1;
+  return 0;
+}
+
+int __attribute__ ((noinline)) Faset (table, elt, c)
+{
+  if (j != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040326-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040326-2.c
new file mode 100644
index 000000000..b1bed75da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040326-2.c
@@ -0,0 +1,64 @@
+/* { dg-options "-O2 -fno-inline-functions" } */
+/* { dg-do run } */
+
+/* Gimplification problem exposed by zsh.  All the side-effects in
+   function arguments and in the called expression should happen
+   before the actual function call.  */
+extern void abort (void);
+int A;
+
+typedef void (*fnptr) (void);
+fnptr *F;
+
+void
+foo (int x)
+{
+  if (A == x)
+    abort ();
+}
+
+void
+bar (int x, int y)
+{
+  if (x == 5 || y != 3)
+    abort ();
+}
+
+void
+boz (void)
+{
+  abort ();
+}
+
+void
+baz (void)
+{
+  if (*F != boz)
+    abort ();
+}
+
+fnptr B[2] = { baz, boz };
+
+main ()
+{
+  int b, c;
+
+  /* The gimplifier was emitting A++ after the call to foo.  */
+  A = 5;
+  foo (A++);
+
+  /* The increment to 'b' and 'c' must happen before the call.  However,
+     the first argument to bar() must be the original value of 'b', while
+     the second argument must be the new value of 'c'.  */
+  b = 4;
+  c = 2;
+  bar (b++, ++c);
+
+  /* This call via function pointer *F should go to baz, but F should
+     be incremented before the actual call (i.e., right before the
+     call F should be pointing to boz).  */
+  F = &B[0];
+  (*F++) ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040408-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040408-1.c
new file mode 100644
index 000000000..6578be543
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040408-1.c
@@ -0,0 +1,51 @@
+/* { dg-do compile }  */
+/* { dg-options "-O2" }  */
+/* Make sure that when a variable with an NMT is marked for renaming
+   that the NMT's aliases are also marked for renaming.  */
+
+static int eiisnan (short unsigned int *x)
+{
+  int i;
+
+  if( x[i] != 0 )
+    return(1);
+}
+
+static int eiisinf (unsigned short *x)
+{
+  if (eiisnan (x))
+    return (0);
+
+  if ((x[1] & 0x7fff) == 0x7fff)
+    return (1);
+}
+
+static void toe64(short unsigned int *a, short unsigned int *b)
+{
+  register unsigned short *p, *q;
+  unsigned short i;
+
+  q = b + 4;
+
+  if (eiisinf (a));
+
+  for( i=0; i<4; i++ )
+    *q-- = *p++;
+}
+
+static int asctoeg(short unsigned int *y, int oprec)
+{
+  unsigned short yy[13];
+  char *s;
+  
+  while( *s == ' ' )
+    ++s;
+  
+  toe64( yy, y );
+}
+
+long double _strtold (char *s, char **se)
+{
+  long double x;
+  asctoeg( (unsigned short *)&x, 64 );
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040430-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040430-1.c
new file mode 100644
index 000000000..4bc1f85ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040430-1.c
@@ -0,0 +1,26 @@
+/* PR middle-end/14470.  Similar to
+   gcc.c-torture/execute/20040313-1.c, but with a compile time test to
+   make sure the second if() is removed.  */
+/* Update: We now remove both ifs.  Whee. */
+
+/* { dg-do run } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+
+extern void abort(void);
+
+int main()
+{
+  int t[1025] = { 1024 }, d;
+
+  d = 0;
+  d = t[d]++;
+  if (t[0] != 1025)
+    abort();
+  if (d != 1024)
+    abort();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "if " 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040513-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040513-1.c
new file mode 100644
index 000000000..bc65b979d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040513-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-forwprop1" } */
+void bar (void);
+
+void
+foo (unsigned int a)
+{
+  if ((a >> 5) & 1)
+    bar ();
+}
+
+
+
+/* There should be no casts to a _Bool since we can use the temporary
+   holding (a>>5)&1 directly.  */
+/* { dg-final { scan-tree-dump-times "\\(_Bool\\)" 0 "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040513-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040513-2.c
new file mode 100644
index 000000000..a3edf9b80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040513-2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+int link_error(void);
+int s(void);
+
+int t(int i)
+{
+  _Bool g = i == 4;
+ int h = g;
+ _Bool j = h;
+ int k = j;
+ _Bool l = k == 0;
+ _Bool o = !l;
+ int m = o;
+
+ if (m)
+  if (i != 4)
+   return link_error();
+ return 0;
+}
+
+/* There should be no link_error calls, if there is any, the
+   optimization has failed */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040514-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040514-1.c
new file mode 100644
index 000000000..4c2835075
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040514-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-phiopt1-details" } */
+
+int t( int i)
+{
+  int j;
+  if(i ==0)
+  {
+   j = 1;
+   goto end;
+  }
+  j = 0;
+end:
+  return j;
+}
+
+/* Should have no ifs left after straightening.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "phiopt1"} } */
+/* { dg-final { cleanup-tree-dump "phiopt1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040514-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040514-2.c
new file mode 100644
index 000000000..d518cacd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040514-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-phiopt1" } */
+int
+foo2 (distance, i, j)
+     int distance;
+     int i, j;
+{
+ int t = distance;
+ if (t <= 0)
+   t = ((t) >= 0 ? (t)  : -(t));
+ return t;
+}
+
+/* There should be one ABS_EXPR and no conditionals.  */
+/* { dg-final { scan-tree-dump-times "ABS_EXPR " 1 "phiopt1"} } */
+/* { dg-final { scan-tree-dump-times "if " 0 "phiopt1"} } */
+/* { dg-final { cleanup-tree-dump "phiopt1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040517-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040517-1.c
new file mode 100644
index 000000000..99b27ce02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040517-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-alias-vops" } */
+extern void abort (void);
+int a; 
+ 
+extern void __attribute__ ((malloc)) *foo ();
+ 
+void bar (void) 
+{ 
+  a = 1; 
+  foo (); 
+  if (a) 
+    abort (); 
+} 
+
+/* We used to treat malloc functions like pure and const functions, but
+   malloc functions may clobber global memory.  Only the function result
+   does not alias any other pointer.
+   Hence, we must have a VDEF for a before and after the call to foo().  */
+/* { dg-final { scan-tree-dump-times "VDEF" 2 "alias"} } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040518-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040518-1.c
new file mode 100644
index 000000000..315a5ebf8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040518-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-phiopt1-details" } */
+int f(int a, int b)
+{
+   int c = b;
+   if (a != b)
+    c = a;
+   return c;
+}
+
+/* Should have no ifs left after straightening.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "phiopt1"} } */
+/* { dg-final { cleanup-tree-dump "phiopt1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040518-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040518-2.c
new file mode 100644
index 000000000..62f66232d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040518-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-phiopt1-details" } */
+
+int t( int i)
+{
+   int j;
+   if(i>=0)
+    j = i;
+   else
+    j = -i;
+   return j;
+}
+
+/* We should convert one COND_EXPRs into straightline code with ABS.  */
+/* { dg-final { scan-tree-dump-times "straightline" 1 "phiopt1"} } */
+/* { dg-final { scan-tree-dump-times "ABS_EXPR" 1 "phiopt1"} } */
+/* { dg-final { cleanup-tree-dump "phiopt1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040615-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040615-1.c
new file mode 100644
index 000000000..5bb7a4d7f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040615-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom1" } */
+  
+void bar1 (void);
+void bar2 (void);
+
+void
+foo (unsigned int a, unsigned int b)
+{
+  if (a >= b)
+    bar1 ();
+  else if (b <= a)
+    bar2 ();
+}
+
+/* { dg-final { scan-tree-dump-times "bar2" 0 "dom1" } } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040624-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040624-1.c
new file mode 100644
index 000000000..eb8e21095
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040624-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom1" } */
+  
+void bar1 (void);
+void bar2 (void);
+
+void
+foo (unsigned int a, unsigned int b)
+{
+  if (a >= b)
+    bar1 ();
+  else if (a <= b)
+    bar2 ();
+}
+
+/* The second conditional is redundant since we know it must be
+   true (to reach the second condition we know a < b via the first
+   conditional.  */
+
+/* { dg-final { scan-tree-dump-times "if " 1 "dom1" } } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040703-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040703-1.c
new file mode 100644
index 000000000..ad96198a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040703-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dom2" } */
+
+float foo(float x)
+{
+  x += 1;
+  x -= 1;
+  return x;
+}
+
+/* We should *not* fold the arithmetic.  */
+/* { dg-final { scan-tree-dump-times "0\\.0" 0 "dom2"} } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040713-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040713-1.c
new file mode 100644
index 000000000..78919d040
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040713-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-Os" } */
+
+/* Extracted from PR 16443.  Contributed by Volker Reichelt.
+   Scanning of __asm__ operands wasn't considering call-clobbered
+   variables discovered before the aliasing pass.  This was causing a
+   crash in verify_ssa() because 'p' was not being given an SSA_NAME.  */
+
+void foo(char *p)
+{
+    __asm__ ("" ::: "memory");
+}
+
+void bar()
+{
+    static char *p;
+    foo(p);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040721-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040721-1.c
new file mode 100644
index 000000000..1a6e36df8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040721-1.c
@@ -0,0 +1,29 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+/* Test to check whether global variables are being
+   constant propagated. */
+
+extern void link_error (void);
+
+int G;
+
+void
+foo (int i)
+{
+   if (i > 0)
+     G = 3;
+   else
+     G = 3;
+
+   if (G != 3)
+     link_error ();
+}
+
+int
+main ()
+{
+   foo (0);
+   return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040729-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040729-1.c
new file mode 100644
index 000000000..ef94096fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040729-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dce2" } */
+
+foo ()
+{
+  volatile int *p;
+  volatile int x;
+
+  p = &x;
+  *p = 3;
+  return *p + 1;
+}
+
+/* The assignment to 'p' is dead and should be removed.  But the
+   compiler was mistakenly thinking that the statement had volatile
+   operands.  But 'p' itself is not volatile and taking the address of
+   a volatile does not constitute a volatile operand.  */
+/* { dg-final { scan-tree-dump-times "&x" 0 "dce2"} } */
+/* { dg-final { cleanup-tree-dump "dce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040911-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040911-1.c
new file mode 100644
index 000000000..f17e98aed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20040911-1.c
@@ -0,0 +1,22 @@
+/* Verify that points-to information is handled properly for PTR + OFFSET
+   pointer arithmetics.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-alias-vops" } */
+
+char buf[4], *q;
+int foo (int i)
+{
+  char c, *p;
+  q = &c;
+  p = buf;
+  if (i)
+    p = p + 3;
+  else
+    p = p + 2;
+  *p = 6;
+  c = 8;
+  return *p;
+}
+
+/* { dg-final { scan-tree-dump-not "VUSE <c" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041002-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041002-1.c
new file mode 100644
index 000000000..9a07877fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041002-1.c
@@ -0,0 +1,24 @@
+/* PR tree-optimization/16632
+   fold() failed to see the following "if" statements never trigger.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ssa" } */
+
+int
+foo (int i)
+{
+  if ((i | 3) == 1)
+    return 1;
+  return 0;
+}
+
+int
+bar (int i)
+{
+  if ((i & 4) == 2)
+    return 1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "if" 0 "ssa" } } */
+/* { dg-final { cleanup-tree-dump "ssa" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041008-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041008-1.c
new file mode 100644
index 000000000..ca24427b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041008-1.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */ 
+/* { dg-options "-O2" } */
+
+struct A {
+    int x;
+    int y;
+};
+
+baz (struct A *a)
+{
+  a->x = 3;
+  a->y = 2;
+}
+
+foo (int i)
+{
+  struct A a;
+
+  /* Make sure we can't scalarize 'a'.  */
+  baz (&a);
+
+  if (i > 10)
+    a.x = i;
+  else
+    a.x = i;
+
+  /* Copy propagation should prove that this predicate is always false.  */
+  if (a.x != i)
+    link_error ();
+
+  return a.x;
+}
+
+main ()
+{
+  foo (30);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
new file mode 100644
index 000000000..825b2b41f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041110-1.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+/* This testcase was causing an ICE in building distance vectors because
+   we weren't ignoring the fact that one of the induction variables
+   involved in the dependence was outside of the loop.  */
+extern int foo (int, int);
+int
+main (void)
+{
+  int a[50];
+  int b[50];
+  int i, j, k;
+  for (i = 4; i < 30; i++)
+    {
+      for (j = 3; j < 40; j++)
+	{
+	  for (k = 9; k < 50; k++)
+	    {
+	      b[j] = a[i];
+	      a[k] = b[i];
+	    }
+	}
+    }
+  foo (a[i], b[i]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c
new file mode 100644
index 000000000..d72d133e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20041122-1.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dom2" } */
+
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+extern void *xmalloc (size_t) __attribute__ ((__malloc__));
+struct edge_def
+{
+  struct basic_block_def *dest;
+  int flags;
+};
+typedef struct edge_def *edge;
+struct basic_block_def
+{
+  int flags;
+};
+typedef struct basic_block_def *basic_block;
+extern int n_basic_blocks;
+extern edge frob ();
+void
+find_unreachable_blocks (int frobit)
+{
+  basic_block *tos, *worklist, bb;
+  tos = worklist = xmalloc (sizeof (basic_block) * n_basic_blocks);
+  edge e = frob();
+  if (!(e->dest->flags & 4))
+    {
+      e->dest->flags |= 4;
+      *tos++ = e->dest;
+    }
+}
+
+/* If the aliasing code does its job properly, then we should be
+   able to determine that modifying e->dest->flags does not
+   modify e or e->dest.  The net result is that we only need one
+   load of e->dest.  */
+/* { dg-final { scan-tree-dump-times "->dest" 1 "dom2" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050128-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050128-1.c
new file mode 100644
index 000000000..7197ec8b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050128-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+int
+foo (int align)
+{
+  int off = 0 % align;
+  return off ? align - off : 0;
+}
+
+/* We should have optimized away the mod operator before we gimpleized
+   the code.  */
+/* { dg-final { scan-tree-dump-times "%" 0 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050215-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050215-1.c
new file mode 100644
index 000000000..b9bb3a749
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050215-1.c
@@ -0,0 +1,14 @@
+/* PR middle-end/19857 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int i;
+int foo (void)
+{
+  return i & ~(unsigned int) 3;
+}
+
+/* Make sure the optimizers don't introduce overflow where one
+   did not exist in the original.  */
+/* { dg-final { scan-tree-dump-times "-0+4" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050314-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050314-1.c
new file mode 100644
index 000000000..04f202835
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050314-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-lim-details" } */
+
+float a[100];
+
+int foo(void);
+float sinf (float);
+
+void xxx (void)
+{
+  int i, k = foo ();
+
+  for (i = 0; i < 100; i++)
+    a[k] += sinf (i);
+}
+
+/* Store motion may be applied to the assignment to a[k], since sinf
+   cannot read nor write the memory.  */
+
+/* { dg-final { scan-tree-dump-times "Moving statement" 1 "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050412-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050412-1.c
new file mode 100644
index 000000000..9c172d769
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050412-1.c
@@ -0,0 +1,16 @@
+/* PR tree-optimization/14627 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+
+int b;
+void foo (int a) {
+	if (a)
+		a = 3;
+	b = a;
+}
+
+/* Make sure we do not have an assignment a = 0 in the resulting
+   optimized dump.  */
+/* { dg-final { scan-tree-dump-times "a.* = 0;" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050719-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050719-1.c
new file mode 100644
index 000000000..8dc4c7e5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20050719-1.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void) __attribute__ ((__nothrow__)) __attribute__
+((__noreturn__));
+extern void exit (int __status) __attribute__ ((__nothrow__))
+__attribute__ ((__noreturn__));
+
+struct bootLoader {
+  int x;
+};
+
+void
+zap(struct bootLoader *bootLoader)
+{
+  /* The expression on the RHS of the assignment is *not* a
+     dereference of pointer 'bootLoader'.  It is merely used as an
+     offset calculation.  VRP was erroneously removing the if()
+     because it thought that 'bootLoader' was always dereferenced.  */
+  int *boot = &bootLoader->x;
+
+  if (bootLoader)
+    {
+      useboot (boot);
+    }
+}
+
+int
+useboot (void *boot)
+{
+  abort ();
+}
+
+main()
+{
+  zap (0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20070302-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20070302-1.c
new file mode 100644
index 000000000..ab8e38e1d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20070302-1.c
@@ -0,0 +1,46 @@
+/* { dg-do link } */
+/* { dg-xfail-if "" { *-*-* } { "*" } { "" } }  See PR34743.  */
+/* { dg-options "-O2" } */
+
+struct A
+{
+  int x;
+  float y;
+};
+
+volatile float X, Y;
+
+int __attribute__ ((__noinline__))
+baz (struct A *z, struct A *y)
+{
+  z->x = (int) X;
+  z->y = Y;
+  y->x = (int) X;
+  y->y = Y;
+}
+
+
+struct A B;
+
+float foo (int i)
+{
+  struct A *p, x, y, z;
+
+  p = (i > 10) ? &x : &z;
+  x.y = 3.0;
+  p->x += baz (&z, &y);
+  X = z.y;
+  Y = p->y;
+
+  /* This predicate should always evaluate to false.  The call to
+     baz() is not a clobbering site for x.y.  The operand scanner was
+     considering it a clobbering site for x.y because x.y is in the
+     alias set of a call-clobbered memory tag.  */
+  if (x.y != 3.0)
+    link_error ();
+}
+
+main(int argc, char **argv)
+{
+  foo (argc);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20070815.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20070815.c
new file mode 100644
index 000000000..fa0e69f7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20070815.c
@@ -0,0 +1,60 @@
+/* { dg-do compile } */
+/* { dg-options "-O -w" } */
+
+/* This code snippet from glibc 2.3.5 was causing an ICE during
+   optimization because we were failing to update the SSA form for
+   stale name tags.  These are tags that are associated with SSA pointers
+   that have been removed from the IL.  This was causing the SSA
+   verifier to fail before we had a chance to run the cleanup pass that
+   finally removes all the remaining PHI nodes for the stale name tag.  */
+struct _IO_wide_data
+{
+};
+struct _IO_FILE {
+};
+typedef struct _IO_FILE _IO_FILE;
+struct _IO_jump_t
+{
+};
+struct _IO_FILE_plus
+{
+  _IO_FILE file;
+};
+extern const struct _IO_jump_t _IO_file_jumps_maybe_mmap ;
+extern const struct _IO_jump_t _IO_wfile_jumps;
+extern const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap ;
+
+_IO_new_fdopen (fd, mode)
+     const char *mode;
+{
+  int read_write;
+  int posix_mode = 0;
+  struct locked_FILE
+  {
+    struct _IO_FILE_plus fp;
+    struct _IO_wide_data wd;
+  } *new_f;
+  int fd_flags;
+  int use_mmap = 0;
+    {
+  }
+    {
+      switch (*++mode)
+ {
+ case '\0':
+   use_mmap = 1;
+ }
+    }
+  if (((fd_flags & 0003) == 00 && !(read_write & 8))
+      || ((fd_flags & 0003) == 01 && !(read_write & 4)))
+    {
+    }
+  if ((posix_mode & 02000) && !(fd_flags & 02000))
+    return ((void *)0);
+  _IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd,
+        (use_mmap && (read_write & 8))
+        ? &_IO_wfile_jumps_maybe_mmap :
+        &_IO_wfile_jumps);
+    (use_mmap && (read_write & 8)) ? &_IO_file_jumps_maybe_mmap :
+  _IO_file_init (&new_f->fp);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20080530.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20080530.c
new file mode 100644
index 000000000..6da7cb8a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/20080530.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-einline" } */
+
+void bar (char *);
+int i;
+
+static void
+foo (void)
+{
+  char *p = __builtin_alloca (i);
+  bar (p);
+}
+
+int
+baz (void)
+{
+  foo ();	/* foo() should not be inlined here because it calls alloca */
+  return 6;
+}
+
+/* { dg-final { scan-tree-dump-times "Inlining foo into baz" 0 "einline2"} } */
+/* { dg-final { cleanup-tree-dump "einline2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-1.c
new file mode 100644
index 000000000..6e88eb1ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-1.c
@@ -0,0 +1,17 @@
+/* { dg-options "-O2 -fargument-noalias-global -fdump-tree-optimized" } */
+int f;
+void link_error ();
+
+void g(int *i)
+{
+  *i = 0;
+  f = 1;
+  if (*i != 0)
+    link_error ();
+}
+
+
+/* We should have removed the link_error on the tree level as we told GCC
+   that *i cannot point to f via the option -fargument-noalias-global. */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-10.c
new file mode 100644
index 000000000..03956100a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-10.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct {
+	int i;
+	int x[2];
+	int j;
+} a;
+
+int foo(int i)
+{
+	a.i = 1;
+	a.j = 2;
+	a.x[i] = 0;
+	return a.i + a.j;
+}
+
+/* { dg-final { scan-tree-dump "return 3;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-11.c
new file mode 100644
index 000000000..cccc512cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-11.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct param { int *a; };
+void foo(struct param *p);
+int bar(void)
+{
+  int a[32];
+  struct param p;
+  a[0] = 1;
+  a[1] = 1;
+  p.a = &a[0];
+  foo(&p);
+  return a[0] + *p.a;
+}
+
+/* { dg-final { scan-tree-dump "return \\*p\\.a \\\+ a.0.;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-12.c
new file mode 100644
index 000000000..b1fb7997f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-12.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-alias-vops" } */
+
+struct {
+	int i;
+	int x[128];
+	int j;
+} a;
+
+int foo(int i)
+{
+	a.x[i] = 0;
+	return a.x[i];
+}
+
+/* { dg-final { scan-tree-dump "VDEF" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-13.c
new file mode 100644
index 000000000..ae7cc8214
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-13.c
@@ -0,0 +1,33 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+
+struct a
+{
+  char a1;
+};
+
+int *aa;
+
+void g(int *a)
+{
+  aa = a;
+  *a = 2;
+}
+
+int t(int i, struct a *b)
+{
+  g(&i);
+  b->a1 = 1;
+  i = 2;
+  if (b->a1 != 1)
+    link_failure ();
+}
+int main(void)
+{
+  struct a b;
+  t(1, &b);
+  return 0;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-14.c
new file mode 100644
index 000000000..a1216b7d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-14.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+struct s
+{
+  long long a:12;
+  long long b:12;
+  long long c:40;
+};
+
+struct s s, *p = &s;
+
+int
+main ()
+{
+  p->a = 1;
+  s.a = 0;
+  s.b = 0;
+  return p->a + s.b;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-15.c
new file mode 100644
index 000000000..617af0fd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-15.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fno-early-inlining -fdump-tree-alias-vops-details" } */
+
+struct foo {
+  int a;
+  struct X {
+    int b[4];
+  } b;
+} m;
+static inline struct X *wrap(struct X *p) { return p; }
+int test2(void)
+{
+  struct X *p = wrap(&m.b);
+  /* Both memory references need to alias the same tags.  */
+  return p->b[3] - m.b.b[3];
+}
+
+/* { dg-final { scan-tree-dump-times "VUSE <m_.\\\(D\\\)>" 2 "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-16.c
new file mode 100644
index 000000000..cf10fa913
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-16.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-O --param max-aliased-vops=1" } */
+
+/* Compile with -O --param max-aliased-vops=1.  This partitions all
+   the initial SFTs for 'm' which was causing the operand scanner to
+   miss adding the right SFTs to p->b[2].  */
+extern void abort (void);
+
+struct X {
+    int a;
+    struct Y {
+	int b[4];
+    } b;
+    struct Y c;
+} m;
+
+struct X n;
+
+foo (int i)
+{
+  struct Y *p = (i > 10) ? &m.b : &n.c;
+  p->b[2] = 10;
+  m.b.b[3] = 6;
+  n.c.b[2] = 3;
+  return p->b[2] + n.c.b[2] + m.b.b[3];
+}
+
+main()
+{
+  if (foo (3) != 12)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-17.c
new file mode 100644
index 000000000..48e72ffee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-17.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fno-early-inlining -fdump-tree-ccp2" } */
+
+int *p;
+int inline bar(void) { return 0; }
+int foo(int x)
+{
+  int i;
+  int *q;
+  if (bar())
+    q = &i;
+  else
+    q = p;
+  return *q + *p;
+}
+
+/* { dg-final { scan-tree-dump-not "NOTE: no flow-sensitive alias info for" "ccp2" } } */
+/* { dg-final { cleanup-tree-dump "ccp2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-18.c
new file mode 100644
index 000000000..84d884eff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-18.c
@@ -0,0 +1,90 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fre-details -fdump-tree-optimized --param max-aliased-vops=0" } */
+
+struct A {
+  int i;
+  int j;
+  float x;
+};
+struct B {
+  struct A a;
+  int k;
+};
+
+int g;
+
+int test0 (struct A *p, struct A *q)
+{
+  p->i = 0;
+  q->j = -1;
+  return p->i;
+}
+
+int test1 (struct A *p, struct B *q)
+{
+  p->i = 1;
+  q->k = -1;
+  return p->i;
+}
+
+int test2 (struct A *p, struct B *q)
+{
+  p->i = 2;
+  q->a.i = -1;
+  return p->i;
+}
+
+int test3 (struct A *p, struct B *q)
+{
+  p->i = 3;
+  q->a.j = -1;
+  return p->i;
+}
+
+int test4 (struct A *p)
+{
+  g = 4;
+  p->i = -1;
+  return g;
+}
+
+int test5 (struct A *p)
+{
+  p->i = 5;
+  g = -1;
+  return p->i;
+}
+
+int test6 (struct A *p, int *q)
+{
+  p->i = 6;
+  *q = -1;
+  return p->i;
+}
+
+int test7 (struct A *p, int *q)
+{
+  p->j = 7;
+  *q = -1;
+  return p->j;
+}
+
+int test8 (struct A *p, int *q)
+{
+  *q = 8;
+  p->x = -1;
+  return *q;
+}
+
+/* { dg-final { scan-tree-dump "with 0" "fre" } } */
+/* { dg-final { scan-tree-dump "with 1" "fre" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump "with 3" "fre" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump "with 4" "fre" } } */
+/* { dg-final { scan-tree-dump "with 5" "fre" } } */
+/* { dg-final { scan-tree-dump "with 8" "fre" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-not "return 2;" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "return 6;" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "return 7;" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "return -1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-19.c
new file mode 100644
index 000000000..b92df4343
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-19.c
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fdump-tree-alias-vops" } */
+
+const static int a;
+
+int __attribute__((noinline))
+foo(int i)
+{
+  const int *q;
+  int b;
+  if (i)
+    q = &a;
+  else
+    q = &b;
+  b = 1;
+  /* We should not prune a from the points-to set of q.  */
+  return *q;
+}
+
+extern void abort (void);
+int main()
+{
+  if (foo(1) != 0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "q_. = { a b }" "alias" } } */
+/* { dg-final { scan-tree-dump "q_., name memory tag: NMT..., is dereferenced, points-to vars: { a b }" "alias" } } */
+/* { dg-final { scan-tree-dump "# VUSE <a_.\\\(D\\\), b_.>" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-2.c
new file mode 100644
index 000000000..ecd0fdc9f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-2.c
@@ -0,0 +1,28 @@
+/* { dg-do compile { target { nonpic } } } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+static int a;
+int f;
+void bar (void)  __attribute__((noinline));
+void bar (void)
+{
+  f = 9;
+}
+
+void link_error ();
+
+int foo()
+{
+  int b, c;
+  a = 5;
+  b = a;
+  bar ();
+  b = b + a;
+  if (b != 10)
+    link_error ();
+  return b;
+}
+
+/* We should have removed the link_error on the tree level as GCC can tell that
+   a is not touched by the calling bar at all. */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-3.c
new file mode 100644
index 000000000..3d8587da8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-3.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct {
+	int i;
+	int j;
+	int x[2];
+} a;
+
+int foo(void)
+{
+	a.i = 1;
+	a.j = 0;
+	a.x[0] = 0;
+	return a.i + a.j;
+}
+
+/* { dg-final { scan-tree-dump "return 1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-4.c
new file mode 100644
index 000000000..e0394327d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct {
+	int i;
+	struct {
+		int x[2];
+	} b;
+} a;
+
+int foo(void)
+{
+	a.i = 1;
+	a.b.x[0] = 0;
+	a.b.x[1] = 1;
+	return a.i + a.b.x[0];
+}
+
+/* { dg-final { scan-tree-dump "return 1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-5.c
new file mode 100644
index 000000000..f1faae52c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-5.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct {
+	int i;
+	struct {
+		struct {
+			int i;
+		} x[2];
+	} b;
+} a;
+
+int foo(void)
+{
+	a.i = 1;
+	a.b.x[0].i = 0;
+	a.b.x[1].i = 1;
+	return a.i + a.b.x[0].i;
+}
+
+/* { dg-final { scan-tree-dump "return 1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-6.c
new file mode 100644
index 000000000..460dd11cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-6.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct param { int *a; };
+void foo(struct param *p);
+int bar(void)
+{
+  int a[2];
+  struct param p;
+  a[0] = 1;
+  a[1] = 1;
+  p.a = &a[0];
+  foo(&p);
+  return a[0] + *p.a;
+}
+
+/* { dg-final { scan-tree-dump "return \\*p\\.a \\\+ a.0.;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-7.c
new file mode 100644
index 000000000..7ef604be2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-7.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort(void);
+int main()
+{
+  int a[2];
+  int *p = a;
+  int i;
+  a[0] = 1;
+  a[1] = 2;
+  for (i=0; i<2; ++i)
+    if (p[i] != i+1)
+      abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-8.c
new file mode 100644
index 000000000..7c825f965
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-8.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort(void);
+int main()
+{
+  int a[2];
+  int i = 1;
+  a[0] = 1;
+  a[1] = 2;
+  if (*(a + i) != 2)
+    abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-9.c
new file mode 100644
index 000000000..0a20e0543
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/alias-9.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort(void);
+int main()
+{
+  int a[32];
+  int i = 1;
+  a[0] = 1;
+  a[1] = 2;
+  if (*(a + i) != 2)
+    abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/andor-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/andor-1.c
new file mode 100644
index 000000000..1a5385740
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/andor-1.c
@@ -0,0 +1,65 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+unsigned int test1(unsigned int a)
+{
+  return (a & 1) | 1;
+}
+
+int test2(int b)
+{
+  return (b & 1) | 1;
+}
+
+unsigned int test3(unsigned int c)
+{
+  return (c | 1) & 1;
+}
+
+int test4(int d)
+{
+  return (d | 1) & 1;
+}
+
+unsigned int test5(unsigned int e)
+{
+  return (e | 4) & 6;
+}
+
+int test6(int f)
+{
+  return (f | 4) & 6;
+}
+
+unsigned int test7(unsigned int g)
+{
+  return (g & -2) | 1;
+}
+
+int test8(int h)
+{
+  return (h & -2) | 1;
+}
+
+unsigned int test9(unsigned int i)
+{
+  return (i & 3) | 1;
+}
+
+int test10(int j)
+{
+  return (j & 3) | 1;
+}
+
+/* { dg-final { scan-tree-dump-times "a \& 1 \\| 1" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "b \& 1 \\| 1" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(c \\| 1\\) \& 1" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "\\(d \\| 1\\) \& 1" 0 "original" } } */
+/* { dg-final { scan-tree-dump-times "e \& 2 \\| 4" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "f \& 2 \\| 4" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "g \\| 1" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "h \\| 1" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "i \& 2 \\| 1" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "j \& 2 \\| 1" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/andor-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/andor-2.c
new file mode 100644
index 000000000..cdc00b7a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/andor-2.c
@@ -0,0 +1,52 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+int test1(int a, int b)
+{
+  return (a & b) | b;
+}
+
+int test2(int c, int d)
+{
+  return (c & d) | c;
+}
+
+int test3(int e, int f)
+{
+  return e | (e & f);
+}
+
+int test4(int g, int h)
+{
+  return g | (h & g);
+}
+
+int test5(int i, int j)
+{
+  return (i | j) & j;
+}
+
+int test6(int k, int l)
+{
+  return (k | l) & k;
+}
+
+int test7(int m, int n)
+{
+  return m & (m | n);
+}
+
+int test8(int o, int p)
+{
+  return o & (p | o);
+}
+
+/* { dg-final { scan-tree-dump-times "return b;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return c;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return e;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return g;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return j;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return k;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return m;" 1 "original" } } */
+/* { dg-final { scan-tree-dump-times "return o;" 1 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-1.c
new file mode 100644
index 000000000..64026287c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-1.c
@@ -0,0 +1,17 @@
+/* Make sure that gcc understands that an in/out operand is a use as well
+   as a def.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+void f()
+{
+  int i = 42;
+  int j = 63;
+  
+  asm ("": "=m"(i), "+r"(j) : "m"(i));
+}
+
+/* { dg-final { scan-tree-dump-times "42" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "63" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-2.c
new file mode 100644
index 000000000..c67b9b53f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+#ifdef __hppa__
+#define REGISTER "1"
+#else
+#define REGISTER "0"
+#endif
+
+void baz(void)
+{
+	register int xyzzy asm(REGISTER) = 1;
+	asm volatile ("" : : "r"(xyzzy));
+}
+
+/* { dg-final { scan-tree-dump-times "asm\[^\\r\\n\]*xyzzy" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-3.c
new file mode 100644
index 000000000..fdcddb7a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/asm-3.c
@@ -0,0 +1,32 @@
+/* PR 17739 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+#ifdef __hppa__
+#define REGISTER "1"
+#else
+#define REGISTER "0"
+#endif
+
+static inline int source(void)
+{
+  register int hardreg __asm__(REGISTER);
+  asm("" : "=r"(hardreg));
+  return hardreg;
+}
+                                                                                
+void test(void)
+{
+  int t = source();
+  foo(t);
+  bar(t);
+}
+
+/* Hardreg should appear exactly 3 times -- declaration, asm stmt,
+   and copy out.  */
+/* { dg-final { scan-tree-dump-times "hardreg" 3 "optimized" } } */
+
+/* In particular, hardreg should *not* appear in the call to bar.  */
+/* { dg-final { scan-tree-dump-times "bar \[(\]t\[)\]" 1 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-1.c
new file mode 100644
index 000000000..d6e121ae0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  if (x != 0)
+   return 1;
+  return 0;
+}
+
+/* There should be no != 0 which is produced by the front-end as
+   bool_var != 0 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "!= 0" 0 "optimized"} } */
+
+/* There should be no adde for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "adde" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-10.c
new file mode 100644
index 000000000..d7bf20da8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-10.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  return (x != 1);
+}
+
+/* There should be no != 1 which is produced by the front-end as
+   bool_var != 1 is the same as !bool_var. */
+/* { dg-final { scan-tree-dump-times "!= 1" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "!x" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-11.c
new file mode 100644
index 000000000..8d88b7e87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-11.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  return (x == 0);
+}
+
+/* There should be no == 0 which is produced by the front-end as
+   bool_var == 0 is the same as !bool_var. */
+/* { dg-final { scan-tree-dump-times "== 0" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "!x" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-2.c
new file mode 100644
index 000000000..0f88b0965
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  int y;
+  if (x)
+    y = 1;
+  else
+    y = 0;
+  return y;
+}
+
+/* There should be no != 0 which is produced by the front-end as
+   bool_var != 0 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "!= 0" 0 "optimized"} } */
+
+/* There should be no adde for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "adde" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-3.c
new file mode 100644
index 000000000..8fa2a57c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-3.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  int y;
+  if (!x)
+    y = 0;
+  else
+    y = 1;
+  return y;
+}
+
+/* There should be no == 0.  Though PHI-OPT or invert_truth does not
+   fold its tree forwprop is able to clean up the mess.  */
+/* { dg-final { scan-tree-dump-times "== 0" 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-4.c
new file mode 100644
index 000000000..b06182e2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-4.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  return (x != 0);
+}
+
+/* There should be no != 0 which is produced by the front-end as
+   bool_var != 0 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "!= 0" 0 "optimized"} } */
+
+/* There should be no adde for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "adde" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-5.c
new file mode 100644
index 000000000..e33ce9c73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-5.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  if (x == 1)
+   return 1;
+  return 0;
+}
+
+/* There should be no == 1 which is produced by the front-end as
+   bool_var == 1 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "== 1" 0 "optimized"} } */
+
+/* There should be no adde for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "adde" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-6.c
new file mode 100644
index 000000000..cc77591c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-6.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  int y;
+  if (x)
+    y = 1;
+  else
+    y = 0;
+  return y;
+}
+
+/* There should be no == 1 which is produced by the front-end as
+   bool_var == 1 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "== 1" 0 "optimized"} } */
+
+/* There should be no adde for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "adde" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-7.c
new file mode 100644
index 000000000..b79871064
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  int y;
+  if (x != 1)
+    y = 0;
+  else
+    y = 1;
+  return y;
+}
+
+/* There should be no != 1. Fold changes x != 1 to ! x.  */
+/* { dg-final { scan-tree-dump-times "!= 1" 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-8.c
new file mode 100644
index 000000000..527525270
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-8.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(_Bool x)
+{
+  return (x == 1);
+}
+
+/* There should be no == 1 which is produced by the front-end as
+   bool_var == 1 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "== 1" 0 "optimized"} } */
+
+/* There should be no adde for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "adde" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-9.c
new file mode 100644
index 000000000..2660b2580
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/bool-9.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+_Bool f1(_Bool x)
+{
+  return !!x;
+}
+
+/* There should be no != 0 which is produced by the front-end as
+   bool_var != 0 is the same as bool_var. */
+/* { dg-final { scan-tree-dump-times "!= 0" 0 "optimized"} } */
+
+/* There should be no subfe for powerpc.  Check if we actually optimized
+   away the comparison.  */
+/* { dg-final { scan-assembler-times "subfe" 0 { target powerpc*-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-1.c
new file mode 100644
index 000000000..42d4b0dd8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+f (int i, float j) 
+{ 
+  if (__builtin_expect (i > 0 && j, 0)) 
+    g ();
+} 
+
+/* { dg-final { scan-tree-dump-times {builtin_expect[^\n]*, 0\);\n[^\n]*if} 2 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-2.c
new file mode 100644
index 000000000..ff175b975
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+f (int i, float j) 
+{ 
+  if (__builtin_expect (i > 0 || j, 0))
+    ;
+  else
+    g ();
+} 
+
+/* { dg-final { scan-tree-dump-times {builtin_expect[^\n]*, 0\);\n[^\n]*if} 2 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-3.c
new file mode 100644
index 000000000..8fcc4e2bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+f (int i, float j) 
+{ 
+  if (__builtin_expect (i > 0 && j, 0))
+    a ();
+  else
+    b ();
+} 
+
+/* { dg-final { scan-tree-dump-times {builtin_expect[^\n]*, 0\);\n[^\n]*if} 2 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-4.c
new file mode 100644
index 000000000..1fecf1b98
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-4.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+f (int i, float j) 
+{ 
+  if (__builtin_expect (i > 0 || j, 0))
+    a ();
+  else
+    b ();
+} 
+
+/* { dg-final { scan-tree-dump-times {builtin_expect[^\n]*, 0\);\n[^\n]*if} 2 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-5.c
new file mode 100644
index 000000000..ed53b287b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-expect-5.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop" } */
+
+f (int i, float j) 
+{ 
+  if (__builtin_expect (i > 0 && __builtin_expect (j != 0, 1), 0))
+    a ();
+  else
+    b ();
+} 
+
+/* { dg-final { scan-tree-dump-times { if } 2 "forwprop1"} } */
+/* { dg-final { scan-tree-dump {builtin_expect[^\n]*, 0\);\n[^\n]*if} "forwprop1"} } */
+/* { dg-final { scan-tree-dump {builtin_expect[^\n]*, 1\);\n[^\n]*if} "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop?" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-fprintf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-fprintf-1.c
new file mode 100644
index 000000000..b08e1242b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-fprintf-1.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+typedef struct { int i; } FILE;
+FILE *fp;
+extern int fprintf (FILE *, const char *, ...);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9;
+
+void test (void)
+{
+  vi0 = 0;
+  fprintf (fp, "hello");
+  vi1 = 0;
+  fprintf (fp, "hello\n");
+  vi2 = 0;
+  fprintf (fp, "a");
+  vi3 = 0;
+  fprintf (fp, "");
+  vi4 = 0;
+  fprintf (fp, "%s", "hello");
+  vi5 = 0;
+  fprintf (fp, "%s", "hello\n");
+  vi6 = 0;
+  fprintf (fp, "%s", "a");
+  vi7 = 0;
+  fprintf (fp, "%c", 'x');
+  vi8 = 0;
+  fprintf (fp, "%d%d", vi0, vi1);
+  vi9 = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*fwrite.*\"hello\".*1, 5, fp.*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*fwrite.*\"hello\\\\n\".*1, 6, fp.*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*fputc.*fp.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*fwrite.*\"hello\".*1, 5, fp.*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*fwrite.*\"hello\\\\n\".*1, 6, fp.*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*fputc.*fp.*vi7" "fab"} } */
+/* { dg-final { scan-tree-dump "vi7.*fputc.*fp.*vi8" "fab"} } */
+/* { dg-final { scan-tree-dump "vi8.*fprintf.*fp.*\"%d%d\".*vi9" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-fprintf-chk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-fprintf-chk-1.c
new file mode 100644
index 000000000..93e38cb9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-fprintf-chk-1.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+typedef struct { int i; } FILE;
+FILE *fp;
+extern int __fprintf_chk (FILE *, int, const char *, ...);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9;
+
+void test (void)
+{
+  vi0 = 0;
+  __fprintf_chk (fp, 1, "hello");
+  vi1 = 0;
+  __fprintf_chk (fp, 1, "hello\n");
+  vi2 = 0;
+  __fprintf_chk (fp, 1, "a");
+  vi3 = 0;
+  __fprintf_chk (fp, 1, "");
+  vi4 = 0;
+  __fprintf_chk (fp, 1, "%s", "hello");
+  vi5 = 0;
+  __fprintf_chk (fp, 1, "%s", "hello\n");
+  vi6 = 0;
+  __fprintf_chk (fp, 1, "%s", "a");
+  vi7 = 0;
+  __fprintf_chk (fp, 1, "%c", 'x');
+  vi8 = 0;
+  __fprintf_chk (fp, 1, "%d%d", vi0, vi1);
+  vi9 = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*fwrite.*\"hello\".*1, 5, fp.*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*fwrite.*\"hello\\\\n\".*1, 6, fp.*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*fputc.*fp.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*fwrite.*\"hello\".*1, 5, fp.*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*fwrite.*\"hello\\\\n\".*1, 6, fp.*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*fputc.*fp.*vi7" "fab"} } */
+/* { dg-final { scan-tree-dump "vi7.*fputc.*fp.*vi8" "fab"} } */
+/* { dg-final { scan-tree-dump "vi8.*__fprintf_chk.*fp.*1.*\"%d%d\".*vi9" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-printf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-printf-1.c
new file mode 100644
index 000000000..a78d0880c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-printf-1.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+extern int printf (const char *, ...);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9, via;
+
+void test (void)
+{
+  vi0 = 0;
+  printf ("hello");
+  vi1 = 0;
+  printf ("hello\n");
+  vi2 = 0;
+  printf ("a");
+  vi3 = 0;
+  printf ("");
+  vi4 = 0;
+  printf ("%s", "hello");
+  vi5 = 0;
+  printf ("%s", "hello\n");
+  vi6 = 0;
+  printf ("%s", "a");
+  vi7 = 0;
+  printf ("%s", "");
+  vi8 = 0;
+  printf ("%c", 'x');
+  vi9 = 0;
+  printf ("%s\n", "hello\n");
+  via = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*printf.*\"hello\".*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*puts.*\"hello\".*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*putchar.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*printf.*\"hello\".*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*puts.*\"hello\".*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*putchar.*vi7" "fab"} } */
+/* { dg-final { scan-tree-dump "vi7 ={v} 0\[^\(\)\]*vi8 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi8.*putchar.*vi9" "fab"} } */
+/* { dg-final { scan-tree-dump "vi9.*puts.*\"hello\\\\n\".*via" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-printf-chk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-printf-chk-1.c
new file mode 100644
index 000000000..2f85b28ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-printf-chk-1.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+extern int __printf_chk (int, const char *, ...);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9, via;
+
+void test (void)
+{
+  vi0 = 0;
+  __printf_chk (1, "hello");
+  vi1 = 0;
+  __printf_chk (1, "hello\n");
+  vi2 = 0;
+  __printf_chk (1, "a");
+  vi3 = 0;
+  __printf_chk (1, "");
+  vi4 = 0;
+  __printf_chk (1, "%s", "hello");
+  vi5 = 0;
+  __printf_chk (1, "%s", "hello\n");
+  vi6 = 0;
+  __printf_chk (1, "%s", "a");
+  vi7 = 0;
+  __printf_chk (1, "%s", "");
+  vi8 = 0;
+  __printf_chk (1, "%c", 'x');
+  vi9 = 0;
+  __printf_chk (1, "%s\n", "hello\n");
+  via = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*__printf_chk.*1.*\"hello\".*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*puts.*\"hello\".*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*putchar.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*__printf_chk.*1.*\"hello\".*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*puts.*\"hello\".*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*putchar.*vi7" "fab"} } */
+/* { dg-final { scan-tree-dump "vi7 ={v} 0\[^\(\)\]*vi8 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi8.*putchar.*vi9" "fab"} } */
+/* { dg-final { scan-tree-dump "vi9.*puts.*\"hello\\\\n\".*via" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vfprintf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vfprintf-1.c
new file mode 100644
index 000000000..1083f13bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vfprintf-1.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+#include <stdarg.h>
+
+typedef struct { int i; } FILE;
+FILE *fp;
+extern int vfprintf (FILE *, const char *, va_list);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9, via;
+
+void
+test (va_list ap1, va_list ap2, va_list ap3, va_list ap4, va_list ap5,
+      va_list ap6, va_list ap7)
+{
+  vi0 = 0;
+  vfprintf (fp, "hello", ap1);
+  vi1 = 0;
+  vfprintf (fp, "hello\n", ap2);
+  vi2 = 0;
+  vfprintf (fp, "a", ap3);
+  vi3 = 0;
+  vfprintf (fp, "", ap4);
+  vi4 = 0;
+  vfprintf (fp, "%s", ap5);
+  vi5 = 0;
+  vfprintf (fp, "%c", ap6);
+  vi6 = 0;
+  vfprintf (fp, "%s\n", ap7);
+  vi7 = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*fwrite.*\"hello\".*1, 5, fp.*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*fwrite.*\"hello\\\\n\".*1, 6, fp.*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*fputc.*fp.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*vfprintf.*\"%s\".*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*vfprintf.*\"%c\".*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*vfprintf.*\"%s\\\\n\".*vi7" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vfprintf-chk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vfprintf-chk-1.c
new file mode 100644
index 000000000..ce767d1a1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vfprintf-chk-1.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+#include <stdarg.h>
+
+typedef struct { int i; } FILE;
+FILE *fp;
+extern int __vfprintf_chk (FILE *, int, const char *, va_list);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9, via;
+
+void
+test (va_list ap1, va_list ap2, va_list ap3, va_list ap4, va_list ap5,
+      va_list ap6, va_list ap7)
+{
+  vi0 = 0;
+  __vfprintf_chk (fp, 1, "hello", ap1);
+  vi1 = 0;
+  __vfprintf_chk (fp, 1, "hello\n", ap2);
+  vi2 = 0;
+  __vfprintf_chk (fp, 1, "a", ap3);
+  vi3 = 0;
+  __vfprintf_chk (fp, 1, "", ap4);
+  vi4 = 0;
+  __vfprintf_chk (fp, 1, "%s", ap5);
+  vi5 = 0;
+  __vfprintf_chk (fp, 1, "%c", ap6);
+  vi6 = 0;
+  __vfprintf_chk (fp, 1, "%s\n", ap7);
+  vi7 = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*fwrite.*\"hello\".*1, 5, fp.*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*fwrite.*\"hello\\\\n\".*1, 6, fp.*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*fputc.*fp.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*__vfprintf_chk.*fp.*1.*\"%s\".*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*__vfprintf_chk.*fp.*1.*\"%c\".*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*__vfprintf_chk.*fp.*1.*\"%s\\\\n\".*vi7" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vprintf-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vprintf-1.c
new file mode 100644
index 000000000..416ee5b54
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vprintf-1.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+#include <stdarg.h>
+
+extern int vprintf (const char *, va_list);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9, via;
+
+void
+test (va_list ap1, va_list ap2, va_list ap3, va_list ap4, va_list ap5,
+      va_list ap6, va_list ap7)
+{
+  vi0 = 0;
+  vprintf ("hello", ap1);
+  vi1 = 0;
+  vprintf ("hello\n", ap2);
+  vi2 = 0;
+  vprintf ("a", ap3);
+  vi3 = 0;
+  vprintf ("", ap4);
+  vi4 = 0;
+  vprintf ("%s", ap5);
+  vi5 = 0;
+  vprintf ("%c", ap6);
+  vi6 = 0;
+  vprintf ("%s\n", ap7);
+  vi7 = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*vprintf.*\"hello\".*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*puts.*\"hello\".*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*putchar.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*vprintf.*\"%s\".*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*vprintf.*\"%c\".*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*vprintf.*\"%s\\\\n\".*vi7" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vprintf-chk-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vprintf-chk-1.c
new file mode 100644
index 000000000..567a3dfd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/builtin-vprintf-chk-1.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-fab" } */
+
+#include <stdarg.h>
+
+extern int __vprintf_chk (int, const char *, va_list);
+volatile int vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7, vi8, vi9, via;
+
+void
+test (va_list ap1, va_list ap2, va_list ap3, va_list ap4, va_list ap5,
+      va_list ap6, va_list ap7)
+{
+  vi0 = 0;
+  __vprintf_chk (1, "hello", ap1);
+  vi1 = 0;
+  __vprintf_chk (1, "hello\n", ap2);
+  vi2 = 0;
+  __vprintf_chk (1, "a", ap3);
+  vi3 = 0;
+  __vprintf_chk (1, "", ap4);
+  vi4 = 0;
+  __vprintf_chk (1, "%s", ap5);
+  vi5 = 0;
+  __vprintf_chk (1, "%c", ap6);
+  vi6 = 0;
+  __vprintf_chk (1, "%s\n", ap7);
+  vi7 = 0;
+}
+
+/* { dg-final { scan-tree-dump "vi0.*__vprintf_chk.*1.*\"hello\".*vi1" "fab"} } */
+/* { dg-final { scan-tree-dump "vi1.*puts.*\"hello\".*vi2" "fab"} } */
+/* { dg-final { scan-tree-dump "vi2.*putchar.*vi3" "fab"} } */
+/* { dg-final { scan-tree-dump "vi3 ={v} 0\[^\(\)\]*vi4 ={v} 0" "fab"} } */
+/* { dg-final { scan-tree-dump "vi4.*__vprintf_chk.*1.*\"%s\".*vi5" "fab"} } */
+/* { dg-final { scan-tree-dump "vi5.*__vprintf_chk.*1.*\"%c\".*vi6" "fab"} } */
+/* { dg-final { scan-tree-dump "vi6.*__vprintf_chk.*1.*\"%s\\\\n\".*vi7" "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/cfgcleanup-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/cfgcleanup-1.c
new file mode 100644
index 000000000..e86a6484e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/cfgcleanup-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-dce1" } */
+void
+cleanup (int a, int b)
+{
+  if (a)
+    if (b)
+      a = 1;
+    else
+      b = 1;
+  else if (a)
+    a = 1;
+  else
+    b = 1;
+  return;
+}
+/* Dce should get rid of the initializers and cfgcleanup should elliminate ifs  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dce1"} } */
+/* { dg-final { cleanup-tree-dump "dce1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-1.c
new file mode 100644
index 000000000..7c76467f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-1.c
@@ -0,0 +1,13 @@
+/* Verify that we don't libcall for complex * real.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -O -fdump-tree-optimized" } */
+
+typedef _Complex float C;
+
+C foo(C x, float y)
+{
+  return x * y;
+}
+
+/* { dg-final { scan-tree-dump-times "__mul" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-2.c
new file mode 100644
index 000000000..d2d42b93d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-2.c
@@ -0,0 +1,13 @@
+/* Verify that we don't libcall for complex / real.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -O -fdump-tree-optimized" } */
+
+typedef _Complex float C;
+
+C foo(C x, float y)
+{
+  return x / y;
+}
+
+/* { dg-final { scan-tree-dump-times "__div" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-3.c
new file mode 100644
index 000000000..5f4b110c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-3.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+typedef _Complex float COMPLEX_FLOAT;
+float real_part(COMPLEX_FLOAT a)
+{
+  return *(float*)(&a);
+}
+
+float real_part_2(COMPLEX_FLOAT a)
+{
+  return ((float*)(&a))[0];
+}
+
+
+float imag_part(COMPLEX_FLOAT a)
+{
+  return ((float*)(&a))[1];
+}
+
+/* Test that the above gets optimized to REALPART_EXPR and IMAGPART_EXPR
+   respectively. */
+
+/* { dg-final { scan-tree-dump-times "REALPART_EXPR" 2 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "IMAGPART_EXPR" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-4.c
new file mode 100644
index 000000000..fa2ad5816
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-4.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int g(_Complex int*);
+int f(void)
+{
+  _Complex int t = 0;
+  int i, j;
+ __real__ t += 2;
+ __imag__ t += 2;
+  return g(&t);
+}
+
+/* { dg-final { scan-tree-dump-times "__complex__" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-5.c
new file mode 100644
index 000000000..dec394a5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/complex-5.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-tree-dce -fdump-tree-optimized" } */
+_Complex int t = 0;
+int f(void)
+{
+  t = 0;
+ __real__ t = 2;
+ __imag__ t = 2;
+}
+
+/* { dg-final { scan-tree-dump-times "__complex__" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/copy-headers.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/copy-headers.c
new file mode 100644
index 000000000..474633eab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/copy-headers.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-ch-details" } */
+
+extern int foo (int);
+
+void bla (void)
+{
+  int i, n = foo (0);
+
+  for (i = 0; i < n; i++)
+    foo (i);
+}
+
+/* There should be a header duplicated.  */
+/* { dg-final { scan-tree-dump-times "Duplicating header" 1 "ch"} } */
+/* { dg-final { cleanup-tree-dump "ch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/cswtch.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/cswtch.c
new file mode 100644
index 000000000..06710f217
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/cswtch.c
@@ -0,0 +1,81 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-switchconv" } */
+/* { dg-do run } */
+
+extern void abort (void);
+
+static int X, Y;
+
+int check(int param)
+{
+  int a = 0;
+  int b = 1;
+  
+  switch (param) 
+    {
+    case -2:
+      a = 0;
+      b = -1;
+      break;
+    case 1:
+    case 2:
+      a = 8;
+      b = 6;
+      break;
+    case 3:
+      a = 9;
+      b = 5;
+      break;
+    case 6:
+      a = 10;
+      b = 4;
+      break;
+    default:
+      a = 16;
+      b = 1;
+    }
+  
+  X = a;
+  Y = b;
+  return 0;
+}
+
+void assertions(int a, int b)
+{
+  if (X != a || Y != b)
+    abort();  
+
+  return;
+}
+
+int main ()
+{
+  check (-10);
+  assertions (16, 1);
+
+  check (-2);
+  assertions (0, -1);
+
+  check(1);
+  assertions (8, 6);
+
+  check(2);
+  assertions (8, 6);
+
+  check(3);
+  assertions (9, 5);
+
+  check(5);
+  assertions (16, 1);
+
+  check(6);
+  assertions (10, 4);
+
+  check(12);
+  assertions (16, 1);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "Switch converted" "switchconv" } } */
+/* { dg-final { cleanup-tree-dump "switchconv" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
new file mode 100644
index 000000000..54153966a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/data-dep-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile { target int32plus } } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+
+int foo (int n, int m)
+{
+  int a[10000][10000];
+  int i, j, k;
+
+  for(k = 0; k < 1234; k++)
+    for(j = 0; j < 5; j++)
+      for(i = 0; i < 67; i++)
+	{
+	  a[j+i-(-m+n+3)][i-k+4] = a[k+j][i];
+	}
+
+  return a[0][0];
+}
+
+
+/* For the data dependence analysis of the outermost loop, the
+   evolution of "k+j" should be instantiated in the outermost loop "k"
+   and the evolution should be taken in the innermost loop "i".  The
+   pattern below ensures that the evolution is not computed in the
+   outermost "k" loop: the 4 comes from the instantiation of the
+   number of iterations of loop "j".  */
+
+/* { dg-final { scan-tree-dump-times "\\\{4, \\+, 1\\\}" 0 "ltrans" } } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-1.c
new file mode 100644
index 000000000..fdd3f44e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fstrict-overflow -fdump-tree-optimized" } */
+
+int f(int a)
+{
+  return (-a)/10;
+}
+
+
+/* { dg-final { scan-tree-dump-times "-a / 10" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a / -10" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-2.c
new file mode 100644
index 000000000..6cd86b21f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-2.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fstrict-overflow -fdump-tree-optimized" } */
+
+int f(int a)
+{
+  return 10/-a;
+}
+
+
+/* { dg-final { scan-tree-dump-times "10 / -a" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "-10 / a" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-3.c
new file mode 100644
index 000000000..d305b549c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-3.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fstrict-overflow -fdump-tree-optimized" } */
+
+int f(int a)
+{
+  return -(a/10);
+}
+
+/* { dg-final { scan-tree-dump-times "a / 10" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a / -10" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-4.c
new file mode 100644
index 000000000..b1bb1efa9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/divide-4.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fstrict-overflow -fdump-tree-optimized" } */
+
+int f(int a)
+{
+  return -(-a/10);
+}
+
+/* { dg-final { scan-tree-dump-times "-a / 10" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "a / 10" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/dump-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/dump-1.c
new file mode 100644
index 000000000..382f3231b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/dump-1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-profile-details" } */
+
+int f(void)
+{
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/flatten-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/flatten-1.c
new file mode 100644
index 000000000..2eb41e5b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/flatten-1.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options -O2 } */
+
+/* Basic tests for flatten attribute, check we end up
+   with only the flattened function bodies.  */
+
+static int foobar(int i);
+static int bar(int i);
+
+int __attribute__((flatten)) leaf0a(int i)
+{
+  return bar(i);
+}
+int __attribute__((flatten)) leaf0b(int i)
+{
+  return foobar(i);
+}
+int __attribute__((flatten)) leaf1(int i)
+{
+  return bar(foobar(i));
+}
+int __attribute__((flatten)) leaf2(int i)
+{
+  int j;
+  j = foobar(i);
+  return bar(j);
+}
+
+static int foobar(int i)
+{
+  return i-1;
+}
+static int bar(int i)
+{
+  return i + foobar(i);
+}
+
+
+static int gloobar(int i)
+{
+  return i*5+1;
+}
+static int floobar(int i)
+{
+  return gloobar(i);
+}
+int __attribute__((flatten)) leaf3(int i)
+{
+  int j;
+  j = floobar(i);
+  j += floobar(i);
+  return j;
+}
+
+/* { dg-final { scan-assembler-not "bar\[: \t\n\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/flatten-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/flatten-2.c
new file mode 100644
index 000000000..52a865dbd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/flatten-2.c
@@ -0,0 +1,80 @@
+/* { dg-do compile } */
+/* { dg-options -O2 } */
+
+extern void do_something_usefull();
+/* Check that we finish compiling even if instructed to
+   flatten a cyclic callgraph.  Verify we correctly
+   flatten with another function marked flatten in the
+   callgraph.  */
+
+void __attribute__((flatten)) direct(void)
+{
+  direct();
+}
+
+
+void __attribute__((flatten)) indirect(void);
+static void indirect1(void)
+{
+  indirect();
+}
+void __attribute__((flatten)) indirect(void)
+{
+  indirect1();
+}
+
+
+void __attribute__((flatten)) doubleindirect(void);
+static void doubleindirect2(void)
+{
+  doubleindirect();
+  do_something_usefull ();
+}
+static void doubleindirect1(void)
+{
+  doubleindirect2();
+}
+void __attribute__((flatten)) doubleindirect(void)
+{
+  doubleindirect1();
+}
+
+
+static void subcycle1(void);
+static void subcycle2(void)
+{
+  subcycle1();
+  do_something_usefull ();
+}
+static void subcycle1(void)
+{
+  subcycle2();
+}
+void __attribute__((flatten)) subcycle(void)
+{
+  subcycle1();
+}
+
+
+static void doublesubcycle1(void);
+static void doublesubcycle2(void);
+static void doublesubcycle3(void)
+{
+  doublesubcycle1();
+  do_something_usefull ();
+}
+static void doublesubcycle2(void)
+{
+  doublesubcycle3();
+}
+static void doublesubcycle1(void)
+{
+  doublesubcycle2();
+}
+void __attribute__((flatten)) doublesubcycle(void)
+{
+  doublesubcycle1();
+}
+
+/* { dg-final { scan-assembler "cycle\[123\]\[: \t\n\]" } } */
+/* { dg-final { scan-assembler-not "indirect\[12\]\[: \t\n\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-1.c
new file mode 100644
index 000000000..a3c6a2ece
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-original" } */
+#include <stddef.h>
+
+char *a;
+int foo(char *b)
+{
+        return a+5+(ptrdiff_t)b == (ptrdiff_t)b+a;
+}
+
+/* Folding should have determined that the two addresses were
+   not identical and thus collapsed the function into a trivial
+   "return 0".  */
+/* { dg-final { scan-tree-dump-times "return 0" 1 "original" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-2.c
new file mode 100644
index 000000000..dc764c3d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+struct a{
+	int a;
+	int b;
+} a;
+int *
+t()
+{
+	return (int *)&a;
+}
+/* { dg-final { scan-tree-dump "a.a" "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-3.c
new file mode 100644
index 000000000..b764187a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldaddr-3.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+union a
+{
+  struct s1
+  {
+    long long a;
+    long long b;
+  } s1;
+  struct s2
+  {
+    int c;
+    int d;
+  } s2;
+  struct s3
+  {
+    unsigned long long e;
+    unsigned long long f;
+  } s3;
+} a;
+int *
+t ()
+{
+  return (int *) &a;
+}
+
+/* { dg-final { scan-tree-dump "a.s2.c" "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldcast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldcast-1.c
new file mode 100644
index 000000000..a0626ea10
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldcast-1.c
@@ -0,0 +1,16 @@
+/* { dg-do "compile" } */
+/* { dg-options "-fdump-tree-original" } */
+
+typedef int ssize_t __attribute__((mode(pointer)));
+ssize_t foo (ssize_t x)
+{
+  return (ssize_t)(char *)x;
+}
+
+char *bar (char *x)
+{
+  return (char *)(ssize_t)x;
+}
+
+/* { dg-final { scan-tree-dump-times "return x;" 2 "original" } } */
+/* { dg-final { cleanup-tree-dump "original" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldstring-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldstring-1.c
new file mode 100644
index 000000000..25a7ef49f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/foldstring-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-useless" } */
+
+void
+arf ()
+{
+  if (""[0] == 0)
+    blah ();
+}
+/* { dg-final { scan-tree-dump-times "= 0;" 1 "useless"} } */ 
+/* { dg-final { cleanup-tree-dump "useless" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-1.c
new file mode 100644
index 000000000..ee3cb0ebf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop1" }  */
+
+/* We should be able to optimize this to b->t[i] = 1 during
+   early optimizations.  */
+
+struct a
+{
+  int t[10];
+};
+
+void f(struct a * b, __SIZE_TYPE__ i)
+{
+  int *c = b->t;
+  c[i] = 1;
+}
+
+/* { dg-final { scan-tree-dump-times "t\\\[i.*\\\] =.* 1;" 1 "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-10.c
new file mode 100644
index 000000000..0b865245a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-10.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-forwprop1" } */
+
+int b;
+unsigned a;
+
+static inline int *g(void)
+{
+  a = 1;
+  return (int*)&a;
+}
+void test2(void)
+{
+  b = *g();
+}
+
+/* The indirect load should be replaced by a load from a and a
+   conversion to int.  */
+
+/* { dg-final { scan-tree-dump "= a;" "forwprop1" } } */
+/* { dg-final { scan-tree-dump "= \\\(int\\\) " "forwprop1" } } */
+/* { dg-final { scan-tree-dump-not "= \\\*" "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-2.c
new file mode 100644
index 000000000..fe04e66fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-2.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop1" }  */
+
+/* We should be able to optimize this to b->t[i] = 1 during
+   early optimizations.  */
+
+struct a
+{
+  char t[10];
+};
+
+struct a *b;
+
+void f(__SIZE_TYPE__ i)
+{
+  char *c = b->t;
+  c[i] = 1;
+}
+
+/* { dg-final { scan-tree-dump-times "t\\\[i.*\\\] =.* 1;" 1 "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop?" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-3.c
new file mode 100644
index 000000000..dbb6e420e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-3.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop1" } */
+
+struct bar {
+  int a[2];
+};
+
+int foo(struct bar *x)
+{
+  int *p = &x->a[0];
+  int *q = &x->a[1];
+  if (p < q)
+    return 1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "Replaced .p_. < q_.. with .1." "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-4.c
new file mode 100644
index 000000000..7eabd1a7b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-forwprop1" } */
+
+/* We should be able to fold the comparison at least with the
+   first forwprop pass, if not a ccp pass before.  */
+
+extern void link_error (void);
+void foo()
+{
+  int i;
+  char *p = (char *)&i;
+  long *q = (long *)p;
+  if (q == 0)
+    link_error ();
+}
+
+/* { dg-final { scan-tree-dump-not "link_error" "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-5.c
new file mode 100644
index 000000000..710bc5dd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-5.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-forwprop1 -w" } */
+
+#define vector __attribute__((vector_size(16) ))
+struct VecClass
+{
+  vector float v;
+};
+
+vector float foo( vector float v )
+{
+    vector float x = v;
+    x = x + x;
+    struct VecClass y = *(struct VecClass*)&x;
+    return y.v;
+}
+
+/* We should be able to convert the cast to a VCE in forwprop1. */
+/* { dg-final { scan-tree-dump-times "VIEW_CONVERT_EXPR" 1 "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-6.c
new file mode 100644
index 000000000..987f8a390
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-6.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop1 -W -Wall" } */
+#if (__SIZEOF_INT__ == __SIZEOF_FLOAT__)
+typedef int intflt;
+#elif (__SIZEOF_LONG__ == __SIZEOF_FLOAT__)
+typedef long intflt;
+#else
+#error Add target support here for type that will union float size
+#endif
+
+intflt b;
+void f(void)
+{
+  float a;
+  a = 1;
+  b = *(intflt*)&a; /* { dg-warning "aliasing" } */
+}
+
+/* We should be able to convert the cast to a VCE in forwprop1,
+   even if there is an aliasing violation. */
+/* { dg-final { scan-tree-dump-times "VIEW_CONVERT_EXPR" 1 "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-7.c
new file mode 100644
index 000000000..0d2bac521
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-7.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-forwprop1 -W -Wall" } */
+
+int i;
+int foo(void)
+{
+  volatile int *p = (volatile int *)&i;
+  return *p + *p;
+}
+
+/* We should not convert the cast to a VCE in forwprop1 as we have a
+   volatile reference.  */
+
+/* { dg-final { scan-tree-dump-times "VIEW_CONVERT_EXPR" 0 "forwprop1"} } */
+/* { dg-final { scan-tree-dump-times "={v}" 2 "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-8.c
new file mode 100644
index 000000000..4e0751f81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-8.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-forwprop1 -W -Wall" } */
+
+
+struct X { int a[5]; };
+int foo(struct X *q)
+{
+  int (*pointer)[5] = &q->a;
+  return (*pointer)[0];
+}
+
+
+/* We should have propragated &q->a into (*pointer).  */
+/* { dg-final { scan-tree-dump-times "pointer" 0 "forwprop1"} } */
+/* { dg-final { scan-tree-dump "->a\\\[0\\\]" "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-9.c
new file mode 100644
index 000000000..4469fe731
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/forwprop-9.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-final_cleanup -fdump-tree-fre -W -Wall -fno-early-inlining" } */
+
+int b;
+unsigned a;
+static inline int *g(void)
+{
+  a = 1;
+  return (int*)&a;
+}
+void f(void)
+{
+   b = *g(); 
+}
+
+/* We should have converted the assignments to two = 1.  FRE does this.  */
+
+/* { dg-final { scan-tree-dump-times " = 1" 2 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-not " = a;" "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11.c
new file mode 100644
index 000000000..7fdcf7506
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11.c
@@ -0,0 +1,34 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fwrapv -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fwrapv -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 16
+
+char ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+int main ()
+{
+  int i;
+  char ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] + ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] + ic[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11a.c
new file mode 100644
index 000000000..d147b8115
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11a.c
@@ -0,0 +1,42 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 16
+
+#if __INT_MAX__ == 32767
+typedef char half_word;
+#elif __LONG_MAX__ == 2147483647
+typedef short half_word;
+#else
+typedef int half_word;
+#endif
+
+half_word ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+half_word ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+int main ()
+{
+  int i;
+  half_word ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] & ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] & ic[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11b.c
new file mode 100644
index 000000000..33788134e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11b.c
@@ -0,0 +1,34 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 16
+
+int main ()
+{
+  int i;
+  char ia[N];
+  char ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  char ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+  /* Not vectorizable, multiplication */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] * ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != (char) (ib[i] * ic[i]))
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11c.c
new file mode 100644
index 000000000..ec71c62a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-11c.c
@@ -0,0 +1,40 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=3 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 16
+
+#if LONG_MAX == 2147483647
+typedef short half_word;
+#else
+typedef int half_word;
+#endif
+
+int main ()
+{
+  int i;
+  half_word ia[N];
+  half_word ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  half_word ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+  /* Not worthwhile, only 2 parts per int */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] + ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] + ic[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-2.c
new file mode 100644
index 000000000..84248ee87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-2.c
@@ -0,0 +1,41 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 16
+ 
+#if __INT_MAX__ == 32767
+typedef char half_word;
+#elif __LONG_MAX__ == 2147483647
+typedef short half_word;
+#else
+typedef int half_word;
+#endif
+
+half_word cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+int main ()
+{
+  half_word ca[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-25.c
new file mode 100644
index 000000000..e7cb925e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-25.c
@@ -0,0 +1,57 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 128
+
+#if __LONG_MAX__ == 2147483647
+typedef short half_word;
+#else
+typedef int half_word;
+#endif
+
+int main_1 (int n, int *p)
+{
+  int i;
+  half_word ib[N];
+  half_word ia[N];
+  int k;
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = n;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != n)
+        abort ();
+    }
+
+  k = *p;
+  for (i = 0; i < N; i++)
+    {
+      ib[i] = k;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ib[i] != k)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (int n)
+{
+  return main_1 (n + 2, &n);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-26.c
new file mode 100644
index 000000000..38c72eca2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-26.c
@@ -0,0 +1,35 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 128
+
+/* unaligned store.  */
+
+int main ()
+{
+  int i;
+  char ia[N+1];
+
+  for (i = 1; i <= N; i++)
+    {
+      ia[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 1; i <= N; i++)
+    {
+      if (ia[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-28.c
new file mode 100644
index 000000000..77623919e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-28.c
@@ -0,0 +1,36 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 128
+#define OFF 3
+
+/* unaligned store.  */
+
+int main (int off)
+{
+  int i;
+  char ia[N+OFF];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i+off] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i+off] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-32.c
new file mode 100644
index 000000000..04453cce6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-32.c
@@ -0,0 +1,34 @@
+/* { dg-do run { target vect_cmdline_needed } } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats" } */
+/* { dg-options "-O2 -ftree-vectorize -ftree-vectorizer-verbose=4 -fdump-tree-vect-stats -mno-sse" { target { i?86-*-* x86_64-*-* } } } */
+
+#include <stdlib.h>
+
+#define N 16
+ 
+int main ()
+{  
+  struct {
+    char ca[N];
+  } s;
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-33.c
new file mode 100644
index 000000000..8cd12da3d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/gen-vect-33.c
@@ -0,0 +1,14 @@
+/* Compiler generates 64-bit stores of zero for this on some targets.
+   Check there is no problem for such case.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+void
+foo (float *dest, int xcount, int  ycount)
+{
+  int x, y;
+
+  for (y = 0; y < ycount; y++)
+    for (x = 0; x < xcount; x++)
+      dest[x + y] = (float) 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-20040816-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-20040816-1.c
new file mode 100644
index 000000000..e7b13b540
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-20040816-1.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-c -O2 -ftree-vectorize -fdump-tree-ifcvt-stats" { target *-*-* } } */
+
+#include <stdarg.h>
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+
+extern void abort(void); 
+
+int main1 ()
+{  
+  int i, j;
+
+  for (i = 0; i < N; i++)
+    {
+      j = A[i];
+      A[i] = ( j >= MAX ? MAX : 0); 
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (A[i] > MAX)
+	abort ();
+    }
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "Applying if-conversion" 1 "ifcvt" } } */
+/* { dg-final { cleanup-tree-dump "ifcvt" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-20040816-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-20040816-2.c
new file mode 100644
index 000000000..f37a4d336
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-20040816-2.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-c -O2 -ftree-vectorize -fdump-tree-ifcvt-stats" { target *-*-* } } */
+
+void foo(const int * __restrict__ zr_in,
+		const int * __restrict__ zi_in,
+		const int * __restrict__ zk_in,
+		int * __restrict__ zr_out,
+		int * __restrict__ zi_out,
+		int * __restrict__ zk_out,
+		int cr, int ci)
+{
+  unsigned int pi;
+  int tmp_r, tmp_i, tmp_k;
+#if __SIZEOF_INT__ >= 4
+  for (pi = 0; pi < (512)*(512); pi++) {
+#else
+  for (pi = 0; pi < (32)*(32); pi++) {
+#endif
+    int zr = zr_in[pi];
+    int zi = zi_in[pi];
+    int zk = zk_in[pi];
+    
+    if (zr*zr + zi*zi >= 4) {
+      tmp_r = zr;
+      tmp_i = zi;
+      tmp_k = zk;
+    } else {
+      tmp_r = (zr*zr - zi*zi + cr);
+      tmp_i = (2 * zr * zi + ci);
+      tmp_k = zk + 1;
+    }
+    zr_out[pi] = tmp_r;
+    zi_out[pi] = tmp_i;
+    zk_out[pi] = tmp_k;
+  }
+}
+
+
+/* { dg-final { scan-tree-dump-times "Applying if-conversion" 1 "ifcvt" } } */
+/* { dg-final { cleanup-tree-dump "ifcvt" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-3.c
new file mode 100644
index 000000000..e853ec4df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ifc-3.c
@@ -0,0 +1,12 @@
+/* PR 20994 */
+/* { dg-do compile } */
+int foo(double* p, double* q)
+{
+    int i=0;
+
+    for (; q!=p; ++q)
+        if (*q)
+            ++i;
+
+    return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline-1.c
new file mode 100644
index 000000000..7b9e3be49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+
+
+typedef struct {
+  double min;
+  double max;
+} interval;
+inline interval add(interval x, interval y)  __attribute__((always_inline));
+inline interval add(interval x, interval y)  
+{
+  interval r;
+  r.min = x.min + y.min;
+  r.max = x.max + y.max;
+  return r;
+}
+interval foo (interval a, interval b, interval c)
+{
+  return add (a, add (b, c));
+}
+
+
+/* { dg-final { scan-tree-dump-times "\\(struct interval\\)" 0 "final_cleanup"} } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline-2.c
new file mode 100644
index 000000000..72b61c369
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline-2.c
@@ -0,0 +1,17 @@
+/* { dg-do link } */
+/* { dg-options "-O" } */
+
+/* When optimized we expect the call to foo () in bar to be inlined
+   and the call to link_error optimized away.  */
+
+extern void link_error (void);
+inline int __attribute__((always_inline)) foo(void) { return 0; }
+
+int main()
+{
+  int (*fn)(void) = foo;
+  if (fn())
+    link_error ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline_asm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline_asm-1.c
new file mode 100644
index 000000000..0c84ed3fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline_asm-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized -fdump-tree-alias-vops" } */
+/* Test to make sure that inline-asm causes a VDEF and that we call test_function twice. */
+
+char test_function(void ) __attribute__((__pure__));
+char f(char *a)
+{
+  char b = test_function();
+  asm("":"=m"(*a):"r"(b));
+  b = test_function();
+  return b;
+}
+
+/* test_function should be called twice as the inline-asm changes memory. */
+/* { dg-final { scan-tree-dump-times "test_function" 2 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+/* There should a VDEF for the inline-asm.  */
+/* { dg-final { scan-tree-dump-times "VDEF" 1 "alias"} } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline_asm-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline_asm-2.c
new file mode 100644
index 000000000..6b347c41e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/inline_asm-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-alias-vops" } */
+/* Test to make sure that inline-asm causes a VDEF. */
+
+
+void link_error();
+void f(char *a)
+{
+  int *a1 = (int *)a;
+  if (*a == 0)
+   asm("":"=m"(*a1));
+  if (*a == 0)
+   link_error ();
+}
+
+/* There should a VDEF for the inline-asm and one for the link_error.  */
+/* { dg-final { scan-tree-dump-times "VDEF" 2 "alias"} } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ipa-reference-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ipa-reference-1.c
new file mode 100644
index 000000000..c15a8b609
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ipa-reference-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+static int conststaticvariable;
+
+int f(void)
+{
+  return conststaticvariable;
+}
+
+/* There should be no reference to conststaticvariable as we should have
+   inlined the 0 as IPA reference should have marked the variable as a const
+   as it is not set in the IR.  */
+/* { dg-final { scan-tree-dump-times "conststaticvariable" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_1.c
new file mode 100644
index 000000000..a9fae67f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2 -m64 -fdump-tree-ivopts" } */
+#define TYPE char*
+
+void foo (int i_width, TYPE dst, TYPE src1, TYPE src2)
+{
+      int x;
+       for( x = 0; x < i_width; x++ )
+       {
+           dst[x] = ( src1[x] + src2[x] + 1 ) >> 1;
+       }
+}
+
+
+/* { dg-final { scan-tree-dump-times "PHI <ivtmp" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_2.c
new file mode 100644
index 000000000..7c0feafe5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2 -m64 -fdump-tree-ivopts" } */
+
+#define TYPE char*
+
+void foo (int i_width, TYPE dst, TYPE src1, TYPE src2)
+{
+      int x;
+       for( x = 0; x < i_width; x++ )
+       {
+           *dst++ = ( *src1++ + *src2++ + 1 ) >> 1;
+       }
+}
+
+/* { dg-final { scan-tree-dump-times "PHI <ivtmp" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_3.c
new file mode 100644
index 000000000..d5bdcffb2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_3.c
@@ -0,0 +1,19 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2 -m64 -fdump-tree-ivopts" } */
+
+#define TYPE char*
+
+void foo (int i_width, char* dst, char* src1, char* src2)
+{
+      int x;
+       for( x = 0; x < i_width; x++ )
+       {
+           *((TYPE)dst) = ( *((TYPE)src1) + *((TYPE)src2) + 1 ) >> 1;
+	   dst+=sizeof(TYPE);
+	   src1+=sizeof(TYPE);
+	   src2+=sizeof(TYPE);
+       }
+} 
+
+/* { dg-final { scan-tree-dump-times "PHI <ivtmp" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_4.c
new file mode 100644
index 000000000..494650266
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2 -m64 -fdump-tree-ivopts" } */
+
+#ifndef TYPE
+#define TYPE char*
+#endif
+
+void foo (int i_width, TYPE dst, TYPE src1, TYPE src2)
+{
+      TYPE dstn= dst + i_width;
+       for( ; dst < dstn; )
+       {
+           *dst++ = ( *src1++ + *src2++ + 1 ) >> 1;
+       }
+}
+
+/* { dg-final { scan-tree-dump-times "PHI <ivtmp" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_5_sink.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_5_sink.c
new file mode 100644
index 000000000..3c528b0ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_5_sink.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2  -m64 -fdump-tree-ivopts-details" } */
+int inner_longest_match(char *scan, char *match, char *strend)
+{
+  char *start_scan = scan;
+  do {
+  } while (*++scan == *++match && *++scan == *++match &&
+           *++scan == *++match && *++scan == *++match &&
+           *++scan == *++match && *++scan == *++match &&
+           *++scan == *++match && *++scan == *++match &&
+           scan < strend);
+
+  return scan - start_scan;
+}
+
+/* { dg-final { scan-tree-dump-times "Sinking" 7 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_6.c
new file mode 100644
index 000000000..aa14628ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_6.c
@@ -0,0 +1,19 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2 -m64 -fdump-tree-ivopts-details" } */
+#include <stdlib.h>
+int foo(const char* p, const char* p2, size_t N)
+{
+  const char* p_limit = p + N;
+  while (p  <= p_limit - 16
+        && *(long long*)p  <*(long long*)p2 )
+  {
+     p += 16;
+     p2 += 16;
+  }
+  N = p_limit - p;
+  return memcmp(p, p2, N);
+}
+
+/* { dg-final { scan-tree-dump-times "Sinking" 4 "ivopts"} } */
+/* { dg-final { scan-tree-dump-times "Reordering" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_7.c
new file mode 100644
index 000000000..8ee4c61b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopt_7.c
@@ -0,0 +1,20 @@
+/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
+/* { dg-options "-O2 -m64 -fdump-tree-ivopts-details" } */
+#include <stdlib.h>
+
+int foo(const char* p, const char* p2, size_t N)
+{
+ const char* p_limit = p + N;
+ int s = 0;
+ while (p  <= p_limit - 16
+        && *(long long*)p <*(long long*)p2)
+ {
+     p += 8;
+     p2 += 8;
+     s += (*p + *p2);
+  }
+  return s;
+}
+/* { dg-final { scan-tree-dump-times "Reordering" 1 "ivopts"} } */
+/* { dg-final { scan-tree-dump-times "PHI <ivtmp" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopts-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopts-1.c
new file mode 100644
index 000000000..5ee87b033
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopts-1.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+/* Not all platforms support TImode integers.  */
+#if defined(__LP64__) && !defined(__hppa__)
+typedef int TItype __attribute__ ((mode (TI)));
+#else
+typedef long TItype;
+#endif
+
+TItype last_data_offset ;
+int store;
+char *data;
+
+f ()
+{
+
+  TItype data_offset = last_data_offset;
+  char *p;
+
+  for (p = data; *p; p++)
+    {
+      data_offset++;
+      g (data_offset);
+      store = data_offset + 1;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopts-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopts-2.c
new file mode 100644
index 000000000..369f082e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ivopts-2.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ivopts-details" } */
+
+long last_data_offset;
+int store;
+char *data;
+  
+f ()
+{
+  
+  long data_offset = last_data_offset;
+  char *p;
+  
+  for (p = data; *p; p++)
+    {
+      data_offset++;
+      g (data_offset);
+      store = data_offset + 1;
+    }
+}
+
+/* We should only have two IVs.  */
+/* { dg-final { scan-tree-dump-not "\\n  candidates \\d+, \\d+,\[^\\n\]*\\n\[^\\n\]*\\nFinal cost" "ivopts" } }  */
+/* { dg-final { cleanup-tree-dump "ivopts" } }  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-1.c
new file mode 100644
index 000000000..43c104665
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-1.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+void foo (int * __restrict__ ia,
+	  int * __restrict__ ib,
+	  int * __restrict__ oxa,
+	  int * __restrict__ oxb,
+	  int * __restrict__ oya,
+	  int * __restrict__ oyb)
+{
+  int i;
+  long int mya[52];
+  long int myb[52];
+
+  for (i=0; i < 52; i++)
+    {
+      mya[i] = ia[i] * oxa[i] + ib[i] * oxb[i];
+      myb[i] = -ia[i] * oxb[i] + ib[i] * oxa[i];
+      oya[i] = mya[i] >> 10;
+      oyb[i] = myb[i] >> 10;
+    }
+
+  /* This loop was distributed, but it is not anymore due to the cost
+     model changes: the result of a distribution would look like this:
+
+     |  for (i=0; i < 52; i++)
+     |    oya[i] = ia[i] * oxa[i] + ib[i] * oxb[i] >> 10;
+     |
+     |  for (i=0; i < 52; i++)
+     |    oyb[i] = -ia[i] * oxb[i] + ib[i] * oxa[i] >> 10;
+
+     and in this the array IA is read in both tasks.  For maximizing
+     the cache reuse, ldist does not distributes this loop anymore.
+  */
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-10.c
new file mode 100644
index 000000000..0790c18a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-10.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  int a[1000], b[1000], c[1000];
+
+  for (i = 1; i < 1000; i ++)
+    {
+      a[i] = c[i]; /* S1 */
+      b[i] = a[i-1]+1; /* S2 */
+    }
+  /* Dependences:
+     S1->S2 (flow, level 1)
+
+     One partition as A is used in both S1 and S2.
+  */
+
+  return a[1000-2] + b[1000-1] + c[1000-2];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-11.c
new file mode 100644
index 000000000..88651e7b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-11.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+void foo (int * __restrict__ ia,
+	  int * __restrict__ ib,
+	  int * __restrict__ oxa,
+	  int * __restrict__ oxb,
+	  int * __restrict__ oya,
+	  int * __restrict__ oyb)
+{
+  int i;
+  long int mya[52];
+  long int myb[52];
+
+  for (i=0; i < 52; i++)
+    {
+      mya[i] = ia[i] * oxa[i] + ib[i] * oxb[i];
+      myb[i] = -ia[i] * oxb[i] + ib[i] * oxa[i];
+      oya[i] = 0;
+      oyb[i] = myb[i] >> 10;
+    }
+
+  /* This loop should be distributed, and the result should look like
+     this:
+     |  memset (oya, 0, 208);
+     |  for (i=0; i < 52; i++)
+     |    oyb[i] = -ia[i] * oxb[i] + ib[i] * oxa[i] >> 10;
+  */
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 1 "ldist" } } */
+/* { dg-final { scan-tree-dump-times "generated memset zero" 1 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-12.c
new file mode 100644
index 000000000..1e555fe26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-12.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int foo (int * __restrict__ ia,
+	 int * __restrict__ ib,
+	 int * __restrict__ oxa,
+	 int * __restrict__ oxb)
+{
+  int i;
+  int oya[52], oyb[52];
+
+  for (i=0; i < 52; i++)
+    {
+      oya[i] = (ia[i] * oxa[i]) >> 10;
+      oyb[i] = (ib[i] * oxb[i]) >> 10;
+    }
+
+  return oya[22] + oyb[21];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 1 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-1a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-1a.c
new file mode 100644
index 000000000..623aacfdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-1a.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int foo (int * __restrict__ ia,
+	 int * __restrict__ ib,
+	 int * __restrict__ oxa,
+	 int * __restrict__ oxb)
+{
+  int i;
+  int oya[52], oyb[52];
+
+  for (i=0; i < 52; i++)
+    {
+      oya[i] = (ia[i] * oxa[i] + ib[i] * oxb[i]) >> 10;
+      oyb[i] = (-ia[i] * oxb[i] + ib[i] * oxa[i]) >> 10;
+    }
+
+  return oya[22] + oyb[21];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-2.c
new file mode 100644
index 000000000..de98ccc4c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-2.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+void foo (int * __restrict__ a,
+	  int * __restrict__ b,
+	  int * __restrict__ c)
+{
+  int i;
+
+  for (i=1; i < 10; i++)
+    {
+      a[i] += c[i];
+      b[i] = a[i - 1] + 1;
+    }
+
+  /* This loop is not distributed because the cost of spliting it:
+
+     |  for (i=1; i < N; i++)
+     |    a[i] += c[i];
+     |
+     |  for (i=1; i < N; i++)
+     |    b[i] = a[i - 1] + 1;
+
+     is higher due to data in array A that is written and then read in
+     another task.  The cost model should forbid the transformation in
+     this case.
+  */
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-3.c
new file mode 100644
index 000000000..40adfe1a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-3.c
@@ -0,0 +1,34 @@
+/* { dg-do compile { target int32plus } } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  int a[10000], b[10000], c[10000], d[10000];
+	
+  a[0] = k; a[3] = k*2;
+  c[1] = k+1;
+  for (i = 2; i < (10000-1); i ++)
+    {
+      a[i] = k * i; /* S1 */
+      b[i] = a[i-2] + k; /* S2 */
+      c[i] = b[i] + a[i+1]; /* S3 */
+      d[i] = c[i-1] + k + i; /* S4 */
+    }
+  /*
+    Dependences:
+    S1 -> S2 (flow, level 1)
+    S1 -> S3 (anti, level 1)
+    S2 -> S3 (flow, level 0)
+    S3 -> S4 (flow, level 1)
+
+    There are three partitions: {S1, S3}, {S2} and {S4}.
+
+    The cost model should fuse together all the partitions, as they
+    are reusing the same data, ending on a single partition.
+  */
+  return a[10000-2] + b[10000-1] + c[10000-2] + d[10000-2];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 3 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-4.c
new file mode 100644
index 000000000..a744fea02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-4.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  unsigned int j;
+  int a[100], b[100][100];
+
+  a[0] = k;
+  for (i = 1; i < 100; i ++)
+    {
+      for (j = 0; j < 100; j++)
+	{
+	  a[j] = k * i;
+	  b[i][j] = a[j-1] + k;
+	}
+    }
+
+  return b[100-1][0];
+}
+
+/* We used to distribute also innermost loops, but these could produce
+   too much code in the outer loop, degrading performance of scalar
+   code.  So this test was XFAILed because the cost model of the stand
+   alone distribution pass has evolved.  Now it passes.  */
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" { target ilp32 } } } */
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 1 "ldist" { target lp64 } } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-5.c
new file mode 100644
index 000000000..9a03dc171
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-5.c
@@ -0,0 +1,33 @@
+/* { dg-do compile { target int32plus } } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  unsigned int j;
+  int a[100][100], b[100][100], c[100][100], d[100][100];
+
+  a[0][0] = k;
+  for (i = 1; i < 100; i ++)
+    for (j = 1; j < (100-1); j++) 
+      {   
+        a[i][j] = k * i; /* S1 */
+        b[i][j] = a[i][j-1] + k; /* S2 */
+        c[i][j] = b[i][j] + a[i][j+1]; /* S3 */
+        d[i][j] = c[i][j] + k + i; /* S4 */
+      }
+  /* Dependences:
+     S1->S2 (flow, level 2)
+     S1->S3 (anti, level 2)
+     S2->S3 (flow, level 0)
+     S3->S4 (flow, level 0)
+  */
+  
+  return a[100-1][100-1] + b[100-1][100-1] + c[100-1][100-1] + d[100-1][100-1];
+}
+
+/* FIXME: This is XFAILed because of a data dependence analysis
+   problem: the dependence test fails with a "don't know" relation.  */
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 1 "ldist" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-6.c
new file mode 100644
index 000000000..7a38c8683
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-6.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  int a[1000], b[1000], c[1000], d[1000];
+
+  for (i = 2; i < (1000-1); i ++) {
+    a[i] = k * i; /* S1 */
+    b[i] = a[i-2] + k; /* S2 */
+    c[i] = b[i-1] + a[i+1]; /* S3 */
+    d[i] = c[i-1] + k + i; /* S4 */
+  }
+  /* Dependences:
+     S1->S2 (flow, level 1)
+     S2->S3 (flow, level 1)
+     S3->S1 (anti, level 1)
+     S3->S4 (flow, level 1)
+
+    There are two partitions: {S1, S2, S3} and {S4}.
+
+    {S1, S2, S3} have to be in the same partition because:
+    - S1 (i) has to be executed before S2 (i+2), as S1 produces a[i] that is then consumed 2 iterations later by S2.
+    - S2 (i) has to be executed before S3 (i+1), as S2 produces b[i] that is then consumed one iteration later by S3,
+    - S3 (i) has to be executed before S1 (i+1), as a[i+1] has to execute before the update to a[i],
+
+    {S4} is the consumer partition: it consumes the values from array "c" produced in S3.
+
+    The cost model should fuse all the tasks together as the cost of
+    fetching data from caches is too high.
+  */
+
+  return a[1000-2] + b[1000-1] + c[1000-2] + d[1000-2];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-7.c
new file mode 100644
index 000000000..124fcdedd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-7.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i, z;
+  int a[1000], b[1000], c[1000], d[1000];
+
+  for (i = 2; i < (1000-1); i ++) {
+    z = a[i+1]; /* S1 */
+    a[i] = k * i; /* S2 */
+    b[i] = a[i-2] + k; /* S3 */
+    c[i] = b[i-1] + z; /* S4 */
+    d[i] = c[i-1] + b[i+1] + k + i; /* S5 */
+  }
+  /* Dependences:
+     S1->S2 (anti, level 1)
+     S1->S4 (flow, level 1, scalar)
+     S2->S3 (flow, level 1)
+     S3->S4 (flow, level 1)
+     S4->S5 (flow, level 1)
+     S5->S3 (anti, level 1)
+
+     There is a single partition: {S1, S2, S3, S4, S5}, because of the
+     scalar dependence z between the two partitions {S1, S2} and {S3, S4, S5}.
+  */
+
+  return a[1000-2] + b[1000-1] + c[1000-2] + d[1000-2];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-8.c
new file mode 100644
index 000000000..4a8e06600
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-8.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  int a[1000], b[1000], c[1000], d[1000];
+
+  for (i = 2; i < (1000-1); i ++)
+    {
+      a[i] = k * i; /* S1 */
+      b[i] = a[i+1] + k; /* S2 */
+      c[i] = a[i-1] + b[i-1] + d[i-1]; /* S3 */
+      d[i] = a[i-1] + b[i+1] + k + i; /* S4 */
+    }
+  /* Dependences:
+     S1->S2 (anti, level 1)
+     S1->S3 (flow, level 1)
+     S1->S4 (flow, level 1)
+     S2->S3 (flow, level 1)
+     S2->S4 (anti, level 1)
+     S4->S3 (flow, level 1)
+
+     Two partitions: {S1, S2, S4} produce information that is consumed in {S3}.
+
+     So that means that the current cost model will also fuse these
+     two partitions into a single one for avoiding cache misses.
+  */
+
+  return a[1000-2] + b[1000-1] + c[1000-2] + d[1000-2];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-9.c
new file mode 100644
index 000000000..ee8d023de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ldist-9.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-distribution -fdump-tree-ldist-all" } */
+
+int loop1 (int k)
+{
+  unsigned int i;
+  int a[1000], b[1000];
+
+  for (i = 1; i < (1000-1); i ++) {
+    a[i] = a[i+1] + a[i-1]; /* S1 */
+    b[i] = a[i-1] + k; /* S2 */
+  }
+  /*
+    Dependences:
+    S1->S2 (flow, level 1)
+    S1->S1 (anti, level 1)
+    S1->S1 (flow, level 1)
+
+    One partition, because of the cost of cache misses.
+  */
+
+  return a[1000-2] + b[1000-1];
+}
+
+/* { dg-final { scan-tree-dump-times "distributed: split to 2 loops" 0 "ldist" } } */
+/* { dg-final { cleanup-tree-dump "ldist" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre1.c
new file mode 100644
index 000000000..e26fa9302
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int *a, int argc)
+{
+  int c;
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = *a;
+  if (argc)
+    {
+      a = &c;
+    }
+  e = *a;
+  return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre10.c
new file mode 100644
index 000000000..4147a702a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre10.c
@@ -0,0 +1,49 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+struct tree_common 
+{ 
+  int code; 
+}; 
+union tree_node 
+{ 
+  struct tree_common common; 
+}; 
+typedef union tree_node *tree; 
+ 
+extern tree test (tree, int, int); 
+extern tree foo (void); 
+extern void abort (void) __attribute__ ((__noreturn__)); 
+
+/* Redundant loads of expr->common.code */
+tree 
+test (tree expr, int t, int D17630) 
+{ 
+  int __i; 
+ 
+L0: 
+  if (expr->common.code != 142) goto L23; else goto L2; 
+ 
+L2: 
+  __i = 0; 
+  goto L10; 
+ 
+L10: 
+  __i = __i + 1; 
+  if (D17630 != __i) goto L8; else goto L19; 
+ 
+L8: 
+  if (t) goto L15; else goto L10; 
+ 
+L15: 
+  expr = foo (); 
+  if (expr->common.code != 142) goto L23; else goto L0; 
+ 
+L19: 
+  abort (); 
+ 
+L23: 
+  return expr; 
+} 
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre11.c
new file mode 100644
index 000000000..eb6089c4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre11.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats -fno-tree-cselim" } */
+int *t;
+int g(int);
+int f(int tt)
+{
+    int *t1 = t;
+    if (*t1)
+      *t1 = 2;
+    return g(*t1);
+} 
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre12.c
new file mode 100644
index 000000000..94a3d00bd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre12.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+type *t;
+int g(int);
+int f(int tt)
+{
+    type *t1 = t;
+    if ((*t1)[0])
+      (*t1)[0] = 2;
+    return g((*t1)[0]);
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre13.c
new file mode 100644
index 000000000..420ad7162
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre13.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int t[2];
+int g(int);
+int f(int tt)
+{
+    if (t[0])
+      t[0] = 2;
+    return g(t[0]);
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre14.c
new file mode 100644
index 000000000..f4c06f264
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre14.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  type c = {0, 1};
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[0];
+  if (argc)
+    {
+      a = &c;
+    }
+  e = (*a)[0];
+  return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre15.c
new file mode 100644
index 000000000..3e3ff7c45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre15.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc, int t)
+{
+  type c = {0, 1};
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[t];
+  if (argc)
+    {
+      a = &c;
+    }
+  e = (*a)[t];
+  return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre16.c
new file mode 100644
index 000000000..3702440f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre16.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[0];
+  if (argc)
+      a++;
+  e = (*a)[0];
+  return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre17.c
new file mode 100644
index 000000000..93c530d5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre17.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[argc];
+  if (argc)
+      a++;
+  e = (*a)[argc];
+  return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre18.c
new file mode 100644
index 000000000..21a1d0670
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre18.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[argc];
+  if (argc)
+      argc++;
+  e = (*a)[argc];
+  return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre19.c
new file mode 100644
index 000000000..62ded9a6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre19.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[argc];
+  if (!d)
+      argc++;
+  e = (*a)[argc];
+  return e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"  } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre2.c
new file mode 100644
index 000000000..8d6557a9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int *a, int argc)
+{
+  int b;
+  int i;
+  int d, e;
+
+  /* Should be able to hoist this out of the loop.  */
+  for (i = 0; i < argc; i++)
+    {
+      e = *a;
+    }
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre20.c
new file mode 100644
index 000000000..330b67a57
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre20.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int d, e;
+  
+  /* Should be able to eliminate the second load of *a along the main path. */
+  d = (*a)[argc];
+  if (!d)
+      a++;
+  e = (*a)[argc];
+  return e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"  } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre21.c
new file mode 100644
index 000000000..77caef6de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre21.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int b;
+  int i;
+  int d, e;
+
+  /* Should be able to hoist this out of the loop.  */
+  for (i = 0; i < argc; i++)
+    {
+      e = (*a)[0];
+    }
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre22.c
new file mode 100644
index 000000000..3c03c9b12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre22.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef int type[2];
+int main(type *a, int argc)
+{
+  int b;
+  int i;
+  int d, e;
+
+  /* Should be able to hoist this out of the loop.  */
+  for (i = 0; i < argc; i++)
+    {
+      e = (*a)[argc];
+    }
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre23.c
new file mode 100644
index 000000000..2273accba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre23.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+struct {
+  int a;
+  int large[100];
+} x;
+
+int foo(int argc)
+{
+  int b;
+  int c;
+  int i;
+  int d, e;
+
+  for (i = 0; i < argc; i++)
+    {
+      e = x.a;
+      x.a = 9;
+    }
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"  } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre24.c
new file mode 100644
index 000000000..31fcc9f8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre24.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+int a;
+
+int foo(int argc)
+{
+  int b;
+  int c;
+  int i;
+  int d, e;
+
+  for (i = 0; i < argc; i++)
+    {
+      e = a;
+      a = 9;
+    }
+  return d + e;
+}
+
+/* We will move the load of a out of the loop.  */
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre25.c
new file mode 100644
index 000000000..aaf09313e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre25.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+struct X { int i; };
+int foo(struct X *a, int argc)
+{
+  int b;
+  int c;
+  int i;
+  int d, e;
+
+  for (i = 0; i < argc; i++)
+    {
+      e = a->i;
+      a->i = 9;
+    }
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"  } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre3.c
new file mode 100644
index 000000000..8767e16a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre3.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int **a,int argc)
+{
+  int b;
+  int d, e;
+
+  if (argc)
+    {
+      d = *(*a);
+    }
+  else
+    {
+
+    }
+  /* Should be able to eliminate one of the *(*a)'s along the if path 
+     by pushing it into the else path. We will also eliminate
+     one of the *a's.  */
+  e = *(*a);
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre4.c
new file mode 100644
index 000000000..1e2660317
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre4.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int *a, int argc)
+{
+  int b;
+  int c;
+  int i;
+  int d, e;
+
+  for (i = 0; i < argc; i++)
+    {
+      e = *a;
+      *a = 9;
+    }
+  return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"  } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre5.c
new file mode 100644
index 000000000..aa5779a56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre5.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int p;
+int r;
+
+__attribute__ ((noinline))
+static int a(void)
+{
+  return p;
+}
+int main(int argc)
+{
+  int q;
+  q = a();
+
+  /* We should be able to move the call to a into the if path.
+     in a perfect world, we'd actually decide that it can't touch
+     r, and not recompute it at all!.  */
+  if (argc)
+    r = 9;
+  return q + a();
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre6.c
new file mode 100644
index 000000000..725f86b19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre6.c
@@ -0,0 +1,77 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+#include <stddef.h>
+
+union tree_node;
+typedef union tree_node *tree;
+
+struct tree_common
+{
+  tree chain;
+};
+
+struct tree_list
+{
+  struct tree_common common;
+  tree value;
+};
+
+union tree_node
+
+{
+  struct tree_common common;
+  struct tree_list list;
+};
+
+extern void abort (void) __attribute__((noreturn));
+
+void __attribute__((noinline))
+foo (void)
+{
+  abort ();
+}
+
+/* There are some reloaded loads of *cell, and cell->common.chain on various
+   branches.  */
+void __attribute__((noinline))
+remove_useless_vars (tree *unexpanded_var_list, int dump_file)
+{
+  tree var, *cell;
+  int c = 0;
+  for (cell = unexpanded_var_list; *cell; )
+    {
+      var = (*cell)->list.value;
+      if (var)
+        {
+          if (dump_file)
+            foo ();
+
+          *cell = ((*cell)->common.chain);
+          continue;
+        }
+
+      cell = &((*cell)->common.chain);
+    }
+}
+extern void *malloc (__SIZE_TYPE__) __attribute__ ((malloc));
+
+int
+main (void)
+{
+  int i;
+  tree unexpanded_var_list, last = (tree) 0;
+
+  for (i = 0; i < 2; i++)
+    {
+      unexpanded_var_list = malloc (sizeof (struct tree_list));
+      unexpanded_var_list->list.value = (tree) (ptrdiff_t) (i & 1);
+      unexpanded_var_list->common.chain = last;
+      last = unexpanded_var_list;
+    }
+
+  remove_useless_vars (&unexpanded_var_list, 0);
+  return 0;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre7.c
new file mode 100644
index 000000000..6f68f3ae2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+/* We can't eliminate the *p load here in any sane way, as eshup8 may 
+   change it.  */
+void
+enormlz (x)
+     unsigned short x[];
+{
+  register unsigned short *p;
+  p = &x[2];
+  while ((*p & 0xff00) == 0)
+    {
+      eshup8 (x);
+    }
+}
+/* { dg-final { scan-tree-dump-not "Eliminated:" "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre8.c
new file mode 100644
index 000000000..056c3fd63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loadpre8.c
@@ -0,0 +1,97 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef union tree_node *tree;
+struct tree_common
+{
+  tree chain;
+}
+VEC_constructor_elt_base;
+struct tree_ssa_name
+{
+  tree var;
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_ssa_name ssa_name;
+};
+struct edge_def
+{
+  struct basic_block_def *dest;
+};
+typedef struct edge_def *edge;
+typedef struct VEC_edge_base
+{
+}
+VEC_edge_base;
+__attribute__ ((noinline)) static edge
+VEC_edge_base_index (const VEC_edge_base * vec_, unsigned ix_)
+{
+}
+typedef struct VEC_edge_gc
+{
+  VEC_edge_base base;
+}
+VEC_edge_gc;
+struct basic_block_def
+{
+  VEC_edge_gc *succs;
+};
+typedef struct basic_block_def *basic_block;
+typedef struct
+{
+  unsigned index;
+  VEC_edge_gc **container;
+}
+edge_iterator;
+__inline__ VEC_edge_gc *
+ei_container (edge_iterator i)
+{
+  return *i.container;
+}
+__inline__ edge_iterator
+ei_start_1 (VEC_edge_gc ** ev)
+{
+  edge_iterator i;
+  i.container = ev;
+  return i;
+}
+__attribute__ ((noinline)) static ei_next (edge_iterator * i)
+{
+}
+static __inline__ edge
+ei_edge (edge_iterator i)
+{
+  return  (edge) (VEC_edge_base_index ((((ei_container (i))) ? &((ei_container (i)))->base : 0), (i.index)));
+}
+static __inline__ unsigned char
+ei_cond (edge_iterator ei, edge * p)
+{
+  *p = ei_edge (ei);
+}
+typedef tree *def_operand_p;
+extern tree *get_phi_result_ptr (tree);
+static __inline__ tree
+get_def_from_ptr (def_operand_p def)
+{
+}
+__attribute__ ((noinline)) static tree
+phi_nodes (basic_block bb)
+{
+}
+
+/* We can eliminate a load of the SRA'd variable edge_iterator.container */
+rewrite_add_phi_arguments (basic_block bb)
+{
+  edge e;
+  edge_iterator ei;
+  for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e));
+       ei_next (&(ei)))
+    {
+      tree phi;
+      for (phi = phi_nodes (e->dest); phi; phi = (((phi))->common.chain))
+	  get_reaching_def ((get_def_from_ptr (get_phi_result_ptr (phi)))->ssa_name.var);
+    }
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-1.c
new file mode 100644
index 000000000..a3d409e55
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-1.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* -mlongcall will cause us to place &foo in the CTR register.  */
+/* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */
+/* { dg-options "-O1 -ftree-loop-ivcanon -funroll-loops -fdump-tree-ivcanon-details -fdump-tree-cunroll-details -fdump-tree-optimized" } */
+
+/* On 31-bit S/390 the function address will be stored (once) in the literal pool,
+   so scan-assembler-times "foo" will return 1 even if the loop is fully unrolled.
+   -msmall-exec avoids this by enabling a call instruction with immediate operand.  */
+/* { dg-options "-O1 -ftree-loop-ivcanon -funroll-loops -fdump-tree-ivcanon-details -fdump-tree-cunroll-details -fdump-tree-optimized -msmall-exec" { target s390-*-* } } */
+
+/* On Darwin, we call extern functions via a stub in PIC mode which is default and
+   the stub is named after the function.  To avoid this we use -static to go out
+   of PIC mode.  */
+/* { dg-options "-O1 -ftree-loop-ivcanon -funroll-loops -fdump-tree-ivcanon-details -fdump-tree-cunroll-details -fdump-tree-optimized -static" { target *-*-darwin* } } */
+
+void xxx(void)
+{
+  int x = 45;
+
+  while (x >>= 1)
+    foo ();
+}
+
+/* We should be able to find out that the loop iterates four times and unroll it completely.  */
+
+/* { dg-final { scan-tree-dump-times "Added canonical iv to loop 1, 4 iterations" 1 "ivcanon"} } */
+/* { dg-final { cleanup-tree-dump "ivcanon" } } */
+/* { dg-final { scan-tree-dump-times "Unrolled loop 1 completely" 1 "cunroll"} } */
+/* { dg-final { cleanup-tree-dump "cunroll" } } */
+/* { dg-final { scan-tree-dump-times "foo" 5 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+/* Because hppa, ia64 and Windows targets include an external declaration
+   for foo as well as the calls we need to look for something more specific
+   than just foo in order to count only the calls and not the declaration.  */
+/* The SH targets always use separate instructions to load the address
+   and to do the actual call - bsr is only generated by link time
+   relaxation.  */
+/* CRIS keeps the address in a register.  */
+/* m68k sometimes puts the address in a register, depending on CPU and PIC.  */
+
+/* { dg-final { scan-assembler-times "foo" 5 { xfail hppa*-*-* ia64*-*-* sh*-*-* cris-*-* crisv32-*-* fido-*-* m68k-*-* i?86-*-mingw* i?86-*-cygwin* } } } */
+/* { dg-final { scan-assembler-times "foo,%r" 5 { target hppa*-*-* } } } */
+/* { dg-final { scan-assembler-times "= foo"  5 { target ia64*-*-* } } } */
+/* { dg-final { scan-assembler-times "call\[ \t\]*_foo" 5 { target i?86-*-mingw* i?86-*-cygwin* } } } */
+/* { dg-final { scan-assembler-times "jsr|bsrf|blink\ttr?,r18"  5 { target sh*-*-* } } } */
+/* { dg-final { scan-assembler-times "Jsr \\\$r" 5 { target cris-*-* } } } */
+/* { dg-final { scan-assembler-times "\[jb\]sr" 5 { target fido-*-* m68k-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-10.c
new file mode 100644
index 000000000..03c2ddd51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-10.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+/* { dg-require-effective-target int32plus } */
+
+int bar (void);
+
+void foo (void)
+{
+  unsigned i, j, n;
+
+  for (i = 0; i < 100000; i++)
+    ;
+
+  n = bar ();
+  for (i = 0; i < n; i++)
+    ;
+
+  for (i = 0; i < n; i++)
+    for (j = 0; j < n; j++)
+      ;
+
+  /* These should not be removed.  */
+  for (i = 0; i < 10000; i++)
+    bar ();
+
+  for (i = 0; i != n; i += 2)
+    ;
+}
+
+/* { dg-final { scan-tree-dump-times "if " 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "bar " 2 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-11.c
new file mode 100644
index 000000000..d6c656f31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-11.c
@@ -0,0 +1,28 @@
+/* A test for final value replacement and higher-order ivs,
+   see PR 22442.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+void bar (unsigned);
+
+void foo (void)
+{
+  unsigned i, a;
+
+  for (i = 0; i < 5; i++)
+    a = i * i;
+
+  bar (a);
+}
+
+/* Final value of a gets replaced.  */
+
+/* { dg-final { scan-tree-dump-times "\\(16\\)" 1 "optimized" } } */
+
+/* And the empty loop is removed.  */
+
+/* { dg-final { scan-tree-dump-times "if " 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-14.c
new file mode 100644
index 000000000..987c7dea8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-14.c
@@ -0,0 +1,19 @@
+/* A test for final value replacement.  */
+
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int foo(void);
+
+int bla(void)
+{
+  int i, j = foo ();
+
+  for (i = 0; i < 100; i++, j++)
+    foo ();
+
+  /* Should be replaced with return j0 + 100;  */
+  return j;
+}
+
+/* { dg-final { scan-tree-dump-times "\\+ 100" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-15.c
new file mode 100644
index 000000000..ad0995d26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-15.c
@@ -0,0 +1,27 @@
+/* A test for # of iterations analysis (signed counter cannot wrap) and final
+   value replacement.  */
+
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int foo(void);
+
+int bla(void)
+{
+  int i, n = foo (), j;
+
+  j = 0;
+  /* The loop should be removed completely.  */
+  for (i = 1; i <= n; i++)
+    j += n;
+
+  /* Should be replaced with return n * n;  */
+  return j;
+}
+
+/* Since the loop is removed, there should be no addition.  */
+/* { dg-final { scan-tree-dump-times "\\+" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "n \\* n" 1 "optimized" } } */
+
+/* The if from the loop header copying remains in the code.  */
+/* { dg-final { scan-tree-dump-times "if " 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-16.c
new file mode 100644
index 000000000..50fa33330
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-16.c
@@ -0,0 +1,24 @@
+/* A test for # of iterations estimation.  We know that the loop is executed
+   at most 100 times, thus the (32-bit) induction variables do not overflow,
+   and we may use 64-bit variable to represent them.  */
+
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-do compile { target x86_64-*-* } } */
+
+unsigned a[100];
+
+void foo(unsigned n)
+{
+  unsigned i;
+
+  for (i = 0; i < n; i++)
+    a[i] = 4 * i;
+}
+
+/* Check that the memory reference was replaced with MEM, and that there is no
+   multiplication.  */
+
+/* { dg-final { scan-tree-dump-times "MEM" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\[^\\n\\r\]*= \\* " 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-17.c
new file mode 100644
index 000000000..d2903cef2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-17.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-sccp-details" } */
+
+/* To determine the number of iterations in this loop we need to fold
+   p_4 + 4B > p_4 + 8B to false.  This transformation has caused
+   troubles in the past due to overflow issues.  */
+
+int foo (int *p)
+{
+  int i = 0, *x;
+
+  for (x = p; x < p + 2; x++)
+    i++;
+
+  return i;
+}
+
+/* { dg-final { scan-tree-dump "set_nb_iterations_in_loop = 1" "sccp" } } */
+/* { dg-final { cleanup-tree-dump "sccp" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-18.c
new file mode 100644
index 000000000..ca75db941
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-18.c
@@ -0,0 +1,24 @@
+/* A test for # of iterations estimation.  We know that I does not overflow,
+   thus we can perform strength reduction (even though the 32-bit variable
+   i is first extended to 64-bit type).  */
+
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-do compile { target x86_64-*-* } } */
+
+unsigned bar(void);
+
+void foo(unsigned *p, unsigned n)
+{
+  unsigned i;
+
+  for (i = 0; i < n; i++)
+    p[i] = bar ();
+}
+
+/* Check that the memory reference was replaced with MEM, and that there is no
+   multiplication.  */
+
+/* { dg-final { scan-tree-dump-times "MEM" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\[^\\n\\r\]*= \\* " 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
new file mode 100644
index 000000000..cae91bac4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
@@ -0,0 +1,28 @@
+/* This tests strength reduction and choice of induction variables.  The targets
+   for this testcase are quite limited, as with different set of available
+   addressing modes, the results may be quite different.
+ 
+   The testcase comes from PR 29256 (and originally, the stream benchmark).  */
+
+/* { dg-do compile { target { i?86-*-* || { x86_64-*-* || powerpc_hard_double } } } } */
+/* { dg-require-effective-target nonpic } */
+/* { dg-options "-O3 -fdump-tree-final_cleanup" } */
+
+# define N      2000000
+static double   a[N],c[N];
+void tuned_STREAM_Copy()
+{
+  int j;
+  for (j=0; j<N; j++)
+    c[j] = a[j];
+}
+
+/* Check that the memory references are based on &a and &c, with appropriate
+   offsets.  Ideally, we would want each of them to appear once in the output.
+   However, due to a bug in jump threading, we end up peeling one iteration from
+   the loop, which creates an additional occurence.  */
+
+/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )a," 2 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "MEM.(base: &|symbol: )c," 2 "final_cleanup" } } */
+
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c
new file mode 100644
index 000000000..8f319594f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-2.c
@@ -0,0 +1,44 @@
+/* A test for strength reduction and induction variable elimination.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+/* { dg-require-effective-target size32plus } */
+
+/* Size of this structure should be sufficiently weird so that no memory
+   addressing mode applies.  */
+
+struct bla
+{
+  char x[187];
+  int y;
+  char z[253];
+} arr_base[100];
+
+void xxx(void)
+{
+  int iter;
+
+  for (iter = 0; iter < 100; iter++)
+    arr_base[iter].y = 17 * iter;
+}
+
+/* Access to arr_base[iter].y should be strength reduced, i.e., there should
+   be no multiplication.  */
+
+/* { dg-final { scan-tree-dump-times " \\* \[^\\n\\r\]*=" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\[^\\n\\r\]*= \\* " 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "MEM" 1 "optimized" } } */
+
+/* 17 * iter should be strength reduced.  */
+
+/* { dg-final { scan-tree-dump-times " \\* 17" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " \\+ 17" 1 "optimized" } } */
+
+/* The induction variable comparison with 99 should be eliminated
+   and replaced by comparison of one of the newly created ivs.  */
+
+/* { dg-final { scan-tree-dump-times "iter" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "99" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "100" 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-20.c
new file mode 100644
index 000000000..24524a02b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-20.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/29516 */
+
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O -ftree-vrp -fPIC -fdump-tree-ivopts" } */
+
+typedef struct gfc_se { int pre; } gfc_se;
+typedef struct gfc_ss_info { int dim[7]; } gfc_ss_info;
+int gfc_rank_cst[7 + 1];
+gfc_conv_array_transpose (gfc_se * se) {
+  int dest, src, dest_index, src_index;
+  gfc_ss_info *dest_info;
+  int n;
+  for (n = 0; n < 2; n++) {
+    dest_info->dim[n] = n;
+    src_index = gfc_rank_cst[1 - n];
+    a (se->pre, b (dest, dest_index), c (src, src_index));
+  }
+}
+
+/* Ivopts should not produce multiplication by a pointer constant.  */
+
+/* { dg-final { scan-tree-dump-times "\\* \[0-9\]*B;" 0 "ivopts" } } */
+/* { dg-final { cleanup-tree-dump "ivopts" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-21.c
new file mode 100644
index 000000000..59a17cb5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-21.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/30322 */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+
+extern void op( int, int);
+void foo(int f0, int f1, int e0, int e1)
+{
+  int i0, i1;
+
+  for (i1 = f1; i1 <= e1; ++i1)
+    for (i0 = f0; i0 <= e0; ++i0)
+      op(i0, i1);
+}
+
+/* { dg-final { scan-tree-dump-times "~" 0 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-22.c
new file mode 100644
index 000000000..be8cdcc77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-22.c
@@ -0,0 +1,17 @@
+/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+
+int a[100];
+
+void test (int n)
+{
+  int i;
+
+  for (i = 0; i < n; i += 3)
+    a[i] = i;
+}
+
+/* We used to replace the exit test "i < n" by "i != ((n-1)/3) * 3 + 1".  Although
+   correct, this transformation is obviously harmful.  */
+
+/* { dg-final { scan-tree-dump-times "/" 0 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-23.c
new file mode 100644
index 000000000..a16dc5f03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-23.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -funroll-loops -fdump-tree-cunroll-details" } */
+
+void bla(int);
+
+void foo(void)
+{
+  int i;
+
+  /* This loop used to appear to be too large for unrolling.  */
+  for (i = 0; i < 4; i++)
+    {
+      bla (i);
+      bla (2*i);
+      bla (3*i);
+      bla (4*i);
+      bla (5*i);
+      bla (6*i);
+      bla (7*i);
+      bla (8*i);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Unrolled loop 1 completely" 1 "cunroll" } } */
+
+/* { dg-final { cleanup-tree-dump "cunroll" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-24.c
new file mode 100644
index 000000000..dfad30dcd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-24.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fstrict-overflow -fdump-tree-empty" } */
+
+void foo(int a, int b)
+{ for(;a!=b;a+=4); }
+
+void foo2(int a, int b)
+{ for(;a<b;a+=4); }
+
+void foo3(int*a, int* b)
+{ for(;a<b;a++); }
+
+void foo4(int*a, int*b)
+{ for(;a!=b;a++); }
+
+/* { dg-final { scan-tree-dump-times "Removing empty loop" 4 "empty" } } */
+/* { dg-final { cleanup-tree-dump "empty" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-25.c
new file mode 100644
index 000000000..75580c1f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-25.c
@@ -0,0 +1,129 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-profile" } */
+
+int foo(void);
+void bla(void);
+void bar(void);
+
+void test1 (void)
+{
+  unsigned i;
+
+  /* Only one loop should be found here.  */
+  i = 0;
+  while (1)
+    {
+      i++;
+      if (i == 100)
+	break;
+
+      if (foo ())
+	bla ();
+      else
+	bar ();
+    }
+}
+
+void test2 (void)
+{
+  unsigned i, j;
+
+  /* Two loops should be found, in this case.  */
+  i = j = 0;
+  while (1)
+    {
+      j++;
+      foo ();
+      if (j < 100)
+	continue;
+
+      i++;
+      j = 0;
+      if (i == 100)
+	break;
+    }
+}
+
+void test3 (void)
+{
+  unsigned i, j, k;
+
+  /* Three loops.  */
+  i = j = k = 0;
+  while (1)
+    {
+      j++;
+      foo ();
+      if (j < 100)
+	continue;
+
+      j = 0;
+      k++;
+      if (k < 100)
+	continue;
+
+      k = 0;
+      i++;
+      if (i == 100)
+	break;
+    }
+}
+
+void test4 (void)
+{
+  unsigned i, j, k;
+
+  /* Two loops with a nested subloop.  */
+  i = j = 0;
+  while (1)
+    {
+      j++;
+      foo ();
+      for (k = 0; k < 100; k++)
+	foo ();
+
+      if (j < 100)
+	continue;
+
+      i++;
+      j = 0;
+      if (i == 100)
+	break;
+    }
+}
+
+
+void test5 (void)
+{
+  unsigned i, j;
+
+  /* Both subloop and non-subloop back edges.  */
+  i = j = 0;
+  while (1)
+    {
+      j++;
+      foo ();
+      if (j < 100)
+	continue;
+      j = 0;
+
+      i++;
+      if (i == 100)
+	break;
+
+      if (foo ())
+	bla ();
+      else
+	bar ();
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Disambiguating loop" 5 "profile" } } */
+/* For the following xfail marks, see PR35629.  */
+/* { dg-final { scan-tree-dump-times "Found latch edge" 5 "profile" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Merged latch edges" 2 "profile" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "4 loops found" 2 "profile" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "3 loops found" 2 "profile" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "2 loops found" 1 "profile" { xfail *-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "profile" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-26.c
new file mode 100644
index 000000000..5ebb3b1e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-26.c
@@ -0,0 +1,29 @@
+/* PR 30730, PR 26900, number of iterations analysis should be able to
+   determine number of iterations of the following loops unconditionally.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -fstrict-overflow -fdump-tree-empty" } */
+
+unsigned foo(unsigned int n)
+{
+  unsigned x = 0;;
+
+  while (n > 10)
+    {
+      n -= 2;
+      x++;
+    }
+
+  return x;
+}
+
+int foo0(int i0, int i1)
+{
+  int i, j = 0;
+  for (i=i0; i<=i1+1; ++i)
+    ++j;
+  return j;
+}
+
+/* { dg-final { scan-tree-dump-times "Removing empty loop" 2 "empty" } } */
+/* { dg-final { cleanup-tree-dump "empty" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
new file mode 100644
index 000000000..802b7c2aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-27.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/30565  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-pre -ftree-loop-linear" } */
+
+static double snrdef[32];
+void psycho_n1(double ltmin[2][32], int stereo)
+{
+  int i, k;
+
+  for (k = 0; k < stereo; k++)
+    for (i = 0; i < 32; i++)
+      ltmin[k][i] = snrdef[i];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-28.c
new file mode 100644
index 000000000..e0b1718a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-28.c
@@ -0,0 +1,24 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-final_cleanup -fdump-tree-aprefetch --param max-unrolled-insns=1000" } */
+
+char x[100000];
+
+void foo(int n)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    x[i] = (char) i;
+}
+
+/* This loop would not be prefetched as the hardware sequential
+prefetcher already prefetches it. */
+
+/* { dg-final { scan-tree-dump-times "MEM" 1 "final_cleanup" } } */
+
+/* There should be no i_a = i_b assignments.  */
+/* { dg-final { scan-tree-dump-times "i_.*= i_\[0-9\]*;" 0 "aprefetch" } } */
+
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-29.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-29.c
new file mode 100644
index 000000000..13699aafd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-29.c
@@ -0,0 +1,21 @@
+/* PR 31885 */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-empty" } */
+
+struct s {
+    int *blah;
+};
+
+static struct s array[] = { { 0 } };
+
+void
+foo (struct s *p)
+{
+  struct s *q = &array[1];
+  while (p < q)
+    p++;
+}
+
+/* { dg-final { scan-tree-dump-times "Removing empty loop" 1 "empty" } } */
+/* { dg-final { cleanup-tree-dump "empty" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c
new file mode 100644
index 000000000..9868c078d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-3.c
@@ -0,0 +1,30 @@
+/* A test for strength reduction and induction variable elimination.
+   Target is restricted to x86 type architectures, so that we may
+   assume something about memory addressing modes.  */
+
+/* { dg-do compile { target { { i?86-*-* x86_64-*-* } && nonpic } } } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int arr_base[100];
+
+int foo(int);
+
+void xxx(void)
+{
+  long iter;
+
+  for (iter = 0; iter < 100; iter++)
+    arr_base[iter] = foo (iter);
+}
+
+/* Access to arr_base[iter].y should not be strength reduced, since
+   we have a memory mode including multiplication by 4.  */
+
+/* { dg-final { scan-tree-dump-times "MEM" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "step:" 1 "optimized" } } */
+
+/* And original induction variable should be preserved.  */
+
+/* { dg-final { scan-tree-dump-times "int iter" 1 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-30.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-30.c
new file mode 100644
index 000000000..14d58e598
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-30.c
@@ -0,0 +1,14 @@
+/* PR 25371 */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+void
+slow_close(int n)
+{
+  int i;
+  double *mm;
+  for (i=0;i<2*n;i++)
+    for (i=0;i<2*n;i++)
+      *(mm+i*2*n+i) = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-31.c
new file mode 100644
index 000000000..cf5843ca7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-31.c
@@ -0,0 +1,19 @@
+/* PR 32283 */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+short a[(2048)];
+short foo (int len, int v)
+{
+  int i;
+  for (i = 0; i < len; i++) {
+      a[i] = v;
+  }
+  return a[0];
+}
+
+/* When we do not have addressing mode including multiplication,
+   the memory access should be strength-reduced.  */
+/* { dg-final { scan-tree-dump-times " \\+ 2" 1 "optimized" { target arm-*-* ia64-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-32.c
new file mode 100644
index 000000000..945ee2fcb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-32.c
@@ -0,0 +1,46 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+
+int x;
+int a[100];
+
+struct a
+{
+  int X;
+  int Y;
+};
+
+void bla(void);
+
+void test1(void)
+{
+  unsigned i;
+
+  /* We should perform store motion here.  */
+  for (x = 0; x < 100; x++)
+    a[x] = x;
+}
+
+void test2(void)
+{
+  unsigned i;
+
+  /* But not here.  */
+  for (x = 0; x < 100; x++)
+    bla ();
+}
+
+void test3(struct a *A)
+{
+  unsigned i;
+
+  /* But we should here (using base + offset analysis).  */
+  for (i = 0; i < 100; i++)
+    {
+      A[5].X += i;
+      A[5].Y += i;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Executing store motion of" 3 "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-33.c
new file mode 100644
index 000000000..6b9b67f3e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-33.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+
+int x;
+int a[100];
+
+struct a
+{
+  int X;
+  int Y;
+};
+
+struct a arr[100];
+
+void test4(unsigned b)
+{
+  unsigned i;
+
+  /* And here.  */
+  for (i = 0; i < 100; i++)
+    {
+      arr[b+8].X += i;
+      arr[b+9].X += i;
+    }
+}
+
+void test5(struct a *A, unsigned b)
+{
+  unsigned i;
+
+  /* And here as well.  */
+  for (i = 0; i < 100; i++)
+    {
+      A[b].X += i;
+      A[b+1].Y += i;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Executing store motion of" 4 "lim" { xfail lp64 } } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-34.c
new file mode 100644
index 000000000..4a0d1eaad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-34.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+
+int r[6];
+
+void f (int n)
+{
+  while (-- n)
+    {
+      r [0] += r [5];
+      r [1] += r [0];
+      r [2] += r [1];
+      r [3] += r [2];
+      r [4] += r [3];
+      r [5] += r [4];
+    }
+}
+
+
+/* { dg-final { scan-tree-dump-times "Executing store motion of r" 6 "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-35.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-35.c
new file mode 100644
index 000000000..e1bdde240
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-35.c
@@ -0,0 +1,65 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+
+int x;
+int a[100];
+
+struct a
+{
+  int X;
+  int Y;
+};
+
+struct a arr[100];
+
+void test1(int b)
+{
+  unsigned i;
+
+  /* And here.  */
+  for (i = 0; i < 100; i++)
+    {
+      arr[b+8].X += i;
+      arr[b+9].X += i;
+    }
+}
+
+void test2(struct a *A, int b)
+{
+  unsigned i;
+
+  /* And here as well.  */
+  for (i = 0; i < 100; i++)
+    {
+      A[b].X += i;
+      A[b+1].Y += i;
+    }
+}
+
+void test3(unsigned long b)
+{
+  unsigned i;
+
+  /* And here.  */
+  for (i = 0; i < 100; i++)
+    {
+      arr[b+8].X += i;
+      arr[b+9].X += i;
+    }
+}
+
+void test4(struct a *A, unsigned long b)
+{
+  unsigned i;
+
+  /* And here as well.  */
+  for (i = 0; i < 100; i++)
+    {
+      A[b].X += i;
+      A[b+1].Y += i;
+    }
+}
+/* long index not hoisted for avr target PR 36561 */
+/* { dg-final { scan-tree-dump-times "Executing store motion of" 8 "lim" { xfail { "avr-*-*" } } } } */
+/* { dg-final { scan-tree-dump-times "Executing store motion of" 6 "lim" { target { "avr-*-*" } } } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-36.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-36.c
new file mode 100644
index 000000000..0af4d534a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-36.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dce2" } */
+
+struct X { float array[4]; };
+
+struct X a,b;
+
+float foobar () {
+  float s = 0;
+  unsigned int d;
+  struct X c;
+  for (d=0; d<4; ++d)
+    c.array[d] = a.array[d] * b.array[d];
+  for (d=0; d<4; ++d)
+    s+=c.array[d];
+  return s;
+}
+
+/* The temporary structure should have been promoted to registers
+   by FRE after the loops have been unrolled by the early unrolling pass.  */
+/* { dg-final { scan-tree-dump-not "c\.array" "dce2" } } */
+/* { dg-final { cleanup-tree-dump "dce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-37.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-37.c
new file mode 100644
index 000000000..46b26bb87
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-37.c
@@ -0,0 +1,27 @@
+/* { dg-do link } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+static const int my_array [3] = { 4, 5, 6 };
+
+void f0 (void)
+{
+  int j, sum = 0;
+  for (j = 0; j < 3; j ++)
+    sum += my_array [j];
+  if (15 != sum)
+    link_error ();
+}
+
+int f1 (int a [])
+{
+  int j, sum = 0;
+  for (j = 0; j < 3; j ++)
+    sum += a [j] + my_array [j];
+  return sum;
+}
+
+int main() { }
+
+/* { dg-final { scan-tree-dump-not "my_array" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-4.c
new file mode 100644
index 000000000..a6c8c8fd3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-4.c
@@ -0,0 +1,46 @@
+/* A test for strength reduction and induction variable elimination.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+/* { dg-require-effective-target size32plus } */
+
+/* Size of this structure should be sufficiently weird so that no memory
+   addressing mode applies.  */
+
+struct bla
+{
+  char x[187];
+  int y;
+  char z[253];
+} arr_base[100];
+
+int foo(void);
+
+void xxx(void)
+{
+  int iter;
+
+  for (iter = 0; iter < 100; iter++)
+    arr_base[iter].y = foo ();
+}
+
+/* Access to arr_base[iter].y should be strength reduced.  Depending on
+   whether we have an addressing mode of type [base + offset], one of the
+   following forms might get chosen:
+
+   -- induction variable with base &arr_base[0].y, the memory access of
+      form *iv = ...
+   -- induction variable with base 0, the memory access of form
+      *(iv + &arr_base[0].y) = ...
+
+   In any case, we should not have any multiplication.  */
+
+/* { dg-final { scan-tree-dump-times " \\* \[^\\n\\r\]*=" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\[^\\n\\r\]*= \\* " 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "MEM" 1 "optimized" } } */
+
+/* And the original induction variable should be eliminated.  */
+
+/* { dg-final { scan-tree-dump-times "iter" 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-5.c
new file mode 100644
index 000000000..f0ba475c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-5.c
@@ -0,0 +1,28 @@
+/* A test for induction variable merging.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+void foo(long);
+
+void xxx(void)
+{
+  long iter, jter;
+
+  for (iter = 0, jter = 2; iter < 100; iter++, jter++)
+    {
+      foo (iter);
+      foo (jter);
+    }
+}
+
+/* Only iter variable should remain.  */
+
+/* { dg-final { scan-tree-dump-times "int iter" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "jter" 0 "optimized" } } */
+
+/* And the use of jter should be replaced by iter + 2 */
+
+/* { dg-final { scan-tree-dump-times " \\+ 2" 1 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-6.c
new file mode 100644
index 000000000..992f671e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-6.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -funswitch-loops -fdump-tree-unswitch-details -fdump-tree-optimized" } */
+
+int ch;
+int a[100];
+
+void xxx(void)
+{
+  int i;
+
+  for (i = 0; i < 100; i++)
+    {
+      if (ch)
+	a[i] = ch;
+      else
+	a[i] = i;
+    }
+}
+
+/* Loop should be unswitched.  */
+
+/* { dg-final { scan-tree-dump-times "Unswitching loop" 1 "unswitch" } } */
+/* { dg-final { cleanup-tree-dump "unswitch" } } */
+
+/* In effect there should be exactly three conditional jumps in the final program.  */
+
+/* { dg-final { scan-tree-dump-times "else" 3 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-7.c
new file mode 100644
index 000000000..a4597b196
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-7.c
@@ -0,0 +1,35 @@
+/* PR tree-optimization/19828 */
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-lim-details" } */
+
+int cst_fun1 (int) __attribute__((__const__));
+int cst_fun2 (int) __attribute__((__const__));
+int pure_fun1 (int) __attribute__((__pure__));
+int pure_fun2 (int) __attribute__((__pure__));
+int foo (void);
+
+int xxx (void)
+{
+  int i, k = foo (), x = 0;
+
+  for (i = 0; i < 100; i++)
+    {
+      x += cst_fun1 (k);
+      x += pure_fun1 (k);
+
+      if (k)
+	{
+	  x += cst_fun2 (k);
+	  x += pure_fun2 (k);
+	}
+    }
+
+  return x;
+}
+
+/* Calls to cst_fun1 and pure_fun1 may be moved out of the loop.
+   Calls to cst_fun2 and pure_fun2 should not be, since calling
+   with k = 0 may be invalid.  */
+
+/* { dg-final { scan-tree-dump-times "Moving statement" 3 "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-8.c
new file mode 100644
index 000000000..de439c719
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-8.c
@@ -0,0 +1,25 @@
+/* A test for strength reduction of ivs with nonconstant step.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int bar (void);
+
+int a[100];
+
+void xxx (void)
+{
+  int iter, step = bar ();
+
+  for (iter = 0; iter < 10; iter++)
+    a[iter * step] = bar ();
+}
+
+/* The array access should be strength reduced.  But to determine the value of
+   the step, we need to calculate step * sizeof (int), thus we need to be
+   a bit careful about which multiplications we disallow.  */
+
+/* { dg-final { scan-tree-dump-times "step \\* \[^0-9\]" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\[^0-9\] \\* step" 0 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-9.c
new file mode 100644
index 000000000..c4b47c054
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/loop-9.c
@@ -0,0 +1,24 @@
+/* Without TARGET_MEM_REFs, dom creates code like
+   
+   i1 = 4 * i;
+   *(p + i1) = i;
+   *(p + i1 + 4) = i
+   
+   causing us to have unnecessary multiplication by 4 in the
+   result.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+void foo (int *p)
+{
+  int i;
+
+  for (i = 0; i < 100; i++)
+    {
+      p[i] = i;
+      p[i + 1] = i;
+    }
+}
+
+/* { dg-final { scan-assembler-times "lea\\t" 0 { target i?86-*-* x86_64-*-* } } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
new file mode 100644
index 000000000..736a4d955
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+double u[1782225];
+int foo(int N, int *res)
+{
+  int i, j;
+  double sum = 0.0;
+  /* This loop should be converted to a perfect nest and
+     interchanged. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	sum = sum + u[i + 1335 * j];
+      
+      u[1336 * i] *= 2;
+    }
+  *res = sum + N;
+}
+/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 1 "ltrans"} } */ 
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
new file mode 100644
index 000000000..9548bf217
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+double u[1782225];
+int foo(int N, int *res)
+{
+  unsigned int i, j;
+  double sum = 0;
+  
+  /* This loop should be converted to a perfect nest and
+     interchanged.  */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+	  sum = sum + u[i + 1335 * j];
+	  if (j == N - 1)
+	    u[1336 * i] *= 2;
+	}
+    }
+  *res = sum + N;
+}
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} {
+   xfail *-*-*} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
new file mode 100644
index 000000000..51508f98a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-3.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+double u[1782225];
+int foo(int N, int *res)
+{
+  unsigned int i, j;
+  double sum = 0;
+      for (i = 0; i < N; i++)
+	{
+	  for (j = 0; j < N; j++)
+	    {
+	      sum = sum + u[i + 1335 * j];
+	    }
+	}
+      *res = sum + N;
+}
+
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans" } } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
new file mode 100644
index 000000000..e2d6abced
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-4.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+double u[1782225];
+int foo(int N, int *res)
+{
+  int i, j;
+  double sum = 0;
+  for (i = 0; i < N; i++)	
+    for (j = 0; j < N; j++)
+      sum = sum + u[i + 1335 * j];
+  
+  for (i = 0; i < N; i++)
+    u[1336 * i] *= 2;
+  *res = sum + N;
+}
+
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
new file mode 100644
index 000000000..2f64925e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-5.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target { size32plus } } } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+
+int foo ()
+{
+  int A[100][1111];
+  int i, j;
+
+  for( i = 0; i < 1111; i++)
+    for( j = 0; j < 100; j++)
+      A[j][i] = 5 * A[j][i];
+
+  return A[10][10];
+}
+
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
new file mode 100644
index 000000000..edf30a3d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-6.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+
+
+int medium_loop_interchange(int A[100][200])
+{
+  int i,j;
+
+  /* This loop should be interchanged. */
+
+  for(j = 0; j < 200; j++)
+    for(i = 0; i < 100; i++)
+      A[i][j] = A[i][j] + A[i][j];
+
+  return A[1][1];
+}
+
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
new file mode 100644
index 000000000..21f8ffafc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+double foo(double *a)
+{
+       int i,j;
+       double r = 0.0;
+      for (i=0; i<100; ++i)
+               for (j=0; j<1000; ++j)
+                      r += a[j*100+i];
+       return r;
+}
+
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-1.c
new file mode 100644
index 000000000..b29516936
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-1.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(int a, int b, int c)
+{
+  if (c == 0) goto temp;
+  if (a == 0)
+   return 0;
+temp:
+  if (a == b)
+   return a;
+ return a;
+}
+
+/* There should be no ifs as the PHI arguments, we did not
+   optimize this before because PHI-OPT did not look at 
+   PHIs which have more than two arguments.  */
+/* { dg-final { scan-tree-dump-times "if" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-2.c
new file mode 100644
index 000000000..415c11777
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+_Bool f1(_Bool a, _Bool b)
+{
+  if (a)
+   {
+     if (b)
+      return 1;
+     else
+      return 0;
+   }
+  return 0;
+}
+
+
+/* There should be only one if, the outer one; the inner one
+   should have been changed to straight line code with the
+   value of b (except that we don't fold ! (b != 0) into b
+   which can be fixed in a different patch).  */
+/* { dg-final { scan-tree-dump-times "if" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-3.c
new file mode 100644
index 000000000..54970ad80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-3.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(int a, int b)
+{
+  if (a == 0)
+   return 0;
+  if (a != b)
+   return a;
+ return a;
+}
+
+/* There should be no ifs as the PHI arguments, we did not
+   optimize this before because PHI-OPT did not look at 
+   PHIs which have more than two arguments.  */
+/* { dg-final { scan-tree-dump-times "if" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-4.c
new file mode 100644
index 000000000..efd9228b6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-4.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+_Bool t();
+_Bool t1();
+
+_Bool f1()
+{
+  return t() && t1();
+}
+
+/* There should be only one if, the outer one; the inner one
+   should have been changed to straight line code with the
+   value of b (except that we don't fold ! (b != 0) into b
+   which means that we miss a sib calling opportunity).  */
+/* { dg-final { scan-tree-dump-times "if " 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-5.c
new file mode 100644
index 000000000..7a930dd45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/phi-opt-5.c
@@ -0,0 +1,59 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ffinite-math-only -fdump-tree-phiopt1" } */
+
+float repl1 (float varx)
+{
+  if (varx < 0.0)
+    return 0.0;
+  else if (varx > 1.0)
+    return 1.0;
+  else
+    return varx;
+}
+
+/* Should be turned to
+
+   varx_4 = MIN_EXPR <1.0e+0, varx_2>;
+   varx_5 = MAX_EXPR <varx_4, 0.0>;  */  
+
+/* { dg-final { scan-tree-dump "varx.*MIN_EXPR.*1\\.0" "phiopt1"} } */
+/* { dg-final { scan-tree-dump "varx.*MAX_EXPR.*0\\.0" "phiopt1"} } */
+
+float repl2 (float vary)
+{
+  if (vary > 1.0)
+    return 1.0;
+  else if (vary < 0.0)
+    return 0.0;
+  else
+    return vary;
+}
+
+/* Should be turned to
+
+   vary_4 = MAX_EXPR <0.0, vary_2>;
+   vary_5 = MIN_EXPR <vary_4, 1.0e+0>;  */
+
+/* { dg-final { scan-tree-dump "vary.*MAX_EXPR.*0\\.0" "phiopt1"} } */
+/* { dg-final { scan-tree-dump "vary.*MIN_EXPR.*1\\.0" "phiopt1"} } */
+
+float repl3 (float varz, float vara, float varb)
+{
+  if (varz > vara)
+    return vara;
+  else if (varz < varb)
+    return varb;
+  else
+    return varz;
+}
+
+/* Should be turned to
+
+  if (varz_2 > vara_3) goto <L4>; else goto <L1>;
+
+<L1>:;
+  vara_6 = MAX_EXPR <varb_5, varz_2>;  */
+
+/* { dg-final { scan-tree-dump "if .*varz" "phiopt1"} } */
+/* { dg-final { scan-tree-dump "vara.*MAX_EXPR" "phiopt1"} } */
+/* { dg-final { cleanup-tree-dump "phiopt1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14341.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14341.c
new file mode 100644
index 000000000..0287a25cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14341.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+/* { dg-require-effective-target int32plus } */
+
+void fn_call (int);
+int h(int, int);
+void t()
+{
+  int i;
+  int x;
+    for( i = 0; i < 100000000; i++ ){ 
+ 	fn_call (i < 100000000);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "fn_call \\(1\\)" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c
new file mode 100644
index 000000000..b69bb70d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -fdump-tree-gimple" } */
+int g(int x)
+{
+   return (x - 10) < 0;
+}
+/* There should be only x <= 9 and no x - 10. */
+/* { dg-final { scan-tree-dump-times "<= 9" 1 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "\\+ -10" 0 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c
new file mode 100644
index 000000000..925442bb4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-2.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple -fwrapv" } */
+int g(int x)
+{
+   return (x - 10) < 0;
+}
+/* There should be no x >= 9 and one x - 10. */
+/* { dg-final { scan-tree-dump-times "<= 9" 0 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "\\+ -10" 1 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c
new file mode 100644
index 000000000..bf63d3afc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-3.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fstrict-overflow -fdump-tree-gimple" } */
+int g(int x)
+{
+   return (x + 10) < 0;
+}
+/* There should be only x < -10 and no x + 10. */
+/* { dg-final { scan-tree-dump-times "< -10" 1 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "\\+ 10" 0 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c
new file mode 100644
index 000000000..90a49bbdd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14490-4.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple -fwrapv" } */
+int g(int x)
+{
+   return (x + 10) < 0;
+}
+/* There should be no x < -10 and one x + 10. */
+/* { dg-final { scan-tree-dump-times "< -10" 0 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "\\+ 10" 1 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14814.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14814.c
new file mode 100644
index 000000000..a5bf8c85e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14814.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop2" } */
+
+
+struct YY {
+  double e[3];  };
+
+static inline double *y(struct YY* this_1) { return &this_1->e[1]; }
+
+struct XX {
+  struct YY v;
+ };
+
+static inline struct YY direction (const struct  XX* this_1) { return this_1->v;}
+
+int foo(const struct XX* r) {
+  struct YY t = direction(r);
+  if (*y(&t) < 0.000001) return 0;
+  return 1;
+}
+
+/* { dg-final { scan-tree-dump-times "&" 0 "forwprop2" } } */
+/* { dg-final { cleanup-tree-dump "forwprop2" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c
new file mode 100644
index 000000000..cc6e0158b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr14841.c
@@ -0,0 +1,29 @@
+/* PR tree-optimization/14841
+   Make sure that we can fold a possible nested reference into a
+   constant aggregate.  */
+
+/* { dg-do link } */
+/* { dg-options "-O" } */
+
+struct car {
+  int speed;
+  int tire_pressure[4];
+};
+
+static const struct car cars[] = {
+  { 75, { 10, 20, 30, 40 } },
+  { 35, { 12, 34, 56, 78 } },
+  { 40, { 19, 28, 37, 46 } }
+};
+
+extern void link_error (void);
+
+void
+foo (void)
+{
+  if (cars[1].tire_pressure[2] != 56)
+    link_error ();
+}
+
+int main () { return 0; }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15349.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15349.c
new file mode 100644
index 000000000..9f15d727f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15349.c
@@ -0,0 +1,26 @@
+/* PR 15349.  Merge two PHI nodes.  */
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-mergephi" } */
+
+int
+foo (int a, int b)
+{
+  int t;
+
+  if (b)
+    {
+      if (a)
+	t = 3;
+      else
+	t = 5;
+
+      a = 0;
+    }
+  else
+    t = 7;
+
+  return t;
+}
+
+/* { dg-final { scan-tree-dump-times "PHI" 1 "mergephi2"} } */
+/* { dg-final { cleanup-tree-dump "mergephi\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-1.c
new file mode 100644
index 000000000..68f14adad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-1.c
@@ -0,0 +1,25 @@
+/* { dg-do link } */
+
+void link_error ();
+
+int main ()
+{
+  struct { int b[2]; } x;
+  int b[2];
+  if (&b[1] != &b[1])
+    link_error ();
+  if (&b[0] != b)
+    link_error ();
+  if (b == &b[2])
+    link_error ();
+  if (b != b)
+    link_error ();
+  if (&x.b[1] == &x.b[0])
+    link_error ();
+  if (x.b != &x.b[0])
+    link_error ();
+  if (&x.b[1] == x.b)
+    link_error ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-2.c
new file mode 100644
index 000000000..df68bfeba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-2.c
@@ -0,0 +1,13 @@
+/* { dg-do link } */
+/* { dg-options "" } */
+
+void link_error ();
+struct a {};
+int main ()
+{
+  struct a b[2];
+  if (&b[0] != &b[1])
+    link_error ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-3.c
new file mode 100644
index 000000000..2fd03e2e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int f(int i, unsigned j)
+{
+      int b[2];
+      if (&b[i] == &b[j])
+	      return 1;
+      return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "i == j" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-4.c
new file mode 100644
index 000000000..82be2e33a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-4.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int f(int i, int j)
+{
+    int b[2][2];
+    if (&b[1][i] == &b[0][j])
+      return 1;
+    return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "i == j" 0 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-5.c
new file mode 100644
index 000000000..06ce523a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr15791-5.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+int foo(int i, int j)
+{
+	char g[16];
+	if (&g[i] == &g[j])
+		return 1;
+	return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "i == j" 1 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr16721.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr16721.c
new file mode 100644
index 000000000..eec753405
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr16721.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fno-strict-aliasing -fdump-tree-optimized" } */
+
+struct data {
+	volatile unsigned long *addr;
+} *p;
+
+int test()
+{
+	*p->addr;
+	return 0;
+}
+
+/* The load from p->addr should not disappear.  */
+/* { dg-final { scan-tree-dump-times "\->addr" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17141-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17141-1.c
new file mode 100644
index 000000000..af8675150
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17141-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-forwprop1" } */
+
+struct A { int i; };
+int
+foo(struct A *locp, int str)
+{
+  int T355, *T356;
+  T356 = &locp->i;
+  *T356 = str;
+  return locp->i;
+}
+
+/* { dg-final { scan-tree-dump "locp.*->i =" "forwprop1" } } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17141-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17141-2.c
new file mode 100644
index 000000000..37782cafe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17141-2.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+
+
+void abort (void);
+struct a
+{
+  int i;
+} *a;
+int f(void)
+{
+  int *ii = &a->i;
+  void *l;
+  a->i = 1;
+  if (*ii)
+   l = &&l1;
+  else
+   l = &&l2;
+  goto *l;
+l1:
+  return 0;
+l2:
+  abort ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "&" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "abort" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17598.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17598.c
new file mode 100644
index 000000000..ac912a2b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr17598.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+struct f
+{
+  int i;
+  int j;
+};
+
+struct g
+{
+  int i;
+  struct f j;
+  struct f *k;
+};
+
+int foo(struct f *x, struct f *y)
+{
+  return &x->j == &y->j; /* x == y */
+}
+
+struct f y;
+int bar(struct f *x)
+{
+  return &x->j == &y.j; /* x == &y */
+}
+
+struct g yy;
+int foobar(struct g *x)
+{
+  return &x->j.i == &yy.j.i; /* x == &yy */
+}
+int foobar2(struct g *x)
+{
+  return &x->k->i == &yy.k->i; /* x->k == yy.k */
+}
+
+/* { dg-final { scan-tree-dump-times "x == y" 1 "gimple" } } */
+/* { dg-final { scan-tree-dump-times "x == &y" 2 "gimple" } } */
+/* { dg-final { scan-tree-dump "x->k" "gimple" } } */
+/* { dg-final { scan-tree-dump "yy.k" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c
new file mode 100644
index 000000000..f225f662d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18133-1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized-blocks" } */
+
+void foo (void)
+{
+void *p;
+p = &&L0;
+goto *p;
+L0:
+return;
+}
+
+/* The goto &L0 should have been optimized away during CFG
+   cleanups.  */
+/* { dg-final { scan-tree-dump-times "goto &L0" 0 "optimized" } } */
+
+/* There should not be any abnormal edges as DOM removed the
+   computed goto.  */
+
+/* { dg-final { scan-tree-dump-times "ab" 0 "optimized" } } */
+
+/* And verify that we have fixed the fallthru flag as well. 
+   After DOM we will have two fallthru edges (e->0, 0->1),
+   but in the dump files we mention the 0->1 two times.  So
+   scan for 3 instances of "fallthru".  */
+
+/* { dg-final { scan-tree-dump-times "fallthru" 3 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18133-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18133-2.c
new file mode 100644
index 000000000..9d04ded45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18133-2.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized-blocks" } */
+
+int c, d;
+
+int
+bar (int a)
+{
+  void *p;
+  int b;
+
+  if (a!=0)
+    {
+      b = 3;
+      p = &&L0;
+    }
+  else
+    {
+      b = 5;
+      p = &&L1;
+    }
+
+  goto *p;
+
+ L0:
+  c = b;
+  return 1;
+
+ L1:
+  d = b;
+  return 0;
+}
+
+/* The both paths to the block containing the goto *p should
+   have been threaded, thus eliminating the need for the goto *p.  */
+
+/* { dg-final { scan-tree-dump-times "goto p" 0 "optimized" } } */
+
+/* There should not be any abnormal edges as DOM removed the
+   computed goto.  */
+
+/* { dg-final { scan-tree-dump-times "ab" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18134.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18134.c
new file mode 100644
index 000000000..d126313fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr18134.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int  foo (int a)
+{
+void *p;
+if (a!=0)
+  p = &&L0;
+else
+  p = &&L1;
+goto *p;
+L0:
+return 1;
+L1:
+return 0;
+}
+
+/* Everything should have been cleaned up leaving a simple
+   return statement.  */
+/* { dg-final { scan-tree-dump-times "return.*a != 0" 1 "optimized" } } */
+
+/* There should not be any abnormal edges as DOM removed the
+   computed gotos.  */
+
+/* { dg-final { scan-tree-dump-times "ab" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19055-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19055-2.c
new file mode 100644
index 000000000..739d69c0e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19055-2.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+int f1(int a,int b,int c,int d)
+{
+  return ((a&d)|(b&c)) ^ (b&c);
+}
+
+int f2(int a,int b,int c,int d)
+{
+  return (b&c) ^ ((a&d)|(b&c));
+}
+
+int f3(int a,int b,int c,int d)
+{
+  return ((b&c)|(a&d)) ^ (b&c);
+}
+
+int f4(int a,int b,int c,int d)
+{
+  return (b&c) ^ ((b&c)|(a&d));
+}
+
+/* There should be no ^, 4 ~ and 12 &. */
+/* { dg-final { scan-tree-dump-times "\\^" 0 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "~" 4 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "&" 12 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19055.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19055.c
new file mode 100644
index 000000000..055a96c1c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19055.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+int f1(int a,int b)
+{
+  return (a|b) ^ b;
+}
+int f2(int a,int b)
+{
+  return (b|a) ^ b;
+}
+int f3(int a,int b)
+{
+  return b^(a|b);
+}
+int f4(int a,int b)
+{
+  return b^(b|a);
+}
+/* There should be no ^, 4 ~ and 4 &. */
+/* { dg-final { scan-tree-dump-times "\\^" 0 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "~" 4 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "&" 4 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c
new file mode 100644
index 000000000..906132c69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wunsafe-loop-optimizations" } */
+extern void g(void);
+
+void
+f (unsigned n)
+{
+  unsigned k;
+  for(k = 0;k <= n;k++) /* { dg-warning "cannot optimize.*infinite loops" } */
+    g();
+
+  for(k = 0;k <= n;k += 4) /* { dg-warning "cannot optimize.*overflow" } */
+    g();
+
+  /* We used to get warning for this loop.  However, since then # of iterations
+     analysis improved, and we can now prove that this loop does not verflow.
+     This is because the only case when it would overflow is if n = ~0 (since
+     ~0 is divisible by 5), and this cannot be the case, since when we got
+     here, the previous loop exited, thus there exists k > n.  */
+  for(k = 5;k <= n;k += 5)
+    g();
+
+  /* So we need the following loop, instead.  */
+  for(k = 4;k <= n;k += 5) /* { dg-warning "cannot optimize.*overflow" } */
+    g();
+  
+  for(k = 15;k >= n;k--) /* { dg-warning "cannot optimize.*infinite" } */
+    g();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19210-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19210-2.c
new file mode 100644
index 000000000..9116e97ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19210-2.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -funsafe-loop-optimizations -Wunsafe-loop-optimizations" } */
+extern void g(void);
+
+void
+f (unsigned n)
+{
+  unsigned k;
+  for(k = 0;k <= n;k++) /* { dg-warning "assuming.*not infinite" } */
+    g();
+
+  for(k = 5;k <= n;k += 4) /* { dg-warning "assuming.*not overflow" } */
+    g();
+
+  /* We used to get warning for this loop.  However, since then # of iterations
+     analysis improved, and we can now prove that this loop does not verflow.
+     This is because the only case when it would overflow is if n = ~0 (since
+     ~0 is divisible by 5), and this cannot be the case, since when we got
+     here, the previous loop exited, thus there exists k > n.  */
+  for(k = 5;k <= n;k += 5)
+    g();
+
+  for(k = 4;k <= n;k += 5) /* { dg-warning "assuming.*not overflow" } */
+    g();
+
+  for(k = 15;k >= n;k--) /* { dg-warning "assuming.*not infinite" } */
+    g();
+
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c
new file mode 100644
index 000000000..4334648ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+/* We want this optimized as
+<bb 2>:
+  if (k != 0) goto <L2>; else goto <L3>;
+
+<L3>:;
+  i1 = j1;
+
+<L2>:;
+  return i1;
+
+  This requires that i1 and j1 are changed into registers after they
+  no longer have their address taken.  */
+
+int f(int k, int i1, int j1)
+{
+  int *f1;
+  if(k)
+   f1 = &i1;
+  else
+   f1 = &j1;
+  return *f1;
+}
+
+/* { dg-final { scan-tree-dump "i1 = j1" "optimized" } } */
+/* { dg-final { scan-tree-dump "return i1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19590.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19590.c
new file mode 100644
index 000000000..1be1119da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19590.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ivopts" } */
+
+void vnum_test8(int *data) 
+{ 
+  int i; 
+  int stop = data[3]; 
+  int m = data[4]; 
+  int n = m; 
+  for (i=1; i<stop; i++) { 
+    int k = data[2]; 
+    data[k] = 2; 
+    data[0] = m - n; 
+    k = data[1]; 
+    m = m + k; 
+    n = n + k; 
+  } 
+} 
+
+/* Using the SCEV analysis, this loop should be transformed to:
+
+   | void vnum_result8(int *data) 
+   |{ 
+   |  int i; 
+   |  int stop = data[3]; 
+   |  for (i=1; i<stop; i++) { 
+   |    int k = data[2]; 
+   |    data[k] = 2; 
+   |    data[0] = 0; 
+   |  } 
+   |}
+
+*/
+
+/* { dg-final { scan-tree-dump-times "= 0;" 1 "ivopts"} } */
+/* { dg-final { scan-tree-dump-times "= 2;" 1 "ivopts"} } */
+/* { dg-final { cleanup-tree-dump "ivopts" } }  */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19633.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19633.c
new file mode 100644
index 000000000..01c7eec31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr19633.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-ssa-vops" } */
+struct S
+{
+  int w, x, y, z;
+};
+struct T
+{
+  int r;
+  struct S s;
+};
+void bar (struct S, int);
+void
+foo (int a, struct T b)
+{
+  struct S x;
+  struct S *c = &x;
+  if (a)
+    c = &b.s;
+  bar (*c, a);
+}
+
+/* Make sure that .GLOBAL_VAR is not created when there are no
+   clobbering calls.  */
+/* { dg-final { scan-tree-dump-times "GLOBAL_VAR" 0 "ssa"} } */
+/* { dg-final { cleanup-tree-dump "ssa" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20139.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20139.c
new file mode 100644
index 000000000..054e4b208
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20139.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/20139
+   This testcase is derived from gcc.dg/20020720-1.c.  Here we check
+   that the optimization happens at tree level.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+
+extern double fabs (double);
+extern void link_error (void);
+
+void
+foo (double x)
+{
+  double p, q;
+
+  p = fabs (x);
+  q = 0.0;
+  if (p < q)
+    link_error ();
+}
+
+/* { dg-final { scan-tree-dump-times "link_error" 0 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
new file mode 100644
index 000000000..aa482edab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20256.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+int foo()
+{
+  int x[2][2], y[2];
+  int i, n, s;
+
+  /* This is a reduction: there is a scalar dependence that cannot be
+     removed by rewriting IVs.  This code cannot and should not be
+     transformed into a perfect loop.  */
+  for (n = 0; n < 2; n++)
+    {
+      s = 0;
+      for (i = 0; i < 2; i++)
+        s += x[n][i]*y[i];
+      s += 1;
+    }
+
+  return s;
+}
+
+/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 0 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20470.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20470.c
new file mode 100644
index 000000000..b0d7492de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20470.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+/* PR tree-optimization/20470:
+    Missing fold to abs(x) when x == MINUS_EXPR.  */
+#define abs(x)  ((x) >= 0 ? (x) : -(x))
+
+int i,j,k;
+void f1()
+{
+  i = abs(j-k);
+}
+
+/* { dg-final { scan-tree-dump-times "ABS_EXPR" 1 "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20490.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20490.c
new file mode 100644
index 000000000..8edc35e8a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20490.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-pre" } */
+static int  a;
+static int  b;
+
+typedef int gint;
+
+int blah ()
+{
+	gint x = a;
+	gint y = b;
+
+	x *= (x < 0) ? -1 : 0;
+	y *= (y < 0) ? -1 : 0;
+
+	return (y * x);
+
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20657.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20657.c
new file mode 100644
index 000000000..1c3dbf9fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20657.c
@@ -0,0 +1,18 @@
+/* PR tree-optimization/20657
+   VRP did not pick up a conditional equivalence from the first "if"
+   statement, which was needed to eliminate the second "if" statement.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-vrp1-details" } */
+
+int
+foo (int a)
+{
+  if (a == 0)
+    if (a == 0)
+      return 1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate" 1 "vrp1"} } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20701.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20701.c
new file mode 100644
index 000000000..3ddf48e6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20701.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1 -fno-early-inlining" } */
+
+typedef struct {
+  int code;
+} *rtx;
+
+static inline void *zero ()
+{
+  return 0;
+}
+static inline int three ()
+{
+  return 3;
+}
+
+int
+can_combine_p (rtx insn, rtx elt)
+{
+  rtx set;
+
+  set = zero ();
+  if (insn->code == three ())
+    set = insn;
+  else
+    {
+      set = elt;
+      if (set == zero ())
+	return 0;
+    }
+
+  if (set == zero ())
+    return 1;
+
+  return 0;
+}
+
+/* Target with fno-delete-null-pointer-checks should not fold checks */
+/* { dg-final { scan-tree-dump-times "Folding predicate.*to 0" 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate.*to 0" 0 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20702.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20702.c
new file mode 100644
index 000000000..ce62fa3f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20702.c
@@ -0,0 +1,31 @@
+/* PR tree-optimization/20702
+   VRP did not insert ASSERT_EXPRs into dominator dominator children
+   of a basic block ending with COND_EXPR unless the children are also
+   immediate successors of the basic block.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-vrp1-details" } */
+
+extern void bar (int);
+
+int
+foo (int *p, int b)
+{
+  int a;
+
+  if (b)
+    bar (123);
+  else
+    bar (321);
+
+  a = *p;
+  if (p == 0)
+    return 0;
+
+  return a;
+}
+
+/* Target with fno-delete-null-pointer-checks should not fold checks */
+/* { dg-final { scan-tree-dump-times "Folding predicate" 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate" 0 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20739.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20739.c
new file mode 100644
index 000000000..c1e7b58e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20739.c
@@ -0,0 +1,24 @@
+/* PR middle-end/20739 */
+
+/* dg-do compile */
+/* dg-options "-O" */
+
+/* We used to fail to compile this because gimplification dropped the
+   conversion that added the const qualifier to the sub-expression
+   involving baz, and then immediately noticed and reported its
+   absence.  */
+
+typedef struct 
+{ 
+    char chars[5]; 
+} 
+baz_t; 
+ 
+extern baz_t * baz; 
+ 
+extern void foo (baz_t); 
+int 
+bar (const baz_t * ls) 
+{ 
+    foo (ls == 0 ? *(&baz[0]) : *ls); 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20913.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20913.c
new file mode 100644
index 000000000..fb5461a26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20913.c
@@ -0,0 +1,34 @@
+/* PR tree-optimization/20913
+   COPY-PROP did not fold COND_EXPR, blocking some copy propagation
+   opportunities.  */
+
+/* { dg-do link } */
+/* { dg-options "-O2 -fno-tree-dominator-opts" } */
+
+int
+foo (int a, int b, int c, int d)
+{
+  int x, y;
+
+  b = a;
+  if (a == b)
+    x = c;
+  else
+    {
+      link_error ();
+      x = d;
+    }
+
+  if (x == c)
+    return a;
+  else
+    {
+      link_error ();
+      return b;
+    }
+}
+
+main()
+{
+  foo (1, 2, 3, 4);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20933.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20933.c
new file mode 100644
index 000000000..d32d6003e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr20933.c
@@ -0,0 +1,70 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern __SIZE_TYPE__ strlen (__const char *__s)
+     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *getenv (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
+extern int access (__const char *__name, int __type) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
+extern void * xmalloc (__SIZE_TYPE__) __attribute__ ((__malloc__));
+
+static __inline__ const char *
+try (const char *dir, const char *base)
+{
+  if (base != 0)
+    return base;
+  if (dir != 0
+      && access (dir, 4 | 2 | 1) == 0)
+    return dir;
+  return 0;
+}
+
+static const char tmp[] = { '/', 't', 'm', 'p', 0 };
+static const char usrtmp[] =
+{ '/', 'u', 's', 'r', '/', 't', 'm', 'p', 0 };
+static const char vartmp[] =
+{ '/', 'v', 'a', 'r', '/', 't', 'm', 'p', 0 };
+
+static char *memoized_tmpdir;
+char *
+choose_tmpdir (void)
+{
+  const char *base = 0;
+  char *tmpdir;
+  unsigned int len;
+
+  if (memoized_tmpdir)
+    return memoized_tmpdir;
+
+  base = try (getenv ("TMPDIR"), base);
+  base = try (getenv ("TMP"), base);
+  base = try (getenv ("TEMP"), base);
+
+
+  base = try ("/tmp", base);
+
+
+
+  base = try (vartmp, base);
+  base = try (usrtmp, base);
+  base = try (tmp, base);
+
+
+  if (base == 0)
+    base = ".";
+
+
+
+  len = strlen (base);
+  tmpdir = xmalloc (len + 2);
+  strcpy (tmpdir, base);
+  /* Alias analysis was associating read-only memory tags to pointers
+     that are not read-only.  We would then not issue any V_MAY_DEF in
+     this store.  */
+  tmpdir[len] = '/';
+  tmpdir[len+1] = '\0';
+
+  memoized_tmpdir = tmpdir;
+  return tmpdir;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21001.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21001.c
new file mode 100644
index 000000000..84280b39c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21001.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/21001
+   VRP did not insert ASSERT_EXPRs when the variable tested in a
+   COND_EXPR is a single-use variable.  By propagating the definition
+   of the single-use variable into the COND_EXPR, we can get useful
+   range infomation out of the conditional.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-vrp1-details" } */
+
+int
+foo (int a)
+{
+  int b = a != 0;
+  if (b)
+    if (a != 0)
+      return 1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate" 1 "vrp1"} } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21029.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21029.c
new file mode 100644
index 000000000..de2595aee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21029.c
@@ -0,0 +1,118 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fwrapv" } */
+
+/* PR tree-optimization/21029
+
+   f() used to get optimized to an infinite loop by tree-vrp, because
+   j is assumed to be non-negative.  Even though the conversion from
+   unsigned to signed has unspecified results if the expression value
+   is not representable in the signed type, the compiler itself (e.g.,
+   the Ada front end) depends on wrap-around behavior.  */
+
+unsigned int f(void) {
+  unsigned char i = 123;
+  signed char j;
+
+  do
+    if ((j = (signed char) i) < 0)
+      break;
+    else
+      i++;
+  while (1);
+
+  return i;
+}
+
+/* Now let's torture it a bit further.  Narrowing conversions need
+   similar treatment.  */
+
+unsigned int f1 (void) {
+  unsigned short i = 123;
+  signed char j;
+
+  do
+    if ((j = (signed char) i) < 0)
+      break;
+    else
+      i++;
+  while (1);
+
+  return i;
+}
+
+/* And so do widening conversions.  */
+
+unsigned int f2 (void) {
+  unsigned char i = 123;
+  signed short j;
+
+  do
+    if ((j = (signed short) (signed char) i) < 0)
+      break;
+    else
+      i++;
+  while (1);
+
+  return i;
+}
+
+/* Check same-sign truncations with an increment that turns into
+   decrements.  */
+
+unsigned int f3 (void) {
+  signed short i = 5;
+  signed char j;
+
+  do
+    if ((j = (signed char) i) < 0)
+      break;
+    else
+      i += 255;
+  while (1);
+
+  return i;
+}
+
+/* Check that the truncation above doesn't confuse the result of the
+   test after a widening conversion.  */
+
+unsigned int f4 (void) {
+  signed short i = -123;
+  signed int j;
+
+  do
+    if ((j = (signed int) (signed char) i) > 0)
+      break;
+    else
+      i += 255;
+  while (1);
+
+  return i;
+}
+
+/* Even if we omit the widening truncation, the narrowing truncation
+   is implementation-defined.  */
+
+unsigned int f5 (void) {
+  signed long i = -123;
+  signed char j;
+
+  do
+    if ((j = (signed char) i) > 0)
+      break;
+    else
+      i += 255;
+  while (1);
+
+  return i;
+}
+
+int main (void) {
+  f ();
+  f1 ();
+  f2 ();
+  f3 ();
+  f4 ();
+  f5 ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21031.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21031.c
new file mode 100644
index 000000000..df200d564
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21031.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/21031
+
+   Make sure that a != 0 is propagated into the "if" statement.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-forwprop1-details" } */
+
+int
+foo (int a)
+{
+  int b = a != 0;
+  unsigned char c = b;
+  if (c)
+    return 1;
+  else
+    return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Replaced" 2 "forwprop1"} } */
+/* { dg-final { cleanup-tree-dump "forwprop1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21086.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21086.c
new file mode 100644
index 000000000..2409608d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21086.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int
+foo (int *p)
+{
+  int a = *p;
+  int b = p != 0;
+
+  *p = b;
+
+  if (b)
+    return a;
+  else
+    return 0;
+}
+
+/* Target with fno-delete-null-pointer-checks should not fold checks */
+/* { dg-final { scan-tree-dump-times "Folding predicate " 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate " 0 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-not "b_. =" "vrp1" { target { ! avr-*-* } } } } */
+/* { dg-final { scan-tree-dump "b_. =" "vrp1" { target { avr-*-* } } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21090.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21090.c
new file mode 100644
index 000000000..8e32e4217
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21090.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int g, h;
+
+int
+foo (int a)
+{
+  int *p;
+
+  if (a)
+    p = &g;
+  else
+    p = &h;
+
+  if (p != 0)
+    return 1;
+  else
+    return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21171.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21171.c
new file mode 100644
index 000000000..9f7278378
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21171.c
@@ -0,0 +1,29 @@
+/* PR 21171.  Ivopts should not rewrite references to volatile memory.  */
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+typedef	unsigned int u_int32_t;
+typedef	unsigned char u_int8_t;
+
+#define	AIC_VECTORS	32
+
+typedef volatile struct AT91RM9200_regs {
+  u_int32_t	SVR[AIC_VECTORS];
+} AT91RM9200_regs_t;
+
+#define CPUReg  ((AT91RM9200_regs_t*)0xFFF00000)
+
+extern const u_int32_t __IntTable[AIC_VECTORS];
+
+int main()
+{
+  int c;
+
+  for (c = 0; c < AIC_VECTORS; c++)
+    CPUReg->SVR[c] = __IntTable[c];
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "SVR" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21294.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21294.c
new file mode 100644
index 000000000..567e6366a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21294.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/21294
+   VRP did not notice that an address of the form &p->i is nonnull
+   when p is known to be nonnull.  In this testcase, noticing that
+   allows us to eliminate the second "if" statement.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-vrp1-details" } */
+
+struct f {
+  int i;
+};
+
+int
+foo (struct f *p)
+{
+  if (p != 0)
+    if (&p->i != 0)
+      return 123;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate" 1 "vrp1"} } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21332.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21332.c
new file mode 100644
index 000000000..8dd75ccc5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21332.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+// this testcase fails also on amd64:
+
+extern void abort (void);
+
+int f ()
+{
+  return -1;
+}
+
+int main ()
+{
+  int b, c, i;
+
+  b = 0;
+  c = f ();
+  if (c <= 0)
+    {
+      c = -c;
+      for (i = 0; i < c; i++)
+	  b = 1;
+      if (!b)
+	abort ();
+    }
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21417.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21417.c
new file mode 100644
index 000000000..4a2c82143
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21417.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dom2-details" } */
+
+struct tree_common 
+{ 
+  int code; 
+}; 
+union tree_node 
+{ 
+  struct tree_common common; 
+}; 
+typedef union tree_node *tree; 
+ 
+extern tree test (tree, int, int); 
+extern tree foo (void); 
+extern void abort (void) __attribute__ ((__noreturn__)); 
+ 
+tree 
+test (tree expr, int t, int D17630) 
+{ 
+  int __i; 
+ 
+L0: 
+  if (expr->common.code != 142) goto L23; else goto L2; 
+ 
+L2: 
+  __i = 0; 
+  goto L10; 
+ 
+L10: 
+  __i = __i + 1; 
+  if (D17630 != __i) goto L8; else goto L19; 
+ 
+L8: 
+  if (t) goto L15; else goto L10; 
+ 
+L15: 
+  expr = foo (); 
+  if (expr->common.code != 142) goto L23; else goto L0; 
+ 
+L19: 
+  abort (); 
+ 
+L23: 
+  return expr; 
+} 
+
+
+/* We should thread the backedge to the top of the loop; ie we only
+   execute the if (expr->common.code != 142) test once per loop
+   iteration.  */
+/* { dg-final { scan-tree-dump-times "Threaded jump" 1 "dom2" } } */
+/* { dg-final { cleanup-tree-dump "dom2" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21458.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21458.c
new file mode 100644
index 000000000..01777f6e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21458.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+extern void g (void);
+extern void bar (int);
+
+int
+foo (int a)
+{
+  int i;
+
+  for (i = 1; i < 100; i++)
+    {
+      if (i)
+	g ();
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21463.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21463.c
new file mode 100644
index 000000000..f490bf61e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21463.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-phiprop" } */
+
+struct f
+{
+  int i;
+};
+
+int g(int i, int c, struct f *ff, int g)
+{
+  int *t;
+  if (c)
+    t = &i;
+  else
+    t = &ff->i;
+  return *t;
+}
+
+/* { dg-final { scan-tree-dump-not "\\*t" "phiprop" } } */
+/* { dg-final { cleanup-tree-dump "phiprop" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c
new file mode 100644
index 000000000..34f4a01db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1-details" } */
+
+static int blocksize = 4096;
+
+int bar (int);
+
+void foo (void)
+{
+  int toread;
+  int bytes;
+  static char eof_reached = 0;
+
+  toread = blocksize;
+  bytes = 1;
+
+  while (toread != 0)
+    {
+      bytes = bar (toread);
+      if (bytes <= 0)
+        {
+          if (bytes < 0)
+            continue;
+          break;
+        }
+      toread -= bytes;
+    }
+
+  if (bytes == 0)
+    eof_reached = 1;
+}
+
+
+/* First, we should simplify the bits < 0 test within the loop.  */
+/* { dg-final { scan-tree-dump-times "Simplified relational" 1 "vrp1" } } */
+
+/* Second, we should thread the edge out of the loop via the break
+   statement.  We also realize that the final bytes == 0 test is useless,
+   and thread over it.  */
+/* { dg-final { scan-tree-dump-times "Threaded jump" 3 "vrp1" } } */
+
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21563.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21563.c
new file mode 100644
index 000000000..8e6c57850
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21563.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/21563
+   Make sure VRP folds the second "if" statement.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-vrp1-details" } */
+
+int
+foo (int a)
+{
+  if (a > 1)
+    if (a == 0)
+      return 1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate" 1 "vrp1"} } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21574.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21574.c
new file mode 100644
index 000000000..fc33d74e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21574.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+int
+foo (int *p)
+{
+  *p = 0;
+  return *p;
+}
+
+/* The store to *p should be propagated to the load statement.  */
+/* { dg-final { scan-tree-dump "Replaced \\\*p_.\\\(D\\\) with 0" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21582.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21582.c
new file mode 100644
index 000000000..0f5dc9ec1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21582.c
@@ -0,0 +1,28 @@
+/* { dg-do link }  */
+/* { dg-options "-O2 -fdump-tree-vrp1" }  */
+
+static inline void do_thing(char *s, int *p, char *q)
+{
+  	/* This should be folded away.  */
+        if (s == 0 || q == 0)
+                link_error ();
+
+	/* This should not be folded as 'p' is not marked nonnull.  */
+	if (p)
+	  	*p = 3;
+}
+
+void __attribute__((nonnull (1, 3))) do_other_thing(char *s, int *p, char *q)
+{
+        do_thing(s, p, q);
+}
+
+int i;
+
+main()
+{
+  do_other_thing ("xxx", &i, "yyy");
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*" 0 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21658.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21658.c
new file mode 100644
index 000000000..c1a48c04b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21658.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/21658
+   CCP did not propagate an ADDR_EXPR far enough, preventing the "if"
+   statement below from being folded.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-ccp1-details" } */
+
+void link_error (void);
+
+void
+f (void)
+{
+  int a[10];
+  int *p = &a[5];
+  int *q = p - 1;
+  if (q != &a[4])
+    link_error ();
+}
+
+/* { dg-final { scan-tree-dump-times "Folded into: if " 1 "ccp1"} } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21829.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21829.c
new file mode 100644
index 000000000..6b5c4bbf1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21829.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized -fdump-tree-cddce2" } */
+
+int test(int v)
+{
+  int x = 0;
+  int u;
+  for (u=0;u<2;u++)
+  {
+    if (u>v)
+    {
+      if (u%2==1)
+        x++;
+    }
+  }  
+  return x;
+}
+
+/* This should be optimized to
+
+    if (v <= 0) goto <L1>; else goto <L3>;
+
+   <L1>:;
+
+    # x_1 = PHI <0(3), 1(1)>;
+   <L3>:;
+    return x_1;
+
+   retaining only a single conditional.  This doesn't work as nobody
+   combines the two tests
+
+    if (v < 0) goto <bb 4>; else goto <bb 3>;
+
+   <bb 3>:
+
+    if (v <= 0) goto <bb 4>; else goto <bb 5>;
+
+   this late in the game.  tree-ssa-ifcombine.c would do it if we would
+   unroll the loop during early loop unrolling though.
+
+   For now vrp2 does all the needed folding and threading and cddce2
+   provides a nice IL to scan.  */
+
+/* { dg-final { scan-tree-dump-times "if " 1 "optimized" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "if " 2 "cddce2" } } */
+/* { dg-final { scan-tree-dump "x_. = PHI <0\\\(.\\\), 1\\\(.\\\)>" "cddce2" } } */
+/* { dg-final { cleanup-tree-dump "cddce2" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21959.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21959.c
new file mode 100644
index 000000000..decbcaf3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21959.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+unsigned char c[0xFF];
+void f(void)
+{
+  unsigned char i;
+  c[128] = 128;
+  i = 0;
+  while (1)
+  {
+    /* This predicate should not be folded out.  */
+    if (((signed char) i) < 0) break;
+    c[i] = ' ';
+    i++;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate " 0 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21985.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21985.c
new file mode 100644
index 000000000..19ad0f113
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr21985.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+struct
+{
+  struct
+    {
+      int a;
+      int b;
+    } a[100];
+} a;
+
+typedef __SIZE_TYPE__ size_t;
+void foo(size_t);
+size_t *bar (void);
+
+int
+main (void)
+{
+  size_t *b = bar ();
+
+  /* This should be folded.  */
+  foo (&a.a[50].a - &a.a[33].b);
+  foo ((size_t) &a.a[50].b - (size_t) &a);
+
+  /* And this should not.  */
+  foo ((size_t) &b - (size_t) b);
+  return 0;
+}
+
+/* Two of the calls to foo should be folded to just foo(constant).  */
+
+/* { dg-final { scan-tree-dump-times "foo \\(\[0-9\]*\\)" 2 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22018.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22018.c
new file mode 100644
index 000000000..d4d332c2f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22018.c
@@ -0,0 +1,32 @@
+/* { dg-do run }  */
+/* { dg-options -O2 }  */
+
+void abort (void);
+void g(int);
+void f(int l)
+{
+  unsigned i;
+  for (i = 0; i < l; i++)
+    {
+      int y = i;
+      /* VRP was wrongfully computing z's range to be [0, 0] instead
+	 of [-INF, 0].  */
+      int z = y*-32;
+      g(z);
+    }
+}
+
+void g(int i)
+{
+  static int x = 0;
+  if (i == 0)
+    x ++;
+  if (x > 1)
+    abort ();
+}
+
+int main(void)
+{
+  f(3);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22026.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22026.c
new file mode 100644
index 000000000..7e6914d9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22026.c
@@ -0,0 +1,49 @@
+/* PR tree-optimization/22026
+   VRP used think that ~[0,0] + ~[0,0] = ~[0,0], which is wrong.  The
+   same applies to subtraction and unsigned multiplication.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int
+plus (int x, int y)
+{
+  if (x != 0)
+    if (y != 0)
+      {
+        int z = x + y;
+        if (z != 0)
+          return 1;
+      }
+  return 0;
+}
+
+int
+minus (int x, int y)
+{
+  if (x != 0)
+    if (y != 0)
+      {
+        int z = x - y;
+        if (z != 0)
+          return 1;
+      }
+  return 0;
+}
+
+int
+mult (unsigned x, unsigned y)
+{
+  if (x != 0)
+    if (y != 0)
+      {
+	unsigned z = x * y;
+	if (z != 0)
+	  return 1;
+      }
+  return 0;
+}
+
+/* None of the predicates can be folded in these functions.  */
+/* { dg-final { scan-tree-dump-times "Folding predicate" 0 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22051-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22051-1.c
new file mode 100644
index 000000000..4815be0ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22051-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile }  */
+/* { dg-options "-O2 -fdump-tree-optimized" }  */
+
+
+void *arf ();
+int
+foo()
+{
+  void *p = arf ();
+
+  if ((void (*)(void))p != 0)
+    return 1;
+  else
+    return 2;
+}
+
+/* The cast to a function pointer type must remain after all optimizations
+   are complete so that function pointer canonicalization works on those
+   targets which require it.  */
+/* { dg-final { scan-tree-dump-times "if \\(\\(void \\(\\*<.*>\\) \\(void\\)\\) p" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22051-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22051-2.c
new file mode 100644
index 000000000..a6b7099d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22051-2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile }  */
+/* { dg-options "-O2 -fdump-tree-optimized -w" }  */
+
+
+
+
+void *arf ();
+int
+foo()
+{
+  void (*q)(void);
+  int r = q;
+
+  if (r != 0)
+    return 1;
+  else
+    return 2;
+}
+
+/* The cast to an int type must remain after all optimizations are complete
+   so that we do not try to canonicalize a function pointer for the
+   comparison when no such canonicalization is wanted.  */
+/* { dg-final { scan-tree-dump-times "if \\(\\(int\\).*q" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22117.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22117.c
new file mode 100644
index 000000000..d265d5e2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22117.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/22117
+   VRP used think that &p[q] is nonzero even though p and q are both
+   known to be zero after entering the first two "if" statements.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+void
+foo (int *p, int q)
+{
+  if (p == 0)
+    {
+      if (q == 0)
+	{
+	  int *r = &p[q];
+	  if (r != 0)
+	    link_error ();
+	}
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate r_.* != 0B to 0" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22171.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22171.c
new file mode 100644
index 000000000..6a26c56d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22171.c
@@ -0,0 +1,28 @@
+/* { dg-options "-O2" } */
+
+static unsigned int old_serial_port_irq[10];
+
+static struct uart_8250_port {
+  volatile unsigned int slock;
+  unsigned int irq;
+} serial8250_ports[10];
+
+static __inline__ __attribute__((always_inline)) int irq_canonicalize(int irq)
+{
+  return ((irq == 2) ? 9 : irq);
+}
+
+void serial8250_isa_init_ports(void)
+{
+  struct uart_8250_port *up;
+  int i;
+
+  for (i = 0, up = serial8250_ports; i < 10; i++, up++)
+    up->irq = irq_canonicalize(old_serial_port_irq[i]);
+}
+
+int main(void)
+{
+  serial8250_isa_init_ports();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22230.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22230.c
new file mode 100644
index 000000000..4d6534909
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22230.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-O1 -ftree-vrp" } */
+
+/* PR tree-optimization/22230
+
+   The meet of the ranges in "i*i" was not computed correctly, leading
+   gcc to believe that a was equal to 0 after the loop.  */
+
+extern void abort (void) __attribute__((noreturn));
+
+int main (void)
+{
+  long a, i;
+
+  for (i = 0; i < 5; i++)
+    a = i * i;
+  if (a != 16)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22236.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22236.c
new file mode 100644
index 000000000..1986c2f0c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22236.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-O1 -fno-tree-vrp -fwrapv" } */
+
+/* PR tree-optimization/22236
+
+    Avoid conversion of (signed char) {(uchar)1, +, (uchar)1}_x when
+    it is not possible to prove that the scev does not wrap.  
+
+    In this PR, a sequence 1, 2, ..., 255 has to be converted to
+    signed char, but this would wrap: 1, 2, ..., 127, -128, ...  The
+    result should not be a linear scev {(schar)1, +, (schar)1}_x.
+    The conversion should be kept: (schar) {(uchar)1, +, (uchar)1}_x.
+ */
+
+void abort(void);
+
+static inline void
+foo (signed char a)
+{
+  int b = a - 0x7F;
+  if (b > 1)
+    abort();
+}
+
+int main()
+{
+  unsigned char b;
+  for(b = 0; b < 0xFF; b++)
+    foo (b);
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22321.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22321.c
new file mode 100644
index 000000000..64a94ab2d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22321.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-tree-vrp -fno-tree-copy-prop -fno-tree-ccp -fdump-tree-optimized" } */
+
+
+volatile int x;
+
+int main ()
+{
+  volatile int *vip;
+  vip = &x;
+  volatile int *cvip;
+  cvip = vip;
+
+  if (vip != cvip) return -1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "return 0" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22591.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22591.c
new file mode 100644
index 000000000..f1f5ec849
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr22591.c
@@ -0,0 +1,56 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort (); 
+ 
+typedef struct _Node 
+{ 
+  struct _Node *next, *prev; 
+} Node; 
+ 
+void __attribute__ ((noinline)) append (Node * q, Node * p) 
+{ 
+  p->next = q; 
+  p->prev = q; 
+  q->next = p; 
+  q->prev = p; 
+} 
+ 
+inline void 
+swap (Node ** a, Node ** b) 
+{ 
+  Node *tmp = *a; 
+  *a = *b; 
+  *b = tmp; 
+} 
+ 
+/* Miscompilation seems to happen here. If one removes the if condition 
+   (which should be true) the program works fine.  */ 
+void 
+ListSwap (Node * x, Node * y) 
+{ 
+  Node *tmp; 
+  if (x->next) 
+    { 
+      swap (&x->next, &y->next); 
+      swap (&x->prev, &y->prev); 
+      x->next->prev = x->prev->next = x; 
+      y->next->prev = y->prev->next = y; 
+    } 
+} 
+ 
+int 
+main () 
+{ 
+  Node A, A1, B, B1; 
+ 
+  append (&A, &A1); 
+  append (&B, &B1); 
+ 
+  ListSwap (&A, &B); 
+ 
+  if (&A != A.next->prev) 
+    abort (); 
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23048.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23048.c
new file mode 100644
index 000000000..7dc67ea29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23048.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-vectorize" } */
+
+void f(unsigned char *mem)
+{
+   int i;
+
+   for(i=0;i<4;i++) {
+     while(mem[i]==0) ;
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23109.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23109.c
new file mode 100644
index 000000000..e60b2f09f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23109.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -funsafe-math-optimizations -ftrapping-math -fdump-tree-recip -fdump-tree-lim" } */
+/* { dg-warning "-fassociative-math disabled" "" { target *-*-* } 1 } */
+
+double F[2] = { 0., 0. }, e = 0.;
+
+int main()
+{
+	int i;
+	double E, W, P, d;
+
+        /* make sure the program crashes on FP exception */
+        unsigned short int Mask;
+
+	W = 1.;
+	d = 2.*e;
+	E = 1. - d;
+
+	for( i=0; i < 2; i++ )
+		if( d > 0.01 )
+		{
+			P = ( W < E ) ? (W - E)/d : (E - W)/d;
+			F[i] += P;
+		}
+
+	return 0;
+}
+
+/* LIM only performs the transformation in the no-trapping-math case.  In
+   the future we will do it for trapping-math as well in recip, check that
+   this is not wrongly optimized.  */
+/* { dg-final { scan-tree-dump-not "reciptmp" "lim" } } */
+/* { dg-final { scan-tree-dump-not "reciptmp" "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23115.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23115.c
new file mode 100644
index 000000000..61408e47a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23115.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ftree-vectorize" } */
+
+extern void abort (void);
+
+#define MIN2(a,b) (((a)<(b)) ? (a) : (b))
+#define MAX2(a,b) (((a)>(b)) ? (a) : (b))
+
+double p[2] = { 4., 5. };
+
+int main()
+{
+  long j;
+  double R, n, x;
+#if __SIZEOF_DOUBLE__ >= 8
+  n = 1.e300;
+  x = -1.e300;
+#else
+  n = 1.e30;
+  x = -1.e30;
+#endif
+  for( j=0; j < 2; j++ )
+    {
+      x = MAX2(x,p[j]);
+      n = MIN2(n,p[j]);
+    }
+  R = x-n;
+
+  if( R < 0.1 )
+      abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23192.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23192.c
new file mode 100644
index 000000000..2a606a5c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23192.c
@@ -0,0 +1,23 @@
+/* { dg-options "-O2" } */
+/* { dg-do run } */
+
+struct S { int i; } s;
+
+void f (struct S *q)
+{
+  int a, *p;
+  p = &a;
+  if (q)
+    p = &q->i;
+  *p = 1;
+}
+
+void abort (void);
+
+int main (void)
+{
+  f (&s);
+  if (s.i != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23234.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23234.c
new file mode 100644
index 000000000..3a3869815
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23234.c
@@ -0,0 +1,58 @@
+/* The problem in this PR was mostly finding a suitable place to insert
+   the reciprocals of the function arguments.  This test case tries to
+   test three possible ways of how this may go wrong.  */
+/* { dg-options "-O2 -ffast-math" } */
+/* { dg-do compile } */
+
+/* The original test case.  */
+double
+f1 (double a, double b, double c)
+{
+  double y0;
+  double y1;
+
+  if (a == 0.0)
+    {
+      y0 = -c / b;
+      return y0;
+    }
+  y0 = c / b;
+  y1 = a / b;
+  return y0 * y1;
+}
+
+/* Labels may end up in the middle of a block.  Also bad.  */
+double
+f2 (double a, double b, double c)
+{
+  double y0;
+  double y1;
+
+a_label:
+another_label:
+  if (a == 0.0)
+    {
+      y0 = -c / b;
+      return y0;
+    }
+  y0 = c / b;
+  y1 = a / b;
+  return y0 * y1;
+}
+
+/* Uses must still be dominated by their defs.  */
+double
+f3 (double a, double b, double c)
+{
+  double y0;
+  double y1;
+
+  y0 = -c / b;
+  if (a == 0.0)
+    {
+      return y0;
+    }
+  y0 = c / b;
+  y1 = a / b;
+  return y0 * y1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23294.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23294.c
new file mode 100644
index 000000000..d73512d7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23294.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+int f1(int a)
+{
+  return a*6-a;
+}
+
+int f2(int a)
+{
+  return a*4+a;
+}
+
+int f3(int a)
+{
+  return 2*a + 3*a;
+}
+
+int f4(int a, int b)
+{
+  return 2*a + 6*b;
+}
+
+int f5(int a, int b)
+{
+  return 2*a - 6*b;
+}
+
+int f6(int a, int b)
+{
+  return 6*a - 2*b;
+}
+
+/* { dg-final { scan-tree-dump-times "a \\\* 5" 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\\\) \\\* 2" 3 "optimized" } } */
+/* { dg-final { scan-tree-dump-not "\\\* 6" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23382.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23382.c
new file mode 100644
index 000000000..331e01b5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23382.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-alias-vops" } */
+struct a
+{
+  int length;
+  int a1[256];
+};
+
+void *malloc(__SIZE_TYPE__ size) __attribute__((malloc));
+
+int f(void)
+{
+   struct a *a = malloc(sizeof(struct a));
+   return a->length;
+}
+/* { dg-final { scan-tree-dump-times "VDEF <HEAP" 1 "alias"} } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23386.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23386.c
new file mode 100644
index 000000000..d322f995b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23386.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int f[100];
+int g[100];
+unsigned char
+f1 (int a, int b)
+{
+  __SIZE_TYPE__ ix;
+  if (a)
+    return 1;
+  for (ix = 4; ix--;)
+      if (f[ix] != g[ix])
+	  return 0;
+  return 1;
+}
+
+int main(void)
+{
+  if (!f1 (0, 2))
+    __builtin_abort();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23391.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23391.c
new file mode 100644
index 000000000..a5effbb15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23391.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+void 
+foo (int N) 
+{ 
+  int C; 
+  double R; 
+ 
+  R = 0.0; 
+  do 
+    { 
+      R += 0.001; 
+      C = (int) (R * N); 
+      if (-R * N <= R * N) 
+        { 
+          C++; 
+        } 
+    } 
+  while (C < 0); 
+ 
+  return; 
+} 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23433.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23433.c
new file mode 100644
index 000000000..464d4b542
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23433.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+double transport_sumexp(int numexp)
+{
+  int k,j;
+  double xk1 = 1.0;
+  for(k=1; k<=numexp;k++)
+    for(j=1;j<=3;j++)
+      xk1 += 1.0;
+  return xk1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23434.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23434.c
new file mode 100644
index 000000000..a21b95566
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23434.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+cblas_csyr2k (int N, void *A, int lda, float *B, int ldb, float *C, int k)
+{
+  int i, j;
+  for (;; k ++)
+    {
+      for (i = 0; i < N; i ++)
+	{
+	  float t = ((float * ) A) [i];
+	  for (j = i; j < N; j ++)
+	    {
+	      C [i + j] = B [ldb] * ((float *) A) [k];
+	      C [lda] = 0 ;
+	    }
+	}
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23455.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23455.c
new file mode 100644
index 000000000..3814d90e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23455.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+unsigned long outcnt;
+extern void flush_outbuf(void);
+
+void
+bi_windup(unsigned int *outbuf, unsigned int bi_buf)
+{
+    unsigned long t1 = outcnt;
+    outbuf[t1] = bi_buf;
+
+    unsigned long t2 = outcnt;
+    if (t2 == 16384)
+      flush_outbuf();
+
+    unsigned long t3 = outcnt;
+    outbuf[t3] = bi_buf;
+}
+/* We should eliminate one load of outcnt, which will in turn let us eliminate
+   one multiply of outcnt which will in turn let us eliminate
+   one add involving outcnt and outbuf.  */
+/* { dg-final { scan-tree-dump-times "Eliminated: 3" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23546.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23546.c
new file mode 100644
index 000000000..06324dfcb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23546.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+typedef int m64 __attribute__ ((__vector_size__ (8)));
+
+void mmxCombineMaskU (m64 * mask, int width)
+{
+  while (--width >= 0)
+    *mask++ = (m64) 0LL;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23744.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23744.c
new file mode 100644
index 000000000..8ba238c74
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23744.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int g (int i, int j)
+{
+  int t = 0;
+  int i1;
+
+  if (i == j)
+    t = 3;
+  for (i1 = 0; i1 < 10000; i1++) h();
+  if (t != 5)
+    return 0;
+  else
+    return 1;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23777.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23777.c
new file mode 100644
index 000000000..c2ad9b707
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23777.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+extern void f(char *const *);
+void g (char **o)
+{
+  static const char *const multilib_exclusions_raw[] = { 0 };
+  const char *const *q = multilib_exclusions_raw;
+
+  f (o);
+  while (*q++)
+    f (o);
+}
+
+/* The last DCE pass is able to remove the load from
+    multilib_exclusions_raw.  */
+
+/* { dg-final { scan-tree-dump-not "multilib_exclusions_raw" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
new file mode 100644
index 000000000..ee855e139
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23820.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int t [2][4];
+
+void foo (void)
+{
+  int i, j, k, v;
+  float e;
+  for (;;)
+    {
+      v = 0;
+      for (j = 0; j < 2; j ++)
+        {
+          for (k = 2; k < 4; k ++)
+            {
+              e = 0.0;
+              for (i = 0; i < 4; i ++)
+                e += t [j][i];
+              if (e)
+                v = j;
+            }
+        }
+      t [v][0] = 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-1.c
new file mode 100644
index 000000000..08916e4e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-1.c
@@ -0,0 +1,32 @@
+/* PR middle-end/23848 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void bar1 (char *, int);
+void foo1 (int size)
+{
+  char temp[size];
+  temp[size-1] = '\0';
+  bar1 (temp, size);
+}
+
+void bar2 (char *, char *, char *, char *, int);
+void foo2 (int size)
+{
+  char temp[size];
+  temp[size-1] = '\0';
+  {
+    char temp2[size];
+    {
+      char temp3[size];
+      {
+	char temp4[size];
+	bar2 (temp, temp2, temp3, temp4, size);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-tree-dump-not "__builtin_stack_save" "optimized"} } */
+/* { dg-final { scan-tree-dump-not "__builtin_stack_restore" "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-2.c
new file mode 100644
index 000000000..c9691469d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-2.c
@@ -0,0 +1,25 @@
+/* PR middle-end/23848 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void bar (char *, char *, char *, char *, int);
+void foo (int size)
+{
+  char temp[size];
+  temp[size-1] = '\0';
+  {
+    char temp2[size];
+    {
+      char temp3[size];
+      {
+	char temp4[size];
+	bar (temp, temp2, temp3, temp4, size);
+      }
+    }
+    bar (temp, temp2, (char *) 0, (char *) 0, size);
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_stack_save" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "__builtin_stack_restore" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-3.c
new file mode 100644
index 000000000..d2555049b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-3.c
@@ -0,0 +1,28 @@
+/* PR middle-end/23848 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void bar (int, char *, char *, char *, char *, int);
+void foo (int size)
+{
+  int i;
+  for (i = 0; i < size; i++)
+    {
+      char temp[size];
+      temp[size-1] = '\0';
+      {
+	char temp2[size];
+	{
+	  char temp3[size];
+	  {
+	    char temp4[size];
+	    bar (i, temp, temp2, temp3, temp4, size);
+	  }
+	}
+      }
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_stack_save" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "__builtin_stack_restore" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-4.c
new file mode 100644
index 000000000..66b21b81e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr23848-4.c
@@ -0,0 +1,25 @@
+/* PR middle-end/23848 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void bar (char *, char *, char *, char *, int);
+void foo (int size)
+{
+  char temp[size];
+  temp[size-1] = '\0';
+  {
+    char temp2[size];
+    {
+      char temp3[size];
+      {
+	char temp4[size];
+	bar (temp, temp2, temp3, temp4, size);
+      }
+    }
+    __asm __volatile ("" : : "r" (&temp[0]), "r" (&temp2[0]) : "memory");
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_stack_save" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "__builtin_stack_restore" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24117.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24117.c
new file mode 100644
index 000000000..ffa5dd04c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24117.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+typedef struct  {
+  int x;
+  int z;
+} Foo_t;
+
+char *xm;
+void bar(void);
+
+void foo(void)
+{
+  Foo_t x;
+  x.x = 1;
+  x.z = 2;
+  xm = (char *)&x;
+  bar();
+  /* We can't propagate x.z past bar, so this link_error should still be there.  */
+  if (x.z != 2)
+    link_error ();
+}
+/* { dg-final { scan-tree-dump-times "link_error" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24287.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24287.c
new file mode 100644
index 000000000..63120457c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24287.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int g1(int);
+int h(int *a, int *b)__attribute__((pure));
+void link_error();
+
+/* The calls to link_error should be eliminated, since nothing escapes to 
+   non-pure functions.  */
+int g(void)
+{
+  int t = 0, t1 = 2;
+  int t2 = h(&t, &t1);
+  if (t != 0)
+    link_error ();
+  if (t1 != 2)
+    link_error ();
+  g1(t2);
+  if (t != 0)
+    link_error ();
+  if (t1 != 2)
+    link_error ();
+  return t2 == 2;
+}
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
new file mode 100644
index 000000000..b50e7a8ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24309.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+float weight[10];
+void lsp_weight_quant(float *x, char *cdbk)
+{
+   int i,j;
+   float dist;
+   int best_id=0;
+   for (i=0;i<16;i++)
+   {
+      for (j=0;j<10;j++)
+         dist=dist+weight[j];
+      if (dist<0)
+         best_id=i;
+   }
+   x[j] = cdbk[best_id*10+j];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24627.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24627.c
new file mode 100644
index 000000000..c065eef84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24627.c
@@ -0,0 +1,67 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+/* { dg-require-effective-target int32plus } */
+
+extern void abort (void);
+typedef unsigned int u_int32;
+
+typedef struct {
+  union {u_int32 Xl_ui;} Ul_i;
+  union {u_int32 Xl_uf;} Ul_f;
+} l_fp;
+
+void
+dolfptoa (short ndec)
+{
+  l_fp work, ftmp;
+
+  work.Ul_i.Xl_ui = 0;
+  work.Ul_f.Xl_uf = 0x535f3d8;
+
+  while (ndec > 0)
+    {
+      u_int32 lo_tmp;
+      u_int32 hi_tmp;
+
+      ndec--;
+      work.Ul_i.Xl_ui = 0;
+      work.Ul_i.Xl_ui <<= 1;
+      if ((work.Ul_f.Xl_uf) & 0x80000000)
+	(work.Ul_i.Xl_ui) |= 0x1;
+      (work.Ul_f.Xl_uf) <<= 1;
+
+      ftmp = work;
+      (work.Ul_i.Xl_ui) <<= 1;
+      if ((work.Ul_f.Xl_uf) & 0x80000000)
+	(work.Ul_i.Xl_ui) |= 0x1;
+      (work.Ul_f.Xl_uf) <<= 1;
+
+      (work.Ul_i.Xl_ui) <<= 1;
+      if ((work.Ul_f.Xl_uf) & 0x80000000)
+	(work.Ul_i.Xl_ui) |= 0x1;
+      (work.Ul_f.Xl_uf) <<= 1;
+
+      lo_tmp = ((work.Ul_f.Xl_uf) & 0xffff) + ((ftmp.Ul_f.Xl_uf) & 0xffff);
+      hi_tmp = (((work.Ul_f.Xl_uf) >> 16) & 0xffff)
+               + (((ftmp.Ul_f.Xl_uf) >> 16) & 0xffff);
+
+      if (lo_tmp & 0x10000)
+	hi_tmp++;
+
+      (work.Ul_f.Xl_uf) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff);
+      (work.Ul_i.Xl_ui) += (ftmp.Ul_i.Xl_ui);
+
+      if (hi_tmp & 0x10000)
+	(work.Ul_i.Xl_ui)++;
+
+
+      if (!(work.Ul_i.Xl_ui < 10))
+	abort ();
+    }
+}
+
+int main()
+{
+  dolfptoa(6);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24670.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24670.c
new file mode 100644
index 000000000..a5ff800d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24670.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+__inline__ void
+shift128Right (int count, long long int *z1Ptr)
+{
+  long long int z1;
+  if (count == 0);
+  else if (count < 64);
+  else
+    z1 = (count < 64) ? count : 0;
+  *z1Ptr = z1;
+}
+
+float128_rem ()
+{
+  signed int expDiff;
+  long long int aSig1;
+  long long int sigMean1;
+  if (-64 < expDiff)
+    shift128Right (-expDiff, &aSig1);
+  add128 (&sigMean1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24689.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24689.c
new file mode 100644
index 000000000..4fe74b658
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24689.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+extern void bar (unsigned int);
+
+int
+foo (void)
+{
+  char buf[1] = { 3 };
+  const char *p = buf;
+  const char **q = &p;
+  unsigned int ch;
+  switch (**q)
+    {
+    case 1:  ch = 5; break;
+    default: ch = 0; break;
+    }
+
+  bar (ch);
+  return ch;
+}
+
+/* { dg-final { scan-tree-dump "return 0;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24840.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24840.c
new file mode 100644
index 000000000..736dafdec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24840.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+typedef struct
+{
+  int tag, y;
+} Object;
+
+void Err_Handler () __attribute__ ((__noreturn__));
+
+int
+P_Error (int argc, Object * argv)
+{
+    if (((argv[1]).tag >> 1) != 11)
+      Wrong_Type (argv[1], 11);
+  Err_Handler (argv[0], argv[1], argc - 2, argv + 2);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24990-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24990-1.c
new file mode 100644
index 000000000..a518df025
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr24990-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(int x)
+{
+  return ((~x) != 0);
+}
+int f1(int x)
+{
+  return ((~x) == 0);
+}
+
+/* There should be no != 0 which is produced by the front-end as
+   ~x != 0 is the same as x != -1 (or ~0).   Likewise for ==. */
+/* { dg-final { scan-tree-dump-times "!= 0" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "!= -1" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "== 0" 0 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "== -1" 1 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25382.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25382.c
new file mode 100644
index 000000000..a80480094
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25382.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/25382
+   VRP used to ignore BIT_AND_EXPRs for the purpose of distilling ranges.
+   Check that VRP now gets ranges from BIT_AND_EXPRs.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int
+foo (int a)
+{
+  int b = a & 0xff;
+  if (b > 300)
+    return 2;
+  else
+    return 1;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate b_.* > 300 to 0" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25485.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25485.c
new file mode 100644
index 000000000..93f583cc3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25485.c
@@ -0,0 +1,17 @@
+/* PR tree-optimization/25485
+   VRP did not fold TRUTH_AND_EXPR.  Make sure it does now.  */
+
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int
+foo (int a, int b)
+{
+  if (a > 50)
+    return 19;
+  if (a > 63 && b < 50)
+    return 17;
+  return 31;
+}
+
+/* { dg-final { scan-tree-dump-times "if" 1 "vrp1"} } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25501.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25501.c
new file mode 100644
index 000000000..d63a5274e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25501.c
@@ -0,0 +1,36 @@
+/* PR tree-optimization/25501
+   The PHI merge pass used to try to merge PHI nodes that cannot
+   actually merged, causing a segfault later.  Make sure that does not
+   happen any more.  */
+
+/* { dg-options "-O1 -fdump-tree-mergephi" } */
+
+int
+foo (int a)
+{
+  int b;
+  int c;
+  int d;
+
+  if (a == 2)
+    b = 3;
+  else
+    b = 5;
+
+  c = 7;
+
+  d = 11;
+
+  for (;;)
+    {
+      if (d == 5)
+	break;
+
+      d = b;
+    }
+
+  return 13;
+}
+
+/* { dg-final { scan-tree-dump-times "Removing basic block" 0 "mergephi1"} } */
+/* { dg-final { cleanup-tree-dump "mergephi\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25734.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25734.c
new file mode 100644
index 000000000..a71c7f01a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr25734.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-Os" } */
+
+struct list_head {
+ struct list_head *next;
+};
+static inline __attribute__((always_inline)) void list_del_init(struct
+list_head *entry)
+{
+ __list_del(entry->next);
+ (entry)->next = (entry);
+};
+struct dentry {
+ void *d_fsdata;
+};
+struct sysfs_dirent {
+ struct list_head s_sibling;
+ struct list_head s_children;
+};
+const char *sysfs_get_name(struct sysfs_dirent *);
+void sysfs_hash_and_remove(struct dentry * dir, const char * name)
+{
+ struct sysfs_dirent * sd;
+ struct sysfs_dirent * parent_sd = dir->d_fsdata;
+ for (sd = (struct sysfs_dirent *)((&parent_sd->s_children)->next);
+     &sd->s_sibling != (&parent_sd->s_children);
+     sd  = (struct sysfs_dirent *)sd->s_sibling.next) {
+  if (!__builtin_strcmp(sysfs_get_name(sd), name))
+  {
+   list_del_init(&sd->s_sibling);
+   break;
+  }
+ }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26180.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26180.c
new file mode 100644
index 000000000..13c302dea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26180.c
@@ -0,0 +1,44 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target int32plus } */
+
+void abort(void);
+int bar(int x, int y)
+{
+    int x1, y1;
+    int x2, y2;
+    unsigned int x3, y3, w;
+    int z = 1;
+
+    x1 = (x < (1 << 30));
+    y1 = (y < (1 << 30));
+    if (x1)
+    if (y1) {
+        x2 = ((x > 0)? (x): -(x));
+        y2 = ((y > 0)? (y): -(y));
+
+        x3 = x2;
+        y3 = y2;
+        w = x3 * y3;
+
+        if (w >= (1 << 30)) {
+          z = 1;
+        } else    {
+          z = -1;
+        }
+    }
+
+        return z;
+}
+
+
+int main()
+{
+  int x, y, z;
+  x = 536870912;  /* 2^29 */
+  y = 2;
+  z = bar(x, y);
+  if (z != 1)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26421.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26421.c
new file mode 100644
index 000000000..73db85c17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26421.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-alias-vops" } */
+
+typedef struct {
+  int i;
+  int j;
+  int k;
+} Foo;
+
+void bar(Foo*);
+int foo(void)
+{
+  Foo a;
+  a.i = 1;
+  bar(&a);
+  return a.i;
+}
+
+/* Verify the call clobbers all of a.  */
+
+/* { dg-final { scan-tree-dump-times "VDEF <a_" 2 "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
new file mode 100644
index 000000000..907c5d28d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26435.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+/* { dg-require-effective-target size32plus } */
+
+int foo(int *p, int n)
+{
+  int i, j, k = 0;
+
+  /* This is a reduction: there is a scalar dependence that cannot be
+     removed by rewriting IVs.  This code cannot and should not be
+     transformed into a perfect loop.  */
+  for (i = 0; i < 2; ++i, p += n)
+    for (j = 0; j < 2; ++j)
+      k += p[j];
+
+  return k;
+}
+
+/* { dg-final { scan-tree-dump-times "converted loop nest to perfect loop nest" 0 "ltrans"} } */ 
+/* { dg-final { cleanup-tree-dump "ltrans" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26899.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26899.c
new file mode 100644
index 000000000..2e9941060
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr26899.c
@@ -0,0 +1,10 @@
+/* { dg-options "-fstrict-overflow -fdump-tree-gimple" } */
+
+int foo (int i, int j)
+{
+  return (i < j + 1) || (j > i - 1);
+}
+
+/* { dg-final { scan-tree-dump "j >= i" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27236.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27236.c
new file mode 100644
index 000000000..389b65206
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27236.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+static inline int inline_read(volatile int *mem)
+{
+        return *mem;
+}
+__attribute__ ((noinline))
+int foo_read(volatile int *mem)
+{
+        return inline_read(mem);
+}
+unsigned int foo(volatile int *mem)
+{
+        foo_read(mem);
+        return foo_read(mem);
+}
+
+/* { dg-final { scan-tree-dump-times "foo_read" 5 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27498.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27498.c
new file mode 100644
index 000000000..75d3d4bac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27498.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+void zconfdump(void)
+{
+  char *p, *p2;
+  for (p2 = p; p2; )
+    {
+      char __a0, __a1, __a2;
+      __a0 = ((__const char *) ("\"\\"))[0];
+      if (__a0)
+        return;
+    }
+}
+
+/* { dg-final { scan-tree-dump-not "goto" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27781.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27781.c
new file mode 100644
index 000000000..233c93dac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27781.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-weak-override "" } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void __attribute__((weak)) func(void)
+{
+    /* no code */
+}
+
+int main()
+{
+    func();
+    return 0;
+}
+
+/* { dg-final { scan-tree-dump "func \\(\\);" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27799.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27799.c
new file mode 100644
index 000000000..de09a40e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr27799.c
@@ -0,0 +1,26 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+struct X { double m; int x; };
+struct Y { int y; short d; };
+struct YY { int y; short d; char c; };
+
+extern void link_error (void);
+
+int foo(struct X *x,  struct Y *y)
+{
+  x->x =  0;
+  y->y =  1;
+  if (x->x != 0)
+    link_error ();
+}
+
+int foo_no(struct X *x,  struct YY *y)
+{
+  x->x =  0;
+  y->y =  1;
+  if (x->x != 0)
+    link_error ();
+}
+
+int main() {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr28410.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr28410.c
new file mode 100644
index 000000000..adc49b15c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr28410.c
@@ -0,0 +1,26 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort(void);
+struct Bar { int p; };
+struct Foo { struct Bar *p; };
+struct Bar p0 = { 0 };
+struct Bar p1 = { 1 };
+void bar(struct Foo *f)
+{
+  f->p = &p0;
+}
+int foo(struct Foo *f)
+{
+  f->p->p = 1;
+  bar(f);
+  return f->p->p;
+}
+int main()
+{
+  struct Foo f;
+  f.p = &p1;
+  if (foo(&f) != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c
new file mode 100644
index 000000000..50b3bfd56
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr30375.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse" } */
+
+typedef struct _s {
+    int a;
+    int b;
+    int c;
+    int d;
+} s;
+
+extern void g(s*);
+extern void f(void);
+
+void test_signed_msg_encoding(void)
+{
+    s signInfo = { sizeof(signInfo), 0 };
+
+    signInfo.b = 1;
+    signInfo.c = 0;
+    g(&signInfo);
+    signInfo.d = 0;
+    f();
+}
+
+/* { dg-final { scan-tree-dump-times "signInfo = {}" 1 "dse1" } } */
+/* { dg-final { cleanup-tree-dump "dse*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c
new file mode 100644
index 000000000..5444e2d19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+int foo(int a)
+{
+  unsigned int b = a > 0;
+  char c = b;
+  _Bool d = c == 0;
+  int e = !d;
+  return e;
+}
+
+/* { dg-final { scan-tree-dump "return a > 0;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
new file mode 100644
index 000000000..000d7b5bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31183.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int buf[256 * 9];
+int f() 
+{
+  int i, j;
+
+  for (i = 0; i < 256; ++i)
+    for (j = 0; j < 8; ++j)
+      buf[j + 1] = buf[j] + 1;
+
+  return buf[10];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31521.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31521.c
new file mode 100644
index 000000000..4f54cc077
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31521.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+void fail(void) __attribute__((noreturn));
+int bar(int);
+
+int foo(int x) {
+  int i;
+  int s = 0;
+
+  if (x <= 0) fail();
+  for (i = 0; i < x; ++i) {
+    /* This division by 4 should be replaced with >> 2.  */
+    s += bar(i/4);
+  }
+  return s;
+}
+
+/* { dg-final { scan-tree-dump-times " = i_.* >> 2" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31966.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31966.c
new file mode 100644
index 000000000..a18f9d041
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr31966.c
@@ -0,0 +1,50 @@
+/* Contributed by Jack Lloyd  <lloyd@randombit.net> */
+
+/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -march=nocona" { target { i?86-*-* x86_64-*-* } } } */
+
+typedef unsigned long long word;
+
+const unsigned int MP_WORD_BITS = 64;
+const word MP_WORD_MASK = ~((word)0);
+const word MP_WORD_TOP_BIT = (word)1 << (8*sizeof(word) - 1);
+
+extern void abort (void);
+
+word do_div(word n1, word n0, word d)
+{
+  word high = n1 % d, quotient = 0;
+  unsigned int j;
+
+  for(j = 0; j != MP_WORD_BITS; ++j)
+    {
+      word high_top_bit = (high & MP_WORD_TOP_BIT);
+
+      high <<= 1;
+      high |= (n0 >> (MP_WORD_BITS-1-j)) & 1;
+      quotient <<= 1;
+
+      if(high_top_bit || high >= d)
+	{
+	  high -= d;
+	  quotient |= 1;
+	}
+    }
+
+  return quotient;
+}
+
+int main()
+{
+  word result;
+
+  result = do_div(0x0000000000200000ll,
+		  0x0000000000000000ll,
+		  0x86E53497CE000000ll);
+
+  
+  if (result != 0x3CBA83)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32044.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32044.c
new file mode 100644
index 000000000..0c1a58206
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32044.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-empty -fdump-tree-final_cleanup" } */
+
+int foo (int n)
+{
+  while (n >= 45)
+    n -= 45;
+
+  return n;
+}
+
+int bar (int n)
+{
+  while (n >= 64)
+    n -= 64;
+
+  return n;
+}
+
+int bla (int n)
+{
+  int i = 0;
+
+  while (n >= 45)
+    {
+      i++;
+      n -= 45;
+    }
+
+  return i;
+}
+
+int baz (int n)
+{
+  int i = 0;
+
+  while (n >= 64)
+    {
+      i++;
+      n -= 64;
+    }
+
+  return i;
+}
+
+/* The loops computing division/modulo by 64 should be eliminated.  */
+/* { dg-final { scan-tree-dump-times "Removing empty loop" 2 "empty" } } */
+
+/* There should be no division/modulo in the final dump (division and modulo
+   by 64 are done using bit operations).  */
+/* { dg-final { scan-tree-dump-times "/" 0 "final_cleanup" } } */
+/* { dg-final { scan-tree-dump-times "%" 0 "final_cleanup" } } */
+
+/* { dg-final { cleanup-tree-dump "empty" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32367.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32367.c
new file mode 100644
index 000000000..1b153b65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32367.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+int BinomialCoefficientsInited = 0;
+int BinomialCoefficients[17 * 35];
+double Evaluate_TPat (void)
+{
+        unsigned short n, k;
+        if (BinomialCoefficientsInited == 0)
+        {
+                int *ptr = BinomialCoefficients;
+                for (n = 1; n <= 33; ++n)
+                {
+                        for (k = 1; k < n; ++k)
+                                ++ptr;
+                        *ptr = 1;
+                }
+        }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32461-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32461-1.c
new file mode 100644
index 000000000..6e069886d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32461-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+typedef struct
+{
+  unsigned exp[256];
+}
+expbap_t;
+
+void
+a52_bit_allocate (expbap_t * expbap)
+{
+  int i;
+  unsigned *exp = expbap->exp;
+  char *bap;
+
+  while (i < 3 || exp[i] > exp[i - 1]);
+
+  do {
+    if (exp[i + 1] == exp[i])
+      bap[i] = 0;
+    i++;
+  } while (i < 20);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32461-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32461-2.c
new file mode 100644
index 000000000..81ee6ae95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32461-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+typedef struct
+{
+  unsigned char exp[256];
+}
+expbap_t;
+
+void
+a52_bit_allocate (expbap_t * expbap)
+{
+  int i;
+  unsigned char *exp = expbap->exp;
+  int lowcomp;
+
+  do
+    {
+      if (exp[i + 1] == exp[i] - 2)
+        lowcomp = 384;
+      else if (lowcomp && (exp[i + 1] > exp[i]))
+        lowcomp -= 64;
+      i++;
+    }
+  while ((i < 3) || ((i < 7) && (exp[i] > exp[i - 1])));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32540-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32540-1.c
new file mode 100644
index 000000000..f5a444806
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32540-1.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -ftree-pre" } */
+
+int f(void);
+void acceptloop_th(int *t) {
+   int options = 0;
+   if (f()) options |= 0x1 << 1;
+   if (f()) options |= 0x1 << 2;
+   if (f()) options |= 0x1 << 3;
+   if (f()) options |= 0x1 << 4;
+   if (f()) options |= 0x1 << 5;
+   if (f()) options |= 0x1 << 6;
+   if (f()) options |= 0x1 << 7;
+   if (f()) options |= 0x1 << 8;
+   if (f()) options |= 0x1 << 9;
+   if (f()) options |= 0x1 << 10;
+   if (f()) options |= 0x1 << 11;
+   if (f()) options |= 0x1 << 12;
+   if (f()) options |= 0x1 << 13;
+   if (f()) options |= 0x1 << 14;
+   if (f()) options |= 0x1 << 15;
+#if(__SIZEOF_INT__ >= 4)    
+   if (f()) options |= 0x1 << 16;
+   if (f()) options |= 0x1 << 17;
+   if (f()) options |= 0x1 << 18;
+   if (f()) options |= 0x1 << 19;
+   if (f()) options |= 0x1 << 20;
+   if (f()) options |= 0x1 << 21;
+   if (f()) options |= 0x1 << 22;
+   if (f()) options |= 0x1 << 23;
+   if (f()) options |= 0x1 << 24;
+   if (f()) options |= 0x1 << 25;
+   if (f()) options |= 0x1 << 26;
+#endif
+   if (f()) *t = options;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32540-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32540-2.c
new file mode 100644
index 000000000..f7fa38de1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32540-2.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -ftree-pre" } */
+
+int f(void);
+void acceptloop_th(int *t, int options) {
+    if (f()) options |= 0x1 << 0;
+    if (f()) options |= 0x1 << 1;
+    if (f()) options |= 0x1 << 2;
+    if (f()) options |= 0x1 << 3;
+    if (f()) options |= 0x1 << 4;
+    if (f()) options |= 0x1 << 5;
+    if (f()) options |= 0x1 << 6;
+    if (f()) options |= 0x1 << 7;
+    if (f()) options |= 0x1 << 8;
+    if (f()) options |= 0x1 << 9;
+    if (f()) options |= 0x1 << 10;
+    if (f()) options |= 0x1 << 11;
+    if (f()) options |= 0x1 << 12;
+    if (f()) options |= 0x1 << 13;
+    if (f()) options |= 0x1 << 14;
+    if (f()) options |= 0x1 << 15;
+#if(__SIZEOF_INT__ >= 4)    
+    if (f()) options |= 0x1 << 16;
+    if (f()) options |= 0x1 << 17;
+    if (f()) options |= 0x1 << 18;
+    if (f()) options |= 0x1 << 19;
+    if (f()) options |= 0x1 << 20;
+    if (f()) options |= 0x1 << 21;
+    if (f()) options |= 0x1 << 22;
+    if (f()) options |= 0x1 << 23;
+    if (f()) options |= 0x1 << 24;
+    if (f()) options |= 0x1 << 25;
+    if (f()) options |= 0x1 << 26;
+#endif
+    if (f()) *t = options;
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32681.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32681.c
new file mode 100644
index 000000000..235234244
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32681.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -ffast-math -ftree-vectorize" } */
+/* { dg-options "-O3 -ffast-math -ftree-vectorize -march=nocona" { target { i?86-*-* x86_64-*-* } } } */
+
+int aa_renderpalette (int p)
+{
+  int y = 42;
+  int i;
+
+  for (i = 0; i < 256; i++)
+    {
+      if (y > 255)
+	y = 255;
+      if (y < 0)
+	y = 0;
+
+      if (p)
+	y = (y < p ? 0 : (y > p) * 255 / (255 - 2 * p));
+    }
+    return y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32821.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32821.c
new file mode 100644
index 000000000..219573940
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32821.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize -fdump-tree-ifcvt-details" } */
+
+void
+main1 (int *arr, int n, int a, int b)
+{
+  int i;
+  for (i = 0; i < n; i++)
+    {
+      int m = arr[i];
+      arr[i] = (m < a ? m - a : b);
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "ifcvt" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32901.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32901.c
new file mode 100644
index 000000000..c0ba060e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr32901.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-gimple" } */
+
+struct foo {
+        unsigned a1: 1;
+        unsigned a2: 3;
+        unsigned : 4;
+};
+
+extern struct foo thefoo, theotherfoo;
+
+void setup_foo(void)
+{
+        const struct foo init = {
+                .a1 = 1,
+                .a2 = 5,
+        };
+	volatile const struct foo volinit = {
+		.a1 = 0,
+		.a2 = 6
+	};
+        thefoo = init;
+	theotherfoo = volinit;
+}
+
+/* { dg-final { scan-tree-dump-times "thefoo.* = {}" 1 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "thefoo.* = 1" 1 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "thefoo.* = 5" 1 "gimple"} } */
+/* { dg-final { scan-tree-dump-times "theotherfoo = volinit" 1 "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
new file mode 100644
index 000000000..2470762f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33576.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+int a1[6][4][4];
+short b1[16];
+
+int c1;
+void CalculateQuantParam(void)
+{
+  int i, j, k, temp;
+
+   for(k=0; k<6; k++)
+      for(j=0; j<4; j++)
+        for(i=0; i<4; i++)
+        {
+          temp = (i<<2)+j;
+          a1[k][j][i]  = c1/b1[temp];
+        }
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33723.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33723.c
new file mode 100644
index 000000000..32a3aad9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33723.c
@@ -0,0 +1,72 @@
+/* PR tree-optimization/33723 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+typedef union
+{
+  struct
+  {
+    int f1, f2, f3, f4, f5, f6, f7, f8;
+    long int f9, f10;
+    int f11;
+  } f;
+  char s[4];
+  long int a;
+} T;
+
+void
+foo1 (void)
+{
+  T t;
+  t = (T) { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
+  test (&t);
+}
+
+void
+bar1 (void)
+{
+  T t = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
+  test (&t);
+}
+
+void
+baz1 (void)
+{
+  T t;
+  t = (const T) { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
+  test (&t);
+}
+
+void
+foo2 (void)
+{
+  T t;
+  t = (T) { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 } };
+  test (&t);
+}
+
+void
+bar2 (void)
+{
+  T t = { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 } };
+  test (&t);
+}
+
+void
+baz2 (void)
+{
+  T t;
+  t = (const T) { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 } };
+  test (&t);
+}
+
+void
+baz3 (void)
+{
+  T t;
+  t = (const T) (T) { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 } };
+  test (&t);
+}
+
+/* { dg-final { scan-tree-dump-not "t = D" "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
new file mode 100644
index 000000000..f6bb50615
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33766.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+float
+fxt1_quantize_ALPHA1()
+{
+        int j1;
+        int i;
+        float *tv;
+        for (j1 = 1; j1; j1++) {
+                float e;
+                for (i = 1; i; i++)
+                        e = tv[i];
+                if (e)
+                        i = j1;
+        }
+        return tv[i];
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33920.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33920.c
new file mode 100644
index 000000000..0b91dae38
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33920.c
@@ -0,0 +1,52 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+typedef __PTRDIFF_TYPE__ intptr_t;
+typedef union lispunion *object;
+struct character
+{
+  long e;
+};
+extern struct symbol Cnil_body;
+extern struct symbol Ct_body;
+struct vector
+{
+  object *v_self;
+};
+union lispunion
+{
+  struct vector v;
+};
+void init_code ()
+{
+  object V659;
+  object _x, _y;
+  object V643;
+  intptr_t V648;
+  unsigned char V653;
+  object V651;
+  object V654;
+  object V658;
+
+T1240:
+if (V648 >= (intptr_t)V651) /* { dg-warning "cast from pointer to integer of different size" "" { target { ! int32plus } } } */
+    goto T1243;
+  V653 = ((char *) V654->v.v_self)[V648];
+  V659 = (object) V654 + V653;
+T1261:
+  V658 =
+    (object)
+     V659 ? (object) & Ct_body : (object) & Cnil_body;
+  if (V658 == (object) & Cnil_body)
+    goto T1249;
+  goto T1224;
+T1249:
+  V648 = (intptr_t) V648 + 1;
+  goto T1240;
+T1243:
+  V643 = (object) & Cnil_body;
+T1224:
+  _y = V643;
+  number_plus (_x, _y);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33922.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33922.c
new file mode 100644
index 000000000..7429eb161
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr33922.c
@@ -0,0 +1,79 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -ftree-pre" } */
+
+typedef enum
+{
+  ST_TiemanStyle,
+}
+BrailleDisplay;
+static int pendingCommand;
+static int currentModifiers;
+typedef struct
+{
+  int (*updateKeys) (BrailleDisplay * brl, int *keyPressed);
+}
+ProtocolOperations;
+static const ProtocolOperations *protocol;
+brl_readCommand (BrailleDisplay * brl)
+{
+  unsigned long int keys;
+  int command;
+  int keyPressed;
+  unsigned char routingKeys[200];
+  int routingKeyCount;
+  signed char rightVerticalSensor;
+  if (pendingCommand != (-1))
+    {
+      return command;
+    }
+  if (!protocol->updateKeys (brl, &keyPressed))
+    {
+      if (rightVerticalSensor >= 0)
+        keys |= 1;
+      if ((routingKeyCount == 0) && keys)
+        {
+          if (currentModifiers)
+            {
+            doChord:switch (keys);
+            }
+          else
+            {
+            doCharacter:
+              command = 0X2200;
+              if (keys & 0X01UL)
+                command |= 0001;
+              if (keys & 0X02UL)
+                command |= 0002;
+              if (keys & 0X04UL)
+                command |= 0004;
+              if (keys & 0X08UL)
+                command |= 0010;
+              if (keys & 0X10UL)
+                command |= 0020;
+              if (keys & 0X20UL)
+                command |= 0040;
+              if (currentModifiers & (0X0010 | 0X0200))
+                command |= 0100;
+              if (currentModifiers & 0X0040)
+                command |= 0200;
+              if (currentModifiers & 0X0100)
+                command |= 0X020000;
+              if (currentModifiers & 0X0400)
+                command |= 0X080000;
+              if (currentModifiers & 0X0800)
+                command |= 0X040000;
+            }
+          unsigned char key1 = routingKeys[0];
+          if (key1 == 0)
+            {
+            }
+          if (key1 == 1)
+            if (keys)
+              {
+                currentModifiers |= 0X0010;
+                goto doCharacter;
+              }
+        }
+    }
+  return command;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
new file mode 100644
index 000000000..ee279b7c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34017.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+extern int s;
+
+void
+foo (int *x, int y, int z)
+{
+ int m, n;
+ int o;
+ int p = x[0];
+ o = s;
+ for (m = 0; m < s; m++)
+   for (n = 0; n < s; n++)
+     {
+       if (x[n] != p)
+         continue;
+       if (m > z)
+         z = m;
+       if (n < o)
+         o = n;
+     }
+ for (m = y; m <= z; m++)
+   {
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
new file mode 100644
index 000000000..81dbf3aac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34123.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear" } */
+
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+
+static unsigned char sbox[256] = {
+};
+void MD2Transform (unsigned char state[16])
+{
+  unsigned char t = 0;
+  int i, j;
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < 2; j++)
+        t = (state[j] ^= sbox[t]);
+      t += i;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34146-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34146-2.c
new file mode 100644
index 000000000..31007b07f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34146-2.c
@@ -0,0 +1,53 @@
+/* PR c/34146 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+struct A
+{
+  int f1, f2, f3;
+};
+
+struct B
+{
+  struct A g1, g2;
+};
+
+struct C
+{
+  struct B h1, h2;
+};
+
+typedef union
+{
+  struct C c;
+  char s[4];
+  long int a;
+} T;
+
+void
+foo (void)
+{
+  T t = (T) { { { { 0, 0, 0 }, { 0, 0, 0 } }, { { 0, 0, 0 }, { 0, 0, 0 } } } };
+  test (&t);
+}
+
+void
+bar (void)
+{
+  T t = (T) { { { { 0, 0, 0 }, (struct A) { 0, 0, 0 } },
+	      (struct B) { (struct A) { 0, 0, 0 }, { 0, 0, 0 } } } };
+  test (&t);
+}
+
+void
+baz (void)
+{
+  T t = (T) { { { { 0, 0, 0 }, (struct A) { 1, 1, 1 } },
+	      (struct B) { (struct A) { 0, 0, 0 }, { 1, 1, 1 } } } };
+  test (&t);
+}
+
+/* { dg-final { scan-tree-dump-not "t = D" "gimple"} } */
+/* { dg-final { scan-tree-dump-not "t\.c\.h\[12\] = D" "gimple"} } */
+/* { dg-final { scan-tree-dump-not "\.g\[12\] = D" "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34146.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34146.c
new file mode 100644
index 000000000..99fdeb5ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34146.c
@@ -0,0 +1,53 @@
+/* PR c/34146 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple" } */
+
+struct A
+{
+  int f1, f2, f3;
+};
+
+struct B
+{
+  struct A g1, g2;
+};
+
+struct C
+{
+  struct B h1, h2;
+};
+
+typedef union
+{
+  struct C c;
+  char s[4];
+  long int a;
+} T;
+
+void
+foo (void)
+{
+  T t = { { { { 0, 0, 0 }, { 0, 0, 0 } }, { { 0, 0, 0 }, { 0, 0, 0 } } } };
+  test (&t);
+}
+
+void
+bar (void)
+{
+  T t = { { { { 0, 0, 0 }, (struct A) { 0, 0, 0 } },
+	    (struct B) { (struct A) { 0, 0, 0 }, { 0, 0, 0 } } } };
+  test (&t);
+}
+
+void
+baz (void)
+{
+  T t = { { { { 0, 0, 0 }, (struct A) { 1, 1, 1 } },
+	    (struct B) { (struct A) { 0, 0, 0 }, { 1, 1, 1 } } } };
+  test (&t);
+}
+
+/* { dg-final { scan-tree-dump-not "t = D" "gimple"} } */
+/* { dg-final { scan-tree-dump-not "t\.c\.h\[12\] = D" "gimple"} } */
+/* { dg-final { scan-tree-dump-not "\.g\[12\] = D" "gimple"} } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34244.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34244.c
new file mode 100644
index 000000000..262c92f1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34244.c
@@ -0,0 +1,65 @@
+/* PR tree-optimization/34244  */
+/* { dg-do run } */
+/* { dg-options "-O2 " } */
+
+int __attribute__((noinline)) GetParent(void)
+{
+  static int count = 0;
+  count++;
+  switch (count)
+    {
+    case 1:
+    case 3:
+    case 4:
+        return 1;
+    default:
+        return 0;
+    }
+}
+int __attribute__((noinline)) FindCommonAncestor(int aNode1, int aNode2)
+{
+  if (aNode1 && aNode2) {
+    int offset = 0;
+    int anc1 = aNode1;
+    for (;;) {
+      ++offset;
+      int  parent = GetParent();
+      if (!parent)
+        break;
+      anc1 = parent;
+    }
+    int anc2 = aNode2;
+    for (;;) {
+      --offset;
+      int  parent = GetParent();
+      if (!parent)
+        break;
+      anc2 = parent;
+    }
+    if (anc1 == anc2) {
+      anc1 = aNode1;
+      anc2 = aNode2;
+      while (offset > 0) {
+        anc1 = GetParent();
+        --offset;
+      }
+      while (offset < 0) {
+        anc2 = GetParent();
+        ++offset;
+      }
+      while (anc1 != anc2) {
+        anc1 = GetParent();
+        anc2 = GetParent();
+      } 
+      return anc1;
+    }
+  }
+  return 0;
+}
+extern void abort (void);
+int main()
+{
+  if (FindCommonAncestor (1, 1) != 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34635-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34635-1.c
new file mode 100644
index 000000000..5afc6db27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34635-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+void foo(int x[])
+{
+ int i, j;
+
+ for (i = 0; i < 2; i++)
+   for (j = 0; j < 2; j++)
+   {
+     x[i] = x[i+j];
+     x[i] = x[i+j];
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34635.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34635.c
new file mode 100644
index 000000000..5b4253cc4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr34635.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+void foo(int x[])
+{
+ int i, j;
+
+ for (i = 0; i < 2; i++)
+   for (j = 0; j < 2; j++)
+   {
+     x[i] = x[i*j];
+     x[i] = x[i*j];
+   }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr35286.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr35286.c
new file mode 100644
index 000000000..8601cabec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr35286.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int g2;
+struct A {
+    int a; int b;
+}g1;
+int foo(int a, int b)
+{
+  if (a > 0)
+    {
+      g1.a = a+ b;
+    }
+  else
+    g1.a = b;
+
+  g2 = a+b;
+
+  return g1.a;
+}
+/* We will eliminate the g1.a from the return statement as fully redundant,
+   and remove one calculation of a + b. */
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr35287.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr35287.c
new file mode 100644
index 000000000..1e9766280
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr35287.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int *gp;
+int foo(int p)
+{
+  int t = 0;
+  if (p)
+    t = *gp + 1;
+
+  return (*gp + t);
+}
+
+/* We will eliminate one load of gp and one indirect load of *gp. */
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36181.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36181.c
new file mode 100644
index 000000000..7294c07b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36181.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target pthread } */
+/* { dg-options "-O3 -ftree-parallelize-loops=2" } */
+
+int foo ()
+{
+  int i, sum = 0, data[1024];
+
+  for(i = 0; i<1024; i++)
+    sum += data[i];
+
+  return sum;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
new file mode 100644
index 000000000..51b77c715
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36287.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-loop-linear" } */
+
+int tab[2][2];
+
+int foo ()
+{
+  int i, j, k;
+
+  for (i = 0; i < 2; ++i)
+    for (j = 0; j < 2; ++j)
+      for (k = 0; k < 2; ++k) 
+	{}
+
+  for (i = 0; i < 2; ++i)
+    for (j = 0; j < 2; ++j)
+      if (i == 0)
+	tab[i][j] = 0;
+
+  return tab[0][1];
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36326.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36326.c
new file mode 100644
index 000000000..0611f7d84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36326.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+union X { int i; double x; };
+
+int foo (union X *p)
+{
+  union X x = *p;
+  return x.x;
+}
+
+/* { dg-final { scan-tree-dump-not "x.0" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36881.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36881.c
new file mode 100644
index 000000000..742dd9ddb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36881.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/36881 */
+/* { dg-do compile { target fpic } } */
+/* { dg-options "-O2 -fpic -fdump-tree-switchconv-all" } */
+
+const char *foo (int i)
+{
+  const char *p;
+  switch (i)
+    {
+    case 0:
+    case 6: p = ""; break;
+    case 1:
+    case 7: p = "abc"; break;
+    case 2:
+    case 8: p = "def"; break;
+    default: p = "ghi"; break;
+    }
+  return p;
+}
+
+/* { dg-final { scan-assembler-not "CSWTCH" } } */
+/* { dg-final { scan-tree-dump "need runtime relocations" "switchconv" } } */
+/* { dg-final { cleanup-tree-dump "switchconv" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c
new file mode 100644
index 000000000..8fa2ed2ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr36908.c
@@ -0,0 +1,65 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-distribution" } */
+#define NULL ((void *)0)
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+extern void *foo(size_t nelem, size_t elsize);
+extern void bar (char*, ...);
+
+typedef struct alt_state *alt_state_t;
+typedef struct state *state_t;
+
+struct alt_state
+{
+  alt_state_t next_alt_state;
+};
+
+static alt_state_t first_free_alt_state = NULL;
+
+static void
+free_alt_state (alt_state_t alt_state)
+{
+  if (alt_state == NULL)
+    return;
+  alt_state->next_alt_state = first_free_alt_state;
+  first_free_alt_state = alt_state;
+}
+
+/* The function frees list started with node ALT_STATE_LIST.  */
+static void
+free_alt_states (alt_state_t alt_states_list)
+{
+  alt_state_t curr_alt_state;
+  alt_state_t next_alt_state;
+
+  for (curr_alt_state = alt_states_list;
+       curr_alt_state != NULL;
+       curr_alt_state = next_alt_state)
+    {
+      next_alt_state = curr_alt_state->next_alt_state;
+      free_alt_state (curr_alt_state);
+    }
+}
+
+int 
+main (void)
+{
+  int i;
+  alt_state_t state, act_state;
+
+  act_state = state = foo (1, sizeof (struct alt_state));
+  for (i = 0; i < 2; i ++)
+  {
+    act_state->next_alt_state = foo (1, sizeof (struct alt_state));
+    act_state = act_state->next_alt_state;
+  }
+
+  free_alt_states (state);
+
+  for (act_state = first_free_alt_state;
+       act_state != NULL;
+       act_state = act_state->next_alt_state)
+       bar ("going from %p to %p\n", act_state, act_state->next_alt_state);
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr37508.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr37508.c
new file mode 100644
index 000000000..f31c5940b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr37508.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+struct foo1 {
+  int i:1;
+};
+struct foo2 {
+  unsigned i:1;
+};
+
+int test1 (struct foo1 *x)
+{
+  if (x->i == 0)
+    return 1;
+  else if (x->i == -1)
+    return 1;
+  return 0;
+}
+
+int test2 (struct foo2 *x)
+{
+  if (x->i == 0)
+    return 1;
+  else if (x->i == -1)
+    return 1;
+  return 0;
+}
+
+int test3 (struct foo1 *x)
+{
+  if (x->i == 0)
+    return 1;
+  else if (x->i == 1)
+    return 1;
+  return 0;
+}
+
+int test4 (struct foo2 *x)
+{
+  if (x->i == 0)
+    return 1;
+  else if (x->i == 1)
+    return 1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding" 4 "vrp1" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
new file mode 100644
index 000000000..a5094bf97
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr37686.c
@@ -0,0 +1,48 @@
+/* { dg-do compile { target powerpc*-*-* } } */
+/* { dg-options "-O3 -ftree-loop-linear" } */
+
+unsigned char inUse[256];
+unsigned char len[6][258];
+int code[6][258];
+unsigned int crc32Table[256] = { };
+  unsigned int getGlobalCRC (void) { }
+  int bsLive;
+void bsW (int n, unsigned int v) {
+ while (bsLive >= 8) {}
+ }
+ void hbAssignCodes (int * code,         unsigned char * length, int minLen,
+int maxLen, int alphaSize) {
+   int n, vec, i;
+   for (n = minLen;n <= maxLen;n++)
+       for (i = 0; i < alphaSize;i++)
+      code[i] = vec;
+   }
+  void sendMTFValues (void) {
+   int v, t, i, j, gs, ge, totc, bt, bc, iter;
+   int nSelectors, alphaSize, minLen, maxLen, selCtr;
+   int nGroups, nBytes;
+ {
+    while (1)
+  {
+  break;
+  }
+       hbAssignCodes (&code[t][0], &len[t][0], minLen, maxLen, alphaSize);
+     unsigned char inUse16[16];
+     for (i = 0;i < 16;i++)
+ if (inUse16[i])
+  {
+      for (j = 0;j < 16;j++)
+   if (inUse[i * 16 + j])    { }
+    }
+   }
+   for (i = 0; i < nSelectors;i++)     { }
+   for (t = 0; t < nGroups;t++)
+ {
+       int curr = len[t][0];
+       for (i = 0; i < alphaSize;i++)
+          while (curr < len[t][i])     { }
+     }
+   while (1)
+       for (i = gs; i <= ge;i++)  { }
+ }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c
new file mode 100644
index 000000000..fac6cd3b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38250.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-distribution" } */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+typedef struct   {
+          long dat[2];
+} gsl_complex_long_double;
+typedef struct {
+ size_t size;
+ size_t stride;
+ long *data;
+} gsl_vector_complex_long_double;
+
+void gsl_vector_complex_long_double_set_zero (gsl_vector_complex_long_double * v) 
+{
+ long * const data = v->data;
+ const size_t n = v->size;
+ const size_t stride = v->stride;
+ const gsl_complex_long_double zero = { { 0,0} } ;
+ size_t i;
+ for (i = 0; i < n; i++)     
+  *(gsl_complex_long_double *) (data + 2 * i * stride) = zero;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38385.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38385.c
new file mode 100644
index 000000000..a49c93e26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38385.c
@@ -0,0 +1,124 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-distribution" } */
+
+struct rtx_def
+{
+  int a;
+};
+
+typedef struct rtx_def *rtx;
+
+struct rd {
+  int alternative_enabled_p[100];
+  rtx operand[100];
+  int n_operands;
+};
+
+rtx this_insn;
+int n_reloads;
+int n_replacements;
+int n_earlyclobbers;
+int replace_reloads;
+int hard_regs_live_known;
+short* static_reload_reg_p;
+struct rd recog_data;
+
+int
+find_reloads (rtx insn, int replace, int ind_levels, int live_known,
+	      short *reload_reg_p)
+{
+  int i, j;
+  int noperands = replace;
+
+  int no_input_reloads = 0;
+  int n_alternatives = replace;
+  char this_alternative_match_win[30];
+  char this_alternative_win[30];
+  char this_alternative_earlyclobber[30];
+  int this_alternative_matches[30];
+  int goal_alternative[30];
+  int this_alternative_number;
+
+  char goal_alternative_match_win[30];
+  char goal_alternative_win[30];
+  int best;
+
+  int operand_mode[30];
+  int retval = 0;
+
+  for (this_alternative_number = 0;
+       this_alternative_number < n_alternatives;
+       this_alternative_number++)
+    {
+
+      int losers = 0;
+      int bad = 0;
+      
+      if (!recog_data.alternative_enabled_p[this_alternative_number])
+	{
+	  int i;
+	  
+	  for (i = 0; i < recog_data.n_operands; i++)
+	    ;
+	  
+	  continue;
+	}
+      
+      for (i = 0; i < noperands; i++)
+	if (this_alternative_earlyclobber[i]
+	    && (this_alternative_win[i] || this_alternative_match_win[i]))
+	  {
+	    if (j != noperands)
+	      {
+		losers++;
+		
+		for (j = 0; j < noperands; j++)
+		  if (this_alternative_matches[j] == i
+		      && this_alternative_match_win[j])
+		    {
+		      this_alternative_win[j] = 0;
+		      this_alternative_match_win[j] = 0;
+		      losers++;
+		    }
+	      }
+	  }
+      
+      if (losers == 0)
+	{
+	  for (i = 0; i < noperands; i++)
+	    {
+	      goal_alternative_win[i] = 0;
+	      goal_alternative_match_win[i] = 0;
+	    }
+	  
+	  goto finish;
+	}
+
+      if (! bad && best > losers)
+	{
+	  for (i = 0; i < noperands; i++)
+	    {
+	      goal_alternative[i] = 0;
+	      goal_alternative_win[i] = 0;
+	    }
+	}
+    }
+  
+
+ finish:
+
+  for (i = 0; i < noperands; i++)
+    if (! goal_alternative_win[i])
+      {
+	rtx op = recog_data.operand[i];
+	int mode = operand_mode[i];
+	
+	if (((ix86_preferred_reload_class ((op), (goal_alternative[i])) == 2)
+	     || no_input_reloads)
+	    && mode != 0)
+	  {}
+      }
+
+  return retval;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38533.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38533.c
new file mode 100644
index 000000000..e78722760
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38533.c
@@ -0,0 +1,30 @@
+/* PR middle-end/38533 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+
+#define A asm volatile ("" : "=r" (f) : "0" (0)); e |= f;
+#define B A A A A A A A A A A A
+#define C B B B B B B B B B B B
+
+int
+foo (void)
+{
+  int e = 0, f;
+  C C B B B B B A A A A A A
+  return e;
+}
+
+int
+main (void)
+{
+  if (foo ())
+    __builtin_abort ();
+  return 0;
+}
+
+/* Verify that reassoc hasn't increased register pressure too much
+   by moving all bitwise ors after the last __asm__.  There should
+   be exactly 2 (first) __asm__ stmts with no intervening stmts,
+   all others should have some bitwise or in between.  */
+/* { dg-final { scan-tree-dump-times "__asm__\[^;\n]*;\n *__asm__" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38997.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38997.c
new file mode 100644
index 000000000..211203c9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr38997.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-distribution" } */
+
+int a[8][8];
+int b[8];
+
+void
+foo (int i)
+{
+  int j;
+  for (j = 0; j < 8; j++)
+    {
+      a[i][j] = 0;
+      b[j] = j;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr39007.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr39007.c
new file mode 100644
index 000000000..94b24436d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr39007.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-distribution" } */
+
+void
+foo (int *__restrict__ p, int *__restrict__ q, int count)
+{
+  int i;
+  for (i = 0; i < count; i++)
+    {
+      *p++ = 0;
+      *q++ = 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c
new file mode 100644
index 000000000..22e2b629e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr40087.c
@@ -0,0 +1,30 @@
+/* { dg-do run } */
+/* { dg-options "-O1 " } */
+
+extern void abort (void);
+
+static void __attribute__((always_inline))
+reverse(int *first, int *last)
+{
+  if (first == last--) 
+    return;
+  while (first != last)
+    {
+      int t = *first;
+      *first = *last;
+      *last = t;
+      if (++first == last--)
+        break;
+    }
+}
+
+int main()
+{
+  int seq[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+
+  reverse(seq, seq + 8);
+  if (seq[3] != 5 || seq[4] != 4)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr41497.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr41497.c
new file mode 100644
index 000000000..e66ee8464
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pr41497.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-Os" } */
+
+extern void abort (void);
+
+unsigned int a;
+int b, c;
+
+void
+foo (void)
+{
+  b = 0;
+  do {
+    for (a = -13; a == 0; a = (unsigned short)a)
+      c = 1;
+    b++;
+  } while (b == 0);
+}
+
+int
+main ()
+{
+  foo ();
+  if (a != -13)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-1.c
new file mode 100644
index 000000000..16bd5c910
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-1.c
@@ -0,0 +1,51 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-O2 -fpredictive-commoning -fdump-tree-pcom-details" } */
+
+void abort (void);
+
+unsigned fib[1000];
+
+__attribute__ ((noinline))
+void count_fib(void)
+{
+  int i;
+
+  fib[0] = 0;
+  fib[1] = 1;
+  for (i = 2; i < 1000; i++)
+    fib[i] = (fib[i-1] + fib[i - 2]) & 0xffff;
+}
+
+unsigned avg[1000];
+
+__attribute__ ((noinline))
+void count_averages(int n)
+{
+  int i;
+
+  for (i = 1; i < n; i++)
+    avg[i] = (((unsigned long) fib[i - 1] + fib[i] + fib[i + 1]) / 3) & 0xffff;
+}
+
+int main(void)
+{
+  count_fib ();
+  count_averages (999);
+
+  if (fib[19] != 4181 || avg[19] != 4510)
+    abort ();
+
+  if (fib[999] != 162 || avg[998] != 21953)
+    abort ();
+
+  return 0;
+}
+
+/* Verify that both loops were transformed and unrolled.  */
+/* { dg-final { scan-tree-dump-times "Unrolling 2 times." 2 "pcom"} } */
+
+/* Also check that we undid the transformation previously made by PRE.  */
+/* { dg-final { scan-tree-dump-times "looparound ref" 1 "pcom"} } */
+
+/* { dg-final { cleanup-tree-dump "pcom" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-2.c
new file mode 100644
index 000000000..7275f2868
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-2.c
@@ -0,0 +1,47 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-O2 -fpredictive-commoning -fdump-tree-pcom-details" } */
+
+void abort (void);
+
+long int fib[1000];
+
+__attribute__ ((noinline))
+void count_fib(void)
+{
+  int i;
+
+  fib[0] = 0;
+  fib[1] = 1;
+  for (i = 2; i < 1000; i++)
+    fib[i] = (fib[i-1] + fib[i - 2]) & 0xffff;
+}
+
+int avg[1000];
+
+__attribute__ ((noinline))
+void count_averages(void)
+{
+  int i;
+
+  for (i = 1; i < 999; i++)
+    avg[i] = ((fib[i - 1] + fib[i] + fib[i + 1]) / 3) & 0xffff;
+}
+
+int main(void)
+{
+  count_fib ();
+  count_averages ();
+
+  if (fib[19] != 4181 || avg[19] != 4510)
+    abort ();
+
+  if (fib[999] != 162 || avg[998] != 21953)
+    abort ();
+
+  return 0;
+}
+
+/* Verify that both loops were transformed and unrolled.  */
+/* { dg-final { scan-tree-dump-times "Unrolling 2 times." 2 "pcom"} } */
+/* { dg-final { cleanup-tree-dump "pcom" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-3.c
new file mode 100644
index 000000000..d5002346e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fpredictive-commoning -fdump-tree-pcom-details" } */
+
+int a[1000], b[1000];
+
+void test(void)
+{
+  int i;
+
+  for (i = 1; i < 999; i++)
+    b[i] = (a[i + 1] + a[i] + a[i - 1]) / 3;
+}
+
+/* Verify that we used 3 temporary variables for the loop.  */
+/* { dg-final { scan-tree-dump-times "Unrolling 3 times." 1 "pcom"} } */
+/* { dg-final { cleanup-tree-dump "pcom" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-4.c
new file mode 100644
index 000000000..6f06b7f8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-4.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-O2 -fpredictive-commoning -fdump-tree-pcom-details" } */
+
+/* Test for predictive commoning of expressions, without reassociation.  */
+
+void abort (void);
+
+int a[1000], b[1000], c[1000];
+
+int main(void)
+{
+  int i;
+
+  for (i = 0; i < 1000; i++)
+    a[i] = b[i] = i;
+
+  for (i = 1; i < 998; i++)
+    c[i] = a[i + 2] * b[i + 1] - b[i - 1] * a[i];
+
+  for (i = 1; i < 998; i++)
+    if (c[i] != 4 * i + 2)
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Combination" 1 "pcom"} } */
+/* { dg-final { scan-tree-dump-times "Unrolling 3 times." 1 "pcom"} } */
+/* { dg-final { cleanup-tree-dump "pcom" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-5.c
new file mode 100644
index 000000000..134fc3765
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/predcom-5.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-do run } */
+/* { dg-options "-O2 -fpredictive-commoning -fdump-tree-pcom-details" } */
+
+/* Test for predictive commoning of expressions, with reassociation.  */
+
+void abort (void);
+
+unsigned a[1000], b[1000], c[1000], d[1000];
+
+int main(void)
+{
+  unsigned i;
+
+  for (i = 0; i < 1000; i++)
+    a[i] = b[i] = d[i] = i;
+
+  for (i = 1; i < 998; i++)
+    c[i] = d[i + 1] * a[i + 2] * b[i + 1] - b[i - 1] * a[i] * d[i - 1];
+
+  for (i = 1; i < 998; i++)
+    if (c[i] != (i+1)*(i+2)*(i+1) - (i - 1) * i * (i - 1))
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Combination" 2 "pcom"} } */
+/* { dg-final { scan-tree-dump-times "Unrolling 3 times." 1 "pcom"} } */
+/* { dg-final { cleanup-tree-dump "pcom" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-3.c
new file mode 100644
index 000000000..b4f5bd6af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-3.c
@@ -0,0 +1,25 @@
+/* This simple loops is perfectly prefetched by the hardware
+   sequential prefetcher and thus there should be no software
+   prefetches issued for it. */
+
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -msse2 -mfpmath=sse -fdump-tree-aprefetch-details" } */
+
+#define N 1000000
+
+double a[N];
+
+double test(void)
+{
+  unsigned i;
+  double sum = 0;
+
+  for (i = 0; i < N; i += 2)
+    sum += (a[i] * a[i+1]);
+
+  return sum;
+}
+
+/* { dg-final { scan-assembler-times "prefetcht" 0 } } */
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-4.c
new file mode 100644
index 000000000..8a5230eed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-4.c
@@ -0,0 +1,18 @@
+/* The loop rolls too little, hence the prefetching would not be useful.  */
+
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-final_cleanup" } */
+
+int xxx[20];
+
+void foo (int n)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    xxx[i] = i;
+}
+
+/* { dg-final { scan-tree-dump-times "prefetch" 0 "final_cleanup" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-5.c
new file mode 100644
index 000000000..0ba2b6269
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-5.c
@@ -0,0 +1,59 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -fdump-tree-aprefetch-details" } */
+
+/* These are common idioms for writing variable-length arrays at the end
+   of structures.  We should not deduce anything about the number of iterations
+   of the loops from them.  */
+
+struct tail0
+{
+  int xxx;
+  int yyy[0];
+};
+
+int loop0 (int n, struct tail0 *x)
+{
+  int i, s = 0;
+
+  for (i = 0; i < n; i++)
+    s += x->yyy[i];
+
+  return s;
+}
+
+struct tail1
+{
+  int xxx;
+  int yyy[1];
+};
+int loop1 (int n, struct tail1 *x)
+{
+  int i, s = 0;
+
+  for (i = 0; i < n; i++)
+    s += x->yyy[i];
+
+  return s;
+}
+
+/* It is unlikely that this should be a tail array.  We may deduce that most
+   likely, the loop iterates about 5 times, and the array is not worth prefetching.  */
+
+struct tail5
+{
+  int xxx;
+  int yyy[5];
+};
+int loop5 (int n, struct tail5 *x)
+{
+  int i, s = 0;
+
+  for (i = 0; i < n; i++)
+    s += x->yyy[i];
+
+  return s;
+}
+
+/* { dg-final { scan-tree-dump-times "Issued prefetch" 0 "aprefetch" } } */
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-6.c
new file mode 100644
index 000000000..d20cbd5fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-6.c
@@ -0,0 +1,54 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -msse2 -mfpmath=sse --param simultaneous-prefetches=100 -fdump-tree-aprefetch-details" } */
+
+#define N 1000
+#define K 900
+
+double a[N][N];
+
+double test(void)
+{
+  unsigned i, j;
+  double sum = 0;
+
+  /* Here, we should not use any prefetch instruction as this pattern
+     is hardware prefetchable.  */
+  for (i = 0; i < K; i++)
+    for (j = 0; j < K; j++)
+      sum += a[i][j];
+
+  /* Here, we should not use prefetch instruction, since the value of
+     a[i+10][j] is reused in L2 cache and the two inner loop strides
+     a[i][j] and a[i+10] are hardware predictable. */
+  for (i = 0; i < K; i++)
+    for (j = 0; j < K; j++)
+      sum += a[i][j] * a[i + 10][j];
+
+  /* Here, we should not use any prefetch instruction, since the
+    two independent strides a[i][j] and a[i+100][j] are hardware
+    prefetchable in the inner-loop. */
+  for (i = 0; i < K; i++)
+    for (j = 0; j < K; j++)
+      sum += a[i][j] * a[i + 100][j];
+
+  /* Same as above. */
+  for (i = 0; i < 100; i++)
+    for (j = 0; j < 100; j++)
+      sum += a[i][j] * a[i + 100][j];
+
+  /* Temporal prefetches should be used here (even though the accesses to
+     a[j][i] are independent, the same cache line is almost always hit
+     every N iterations).  */
+  for (i = 0; i < N; i++)
+    for (j = 0; j < N; j++)
+      sum += a[j][i];
+
+  return sum;
+}
+
+/* { dg-final { scan-tree-dump-times "Issued prefetch" 1 "aprefetch" } } */
+
+/* { dg-final { scan-assembler-times "prefetcht" 1 } } */
+
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-7.c
new file mode 100644
index 000000000..9ed5f3283
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-7.c
@@ -0,0 +1,29 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -msse2 -mfpmath=sse --param simultaneous-prefetches=100 --param max-unrolled-insns=1 -fdump-tree-aprefetch-details -fdump-tree-final_cleanup" } */
+
+#define K 1000000
+int a[K], b[K];
+
+void test(int *p)
+{
+  unsigned i;
+
+  /* Nontemporal store should be used neither for a nor for p, as we do not know
+     whether they alias or not.  */
+  for (i = 0; i < K; i++)
+    {
+      a[i] = 0;
+      *p++ = 1;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "nontemporal store" 0 "aprefetch" } } */
+
+/* { dg-final { scan-assembler-times "prefetcht" 0 } } */
+/* { dg-final { scan-assembler-times "prefetchnta" 0 } } */
+/* { dg-final { scan-assembler-times "movnti" 0 } } */
+/* { dg-final { scan-assembler-times "mfence" 0 } } */
+
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-8.c
new file mode 100644
index 000000000..3de29b230
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/prefetch-8.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O2 -fprefetch-loop-arrays -march=athlon -msse2 -mfpmath=sse --param simultaneous-prefetches=100 -fdump-tree-aprefetch-details" } */
+
+int a[12000];
+
+unsigned test(unsigned n)
+{
+  unsigned i, s = 0;
+
+  /* Temporal prefetch should be issued here. */
+  for (i = 0; i < 600; i++)
+    s += a[i*20];
+
+  return s;
+}
+
+/* { dg-final { scan-tree-dump-times "Issued prefetch" 1 "aprefetch" } } */
+
+/* { dg-final { scan-assembler-times "prefetcht" 1 } } */
+
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c
new file mode 100644
index 000000000..c2b512a12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 --param max-fields-for-field-sensitive=2 -fdump-tree-alias" } */
+
+struct Foo {
+  int *p, *q;
+};
+
+int foo (int ***x) __attribute__((pure));
+
+int bar (int b)
+{
+  int i;
+  struct Foo f;
+  int *p, **q;
+  p = &i;
+  f.p = &i;
+  f.q = f.p;
+  if (b)
+    q = &f.p;
+  else
+    q = &f.q;
+  return foo (&q);
+}
+
+/* { dg-final { scan-tree-dump "CALLUSED = { f.* i q }" "alias" } } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pta-fp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pta-fp.c
new file mode 100644
index 000000000..022783df1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/pta-fp.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-alias" } */
+extern double cos (double);
+extern double sin (double);
+double f(double a)
+{
+  double b;
+  double c,d;
+  double (*fp) (double);
+  if (a < 2.0)
+    {
+      fp = sin;
+      c = fp (a);
+    }
+  else
+    {
+      c = 1.0; 
+      fp = cos;
+    }
+  d = fp (a);
+  return d + c;
+}
+/* The points-to set of the final function pointer should be "sin cos" */
+
+/* { dg-final { scan-tree-dump-times "{ sin cos }" 1 "alias"} } */
+/* { dg-final { cleanup-tree-dump "alias" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-1.c
new file mode 100644
index 000000000..166780adf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int a, b, c, d;
+extern int printf (const char *, ...);
+int main(void)
+{
+  int e;
+  int f;
+  /* We should be able to transform these into the same expression, and only have two additions.  */
+  e = a + b;
+  e = e + c;
+  f = c + a;
+  f = f + b;
+  printf ("%d %d\n", e, f);
+}
+
+/* { dg-final { scan-tree-dump-times "b \\\+ a" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-10.c
new file mode 100644
index 000000000..cdc277431
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-10.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int main(int a, int b, int c, int d)
+{
+  /* Should become just a & b & c & d */
+  int e = (a & b) & (c & d);
+  int f = (c & a) & (b & d);
+  return e & f;
+}
+/* { dg-final { scan-tree-dump-times "\\\& " 3 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-11.c
new file mode 100644
index 000000000..f48f04e99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-11.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+int main(int a, int b, int c, int d)
+{
+  /* All the xor's cancel each other out, leaving 0  */
+  int e = (a ^ b) ^ (c ^ d);
+  int f = (c ^ a) ^ (b ^ d);
+  return e ^ f;
+}
+/* { dg-final { scan-tree-dump-times "= 0" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-12.c
new file mode 100644
index 000000000..65e2931ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-12.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-reassoc1-details" } */
+int f(int a, int b)
+{
+  /* MAX_EXPR <a, a> should cause it to be equivalent to a.  */
+  int c = a>=b?a:b;
+  int d = c>=a?c:a;
+  return d;
+}
+/* { dg-final { scan-tree-dump-times "Equivalence:" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-13.c
new file mode 100644
index 000000000..4d4dfeb44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-13.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ffast-math -fdump-tree-reassoc1 -fdump-tree-optimized" } */
+
+double foo(double a)
+{
+  double tmp = 5.0;
+  double tmp2 = a + tmp;
+  tmp2 = tmp2 - a;
+  return a + tmp2 - 5.0;
+}
+
+/* { dg-final { scan-tree-dump-not "\\\+ 0.0" "reassoc1" } } */
+/* { dg-final { scan-tree-dump "return a;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-14.c
new file mode 100644
index 000000000..24141ef34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-14.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+
+int test1 (int x, int y, int z, int weight)
+{
+  int tmp1 = x * weight;
+  int tmp2 = y * weight;
+  int tmp3 = (x - y) * weight;
+  return tmp1 + (tmp2 + tmp3);
+}
+
+int test2 (int x, int y, int z, int weight)
+{
+  int tmp1 = x * weight;
+  int tmp2 = y * weight * weight;
+  int tmp3 = z * weight * weight * weight;
+  return tmp1 + tmp2 + tmp3;
+}
+
+/* There should be one multiplication left in test1 and three in test2.  */
+
+/* { dg-final { scan-tree-dump-times "\\\*" 4 "reassoc1" } } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-15.c
new file mode 100644
index 000000000..d9b74d277
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-15.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+
+int test3 (int x, int y, int z, int weight, int w1, int w2, int w3)
+{
+  int wtmp1 = w1 * weight;
+  int wtmp2 = w2 * weight;
+  int wtmp3 = w3 * weight;
+  int tmp1 = x * wtmp1;
+  int tmp2 = y * wtmp2;
+  int tmp3 = z * wtmp3;
+  return tmp1 + tmp2 + tmp3;
+}
+
+/* The multiplication with weight should be un-distributed.
+   ???  This pattern is not recognized currently.  */
+
+/* { dg-final { scan-tree-dump-times "\\\*" 4 "reassoc1" } } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-16.c
new file mode 100644
index 000000000..4dd54a8cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-16.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -fdump-tree-reassoc1" } */
+
+double test1 (double x, double y, double z, double weight)
+{
+  double tmp1 = x / weight;
+  double tmp2 = y / weight;
+  double tmp3 = -x / weight;
+  return tmp1 + tmp2 + tmp3;
+}
+
+/* The division should be un-distributed and all references to x should
+   be gone.  */
+
+/* { dg-final { scan-tree-dump-times "/" 1 "reassoc1" } } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-17.c
new file mode 100644
index 000000000..255c786d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-17.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -fdump-tree-reassoc1" } */
+
+double test2 (double x, double y, double ddj, int b)
+{
+  double tmp1, tmp2, sum;
+  sum = 0.0;
+  if (b)
+    sum = 1.0;
+  tmp1 = sum/ddj;
+  tmp2 = x/ddj;
+  return tmp1 + y + tmp2;
+}
+
+/* { dg-final { scan-tree-dump-times "/" 1 "reassoc1" } } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-18.c
new file mode 100644
index 000000000..ce52cd0d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-18.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-reassoc1" } */
+
+int
+ETree_nFactorEntriesInFront (int b, int m)
+{
+  int nent = b*b + 2*b*m;
+  return nent;
+}
+
+/* { dg-final { scan-tree-dump-times "\\\*" 2 "reassoc1" } } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-19.c
new file mode 100644
index 000000000..c13e1d36f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-19.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-Os -fdump-tree-reassoc2" } */
+
+/* Slightly changed testcase from PR middle-end/40815.  */
+void bar(char*, char*, int);
+void foo(char* left, char* rite, int element)
+{
+  while (left <= rite)
+  {
+    /* This should expand into
+       D.zzzz = D.zzzz - D.xxxx;
+       and NOT to
+       D.D.yyyy = -D.xxxx; D.zzzz = D.zzzz + D.yyyy;  */
+    rite -= element;
+    bar(left, rite, element);
+  }
+}
+
+/* There should be no " + " in the dump.  */
+/* { dg-final { scan-tree-dump-times " \\\+ " 0 "reassoc2" } } */
+/* { dg-final { cleanup-tree-dump "reassoc2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-2.c
new file mode 100644
index 000000000..96be8cfe8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int f (int a0,int a1,int a2,int a3,int a4) 
+{ 
+int b0, b1, b2, b3, b4,e; 
+  /* this can be optimized to four additions... */ 
+  b4 = a4 + a3 + a2 + a1 + a0; 
+  b3 = a3 + a2 + a1 + a0; 
+  b2 = a2 + a1 + a0; 
+  b1 = a1 + a0; 
+  /* This is actually 0 */
+  e = b4 - b3 + b2 - b1 - a4 - a2;
+  return e;
+}
+
+/* { dg-final { scan-tree-dump-times "return 0" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c
new file mode 100644
index 000000000..178e6a448
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c
@@ -0,0 +1,7 @@
+/* { dg-options "" } */
+int main(int a, int b, int c, int d)
+{
+  int e = (a & ~b) & (~c & d);
+  int f = (~c & a) & (b & ~d);
+ return (e & f);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-4.c
new file mode 100644
index 000000000..8f9de464e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized -ffast-math" } */
+float a, b, c, d;
+extern int printf (const char *, ...);
+int main(void)
+{
+  float e;
+  float f;
+  /* We should not be able to transform these into the same expression, and only have two additions.  */
+  e = a + b;
+  e = e + c;
+  f = c + a;
+  f = f + b;
+  printf ("%f %f\n", e, f);
+}
+
+/* { dg-final { scan-tree-dump-times "\\\+" 2 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-5.c
new file mode 100644
index 000000000..8d168f90f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-5.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+extern int printf (const char *, ...);
+int main(int argc, int b)
+{
+  /* We should be able to get rid of the a - i.  */
+  int i;
+  for (i = 0; i < 50; i++)
+    {
+      int a = b + i;
+      int c = a - i;
+      int d = argc + b;
+      printf ("%d %d\n", c,d);
+    }
+}
+/* { dg-final { scan-tree-dump-times "a - i" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-6.c
new file mode 100644
index 000000000..d7c8b818c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-6.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+int main(int a, int b, int c, int d)
+{
+  /* Should be transformed into a + c + 8 */
+  int e = a + 3;
+  int f = c + 5;
+  int g = e + f;
+  return g;
+}
+
+/* { dg-final { scan-tree-dump-times "\\\+ 8" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-7.c
new file mode 100644
index 000000000..6b3b22702
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-7.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+int main(int a, int b, int c, int d, int e, int f, int g, int h)
+{
+  /* Should be transformed into a + c + d + e + g + 15 */
+  int i = (a + 9) + (c + d);
+  int j = (e + 4) + (2 + g);
+  e = i + j;
+  return e;
+}
+/* { dg-final { scan-tree-dump-times "\\\+ 15" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-8.c
new file mode 100644
index 000000000..b2ca4ae03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-8.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+
+int main(int a, int b, int c, int d, int e, int f, int g, int h)
+{
+  /* e & ~e -> 0 */
+  int i = (a & 9) & (c & d);
+  int j = (~e & d) & (~c & e);
+  e = i & j;
+  return e;
+}
+/* { dg-final { scan-tree-dump-times "= 0" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-9.c
new file mode 100644
index 000000000..7fa9ff3f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/reassoc-9.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-reassoc1" } */
+
+int main(int a, int b, int c, int d, int e, int f, int g, int h)
+{
+  /* Should be transformed into e = 20 */
+  int i = (a + 9) + (c + 8);
+  int j = (-c + 1) + (-a + 2);
+
+  e = i + j;
+  return e;
+}
+/* { dg-final { scan-tree-dump-times "= 20" 1 "reassoc1"} } */
+/* { dg-final { cleanup-tree-dump "reassoc1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-1.c
new file mode 100644
index 000000000..36f2c23de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -funsafe-math-optimizations -fdump-tree-recip" } */
+
+float e(float *x, float *y, float *z)
+{
+  float m = __builtin_sqrt (*x * *x + *y * *y + *z * *z);
+  *x /= m;
+  *y /= m;
+  *z /= m;
+}
+
+/* Look for only one division.  */
+/* { dg-final { scan-tree-dump-times "= .* /" 1 "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c
new file mode 100644
index 000000000..be754145e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -funsafe-math-optimizations -fdump-tree-recip" } */
+
+float u, v, w, x, y, z;
+
+void e(float a, float b, float c, float d, float e, float f)
+{
+  if (a < b)
+    {
+      a = a + b;
+      c = c + d;
+    }
+
+  /* The PHI nodes for these divisions should be combined.  */
+  d = d / a;
+  e = e / a;
+  f = f / a;
+  
+  a = a / c;
+  b = b / c;
+
+  /* This should not be left as a multiplication.  */
+  c = 1 / c;
+
+  u = a;
+  v = b;
+  w = c;
+  x = d;
+  y = e;
+  z = f;
+}
+
+/* { dg-final { scan-tree-dump-times " / " 2 "recip" } } */
+/* { dg-final { scan-tree-dump-times " \\* " 5 "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-3.c
new file mode 100644
index 000000000..04b40f32a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-3.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-trapping-math -funsafe-math-optimizations -fdump-tree-recip" } */
+
+double F[2] = { 0.0, 0.0 }, e;
+
+/* In this case the optimization is interesting.  */
+float h ()
+{
+	int i;
+	double E, W, P, d;
+
+	W = 1.1;
+	d = 2.*e;
+	E = 1. - d;
+
+	for( i=0; i < 2; i++ )
+		if( d > 0.01 )
+		{
+			P = ( W < E ) ? (W - E)/d : (E - W)/d;
+			F[i] += P;
+		}
+
+	F[0] += E / d;
+}
+
+/* { dg-final { scan-tree-dump-times " / " 1 "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-4.c
new file mode 100644
index 000000000..20d7681d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-4.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fno-trapping-math -funsafe-math-optimizations -fdump-tree-recip" } */
+
+/* based on the test case in pr23109 */
+
+double F[2] = { 0., 0. }, e = 0.;
+
+/* Nope, we cannot prove the optimization is worthwhile in this case.  */
+void f ()
+{
+	int i;
+	double E, W, P, d;
+
+	W = 1.;
+	d = 2.*e;
+	E = 1. - d;
+
+	if( d > 0.01 )
+	{
+		P = ( W < E ) ? (W - E)/d : (E - W)/d;
+		F[i] += P;
+	}
+}
+
+/* We also cannot prove the optimization is worthwhile in this case.  */
+float g ()
+{
+	int i;
+	double E, W, P, d;
+
+	W = 1.;
+	d = 2.*e;
+	E = 1. - d;
+
+	if( d > 0.01 )
+	{
+		P = ( W < E ) ? (W - E)/d : (E - W)/d;
+		F[i] += P;
+	}
+
+	return 1.0 / d;
+}
+
+/* { dg-final { scan-tree-dump-not "reciptmp" "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-5.c
new file mode 100644
index 000000000..aafa98f16
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-5.c
@@ -0,0 +1,32 @@
+/* { dg-options "-O1 -funsafe-math-optimizations -ftrapping-math -fdump-tree-recip -fdump-tree-optimized" } */
+/* { dg-do compile } */
+/* { dg-warning "-fassociative-math disabled" "" { target *-*-* } 1 } */
+
+/* Test the reciprocal optimizations together with trapping math.  */
+
+extern int f2();
+
+double f1(double y, double z, double w, double j, double k)
+{
+  double b, c, d, e, f, g;
+
+  if (f2 ())
+    /* inserts one division here */
+    b = 1 / y, c = z / y, d = j / y;
+  else
+    /* one division here */
+    b = 3 / y, c = w / y, d = k / y;
+
+  /* and one here, that should be removed afterwards but is not right now */
+  e = b / y;
+  f = c / y;
+  g = d / y;
+
+  return e + f + g;
+}
+
+/* { dg-final { scan-tree-dump-times " / " 3 "recip" } } */
+/* { dg-final { scan-tree-dump-times " / " 2 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c
new file mode 100644
index 000000000..b3334fb86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c
@@ -0,0 +1,30 @@
+/* { dg-options "-O1 -funsafe-math-optimizations -fno-trapping-math -fdump-tree-recip" } */
+/* { dg-do compile } */
+
+/* Test inserting in a block that does not contain a division.  */
+
+extern int f2();
+
+double m, n, o;
+
+void f1(double y, double z, double w)
+{
+  double b, c, d, e, f;
+
+  if (g ())
+    b = 1 / y, c = z / y;
+  else
+    b = 3 / y, c = w / y;
+
+  d = b / y;
+  e = c / y;
+  f = 1 / y;
+
+  m = d;
+  n = e;
+  o = f;
+}
+
+/* { dg-final { scan-tree-dump-times " / " 1 "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c
new file mode 100644
index 000000000..98bbdca6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c
@@ -0,0 +1,31 @@
+/* { dg-options "-O1 -funsafe-math-optimizations -fno-trapping-math -fdump-tree-recip" } */
+/* { dg-do compile } */
+
+/* Test inserting in a block that does not contain a division.  */
+
+extern double h();
+
+double m, n, o;
+
+void f(int x, double z, double w)
+{
+  double b, c, d, e, f;
+  double y = h ();
+
+  if (x)
+    b = 1 / y, c = z / y;
+  else
+    b = 3 / y, c = w / y;
+
+  d = b / y;
+  e = c / y;
+  f = 1 / y;
+
+  m = d;
+  n = e;
+  o = f;
+}
+
+/* { dg-final { scan-tree-dump-times " / " 1 "recip" } } */
+/* { dg-final { cleanup-tree-dump "recip" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-1.c
new file mode 100644
index 000000000..b959fa17b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-1.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/19899 */
+/* Decrementing a floating-point variable in a loop caused an ICE.  */
+
+/* { dg-do run } */
+/* { dg-options "-O -ftree-vectorize" } */
+
+extern void abort (void);
+
+int main()
+{
+  float i=1;
+
+  while (i>=0)
+    --i;
+
+  if (i != -1)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-2.c
new file mode 100644
index 000000000..0cac99475
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-2.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/19899 */
+/* Decrementing a floating-point variable in a loop caused an ICE.  */
+
+/* { dg-do run } */
+/* { dg-options "-O -ftree-vectorize" } */
+
+extern void abort (void);
+
+int main()
+{
+  double a = 20;
+  int i;
+
+  for (i = 0; i < 10; ++i)
+    a -= 2;
+
+  if (a)
+    abort();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-cast.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-cast.c
new file mode 100644
index 000000000..fe6dde4bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/scev-cast.c
@@ -0,0 +1,26 @@
+/* A test for various conversions of chrecs.  */
+
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void blas (char xxx);
+void blau (unsigned char xxx);
+
+void tst(void)
+{
+  unsigned i;
+
+  for (i = 0; i < 128; i++) /* This cast to char has to be preserved.  */
+    blas ((char) i);
+  for (i = 0; i < 127; i++) /* And this one does not.  */
+    blas ((char) i);
+  for (i = 0; i < 255; i++) /* This cast is not necessary.  */
+    blau ((unsigned char) i);
+  for (i = 0; i < 256; i++)
+    blau ((unsigned char) i); /* This one is necessary.  */
+}
+
+/* { dg-final { scan-tree-dump-times "\\(int\\) \\(unsigned char\\)" 1 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "\\(int\\) \\(char\\)" 1 "optimized" } } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-1.c
new file mode 100644
index 000000000..c2e45eb1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-1.c
@@ -0,0 +1,73 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized --param sra-max-structure-size=32" } */
+
+/* Tests for SRA. */
+
+typedef struct teststruct
+{
+  double d;
+  char f1;
+} teststruct;
+
+void
+copystruct1 (teststruct param)
+{
+  teststruct local;
+  param.f1 = 0;
+  local = param;
+  if (local.f1 != 0)
+    link_error ();
+}
+
+void
+copystruct11 (teststruct *param)
+{
+  teststruct local;
+  param->f1 = 0;
+  local = *param;
+  if (local.f1 != 0)
+    link_error ();
+}
+
+void
+copystruct111 (teststruct param)
+{
+  teststruct *local = &param;
+  param.f1 = 0;
+  if (local->f1 != 0)
+    link_error ();
+}
+
+teststruct globf;
+void
+copystruct1111 (void)
+{
+  teststruct local;
+  globf.f1 = 0;
+  local = globf;
+  if (local.f1 != 0)
+    link_error ();
+}
+
+void
+copystruct11111 (void)
+{
+  teststruct *local = &globf;
+  globf.f1 = 0;
+  if (local->f1 != 0)
+    link_error ();
+}
+
+void
+copystruct111111 (teststruct param)
+{
+  static teststruct local;
+  param.f1 = 0;
+  local = param;
+  if (local.f1 != 0)
+    link_error ();
+}
+
+/* There should be no referenc to link_error. */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-2.c
new file mode 100644
index 000000000..ec30bc904
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-2.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized --param sra-max-structure-size=32" } */
+
+/* Test for SRA. */
+
+typedef struct teststruct
+{
+  double d;
+  char f1;
+} teststruct;
+
+
+void
+copystruct11 (teststruct *param)
+{
+  static teststruct local;
+  param->f1 = 0;
+  local = *param;
+  if (local.f1 != 0)
+    link_error ();
+}
+
+
+/* There should be no reference to link_error. */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-3.c
new file mode 100644
index 000000000..732dc302d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-3.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized --param sra-max-structure-size=32" } */
+
+/* Test for SRA. */
+
+typedef struct teststruct
+{
+  double d;
+  char f1;
+} teststruct;
+
+teststruct *globf1;
+
+extern void link_error (void);
+
+void
+copystruct1 (void)
+{
+  teststruct local;
+  globf1->f1 = 0;
+  local = *globf1;
+  if (local.f1 != 0)
+    link_error ();
+}
+
+/* There should be no reference to link_error. */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-4.c
new file mode 100644
index 000000000..6fdf37ffb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/sra-4.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized -w" } */
+/* Check that SRA does non block copies for structs that just contain vectors. */
+
+#define vector __attribute__((vector_size(16)))
+
+struct vt
+{
+  vector int t;
+};
+
+
+vector int f(vector int t1, vector int t2)
+{
+  struct vt st1, st2, st3;
+  st1.t = t1;
+  st2 = st1;
+  st2.t += t2;
+  st3 = st2;
+  return st3.t;
+}
+
+/* There should be no references to st as SRA should not have done block copy. */
+/* { dg-final { scan-tree-dump-times "st" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-1.c
new file mode 100644
index 000000000..82f37abc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-1.c
@@ -0,0 +1,75 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+extern void link_error (void);
+
+/* check folding */
+
+void test1 (void)
+{
+  unsigned int l = 3 * 4 - 5 / 2;
+  if (l != 10)
+    link_error ();
+}
+
+void test11 (void)
+{
+  unsigned int l = (((((((3 / 2 + 2) * 4) & 7) ^ 3) % 8) << 2) + 1) >> 2;
+  if (l != 7)
+    link_error ();
+}
+
+/* cprop in a basic block */
+void test111 (void)
+{
+  unsigned int l0 = 3 / 2 + 2;
+  unsigned int l1 = l0 * 4;
+  unsigned int l2 = 7;
+  unsigned int l3 = l1 & l2;
+  unsigned int l4 = 3;
+  unsigned int l5 = l3 ^ l4;
+  unsigned int l6 = 8;
+  unsigned int l7 = l5 % l6;
+  unsigned int l8 = 2;
+  unsigned int l9 = l7 << l8;
+  unsigned int l10 = l9 + 1;
+  unsigned int l11 = l10 >> 2;
+  if (l11 != 7)
+    link_error ();
+}
+
+
+/* cprop after an if statement */
+void test1111 (int p)
+{
+  int l = 53;
+  if (p)
+    {
+      if ((67 + l - 25) != 95)
+        link_error ();
+    }
+  else
+    {
+      if ((93 - l +  25) != 65)
+        link_error ();
+    }
+}
+
+/* cprop after a loop */
+void test11111 (int p, int q, int r)
+{
+  int l = 53;
+  while (p < r)
+    {
+      if ((67 + l - 25) != 95)
+        link_error ();
+      p -= q;
+    }
+}
+
+
+
+/* There should be not link_error calls, if there is any the
+   optimization has failed */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "ccp1"} } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-10.c
new file mode 100644
index 000000000..7177d991e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-10.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-fab" } */
+
+/* Check that we fold strlen of equally long strings, and that we do not
+   fail to terminate when there is a nontrivial cycle in the corresponding
+   ssa graph.  */
+
+extern __SIZE_TYPE__ strlen (const char *);
+
+void foo(int i)
+{
+  char *s = "abcde";
+
+  if (i)
+    {
+      s = "defgh";
+      goto middle;
+    }
+
+start:
+
+  bla ();
+
+middle:
+
+  if (bla ())
+    goto start;
+
+  bar (strlen (s));
+}
+
+/* There should be no calls to strlen.  */
+/* { dg-final { scan-tree-dump-times "strlen" 0 "fab"} } */
+/* { dg-final { cleanup-tree-dump "fab" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-11.c
new file mode 100644
index 000000000..4eaad28b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-11.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+/* Test for CPROP across a DAG. */
+
+int test111 (int param)
+{
+  int a, b, c;
+  if (param) {
+    a = 3;
+    b = 2;
+  }
+  else {
+    a = 2;
+    b = 3;
+  }
+  c = a + b;
+  if (c != 5)
+    return 2;
+  return 0;
+}
+
+int test1111 (int param)
+{
+  _Bool a, b, c;
+  if (param) {
+    a = 1;
+    b = 0;
+  }
+  else {
+    a = 0;
+    b = 1;
+  }
+  c = a && b;
+  if (c)
+    return 2;
+  return 0;
+}
+
+/* All ifs should be eliminated. */
+/* { dg-final { scan-tree-dump-times "if " 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-12.c
new file mode 100644
index 000000000..8ee9eb8d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-12.c
@@ -0,0 +1,32 @@
+/* { dg-do run } */ 
+/* { dg-options "-O2" } */
+
+struct A
+{
+  int a;
+  int b;
+};
+
+struct A a;
+const int B = 42;
+
+void foo (int i)
+{
+  if (i > 10)
+    a.a = 42;
+  else
+    {
+      a.b = 21;
+      a.a = a.b + 21;
+    }
+
+  /* This should be folded to 'if (0)' as a.a and B are both 42.  */
+  if (a.a != B)
+    link_error ();
+}
+
+main ()
+{
+  foo (3);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-13.c
new file mode 100644
index 000000000..d35adee51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-13.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+static const char f[3] = "?";
+
+int foo()
+{
+  int i = 0;
+  return f[i] != '?';
+}
+
+/* { dg-final { scan-tree-dump "return 0;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-14.c
new file mode 100644
index 000000000..3be025f07
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-14.c
@@ -0,0 +1,21 @@
+/* PR tree-optimization/29738.  We used not to realize that "i" can never
+   become nonzero.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int i;
+
+void foo (void);
+void bar (void)
+{
+  int j;
+  i = 0;
+  for (j = 0; j < 10000; j++)
+    if (i)
+      foo ();
+}
+
+/* Everything except for the "i = 0" assignment should get removed.  */
+/* { dg-final { scan-tree-dump-times "if" 0 "optimized" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-15.c
new file mode 100644
index 000000000..aaf57126a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-15.c
@@ -0,0 +1,49 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+/* Check that the initial values are honored when necessary.  */
+
+void link_error (void);
+
+/* The call to link_error cannot be eliminated in this case.  */
+
+void test1 (int param1, int param2, int x)
+{
+  if (param1)
+    x = 3;
+
+  if (param2)
+    if (x != 3)
+      link_error ();
+}
+
+/* The call to link_error cannot be eliminated in this case.  */
+
+int global;
+void test2 (int param1, int param2)
+{
+  if (param1)
+    global = 3;
+
+  if (param2)
+    if (global != 3)
+      link_error ();
+}
+
+/* In this case, we can eliminate the call, as unless "local" is set
+   to 3, its value is undefined.  */
+
+void test3 (int param1, int param2)
+{
+  int local;
+
+  if (param1)
+    local = 3;
+
+  if (param2)
+    if (local != 3)
+      link_error ();
+}
+
+/* { dg-final { scan-tree-dump-times "link_error" 2 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-16.c
new file mode 100644
index 000000000..33f9744d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-16.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+static const int x;
+
+int test1 (void)
+{
+  char *p = "hello";
+  int i = x;
+  i = i + 5;
+  return p[i];
+}
+
+int test2 (void)
+{
+  int i = x;
+  i = i + 5;
+  return "hello"[i];
+}
+
+/* { dg-final { scan-tree-dump-times "return 0;" 2 "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-17.c
new file mode 100644
index 000000000..7d769ae17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-17.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+int foo(void)
+{
+  int i = 0;
+  char *p = (char *)&i;
+  return *(int *)p;
+}
+
+struct Foo {
+  int i;
+} f;
+
+int bar(void)
+{
+  char *p = (char *)&f;
+  return ((struct Foo *)p)->i;
+}
+
+const struct Foo g;
+
+int foobar(void)
+{
+  struct Foo *p = (struct Foo *)&g;
+  return ((const struct Foo *)p)->i;
+}
+
+/* { dg-final { scan-tree-dump "= i;" "ccp1" } } */
+/* { dg-final { scan-tree-dump "= f.i;" "ccp1" } } */
+/* { dg-final { scan-tree-dump "= g.i;" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-18.c
new file mode 100644
index 000000000..cbe12598b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-18.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+/* Check that we constant propagate &&c into the goto and remove
+   the unreachable BBs.  */
+
+void a(int*);  void b(int*);  void c(int*);  void d(int*);
+void func2(int* val)
+{
+  const void *const labels[] = { &&a, &&b, &&c, &&d };
+  goto *labels[2];
+  a: a(val);
+  b: b(val);
+  c: c(val);
+  d: d(val);
+}
+
+/* { dg-final { scan-tree-dump-not "a \\\(" "ccp1" } } */
+/* { dg-final { scan-tree-dump-not "b \\\(" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-19.c
new file mode 100644
index 000000000..ab4182246
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-19.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+struct f { int i; };
+int g()
+{
+  struct f a, *a1;
+  int *i;
+  a.i = 1;
+  a1 = &a;
+  i = &a1->i;
+  return *i;  /* This should be turned into a.i */
+}
+
+/* { dg-final { scan-tree-dump "= a.i;" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-2.c
new file mode 100644
index 000000000..19975a392
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-2.c
@@ -0,0 +1,172 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+
+/* check that cprop for variables of different types still works even
+   if function calls or assignments to different types of data are
+   interposed.  */
+
+int test7 (int *intarr)
+{
+  extern int foo7 (int);
+  int u = 7, v1;
+  foo7 (u);
+  v1 = u;
+  if (v1 != 7)
+    link_error ();
+  return v1;
+}
+
+int test77 (int *arr)
+{
+  int u = 7, v1;
+  arr[0] = 4;
+  v1 = u;
+  if (v1 != 7)
+    link_error ();
+  return v1 + arr[0];
+}
+
+int test777 (void)
+{
+  extern int foo(int *);
+  int u = 7, v1;
+  static int sarr[10];
+  sarr[0] = 4;
+  v1 = u;
+  if (v1 != 7)
+    link_error ();
+  foo (sarr);
+  return v1 + sarr[0];
+}
+
+int garr[10];
+int test7777 (void)
+{
+  int u = 7, v1;
+  garr[0] = 4;
+  v1 = u;
+  if (v1 != 7)
+    link_error ();
+  return v1 + garr[0];
+}
+
+int test88 (int *arr)
+{
+  static int l;
+  int v1;
+  l = 8;
+  arr[0] = 4;
+  v1 = l;
+  if (v1 != 8)
+    link_error ();
+  l = foo88 (l);
+  return v1 + arr[0];
+}
+
+int test888 (void)
+{
+  static int l;
+  extern int foo(int *);
+  int v1;
+  static int sarr[10];
+  l = 8;
+  sarr[0] = 4;
+  v1 = l;
+  if (v1 != 8)
+    link_error ();
+  foo (sarr);
+  l = foo88(l);
+  return v1 + sarr[0];
+}
+
+int test8888 (void)
+{
+  static int l;
+  int v1;
+  l = 8;
+  garr[0] = 4;
+  v1 = l;
+  if (v1 != 8)
+    link_error ();
+  return v1 + garr[0];
+}
+
+
+
+/* global var  */
+int g9;
+int garr9[10];
+int test9 (int *intarr)
+{
+  extern int foo9 (int) __attribute__ ((const));
+  int h, v;
+  g9 = 9;
+  h = foo9 (g9);
+  v = g9;
+  if (v != 9)
+    link_error ();
+  return g9;
+}
+
+int test99 (int *intarr)
+{
+  extern int foo9 (int) __attribute__ ((pure));
+  int h, v;
+  g9 = 9;
+  h = foo9 (g9);
+  v = g9;
+  if (v != 9)
+    link_error ();
+  return g9;
+}
+
+extern int foo99 (int);
+
+int test999 (int *arr)
+{
+  static int l;
+  int v1;
+  g9 = 9;
+  l = 4;
+  v1 = g9;
+  if (v1 != 9)
+    link_error ();
+  l = foo99 (l);
+  return v1 + l;
+}
+
+
+int test9999 (void)
+{
+  int v1;
+  static int sarr[10];
+  g9 = 9;
+  sarr[0] = 4;
+  v1 = g9;
+  if (v1 != 9)
+    link_error ();
+  foo (sarr);
+  g9 = foo99 (g9);
+  return v1 + sarr[0];
+}
+
+
+int test99999 (void)
+{
+  int v1;
+  g9 = 9;
+  garr9[0] = 4;
+  v1 = g9;
+  if (v1 != 9)
+    link_error ();
+  return v1 + garr9[0];
+}
+
+
+/* There should be not link_error calls, if there is any the
+   optimization has failed */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-20.c
new file mode 100644
index 000000000..63febd0e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-20.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+/* Make sure CCP propagates through indirect calls.  */
+
+int foo (void)
+{
+  int i = -5;
+  int (*fn)(int) = __builtin_abs;
+  int j = fn(i);
+  return j + 5;
+}
+
+/* { dg-final { scan-tree-dump "return 10;" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-21.c
new file mode 100644
index 000000000..3b23c3623
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-21.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+struct A {
+    struct B {
+	int i;
+    } b;
+} a;
+
+int foo (void)
+{
+  struct B *p = &a.b;
+  struct A *q = (struct A *) p;
+  return q->b.i;
+}
+
+int bar (void)
+{
+  struct A *p = &a;
+  struct B *q = (struct B *) p;
+  return q->i;
+}
+
+/* { dg-final { scan-tree-dump-times "a.b.i" 2 "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-22.c
new file mode 100644
index 000000000..01d11ecac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-22.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+/* Make sure we propagate through builtins.  */
+
+int foo (unsigned b)
+{
+  unsigned t = -1;
+  int x = b <= t;
+  long l = __builtin_expect (x, 0);
+  return l;
+}
+
+/* { dg-final { scan-tree-dump "return 1;" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-23.c
new file mode 100644
index 000000000..ac7f068cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-23.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp1" } */
+
+/* Make sure we propagate through POINTER_PLUS_EXPRs.  */
+
+struct A {
+  int i[2];
+} a;
+
+int foo (void)
+{
+  struct A *p = &a;
+  int *q = (int *)p;
+  int *x = q + 1;
+  return *x;
+}
+
+/* { dg-final { scan-tree-dump "a.i\\\[1\\\]" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-27.c
new file mode 100644
index 000000000..c27963454
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-27.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ccp1" } */
+
+#include <string.h>
+
+char c[10];
+
+void
+f1 ()
+{
+  const char *p = "123456";
+  memcpy (c, p, 6);
+}
+
+void
+f2 ()
+{
+  const char *p = "12345678";
+  p += 2;
+  memcpy (c, p, 6);
+}
+
+/* { dg-final { scan-tree-dump-times "memcpy\[^\n\]*123456" 2 "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-3.c
new file mode 100644
index 000000000..86a706b80
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-3.c
@@ -0,0 +1,137 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ccp2" } */
+
+extern void link_error (void);
+
+/* Some addresses clearly cannot be equal, check that some address
+   expressions can be evaluated as constants.
+   Most of the tests are folding tests, but at least some require
+   points-to analysis, so we scan the first CCP dump after PTA.  */
+
+char g1, g2;
+void test6 (char p1, char p2)
+{
+  char l1 = 1, l2 = 2;
+  static char s1 = 5, s2 = 7;
+  if (&l1 == &l2)
+    link_error ();
+
+  if (&p1 == &p2)
+    link_error ();
+
+  if (&s1 == &s2)
+    link_error ();
+
+  if (&g1 == &g2)
+    link_error ();
+  
+  if (&p1 == &l1)
+    link_error (); 
+
+  if (&p1 == &s1)
+    link_error (); 
+
+  if (&p1 == &l2)
+    link_error (); 
+
+  if (&p1 == &g1)
+    link_error (); 
+
+  if (&l1 == &g1)
+    link_error (); 
+
+  if (&s1 == &g1)
+    link_error (); 
+}
+
+extern void *alloc (int) __attribute__ ((malloc));
+char gca1[128];
+char* __restrict__ rgc1;
+char* test66 (char * __restrict__ rp1, char * __restrict__ rp2, char *p1)
+{
+  char * __restrict__ rl1 = p1;
+  char * l1 = (char*) alloc (20);
+
+  if (l1 == rgc1)
+    link_error ();
+
+  if (l1 == rp1)
+    link_error ();
+
+  if (l1 == rl1)
+    link_error ();
+
+  if (l1 == gca1)
+    link_error ();
+
+  if (rl1 == rgc1)
+    link_error ();
+
+  if (rl1 == rp1)
+    link_error ();
+
+  if (rl1 == gca1)
+    link_error ();
+  
+  if (rp1 == rp2)
+    link_error ();
+
+  if (rp1 == rgc1)
+    link_error ();
+  
+  if (rp1 == gca1)
+    link_error ();
+
+  if (gca1 == rgc1)
+    link_error ();
+
+}
+
+int gci1[128];
+int* __restrict__ rgi1;
+int* test666 (int * __restrict__ rp1, int * __restrict__ rp2, int *p1)
+{
+  int * __restrict__ rl1 = p1;
+  int * l1 = (int*) alloc (20);
+
+  if (l1 == rgi1)
+    link_error ();
+
+  if (l1 == rp1)
+    link_error ();
+
+  if (l1 == rl1)
+    link_error ();
+
+  if (l1 == gci1)
+    link_error ();
+
+  if (rl1 == rgi1)
+    link_error ();
+
+  if (rl1 == rp1)
+    link_error ();
+
+  if (rl1 == gci1)
+    link_error ();
+  
+  if (rp1 == rp2)
+    link_error ();
+
+  if (rp1 == rgi1)
+    link_error ();
+  
+  if (rp1 == gci1)
+    link_error ();
+
+  if (gci1 == rgi1)
+    link_error ();
+}
+
+
+/* There should be not link_error calls, if there is any the
+   optimization has failed */
+/* ??? While we indeed don't handle some of these, a couple of the
+   restrict tests are incorrect.  */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "ccp2" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "ccp2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-7.c
new file mode 100644
index 000000000..b34974130
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-7.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+extern void link_error (void);
+
+/* tests to check if cprop works when using non-return functions   */
+
+extern int not_returning (int) __attribute__ ((noreturn));
+
+int b;
+int test7 (int a)
+{
+  b = 7;
+  if (a)
+    {
+      not_returning (a);
+    }
+  if (b != 7)
+    link_error ();
+  return b;
+}
+
+
+/* There should be not link_error calls, if there is any the
+   optimization has failed */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-9.c
new file mode 100644
index 000000000..af23f8beb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-9.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+/* Check that cprop works for assignments to array elements and structs.  */
+
+struct foo {
+  int a;
+};
+
+extern void link_error (void);
+
+void
+test9 (struct foo f)
+{
+  f.a = 0;
+  if (f.a != 0)
+    link_error ();
+}
+
+void
+test99 (struct foo *f)
+{
+  f->a = 0;
+  if (f->a != 0)
+    link_error ();
+}
+
+void
+test999 (int *arr)
+{
+  *arr = 0;
+  if (*arr != 0)
+    link_error ();
+}
+
+void
+test9999 (int *arr)
+{
+  arr[13] = 0;
+  if (arr[13] != 0)
+    link_error ();
+}
+
+void
+test99999 (int *arr, int j)
+{
+  arr[j] = 0;
+  if (arr[j] != 0)
+    link_error ();
+}
+
+/* There should be no link_error calls, if there is any, the
+   optimization has failed */
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-copyprop-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-copyprop-1.c
new file mode 100644
index 000000000..41ad6ce6e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-copyprop-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-optimized" } */
+
+typedef struct { int i; int j; } A;
+int foo(A *a, int i)
+{
+  a->i = i;
+  return a->i;
+}
+
+/* { dg-final { scan-tree-dump "return i" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-1.c
new file mode 100644
index 000000000..12d982629
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-dce2" } */
+
+int t() __attribute__ ((const));
+q()
+{
+  int i = t();
+  if (!i)
+    i = t();
+}
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dce2"} } */
+/* { dg-final { cleanup-tree-dump "dce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-2.c
new file mode 100644
index 000000000..5e5302486
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dce2" } */
+
+/* We should notice constantness of this function. */
+static int __attribute__((noinline)) t(int a) 
+{
+	return a+1;
+}
+void q(void)
+{
+  int i = t(1);
+  if (!i)
+    i = t(1);
+}
+/* There should be no IF conditionals.  */
+/* { dg-final { scan-tree-dump-times "if " 0 "dce2"} } */
+/* { dg-final { cleanup-tree-dump "dce2" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-3.c
new file mode 100644
index 000000000..f7645c353
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dce-3.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-cddce1" } */
+
+int main(void)
+{
+  unsigned i, j;
+
+  for (i = 1, j = 0; i != 0; i+=2)
+    {
+      j += 500;
+      if (j % 7)
+	{
+	  j++;
+	}
+      else
+	{
+	  j--;
+	}
+    }
+
+  return 0;
+}
+
+/* We should eliminate the inner condition, but the loop must be preserved
+   as it is infinite.  Therefore there should be just one phi node (for i):  */
+/* { dg-final { scan-tree-dump-times "PHI " 1 "cddce1"} } */
+
+/* And one if (for the exit condition of the loop):  */
+/* { dg-final { scan-tree-dump-times "if " 1 "cddce1"} } */
+
+/* { dg-final { cleanup-tree-dump "cddce1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-ccp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-ccp-1.c
new file mode 100644
index 000000000..b2bcd06be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-ccp-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int t(int a) __attribute__ ((const));
+void abort (void);
+int
+ccp(int b)
+{
+	int a=1;
+	a++;
+	a++;
+	a++;
+	if (b)
+	  abort();
+	return a;
+}
+/* We should propagate constant 4 into return.  */
+/* { dg-final { scan-tree-dump-times "return 4" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-cse-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-cse-1.c
new file mode 100644
index 000000000..5bbfd3d17
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-cse-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-fre-details" } */
+int t(int a) __attribute__ ((const));
+void q (void);
+void
+threading(int a,int b)
+{
+	if (t(a))
+	{
+	  if (t(a))
+	    q();
+	}
+}
+/* We should thread the jump twice and eliminate it.  */
+/* { dg-final { scan-tree-dump-times "Replaced.* t " 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-1.c
new file mode 100644
index 000000000..7671e93ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fno-tree-vrp -fdump-tree-dom1-details" } */
+void t(void);
+void q(void);
+void q1(void);
+void
+threading(int a,int b)
+{
+	if (a>b)
+	  t();
+	else
+	  q();
+	if (a<=b)
+	  q1();
+}
+/* We should thread the jump twice and elliminate it.  */
+/* { dg-final { scan-tree-dump-times "Threaded" 2 "dom1"} } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-2.c
new file mode 100644
index 000000000..6aaea8ecb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-2.c
@@ -0,0 +1,119 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-vrp1-stats -fdump-tree-dom1-stats" } */
+
+void foo();
+void bla();
+void bar();
+
+/* In the following two cases, we should be able to thread edge through
+   the loop header.  */
+
+void thread_entry_through_header (void)
+{
+  int i;
+
+  for (i = 0; i < 170; i++)
+    bla ();
+}
+
+void thread_latch_through_header (void)
+{
+  int i = 0;
+  int first = 1;
+
+  do
+    {
+      if (first)
+	foo ();
+
+      first = 0;
+      bla ();
+    } while (i++ < 100);
+}
+
+/* This is a TODO -- it is correct to thread both entry and latch edge through
+   the header, but we do not handle this case yet.  */
+
+void dont_thread_1 (void)
+{
+  int i = 0;
+  int first = 1;
+
+  do
+    {
+      if (first)
+	foo ();
+      else
+	bar ();
+
+      first = 0;
+      bla ();
+    } while (i++ < 100);
+}
+
+/* Avoid threading in the following two cases, to prevent creating subloops.  */
+
+void dont_thread_2 (int first)
+{
+  int i = 0;
+
+  do
+    {
+      if (first)
+	foo ();
+      else
+	bar ();
+
+      first = 0;
+      bla ();
+    } while (i++ < 100);
+}
+
+void dont_thread_3 (int nfirst)
+{
+  int i = 0;
+  int first = 0;
+
+  do
+    {
+      if (first)
+	foo ();
+      else
+	bar ();
+
+      first = nfirst;
+      bla ();
+    } while (i++ < 100);
+}
+
+/* Avoid threading in this case, in order to avoid creating loop with
+   multiple entries.  */
+
+void dont_thread_4 (int a, int nfirst)
+{
+  int i = 0;
+  int first;
+
+  if (a)
+    first = 0;
+  else
+    first = 1;
+
+  do
+    {
+      if (first)
+	foo ();
+      else
+	bar ();
+
+      first = nfirst;
+      bla ();
+    } while (i++ < 100);
+}
+
+/* { dg-final { scan-tree-dump-times "Jumps threaded: 1" 1 "vrp1"} } */
+/* { dg-final { scan-tree-dump-times "Jumps threaded: 2" 0 "vrp1"} } */
+/* { dg-final { scan-tree-dump-times "Jumps threaded: 1" 0 "dom1"} } */
+/* { dg-final { scan-tree-dump-times "Jumps threaded: 2" 1 "dom1"} } */
+/* { dg-final { cleanup-tree-dump "dom1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-1.c
new file mode 100644
index 000000000..d0263e3a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-1.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1" } */
+
+int
+foo (int a, int b, int c)
+{
+  int *p;
+  if (c)
+    p = &a;
+  else
+    p = &b;
+
+  *p = 3;
+  *p = 4;
+  return *p;
+}
+
+
+/* We should eliminate both assignments to *p.  */
+/* { dg-final { scan-tree-dump-times " = 3" 0 "dse1"} } */
+/* { dg-final { scan-tree-dump-times " = 4" 0 "dse1"} } */
+
+/* The return *p should be turned into return 4.  */
+/* { dg-final { scan-tree-dump-times " return 4" 1 "dse1"} } */
+
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c
new file mode 100644
index 000000000..bce2c315a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c
@@ -0,0 +1,1523 @@
+/* { dg-do compile } */
+/* { dg-options "-O -w -fdump-tree-dse-vops" } */
+
+__extension__ typedef __SIZE_TYPE__ size_t;
+typedef struct _IO_FILE FILE;
+typedef struct
+{
+} __mbstate_t;
+typedef struct
+{
+} _G_fpos_t;
+typedef struct
+{
+};
+typedef int (*__gconv_trans_fct) (struct __gconv_step *,
+      size_t *);
+typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
+     size_t *);
+struct __gconv_trans_data
+{
+};
+struct __gconv_step_data
+{
+};
+typedef struct __gconv_info
+{
+} *__gconv_t;
+typedef union
+{
+  struct
+  {
+  } __combined;
+} _G_iconv_t;
+typedef __builtin_va_list __gnuc_va_list;
+enum __codecvt_result
+{
+  __codecvt_noconv
+};
+struct _IO_FILE {
+};
+vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
+{
+}
+putchar (int __c)
+{
+}
+fputc_unlocked (int __c, FILE *__stream)
+{
+}
+putc_unlocked (int __c, FILE *__stream)
+{
+}
+__attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
+{
+}
+extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
+     __gnuc_va_list __ap);
+gets (char *__str)
+{
+}
+extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
+     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+{
+}
+typedef void *LPVOID;
+typedef int BOOL, *PBOOL, *LPBOOL;
+typedef unsigned char BYTE, *PBYTE, *LPBYTE;
+typedef unsigned short WORD, *PWORD, *LPWORD;
+typedef unsigned int DWORD, *PDWORD, *LPDWORD;
+typedef struct _GUID
+{
+} GUID;
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+};
+extern char *__strtok_r (char *__restrict __s,
+    __const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
+__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
+       int __reject3)
+{
+}
+extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
+        int __accept2, int __accept3);
+extern __inline size_t
+__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
+{
+}
+extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
+         int __accept2);
+extern __inline char *
+__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
+{
+}
+extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
+       int __accept3)
+{
+}
+__strtok_r_1c (char *__s, char __sep, char **__nextp)
+{
+    {
+   {
+   }
+    }
+}
+__strsep_1c (char **__s, char __reject)
+{
+}
+__strsep_2c (char **__s, char __reject1, char __reject2)
+{
+    {
+ {
+ }
+    }
+}
+extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
+       char __reject3);
+extern __inline char *
+__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
+{
+    {
+ {
+     {
+     }
+ }
+    }
+}
+__attribute__ ((__nothrow__)) __memcpy_ichk (void *__restrict __dest, __const void *__restrict __src, size_t __len)
+{
+}
+__attribute__ ((__nothrow__)) __memmove_ichk (void *__dest, __const void *__src, size_t __len)
+{
+}
+__attribute__ ((__nothrow__)) __strncpy_ichk (char *__restrict __dest, __const char *__restrict __src, size_t __len)
+{
+}
+__attribute__ ((__nothrow__)) stpncpy (char *__dest, __const char *__src, size_t __n)
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
+      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
+    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
+}
+__attribute__ ((__nothrow__)) __strncat_ichk (char *__restrict __dest, __const char *__restrict __src, size_t __len)
+{
+}
+typedef void *PVOID;
+typedef char CHAR, *PCHAR;
+typedef int LONG, *PLONG;
+typedef unsigned short WCHAR, *PWCHAR;
+typedef CHAR *PSTR, *LPSTR, *NPSTR;
+typedef const CHAR *PCSTR, *LPCSTR;
+typedef WCHAR *PWSTR, *LPWSTR, *NWPSTR;
+typedef LONG HRESULT;
+typedef struct _MEMORY_BASIC_INFORMATION
+{
+} SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;
+typedef enum _HEAP_INFORMATION_CLASS {
+    HeapCompatibilityInformation,
+} HEAP_INFORMATION_CLASS;
+typedef struct _FLOATING_SAVE_AREA
+{
+} CONTEXT86;
+typedef struct _LDT_ENTRY {
+    union {
+        struct {
+        } Bits;
+    } HighWord;
+} LDT_ENTRY, *PLDT_ENTRY;
+typedef struct _EXCEPTION_RECORD
+{
+} EXCEPTION_RECORD, *PEXCEPTION_RECORD;
+typedef struct _EXCEPTION_POINTERS
+{
+} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
+typedef struct _NT_TIB
+{
+ union {
+ } ;
+} NT_TIB, *PNT_TIB;
+extern inline struct _TEB * __attribute__((__stdcall__)) NtCurrentTeb(void)
+{
+} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
+typedef struct _IMAGE_SYMBOL {
+    union {
+        struct {
+        } FcnAry;
+    } Section;
+} IMAGE_AUX_SYMBOL;
+typedef struct _IMAGE_EXPORT_DIRECTORY {
+ union {
+ } u1;
+} IMAGE_BOUND_FORWARDER_REF, *PIMAGE_BOUND_FORWARDER_REF;
+typedef struct _IMAGE_BASE_RELOCATION
+{
+} IMAGE_BASE_RELOCATION,*PIMAGE_BASE_RELOCATION;
+typedef struct _IMAGE_RELOCATION
+{
+    union {
+    } ;
+} IMAGE_RELOCATION, *PIMAGE_RELOCATION;
+typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER
+{
+} IMAGE_RESOURCE_DIRECTORY,*PIMAGE_RESOURCE_DIRECTORY;
+typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
+ union {
+  struct {
+  } ;
+                struct {
+  } ;
+ } ;
+} IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;
+typedef enum ReplacesCorHdrNumericDefines
+{
+    MAX_PACKAGE_NAME = 1024,
+} ReplacesCorHdrNumericDefines;
+typedef struct IMAGE_COR20_HEADER
+{
+} MESSAGE_RESOURCE_DATA,*PMESSAGE_RESOURCE_DATA;
+typedef PVOID PSECURITY_DESCRIPTOR;
+typedef enum _TOKEN_INFORMATION_CLASS {
+  TokenUser = 1,
+} TOKEN_INFORMATION_CLASS;
+typedef struct _GENERIC_MAPPING {
+} ACL, *PACL;
+typedef struct _ACL_SIZE_INFORMATION
+{
+} ACL_SIZE_INFORMATION, *PACL_SIZE_INFORMATION;
+typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
+typedef struct {
+} SID_AND_ATTRIBUTES;
+typedef enum {
+    WinBuiltinTerminalServerLicenseServersSid = 60
+} WELL_KNOWN_SID_TYPE;
+typedef struct _TOKEN_USER {
+} TOKEN_GROUPS, *PTOKEN_GROUPS;
+typedef union _LARGE_INTEGER {
+    struct {
+    };
+} LARGE_INTEGER, *PLARGE_INTEGER;
+typedef union _ULARGE_INTEGER {
+    struct {
+    };
+} LUID, *PLUID;
+typedef struct _LUID_AND_ATTRIBUTES {
+} LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
+typedef enum tagTOKEN_TYPE {
+  TokenPrimary = 1,
+} SECURITY_IMPERSONATION_LEVEL, *PSECURITY_IMPERSONATION_LEVEL;
+typedef struct _SECURITY_QUALITY_OF_SERVICE {
+} QUOTA_LIMITS_EX, *PQUOTA_LIMITS_EX;
+typedef enum _LATENCY_TIME {
+        VerifyProcessorPowerPolicyDc,
+} POWER_INFORMATION_LEVEL;
+typedef struct _ADMINISTRATOR_POWER_POLICY {
+} RTL_CRITICAL_SECTION_DEBUG, *PRTL_CRITICAL_SECTION_DEBUG, RTL_RESOURCE_DEBUG, *PRTL_RESOURCE_DEBUG;
+typedef struct _RTL_CRITICAL_SECTION {
+} RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
+typedef struct _IO_COUNTERS {
+} OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
+typedef struct {
+} OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
+typedef struct {
+} OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
+typedef struct {
+} OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
+typedef struct tagSIZE
+{
+} POINT, *PPOINT, *LPPOINT;
+typedef struct _POINTL
+{
+} FILETIME, *PFILETIME, *LPFILETIME;
+typedef struct tagRECT
+{
+  } ldiv_t;
+extern double strtod (__const char *__restrict __nptr,
+        char **__restrict __endptr)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern long int strtol (__const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern long int __strtol_internal (__const char *__restrict __nptr,
+       int __base, int __group)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
+          int __base, int __group)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern __inline double
+__attribute__ ((__nothrow__)) strtod (__const char *__restrict __nptr, char **__restrict __endptr)
+{
+}
+extern __inline long int
+__attribute__ ((__nothrow__)) strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
+{
+}
+__attribute__ ((__nothrow__)) strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
+{
+}
+__attribute__ ((__nothrow__)) atoi (__const char *__nptr)
+{
+}
+typedef int int32_t __attribute__ ((__mode__ (__SI__)));
+typedef struct
+  {
+  };
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
+struct drand48_data
+  {
+  };
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *qfcvt (long double __value, int __ndigit,
+        size_t __resolvedlen) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
+__attribute__ ((__nothrow__)) realpath (__const char *__restrict __name, char *__restrict __resolved)
+{
+}
+__attribute__ ((__nothrow__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
+{
+}
+typedef struct _EXCEPTION_DEBUG_INFO {
+} EXCEPTION_DEBUG_INFO;
+typedef struct _CREATE_THREAD_DEBUG_INFO {
+} CREATE_THREAD_DEBUG_INFO;
+typedef struct _CREATE_PROCESS_DEBUG_INFO {
+} CREATE_PROCESS_DEBUG_INFO;
+typedef struct _EXIT_THREAD_DEBUG_INFO {
+} LOAD_DLL_DEBUG_INFO;
+typedef struct _UNLOAD_DLL_DEBUG_INFO {
+} RIP_INFO;
+typedef struct _DEBUG_EVENT {
+    union {
+    } u;
+} DEBUG_EVENT, *LPDEBUG_EVENT;
+typedef struct _OFSTRUCT
+{
+} WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
+typedef struct _WIN32_FIND_DATAW
+{
+} WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW;
+typedef enum _FINDEX_SEARCH_OPS
+{
+ FindExSearchNameMatch,
+} FINDEX_SEARCH_OPS;
+typedef struct _PROCESS_HEAP_ENTRY
+{
+    union {
+        struct {
+        } Block;
+        struct {
+        } Region;
+    } ;
+} PROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY;
+typedef struct tagMEMORYSTATUS
+{
+} MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
+typedef struct _SYSTEMTIME{
+        WORD wYear;
+} SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
+typedef struct _OVERLAPPED {
+        union {
+            struct {
+            } ;
+        } ;
+} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
+typedef struct _TIME_ZONE_INFORMATION{
+} TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
+typedef struct _BY_HANDLE_FILE_INFORMATION
+{
+} ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, *PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
+typedef struct tagACTCTX_SECTION_KEYED_DATA {
+} COMMTIMEOUTS,*LPCOMMTIMEOUTS;
+typedef enum _COMPUTER_NAME_FORMAT
+{
+ ComputerNameNetBIOS,
+} COMPUTER_NAME_FORMAT;
+typedef struct tagHW_PROFILE_INFOA {
+} HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA;
+typedef struct tagHW_PROFILE_INFOW {
+} HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW;
+BOOL __attribute__((__stdcall__)) SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,SECURITY_DESCRIPTOR_CONTROL,
+                                                SECURITY_DESCRIPTOR_CONTROL);
+typedef struct tagSYSLEVEL
+{
+} SYSLEVEL;
+static inline PVOID __attribute__((__stdcall__)) InterlockedCompareExchangePointer( PVOID volatile *dest, PVOID xchg, PVOID compare )
+{
+}
+static inline PVOID __attribute__((__stdcall__)) InterlockedExchangePointer( PVOID volatile *dest, PVOID val )
+{
+}
+typedef unsigned long HCRYPTPROV;
+typedef unsigned long HCRYPTKEY;
+typedef void *HCERTSTOREPROV;
+typedef struct _PROV_ENUMALGS {
+} PROV_ENUMALGS;
+typedef struct _HMAC_INFO {
+} HMAC_INFO, *PHMAC_INFO;
+typedef struct _CRYPTOAPI_BLOB {
+  DWORD cbData;
+  BYTE* pbData;
+} CRYPT_INTEGER_BLOB, *PCRYPT_INTEGER_BLOB,
+  CRYPT_OBJID_BLOB, *PCRYPT_OBJID_BLOB,
+  CERT_NAME_BLOB, *PCERT_NAME_BLOB,
+  CERT_RDN_VALUE_BLOB, *PCERT_RDN_VALUE_BLOB,
+  CRYPT_DER_BLOB, *PCRYPT_DER_BLOB,
+  CRYPT_ATTR_BLOB, *PCRYPT_ATTR_BLOB;
+typedef struct _CRYPTPROTECT_PROMPTSTRUCT{
+} CRYPTPROTECT_PROMPTSTRUCT, *PCRYPTPROTECT_PROMPTSTRUCT;
+typedef struct _CRYPT_ALGORITHM_IDENTIFIER {
+  LPSTR pszObjId;
+  CRYPT_OBJID_BLOB Parameters;
+} CRYPT_ALGORITHM_IDENTIFIER, *PCRYPT_ALGORITHM_IDENTIFIER;
+typedef struct _CRYPT_ATTRIBUTE_TYPE_VALUE {
+} CRYPT_ATTRIBUTE_TYPE_VALUE, *PCRYPT_ATTRIBUTE_TYPE_VALUE;
+typedef struct _PUBLICKEYSTRUC {
+} BLOBHEADER, PUBLICKEYSTRUC;
+typedef struct _RSAPUBKEY {
+    DWORD magic;
+    DWORD pubexp;
+} RSAPUBKEY;
+typedef struct _CRYPT_BIT_BLOB {
+    DWORD cbData;
+    BYTE *pbData;
+    DWORD cUnusedBits;
+} CRYPT_BIT_BLOB, *PCRYPT_BIT_BLOB;
+typedef struct _CRYPT_KEY_PROV_PARAM {
+} CRYPT_KEY_PROV_PARAM, *PCRYPT_KEY_PROV_PARAM;
+typedef struct _CRYPT_KEY_PROV_INFO {
+    CRYPT_ALGORITHM_IDENTIFIER Algorithm;
+    CRYPT_BIT_BLOB PublicKey;
+} CERT_PUBLIC_KEY_INFO, *PCERT_PUBLIC_KEY_INFO;
+typedef struct _CERT_EXTENSION {
+    LPSTR pszObjId;
+    CRYPT_OBJID_BLOB Value;
+} CERT_EXTENSION, *PCERT_EXTENSION;
+typedef struct _CERT_EXTENSIONS {
+    DWORD cExtension;
+    PCERT_EXTENSION rgExtension;
+} CERT_EXTENSIONS, *PCERT_EXTENSIONS;
+typedef struct _CERT_INFO {
+    CRYPT_INTEGER_BLOB SerialNumber;
+    CERT_NAME_BLOB Subject;
+    CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
+} CERT_INFO, *PCERT_INFO;
+typedef struct _CERT_RDN_ATTR {
+    LPSTR pszObjId;
+    CERT_RDN_VALUE_BLOB Value;
+} CERT_RDN_ATTR, *PCERT_RDN_ATTR;
+typedef struct _CERT_RDN {
+} CERT_RDN, *PCERT_RDN;
+typedef struct _CERT_NAME_INFO {
+    DWORD cRDN;
+} CERT_NAME_INFO, *PCERT_NAME_INFO;
+typedef struct _CERT_NAME_VALUE {
+    DWORD dwValueType;
+    CERT_RDN_VALUE_BLOB Value;
+} CERT_NAME_VALUE, *PCERT_NAME_VALUE;
+typedef struct _CERT_ENCRYPTED_PRIVATE_KEY_INFO {
+    CERT_NAME_BLOB CertIssuer;
+} CERT_AUTHORITY_KEY_ID_INFO, *PCERT_AUTHORITY_KEY_ID_INFO;
+typedef struct _CERT_PRIVATE_KEY_VALIDITY {
+} CERT_OTHER_NAME, *PCERT_OTHER_NAME;
+typedef struct _CERT_ALT_NAME_ENTRY {
+    DWORD dwAltNameChoice;
+    union {
+        LPWSTR pwszURL;
+    } ;
+} CERT_ALT_NAME_ENTRY, *PCERT_ALT_NAME_ENTRY;
+typedef struct _CERT_ALT_NAME_INFO {
+    DWORD cAltEntry;
+    PCERT_ALT_NAME_ENTRY rgAltEntry;
+} CERT_ALT_NAME_INFO, *PCERT_ALT_NAME_INFO;
+typedef struct _CERT_BASIC_CONSTRAINTS_INFO {
+    CERT_NAME_BLOB *rgSubtreesConstraint;
+} CERT_BASIC_CONSTRAINTS_INFO, *PCERT_BASIC_CONSTRAINTS_INFO;
+typedef struct _CERT_BASIC_CONSTRAINTS2_INFO {
+} CERT_BASIC_CONSTRAINTS2_INFO, *PCERT_BASIC_CONSTRAINTS2_INFO;
+typedef struct _CERT_POLICY_QUALIFIER_INFO {
+} CERT_POLICY_QUALIFIER_INFO, *PCERT_POLICY_QUALIFIER_INFO;
+typedef struct _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
+} CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
+ *PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE;
+typedef struct _CERT_POLICY_QUALIFIER_USER_NOTICE {
+    DWORD cValue;
+    PCRYPT_DER_BLOB rgValue;
+} CRYPT_SEQUENCE_OF_ANY, *PCRYPT_SEQUENCE_OF_ANY;
+typedef struct _CERT_AUTHORITY_KEY_ID2_INFO {
+    PCERT_INFO pCertInfo;
+} CERT_CONTEXT, *PCERT_CONTEXT;
+typedef const CERT_CONTEXT *PCCERT_CONTEXT;
+typedef struct _CRL_ENTRY {
+} CRL_ENTRY, *PCRL_ENTRY;
+typedef struct _CRL_INFO {
+    DWORD cCRLEntry;
+    DWORD cExtension;
+} CRL_INFO, *PCRL_INFO;
+typedef struct _CRL_DIST_POINT_NAME {
+    DWORD dwDistPointNameChoice;
+    union {
+    } ;
+} CRL_DIST_POINT_NAME, *PCRL_DIST_POINT_NAME;
+typedef struct _CRL_DIST_POINT {
+    CRL_DIST_POINT_NAME DistPointName;
+    CRYPT_BIT_BLOB ReasonFlags;
+    CERT_ALT_NAME_INFO CRLIssuer;
+} CRL_DIST_POINT, *PCRL_DIST_POINT;
+typedef struct _CRL_DIST_POINTS_INFO {
+    DWORD cDistPoint;
+    PCRL_DIST_POINT rgDistPoint;
+} CRL_DIST_POINTS_INFO, *PCRL_DIST_POINTS_INFO;
+typedef struct _CRL_ISSUING_DIST_POINT {
+    BOOL fOnlyContainsUserCerts;
+} CRL_ISSUING_DIST_POINT, *PCRL_ISSUING_DIST_POINT;
+typedef struct _CERT_GENERAL_SUBTREE {
+} CRYPT_ATTRIBUTE, *PCRYPT_ATTRIBUTE;
+typedef struct _CRYPT_ATTRIBUTES {
+} CRYPT_ATTRIBUTES, *PCRYPT_ATTRIBUTES;
+typedef struct _CERT_REQUEST_INFO {
+    DWORD dwVersion;
+    CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
+    CRYPT_BIT_BLOB Signature;
+} CERT_SIGNED_CONTENT_INFO, *PCERT_SIGNED_CONTENT_INFO;
+typedef struct _CRL_CONTEXT {
+} CRL_CONTEXT, *PCRL_CONTEXT;
+typedef struct _VTableProvStruc {
+} CTL_CONTEXT, *PCTL_CONTEXT;
+typedef struct _CRYPT_TIME_STAMP_REQUEST_INFO {
+} CERT_REVOCATION_STATUS, *PCERT_REVOCATION_STATUS;
+typedef struct _CERT_TRUST_STATUS {
+} CERT_SYSTEM_STORE_RELOCATE_PARA, *PCERT_SYSTEM_STORE_RELOCATE_PARA;
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_ENUM_SYSTEM_STORE_LOCATION)(
+ void *pvArg);
+typedef struct _CRYPT_ENCODE_PARA {
+} CERT_STORE_PROV_INFO, *PCERT_STORE_PROV_INFO;
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_DLL_OPEN_STORE_PROV_FUNC)(
+ DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara);
+typedef struct _CERT_STORE_PROV_FIND_INFO {
+} CERT_STORE_PROV_FIND_INFO, *PCERT_STORE_PROV_FIND_INFO;
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_FIND_CERT)(HCERTSTOREPROV hStoreProv,
+ DWORD dwFlags, void **ppvStoreProvFindInfo, PCCERT_CONTEXT *ppProvCertContext);
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_FREE_FIND_CERT)(
+ DWORD dwFlags, void *pvData, DWORD *pcbData);
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_GET_CTL_PROPERTY)(
+ DWORD dwFlags, void *pvData);
+typedef struct _CERT_CREATE_CONTEXT_PARA {
+} CRYPT_OID_FUNC_ENTRY, *PCRYPT_OID_FUNC_ENTRY;
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CRYPT_ENUM_OID_FUNC)(DWORD dwEncodingType,
+ const DWORD rgcbValueData[], void *pvArg);
+typedef struct _CRYPT_OID_INFO {
+    union {
+    } ;
+} CRYPT_OID_INFO, *PCRYPT_OID_INFO;
+typedef const CRYPT_OID_INFO CCRYPT_OID_INFO, *PCCRYPT_OID_INFO;
+typedef BOOL (__attribute__((__stdcall__)) *PFN_CRYPT_ENUM_OID_INFO)(PCCRYPT_OID_INFO pInfo,
+ void *pvArg);
+typedef struct _CRYPT_SIGN_MESSAGE_PARA {
+} CRYPT_HASH_MESSAGE_PARA, *PCRYPT_HASH_MESSAGE_PARA;
+typedef struct _CRYPT_KEY_SIGN_MESSAGE_PARA {
+} CRYPT_URL_INFO, *PCRYPT_URL_INFO;
+typedef void (__attribute__((__stdcall__)) *PFN_CRYPT_ASYNC_PARAM_FREE_FUNC)(LPSTR pszParamOid,
+ LPVOID pvParam);
+typedef struct _CRYPT_CREDENTIALS {
+} CRYPT_CREDENTIALS, *PCRYPT_CREDENTIALS;
+typedef struct _CRYPT_PASSWORD_CREDENTIALSA {
+} CRYPT_PASSWORD_CREDENTIALSW, *PCRYPT_PASSWORD_CREDENTIALSW;
+typedef struct _CRYPT_RETRIEVE_AUX_INFO {
+} CRYPT_RETRIEVE_AUX_INFO, *PCRYPT_RETRIEVE_AUX_INFO;
+typedef struct _CERT_CHAIN_ENGINE_CONFIG
+{
+} CERT_CHAIN_ENGINE_CONFIG, *PCERT_CHAIN_ENGINE_CONFIG;
+BOOL __attribute__((__stdcall__)) CryptExportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
+ DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
+ void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
+BOOL __attribute__((__stdcall__)) CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
+ PCRYPT_RETRIEVE_AUX_INFO pAuxInfo);
+struct encodedInt
+{
+    int val;
+    const BYTE *encoded;
+};
+static const struct encodedInt ints[] = {
+};
+struct encodedBigInt
+{
+    const BYTE *val;
+    const BYTE *encoded;
+};
+static const struct encodedBigInt bigInts[] = {
+};
+static const struct encodedBigInt bigUInts[] = {
+};
+static void test_encodeInt(DWORD dwEncoding)
+{
+    DWORD bufSize = 0;
+    int i;
+    BOOL ret;
+    CRYPT_INTEGER_BLOB blob;
+    BYTE *buf = ((void *)0);
+    ret = CryptEncodeObjectEx(0, ((LPCSTR)27), &ints[0].val, 0, ((void *)0), ((void *)0),
+     "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
+    {
+        ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)27), &ints[i].val,
+         0x08000, ((void *)0), &buf, &bufSize);
+        {
+            (winetest_set_location("encode.c", 119), 0) ? 0 : winetest_ok(buf[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
+             buf[1], ints[i].encoded[1]);
+        }
+        ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)28), &blob,
+         0, ((void *)0), ((void *)0), &bufSize);
+        {
+        }
+        ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)38), &blob,
+         0x08000, ((void *)0), &buf, &bufSize);
+        {
+            (winetest_set_location("encode.c", 187), 0) ? 0 : winetest_ok(buf[1] == bigUInts[i].encoded[1], "Got length %d, expected %d\n",
+             buf[1], bigUInts[i].encoded[1]);
+            (winetest_set_location("encode.c", 189), 0) ? 0 : winetest_ok(!memcmp(buf + 1, bigUInts[i].encoded + 1,
+             bigUInts[i].encoded[1] + 1),
+             "Encoded value didn't match expected\n");
+        }
+    }
+}
+static void test_decodeInt(DWORD dwEncoding)
+{
+    static const BYTE longForm[] = { 2, 0x81, 0x01, 0x01 };
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    int i;
+    BOOL ret;
+    ret = CryptDecodeObjectEx(3, ((LPCSTR)27), (BYTE *)&ints[0].encoded,
+     ints[0].encoded[1] + 2, 0, ((void *)0), ((void *)0), &bufSize);
+    (winetest_set_location("encode.c", 225), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x80093104L),
+     "Expected CRYPT_E_ASN1_BADTAG, got %d\n", GetLastError());
+    {
+        {
+            (winetest_set_location("encode.c", 249), 0) ? 0 : winetest_ok(!memcmp(buf, &ints[i].val, bufSize), "Expected %d, got %d\n",
+             ints[i].val, *(int *)buf);
+        }
+    }
+    {
+        ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)28),
+         &bufSize);
+        {
+            CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
+            (winetest_set_location("encode.c", 296), 0) ? 0 : winetest_ok(blob->cbData == strlen((const char*)bigUInts[i].val),
+             "Unexpected value\n");
+        }
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)28), longForm,
+     sizeof(longForm), 0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
+    {
+    }
+}
+static const struct encodedInt enums[] = {
+};
+static const LPCSTR enumeratedTypes[] = { ((LPCSTR)29),
+ "2.5.29.21" };
+static void test_encodeEnumerated(DWORD dwEncoding)
+{
+    DWORD i, j;
+    {
+        {
+            BOOL ret;
+            DWORD bufSize = 0;
+            ret = CryptEncodeObjectEx(dwEncoding, enumeratedTypes[i],
+             &bufSize);
+            {
+            }
+        }
+    }
+}
+static void test_decodeEnumerated(DWORD dwEncoding)
+{
+    DWORD i, j;
+    {
+        {
+            BOOL ret;
+            DWORD bufSize = sizeof(int);
+            int val;
+            ret = CryptDecodeObjectEx(dwEncoding, enumeratedTypes[i],
+             (BYTE *)&val, &bufSize);
+            (winetest_set_location("encode.c", 403), 0) ? 0 : winetest_ok(val == enums[j].val, "Unexpected value %d, expected %d\n",
+             val, enums[j].val);
+        }
+    }
+}
+struct encodedFiletime
+{
+    SYSTEMTIME sysTime;
+    const BYTE *encodedTime;
+};
+static void testTimeEncoding(DWORD dwEncoding, LPCSTR structType,
+ const struct encodedFiletime *time)
+{
+}
+static void testTimeDecoding(DWORD dwEncoding, LPCSTR structType,
+ const struct encodedFiletime *time)
+{
+    BOOL ret;
+    if (structType == ((LPCSTR)30) ||
+     (time->sysTime.wYear >= 1950 && time->sysTime.wYear <= 2050))
+    {
+    }
+        (winetest_set_location("encode.c", 476), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x8009310BL),
+         "Expected CRYPT_E_ASN1_BADTAG, got 0x%08x\n", GetLastError());
+}
+static const BYTE bin22[] = {
+    0x18,0x0f,'2','1','4','5','0','6','0','6','1','6','1','0','0','0','Z'};
+static const struct encodedFiletime times[] = {
+};
+static void test_encodeFiletime(DWORD dwEncoding)
+{
+    {
+    }
+}
+static const BYTE bin23[] = {
+    0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','0','0','0','Z'};
+static const BYTE bin24[] = {
+    0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','9','9','9','Z'};
+static const BYTE bin26[] = {
+    0x17,0x0b,'4','5','0','6','0','6','1','6','1','0','Z'};
+static const BYTE bin33[] = {
+    0x17,0x0f,'4','5','0','6','0','6','1','6','1','0','-','0','1','0','0'};
+static const BYTE bin35[] = {
+    0x17,0x08, '4','5','0','6','0','6','1','6'};
+static const BYTE bin38[] = {
+    0x18,0x08, '2','1','4','5','0','6','0','6'};
+static void test_decodeFiletime(DWORD dwEncoding)
+{
+    static const struct encodedFiletime otherTimes[] = {
+    };
+    static const unsigned char *bogusTimes[] = {
+    };
+    {
+    }
+}
+static const char commonName[] = "Juan Lang";
+static const char surName[] = "Lang";
+static const BYTE emptySequence[] = { 0x30, 0 };
+static const BYTE emptyRDNs[] = { 0x30, 0x02, 0x31, 0 };
+static const BYTE twoRDNs[] = {
+    0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0};
+static const BYTE encodedTwoRDNs[] = {
+};
+static const BYTE us[] = { 0x55, 0x53 };
+static const BYTE minnesota[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+ 0x6f, 0x6c, 0x69, 0x73 };
+static const BYTE codeweavers[] = { 0x43, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x61,
+ 0x76, 0x65, 0x72, 0x73 };
+static const BYTE wine[] = { 0x57, 0x69, 0x6e, 0x65, 0x20, 0x44, 0x65, 0x76,
+ 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74 };
+static const BYTE aric[] = { 0x61, 0x72, 0x69, 0x63, 0x40, 0x63, 0x6f, 0x64,
+ 0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63, 0x6f, 0x6d };
+static CHAR oid_us[] = "2.5.4.6",
+            oid_aric[] = "1.2.840.113549.1.9.1";
+static CERT_RDN_ATTR rdnAttrs[] = { { oid_us, 4, { sizeof(us), (LPBYTE)us } },
+                                           { oid_aric, 7, { sizeof(aric), (LPBYTE)aric } } };
+static const BYTE encodedRDNAttrs[] = {
+};
+static void test_encodeName(DWORD dwEncoding)
+{
+    CERT_NAME_INFO info;
+    static CHAR oid_common_name[] = "2.5.4.3",
+                oid_sur_name[] = "2.5.4.4";
+    BOOL ret;
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), ((void *)0),
+     "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), &info,
+     "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
+    {
+    }
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), &info,
+     "Expected E_INVALIDARG, got %08x\n", GetLastError());
+    {
+    }
+}
+static WCHAR commonNameW[] = { 'J','u','a','n',' ','L','a','n','g',0 };
+static const BYTE twoRDNsNoNull[] = {
+ 0x20,0x4c,0x61,0x6e,0x67 };
+static const BYTE anyType[] = {
+ 0x61,0x4c,0x67,0x6e };
+static void test_encodeUnicodeName(DWORD dwEncoding)
+{
+    BOOL ret;
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)20), ((void *)0),
+     "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
+    {
+    }
+}
+static void compareNameValues(const CERT_NAME_VALUE *expected,
+ const CERT_NAME_VALUE *got)
+{
+    (winetest_set_location("encode.c", 913), 0) ? 0 : winetest_ok(got->dwValueType == expected->dwValueType,
+     expected->dwValueType, got->Value.cbData, expected->Value.cbData);
+        (winetest_set_location("encode.c", 920), 0) ? 0 : winetest_ok(!memcmp(got->Value.pbData, expected->Value.pbData,
+         (((got->Value.cbData) < (expected->Value.cbData)) ? (got->Value.cbData) : (expected->Value.cbData))),
+         "String type %d: unexpected value\n", expected->dwValueType);
+}
+static void compareRDNAttrs(const CERT_RDN_ATTR *expected,
+ const CERT_RDN_ATTR *got)
+{
+    {
+        {
+            (winetest_set_location("encode.c", 934), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (got->pszObjId) && __builtin_constant_p (expected->pszObjId) && (__s1_len = strlen (got->pszObjId), __s2_len = strlen (expected->pszObjId), (!((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__builtin_constant_p (got->pszObjId) && ((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) && (__s1_len = strlen (got->pszObjId), __s1_len < 4) ? (__builtin_constant_p (expected->pszObjId) && ((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (expected->pszObjId); register int __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (expected->pszObjId) && ((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) && (__s2_len = strlen (expected->pszObjId), __s2_len < 4) ? (__builtin_constant_p (got->pszObjId) && ((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (got->pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[3]); } } __result; }))) : __builtin_strcmp (got->pszObjId, expected->pszObjId)))); }),
+             expected->pszObjId);
+        }
+    }
+}
+static void compareRDNs(const CERT_RDN *expected, const CERT_RDN *got)
+{
+    {
+    }
+}
+static void compareNames(const CERT_NAME_INFO *expected,
+ const CERT_NAME_INFO *got)
+{
+    (winetest_set_location("encode.c", 959), 0) ? 0 : winetest_ok(got->cRDN == expected->cRDN, "Expected %d RDNs, got %d\n",
+     expected->cRDN, got->cRDN);
+    {
+    }
+}
+static void test_decodeName(DWORD dwEncoding)
+{
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    BOOL ret;
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)7), emptySequence,
+     (BYTE *)&buf, &bufSize);
+    {
+        static CHAR oid_sur_name[] = "2.5.4.4",
+                    oid_common_name[] = "2.5.4.3";
+        CERT_RDN_ATTR attrs[] = {
+         { oid_sur_name, 4, { sizeof(surName),
+          (BYTE *)commonName } },
+        };
+    }
+    {
+    }
+}
+static void test_decodeUnicodeName(DWORD dwEncoding)
+{
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    BOOL ret;
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), emptySequence,
+     (BYTE *)&buf, &bufSize);
+    {
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), emptyRDNs,
+     (BYTE *)&buf, &bufSize);
+    {
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), twoRDNsNoNull,
+     (BYTE *)&buf, &bufSize);
+    {
+        static CHAR oid_sur_name[] = "2.5.4.4",
+                    oid_common_name[] = "2.5.4.3";
+        CERT_RDN_ATTR attrs[] = {
+         { oid_sur_name, 4,
+         { lstrlenW(commonNameW) * sizeof(WCHAR), (BYTE *)commonNameW } },
+        };
+    }
+}
+struct EncodedNameValue
+{
+    CERT_NAME_VALUE value;
+};
+static const char bogusPrintable[] = "~";
+static const BYTE bin42[] = { 0x16,0x02,0x80,0x00 };
+static const BYTE bin43[] = { 0x13,0x02,0x7e,0x00 };
+static BYTE octetCommonNameValue[] = {
+ 0x12,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
+static BYTE printableCommonNameValue[] = {
+ 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
+static BYTE t61CommonNameValue[] = {
+ 0x14,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
+static BYTE graphicCommonNameValue[] = {
+ 0x61,0x00,0x6e,0x00,0x67,0x00,0x00 };
+static BYTE utf8CommonNameValue[] = {
+ 0x0c,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
+static struct EncodedNameValue nameValues[] = {
+ { { 5, { sizeof(commonName), (BYTE *)commonName } },
+     sizeof(bin42) },
+ { { 4, { sizeof(bogusPrintable),
+     (BYTE *)bogusPrintable } }, bin43, sizeof(bin43) },
+};
+static void test_encodeNameValue(DWORD dwEncoding)
+{
+    DWORD size = 0, i;
+    BOOL ret;
+    CERT_NAME_VALUE value = { 0, { 0, ((void *)0) } };
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)6), &value,
+     "Expected CRYPT_E_ASN1_CHOICE, got %08x\n", GetLastError());
+    {
+        (winetest_set_location("encode.c", 1209), 0) ? 0 : winetest_ok(size == sizeof(printableCommonNameValue), "Unexpected size %d\n",
+         "Unexpected encoding\n");
+        ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)6),
+         nameValues[i].value.dwValueType, GetLastError());
+        {
+        }
+    }
+}
+static void test_decodeNameValue(DWORD dwEncoding)
+{
+    int i;
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    BOOL ret;
+    {
+        ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)6),
+         (BYTE *)&buf, &bufSize);
+        {
+            compareNameValues(&nameValues[i].value,
+             (const CERT_NAME_VALUE *)buf);
+        }
+    }
+}
+static const BYTE emptyURL[] = { 0x30, 0x02, 0x86, 0x00 };
+static const WCHAR url[] = { 'h','t','t','p',':','/','/','w','i','n','e',
+ 0x6f, 0x72, 0x67 };
+static const BYTE encodedIPAddr[] = { 0x30, 0x06, 0x87, 0x04, 0x7f, 0x00, 0x00,
+ 0x01 };
+static void test_encodeAltName(DWORD dwEncoding)
+{
+    CERT_ALT_NAME_INFO info = { 0 };
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    BOOL ret;
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)12), &info,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+    {
+    }
+}
+static void test_decodeAltName(DWORD dwEncoding)
+{
+    BOOL ret;
+    DWORD bufSize = 0;
+    CERT_ALT_NAME_INFO *info;
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)12),
+     &bufSize);
+    {
+        (winetest_set_location("encode.c", 1392), 0) ? 0 : winetest_ok(info->cAltEntry == 0, "Expected 0 entries, got %d\n",
+         info->cAltEntry);
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)12), emptyURL,
+     &bufSize);
+    {
+    }
+}
+struct encodedBits
+{
+    const BYTE *encoded;
+    DWORD cbDecoded;
+};
+static const struct encodedBits bits[] = {
+};
+static void test_encodeBits(DWORD dwEncoding)
+{
+    DWORD i;
+    {
+        DWORD bufSize = 0;
+        {
+            (winetest_set_location("encode.c", 1802), 0) ? 0 : winetest_ok(bufSize == bits[i].encoded[1] + 2,
+             bits[i].encoded[1] + 2);
+        }
+    }
+}
+static void test_decodeBits(DWORD dwEncoding)
+{
+    DWORD i;
+    {
+        {
+            CRYPT_BIT_BLOB *blob;
+            (winetest_set_location("encode.c", 1835), 0) ? 0 : winetest_ok(blob->cbData == bits[i].cbDecoded,
+                 "Unexpected value\n");
+        }
+    }
+    {
+    }
+}
+struct Constraints2
+{
+    CERT_BASIC_CONSTRAINTS2_INFO info;
+};
+static const struct Constraints2 constraints2[] = {
+};
+static const BYTE encodedDomainName[] = { 0x30, 0x2b, 0x31, 0x29, 0x30, 0x11,
+ 0x16, 0x06, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71 };
+static void test_encodeBasicConstraints(DWORD dwEncoding)
+{
+    CERT_NAME_BLOB nameBlob = { sizeof(encodedDomainName),
+     (LPBYTE)encodedDomainName };
+    {
+        {
+        }
+    }
+    {
+    }
+}
+static const unsigned char encodedCommonName[] = {
+    0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0};
+static void test_decodeBasicConstraints(DWORD dwEncoding)
+{
+    static const BYTE inverted[] = { 0x30, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
+     0xff };
+    DWORD i;
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    {
+        ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)15),
+         0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
+        {
+            CERT_BASIC_CONSTRAINTS2_INFO *info =
+            (winetest_set_location("encode.c", 1984), 0) ? 0 : winetest_ok(!memcmp(info, &constraints2[i].info, sizeof(*info)),
+             "Unexpected value for item %d\n", i);
+        }
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)15),
+     (BYTE *)&buf, &bufSize);
+    {
+        CERT_BASIC_CONSTRAINTS_INFO *info = (CERT_BASIC_CONSTRAINTS_INFO *)buf;
+        {
+            (winetest_set_location("encode.c", 2043), 0) ? 0 : winetest_ok(info->rgSubtreesConstraint[0].cbData ==
+             info->rgSubtreesConstraint[0].cbData);
+            (winetest_set_location("encode.c", 2046), 0) ? 0 : winetest_ok(!memcmp(info->rgSubtreesConstraint[0].pbData, encodedDomainName,
+             sizeof(encodedDomainName)), "Unexpected value\n");
+        }
+    }
+}
+static const BYTE modulus1[] = { 0,0,0,1,1,1,1,1 };
+struct EncodedRSAPubKey
+{
+    const BYTE *modulus;
+    size_t decodedModulusLen;
+};
+struct EncodedRSAPubKey rsaPubKeys[] = {
+};
+static void test_encodeRsaPublicKey(DWORD dwEncoding)
+{
+    BYTE toEncode[sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) + sizeof(modulus1)];
+    RSAPUBKEY *rsaPubKey = (RSAPUBKEY *)(toEncode + sizeof(BLOBHEADER));
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0, i;
+    ret = CryptDecodeObjectEx(dwEncoding, "1.2.840.113549.1.1.1",
+     "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
+    {
+        {
+            (winetest_set_location("encode.c", 2210), 0) ? 0 : winetest_ok(bufSize >= sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
+             "Wrong size %d\n", bufSize);
+            (winetest_set_location("encode.c", 2223), 0) ? 0 : winetest_ok(rsaPubKey->magic == 0x31415352,
+             rsaPubKey->pubexp);
+            (winetest_set_location("encode.c", 2229), 0) ? 0 : winetest_ok(!memcmp(buf + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY),
+             rsaPubKeys[i].modulus, rsaPubKeys[i].decodedModulusLen),
+             "Unexpected modulus\n");
+        }
+    }
+}
+static const BYTE intSequence[] = { 0x30, 0x1b, 0x02, 0x01, 0x01, 0x02, 0x01,
+ 0x02, 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
+static const BYTE mixedSequence[] = { 0x30, 0x27, 0x17, 0x0d, 0x30, 0x35, 0x30,
+ 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
+static void test_encodeSequenceOfAny(DWORD dwEncoding)
+{
+    BYTE *buf = ((void *)0);
+    {
+    }
+    {
+        (winetest_set_location("encode.c", 2284), 0) ? 0 : winetest_ok(!memcmp(buf, mixedSequence, mixedSequence[1] + 2),
+         "Unexpected value\n");
+    }
+}
+static void test_decodeSequenceOfAny(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    {
+        {
+        }
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)34), mixedSequence,
+     &bufSize);
+    {
+        CRYPT_SEQUENCE_OF_ANY *seq = (CRYPT_SEQUENCE_OF_ANY *)buf;
+        (winetest_set_location("encode.c", 2324), 0) ? 0 : winetest_ok(seq->cValue == sizeof(ints) / sizeof(ints[0]),
+         seq->rgValue[0].cbData);
+        (winetest_set_location("encode.c", 2330), 0) ? 0 : winetest_ok(!memcmp(seq->rgValue[0].pbData, times[0].encodedTime,
+         times[0].encodedTime[1] + 2), "Unexpected value\n");
+    }
+}
+struct encodedExtensions
+{
+    CERT_EXTENSIONS exts;
+};
+static BYTE noncrit_ext_data[] = { 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
+static CHAR oid_basic_constraints2[] = "2.5.29.19";
+static CERT_EXTENSION nonCriticalExt =
+ { oid_basic_constraints2, 0, { 8, noncrit_ext_data } };
+static const struct encodedExtensions exts[] = {
+};
+static void test_encodeExtensions(DWORD dwEncoding)
+{
+    DWORD i;
+    {
+        {
+        }
+    }
+    {
+        BOOL ret;
+        BYTE *buf = ((void *)0);
+        DWORD bufSize = 0;
+        ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)5),
+         ((void *)0), (BYTE *)&buf, &bufSize);
+        {
+            CERT_EXTENSIONS *ext = (CERT_EXTENSIONS *)buf;
+            DWORD j;
+            (winetest_set_location("encode.c", 2405), 0) ? 0 : winetest_ok(ext->cExtension == exts[i].exts.cExtension,
+             ext->cExtension);
+            {
+                (winetest_set_location("encode.c", 2410), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ext->rgExtension[j].pszObjId) && __builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && (__s1_len = strlen (ext->rgExtension[j].pszObjId), __s2_len = strlen (exts[i].exts.rgExtension[j].pszObjId), (!((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__builtin_constant_p (ext->rgExtension[j].pszObjId) && ((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) && (__s1_len = strlen (ext->rgExtension[j].pszObjId), __s1_len < 4) ? (__builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && ((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId); register int __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && ((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) && (__s2_len = strlen (exts[i].exts.rgExtension[j].pszObjId), __s2_len < 4) ? (__builtin_constant_p (ext->rgExtension[j].pszObjId) && ((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[3]); } } __result; }))) : __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId)))); }),
+                 ext->rgExtension[j].pszObjId);
+                (winetest_set_location("encode.c", 2415), 0) ? 0 : winetest_ok(!memcmp(ext->rgExtension[j].Value.pbData,
+                 exts[i].exts.rgExtension[j].Value.cbData),
+                 "Unexpected value\n");
+            }
+        }
+    }
+}
+struct encodedPublicKey
+{
+    const BYTE *encoded;
+    const BYTE *encodedNoNull;
+};
+static const BYTE aKey[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
+ 0xe, 0xf };
+static const BYTE params[] = { 0x02, 0x01, 0x01 };
+static const unsigned char bin66[] = {
+    0x30,0x0f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,0x01,0x00};
+static const unsigned char bin67[] = {
+    0x30,0x0d,0x30,0x08,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x01,0x00};
+static const unsigned char bin69[] = {
+    0x0f};
+static unsigned char bin72[] = { 0x05,0x00};
+static CHAR oid_bogus[] = "1.2.3",
+            oid_rsa[] = "1.2.840.113549";
+static const struct encodedPublicKey pubKeys[] = {
+ { { { oid_rsa, { 0, ((void *)0) } }, { 0, ((void *)0), 0} },
+  { { oid_rsa, { 2, bin72 } }, { sizeof(aKey), (BYTE *)aKey, 0} } },
+ { { { oid_rsa, { sizeof(params), (BYTE *)params } }, { sizeof(aKey),
+  (BYTE *)aKey, 0 } } },
+};
+static void test_encodePublicKeyInfo(DWORD dwEncoding)
+{
+    DWORD i;
+    {
+        BOOL ret;
+        BYTE *buf = ((void *)0);
+        DWORD bufSize = 0;
+        ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)8),
+         &bufSize);
+        {
+            (winetest_set_location("encode.c", 2505), 0) ? 0 : winetest_ok(bufSize == pubKeys[i].encoded[1] + 2 ||
+             pubKeys[i].encodedNoNull[1] + 2, bufSize);
+                (winetest_set_location("encode.c", 2510), 0) ? 0 : winetest_ok(!memcmp(buf, pubKeys[i].encoded, pubKeys[i].encoded[1] + 2),
+                 "Unexpected value\n");
+                (winetest_set_location("encode.c", 2513), 0) ? 0 : winetest_ok(!memcmp(buf, pubKeys[i].encodedNoNull,
+                 pubKeys[i].encodedNoNull[1] + 2), "Unexpected value\n");
+        }
+    }
+}
+static void comparePublicKeyInfo(const CERT_PUBLIC_KEY_INFO *expected,
+ const CERT_PUBLIC_KEY_INFO *got)
+{
+    (winetest_set_location("encode.c", 2523), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (expected->Algorithm.pszObjId) && __builtin_constant_p (got->Algorithm.pszObjId) && (__s1_len = strlen (expected->Algorithm.pszObjId), __s2_len = strlen (got->Algorithm.pszObjId), (!((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__builtin_constant_p (expected->Algorithm.pszObjId) && ((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) && (__s1_len = strlen (expected->Algorithm.pszObjId), __s1_len < 4) ? (__builtin_constant_p (got->Algorithm.pszObjId) && ((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (got->Algorithm.pszObjId); register int __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (got->Algorithm.pszObjId) && ((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) && (__s2_len = strlen (got->Algorithm.pszObjId), __s2_len < 4) ? (__builtin_constant_p (expected->Algorithm.pszObjId) && ((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[3]); } } __result; }))) : __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId)))); }),
+     expected->PublicKey.cbData, got->PublicKey.cbData);
+        (winetest_set_location("encode.c", 2538), 0) ? 0 : winetest_ok(!memcmp(expected->PublicKey.pbData, got->PublicKey.pbData,
+         got->PublicKey.cbData), "Unexpected public key value\n");
+}
+static void test_decodePublicKeyInfo(DWORD dwEncoding)
+{
+    static const BYTE bogusPubKeyInfo[] = { 0x30, 0x22, 0x30, 0x0d, 0x06, 0x06,
+     0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    {
+        ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)8),
+         0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
+        {
+        }
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)8),
+     "Expected CRYPT_E_ASN1_CORRUPT, got %08x\n", GetLastError());
+}
+static const BYTE v1Cert[] = { 0x30, 0x33, 0x02, 0x00, 0x30, 0x02, 0x06, 0x00,
+ 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
+static const BYTE v2Cert[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x01, 0x02,
+ 0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
+static const BYTE v3Cert[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02,
+ 0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
+static const BYTE v1CertWithConstraints[] = { 0x30, 0x4b, 0x02, 0x00, 0x30,
+ 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
+static const BYTE v1CertWithSerial[] = { 0x30, 0x4c, 0x02, 0x01, 0x01, 0x30,
+ 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
+static const BYTE bigCert[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
+ 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
+static void test_encodeCertToBeSigned(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    CERT_INFO info = { 0 };
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)2), ((void *)0),
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)2), &info,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+    {
+    }
+}
+static void test_decodeCertToBeSigned(DWORD dwEncoding)
+{
+    static const BYTE *corruptCerts[] = { v1Cert, v2Cert, v3Cert,
+     v1CertWithConstraints, v1CertWithSerial };
+    BOOL ret;
+    (winetest_set_location("encode.c", 2727), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x80093102L),
+     "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
+    {
+        ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)2),
+         "Expected CRYPT_E_ASN1_CORRUPT, got %08x\n", GetLastError());
+    }
+    {
+    }
+}
+static const BYTE hash[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
+ 0xe, 0xf };
+static const BYTE signedBigCert[] = {
+ 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
+static void test_encodeCert(DWORD dwEncoding)
+{
+    CERT_SIGNED_CONTENT_INFO info = { { sizeof(bigCert), (BYTE *)bigCert },
+     { ((void *)0), { 0, ((void *)0) } }, { sizeof(hash), (BYTE *)hash, 0 } };
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD bufSize = 0;
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)1), &info,
+     0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
+    {
+    }
+}
+static void test_decodeCert(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    {
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)2), signedBigCert,
+     sizeof(signedBigCert), 0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+        CERT_INFO *info = (CERT_INFO *)buf;
+        (winetest_set_location("encode.c", 2843), 0) ? 0 : winetest_ok(info->SerialNumber.cbData == 1,
+         *info->SerialNumber.pbData);
+        (winetest_set_location("encode.c", 2852), 0) ? 0 : winetest_ok(info->Subject.cbData == sizeof(encodedCommonName),
+         "Wrong size %d\n", info->Subject.cbData);
+        (winetest_set_location("encode.c", 2854), 0) ? 0 : winetest_ok(!memcmp(info->Subject.pbData, encodedCommonName,
+         info->Subject.cbData), "Unexpected subject\n");
+    }
+}
+static const BYTE distPointWithUrl[] = { 0x30, 0x19, 0x30, 0x17, 0xa0, 0x15,
+ 0x6e, 0x65, 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67 };
+static const BYTE distPointWithIssuer[] = { 0x30, 0x17, 0x30, 0x15, 0xa2, 0x13,
+ 0x2e, 0x6f, 0x72, 0x67 };
+static const BYTE crlReason = 1 |
+ 3;
+static void test_encodeCRLDistPoints(DWORD dwEncoding)
+{
+    CRL_DIST_POINTS_INFO xxxinfo = { 0 };
+    CRL_DIST_POINT point = { { 0 } };
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)35), &xxxinfo,
+     "Expected E_INVALIDARG, got %08x\n", GetLastError());
+    xxxinfo.cDistPoint = 1;
+    xxxinfo.rgDistPoint = &point;
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)35), &xxxinfo,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    point.ReasonFlags.cbData = sizeof(crlReason);
+    {
+    }
+}
+static void test_decodeCRLDistPoints(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    PCERT_ALT_NAME_ENTRY entry;
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)35),
+     (BYTE *)&buf, &size);
+    {
+        (winetest_set_location("encode.c", 3065), 0) ? 0 : winetest_ok(entry->dwAltNameChoice == 7,
+         "Expected CERT_ALT_NAME_URL, got %d\n", entry->dwAltNameChoice);
+    }
+}
+static const BYTE urlIDP[] = { 0x30,0x17,0xa0,0x15,0xa0,0x13,0x86,0x11,0x68,
+ 0x67 };
+static void test_encodeCRLIssuingDistPoint(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    CRL_ISSUING_DIST_POINT point = { { 0 } };
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)54), ((void *)0),
+     "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)54), &point,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+    {
+    }
+}
+static void compareAltNameEntry(const CERT_ALT_NAME_ENTRY *expected,
+ const CERT_ALT_NAME_ENTRY *got)
+{
+    (winetest_set_location("encode.c", 3149), 0) ? 0 : winetest_ok(expected->dwAltNameChoice == got->dwAltNameChoice,
+     got->dwAltNameChoice);
+    {
+        {
+            (winetest_set_location("encode.c", 3161), 0) ? 0 : winetest_ok((!(*expected).pwszURL && !(*got).pwszURL) ||
+               !lstrcmpW((*expected).pwszURL, (*got).pwszURL), "Unexpected name\n");
+        }
+    }
+}
+static void compareAltNameInfo(const CERT_ALT_NAME_INFO *expected,
+ const CERT_ALT_NAME_INFO *got)
+{
+}
+static const BYTE v1CRL[] = { 0x30, 0x15, 0x30, 0x02, 0x06, 0x00, 0x18, 0x0f,
+ 0x30, 0x5a };
+static const BYTE v2CRL[] = { 0x30, 0x18, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
+ 0x30, 0x30, 0x30, 0x30, 0x5a };
+static const BYTE v1CRLWithIssuer[] = { 0x30, 0x2c, 0x30, 0x02, 0x06, 0x00,
+ 0x5a };
+static const BYTE v1CRLWithIssuerAndEmptyEntry[] = { 0x30, 0x43, 0x30, 0x02,
+ 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
+static const BYTE v1CRLWithIssuerAndEntry[] = { 0x30, 0x44, 0x30, 0x02, 0x06,
+ 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
+static const BYTE v1CRLWithEntryExt[] = { 0x30,0x5a,0x30,0x02,0x06,0x00,0x30,
+ 0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
+static const BYTE v1CRLWithExt[] = { 0x30,0x5c,0x30,0x02,0x06,0x00,0x30,0x15,
+ 0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
+static const BYTE v2CRLWithExt[] = { 0x30,0x5c,0x02,0x01,0x01,0x30,0x02,0x06,
+ 0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
+static const BYTE v2CRLWithIssuingDistPoint[] = { 0x30,0x5c,0x02,0x01,0x01,
+ 0x03,0x55,0x1d,0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
+static void test_encodeCRLToBeSigned(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    CRL_INFO info = { 0 };
+    {
+        (winetest_set_location("encode.c", 3386), 0) ? 0 : winetest_ok(size == sizeof(v1CRLWithIssuerAndEntry),
+         "Wrong size %d\n", size);
+    }
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)3), &info,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+    {
+    }
+}
+static const BYTE verisignCRL[] = { 0x30, 0x82, 0x01, 0xb1, 0x30, 0x82, 0x01,
+0x61,0xc0,0x99,0x16,0x71,0x05,0xb6,0x25,0x14,0x64,0x4f,0x30 };
+static void test_decodeCRLToBeSigned(DWORD dwEncoding)
+{
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0, i;
+    {
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
+     (BYTE *)&buf, &size);
+    {
+        CRL_INFO *info = (CRL_INFO *)buf;
+        (winetest_set_location("encode.c", 4016), 0) ? 0 : winetest_ok(info->cCRLEntry == 0, "Expected 0 CRL entries, got %d\n",
+         "Unexpected issuer\n");
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+        CRL_INFO *info = (CRL_INFO *)buf;
+        (winetest_set_location("encode.c", 4041), 0) ? 0 : winetest_ok(info->cCRLEntry == 1, "Expected 1 CRL entries, got %d\n",
+         "Unexpected issuer\n");
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+        CRL_INFO *info = (CRL_INFO *)buf;
+        (winetest_set_location("encode.c", 4085), 0) ? 0 : winetest_ok(info->cCRLEntry == 209, "Expected 209 CRL entries, got %d\n",
+         info->cExtension);
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
+     ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+}
+static const BYTE authorityKeyIdWithIssuer[] = { 0x30,0x19,0xa1,0x17,0x30,0x15,
+ 0x20,0x4c,0x61,0x6e,0x67,0x00 };
+static const BYTE authorityKeyIdWithSerial[] = { 0x30,0x03,0x82,0x01,0x01 };
+static void test_encodeAuthorityKeyId(DWORD dwEncoding)
+{
+    CERT_AUTHORITY_KEY_ID_INFO info = { { 0 } };
+    BOOL ret;
+    BYTE *buf = ((void *)0);
+    DWORD size = 0;
+    {
+    }
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)9), &info,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+    }
+    ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)9), &info,
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+        (winetest_set_location("encode.c", 4284), 0) ? 0 : winetest_ok(size == sizeof(authorityKeyIdWithSerial), "Unexpected size %d\n",
+         size);
+    }
+}
+static void test_decodeAuthorityKeyId(DWORD dwEncoding)
+{
+    BOOL ret;
+    LPBYTE buf = ((void *)0);
+    DWORD size = 0;
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)9),
+     (BYTE *)&buf, &size);
+    {
+    }
+    ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)9),
+     0x08000, ((void *)0), (BYTE *)&buf, &size);
+    {
+        (winetest_set_location("encode.c", 4355), 0) ? 0 : winetest_ok(size >= sizeof(CERT_AUTHORITY_KEY_ID_INFO), "Unexpected size %d\n",
+         "Unexpected serial number\n");
+    }
+}
+static void testExportPublicKey(HCRYPTPROV csp, PCERT_PUBLIC_KEY_INFO *pInfo)
+{
+    BOOL ret;
+    DWORD size = 0;
+    {
+        ret = CryptExportPublicKeyInfoEx(csp, 2, 0x00000001,
+         ((void *)0), 0, ((void *)0), ((void *)0), &size);
+        {
+            {
+                (winetest_set_location("encode.c", 4416), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && __builtin_constant_p ("1.2.840.113549.1.1.1") && (__s1_len = strlen ((*pInfo)->Algorithm.pszObjId), __s2_len = strlen ("1.2.840.113549.1.1.1"), (!((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) || __s2_len >= 4)) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && ((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) && (__s1_len = strlen ((*pInfo)->Algorithm.pszObjId), __s1_len < 4) ? (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"); register int __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) && (__s2_len = strlen ("1.2.840.113549.1.1.1"), __s2_len < 4) ? (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && ((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[3]); } } __result; }))) : __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1")))); }),
+                 (*pInfo)->Algorithm.pszObjId);
+            }
+        }
+    }
+}
+static const BYTE expiredCert[] = { 0x30, 0x82, 0x01, 0x33, 0x30, 0x81, 0xe2,
+ 0x49, 0xe5, 0xf9, 0x65, 0xf3 };
+static void testImportPublicKey(HCRYPTPROV csp, PCERT_PUBLIC_KEY_INFO info)
+{
+    BOOL ret;
+    HCRYPTKEY key;
+    PCCERT_CONTEXT context;
+    (winetest_set_location("encode.c", 4464), 0) ? 0 : winetest_ok(!ret && GetLastError() == 2,
+     GetLastError());
+    {
+        (winetest_set_location("encode.c", 4485), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ("1.2.840.113549.1.1.1") && __builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && (__s1_len = strlen ("1.2.840.113549.1.1.1"), __s2_len = strlen (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId), (!((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) || __s1_len >= 4) && (!((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) && (__s1_len = strlen ("1.2.840.113549.1.1.1"), __s1_len < 4) ? (__builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && ((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId); register int __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && ((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) && (__s2_len = strlen (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId), __s2_len < 4) ? (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[3]); } } __result; }))) : __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId)))); }),
+         &context->pCertInfo->SubjectPublicKeyInfo, 0, 0, ((void *)0), &key);
+    }
+}
+static const char cspName[] = "WineCryptTemp";
+static void testPortPublicKeyInfo(void)
+{
+    HCRYPTPROV csp;
+    BOOL ret;
+    CryptAcquireContextA(&csp, cspName, "Microsoft Base Cryptographic Provider v1.0", 1,
+     0x00000008);
+    ret = CryptAcquireContextA(&csp, cspName, "Microsoft Base Cryptographic Provider v1.0", 1,
+     0x00000010);
+}
+void func_encode(void)
+{
+    test_encodeCRLDistPoints(0x00000001);
+}
+
+/* { dg-final { scan-tree-dump-times " xxxinfo = {}" 1 "dse1"} } */
+/* { dg-final { cleanup-tree-dump "dse\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-11.c
new file mode 100644
index 000000000..6e13e1875
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-11.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-dse1-details" } */
+
+extern void abort(void);
+void foo(int *p)
+{
+  while (1)
+   {
+      *p = 1;
+      *p = 0;
+   }
+}
+void bar(int *p)
+{
+  *p = 1;
+  *p = 0;
+  abort ();
+}
+
+/* { dg-final { scan-tree-dump-times "Deleted dead store" 2 "dse1" } } */
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-2.c
new file mode 100644
index 000000000..104ef26df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-2.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1" } */
+
+int a, b, c;
+int
+foo ()
+{
+  int *p;
+  if (c)
+    p = &a;
+  else
+    p = &b;
+
+  *p = 3;
+  *p = 4;
+  return *p;
+}
+
+
+/* We should eliminate the first assignment to *p, but not the second.  */
+/* { dg-final { scan-tree-dump-times " = 3" 0 "dse1"} } */
+/* { dg-final { scan-tree-dump-times " = 4" 1 "dse1"} } */
+
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-3.c
new file mode 100644
index 000000000..4292f2384
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1" } */
+
+char Bool_Glob;
+void f(void)
+{
+  Bool_Glob = 0;
+  Bool_Glob = 1;
+}
+
+/* We should eliminate the first assignment to *p, but not the second.  */
+/* { dg-final { scan-tree-dump-times "Bool_Glob = 0" 0 "dse1"} } */
+/* { dg-final { scan-tree-dump-times "Bool_Glob = 1" 1 "dse1"} } */
+
+/* { dg-final { cleanup-tree-dump "dse1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-4.c
new file mode 100644
index 000000000..39fc85e69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-4.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1" } */
+
+foo( int *a)
+{
+  *a = 5;
+  *a = 3;
+}
+
+
+
+
+/* We should eliminate the first assignment to *p, but not the second.  */
+/* { dg-final { scan-tree-dump-times "= 5" 0 "dse1"} } */
+/* { dg-final { scan-tree-dump-times "= 3" 1 "dse1"} } */
+
+/* { dg-final { cleanup-tree-dump "dse1" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-5.c
new file mode 100644
index 000000000..537a5e57b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-5.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int x; 
+ 
+int 
+f1 (int i, int j, int k) 
+{ 
+  int *p = k ? &i : &j; 
+  i = 3;
+  *p = 5; 
+  x = j; 
+} 
+
+/* The assignment "i = 3" is partialy dead.  Our DSE pass doesn't handle
+   detection of partially dead assignments.
+
+   There's two outputs which would indicate that the optimization was
+   performed.
+
+   If we used block copying to detect and eliminate the partially dead
+   store, then we should see an assignment "i = 5" somewhere in the
+   dump file.
+
+   Another approach would be to redirect the path from the true arm
+   of the first conditional so that it reaches the statement *p = 5
+   rather than i = 3.  */
+
+/* { dg-final { scan-tree-dump-times "i = 5" 1 "optimized" { xfail *-*-* }} } */
+/* { dg-final { scan-tree-dump-times "<L.*>:;\[\n\t \]*\\*p = 5" 1 "optimized" { xfail *-*-*}} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-6.c
new file mode 100644
index 000000000..3d020067c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-6.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1" } */
+
+int foo11 (int c)
+{
+  static int local1, local2;
+  local1 = 0;
+  local2 += c;
+  local1 = 2;
+  local2++;
+  return local1 + local2;
+}
+
+/* There should only be one assignment to local1 and local2.  */
+/* { dg-final { scan-tree-dump-times "local1 = " 1 "dse1"} } */
+/* { dg-final { scan-tree-dump-times "local2 = " 1 "dse1"} } */
+
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-7.c
new file mode 100644
index 000000000..77e4a6246
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-7.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1" } */
+
+int glob1, glob2;
+
+int foo1 (void)
+{
+  glob1 = 0;
+  glob2 = 1;
+  glob1 = 2;
+  glob2 = 3;
+  return glob1 + glob2;
+}
+
+
+
+/* There should only be one assignment to glob1 and glob2, the final
+   return statement should just return a constant.  */
+/* { dg-final { scan-tree-dump-times "glob1 = " 1 "dse1"} } */
+/* { dg-final { scan-tree-dump-times "glob2 = " 1 "dse1"} } */
+/* { dg-final { scan-tree-dump-times "return 5" 1 "dse1"} } */
+
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-8.c
new file mode 100644
index 000000000..de1d5bb62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-8.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-dce -fno-tree-ccp -fno-tree-copy-prop -fno-tree-dominator-opts" } */
+
+/* This caused the compiler to enter an infinite loop if copies are not
+   fully propagated.   The options are to disable copy propagation and
+   thus expose the bug.   */
+
+int foo (void);
+
+struct A {
+  struct B {
+    struct B *n;
+  } *p;
+};
+
+static inline void baz (struct A *a)
+{
+  a->p = a->p->n;
+}
+
+void bar (struct A a)
+{
+  while (foo ())
+    baz (&a);
+  while (foo ());
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-9.c
new file mode 100644
index 000000000..4cb67f0ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-9.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1-vops" } */
+
+struct { int a, b; } soup1, soup2;
+foo ()
+{
+  soup1 = soup2;
+  soup1.a = 66;
+  soup1.b = 77;
+}
+
+/* We should eliminate the first assignment.  */
+/* { dg-final { scan-tree-dump-times "VDEF" 2 "dse1" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "dse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-1.c
new file mode 100644
index 000000000..0cb63242c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+/* From PR27090.  */
+
+int f(int *a)
+{
+  int t = *a;
+  unsigned *b = (unsigned *)a;
+  int *c = (int*)b;
+  return *c + t;
+}
+
+/* { dg-final { scan-tree-dump "Replaced \\\(int \\\*\\\) b_.*with a_" "fre" } } */
+/* { dg-final { scan-tree-dump "Replaced \\\*c_.*with t_" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-10.c
new file mode 100644
index 000000000..a27f2d6c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-10.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+union loc {  unsigned reg; signed offset; };
+void __frame_state_for (volatile char *state_in, int x)
+{
+  /* We should move all the loads out of this loop. Right now, we only
+     move one.  It takes two insertions because we insert a cast.  */
+    union loc fs;
+    int reg;
+    for (;;)     {
+        switch (x)  {
+	    case 0:
+		*state_in = fs.reg;
+	    case 1:
+		*state_in = fs.offset;
+	}
+    }
+}
+
+/* { dg-final { scan-tree-dump "Insertions: 2" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-11.c
new file mode 100644
index 000000000..50bb5d960
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-11.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+struct
+{
+  int x;
+  int y;
+} S[100];
+
+int z[100];
+
+int
+foo (int y)
+{
+  int x;
+
+  S[5].x = 4;
+  S[5].y = 0;
+
+  x = S[5].x;
+
+  return (x);
+}
+
+/* { dg-final { scan-tree-dump "Replaced S\\\[5\\\].x with 4" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-12.c
new file mode 100644
index 000000000..50bb5d960
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-12.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+struct
+{
+  int x;
+  int y;
+} S[100];
+
+int z[100];
+
+int
+foo (int y)
+{
+  int x;
+
+  S[5].x = 4;
+  S[5].y = 0;
+
+  x = S[5].x;
+
+  return (x);
+}
+
+/* { dg-final { scan-tree-dump "Replaced S\\\[5\\\].x with 4" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-13.c
new file mode 100644
index 000000000..3253afe29
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-13.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fstrict-aliasing -fno-tree-sra --param max-aliased-vops=0 --param max-fields-for-field-sensitive=0 -fdump-tree-fre-details" } */
+
+/* Should be optimized, propagating &a into (*p)[i] with parameters
+     --param max-aliased-vops=0 --param max-fields-for-field-sensitive=0
+   which means max 1 VOP per stmt and no SFTs.  */
+
+/* For this testcase we need TBAA to work.  */
+
+struct Foo
+{
+  void *data;
+  int size;
+};
+void foo(double (*q)[4], struct Foo *tmp1)
+{
+  double a[4];
+  int i;
+  tmp1->data = &a;
+  tmp1->size = 4;
+  for (i=0; i<4; ++i)
+    {
+      double (*p)[4] = tmp1->data;
+      (*p)[i] = (*q)[i];
+    }
+}
+
+/* { dg-final { scan-tree-dump "Inserted .* &a" "fre" } } */
+/* { dg-final { scan-tree-dump "Replaced tmp1_.\\\(D\\\)->data" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-14.c
new file mode 100644
index 000000000..d2d5e01bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-14.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fno-tree-sra --param max-aliased-vops=0 --param max-fields-for-field-sensitive=0 -fdump-tree-fre-details" } */
+
+/* Should be optimized, propagating &a into (*p)[i] with parameters
+     --param max-aliased-vops=0 --param max-fields-for-field-sensitive=0
+   which means max 1 VOP per stmt and no SFTs.  */
+
+struct Foo
+{
+  void *data;
+  double size;
+};
+void foo(double (*q)[4])
+{
+  struct Foo tmp1;
+  double a[4];
+  int i;
+  tmp1.data = &a;
+  tmp1.size = 4;
+  for (i=0; i<4; ++i)
+    {
+      double (*p)[4] = tmp1.data;
+      (*p)[i] = (*q)[i];
+      /* We want a PHI for the VOP for accessing tmp1.data, so place
+ 	 this store to tmp1 here.  */
+      tmp1.size -= 1.0;
+    }
+}
+
+/* { dg-final { scan-tree-dump "Inserted .* &a" "fre" } } */
+/* { dg-final { scan-tree-dump "Replaced tmp1.data" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-15.c
new file mode 100644
index 000000000..1a286f1e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-15.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fno-tree-sra --param max-aliased-vops=0 --param max-fields-for-field-sensitive=0 -fdump-tree-fre-details" } */
+
+/* Should be optimized, propagating &a into (*p)[i] with parameters
+     --param max-aliased-vops=0 --param max-fields-for-field-sensitive=0
+   which means max 1 VOP per stmt and no SFTs.  */
+
+struct Foo
+{
+  void *data;
+  double size;
+};
+void foo(double (*q)[4])
+{
+  struct Foo tmp1;
+  double a[4];
+  int i;
+  tmp1.data = &a;
+  for (i=0; i<4; ++i)
+    {
+      double (*p)[4] = tmp1.data;
+      (*p)[i] = (*q)[i];
+      /* We want a PHI for the VOP for accessing tmp1.data, so place
+ 	 this store to tmp1 here.  */
+      tmp1.size -= 1.0;
+    }
+}
+
+/* { dg-final { scan-tree-dump "Replaced" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-16.c
new file mode 100644
index 000000000..56d85e58e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-16.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre" } */
+
+/* FRE should be able to combine i and j and perform simplification
+   on the condition.  */
+
+extern void link_error (void);
+int i;
+int foo(int b, int c)
+{
+  i = b + 1;
+  int j = i - 1;
+  if (b != j)
+    link_error ();
+}
+
+/* { dg-final { scan-tree-dump-not "link_error" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-17.c
new file mode 100644
index 000000000..aced64977
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-17.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details -fno-tree-sra" } */
+
+struct Bar {
+  int dom;
+};
+struct Foo {
+  struct Bar doms[3];
+};
+
+int foo(int i, int j, int k)
+{
+  struct Foo f;
+
+  f.doms[0].dom = i;
+  f.doms[1].dom = j;
+  f.doms[2].dom = k;
+  return f.doms[0LL].dom;
+}
+
+/* { dg-final { scan-tree-dump "Replaced f.doms\\\[0\\\].dom with i_" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-2.c
new file mode 100644
index 000000000..d1eabf69b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+/* From PR14287.  */
+
+short g, h;
+
+void
+foo (long a)
+{
+  short b = a & 3;
+  long c = b;
+  g = c;
+  h = c;
+}
+
+/* { dg-final { scan-tree-dump "Replaced \\\(short int\\\) c_.*with b_" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-21.c
new file mode 100644
index 000000000..aadf32e21
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-21.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre" } */
+
+struct f {
+  float a;
+  float b;
+  float c;
+  float d;
+};
+
+struct f a;
+
+void h(float, float, float, float);
+
+void g(void)
+{
+  float a1 = a.a, b = a.b, c = a.c, d = a.d;
+  a.a = a1;
+  a.b = b;
+  a.c = c;
+  a.d = d;
+  h(a1, b, c, d);
+}
+
+/* { dg-final { scan-tree-dump-not "a\\\.? = " "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-3.c
new file mode 100644
index 000000000..85e444886
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-3.c
@@ -0,0 +1,22 @@
+/* This test requires:
+
+      TRULY_NOOP_TRUNCATION (sizeof (int) * CHAR_BIT,
+			     sizeof (long long) * CHAR_BIT)
+
+   When the condition is true, we distribute "(int) (a + b)" as
+   "(int) a + (int) b", otherwise we keep the original.  */
+/* { dg-do compile { target { { ! mips64 } && { ! spu-*-* } } } } */
+/* { dg-options "-O -fwrapv -fdump-tree-fre-details" } */
+
+/* From PR14844.  */
+
+int
+foo (int a, int b)
+{
+  long long aa = a;
+  long long bb = b;
+  return aa + bb;
+}
+
+/* { dg-final { scan-tree-dump "Replaced \\\(int\\\) aa_.*with a_" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-4.c
new file mode 100644
index 000000000..ca8d4c96b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-4.c
@@ -0,0 +1,15 @@
+/* If the target returns false for TARGET_PROMOTE_PROTOTYPES, then there
+   will be no casts for FRE to eliminate and the test will fail.  */
+/* { dg-do compile { target i?86-*-* x86_64-*-* hppa*-*-* mips*-*-* m68k*-*-* } } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+/* From PR21608.  */
+
+static inline char wrap(char f) { return f; }
+char bar(char f)
+{
+        return wrap(f);
+}
+
+/* { dg-final { scan-tree-dump "Replaced \\\(char\\\) .*with " "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-5.c
new file mode 100644
index 000000000..7ef20c221
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-5.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+/* From PR19792.  */
+
+int
+bar (unsigned int t)
+{
+  int a = t;
+  return a == t;
+}
+
+/* { dg-final { scan-tree-dump "Replaced \\\(unsigned int\\\) a_.*with t_" "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c
new file mode 100644
index 000000000..6963c1ce4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+
+ int i; int foo(void) { i = 2; int j = i * 2; int k = i + 2; return j == k; }
+/* { dg-final { scan-tree-dump-times "Replaced " 5 "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-7.c
new file mode 100644
index 000000000..bd81831eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-7.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details -fdump-tree-optimized" } */
+#if (__SIZEOF_INT__ == __SIZEOF_FLOAT__)
+typedef int intflt;
+#elif (__SIZEOF_LONG__ == __SIZEOF_FLOAT__)
+typedef long intflt;
+#else
+#error Add target support here for type that will union float size
+#endif
+
+struct X {
+  int i;
+  union {
+    intflt j;
+    intflt k;
+    float f;
+  } u;
+};
+
+intflt foo(intflt j)
+{
+  struct X a;
+
+  a.u.j = j;
+  a.u.f = a.u.f;
+  a.u.f = a.u.f;
+  a.u.j = a.u.j;
+  a.u.f = a.u.f;
+  return a.u.k;
+}
+
+/* { dg-final { scan-tree-dump-times "Inserted pretmp" 1 "fre" } } */
+/* { dg-final { scan-tree-dump-times "Replaced a.u.f with pretmp" 3 "fre" } } */
+/* { dg-final { scan-tree-dump-times "Replaced a.u.k with j" 1 "fre" } } */
+/* { dg-final { scan-tree-dump "= VIEW_CONVERT_EXPR<float>\\\(j_" "fre" } } */
+/* { dg-final { scan-tree-dump "return j" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-8.c
new file mode 100644
index 000000000..6e17bd531
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-8.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-details" } */
+#if (__SIZEOF_INT__ == __SIZEOF_FLOAT__)
+typedef int intflt;
+#elif (__SIZEOF_LONG__ == __SIZEOF_FLOAT__)
+typedef long intflt;
+#else
+#error Add target support here for type that will union float size
+#endif
+union U {
+  intflt i;
+  float f;
+};
+intflt foo(int i, int b)
+{
+  union U u;
+  if (b)
+    {
+      i = i << 2;
+      u.i = i;
+      return u.f;
+    }
+  else
+    {
+      i = i << 2;
+      u.i = i;
+      return u.f;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Replaced u.f with pretmp" 2 "fre" } } */
+/* { dg-final { scan-tree-dump-times "Inserted pretmp" 2 "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-9.c
new file mode 100644
index 000000000..18595ed6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-9.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre-stats" } */
+
+union loc {
+    unsigned reg;
+    signed offset;
+};
+void __frame_state_for2 (volatile char *state_in)
+{
+    union loc fs;
+    {
+	*state_in = fs.reg;
+	*state_in = fs.offset;
+    }
+}
+void __frame_state_for1 (volatile char *state_in)
+{
+    union loc fs;
+    for (;;)
+    {
+	*state_in = fs.offset;
+	*state_in = fs.reg;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 2 "fre" } } */
+/* { dg-final { scan-tree-dump-times "Insertions: 1" 2 "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-1.c
new file mode 100644
index 000000000..20854813d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+/* Testcase for PR31657.  */
+
+int foo (int x, int a, int b)
+{
+  int c = 1 << a;
+  if (x & c)
+    if (x & (1 << b))
+      /* returning 1 causes phiopt to trigger in */
+      return 2;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "\\|" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-2.c
new file mode 100644
index 000000000..dab30addd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-2.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+/* Testcase for PR31657.  */
+
+int foo (int x, int a, int b)
+{
+  /* if ((x & a) || (x & b)) */
+  if (x & a)
+    goto doit;
+  if (x & b)
+    goto doit;
+
+  /* else */
+  return 0;
+
+  /* then - returing 1 causes phiopt to trigger */
+doit:
+  return 2;
+}
+
+/* { dg-final { scan-tree-dump "\\|" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-3.c
new file mode 100644
index 000000000..79fec8ba9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-3.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+/* Testcase extracted from PR15353.  */
+
+int foo (int x, int a)
+{
+  /* if ((x > a) || (x == a)) */
+  if (x > a)
+    goto doit;
+  if (x == a)
+    goto doit;
+
+  /* else */
+  return 0;
+
+  /* then - returing 1 causes phiopt to trigger */
+doit:
+  return 2;
+}
+
+/* { dg-final { scan-tree-dump ">=" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-4.c
new file mode 100644
index 000000000..da477867e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+/* Testcase extracted from PR15353.  */
+
+extern void bar(void);
+
+void foo (int x, int a)
+{
+  /* if ((x < a) || (x != a)) return; else bar (); */
+  if (x < a)
+    return;
+  if (x != a)
+    return;
+
+  /* else */
+  bar ();
+}
+
+/* { dg-final { scan-tree-dump "!=" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-5.c
new file mode 100644
index 000000000..88bd81e25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-5.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+/* Testcase from PR15353.  */
+
+int g(void);
+int h(void);
+int f(int *i, int *j)
+{
+  while (1)
+    {
+      if (*i > *j || *i == *j)
+        break;
+      return g();
+    }
+  return h();
+}
+
+/* { dg-final { scan-tree-dump ">=" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-6.c
new file mode 100644
index 000000000..90abc8deb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-ifcombine-6.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-ifcombine" } */
+
+void bar (void);
+
+void
+foo1 (unsigned int a)
+{
+  if (a & 1)
+    goto heaven;
+  if (a & 4)
+    goto heaven;
+  return;
+
+ heaven:
+  bar ();
+}
+
+void
+foo2 (unsigned int a)
+{
+  if (a & 1)
+    if (a & 4)
+      goto heaven;
+  return;
+
+ heaven:
+  bar ();
+}
+
+
+/* The special treatment of a & 1 != 0 in fold caused the pattern not
+   to be recognized due to extra conversions inserted.  */
+
+/* { dg-final { scan-tree-dump "optimizing bits or bits test" "ifcombine" } } */
+/* { dg-final { scan-tree-dump "optimizing double bit test" "ifcombine" } } */
+/* { dg-final { cleanup-tree-dump "ifcombine" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-1.c
new file mode 100644
index 000000000..db36ff02c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-lim" } */
+
+/* This is a variant that does cause fold to place a cast to
+   int before testing bit 1.  */
+
+void
+quantum_toffoli (int control1, int control2, int target,
+		 unsigned long *state, int size)
+{
+  int i;
+
+  for(i=0; i<size; i++)
+    {
+       if (state[i] & ((unsigned long) 1 << control1))
+         if (state[i] & ((unsigned long) 1 << control2))
+           state[i] ^= ((unsigned long) 1 << target);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "1 <<" 3 "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-2.c
new file mode 100644
index 000000000..7b18b1c05
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-lim" } */
+
+/* This is a variant that doesn't cause fold to place a cast to
+   int before testing bit 1.  */
+
+void
+quantum_toffoli(int control1, int control2, int target, int *state,
+int size)
+{
+  int i;
+
+  for(i=0; i<size; i++)
+    {
+       if (state[i] & ( 1 << control1))
+         if (state[i] & ( 1 << control2))
+           state[i] ^= ( 1 << target);
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "1 <<" 3 "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-3.c
new file mode 100644
index 000000000..b88a1e58a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-3.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+
+struct { int x; int y; } global;
+void foo(int n)
+{
+  int i;
+  for ( i=0; i<n; i++)
+    global.y += global.x*global.x;
+}
+
+/* { dg-final { scan-tree-dump "Executing store motion of global.y" "lim" } } */
+/* { dg-final { scan-tree-dump "Moving statement.*global.x.*out of loop 1" "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-5.c
new file mode 100644
index 000000000..4a428515d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-5.c
@@ -0,0 +1,29 @@
+/* { dg-do link } */
+/* { dg-options "-O" } */
+
+/* We should apply store motion here.  */
+
+struct BUF1
+{
+  int b1;
+  int b12;
+};
+
+void link_error();
+
+int foo(struct BUF1 * p)
+{
+    int i = 0;
+#if(__SIZEOF_INT__ >= 4)    
+    for (i = 0; i < 1024*1024; i++)
+#else
+    for (i = 0; i <  128*128; i++)
+#endif
+      p->b1 = 1;
+
+    if (p->b1 != 1)
+      link_error ();
+    return 0;
+}
+
+int main() { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-6.c
new file mode 100644
index 000000000..0da57aa08
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-lim-6.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+
+double a[16][64], y[64], x[16];
+void foo(void)
+{
+  int i, j;
+  for (j = 0; j < 64; ++j)
+    for (i = 0; i < 16; ++i)
+      y[j] = y[j] + a[i][j] * x[i];
+}
+
+/* { dg-final { scan-tree-dump "Executing store motion of y" "lim" } } */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-1.c
new file mode 100644
index 000000000..3bdd204a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+extern int printf (const char *, ...);
+int main(int argc, char **argv)
+{
+	int a;
+	int b;
+	int c;
+	b  = argc + 1;
+	c =  argc + 2;
+	a = b + c;
+	if (argc * 2)
+	{
+		c = argc + 3;
+	}
+	printf ("%d, %d\n", a, b + c);
+}
+/* We should eliminate one evaluation of b + c along the main path, 
+   causing one reload. */
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-10.c
new file mode 100644
index 000000000..41af34498
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-10.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-fre-stats" } */
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-fre-stats -fno-finite-math-only" { target sh*-*-* } } */
+double cos (double);
+void link_error();
+void f(double a)
+{
+  double b = cos (a);
+  double c = cos (a);
+  if (b != c)
+    link_error();
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-11.c
new file mode 100644
index 000000000..26c47b183
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-11.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+double cos (double);
+double f(double a)
+{
+  double b;
+  double c,d;
+ if (a < 2.0)
+   {
+     c = cos (a);
+   }
+ else
+   {
+     c = 1.0; 
+   }
+ d = cos (a);
+ return d + c;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-12.c
new file mode 100644
index 000000000..fd80e3d8d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-12.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+double cos (double) __attribute__ ((const));
+double sin (double) __attribute__ ((const));
+double f(double a)
+{
+  double b;
+  double c,d;
+  double (*fp) (double) __attribute__ ((const));
+  /* Fully redundant call, but we need a phi node to merge the results.  */
+  if (a < 2.0)
+    {
+      fp = sin;
+      c = fp (a);
+    }
+  else
+    {
+      c = 1.0; 
+      fp = cos;
+      c = fp (a);
+    }
+  d = fp (a);
+  return d + c;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-13.c
new file mode 100644
index 000000000..dfce46b99
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-13.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+double cos (double) __attribute__ ((const));
+double sin (double) __attribute__ ((const));
+double f(double a)
+{
+  double b;
+  double c,d;
+  double (*fp) (double) __attribute__ ((const));
+  /* Partially redundant call */
+  if (a < 2.0)
+    {
+      fp = sin;
+      c = fp (a);
+    }
+  else
+    {
+      c = 1.0; 
+      fp = cos;
+    }
+  d = fp (a);
+  return d + c;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-14.c
new file mode 100644
index 000000000..2371cfa1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-14.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+extern __SIZE_TYPE__ strlen (const char *) __attribute__ ((__pure__));
+
+void
+foo (const char *str)
+{
+  __SIZE_TYPE__ a = strlen (str);
+  __SIZE_TYPE__ b = strlen (str);
+  if (a != b)
+    link_error ();
+}
+/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-15.c
new file mode 100644
index 000000000..518fda854
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-15.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+/* Verify we PRE the strlen call, as strlen("") folds to zero.  */
+
+extern __SIZE_TYPE__ strlen (const char *);
+
+__SIZE_TYPE__ mystrlen (const char *s)
+{
+  if (!s)
+    s = "";
+  return strlen(s);
+}
+
+/* { dg-final { scan-tree-dump "= 0;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-16.c
new file mode 100644
index 000000000..b087dc1b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-16.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats -std=c99" } */
+int foo(int k, int *x)
+{
+  int j=0;
+  int res = 0;
+  /* We should pull res = *x all the way out of the do-while */
+  do {
+    for (int n=0;n<3;++n);
+    res = *x;
+  }  while (++j<k);
+  return res;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-17.c
new file mode 100644
index 000000000..d4274dbe0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-17.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+typedef union {
+  int i;
+  float f;
+} U;
+
+int foo(U *u, int b, int i)
+{
+  u->i = 0;
+  if (b)
+    u->i = i;
+  return u->i;
+}
+
+/* { dg-final { scan-tree-dump "Eliminated: 1" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-18.c
new file mode 100644
index 000000000..5e92934f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-18.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-details" } */
+
+struct Bar { int a; int b; };
+struct Foo { int x; struct Bar y; };
+
+int __attribute__((const)) foo (struct Bar);
+
+int bar (int b)
+{
+  struct Foo f;
+  int c;
+  while (b--)
+    {
+      c = foo(f.y);
+    }
+  return c;
+}
+
+/* { dg-final { scan-tree-dump "Replaced foo \\(f.y\\)" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-19.c
new file mode 100644
index 000000000..0fd0dc542
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-19.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+struct Loc {
+    int x[3];
+};
+
+void bar (struct Loc *);
+
+int foo (int i, int j, int k, int b)
+{
+  struct Loc IND;
+  int res;
+
+  if (b)
+    {
+      IND.x[0] = i;
+      IND.x[1] = j;
+      IND.x[2] = k-1;
+    }
+  else
+    {
+      IND.x[0] = i;
+      IND.x[1] = j;
+      IND.x[2] = k;
+    }
+
+  /* This should be optimized to i + j + {k, k + 1}.  */
+  res = IND.x[0] + IND.x[1] + IND.x[2];
+
+  /* This is just to prevent SRA.  */
+  bar (&IND);
+
+  return res;
+}
+
+/* All three loads should be eliminated.  */
+/* { dg-final { scan-tree-dump "Eliminated: 3" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-2.c
new file mode 100644
index 000000000..38380d3d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int motion_test1(int data, int data_0, int data_3, int v)
+{
+	int i;
+	int t, u;
+
+	if (data)
+		i = data_0 + data_3;
+	else {
+		v = 2;
+		i = 5;
+	}
+	t = data_0 + data_3;
+	u = i;
+	return v * t * u;
+}
+/* We should eliminate one computation of data_0 + data_3 along the 
+   main path, and one computation of v * i along the main path, causing 
+   two eliminations. */
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-20.c
new file mode 100644
index 000000000..6361b679c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-20.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+double pcheck;
+
+void foo(int n, int m, int b)
+{
+  int i, j;
+
+  goto bb18;
+
+start:
+  i = 1;
+  do {
+    j = 1;
+    do {
+      double x = pcheck;
+      x = x + 1;
+      pcheck = x;
+      j = j + 1;
+    } while (j != m);
+    i = i + 1;
+  } while (i != n);
+
+bb18:
+  pcheck = 0.0;
+  goto start;
+}
+
+/* We should have inserted two PHI nodes and the one in the i-loop
+   should have 0.0 in the argument coming from the bb18 block.  */
+
+/* { dg-final { scan-tree-dump "New PHIs: 2" "pre" } } */
+/* { dg-final { scan-tree-dump "PHI <.*0\\\.0" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-21.c
new file mode 100644
index 000000000..65a73d2a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-21.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre" } */
+
+long
+NumSift (long *array, unsigned long k)
+{
+  if (array[k] < array[k + 1L])
+    ++k;
+  return array[k];
+}
+
+/* There should be only two loads left.  */
+
+/* { dg-final { scan-tree-dump-times "= \\\*D" 2 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-22.c
new file mode 100644
index 000000000..3a1697e6c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-22.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+int foo (int i, int b)
+{
+  int j = 1;
+  if (b)
+    j = i;
+  return j - i;
+}
+
+/* { dg-final { scan-tree-dump "Eliminated: 1" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-26.c
new file mode 100644
index 000000000..65c75ede3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-26.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-Os -fdump-tree-pre-details" } */
+
+typedef union
+{
+  int* data;
+} SA;
+
+typedef struct
+{
+  int reserved;
+  char* array;
+}SB;
+
+typedef struct
+{
+  int status;
+}SC;
+
+void foo(SA* pResult, SB* method, SC* self)
+{
+  if (method->array[0] == 'L' && !self->status && pResult->data != 0)
+    pResult->data = pResult->data;
+}
+
+/* { dg-final { scan-tree-dump "Deleted dead store" "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-3.c
new file mode 100644
index 000000000..3925f7529
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-3.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+unsigned foo1 (unsigned a, unsigned b)
+{
+  unsigned i, j, k;
+  for (i = 0; i != a; i++)
+    {
+      j += 4*b;
+      k += 4*a;
+    }
+  return j + k;
+}
+/* We should eliminate both 4*b and 4*a from the main body of the loop */
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-4.c
new file mode 100644
index 000000000..6f4c2f3a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-4.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(void)
+{
+	int x, c, y;
+	x = 3;
+	if (c)
+		x = 2;
+	y = x + 1;
+	return y;
+}
+/* We should eliminate the x+1 computation from this routine, replacing
+   it with a phi of 3, 4 */
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-5.c
new file mode 100644
index 000000000..8756944b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-5.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int 
+foo (int i)
+{
+	int a, b;
+	if (i)
+		a = 3, b = 2;
+	else
+		a = 2, b = 3;
+	return a + b;
+}
+/* We should detect that a+b is the same along both edges, and replace it with
+   5  */
+/* { dg-final { scan-tree-dump-times "Constified: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-6.c
new file mode 100644
index 000000000..a639e9dff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-6.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int x)
+{
+	int c, y;
+	if (c)
+		x = 2;
+	y = x + 1;
+	return y;
+}
+/* We should eliminate one evaluation of x + 1 along the x = 2 path,
+   causing one elimination.  */
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-7.c
new file mode 100644
index 000000000..c87f62e69
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-7.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-fre-stats" } */
+int
+foo (int *array)
+{
+    if (array[1] != 0)
+          return array[1];
+      return 0;
+}
+/* We should eliminate one address calculation, and one load.  */
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-8.c
new file mode 100644
index 000000000..ae933bbcc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-8.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-fre-stats" } */
+struct s {
+      int *n;
+};
+
+int
+foo (__SIZE_TYPE__ i, struct s *array)
+{
+  int *p = array[i].n;
+  if (p)
+    {
+      int *q = array[i].n;
+      if (p != q)
+	return 1;
+    }
+  return 0;
+}
+/* We should eliminate two address calculations, and one load.  */
+/* We used to eliminate a cast but that was before POINTER_PLUS_EXPR
+   was added.  */
+/* { dg-final { scan-tree-dump-times "Eliminated: 3" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-9.c
new file mode 100644
index 000000000..30d968b7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-9.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fno-tree-dominator-opts -fdump-tree-fre-stats" } */
+int
+foo (unsigned long a)
+{
+  int b = __builtin_clzl (a);
+  int c = __builtin_clzl (a);
+  if (b == c)
+    return 1;
+  return 0;
+}
+/* { dg-final { scan-tree-dump-times "return 0;" 0 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-1.c
new file mode 100644
index 000000000..263124b64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-fre-stats" } */
+
+void vnum_test8(int *data) 
+{ 
+  int i; 
+  int stop = data[3]; 
+  int m = data[4]; 
+  int n = m; 
+  for (i=0; i<stop; i++) { 
+    int k = data[2]; 
+    data[k] = 2; 
+    data[0] = m - n; 
+    k = data[1]; 
+    m = m + k; 
+    n = n + k; 
+  } 
+} 
+/* We should eliminate m - n, and set n = n + k into n = m. */
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-2.c
new file mode 100644
index 000000000..2c73a678b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-fre-stats" } */
+
+int vnum_test8(int *data) 
+{ 
+  int i; 
+  int stop = data[3]; 
+  int m = data[4]; 
+  int n = m; 
+  int p;
+  for (i=0; i<stop; i++) { 
+    int k = data[2]; 
+    data[k] = 2; 
+    data[0] = m - n; 
+    k = data[1]; 
+    m = m + k; 
+    n = n + k;
+    p = data[0]; 
+  } 
+  return p;
+} 
+/* We should eliminate m - n, and set n = n + k into n = m, and
+   set p to 0 */
+/* { dg-final { scan-tree-dump-times "Eliminated: 3" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-3.c
new file mode 100644
index 000000000..b80a8dc3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-3.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-fre-stats" } */
+int main(int argc, char **argv)
+{
+  int *p;
+  int result;
+  *p = 2;
+  if (argc)
+    *p = 2;
+  result = *p;
+  return result;
+}
+/* We should eliminate result = *p by saying it has the value 2.  */
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-4.c
new file mode 100644
index 000000000..7caf4eec6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sccvn-4.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-fre-stats" } */
+
+int vnum_test8(int *data) 
+{ 
+  int i; 
+  int stop = data[3]; 
+  int m = data[4]; 
+  int n = m; 
+  int p = 0;
+
+  for (i=0; i<stop; i++) { 
+    int k = data[2]; 
+    data[5] = 0;
+    if (i < 30)
+      data[5] = m - n;
+    p = data[5];
+    k = data[1]; 
+    m = m + k; 
+    n = n + k; 
+  } 
+  return p;
+} 
+/* We should eliminate m - n, n + k, set data[5] = 0, eliminate the
+   address arithmetic for data[5], and set p = 0.
+/* { dg-final { scan-tree-dump-times "Eliminated: 5" 1 "fre"} } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-1.c
new file mode 100644
index 000000000..c3326d27e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-1.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-sink-stats" } */
+int
+foo (int a, int b, int c)
+{
+  int x = a * b;
+  return c ? x : a;
+}
+/* We should sink the x = a * b calculation into the branch that returns x. */
+/* { dg-final { scan-tree-dump-times "Sunk statements: 1" 1 "sink" } } */
+/* { dg-final { cleanup-tree-dump "sink" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-2.c
new file mode 100644
index 000000000..1d54d019e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-sink-stats" } */
+int
+bar (int a, int b, int c)
+{
+  int y = a * b;
+  if (c)
+    y = 12;
+  return y;
+}
+/* We should sink the x = a * b calculation into the else branch  */
+/* { dg-final { scan-tree-dump-times "Sunk statements: 1" 1 "sink" } } */
+/* { dg-final { cleanup-tree-dump "sink" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-3.c
new file mode 100644
index 000000000..fceb509e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-sink-stats" } */
+extern void foo(int a);
+int
+main (int argc)
+{
+  int a;
+  a = argc + 1;
+  if (argc + 3)
+    {
+      foo (a);
+    }
+}
+/* We should sink the a = argc + 1 calculation into the if branch  */
+/* { dg-final { scan-tree-dump-times "Sunk statements: 1" 1 "sink" } } */
+/* { dg-final { cleanup-tree-dump "sink" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-4.c
new file mode 100644
index 000000000..6e1cc50dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */ 
+/* { dg-options "-O2 -fdump-tree-sink-stats" } */
+extern int foo (int *, int *);
+extern int foo2 (int);
+int
+main (int argc)
+{
+  int a, b, c;
+  b = argc + 1;
+  c = argc + 2;
+  a = b + c;
+  if (argc)
+    {
+      foo (&b, &c);
+      a = b + c;
+    }
+  foo2 (a);
+}
+/* We should sink the first a = b + c calculation into the else branch  */
+/* { dg-final { scan-tree-dump-times "Sunk statements: 1" 1 "sink" } } */
+/* { dg-final { cleanup-tree-dump "sink" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-5.c
new file mode 100644
index 000000000..f11a28a37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-5.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Os -fdump-tree-sink-stats" } */
+
+typedef short int16_t;
+typedef unsigned char uint8_t;
+
+void foo(int16_t runs[], uint8_t alpha[], int x, int count)
+{
+    int16_t* next_runs = runs + x;
+    uint8_t*  next_alpha = alpha + x;
+
+    while (x > 0)
+    {
+        int n = runs[0];
+
+        if (x < n)
+        {
+            alpha[x] = alpha[0];
+            runs[0] = (int16_t)(x);
+            runs[x] = (int16_t)(n - x);
+            break;
+        }
+        runs += n;
+        alpha += n;
+        x -= n;
+    }
+
+    runs = next_runs;
+    alpha = next_alpha;
+    x = count;
+
+   for (;;)
+    {
+        int n = runs[0];
+
+        if (x < n)
+        {
+            alpha[x] = alpha[0];
+            break;
+        }
+        x -= n;
+        runs += n;
+   }
+}
+
+/* We should not sink the next_runs = runs + x calculation after the loop.  */
+/* { dg-final { scan-tree-dump-times "Sunk statements:" 0 "sink" } } */
+/* as{ asdg-asfinal { cleanup-tree-dump "sink" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-1.c
new file mode 100644
index 000000000..aaa3d13ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+static const int conststaticvariable;
+
+int f(void)
+{
+  return conststaticvariable;
+}
+
+/* There should be no reference to conststaticvariable as we should have
+   inlined the 0. */
+/* { dg-final { scan-tree-dump-times "conststaticvariable" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-2.c
new file mode 100644
index 000000000..be37a21d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-2.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+const int conststaticvariable;
+
+int f(void)
+{
+  return conststaticvariable;
+}
+
+/* There should be a reference to conststaticvariable since it may
+   may be overriden at link time.  */
+/* { dg-final { scan-tree-dump-times "conststaticvariable" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-3.c
new file mode 100644
index 000000000..fd6b7c812
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-3.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* Skipped on MIPS GNU/Linux and IRIX target because __PIC__ can be
+   defined for executables as well as shared libraries.  */
+/* { dg-skip-if "" { *-*-darwin* hppa*64*-*-* mips*-*-linux* mips*-*-irix* } { "*" } { "" } } */
+/* { dg-options "-O2 -fno-common -fdump-tree-optimized" } */
+
+const int conststaticvariable;
+
+int f(void)
+{
+  return conststaticvariable;
+}
+
+/* There should be no reference for nonpic targets to
+   conststaticvariable as we should have inlined the 0. */
+/* { dg-final { scan-tree-dump-times "conststaticvariable" 0 "optimized" { target nonpic } } } */
+/* { dg-final { scan-tree-dump-times "conststaticvariable" 1 "optimized" { target { ! nonpic } } } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-4.c
new file mode 100644
index 000000000..571fc02a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/ssa-store-ccp-4.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target fpic } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-options "-O2 -fno-common -fpic -fdump-tree-optimized" } */
+
+const int conststaticvariable;
+
+int f(void)
+{
+  return conststaticvariable;
+}
+
+/* There should be a reference to conststaticvariable since it may
+   may be overriden at run time.  */
+/* { dg-final { scan-tree-dump-times "conststaticvariable" 1 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-1.c
new file mode 100644
index 000000000..3cba2928f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-stdarg" } */
+
+#include <stdarg.h>
+
+/* This can be handled on all arches.  If there is no va_start, registers don't need
+   to be saved.  */
+void
+f1 (int i, ...)
+{
+}
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" } } */
+/* { dg-final { cleanup-tree-dump "stdarg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-2.c
new file mode 100644
index 000000000..6b4783c53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-2.c
@@ -0,0 +1,298 @@
+/* First dg-final line after each function is for architectures that use
+   a struct {...} va_list[1] with separate GPR and FPR counters in the
+   structure.  Second dg-final line is for architectures that use void *
+   or char * va_list.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-stdarg" } */
+
+#include <stdarg.h>
+
+extern void foo (int, va_list);
+extern void bar (int);
+long x;
+double d;
+va_list gap;
+va_list *pap;
+
+void
+f1 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f2 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  bar (d);
+  x = va_arg (ap, long);
+  bar (x);
+  va_end (ap);
+}
+/* Assume the counters can be number of registers or bytes on 32-bit
+   architecture or bytes on 64-bit architecture.  */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save \[148\] GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save \[148\] GPR units and 0 FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save 8 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save 1 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f3 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  d = va_arg (ap, double);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 0 GPR units and 1 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 8 GPR units and 2" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[1-9\]\[0-9\]* GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[1-9\]\[0-9\]* GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[1-9\]\[0-9\]* GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f4 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  x = va_arg (ap, double);
+  foo (i, ap);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f5 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  va_copy (gap, ap);
+  bar (i);
+  va_end (ap);
+  va_end (gap);
+}
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f6 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  bar (d);
+  va_arg (ap, long);
+  va_arg (ap, long);
+  x = va_arg (ap, long);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save (3|12|24) GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save (3|12|24) GPR units and 0 FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save 24 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save 3 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save (3|12|24) GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save (3|12|24) GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save (3|12|24) GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f7 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  pap = &ap;
+  bar (6);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f8 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  pap = &ap;
+  bar (d);
+  x = va_arg (ap, long);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f9 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  __asm __volatile ("" : "=r" (pap) : "0" (&ap));
+  bar (6);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f9: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f10 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  __asm __volatile ("" : "=r" (pap) : "0" (&ap));
+  bar (d);
+  x = va_arg (ap, long);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f11 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  bar (d);
+  x = va_arg (ap, long);
+  x += va_arg (ap, long);
+  x += va_arg (ap, long);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save (3|12|24) GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save (3|12|24) GPR units and 0 FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save 24 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save 3 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save (3|12|24) GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save (3|12|24) GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 0, needs to save (3|12|24) GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f12 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  bar (d);
+  va_arg (ap, double);
+  va_arg (ap, double);
+  x = va_arg (ap, double);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save 24 GPR units and 2" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save 0 GPR units and 3 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f13 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  bar (d);
+  x = va_arg (ap, double);
+  x += va_arg (ap, double);
+  x += va_arg (ap, double);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save 24 GPR units and 2" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save 0 GPR units and 3 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f13: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f14 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  bar (d);
+  x = va_arg (ap, double);
+  x += va_arg (ap, long);
+  x += va_arg (ap, double);
+  bar (x);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save \[148\] GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save \[148\] GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save 24 GPR units and 3" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save 1 GPR units and 2 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f14: va_list escapes 0, needs to save \[1-9]\[0-9\]* GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+inline void __attribute__((always_inline))
+f15_1 (va_list ap)
+{
+  x = va_arg (ap, double);
+  x += va_arg (ap, long);
+  x += va_arg (ap, double);
+}
+
+void
+f15 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  f15_1 (ap);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f15: va_list escapes 0, needs to save \[148\] GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f15: va_list escapes 0, needs to save \[148\] GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f15: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f15: va_list escapes 0, needs to save 1 GPR units and 2 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump-not "f15: va_list escapes 0, needs to save 0 GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump-not "f15: va_list escapes 0, needs to save 0 GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump-not "f15: va_list escapes 0, needs to save 0 GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+/* { dg-final { cleanup-tree-dump "stdarg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-3.c
new file mode 100644
index 000000000..9ffbe3fae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-3.c
@@ -0,0 +1,193 @@
+/* First dg-final line after each function is for architectures that use
+   a struct {...} va_list[1] with separate GPR and FPR counters in the
+   structure.  Second dg-final line is for architectures that use void *
+   or char * va_list.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-stdarg" } */
+
+#include <stdarg.h>
+
+extern void foo (int, va_list);
+extern void bar (int);
+long x;
+va_list gap;
+
+/* If va_list is not local variable, it escapes the function.  */
+void
+f1 (int i, ...)
+{
+  va_start (gap, i);
+  x = va_arg (gap, long);
+  va_end (gap);
+}
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f2 (int i, ...)
+{
+  va_start (gap, i);
+  bar (i);
+  va_end (gap);
+}
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+/* tree-stdarg.c only handles va_list variables, not arrays of them or
+   va_list fields embedded in structures.  */
+void
+f3 (int i, ...)
+{
+  va_list aps[10];
+  va_start (aps[4], i);
+  x = va_arg (aps[4], long);
+  va_end (aps[4]);
+}
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f4 (int i, ...)
+{
+  va_list aps[10];
+  va_start (aps[4], i);
+  bar (i);
+  va_end (aps[4]);
+}
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f5 (int i, ...)
+{
+  va_list aps[10];
+  va_start (aps[4], i);
+  foo (i, aps[4]);
+  va_end (aps[4]);
+}
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+struct A { int i; va_list g; va_list h[2]; };
+
+void
+f6 (int i, ...)
+{
+  struct A a;
+  va_start (a.g, i);
+  x = va_arg (a.g, long);
+  va_end (a.g);
+}
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f7 (int i, ...)
+{
+  struct A a;
+  va_start (a.g, i);
+  bar (i);
+  va_end (a.g);
+}
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f8 (int i, ...)
+{
+  struct A a;
+  va_start (a.g, i);
+  foo (i, a.g);
+  va_end (a.g);
+}
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f8: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f10 (int i, ...)
+{
+  struct A a;
+  va_start (a.h[1], i);
+  x = va_arg (a.h[1], long);
+  va_end (a.h[1]);
+}
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f10: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f11 (int i, ...)
+{
+  struct A a;
+  va_start (a.h[1], i);
+  bar (i);
+  va_end (a.h[1]);
+}
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f11: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f12 (int i, ...)
+{
+  struct A a;
+  va_start (a.h[1], i);
+  foo (i, a.h[1]);
+  va_end (a.h[1]);
+}
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f12: va_list escapes 1, needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+/* { dg-final { cleanup-tree-dump "stdarg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-4.c
new file mode 100644
index 000000000..d0e47e18b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-4.c
@@ -0,0 +1,94 @@
+/* First dg-final line after each function is for architectures that use
+   a struct {...} va_list[1] with separate GPR and FPR counters in the
+   structure.  Second dg-final line is for architectures that use void *
+   or char * va_list.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-stdarg" } */
+
+#include <stdarg.h>
+
+extern void foo (int, va_list);
+extern void bar (int);
+long x;
+double d;
+
+/* Here va_arg can be executed more than once for one va_start.  All GPR
+   registers needs to be saved.  */
+void
+f1 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  while (i-- > 0)
+    x = va_arg (ap, long);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save all GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save all GPR units and 0 FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save all GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save all GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes \[01\], needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes \[01\], needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes \[01\], needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f2 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  while (i-- > 0)
+    d = va_arg (ap, double);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save 0 GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save 0 GPR units and all FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save all GPR units and 2" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save 0 GPR units and all FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes \[01\], needs to save all GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes \[01\], needs to save all GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes \[01\], needs to save all GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+/* Here va_arg can be executed at most as many times as va_start.
+   Only one GPR needs to be saved.  */
+void
+f3 (int i, ...)
+{
+  va_list ap;
+  int j = i;
+  while (j-- > 0)
+    {
+      va_start (ap, i);
+      x = va_arg (ap, long);
+      va_end (ap);
+      bar (x);
+    }
+}
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[148\] GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[148\] GPR units and 0 FPR units" "stdarg" { target { powerpc*-*-linux* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 8 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 1 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+
+void
+f4 (int i, ...)
+{
+  va_list ap;
+  int j = i;
+  while (j-- > 0)
+    {
+      va_start (ap, i);
+      d = va_arg (ap, double);
+      va_end (ap);
+      bar (d + 2.5);
+    }
+}
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 0 GPR units and \[1-9\]\[0-9\]* FPR units" "stdarg" { target { powerpc*-*-linux* && { powerpc_fprs && ilp32 } } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 8 GPR units and 2" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 0 GPR units and 1 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target ia64-*-* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save \[148\] GPR units" "stdarg" { target { powerpc*-*-* && lp64 } } } } */
+/* { dg-final { cleanup-tree-dump "stdarg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-5.c
new file mode 100644
index 000000000..08f278725
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/stdarg-5.c
@@ -0,0 +1,119 @@
+/* This test has architecture specific function passing details.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-stdarg" } */
+
+#include <stdarg.h>
+
+extern void foo (int, va_list);
+extern void bar (int);
+struct S1 { int i; double d; int j; double e; } s1;
+struct S2 { double d; long i; } s2;
+int y;
+_Complex int ci;
+_Complex double cd;
+
+/* Here va_arg can be executed more than once for one va_start.  */
+void
+f1 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  while (i-- > 0)
+    s1 = va_arg (ap, struct S1);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save all GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f1: va_list escapes 0, needs to save all GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+
+void
+f2 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  while (i-- > 0)
+    s2 = va_arg (ap, struct S2);
+  va_end (ap);
+}
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save all GPR units and all FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save all GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f2: va_list escapes 0, needs to save all GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+
+/* Here va_arg can be executed at most as many times as va_start.  */
+void
+f3 (int i, ...)
+{
+  va_list ap;
+  int j = i;
+  while (j-- > 0)
+    {
+      va_start (ap, i);
+      s1 = va_arg (ap, struct S1);
+      va_end (ap);
+      bar (s1.i);
+    }
+}
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 0 GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 32 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f3: va_list escapes 0, needs to save 1 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+
+void
+f4 (int i, ...)
+{
+  va_list ap;
+  int j = i;
+  while (j-- > 0)
+    {
+      va_start (ap, i);
+      s2 = va_arg (ap, struct S2);
+      y = va_arg (ap, int);
+      va_end (ap);
+      bar (s2.i);
+    }
+}
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 16 GPR units and 16 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 24 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f4: va_list escapes 0, needs to save 2 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+
+void
+f5 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  ci = va_arg (ap, _Complex int);
+  ci += va_arg (ap, _Complex int);
+  va_end (ap);
+  bar (__real__ ci + __imag__ ci);
+}
+/* { dg-final { scan-tree-dump "f5: va_list escapes 0, needs to save 16 GPR units and 0 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 0, needs to save 32 GPR units and 1" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f5: va_list escapes 0, needs to save (4|2) GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+
+void
+f6 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  ci = va_arg (ap, _Complex int);
+  cd = va_arg (ap, _Complex double);
+  va_end (ap);
+  bar (__real__ ci + __imag__ cd);
+}
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save 8 GPR units and 32 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save 32 GPR units and 3" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f6: va_list escapes 0, needs to save (3|2) GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+
+void
+f7 (int i, ...)
+{
+  va_list ap;
+  va_start (ap, i);
+  cd = va_arg (ap, _Complex double);
+  cd += va_arg (ap, _Complex double);
+  va_end (ap);
+  bar (__real__ cd + __imag__ cd);
+}
+/* { dg-final { scan-tree-dump "f7: va_list escapes 0, needs to save 0 GPR units and 64 FPR units" "stdarg" { target { { i?86-*-* x86_64-*-* } && lp64 } } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 0, needs to save 32 GPR units and 2" "stdarg" { target alpha*-*-linux* } } } */
+/* { dg-final { scan-tree-dump "f7: va_list escapes 0, needs to save 2 GPR units and 0 FPR units" "stdarg" { target s390*-*-linux* } } } */
+/* { dg-final { cleanup-tree-dump "stdarg" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/struct-aliasing-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/struct-aliasing-1.c
new file mode 100644
index 000000000..78e92d769
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/struct-aliasing-1.c
@@ -0,0 +1,15 @@
+/* { dg-do "compile" } */
+/* { dg-options "-O2 -fdump-tree-fre" } */
+
+struct S { float f; };
+int __attribute__((noinline))
+foo (float *r, struct S *p)
+{
+  int *q = (int *)&p->f;
+  int i = *q;
+  *r = 0.0;
+  return i + *q;
+}
+
+/* { dg-final { scan-tree-dump-times "\\\*q" 1 "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/struct-aliasing-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/struct-aliasing-2.c
new file mode 100644
index 000000000..aa9e142bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/struct-aliasing-2.c
@@ -0,0 +1,18 @@
+/* { dg-do "compile" } */
+/* { dg-options "-O2 -fdump-tree-fre" } */
+
+struct S { unsigned f; };
+
+int
+foo ( struct S *p)
+{
+  int *q = (int *)&p->f;
+  int i = *q;
+  return i + p->f;
+}
+
+
+/*  There should only be one load of p->f because fwprop can change *(int *)&p->f into just (int)p->f.  */
+/* { dg-final { scan-tree-dump-times "p_.\\\(D\\\)->f" 1 "fre" } } */
+/* { dg-final { cleanup-tree-dump "fre" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-1.c
new file mode 100644
index 000000000..bc69c4fe0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-lim-details" } */
+int x; int y;
+struct { int x; int y; } global;
+int foo() {
+	int i;
+	for ( i=0; i<10; i++)
+		y += x*x;
+	for ( i=0; i<10; i++)
+		global.y += global.x*global.x;
+}
+
+/* { dg-final { scan-tree-dump-times "Executing store motion of global.y" 1 "lim" } } */
+/* XXX: We should also check for the load motion of global.x, but there is no easy way to do this.  */
+/* { dg-final { cleanup-tree-dump "lim" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-2.c
new file mode 100644
index 000000000..b4d28257e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-2.c
@@ -0,0 +1,46 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized -fno-tree-sra" } */
+
+/* Even without SRA being enabled, we should be able to eliminate every structure store and load here. */
+extern void foo (const int);
+int main(void)
+{
+	struct a
+	{
+		int e;
+		int f;
+		int g;
+	}  a;
+	struct a b;
+	int x, c;
+	a.e = 50;
+	a.f = 9;
+	a.g = a.e * a.f;
+	foo (a.f);
+	foo (a.g);
+	x = a.f;
+	c = a.e;
+	foo (x);
+	foo (c);
+	a.e = 5;
+	a.f = 40;
+	a.g = 90;
+	foo (a.e);
+	foo (a.f);
+	foo (a.g);
+	c = a.f;
+	foo (c);
+	b.e = 9;
+	a.e = b.e + 1 * c;
+	a.f = 30;
+	foo (a.e);
+	foo (a.f);
+	x = a.e * a.f;
+	foo (x);
+
+}
+/* { dg-final { scan-tree-dump-times "a.e" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "a.f" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "a.g" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times "b.e" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-3.c
new file mode 100644
index 000000000..a7fcb5bf8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/structopt-3.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+struct foo
+{
+	int a;
+	int b;
+} temp;
+/* We should be able to optimize this to return 11. */
+int main(void)
+{
+	temp.a = 5;
+	temp.b = 6;
+	return temp.a + temp.b;
+}
+/* { dg-final { scan-tree-dump-times "return 11" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-1.c
new file mode 100644
index 000000000..422ee2d7b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-tailc-details" } */
+extern void *alloca (__SIZE_TYPE__);
+int q(int a);
+int *v;
+int
+t(int a)
+{
+	int r,r1;
+	if (a)
+		r1=r = q(a-1);
+	else
+		return 0;
+	/* Dead alloca should not disturb us.  */
+	if (r!=r1)
+		v=alloca(r);
+	return r;
+}
+/* { dg-final { scan-tree-dump-times "Found tail call" 1 "tailc"} } */
+/* { dg-final { cleanup-tree-dump "tailc" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-2.c
new file mode 100644
index 000000000..bd9a85354
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-2.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-tailc-details" } */
+/* Test provided by Richard Earnshaw in PR 14312.  */
+
+void bar (int i);
+void baz (int *);
+
+void
+foo (int *x)
+{
+  if (*x < 0)
+    {
+      baz (x);
+      return;
+    }
+  bar (*x);
+}
+
+/* The test has no local call-clobbered variables.  Only the memory
+   tag for 'x' is call-clobbered.  And since tags are not real
+   variables, they ought to be ignored.  There should be two tail
+   calls here.  */
+/* { dg-final { scan-tree-dump-times "Found tail call" 2 "tailc"} } */
+/* { dg-final { cleanup-tree-dump "tailc" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-3.c
new file mode 100644
index 000000000..4055bc3f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-3.c
@@ -0,0 +1,28 @@
+/* The return argument needs a type conversion which on some targets
+   (e.g. s390) needs additional code.  So it is invalid to do tail
+   call optimization here.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+long long __attribute__((noinline))
+foo ()
+{
+  return 3;
+}
+
+int __attribute__((noinline))
+boo ()
+{
+  return foo ();
+}
+
+int
+main ()
+{
+  if (boo () != 3)
+    abort ();
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-4.c
new file mode 100644
index 000000000..e7983da31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailcall-4.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-tailc-details" } */
+/* PR tree-opt/37024 */
+
+double doubleValue();
+
+long
+longValue ()
+{
+ return (long) doubleValue ();
+}
+
+/* We should not tail call doubleValue in longValue as the mode changes. */
+/* { dg-final { scan-tree-dump-times "Found tail call" 0 "tailc"} } */
+/* { dg-final { cleanup-tree-dump "tailc" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-1.c
new file mode 100644
index 000000000..ba9a0d65e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -foptimize-sibling-calls -fdump-tree-tailr-details" } */
+int
+t(int a)
+{
+	if (a)
+		return t(a-1);
+	else
+		return 0;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated tail recursion" 1 "tailr1"} } */
+/* { dg-final { cleanup-tree-dump "tailr\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-2.c
new file mode 100644
index 000000000..b5fee4d59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -foptimize-sibling-calls -fdump-tree-tailr-details" } */
+int
+t(char *a)
+{
+	static char p[100];
+	if (a)
+		return t(p);
+	else
+		return 0;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated tail recursion" 1 "tailr1"} } */
+/* { dg-final { cleanup-tree-dump "tailr\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-3.c
new file mode 100644
index 000000000..f14140355
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -foptimize-sibling-calls -fdump-tree-tailr-details" } */
+int
+t(int a)
+{
+	int r;
+	if (a)
+		r = t(a-1);
+	else
+		return 0;
+	if (r)
+		r=r;
+	return r;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated tail recursion" 1 "tailr1"} } */
+/* { dg-final { cleanup-tree-dump "tailr\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-4.c
new file mode 100644
index 000000000..d89739f3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -foptimize-sibling-calls -fdump-tree-tailr-details" } */
+int
+t(int a)
+{
+	int r;
+	if (a&1)
+		r = t(a-1);
+	else if (a)
+		r = t(a-2);
+	else
+		return 0;
+	if (r)
+		r=r;
+	return r;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated tail recursion" 2 "tailr1"} } */
+/* { dg-final { cleanup-tree-dump "tailr\[1-2\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-5.c
new file mode 100644
index 000000000..53a2cdb15
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tailrecursion-5.c
@@ -0,0 +1,77 @@
+/* { dg-do run } */
+/* { dg-options "-O1 -foptimize-sibling-calls -fdump-tree-optimized" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int sum (int n)
+{
+  if (n == 0)
+    return 0;
+
+  return n + sum (n - 1);
+}
+
+int fac (int n)
+{
+  if (n == 0)
+    return 1;
+
+  return n * fac (n - 1);
+}
+
+int sq_sum (int n)
+{
+  if (n == 0)
+    return 0;
+
+  return n * n + sq_sum (n - 1);
+}
+
+int pow2m1 (int n)
+{
+  if (n == 0)
+    return 0;
+
+  return 2 * pow2m1 (n - 1) + 1;
+}
+
+int fib (int n)
+{
+  if (n <= 1)
+    return 1;
+
+  return fib (n - 2) + fib (n - 1);
+}
+
+int main(void)
+{
+  if (sum (5) != 15)
+    abort ();
+
+  if (fac (5) != 120)
+    abort ();
+
+  if (sq_sum (5) != 55)
+    abort ();
+
+  if (pow2m1 (5) != 31)
+    abort ();
+
+  if (fib (5) != 8)
+    abort ();
+
+  exit (0);
+}
+
+/* There is one call of sum in main and then 2 instances of the word in
+   ;; Function sum (sum) and one in the function header.  */
+/* { dg-final { scan-tree-dump-times "\\msum\\M" 4 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "\\mfac\\M" 4 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "\\msq_sum\\M" 4 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "\\mpow2m1\\M" 4 "optimized"} } */
+
+/* There is one recursive call to fib.  */
+/* { dg-final { scan-tree-dump-times "\\mfib\\M" 5 "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tree-ssa.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tree-ssa.exp
new file mode 100644
index 000000000..14225223a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/tree-ssa.exp
@@ -0,0 +1,36 @@
+#   Copyright (C) 1997,2002,2003, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/upcast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/upcast-1.c
new file mode 100644
index 000000000..12c2b91ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/upcast-1.c
@@ -0,0 +1,12 @@
+/* { do-go compile } */
+/* { dg-options "-fdump-tree-gimple" } */
+
+typedef struct { int i; } Foo;
+Foo foo;
+Foo *bar(void)
+{
+  return (Foo *)&foo.i;
+}
+
+/* { dg-final { scan-tree-dump "&foo;" "gimple" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-cunroll.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-cunroll.c
new file mode 100644
index 000000000..dafd44bb9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-cunroll.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+int a[8];
+int t()
+{
+	int i;
+	for (i = 0; i < 3; i++)
+		if (a[i])
+			break;
+	return i;
+}
+/* { dg-final { scan-tree-dump-times "Invalid sum" 0 "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-threading.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-threading.c
new file mode 100644
index 000000000..58b26e615
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-threading.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+typedef struct { unsigned short a; } A;
+
+extern void abort (void);
+extern void exit (int);
+
+void foo (unsigned int x)
+{
+  if (x != 0x800 && x != 0x810)
+    abort ();
+}
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  for (i = 0; i < 2; ++i)
+    foo (((A) { ((!(i >> 4) ? 8 : 64 + (i >> 4)) << 8) + (i << 4) } ).a);
+  exit (0);
+}
+/* { dg-final { scan-tree-dump-times "Invalid sum" 0 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-unroll-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-unroll-1.c
new file mode 100644
index 000000000..5d2e2ee18
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-unroll-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-require-effective-target ilp32 } */
+/* { dg-options "-O1 -fprefetch-loop-arrays -march=athlon -fdump-tree-aprefetch-blocks" } */
+
+int a[10000];
+
+int foo(unsigned n)
+{
+  unsigned i, s = 0;
+
+  for (i = 0; i < n; i++)
+    s += a[i];
+
+  return s;
+}
+
+/* We used to make the probability that the body of the loop (unrolled
+   to enable prefetching) is entered 0, which is not correct.  */
+
+/* { dg-final { scan-tree-dump-not "Invalid sum" "aprefetch"} } */
+/* { dg-final { scan-tree-dump "SUCC: 7 .100.0%" "aprefetch"} } */
+/* { dg-final { cleanup-tree-dump "aprefetch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-unswitch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-unswitch-1.c
new file mode 100644
index 000000000..499b78b01
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/update-unswitch-1.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -funswitch-loops -fdump-tree-unswitch-blocks" } */
+
+int bla(int p)
+{
+  unsigned i, s = 1;
+
+  for (i = 4; i < 100; i++)
+    {
+      if (p)
+	s += i/2;
+      else
+	s *= i/2;
+    }
+
+  return s;
+}
+
+/* We used to make the probability that the first of the loops created
+   by unswitching is entered 100%, which is not correct.  */
+
+/* { dg-final { scan-tree-dump-not "Invalid sum" "unswitch"} } */
+/* { dg-final { scan-tree-dump-not "SUCC: 3 .100.0%" "unswitch"} } */
+/* { dg-final { cleanup-tree-dump "unswitch" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/useless-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/useless-1.c
new file mode 100644
index 000000000..9170b7ca4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/useless-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-useless" } */
+
+void
+foo (void)
+{ 
+  int i, a; 
+  for (i = 0; i < 10; i++) 
+    { a = i; } 
+}
+
+/* There should be three gotos in the dump.  If one was removed
+   in the loop exit condition, it would be re-introduced during
+   GIMPLE lowering, at the cost of an extra statement, label,
+   and basic block.  */
+/* { dg-final { scan-tree-dump-times "goto" 3 "useless"} } */ 
+/* { dg-final { cleanup-tree-dump "useless" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-1.c
new file mode 100644
index 000000000..5b07c67a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-1.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-w -O1 -fdump-tree-gimple" } */
+
+
+/* We should be able to produce a BIT_FIELD_REF for each of these vector access. */
+#define vector __attribute__((vector_size(16)))
+float f0(vector float t)
+{
+  return ((float*)&t)[0];
+}
+
+float f1(vector float t)
+{
+  return ((float*)&t)[1];
+}
+
+float f2(vector float t)
+{
+  return ((float*)&t)[2];
+}
+
+float f3(vector float t)
+{
+  return ((float*)&t)[3];
+}
+
+
+/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 4 "gimple"} } */
+
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c
new file mode 100644
index 000000000..2ce438899
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-w -O1 -fdump-tree-final_cleanup" } */
+
+#define vector __attribute__(( vector_size(16) ))
+
+float f(vector float a, int b, vector float c)
+{
+  vector float dd = c*a;
+  a = (vector float){0,0,0,0};
+  c = (vector float){0,0,0,0};
+  {
+   float d = ((float*)&a)[0];
+   float d1 = ((float*)&c)[0];
+   return d*d1;
+  }
+}
+
+/* We should be able to optimize this to just "return 0.0;" */
+/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-times "0.0" 1 "final_cleanup"} } */
+
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-3.c
new file mode 100644
index 000000000..332e127dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vector-3.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-w -O1 -fdump-tree-final_cleanup" } */
+
+#define vector __attribute((vector_size(16) ))
+vector float a;
+
+float f(float b)
+{
+  vector float c = {0, 0, 0, 0};
+  vector float d = {0, 0, 0, 0};
+  d += c;
+  return ((float*)&c)[2];
+}
+
+/* We should be able to optimize this to just "return 0.0;" */
+/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "final_cleanup"} } */
+/* { dg-final { scan-tree-dump-times "0.0" 1 "final_cleanup"} } */
+
+/* { dg-final { cleanup-tree-dump "final_cleanup" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp01.c
new file mode 100644
index 000000000..3f8e82061
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp01.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+foo (int *p, int i)
+{
+  int x;
+
+  if (i > 10)
+    {
+      if (p)
+	{
+	  x = *p;
+	  p = 0;
+	}
+    }
+  else
+    p = 0;
+
+  /* This should be folded to if (1), but only if we insert an
+     assertion on the ELSE edge from the inner 'if (p)'.  */
+  if (p == 0)
+    return x + 1;
+
+  return i;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp02.c
new file mode 100644
index 000000000..56fca9711
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp02.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+struct A
+{
+  int a;
+  int b;
+};
+
+foo (struct A *p, struct A *q)
+{
+  int x = p->a;
+  if (p == q)
+    return q->a;
+
+  /* We should fold this to 'if (1)' but the assertion for 'p == q'
+     was overwriting the assertion 'p != 0' from the first dereference
+     of 'p'.  */
+  if (p)
+    return x + p->b;
+}
+/* Target with fno-delete-null-pointer-checks should not fold check */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 1" 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 1" 0 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp03.c
new file mode 100644
index 000000000..9b7c08256
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp03.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+struct A
+{
+  int a;
+  int b;
+};
+
+foo (struct A *p, struct A *q)
+{
+  int *r = 0;
+
+  if (p)
+    {
+      if (p == q)
+	{
+	  /* This should be folded to 'if (1)' because q is [p, p]
+	     and p is ~[0, 0].  */
+	  if (q)
+	    r = &q->a;
+
+	  /* This should be folded to 'if (1)' because q should be
+	     ~[0, 0] and thus &q->a should be ~[0, 0].  */
+	  if (r)
+	    return 5;
+	}
+    }
+
+  return q->a;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate q_.*to 1" 1 "vrp1" } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate r_.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp04.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp04.c
new file mode 100644
index 000000000..bf5d683cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp04.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+foo (int a, int b)
+{
+  if (a == b)
+    /* This should be folded to if (1)  */
+    if (a == b)
+      return a + b;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate a_.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp05.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp05.c
new file mode 100644
index 000000000..7b8b61b44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp05.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1 -fno-early-inlining" } */
+
+
+inline int ten()
+{
+  return 10;
+}
+inline int zero()
+{
+  return 0;
+}
+
+foo (int k, int j)
+{
+  if (k >= ten())
+    {
+      if (j > k)
+	{
+	  /* We should fold this to if (1).  */
+	  if (j > zero())
+	    return j;
+	}
+    }
+
+  return j+1;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate j_.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp06.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp06.c
new file mode 100644
index 000000000..1ef6c922e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp06.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+foo (int i, int j, int a)
+{
+  if (i >= 10)
+    if (i <= 30)
+      if (i == j)
+	{
+	  a--;
+
+	  /* This should fold to 'if (0)'.  */
+	  if (i < 0)
+	    i = baz ();
+
+	  /* This should fold to 'if (1)'.  */
+	  if (j > 0)
+	    a--;
+
+	  /* This should fold to 'if (0)'.  */
+	  if (i != j)
+	    return 0;
+	}
+
+  return i + a + j;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate i_.*to 0" 1 "vrp1" } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate j_.*to 1" 1 "vrp1" } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate i_.*to 0" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp07.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp07.c
new file mode 100644
index 000000000..6584919b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp07.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1-details" } */
+
+foo (int i, int *p)
+{
+  int j;
+
+  if (i > 10)
+    {
+      if (p)
+	{
+	  j = *p;
+	  /* This should be folded to if (1) because of the parent 'if
+	     (p)'.  But the dereference of p above does not need an
+	     assertion.  */
+	  if (p)
+	    return j + 1;
+	}
+    }
+  else
+    {
+      j = *p - 3;
+      /* This should be folded to if (0), because p has just been
+	 dereferenced.  But we were not inserting enough ASSERT_EXPRs
+	 to figure it out.  */
+      if (!p)
+	return j - 4;
+    }
+
+  return i;
+}
+/* Target with fno-delete-null-pointer-checks should not fold checks */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 1" 1 "vrp1" } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 0" 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 0" 0 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+
+/* { dg-final { scan-tree-dump-times "PREDICATE: p_\[0-9\]" 2 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "PREDICATE: p_\[0-9\]" 1 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp08.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp08.c
new file mode 100644
index 000000000..193199fbf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp08.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-fre -fdump-tree-vrp1-details" } */
+
+/* Compile with -fno-tree-fre -O2 to prevent CSEing *p.  */
+foo (int a, int *p)
+{
+  int x = *p + 2;
+  int y = *p - 1;
+  int z = *p + 9;
+
+  /* This should be folded to if (1), but only one ASSERT_EXPR should
+     be inserted.  */
+  if (p)
+    a = x + y + z;
+  else
+    a = x - y;
+
+  return a;
+}
+/* Target with fno-delete-null-pointer-checks should not fold checks */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 1" 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "PREDICATE: p_.* ne_expr 0" 1 "vrp1" { target { ! keeps_null_pointer_checks } } } } */
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.*to 1" 0 "vrp1" { target {   keeps_null_pointer_checks } } } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp09.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp09.c
new file mode 100644
index 000000000..9ff0f14f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp09.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+foo (int *p)
+{
+  int x = baz ();
+
+  if (p == 0)
+    goto L78;
+  else
+    {
+      x = *p;
+      /* This should be folded to if (1).  */
+      if (p)
+	x = x + 1;
+L78:
+      /* This should not be folded to if (1).  */
+      if (p)
+	{
+	  x = baz (*p);
+	  /* This should be folded to if (1).  */
+	  if (p)
+	    return x + 3;
+	}
+
+      return x - 3;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate p_.. != 0B to 1" 2 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp10.c
new file mode 100644
index 000000000..5a7458459
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp10.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+extern void abort (void);
+
+foo (int k, int j)
+{
+  if (k >= 10)
+    {
+      if (j > k)
+	{
+	  /* We should fold this to if (0).  */
+	  if (j < 10)
+	    abort ();
+	}
+    }
+
+  return j;
+}
+
+main()
+{
+  foo (10, 3);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp11.c
new file mode 100644
index 000000000..591507c22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp11.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1 -fno-early-inlining" } */
+
+inline int
+bounce (int arg)
+{
+  return arg;
+}
+
+foo (int k, int j, int z)
+{
+  if (k > z)
+    {
+      if (j > k)
+	{
+	  /* We should fold this to if (1).  */
+	  if (j > bounce (z))
+	    return j;
+	}
+    }
+
+  return j+1;
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate.*to 1" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp12.c
new file mode 100644
index 000000000..1714a561c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp12.c
@@ -0,0 +1,23 @@
+/* { dg-do link } */
+/* { dg-options -O2 } */
+
+foo (int i)
+{
+  int x;
+
+  x = i;
+  if (i < -10)
+    {
+      x = __builtin_abs (i);
+      /* VRP was incorrectly folding this to if (1).  */
+      if (x < 0)
+	link_error ();
+    }
+
+  return x;
+}
+
+main()
+{
+  foo (-30);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp13.c
new file mode 100644
index 000000000..4b3afdbc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp13.c
@@ -0,0 +1,258 @@
+/* { dg-do run }  */
+/* { dg-options -O2 }  */
+
+extern void abort (void);
+
+foo_div (int i, int j)
+{
+  int k;
+
+  /* [-INF, -1] / [1, +INF] should not give [-1, -1].  */
+  if (i <= -1)
+    if (j >= 1)
+      {
+	k = i / j;
+	if (k == -1)
+	  abort ();
+
+	return k;
+      }
+
+  /* [-20, -10] / [2, 10] should give [-10, -1].  */
+  if (i >= -20)
+    if (i <= -10)
+      if (j >= 2)
+	if (j <= 10)
+	  {
+	    k = i / j;
+	    if (k < -10)
+	      link_error ();
+	    if (k > -1)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [-20, -10] / [-10, -2] should give [1, 10].  */
+  if (i >= -20)
+    if (i <= -10)
+      if (j >= -10)
+	if (j <= -2)
+	  {
+	    k = i / j;
+	    if (k < 1)
+	      link_error ();
+	    if (k > 10)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [-20, 10] / [2, 10] should give [-10, 5].  */
+  if (i >= -20)
+    if (i <= 10)
+      if (j >= 2)
+	if (j <= 10)
+	  {
+	    k = i / j;
+	    if (k < -10)
+	      link_error ();
+	    if (k > 5)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [-20, 10] / [-10, -2] should give [-5, 10].  */
+  if (i >= -20)
+    if (i <= 10)
+      if (j >= -10)
+	if (j <= -2)
+	  {
+	    k = i / j;
+	    if (k < -5)
+	      link_error ();
+	    if (k > 10)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [10, 20] / [2, 10] should give [1, 10].  */
+  if (i >= 10)
+    if (i <= 20)
+      if (j >= 2)
+	if (j <= 10)
+	  {
+	    k = i / j;
+	    if (k < 1)
+	      link_error ();
+	    if (k > 10)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [10, 20] / [-10, -2] should give [-10, -1].  */
+  if (i >= 10)
+    if (i <= 20)
+      if (j >= -10)
+	if (j <= -2)
+	  {
+	    k = i / j;
+	    if (k > -1)
+	      link_error ();
+	    if (k < -10)
+	      link_error ();
+
+	    return k;
+	  }
+
+  abort ();
+}
+
+
+foo_mult (int i, int j)
+{
+  int k;
+
+  /* [-20, -10] * [2, 10] should give [-200, -20].  */
+  if (i >= -20)
+    if (i <= -10)
+      if (j >= 2)
+	if (j <= 10)
+	  {
+	    k = i * j;
+	    if (k < -200)
+	      link_error ();
+	    if (k > -20)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [-20, -10] * [-10, -2] should give [20, 200].  */
+  if (i >= -20)
+    if (i <= -10)
+      if (j >= -10)
+	if (j <= -2)
+	  {
+	    k = i * j;
+	    if (k < 20)
+	      link_error ();
+	    if (k > 200)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [-20, 10] * [2, 10] should give [-200, 100].  */
+  if (i >= -20)
+    if (i <= 10)
+      if (j >= 2)
+	if (j <= 10)
+	  {
+	    k = i * j;
+	    if (k < -200)
+	      link_error ();
+	    if (k > 100)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [-20, 10] * [-10, -2] should give [-100, 200].  */
+  if (i >= -20)
+    if (i <= 10)
+      if (j >= -10)
+	if (j <= -2)
+	  {
+	    k = i * j;
+	    if (k < -100)
+	      link_error ();
+	    if (k > 200)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [10, 20] * [2, 10] should give [20, 200].  */
+  if (i >= 10)
+    if (i <= 20)
+      if (j >= 2)
+	if (j <= 10)
+	  {
+	    k = i * j;
+	    if (k < 20)
+	      link_error ();
+	    if (k > 200)
+	      link_error ();
+
+	    return k;
+	  }
+
+  /* [10, 20] * [-10, -2] should give [-200, -20].  */
+  if (i >= 10)
+    if (i <= 20)
+      if (j >= -10)
+	if (j <= -2)
+	  {
+	    k = i * j;
+	    if (k < -200)
+	      link_error ();
+	    if (k > -20)
+	      link_error ();
+
+	    return k;
+	  }
+
+  abort ();
+}
+
+
+main()
+{
+  if (foo_div (-10, 5) != -2)
+    abort ();
+
+  if (foo_div (-16, 4) != -4)
+    abort ();
+
+  if (foo_div (-15, -5) != 3)
+    abort ();
+
+  if (foo_div (8, 2) != 4)
+    abort ();
+
+  if (foo_div (10, -2) != -5)
+    abort ();
+
+  if (foo_div (20, 5) != 4)
+    abort ();
+
+  if (foo_div (15, -3) != -5)
+    abort ();
+
+  if (foo_mult (-10, 5) != -50)
+    abort ();
+
+  if (foo_mult (-16, 4) != -64)
+    abort ();
+
+  if (foo_mult (-15, -5) != 75)
+    abort ();
+
+  if (foo_mult (8, 2) != 16)
+    abort ();
+
+  if (foo_mult (10, -2) != -20)
+    abort ();
+
+  if (foo_mult (20, 5) != 100)
+    abort ();
+
+  if (foo_mult (15, -3) != -45)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp14.c
new file mode 100644
index 000000000..a65d8a16d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp14.c
@@ -0,0 +1,47 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target int32plus } */
+
+struct tree_decl
+{
+  union tree_decl_u1 {
+    int f;
+    long i;
+    struct tree_decl_u1_a {
+      unsigned int align : 24;
+      unsigned int off_align : 8;
+    } a;
+  } u1;
+};
+
+extern void abort (void);
+
+unsigned int
+assemble_variable (struct tree_decl decl)
+{
+  unsigned int align;
+
+  align = decl.u1.a.align;
+
+  if (align > (1 << ((8 * 4) < 64 ? (8 * 4) - 2 : 62)))
+    align = (1 << ((8 * 4) < 64 ? (8 * 4) - 2 : 62));
+
+  /* VRP should not be propagating 0 to the RHS of this assignment.
+     But it was erroneously applying a cast operation between types of
+     different precision.  align is an unsigned int with range [0,
+     0x4000000] but the .align field holds only 24 bits.  So the cast
+     was returning a [0, 0] range.  */
+  decl.u1.a.align = align;
+
+  return decl.u1.a.align;
+}
+
+main ()
+{
+  struct tree_decl decl;
+  decl.u1.a.align = 13;
+  unsigned int x = assemble_variable (decl);
+  if (x == 0)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp15.c
new file mode 100644
index 000000000..7e7226487
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp15.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+
+extern void abort (void) __attribute__ ((__noreturn__));
+union tree_node;
+typedef union tree_node *tree;
+enum tree_code
+{
+  ERROR_MARK,
+  COND_EXPR = 42,
+};
+extern const unsigned char tree_code_length[];
+struct tree_common
+{
+  enum tree_code code:8;
+};
+union tree_node
+{
+  struct tree_common common;
+};
+void
+blah (tree t)
+{
+  if (t->common.code != COND_EXPR)
+    abort ();
+  if (1 >= tree_code_length[t->common.code])
+    abort ();
+
+}
+
+/* { dg-final { scan-tree-dump-times "tree_code_length.42." 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp16.c
new file mode 100644
index 000000000..166529ab9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp16.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1-details" } */
+
+
+extern void abort (void) __attribute__ ((__noreturn__));
+struct rtx_def;
+typedef struct rtx_def *rtx;
+struct rtx_def
+{
+  int code;
+};
+int
+nonlocal_mentioned_p (rtx x)
+{
+  if (x->code == 6 || x->code == 7)
+    if (x->code == 7)
+      if (x->code != 7)
+	abort ();
+}
+
+/* { dg-final { scan-tree-dump-times "Folding predicate .*to 0" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp17.c
new file mode 100644
index 000000000..c04b9ba78
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp17.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+extern void abort (void) __attribute__ ((__noreturn__));
+union tree_node;
+typedef union tree_node *tree;
+extern const unsigned char tree_code_length[];
+struct tree_common
+{
+  int code;
+};
+struct tree_exp
+{
+  tree operands[1];
+};
+union tree_node
+{
+  struct tree_common common;
+  struct tree_exp exp;
+};
+int
+gimplify_for_stmt (tree stmt)
+{
+  if (2 >= tree_code_length[stmt->common.code])
+    abort ();
+  if (3 >= tree_code_length[stmt->common.code])
+    abort ();
+}
+
+/* { dg-final { scan-tree-dump-times "Simplified relational" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp18.c
new file mode 100644
index 000000000..a3cc536ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp18.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+static int blocksize = 4096;
+
+int bar (int);
+
+void foo (void)
+{
+  int toread;
+  int bytes;
+  static char eof_reached = 0;
+
+  toread = blocksize;
+  bytes = 1;
+
+  while (toread != 0)
+    {
+      bytes = bar (toread);
+      if (bytes <= 0)
+        {
+          if (bytes < 0)
+            continue;
+          break;
+        }
+      toread -= bytes;
+    }
+
+  if (bytes == 0)
+    eof_reached = 1;
+}
+
+/* { dg-final { scan-tree-dump-times "Simplified relational" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp19.c
new file mode 100644
index 000000000..e4c884a85
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp19.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-fwrapv -O1 -ftree-vrp -fdump-tree-vrp1" } */
+
+#include <limits.h>
+extern void abort ();
+extern void exit (int);
+
+int f (int a) {
+	if (a != INT_MIN) {
+		a = a > 0 ? a : -a;
+		if (a < 0)
+		  return 1;
+	}
+	return 0;
+}
+
+int g (int b) {
+	if (b != INT_MIN) {
+		b = b > 0 ? b : -b;
+		if (b >= 0)
+		  return 0;
+	}
+	return 1;
+}
+/* { dg-final { scan-tree-dump "Folding predicate a_. < 0 to 0" "vrp1" } } */
+/* { dg-final { scan-tree-dump "Folding predicate b_. >= 0 to 1" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp20.c
new file mode 100644
index 000000000..14da7df48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp20.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-fwrapv -O1 -ftree-vrp -fdump-tree-vrp1" } */
+
+extern void abort ();
+extern void exit (int);
+
+int f (int a) {
+	if (a != 0) {
+		a = a > 0 ? a : -a;
+		if (a == 0)
+		  return 1;
+		return 0;
+	}
+	return 0;
+}
+
+int g (int b) {
+	if (b != 0) {
+		b = b > 0 ? b : -b;
+		if (b != 0)
+		  return 0;
+	}
+	return 1;
+}
+
+/* { dg-final { scan-tree-dump "Folding predicate a_. == 0 to 0" "vrp1" } } */
+/* { dg-final { scan-tree-dump "Folding predicate b_. != 0 to 1" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp21.c
new file mode 100644
index 000000000..9a4e4e783
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp21.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-vrp -fdump-tree-vrp1" } */
+/* { dg-require-effective-target int32plus } */
+
+extern void link_error ();
+
+void test01(unsigned int a, unsigned int b)
+{
+  unsigned int x = 0x80000000;
+  if (a < x)
+    if (b < x)
+      if (a > 5)
+        if (a + b == 0U)
+          link_error ();
+}
+
+void test02(unsigned int a, unsigned int b)
+{
+  unsigned int x = 0x80000000;
+  if (a > x)
+    if (b < x)
+      if (a - b == 1U)
+        link_error ();
+}
+
+/* { dg-final { scan-tree-dump-times "link_error" 0 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp22.c
new file mode 100644
index 000000000..cbd4dc529
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp22.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-vrp -fdump-tree-vrp1" } */
+/* { dg-require-effective-target int32plus } */
+
+extern void link_error ();
+
+void test02(unsigned int a, unsigned int b)
+{
+  unsigned int x = 0x80000000;
+  if (a > x)
+    if (b < x)
+      if (a == b)
+        link_error ();
+}
+
+/* { dg-final { scan-tree-dump-times "link_error" 0 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp23.c
new file mode 100644
index 000000000..77899a65f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp23.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1-details" } */
+
+blah (int code1, int code2)
+{
+  int i;
+  int n_sets;
+
+  n_sets = (int) (code1 == 32);
+  if (code2 == 64) goto L2; else goto L3;
+
+L2:
+  aa ();
+
+L3:
+  if (n_sets > 1) goto L4; else goto L10;
+
+L4:
+  aos ();
+  i = 0;
+  goto L24;
+
+L10:
+  if (n_sets > 0) goto L25; else goto L8;
+
+L25:
+  i = 0;
+
+L24:
+  aob ();
+  i = i + 1;
+  if (i < n_sets) goto L24; else goto L8;
+
+L8:
+  return;
+}
+
+
+
+/* The n_sets > 0 test can be simplified into n_sets == 1 since the
+   only way to reach the test is when n_sets <= 1, and the only value
+   which satisfies both conditions is n_sets == 1.  */
+/* { dg-final { scan-tree-dump-times "Simplified relational" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp24.c
new file mode 100644
index 000000000..85e5b62d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp24.c
@@ -0,0 +1,91 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1-details" } */
+
+
+struct rtx_def;
+typedef struct rtx_def *rtx;
+union rtunion_def
+{
+  rtx rt_rtx;
+};
+typedef union rtunion_def rtunion;
+struct rtx_def
+{
+  int code;
+  union u
+  {
+    rtunion fld[1];
+  } u;
+};
+
+sss (rtx insn, int code1, int code2, int code3)
+{
+  _Bool D1562;
+  struct rtx_def * body;
+  int i;
+  int n_sets;
+  int D1544;
+
+  body = insn->u.fld[5].rt_rtx;
+  D1544 = body->code;
+  n_sets = 1;
+  if (D1544 == 55) goto L7; else goto L1;
+
+L1:
+  n_sets = 0;
+  if (code3 == 99) goto L2; else goto L11;
+
+L2:
+  D1562 = code1 == 10;
+  n_sets = (int) D1562;
+  if (n_sets > 0) goto L7; else goto L11;
+
+L37:
+  if (code2 == 42) goto L8; else goto L9;
+
+L8:
+  arf ();
+
+L9:
+  i = i + 1;
+  if (i < n_sets) goto L37; else goto L32;
+
+L32:
+
+L11:
+  if (n_sets > 1) goto L12; else goto L15;
+
+L12:
+  nit ();
+
+L14:
+  i = 0;
+  goto L38;
+
+L15:
+  if (n_sets > 0) goto L14; else goto L16;
+
+L38:
+  frob ();
+  i = i + 1;
+  if (n_sets > i) goto L38; else goto L16;
+
+L16:
+  return;
+
+L7:
+  i = 0;
+  goto L37;
+
+}
+
+/* The first n_sets > 0 test can be simplfiied into n_sets == 1 since
+   n_sets can only have the values [0, 1] as it's the result of a
+   boolean operation.
+
+   The second n_sets > 0 test can also be simplified into n_sets == 1
+   as the only way to reach the tests is when n_sets <= 1 and the only
+   value which satisfies both conditions is n_sets == 1.  */
+/* { dg-final { scan-tree-dump-times "Simplified relational" 2 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp25.c
new file mode 100644
index 000000000..fa8bbfd4c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp25.c
@@ -0,0 +1,52 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1-details" } */
+
+extern void abort ();
+int tree_code_length[100];
+
+blah (int code1)
+{
+  unsigned char D18670;
+
+  if (code1 != 53) goto L0; else goto L1;
+
+L0:
+  abort ();
+
+L1:
+  D18670 = tree_code_length[53];
+  if (D18670 <= 1) goto L2; else goto L3;
+
+L2:
+  abort ();
+
+L3:
+  if (D18670 == 2) goto L4; else goto L5;
+
+L4:
+  abort ();
+
+L5:
+  arf ();
+  if (code1 != 53) goto L6; else goto L7;
+
+L6:
+  abort ();
+
+L7:
+  if (D18670 <= 2) goto L8; else goto L9;
+
+L8:
+  abort ();
+
+L9:
+  return;
+
+}
+
+/* The second test of (code1 != 53) and the test (D18670 <= 2) are
+   both totally subsumed by earlier tests and thus should be folded
+   away using VRP.  */
+/* { dg-final { scan-tree-dump-times "Folding predicate" 2 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp26.c
new file mode 100644
index 000000000..621541630
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp26.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int 
+foo(int a)
+{
+  int z = a | 1;
+  return z != 0;
+}
+
+/* VRP should optimize this to a trivial "return 1".   */
+/* { dg-final { scan-tree-dump-times "return 1" 1 "vrp1" } } * /
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp27.c
new file mode 100644
index 000000000..09b96f919
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp27.c
@@ -0,0 +1,33 @@
+/* PR middle-end/26361.  */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+void abort(void);
+
+__attribute__((noinline))
+void gen_rtx_CONST_INT(long long x) {
+    if (-x > 10)
+        abort();
+}
+__attribute__((noinline))
+int alpha_expand_prologue(long frame_size)
+{
+    unsigned long long a;
+    int probed;
+    if (frame_size <= 1)  return;
+    unsigned long long b = -2;
+    a = -2;
+    do {
+        int a1 = a;
+        probed = -a1;
+        gen_rtx_CONST_INT (a1);
+        a -= 2;
+        a1 = -a;
+        probed = a1;
+    } while (probed < frame_size);
+}
+
+int main(void) {
+    alpha_expand_prologue(10);
+    return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp28.c
new file mode 100644
index 000000000..6b2a1fd6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp28.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int f(_Bool a)
+{
+  int t = a;
+  if (t != 2)
+   return 0;
+  return 1;
+}
+
+int f1(unsigned char a)
+{
+  int t = a;
+  if (t != 256)
+   return 0;
+  return 1;
+}
+
+int f3 (unsigned char c)
+{
+  int i = c;
+  if (i < 0 || i > 255)
+    return -1;
+  else
+    return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "if " 0 "vrp1" } } * /
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp29.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp29.c
new file mode 100644
index 000000000..0a370f7d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp29.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+#include <limits.h>
+
+extern void abort(void);
+
+void decCompareOp (int result)
+{
+  if (result != (int) (INT_MAX + 1U))
+    {
+      result = -result;
+      if (result != (int) (INT_MAX + 2U))
+        abort ();
+    }
+}
+
+int main()
+{
+  decCompareOp (INT_MAX);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp30.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp30.c
new file mode 100644
index 000000000..245dcfb74
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp30.c
@@ -0,0 +1,30 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern int link_error (int);
+
+int tst2 (int x, int y)
+{
+  /* VRP should be able to extract range information for
+     x and y out of this TRUTH_AND_EXPR.  */
+  if ((x > 5555) && (y < 6666))
+    {
+      if (x > 5555)
+        if (y < 6666)
+          return 1111;
+        else
+          return link_error (2222);
+      else
+        if (y < 6666)
+          return link_error (3333);
+        else
+          return link_error (4444);
+    }
+  else
+    return 0;
+}
+
+int main()
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp31.c
new file mode 100644
index 000000000..5b4aa5db9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp31.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int f(int i)
+{
+  int t = i == 1;
+  int g = t == 2;
+  int h = g == 3;
+  return h;
+}
+
+/* { dg-final { scan-tree-dump "return 0;" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp32.c
new file mode 100644
index 000000000..a42b3ca27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp32.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int f(int i)
+{
+  _Bool t = !i;
+  int g = !t && i;
+  int h = g == 3;
+  return h;
+}
+
+/* { dg-final { scan-tree-dump "return 0;" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp33.c
new file mode 100644
index 000000000..13f60a6e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp33.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+/* This is from PR14052.  */
+
+int f2(int x) { return x == 1 || x == 3 || x == 1; }
+
+/* { dg-final { scan-tree-dump "Folding predicate.*== 1 to 0" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp34.c
new file mode 100644
index 000000000..fd92eca65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp34.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+void bar (void);
+
+void
+foo (int a)
+{
+  switch (a)
+    {
+    case 4:
+      if (a >= 3)
+        if (a <= 5)
+          bar ();
+    }
+}
+
+/* { dg-final { scan-tree-dump "Folding predicate a_. > 2 to 1" "vrp1" } } */
+/* { dg-final { scan-tree-dump "Folding predicate a_. <= 5 to 1" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp35.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp35.c
new file mode 100644
index 000000000..06b567d43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp35.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int test1(int i, int k)
+{
+  if (i > 0 && i <= 5 && k >= 10 && k < 42)
+    {
+      int j = i + 1 + k;
+      return j == 10;
+    }
+  return 1;
+}
+
+/* { dg-final { scan-tree-dump "Folding predicate j_.* == 10 to 0" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp36.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp36.c
new file mode 100644
index 000000000..9d61960c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp36.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int foo(int i)
+{
+  if (i < 0 || i >= 5)
+    return i == 1;
+  return 1;
+}
+
+/* { dg-final { scan-tree-dump "Folding predicate i_.* == 1 to 0" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp37.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp37.c
new file mode 100644
index 000000000..fba35a48b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp37.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+unsigned char x;
+int foo(void)
+{
+  unsigned long long i = x;
+  i = i + 0x80000000;
+  if (i > 0xffffffff)
+    return x;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp38.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp38.c
new file mode 100644
index 000000000..b740c6024
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp38.c
@@ -0,0 +1,21 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int __attribute__((noinline))
+foo(char c)
+{
+  unsigned short a = (unsigned short)c;
+  if (a >= -32000 && a <= 32000)
+    return c == 0;
+  return -1;
+}
+
+extern void abort (void);
+
+int main()
+{
+  if (foo(1) == 1)
+    abort ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp39.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp39.c
new file mode 100644
index 000000000..69329affb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp39.c
@@ -0,0 +1,18 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error (void);
+
+void test1(int i)
+{
+  if (i >= -5 && i <= 8)
+    {
+      unsigned int j = i;
+      if (j == -6)
+	link_error ();
+      if (j == 9)
+	link_error ();
+    }
+}
+
+int main() { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp40.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp40.c
new file mode 100644
index 000000000..23f080acf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp40.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+int f(int a) {
+    switch (a & 1) {
+      case 0:
+      case 1: return  3;
+      case 2: return  5;
+      case 3: return  7;
+      case 4: return 11;
+      case 5: return 13;
+      case 6: return 17;
+      case 7: return 19;
+    }
+}
+
+/* { dg-final { scan-tree-dump "return 3;" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp41.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp41.c
new file mode 100644
index 000000000..d573fbb0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp41.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+void bar0 (void);
+void bar1 (void);
+void bar2 (void);
+void bar3 (void);
+
+void
+foo (int a)
+{
+  if (a < 100)
+    return;
+  if (200 < a)
+    return;
+
+  switch (a)
+    {
+    case  99: bar0 (); return;
+    case 100: bar1 (); return;
+    case 101: bar2 (); return;
+    case 102: bar3 (); return;
+    }
+}
+
+/* { dg-final { scan-tree-dump-not "case 99:" "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp42.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp42.c
new file mode 100644
index 000000000..79eb22cb1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp42.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+int foo(int val)
+{
+  int tmp;
+  if ((val > 5) && (val < 8))
+    {
+      switch (val)
+        {
+        case 6:
+          tmp = 1;
+          break;
+        case 7:
+          tmp = 2;
+          break;
+        }
+      return tmp; /* { dg-bogus "used uninitialized" } */
+    }
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp43.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp43.c
new file mode 100644
index 000000000..f475354dc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp43.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+int __attribute__((noinline))
+foo(int i)
+{
+  if (i != 0)
+    {
+      char c = (char)i;
+      return c != 0;
+    }
+  return 0;
+}
+
+extern void abort (void);
+
+int main()
+{
+  if (foo(0xff00))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp44.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp44.c
new file mode 100644
index 000000000..a2df852c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp44.c
@@ -0,0 +1,30 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error (void);
+
+void test1(int i)
+{
+  if (i >= -5 && i <= 8)
+    {
+      unsigned int j = i + 1;
+      if (j == -5)
+	link_error ();
+      if (j == 10)
+	link_error ();
+    }
+}
+
+void test2(unsigned int i)
+{
+  if (i >= -5 || i <= 8)
+    {
+      int j = i;
+      if (j == -6)
+	link_error ();
+      if (j == 9)
+	link_error ();
+    }
+}
+
+int main() { return 0; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp45.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp45.c
new file mode 100644
index 000000000..7916d2da8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp45.c
@@ -0,0 +1,19 @@
+/* { dg-do link } */
+/* { dg-options "-O2" } */
+
+extern void link_error (void);
+
+void foo (int i)
+{
+  if (i > -128 && i < 127)
+    {
+      unsigned char k = i;
+      if (k == 0x80)
+        link_error ();
+      if (k == 0x7f)
+        link_error ();
+    }
+}
+
+int main() { return 0; }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp46.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp46.c
new file mode 100644
index 000000000..a67e839de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp46.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-vrp1" } */
+
+void
+func_18 ( int t )
+{
+  unsigned l_889;
+  int l_895 = 1;
+  for (0; 1; ++l_889)
+    {
+      int t1 = 0;
+      if (func_81 (1))
+	{
+	  int rhs = l_895;
+	  if (rhs == 0)
+	    rhs = 1;
+	  if (1 & (t % rhs))
+	    t1 = 1;
+	}
+      func_98 (t1);
+      l_895 = 0;
+    }
+}
+
+/* There should be a single if left.  */
+
+/* { dg-final { scan-tree-dump-times "if" 1 "vrp1" } } */
+/* { dg-final { cleanup-tree-dump "vrp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
new file mode 100644
index 000000000..d99408967
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c
@@ -0,0 +1,46 @@
+/* Skip on MIPS, where LOGICAL_OP_NON_SHORT_CIRCUIT inhibits the setcc
+   optimizations that expose the VRP opportunity.  */
+/* { dg-do compile { target { ! mips*-*-* } } } */
+/* { dg-options "-O2 -fdump-tree-vrp -fdump-tree-dom" } */
+
+int h(int x, int y)
+{
+  if ((x >= 0 && x <= 1) && (y >= 0 && y <= 1))
+    return x && y;
+  else
+    return -1;
+}
+
+int g(int x, int y)
+{
+  if ((x >= 0 && x <= 1) && (y >= 0 && y <= 1))
+    return x || y;
+  else
+    return -1;
+}
+
+int f(int x)
+{
+  if (x != 0 && x != 1)
+    return -2;
+
+  else
+    return !x;
+}
+
+/* Test that x and y are never compared to 0 -- they're always known to be
+   0 or 1.  */
+/* xfail: PR middle-end/38219  */
+/* { dg-final { scan-tree-dump-times "\[xy\]\[^ \]* !=" 0 "vrp1" { xfail powerpc*-*-* }} } */
+
+/* This one needs more copy propagation that only happens in dom1.  */
+/* xfail: PR middle-end/38219  */
+/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "dom1" { xfail powerpc*-*-* } } } */
+/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "vrp1" { xfail *-*-* } } } */
+
+/* These two are fully simplified by VRP.  */
+/* { dg-final { scan-tree-dump-times "x\[^ \]* \[|\] y" 1 "vrp1" } } */
+/* { dg-final { scan-tree-dump-times "x\[^ \]* \\^ 1" 1 "vrp1" } } */
+
+/* { dg-final { cleanup-tree-dump "vrp\[0-9\]" } } */
+/* { dg-final { cleanup-tree-dump "dom\[0-9\]" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/wholeprogram-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/wholeprogram-1.c
new file mode 100644
index 000000000..9d0af1f23
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/wholeprogram-1.c
@@ -0,0 +1,23 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fwhole-program" } */
+int b[100];
+void abort (void);
+
+void
+large_function ()
+{
+  int i;
+  for (i = 0; i < 99; i++)
+    if (b[i] / (b[i+1] + 1))
+      abort ();
+}
+
+main ()
+{
+  large_function ();
+}
+
+/* Function should be inlined as called once.  */
+/* { dg-final { scan-tree-dump-not "large_function" "optimized"} } */
+
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/wholeprogram-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/wholeprogram-2.c
new file mode 100644
index 000000000..bbdd0dd48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/tree-ssa/wholeprogram-2.c
@@ -0,0 +1,8 @@
+/* { dg-options "-O2 -fdump-tree-optimized -fwhole-program" } */
+__attribute__ ((externally_visible))
+void
+externally_visible_function ()
+{
+}
+/* { dg-final { scan-tree-dump "externally_visible_function" "optimized"} } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/trunc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/trunc-1.c
new file mode 100644
index 000000000..0d6a48b4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/trunc-1.c
@@ -0,0 +1,15 @@
+/* Origin: PR c/675 from aj@suse.de.  */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+#include <stddef.h>
+
+int
+main (void)
+{
+  size_t len;
+
+  len = ~(sizeof (size_t) - 1); /* { dg-bogus "truncated" "bogus truncation warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-init.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-init.c
new file mode 100644
index 000000000..52928da9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-init.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } // suppress default -pedantic-errors */
+
+/* This code used to be a legitimate, if dubious, extension.  However,
+   it's been broken since GCC 3.0 (caused ICE) and we have now removed
+   the extension.  See PR c/7353.  */
+
+/* Case A: just the bare name = initializer.  */
+
+typedef A = 0;  /* { dg-error "initialized" "A" } */
+A a;            /* { dg-bogus "" "A error cascade" } */
+
+/* Case B: with a type also.  */
+
+typedef int B = 0;  /* { dg-error "initialized" "B" } */
+B b;		    /* { dg-bogus "" "B error cascade" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-redecl.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-redecl.c
new file mode 100644
index 000000000..8ac5282fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-redecl.c
@@ -0,0 +1,6 @@
+/* Redeclaration of typedef (invalid but accepted in system headers)
+   causes ICE; PR 13656.  Test case by Richard Sandiford <rsandifo@redhat.com>,
+   reduced from glibc.  */
+
+#include "typedef-redecl.h"
+x a;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-redecl.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-redecl.h
new file mode 100644
index 000000000..9fa7da05d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/typedef-redecl.h
@@ -0,0 +1,7 @@
+/* Redeclaration of typedef (invalid but accepted in system headers)
+   causes ICE; PR 13656.  Test case by Richard Sandiford <rsandifo@redhat.com>,
+   reduced from glibc.  */
+
+#pragma GCC system_header
+typedef int x;
+typedef int x;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/typename-vla-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/typename-vla-1.c
new file mode 100644
index 000000000..161651312
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/typename-vla-1.c
@@ -0,0 +1,17 @@
+/* PR c/21536 */
+/* { dg-do run } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+extern void abort (void);
+extern void exit (int);
+
+int
+main (void)
+{
+  int a = 1;
+  if (sizeof (*(++a, (char (*)[a])0)) != 2)
+    abort ();
+  exit (0);
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/typeof-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/typeof-1.c
new file mode 100644
index 000000000..233b39425
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/typeof-1.c
@@ -0,0 +1,27 @@
+/* Test typeof with __asm redirection. */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern int foo1;
+extern int foo1 __asm ("bar1");
+int foo1 = 1;
+
+extern int foo2 (int);
+extern int foo2 (int) __asm ("bar2");
+int foo2 (int x)
+{
+  return x;
+}
+
+extern int foo3;
+extern __typeof (foo3) foo3 __asm ("bar3");
+int foo3 = 1;
+
+extern int foo4 (int);
+extern __typeof (foo4) foo4 __asm ("bar4");
+int foo4 (int x)
+{
+  return x;
+}
+
+// { dg-final { scan-assembler-not "foo" } }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/typespec-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/typespec-1.c
new file mode 100644
index 000000000..65736546b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/typespec-1.c
@@ -0,0 +1,937 @@
+/* Test for valid and invalid combinations of type specifiers.
+   This test covers combinations of the reserved word type specifiers
+   other than _Complex and _Imaginary, and a typedef name as the first
+   specifier only.  Within those constraints, there are no GCC extensions
+   and what is accepted should be exactly what C99 permits.  All
+   sequences are tested which do not have a shorter invalid initial
+   subsequence.  Within the given constraints, there are no valid sequences
+   with an invalid initial subsequence.
+
+   In particular, the example of PR c/4319 should be rejected unconditionally,
+   not requiring -pedantic.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef char type;
+void *x0;
+char *x1;
+short *x2;
+int *x3;
+long *x4;
+float *x5;
+double *x6;
+signed *x7;
+unsigned *x8;
+_Bool *x9;
+type *x10;
+void void *x11; /* { dg-error "" "void void" } */
+void char *x12; /* { dg-error "" "void char" } */
+void short *x13; /* { dg-error "" "void short" } */
+void int *x14; /* { dg-error "" "void int" } */
+void long *x15; /* { dg-error "" "void long" } */
+void float *x16; /* { dg-error "" "void float" } */
+void double *x17; /* { dg-error "" "void double" } */
+void signed *x18; /* { dg-error "" "void signed" } */
+void unsigned *x19; /* { dg-error "" "void unsigned" } */
+void _Bool *x20; /* { dg-error "" "void _Bool" } */
+char void *x21; /* { dg-error "" "char void" } */
+char char *x22; /* { dg-error "" "char char" } */
+char short *x23; /* { dg-error "" "char short" } */
+char int *x24; /* { dg-error "" "char int" } */
+char long *x25; /* { dg-error "" "char long" } */
+char float *x26; /* { dg-error "" "char float" } */
+char double *x27; /* { dg-error "" "char double" } */
+char signed *x28;
+char unsigned *x29;
+char _Bool *x30; /* { dg-error "" "char _Bool" } */
+short void *x31; /* { dg-error "" "short void" } */
+short char *x32; /* { dg-error "" "short char" } */
+short short *x33; /* { dg-error "" "short short" } */
+short int *x34;
+short long *x35; /* { dg-error "" "short long" } */
+short float *x36; /* { dg-error "" "short float" } */
+short double *x37; /* { dg-error "" "short double" } */
+short signed *x38;
+short unsigned *x39;
+short _Bool *x40; /* { dg-error "" "short _Bool" } */
+int void *x41; /* { dg-error "" "int void" } */
+int char *x42; /* { dg-error "" "int char" } */
+int short *x43;
+int int *x44; /* { dg-error "" "int int" } */
+int long *x45;
+int float *x46; /* { dg-error "" "int float" } */
+int double *x47; /* { dg-error "" "int double" } */
+int signed *x48;
+int unsigned *x49;
+int _Bool *x50; /* { dg-error "" "int _Bool" } */
+long void *x51; /* { dg-error "" "long void" } */
+long char *x52; /* { dg-error "" "long char" } */
+long short *x53; /* { dg-error "" "long short" } */
+long int *x54;
+long long *x55;
+long float *x56; /* { dg-error "" "long float" } */
+long double *x57;
+long signed *x58;
+long unsigned *x59;
+long _Bool *x60; /* { dg-error "" "long _Bool" } */
+float void *x61; /* { dg-error "" "float void" } */
+float char *x62; /* { dg-error "" "float char" } */
+float short *x63; /* { dg-error "" "float short" } */
+float int *x64; /* { dg-error "" "float int" } */
+float long *x65; /* { dg-error "" "float long" } */
+float float *x66; /* { dg-error "" "float float" } */
+float double *x67; /* { dg-error "" "float double" } */
+float signed *x68; /* { dg-error "" "float signed" } */
+float unsigned *x69; /* { dg-error "" "float unsigned" } */
+float _Bool *x70; /* { dg-error "" "float _Bool" } */
+double void *x71; /* { dg-error "" "double void" } */
+double char *x72; /* { dg-error "" "double char" } */
+double short *x73; /* { dg-error "" "double short" } */
+double int *x74; /* { dg-error "" "double int" } */
+double long *x75;
+double float *x76; /* { dg-error "" "double float" } */
+double double *x77; /* { dg-error "" "double double" } */
+double signed *x78; /* { dg-error "" "double signed" } */
+double unsigned *x79; /* { dg-error "" "double unsigned" } */
+double _Bool *x80; /* { dg-error "" "double _Bool" } */
+signed void *x81; /* { dg-error "" "signed void" } */
+signed char *x82;
+signed short *x83;
+signed int *x84;
+signed long *x85;
+signed float *x86; /* { dg-error "" "signed float" } */
+signed double *x87; /* { dg-error "" "signed double" } */
+signed signed *x88; /* { dg-error "" "signed signed" } */
+signed unsigned *x89; /* { dg-error "" "signed unsigned" } */
+signed _Bool *x90; /* { dg-error "" "signed _Bool" } */
+unsigned void *x91; /* { dg-error "" "unsigned void" } */
+unsigned char *x92;
+unsigned short *x93;
+unsigned int *x94;
+unsigned long *x95;
+unsigned float *x96; /* { dg-error "" "unsigned float" } */
+unsigned double *x97; /* { dg-error "" "unsigned double" } */
+unsigned signed *x98; /* { dg-error "" "unsigned signed" } */
+unsigned unsigned *x99; /* { dg-error "" "unsigned unsigned" } */
+unsigned _Bool *x100; /* { dg-error "" "unsigned _Bool" } */
+_Bool void *x101; /* { dg-error "" "_Bool void" } */
+_Bool char *x102; /* { dg-error "" "_Bool char" } */
+_Bool short *x103; /* { dg-error "" "_Bool short" } */
+_Bool int *x104; /* { dg-error "" "_Bool int" } */
+_Bool long *x105; /* { dg-error "" "_Bool long" } */
+_Bool float *x106; /* { dg-error "" "_Bool float" } */
+_Bool double *x107; /* { dg-error "" "_Bool double" } */
+_Bool signed *x108; /* { dg-error "" "_Bool signed" } */
+_Bool unsigned *x109; /* { dg-error "" "_Bool unsigned" } */
+_Bool _Bool *x110; /* { dg-error "" "_Bool _Bool" } */
+type void *x111; /* { dg-error "" "type void" } */
+type char *x112; /* { dg-error "" "type char" } */
+type short *x113; /* { dg-error "" "type short" } */
+type int *x114; /* { dg-error "" "type int" } */
+type long *x115; /* { dg-error "" "type long" } */
+type float *x116; /* { dg-error "" "type float" } */
+type double *x117; /* { dg-error "" "type double" } */
+type signed *x118; /* { dg-error "" "type signed" } */
+type unsigned *x119; /* { dg-error "" "type unsigned" } */
+type _Bool *x120; /* { dg-error "" "type _Bool" } */
+char signed void *x121; /* { dg-error "" "char signed void" } */
+char signed char *x122; /* { dg-error "" "char signed char" } */
+char signed short *x123; /* { dg-error "" "char signed short" } */
+char signed int *x124; /* { dg-error "" "char signed int" } */
+char signed long *x125; /* { dg-error "" "char signed long" } */
+char signed float *x126; /* { dg-error "" "char signed float" } */
+char signed double *x127; /* { dg-error "" "char signed double" } */
+char signed signed *x128; /* { dg-error "" "char signed signed" } */
+char signed unsigned *x129; /* { dg-error "" "char signed unsigned" } */
+char signed _Bool *x130; /* { dg-error "" "char signed _Bool" } */
+char unsigned void *x131; /* { dg-error "" "char unsigned void" } */
+char unsigned char *x132; /* { dg-error "" "char unsigned char" } */
+char unsigned short *x133; /* { dg-error "" "char unsigned short" } */
+char unsigned int *x134; /* { dg-error "" "char unsigned int" } */
+char unsigned long *x135; /* { dg-error "" "char unsigned long" } */
+char unsigned float *x136; /* { dg-error "" "char unsigned float" } */
+char unsigned double *x137; /* { dg-error "" "char unsigned double" } */
+char unsigned signed *x138; /* { dg-error "" "char unsigned signed" } */
+char unsigned unsigned *x139; /* { dg-error "" "char unsigned unsigned" } */
+char unsigned _Bool *x140; /* { dg-error "" "char unsigned _Bool" } */
+short int void *x141; /* { dg-error "" "short int void" } */
+short int char *x142; /* { dg-error "" "short int char" } */
+short int short *x143; /* { dg-error "" "short int short" } */
+short int int *x144; /* { dg-error "" "short int int" } */
+short int long *x145; /* { dg-error "" "short int long" } */
+short int float *x146; /* { dg-error "" "short int float" } */
+short int double *x147; /* { dg-error "" "short int double" } */
+short int signed *x148;
+short int unsigned *x149;
+short int _Bool *x150; /* { dg-error "" "short int _Bool" } */
+short signed void *x151; /* { dg-error "" "short signed void" } */
+short signed char *x152; /* { dg-error "" "short signed char" } */
+short signed short *x153; /* { dg-error "" "short signed short" } */
+short signed int *x154;
+short signed long *x155; /* { dg-error "" "short signed long" } */
+short signed float *x156; /* { dg-error "" "short signed float" } */
+short signed double *x157; /* { dg-error "" "short signed double" } */
+short signed signed *x158; /* { dg-error "" "short signed signed" } */
+short signed unsigned *x159; /* { dg-error "" "short signed unsigned" } */
+short signed _Bool *x160; /* { dg-error "" "short signed _Bool" } */
+short unsigned void *x161; /* { dg-error "" "short unsigned void" } */
+short unsigned char *x162; /* { dg-error "" "short unsigned char" } */
+short unsigned short *x163; /* { dg-error "" "short unsigned short" } */
+short unsigned int *x164;
+short unsigned long *x165; /* { dg-error "" "short unsigned long" } */
+short unsigned float *x166; /* { dg-error "" "short unsigned float" } */
+short unsigned double *x167; /* { dg-error "" "short unsigned double" } */
+short unsigned signed *x168; /* { dg-error "" "short unsigned signed" } */
+short unsigned unsigned *x169; /* { dg-error "" "short unsigned unsigned" } */
+short unsigned _Bool *x170; /* { dg-error "" "short unsigned _Bool" } */
+int short void *x171; /* { dg-error "" "int short void" } */
+int short char *x172; /* { dg-error "" "int short char" } */
+int short short *x173; /* { dg-error "" "int short short" } */
+int short int *x174; /* { dg-error "" "int short int" } */
+int short long *x175; /* { dg-error "" "int short long" } */
+int short float *x176; /* { dg-error "" "int short float" } */
+int short double *x177; /* { dg-error "" "int short double" } */
+int short signed *x178;
+int short unsigned *x179;
+int short _Bool *x180; /* { dg-error "" "int short _Bool" } */
+int long void *x181; /* { dg-error "" "int long void" } */
+int long char *x182; /* { dg-error "" "int long char" } */
+int long short *x183; /* { dg-error "" "int long short" } */
+int long int *x184; /* { dg-error "" "int long int" } */
+int long long *x185;
+int long float *x186; /* { dg-error "" "int long float" } */
+int long double *x187; /* { dg-error "" "int long double" } */
+int long signed *x188;
+int long unsigned *x189;
+int long _Bool *x190; /* { dg-error "" "int long _Bool" } */
+int signed void *x191; /* { dg-error "" "int signed void" } */
+int signed char *x192; /* { dg-error "" "int signed char" } */
+int signed short *x193;
+int signed int *x194; /* { dg-error "" "int signed int" } */
+int signed long *x195;
+int signed float *x196; /* { dg-error "" "int signed float" } */
+int signed double *x197; /* { dg-error "" "int signed double" } */
+int signed signed *x198; /* { dg-error "" "int signed signed" } */
+int signed unsigned *x199; /* { dg-error "" "int signed unsigned" } */
+int signed _Bool *x200; /* { dg-error "" "int signed _Bool" } */
+int unsigned void *x201; /* { dg-error "" "int unsigned void" } */
+int unsigned char *x202; /* { dg-error "" "int unsigned char" } */
+int unsigned short *x203;
+int unsigned int *x204; /* { dg-error "" "int unsigned int" } */
+int unsigned long *x205;
+int unsigned float *x206; /* { dg-error "" "int unsigned float" } */
+int unsigned double *x207; /* { dg-error "" "int unsigned double" } */
+int unsigned signed *x208; /* { dg-error "" "int unsigned signed" } */
+int unsigned unsigned *x209; /* { dg-error "" "int unsigned unsigned" } */
+int unsigned _Bool *x210; /* { dg-error "" "int unsigned _Bool" } */
+long int void *x211; /* { dg-error "" "long int void" } */
+long int char *x212; /* { dg-error "" "long int char" } */
+long int short *x213; /* { dg-error "" "long int short" } */
+long int int *x214; /* { dg-error "" "long int int" } */
+long int long *x215;
+long int float *x216; /* { dg-error "" "long int float" } */
+long int double *x217; /* { dg-error "" "long int double" } */
+long int signed *x218;
+long int unsigned *x219;
+long int _Bool *x220; /* { dg-error "" "long int _Bool" } */
+long long void *x221; /* { dg-error "" "long long void" } */
+long long char *x222; /* { dg-error "" "long long char" } */
+long long short *x223; /* { dg-error "" "long long short" } */
+long long int *x224;
+long long long *x225; /* { dg-error "" "long long long" } */
+long long float *x226; /* { dg-error "" "long long float" } */
+long long double *x227; /* { dg-error "" "long long double" } */
+long long signed *x228;
+long long unsigned *x229;
+long long _Bool *x230; /* { dg-error "" "long long _Bool" } */
+long double void *x231; /* { dg-error "" "long double void" } */
+long double char *x232; /* { dg-error "" "long double char" } */
+long double short *x233; /* { dg-error "" "long double short" } */
+long double int *x234; /* { dg-error "" "long double int" } */
+long double long *x235; /* { dg-error "" "long double long" } */
+long double float *x236; /* { dg-error "" "long double float" } */
+long double double *x237; /* { dg-error "" "long double double" } */
+long double signed *x238; /* { dg-error "" "long double signed" } */
+long double unsigned *x239; /* { dg-error "" "long double unsigned" } */
+long double _Bool *x240; /* { dg-error "" "long double _Bool" } */
+long signed void *x241; /* { dg-error "" "long signed void" } */
+long signed char *x242; /* { dg-error "" "long signed char" } */
+long signed short *x243; /* { dg-error "" "long signed short" } */
+long signed int *x244;
+long signed long *x245;
+long signed float *x246; /* { dg-error "" "long signed float" } */
+long signed double *x247; /* { dg-error "" "long signed double" } */
+long signed signed *x248; /* { dg-error "" "long signed signed" } */
+long signed unsigned *x249; /* { dg-error "" "long signed unsigned" } */
+long signed _Bool *x250; /* { dg-error "" "long signed _Bool" } */
+long unsigned void *x251; /* { dg-error "" "long unsigned void" } */
+long unsigned char *x252; /* { dg-error "" "long unsigned char" } */
+long unsigned short *x253; /* { dg-error "" "long unsigned short" } */
+long unsigned int *x254;
+long unsigned long *x255;
+long unsigned float *x256; /* { dg-error "" "long unsigned float" } */
+long unsigned double *x257; /* { dg-error "" "long unsigned double" } */
+long unsigned signed *x258; /* { dg-error "" "long unsigned signed" } */
+long unsigned unsigned *x259; /* { dg-error "" "long unsigned unsigned" } */
+long unsigned _Bool *x260; /* { dg-error "" "long unsigned _Bool" } */
+double long void *x261; /* { dg-error "" "double long void" } */
+double long char *x262; /* { dg-error "" "double long char" } */
+double long short *x263; /* { dg-error "" "double long short" } */
+double long int *x264; /* { dg-error "" "double long int" } */
+double long long *x265; /* { dg-error "" "double long long" } */
+double long float *x266; /* { dg-error "" "double long float" } */
+double long double *x267; /* { dg-error "" "double long double" } */
+double long signed *x268; /* { dg-error "" "double long signed" } */
+double long unsigned *x269; /* { dg-error "" "double long unsigned" } */
+double long _Bool *x270; /* { dg-error "" "double long _Bool" } */
+signed char void *x271; /* { dg-error "" "signed char void" } */
+signed char char *x272; /* { dg-error "" "signed char char" } */
+signed char short *x273; /* { dg-error "" "signed char short" } */
+signed char int *x274; /* { dg-error "" "signed char int" } */
+signed char long *x275; /* { dg-error "" "signed char long" } */
+signed char float *x276; /* { dg-error "" "signed char float" } */
+signed char double *x277; /* { dg-error "" "signed char double" } */
+signed char signed *x278; /* { dg-error "" "signed char signed" } */
+signed char unsigned *x279; /* { dg-error "" "signed char unsigned" } */
+signed char _Bool *x280; /* { dg-error "" "signed char _Bool" } */
+signed short void *x281; /* { dg-error "" "signed short void" } */
+signed short char *x282; /* { dg-error "" "signed short char" } */
+signed short short *x283; /* { dg-error "" "signed short short" } */
+signed short int *x284;
+signed short long *x285; /* { dg-error "" "signed short long" } */
+signed short float *x286; /* { dg-error "" "signed short float" } */
+signed short double *x287; /* { dg-error "" "signed short double" } */
+signed short signed *x288; /* { dg-error "" "signed short signed" } */
+signed short unsigned *x289; /* { dg-error "" "signed short unsigned" } */
+signed short _Bool *x290; /* { dg-error "" "signed short _Bool" } */
+signed int void *x291; /* { dg-error "" "signed int void" } */
+signed int char *x292; /* { dg-error "" "signed int char" } */
+signed int short *x293;
+signed int int *x294; /* { dg-error "" "signed int int" } */
+signed int long *x295;
+signed int float *x296; /* { dg-error "" "signed int float" } */
+signed int double *x297; /* { dg-error "" "signed int double" } */
+signed int signed *x298; /* { dg-error "" "signed int signed" } */
+signed int unsigned *x299; /* { dg-error "" "signed int unsigned" } */
+signed int _Bool *x300; /* { dg-error "" "signed int _Bool" } */
+signed long void *x301; /* { dg-error "" "signed long void" } */
+signed long char *x302; /* { dg-error "" "signed long char" } */
+signed long short *x303; /* { dg-error "" "signed long short" } */
+signed long int *x304;
+signed long long *x305;
+signed long float *x306; /* { dg-error "" "signed long float" } */
+signed long double *x307; /* { dg-error "" "signed long double" } */
+signed long signed *x308; /* { dg-error "" "signed long signed" } */
+signed long unsigned *x309; /* { dg-error "" "signed long unsigned" } */
+signed long _Bool *x310; /* { dg-error "" "signed long _Bool" } */
+unsigned char void *x311; /* { dg-error "" "unsigned char void" } */
+unsigned char char *x312; /* { dg-error "" "unsigned char char" } */
+unsigned char short *x313; /* { dg-error "" "unsigned char short" } */
+unsigned char int *x314; /* { dg-error "" "unsigned char int" } */
+unsigned char long *x315; /* { dg-error "" "unsigned char long" } */
+unsigned char float *x316; /* { dg-error "" "unsigned char float" } */
+unsigned char double *x317; /* { dg-error "" "unsigned char double" } */
+unsigned char signed *x318; /* { dg-error "" "unsigned char signed" } */
+unsigned char unsigned *x319; /* { dg-error "" "unsigned char unsigned" } */
+unsigned char _Bool *x320; /* { dg-error "" "unsigned char _Bool" } */
+unsigned short void *x321; /* { dg-error "" "unsigned short void" } */
+unsigned short char *x322; /* { dg-error "" "unsigned short char" } */
+unsigned short short *x323; /* { dg-error "" "unsigned short short" } */
+unsigned short int *x324;
+unsigned short long *x325; /* { dg-error "" "unsigned short long" } */
+unsigned short float *x326; /* { dg-error "" "unsigned short float" } */
+unsigned short double *x327; /* { dg-error "" "unsigned short double" } */
+unsigned short signed *x328; /* { dg-error "" "unsigned short signed" } */
+unsigned short unsigned *x329; /* { dg-error "" "unsigned short unsigned" } */
+unsigned short _Bool *x330; /* { dg-error "" "unsigned short _Bool" } */
+unsigned int void *x331; /* { dg-error "" "unsigned int void" } */
+unsigned int char *x332; /* { dg-error "" "unsigned int char" } */
+unsigned int short *x333;
+unsigned int int *x334; /* { dg-error "" "unsigned int int" } */
+unsigned int long *x335;
+unsigned int float *x336; /* { dg-error "" "unsigned int float" } */
+unsigned int double *x337; /* { dg-error "" "unsigned int double" } */
+unsigned int signed *x338; /* { dg-error "" "unsigned int signed" } */
+unsigned int unsigned *x339; /* { dg-error "" "unsigned int unsigned" } */
+unsigned int _Bool *x340; /* { dg-error "" "unsigned int _Bool" } */
+unsigned long void *x341; /* { dg-error "" "unsigned long void" } */
+unsigned long char *x342; /* { dg-error "" "unsigned long char" } */
+unsigned long short *x343; /* { dg-error "" "unsigned long short" } */
+unsigned long int *x344;
+unsigned long long *x345;
+unsigned long float *x346; /* { dg-error "" "unsigned long float" } */
+unsigned long double *x347; /* { dg-error "" "unsigned long double" } */
+unsigned long signed *x348; /* { dg-error "" "unsigned long signed" } */
+unsigned long unsigned *x349; /* { dg-error "" "unsigned long unsigned" } */
+unsigned long _Bool *x350; /* { dg-error "" "unsigned long _Bool" } */
+short int signed void *x351; /* { dg-error "" "short int signed void" } */
+short int signed char *x352; /* { dg-error "" "short int signed char" } */
+short int signed short *x353; /* { dg-error "" "short int signed short" } */
+short int signed int *x354; /* { dg-error "" "short int signed int" } */
+short int signed long *x355; /* { dg-error "" "short int signed long" } */
+short int signed float *x356; /* { dg-error "" "short int signed float" } */
+short int signed double *x357; /* { dg-error "" "short int signed double" } */
+short int signed signed *x358; /* { dg-error "" "short int signed signed" } */
+short int signed unsigned *x359; /* { dg-error "" "short int signed unsigned" } */
+short int signed _Bool *x360; /* { dg-error "" "short int signed _Bool" } */
+short int unsigned void *x361; /* { dg-error "" "short int unsigned void" } */
+short int unsigned char *x362; /* { dg-error "" "short int unsigned char" } */
+short int unsigned short *x363; /* { dg-error "" "short int unsigned short" } */
+short int unsigned int *x364; /* { dg-error "" "short int unsigned int" } */
+short int unsigned long *x365; /* { dg-error "" "short int unsigned long" } */
+short int unsigned float *x366; /* { dg-error "" "short int unsigned float" } */
+short int unsigned double *x367; /* { dg-error "" "short int unsigned double" } */
+short int unsigned signed *x368; /* { dg-error "" "short int unsigned signed" } */
+short int unsigned unsigned *x369; /* { dg-error "" "short int unsigned unsigned" } */
+short int unsigned _Bool *x370; /* { dg-error "" "short int unsigned _Bool" } */
+short signed int void *x371; /* { dg-error "" "short signed int void" } */
+short signed int char *x372; /* { dg-error "" "short signed int char" } */
+short signed int short *x373; /* { dg-error "" "short signed int short" } */
+short signed int int *x374; /* { dg-error "" "short signed int int" } */
+short signed int long *x375; /* { dg-error "" "short signed int long" } */
+short signed int float *x376; /* { dg-error "" "short signed int float" } */
+short signed int double *x377; /* { dg-error "" "short signed int double" } */
+short signed int signed *x378; /* { dg-error "" "short signed int signed" } */
+short signed int unsigned *x379; /* { dg-error "" "short signed int unsigned" } */
+short signed int _Bool *x380; /* { dg-error "" "short signed int _Bool" } */
+short unsigned int void *x381; /* { dg-error "" "short unsigned int void" } */
+short unsigned int char *x382; /* { dg-error "" "short unsigned int char" } */
+short unsigned int short *x383; /* { dg-error "" "short unsigned int short" } */
+short unsigned int int *x384; /* { dg-error "" "short unsigned int int" } */
+short unsigned int long *x385; /* { dg-error "" "short unsigned int long" } */
+short unsigned int float *x386; /* { dg-error "" "short unsigned int float" } */
+short unsigned int double *x387; /* { dg-error "" "short unsigned int double" } */
+short unsigned int signed *x388; /* { dg-error "" "short unsigned int signed" } */
+short unsigned int unsigned *x389; /* { dg-error "" "short unsigned int unsigned" } */
+short unsigned int _Bool *x390; /* { dg-error "" "short unsigned int _Bool" } */
+int short signed void *x391; /* { dg-error "" "int short signed void" } */
+int short signed char *x392; /* { dg-error "" "int short signed char" } */
+int short signed short *x393; /* { dg-error "" "int short signed short" } */
+int short signed int *x394; /* { dg-error "" "int short signed int" } */
+int short signed long *x395; /* { dg-error "" "int short signed long" } */
+int short signed float *x396; /* { dg-error "" "int short signed float" } */
+int short signed double *x397; /* { dg-error "" "int short signed double" } */
+int short signed signed *x398; /* { dg-error "" "int short signed signed" } */
+int short signed unsigned *x399; /* { dg-error "" "int short signed unsigned" } */
+int short signed _Bool *x400; /* { dg-error "" "int short signed _Bool" } */
+int short unsigned void *x401; /* { dg-error "" "int short unsigned void" } */
+int short unsigned char *x402; /* { dg-error "" "int short unsigned char" } */
+int short unsigned short *x403; /* { dg-error "" "int short unsigned short" } */
+int short unsigned int *x404; /* { dg-error "" "int short unsigned int" } */
+int short unsigned long *x405; /* { dg-error "" "int short unsigned long" } */
+int short unsigned float *x406; /* { dg-error "" "int short unsigned float" } */
+int short unsigned double *x407; /* { dg-error "" "int short unsigned double" } */
+int short unsigned signed *x408; /* { dg-error "" "int short unsigned signed" } */
+int short unsigned unsigned *x409; /* { dg-error "" "int short unsigned unsigned" } */
+int short unsigned _Bool *x410; /* { dg-error "" "int short unsigned _Bool" } */
+int long long void *x411; /* { dg-error "" "int long long void" } */
+int long long char *x412; /* { dg-error "" "int long long char" } */
+int long long short *x413; /* { dg-error "" "int long long short" } */
+int long long int *x414; /* { dg-error "" "int long long int" } */
+int long long long *x415; /* { dg-error "" "int long long long" } */
+int long long float *x416; /* { dg-error "" "int long long float" } */
+int long long double *x417; /* { dg-error "" "int long long double" } */
+int long long signed *x418;
+int long long unsigned *x419;
+int long long _Bool *x420; /* { dg-error "" "int long long _Bool" } */
+int long signed void *x421; /* { dg-error "" "int long signed void" } */
+int long signed char *x422; /* { dg-error "" "int long signed char" } */
+int long signed short *x423; /* { dg-error "" "int long signed short" } */
+int long signed int *x424; /* { dg-error "" "int long signed int" } */
+int long signed long *x425;
+int long signed float *x426; /* { dg-error "" "int long signed float" } */
+int long signed double *x427; /* { dg-error "" "int long signed double" } */
+int long signed signed *x428; /* { dg-error "" "int long signed signed" } */
+int long signed unsigned *x429; /* { dg-error "" "int long signed unsigned" } */
+int long signed _Bool *x430; /* { dg-error "" "int long signed _Bool" } */
+int long unsigned void *x431; /* { dg-error "" "int long unsigned void" } */
+int long unsigned char *x432; /* { dg-error "" "int long unsigned char" } */
+int long unsigned short *x433; /* { dg-error "" "int long unsigned short" } */
+int long unsigned int *x434; /* { dg-error "" "int long unsigned int" } */
+int long unsigned long *x435;
+int long unsigned float *x436; /* { dg-error "" "int long unsigned float" } */
+int long unsigned double *x437; /* { dg-error "" "int long unsigned double" } */
+int long unsigned signed *x438; /* { dg-error "" "int long unsigned signed" } */
+int long unsigned unsigned *x439; /* { dg-error "" "int long unsigned unsigned" } */
+int long unsigned _Bool *x440; /* { dg-error "" "int long unsigned _Bool" } */
+int signed short void *x441; /* { dg-error "" "int signed short void" } */
+int signed short char *x442; /* { dg-error "" "int signed short char" } */
+int signed short short *x443; /* { dg-error "" "int signed short short" } */
+int signed short int *x444; /* { dg-error "" "int signed short int" } */
+int signed short long *x445; /* { dg-error "" "int signed short long" } */
+int signed short float *x446; /* { dg-error "" "int signed short float" } */
+int signed short double *x447; /* { dg-error "" "int signed short double" } */
+int signed short signed *x448; /* { dg-error "" "int signed short signed" } */
+int signed short unsigned *x449; /* { dg-error "" "int signed short unsigned" } */
+int signed short _Bool *x450; /* { dg-error "" "int signed short _Bool" } */
+int signed long void *x451; /* { dg-error "" "int signed long void" } */
+int signed long char *x452; /* { dg-error "" "int signed long char" } */
+int signed long short *x453; /* { dg-error "" "int signed long short" } */
+int signed long int *x454; /* { dg-error "" "int signed long int" } */
+int signed long long *x455;
+int signed long float *x456; /* { dg-error "" "int signed long float" } */
+int signed long double *x457; /* { dg-error "" "int signed long double" } */
+int signed long signed *x458; /* { dg-error "" "int signed long signed" } */
+int signed long unsigned *x459; /* { dg-error "" "int signed long unsigned" } */
+int signed long _Bool *x460; /* { dg-error "" "int signed long _Bool" } */
+int unsigned short void *x461; /* { dg-error "" "int unsigned short void" } */
+int unsigned short char *x462; /* { dg-error "" "int unsigned short char" } */
+int unsigned short short *x463; /* { dg-error "" "int unsigned short short" } */
+int unsigned short int *x464; /* { dg-error "" "int unsigned short int" } */
+int unsigned short long *x465; /* { dg-error "" "int unsigned short long" } */
+int unsigned short float *x466; /* { dg-error "" "int unsigned short float" } */
+int unsigned short double *x467; /* { dg-error "" "int unsigned short double" } */
+int unsigned short signed *x468; /* { dg-error "" "int unsigned short signed" } */
+int unsigned short unsigned *x469; /* { dg-error "" "int unsigned short unsigned" } */
+int unsigned short _Bool *x470; /* { dg-error "" "int unsigned short _Bool" } */
+int unsigned long void *x471; /* { dg-error "" "int unsigned long void" } */
+int unsigned long char *x472; /* { dg-error "" "int unsigned long char" } */
+int unsigned long short *x473; /* { dg-error "" "int unsigned long short" } */
+int unsigned long int *x474; /* { dg-error "" "int unsigned long int" } */
+int unsigned long long *x475;
+int unsigned long float *x476; /* { dg-error "" "int unsigned long float" } */
+int unsigned long double *x477; /* { dg-error "" "int unsigned long double" } */
+int unsigned long signed *x478; /* { dg-error "" "int unsigned long signed" } */
+int unsigned long unsigned *x479; /* { dg-error "" "int unsigned long unsigned" } */
+int unsigned long _Bool *x480; /* { dg-error "" "int unsigned long _Bool" } */
+long int long void *x481; /* { dg-error "" "long int long void" } */
+long int long char *x482; /* { dg-error "" "long int long char" } */
+long int long short *x483; /* { dg-error "" "long int long short" } */
+long int long int *x484; /* { dg-error "" "long int long int" } */
+long int long long *x485; /* { dg-error "" "long int long long" } */
+long int long float *x486; /* { dg-error "" "long int long float" } */
+long int long double *x487; /* { dg-error "" "long int long double" } */
+long int long signed *x488;
+long int long unsigned *x489;
+long int long _Bool *x490; /* { dg-error "" "long int long _Bool" } */
+long int signed void *x491; /* { dg-error "" "long int signed void" } */
+long int signed char *x492; /* { dg-error "" "long int signed char" } */
+long int signed short *x493; /* { dg-error "" "long int signed short" } */
+long int signed int *x494; /* { dg-error "" "long int signed int" } */
+long int signed long *x495;
+long int signed float *x496; /* { dg-error "" "long int signed float" } */
+long int signed double *x497; /* { dg-error "" "long int signed double" } */
+long int signed signed *x498; /* { dg-error "" "long int signed signed" } */
+long int signed unsigned *x499; /* { dg-error "" "long int signed unsigned" } */
+long int signed _Bool *x500; /* { dg-error "" "long int signed _Bool" } */
+long int unsigned void *x501; /* { dg-error "" "long int unsigned void" } */
+long int unsigned char *x502; /* { dg-error "" "long int unsigned char" } */
+long int unsigned short *x503; /* { dg-error "" "long int unsigned short" } */
+long int unsigned int *x504; /* { dg-error "" "long int unsigned int" } */
+long int unsigned long *x505;
+long int unsigned float *x506; /* { dg-error "" "long int unsigned float" } */
+long int unsigned double *x507; /* { dg-error "" "long int unsigned double" } */
+long int unsigned signed *x508; /* { dg-error "" "long int unsigned signed" } */
+long int unsigned unsigned *x509; /* { dg-error "" "long int unsigned unsigned" } */
+long int unsigned _Bool *x510; /* { dg-error "" "long int unsigned _Bool" } */
+long long int void *x511; /* { dg-error "" "long long int void" } */
+long long int char *x512; /* { dg-error "" "long long int char" } */
+long long int short *x513; /* { dg-error "" "long long int short" } */
+long long int int *x514; /* { dg-error "" "long long int int" } */
+long long int long *x515; /* { dg-error "" "long long int long" } */
+long long int float *x516; /* { dg-error "" "long long int float" } */
+long long int double *x517; /* { dg-error "" "long long int double" } */
+long long int signed *x518;
+long long int unsigned *x519;
+long long int _Bool *x520; /* { dg-error "" "long long int _Bool" } */
+long long signed void *x521; /* { dg-error "" "long long signed void" } */
+long long signed char *x522; /* { dg-error "" "long long signed char" } */
+long long signed short *x523; /* { dg-error "" "long long signed short" } */
+long long signed int *x524;
+long long signed long *x525; /* { dg-error "" "long long signed long" } */
+long long signed float *x526; /* { dg-error "" "long long signed float" } */
+long long signed double *x527; /* { dg-error "" "long long signed double" } */
+long long signed signed *x528; /* { dg-error "" "long long signed signed" } */
+long long signed unsigned *x529; /* { dg-error "" "long long signed unsigned" } */
+long long signed _Bool *x530; /* { dg-error "" "long long signed _Bool" } */
+long long unsigned void *x531; /* { dg-error "" "long long unsigned void" } */
+long long unsigned char *x532; /* { dg-error "" "long long unsigned char" } */
+long long unsigned short *x533; /* { dg-error "" "long long unsigned short" } */
+long long unsigned int *x534;
+long long unsigned long *x535; /* { dg-error "" "long long unsigned long" } */
+long long unsigned float *x536; /* { dg-error "" "long long unsigned float" } */
+long long unsigned double *x537; /* { dg-error "" "long long unsigned double" } */
+long long unsigned signed *x538; /* { dg-error "" "long long unsigned signed" } */
+long long unsigned unsigned *x539; /* { dg-error "" "long long unsigned unsigned" } */
+long long unsigned _Bool *x540; /* { dg-error "" "long long unsigned _Bool" } */
+long signed int void *x541; /* { dg-error "" "long signed int void" } */
+long signed int char *x542; /* { dg-error "" "long signed int char" } */
+long signed int short *x543; /* { dg-error "" "long signed int short" } */
+long signed int int *x544; /* { dg-error "" "long signed int int" } */
+long signed int long *x545;
+long signed int float *x546; /* { dg-error "" "long signed int float" } */
+long signed int double *x547; /* { dg-error "" "long signed int double" } */
+long signed int signed *x548; /* { dg-error "" "long signed int signed" } */
+long signed int unsigned *x549; /* { dg-error "" "long signed int unsigned" } */
+long signed int _Bool *x550; /* { dg-error "" "long signed int _Bool" } */
+long signed long void *x551; /* { dg-error "" "long signed long void" } */
+long signed long char *x552; /* { dg-error "" "long signed long char" } */
+long signed long short *x553; /* { dg-error "" "long signed long short" } */
+long signed long int *x554;
+long signed long long *x555; /* { dg-error "" "long signed long long" } */
+long signed long float *x556; /* { dg-error "" "long signed long float" } */
+long signed long double *x557; /* { dg-error "" "long signed long double" } */
+long signed long signed *x558; /* { dg-error "" "long signed long signed" } */
+long signed long unsigned *x559; /* { dg-error "" "long signed long unsigned" } */
+long signed long _Bool *x560; /* { dg-error "" "long signed long _Bool" } */
+long unsigned int void *x561; /* { dg-error "" "long unsigned int void" } */
+long unsigned int char *x562; /* { dg-error "" "long unsigned int char" } */
+long unsigned int short *x563; /* { dg-error "" "long unsigned int short" } */
+long unsigned int int *x564; /* { dg-error "" "long unsigned int int" } */
+long unsigned int long *x565;
+long unsigned int float *x566; /* { dg-error "" "long unsigned int float" } */
+long unsigned int double *x567; /* { dg-error "" "long unsigned int double" } */
+long unsigned int signed *x568; /* { dg-error "" "long unsigned int signed" } */
+long unsigned int unsigned *x569; /* { dg-error "" "long unsigned int unsigned" } */
+long unsigned int _Bool *x570; /* { dg-error "" "long unsigned int _Bool" } */
+long unsigned long void *x571; /* { dg-error "" "long unsigned long void" } */
+long unsigned long char *x572; /* { dg-error "" "long unsigned long char" } */
+long unsigned long short *x573; /* { dg-error "" "long unsigned long short" } */
+long unsigned long int *x574;
+long unsigned long long *x575; /* { dg-error "" "long unsigned long long" } */
+long unsigned long float *x576; /* { dg-error "" "long unsigned long float" } */
+long unsigned long double *x577; /* { dg-error "" "long unsigned long double" } */
+long unsigned long signed *x578; /* { dg-error "" "long unsigned long signed" } */
+long unsigned long unsigned *x579; /* { dg-error "" "long unsigned long unsigned" } */
+long unsigned long _Bool *x580; /* { dg-error "" "long unsigned long _Bool" } */
+signed short int void *x581; /* { dg-error "" "signed short int void" } */
+signed short int char *x582; /* { dg-error "" "signed short int char" } */
+signed short int short *x583; /* { dg-error "" "signed short int short" } */
+signed short int int *x584; /* { dg-error "" "signed short int int" } */
+signed short int long *x585; /* { dg-error "" "signed short int long" } */
+signed short int float *x586; /* { dg-error "" "signed short int float" } */
+signed short int double *x587; /* { dg-error "" "signed short int double" } */
+signed short int signed *x588; /* { dg-error "" "signed short int signed" } */
+signed short int unsigned *x589; /* { dg-error "" "signed short int unsigned" } */
+signed short int _Bool *x590; /* { dg-error "" "signed short int _Bool" } */
+signed int short void *x591; /* { dg-error "" "signed int short void" } */
+signed int short char *x592; /* { dg-error "" "signed int short char" } */
+signed int short short *x593; /* { dg-error "" "signed int short short" } */
+signed int short int *x594; /* { dg-error "" "signed int short int" } */
+signed int short long *x595; /* { dg-error "" "signed int short long" } */
+signed int short float *x596; /* { dg-error "" "signed int short float" } */
+signed int short double *x597; /* { dg-error "" "signed int short double" } */
+signed int short signed *x598; /* { dg-error "" "signed int short signed" } */
+signed int short unsigned *x599; /* { dg-error "" "signed int short unsigned" } */
+signed int short _Bool *x600; /* { dg-error "" "signed int short _Bool" } */
+signed int long void *x601; /* { dg-error "" "signed int long void" } */
+signed int long char *x602; /* { dg-error "" "signed int long char" } */
+signed int long short *x603; /* { dg-error "" "signed int long short" } */
+signed int long int *x604; /* { dg-error "" "signed int long int" } */
+signed int long long *x605;
+signed int long float *x606; /* { dg-error "" "signed int long float" } */
+signed int long double *x607; /* { dg-error "" "signed int long double" } */
+signed int long signed *x608; /* { dg-error "" "signed int long signed" } */
+signed int long unsigned *x609; /* { dg-error "" "signed int long unsigned" } */
+signed int long _Bool *x610; /* { dg-error "" "signed int long _Bool" } */
+signed long int void *x611; /* { dg-error "" "signed long int void" } */
+signed long int char *x612; /* { dg-error "" "signed long int char" } */
+signed long int short *x613; /* { dg-error "" "signed long int short" } */
+signed long int int *x614; /* { dg-error "" "signed long int int" } */
+signed long int long *x615;
+signed long int float *x616; /* { dg-error "" "signed long int float" } */
+signed long int double *x617; /* { dg-error "" "signed long int double" } */
+signed long int signed *x618; /* { dg-error "" "signed long int signed" } */
+signed long int unsigned *x619; /* { dg-error "" "signed long int unsigned" } */
+signed long int _Bool *x620; /* { dg-error "" "signed long int _Bool" } */
+signed long long void *x621; /* { dg-error "" "signed long long void" } */
+signed long long char *x622; /* { dg-error "" "signed long long char" } */
+signed long long short *x623; /* { dg-error "" "signed long long short" } */
+signed long long int *x624;
+signed long long long *x625; /* { dg-error "" "signed long long long" } */
+signed long long float *x626; /* { dg-error "" "signed long long float" } */
+signed long long double *x627; /* { dg-error "" "signed long long double" } */
+signed long long signed *x628; /* { dg-error "" "signed long long signed" } */
+signed long long unsigned *x629; /* { dg-error "" "signed long long unsigned" } */
+signed long long _Bool *x630; /* { dg-error "" "signed long long _Bool" } */
+unsigned short int void *x631; /* { dg-error "" "unsigned short int void" } */
+unsigned short int char *x632; /* { dg-error "" "unsigned short int char" } */
+unsigned short int short *x633; /* { dg-error "" "unsigned short int short" } */
+unsigned short int int *x634; /* { dg-error "" "unsigned short int int" } */
+unsigned short int long *x635; /* { dg-error "" "unsigned short int long" } */
+unsigned short int float *x636; /* { dg-error "" "unsigned short int float" } */
+unsigned short int double *x637; /* { dg-error "" "unsigned short int double" } */
+unsigned short int signed *x638; /* { dg-error "" "unsigned short int signed" } */
+unsigned short int unsigned *x639; /* { dg-error "" "unsigned short int unsigned" } */
+unsigned short int _Bool *x640; /* { dg-error "" "unsigned short int _Bool" } */
+unsigned int short void *x641; /* { dg-error "" "unsigned int short void" } */
+unsigned int short char *x642; /* { dg-error "" "unsigned int short char" } */
+unsigned int short short *x643; /* { dg-error "" "unsigned int short short" } */
+unsigned int short int *x644; /* { dg-error "" "unsigned int short int" } */
+unsigned int short long *x645; /* { dg-error "" "unsigned int short long" } */
+unsigned int short float *x646; /* { dg-error "" "unsigned int short float" } */
+unsigned int short double *x647; /* { dg-error "" "unsigned int short double" } */
+unsigned int short signed *x648; /* { dg-error "" "unsigned int short signed" } */
+unsigned int short unsigned *x649; /* { dg-error "" "unsigned int short unsigned" } */
+unsigned int short _Bool *x650; /* { dg-error "" "unsigned int short _Bool" } */
+unsigned int long void *x651; /* { dg-error "" "unsigned int long void" } */
+unsigned int long char *x652; /* { dg-error "" "unsigned int long char" } */
+unsigned int long short *x653; /* { dg-error "" "unsigned int long short" } */
+unsigned int long int *x654; /* { dg-error "" "unsigned int long int" } */
+unsigned int long long *x655;
+unsigned int long float *x656; /* { dg-error "" "unsigned int long float" } */
+unsigned int long double *x657; /* { dg-error "" "unsigned int long double" } */
+unsigned int long signed *x658; /* { dg-error "" "unsigned int long signed" } */
+unsigned int long unsigned *x659; /* { dg-error "" "unsigned int long unsigned" } */
+unsigned int long _Bool *x660; /* { dg-error "" "unsigned int long _Bool" } */
+unsigned long int void *x661; /* { dg-error "" "unsigned long int void" } */
+unsigned long int char *x662; /* { dg-error "" "unsigned long int char" } */
+unsigned long int short *x663; /* { dg-error "" "unsigned long int short" } */
+unsigned long int int *x664; /* { dg-error "" "unsigned long int int" } */
+unsigned long int long *x665;
+unsigned long int float *x666; /* { dg-error "" "unsigned long int float" } */
+unsigned long int double *x667; /* { dg-error "" "unsigned long int double" } */
+unsigned long int signed *x668; /* { dg-error "" "unsigned long int signed" } */
+unsigned long int unsigned *x669; /* { dg-error "" "unsigned long int unsigned" } */
+unsigned long int _Bool *x670; /* { dg-error "" "unsigned long int _Bool" } */
+unsigned long long void *x671; /* { dg-error "" "unsigned long long void" } */
+unsigned long long char *x672; /* { dg-error "" "unsigned long long char" } */
+unsigned long long short *x673; /* { dg-error "" "unsigned long long short" } */
+unsigned long long int *x674;
+unsigned long long long *x675; /* { dg-error "" "unsigned long long long" } */
+unsigned long long float *x676; /* { dg-error "" "unsigned long long float" } */
+unsigned long long double *x677; /* { dg-error "" "unsigned long long double" } */
+unsigned long long signed *x678; /* { dg-error "" "unsigned long long signed" } */
+unsigned long long unsigned *x679; /* { dg-error "" "unsigned long long unsigned" } */
+unsigned long long _Bool *x680; /* { dg-error "" "unsigned long long _Bool" } */
+int long long signed void *x681; /* { dg-error "" "int long long signed void" } */
+int long long signed char *x682; /* { dg-error "" "int long long signed char" } */
+int long long signed short *x683; /* { dg-error "" "int long long signed short" } */
+int long long signed int *x684; /* { dg-error "" "int long long signed int" } */
+int long long signed long *x685; /* { dg-error "" "int long long signed long" } */
+int long long signed float *x686; /* { dg-error "" "int long long signed float" } */
+int long long signed double *x687; /* { dg-error "" "int long long signed double" } */
+int long long signed signed *x688; /* { dg-error "" "int long long signed signed" } */
+int long long signed unsigned *x689; /* { dg-error "" "int long long signed unsigned" } */
+int long long signed _Bool *x690; /* { dg-error "" "int long long signed _Bool" } */
+int long long unsigned void *x691; /* { dg-error "" "int long long unsigned void" } */
+int long long unsigned char *x692; /* { dg-error "" "int long long unsigned char" } */
+int long long unsigned short *x693; /* { dg-error "" "int long long unsigned short" } */
+int long long unsigned int *x694; /* { dg-error "" "int long long unsigned int" } */
+int long long unsigned long *x695; /* { dg-error "" "int long long unsigned long" } */
+int long long unsigned float *x696; /* { dg-error "" "int long long unsigned float" } */
+int long long unsigned double *x697; /* { dg-error "" "int long long unsigned double" } */
+int long long unsigned signed *x698; /* { dg-error "" "int long long unsigned signed" } */
+int long long unsigned unsigned *x699; /* { dg-error "" "int long long unsigned unsigned" } */
+int long long unsigned _Bool *x700; /* { dg-error "" "int long long unsigned _Bool" } */
+int long signed long void *x701; /* { dg-error "" "int long signed long void" } */
+int long signed long char *x702; /* { dg-error "" "int long signed long char" } */
+int long signed long short *x703; /* { dg-error "" "int long signed long short" } */
+int long signed long int *x704; /* { dg-error "" "int long signed long int" } */
+int long signed long long *x705; /* { dg-error "" "int long signed long long" } */
+int long signed long float *x706; /* { dg-error "" "int long signed long float" } */
+int long signed long double *x707; /* { dg-error "" "int long signed long double" } */
+int long signed long signed *x708; /* { dg-error "" "int long signed long signed" } */
+int long signed long unsigned *x709; /* { dg-error "" "int long signed long unsigned" } */
+int long signed long _Bool *x710; /* { dg-error "" "int long signed long _Bool" } */
+int long unsigned long void *x711; /* { dg-error "" "int long unsigned long void" } */
+int long unsigned long char *x712; /* { dg-error "" "int long unsigned long char" } */
+int long unsigned long short *x713; /* { dg-error "" "int long unsigned long short" } */
+int long unsigned long int *x714; /* { dg-error "" "int long unsigned long int" } */
+int long unsigned long long *x715; /* { dg-error "" "int long unsigned long long" } */
+int long unsigned long float *x716; /* { dg-error "" "int long unsigned long float" } */
+int long unsigned long double *x717; /* { dg-error "" "int long unsigned long double" } */
+int long unsigned long signed *x718; /* { dg-error "" "int long unsigned long signed" } */
+int long unsigned long unsigned *x719; /* { dg-error "" "int long unsigned long unsigned" } */
+int long unsigned long _Bool *x720; /* { dg-error "" "int long unsigned long _Bool" } */
+int signed long long void *x721; /* { dg-error "" "int signed long long void" } */
+int signed long long char *x722; /* { dg-error "" "int signed long long char" } */
+int signed long long short *x723; /* { dg-error "" "int signed long long short" } */
+int signed long long int *x724; /* { dg-error "" "int signed long long int" } */
+int signed long long long *x725; /* { dg-error "" "int signed long long long" } */
+int signed long long float *x726; /* { dg-error "" "int signed long long float" } */
+int signed long long double *x727; /* { dg-error "" "int signed long long double" } */
+int signed long long signed *x728; /* { dg-error "" "int signed long long signed" } */
+int signed long long unsigned *x729; /* { dg-error "" "int signed long long unsigned" } */
+int signed long long _Bool *x730; /* { dg-error "" "int signed long long _Bool" } */
+int unsigned long long void *x731; /* { dg-error "" "int unsigned long long void" } */
+int unsigned long long char *x732; /* { dg-error "" "int unsigned long long char" } */
+int unsigned long long short *x733; /* { dg-error "" "int unsigned long long short" } */
+int unsigned long long int *x734; /* { dg-error "" "int unsigned long long int" } */
+int unsigned long long long *x735; /* { dg-error "" "int unsigned long long long" } */
+int unsigned long long float *x736; /* { dg-error "" "int unsigned long long float" } */
+int unsigned long long double *x737; /* { dg-error "" "int unsigned long long double" } */
+int unsigned long long signed *x738; /* { dg-error "" "int unsigned long long signed" } */
+int unsigned long long unsigned *x739; /* { dg-error "" "int unsigned long long unsigned" } */
+int unsigned long long _Bool *x740; /* { dg-error "" "int unsigned long long _Bool" } */
+long int long signed void *x741; /* { dg-error "" "long int long signed void" } */
+long int long signed char *x742; /* { dg-error "" "long int long signed char" } */
+long int long signed short *x743; /* { dg-error "" "long int long signed short" } */
+long int long signed int *x744; /* { dg-error "" "long int long signed int" } */
+long int long signed long *x745; /* { dg-error "" "long int long signed long" } */
+long int long signed float *x746; /* { dg-error "" "long int long signed float" } */
+long int long signed double *x747; /* { dg-error "" "long int long signed double" } */
+long int long signed signed *x748; /* { dg-error "" "long int long signed signed" } */
+long int long signed unsigned *x749; /* { dg-error "" "long int long signed unsigned" } */
+long int long signed _Bool *x750; /* { dg-error "" "long int long signed _Bool" } */
+long int long unsigned void *x751; /* { dg-error "" "long int long unsigned void" } */
+long int long unsigned char *x752; /* { dg-error "" "long int long unsigned char" } */
+long int long unsigned short *x753; /* { dg-error "" "long int long unsigned short" } */
+long int long unsigned int *x754; /* { dg-error "" "long int long unsigned int" } */
+long int long unsigned long *x755; /* { dg-error "" "long int long unsigned long" } */
+long int long unsigned float *x756; /* { dg-error "" "long int long unsigned float" } */
+long int long unsigned double *x757; /* { dg-error "" "long int long unsigned double" } */
+long int long unsigned signed *x758; /* { dg-error "" "long int long unsigned signed" } */
+long int long unsigned unsigned *x759; /* { dg-error "" "long int long unsigned unsigned" } */
+long int long unsigned _Bool *x760; /* { dg-error "" "long int long unsigned _Bool" } */
+long int signed long void *x761; /* { dg-error "" "long int signed long void" } */
+long int signed long char *x762; /* { dg-error "" "long int signed long char" } */
+long int signed long short *x763; /* { dg-error "" "long int signed long short" } */
+long int signed long int *x764; /* { dg-error "" "long int signed long int" } */
+long int signed long long *x765; /* { dg-error "" "long int signed long long" } */
+long int signed long float *x766; /* { dg-error "" "long int signed long float" } */
+long int signed long double *x767; /* { dg-error "" "long int signed long double" } */
+long int signed long signed *x768; /* { dg-error "" "long int signed long signed" } */
+long int signed long unsigned *x769; /* { dg-error "" "long int signed long unsigned" } */
+long int signed long _Bool *x770; /* { dg-error "" "long int signed long _Bool" } */
+long int unsigned long void *x771; /* { dg-error "" "long int unsigned long void" } */
+long int unsigned long char *x772; /* { dg-error "" "long int unsigned long char" } */
+long int unsigned long short *x773; /* { dg-error "" "long int unsigned long short" } */
+long int unsigned long int *x774; /* { dg-error "" "long int unsigned long int" } */
+long int unsigned long long *x775; /* { dg-error "" "long int unsigned long long" } */
+long int unsigned long float *x776; /* { dg-error "" "long int unsigned long float" } */
+long int unsigned long double *x777; /* { dg-error "" "long int unsigned long double" } */
+long int unsigned long signed *x778; /* { dg-error "" "long int unsigned long signed" } */
+long int unsigned long unsigned *x779; /* { dg-error "" "long int unsigned long unsigned" } */
+long int unsigned long _Bool *x780; /* { dg-error "" "long int unsigned long _Bool" } */
+long long int signed void *x781; /* { dg-error "" "long long int signed void" } */
+long long int signed char *x782; /* { dg-error "" "long long int signed char" } */
+long long int signed short *x783; /* { dg-error "" "long long int signed short" } */
+long long int signed int *x784; /* { dg-error "" "long long int signed int" } */
+long long int signed long *x785; /* { dg-error "" "long long int signed long" } */
+long long int signed float *x786; /* { dg-error "" "long long int signed float" } */
+long long int signed double *x787; /* { dg-error "" "long long int signed double" } */
+long long int signed signed *x788; /* { dg-error "" "long long int signed signed" } */
+long long int signed unsigned *x789; /* { dg-error "" "long long int signed unsigned" } */
+long long int signed _Bool *x790; /* { dg-error "" "long long int signed _Bool" } */
+long long int unsigned void *x791; /* { dg-error "" "long long int unsigned void" } */
+long long int unsigned char *x792; /* { dg-error "" "long long int unsigned char" } */
+long long int unsigned short *x793; /* { dg-error "" "long long int unsigned short" } */
+long long int unsigned int *x794; /* { dg-error "" "long long int unsigned int" } */
+long long int unsigned long *x795; /* { dg-error "" "long long int unsigned long" } */
+long long int unsigned float *x796; /* { dg-error "" "long long int unsigned float" } */
+long long int unsigned double *x797; /* { dg-error "" "long long int unsigned double" } */
+long long int unsigned signed *x798; /* { dg-error "" "long long int unsigned signed" } */
+long long int unsigned unsigned *x799; /* { dg-error "" "long long int unsigned unsigned" } */
+long long int unsigned _Bool *x800; /* { dg-error "" "long long int unsigned _Bool" } */
+long long signed int void *x801; /* { dg-error "" "long long signed int void" } */
+long long signed int char *x802; /* { dg-error "" "long long signed int char" } */
+long long signed int short *x803; /* { dg-error "" "long long signed int short" } */
+long long signed int int *x804; /* { dg-error "" "long long signed int int" } */
+long long signed int long *x805; /* { dg-error "" "long long signed int long" } */
+long long signed int float *x806; /* { dg-error "" "long long signed int float" } */
+long long signed int double *x807; /* { dg-error "" "long long signed int double" } */
+long long signed int signed *x808; /* { dg-error "" "long long signed int signed" } */
+long long signed int unsigned *x809; /* { dg-error "" "long long signed int unsigned" } */
+long long signed int _Bool *x810; /* { dg-error "" "long long signed int _Bool" } */
+long long unsigned int void *x811; /* { dg-error "" "long long unsigned int void" } */
+long long unsigned int char *x812; /* { dg-error "" "long long unsigned int char" } */
+long long unsigned int short *x813; /* { dg-error "" "long long unsigned int short" } */
+long long unsigned int int *x814; /* { dg-error "" "long long unsigned int int" } */
+long long unsigned int long *x815; /* { dg-error "" "long long unsigned int long" } */
+long long unsigned int float *x816; /* { dg-error "" "long long unsigned int float" } */
+long long unsigned int double *x817; /* { dg-error "" "long long unsigned int double" } */
+long long unsigned int signed *x818; /* { dg-error "" "long long unsigned int signed" } */
+long long unsigned int unsigned *x819; /* { dg-error "" "long long unsigned int unsigned" } */
+long long unsigned int _Bool *x820; /* { dg-error "" "long long unsigned int _Bool" } */
+long signed int long void *x821; /* { dg-error "" "long signed int long void" } */
+long signed int long char *x822; /* { dg-error "" "long signed int long char" } */
+long signed int long short *x823; /* { dg-error "" "long signed int long short" } */
+long signed int long int *x824; /* { dg-error "" "long signed int long int" } */
+long signed int long long *x825; /* { dg-error "" "long signed int long long" } */
+long signed int long float *x826; /* { dg-error "" "long signed int long float" } */
+long signed int long double *x827; /* { dg-error "" "long signed int long double" } */
+long signed int long signed *x828; /* { dg-error "" "long signed int long signed" } */
+long signed int long unsigned *x829; /* { dg-error "" "long signed int long unsigned" } */
+long signed int long _Bool *x830; /* { dg-error "" "long signed int long _Bool" } */
+long signed long int void *x831; /* { dg-error "" "long signed long int void" } */
+long signed long int char *x832; /* { dg-error "" "long signed long int char" } */
+long signed long int short *x833; /* { dg-error "" "long signed long int short" } */
+long signed long int int *x834; /* { dg-error "" "long signed long int int" } */
+long signed long int long *x835; /* { dg-error "" "long signed long int long" } */
+long signed long int float *x836; /* { dg-error "" "long signed long int float" } */
+long signed long int double *x837; /* { dg-error "" "long signed long int double" } */
+long signed long int signed *x838; /* { dg-error "" "long signed long int signed" } */
+long signed long int unsigned *x839; /* { dg-error "" "long signed long int unsigned" } */
+long signed long int _Bool *x840; /* { dg-error "" "long signed long int _Bool" } */
+long unsigned int long void *x841; /* { dg-error "" "long unsigned int long void" } */
+long unsigned int long char *x842; /* { dg-error "" "long unsigned int long char" } */
+long unsigned int long short *x843; /* { dg-error "" "long unsigned int long short" } */
+long unsigned int long int *x844; /* { dg-error "" "long unsigned int long int" } */
+long unsigned int long long *x845; /* { dg-error "" "long unsigned int long long" } */
+long unsigned int long float *x846; /* { dg-error "" "long unsigned int long float" } */
+long unsigned int long double *x847; /* { dg-error "" "long unsigned int long double" } */
+long unsigned int long signed *x848; /* { dg-error "" "long unsigned int long signed" } */
+long unsigned int long unsigned *x849; /* { dg-error "" "long unsigned int long unsigned" } */
+long unsigned int long _Bool *x850; /* { dg-error "" "long unsigned int long _Bool" } */
+long unsigned long int void *x851; /* { dg-error "" "long unsigned long int void" } */
+long unsigned long int char *x852; /* { dg-error "" "long unsigned long int char" } */
+long unsigned long int short *x853; /* { dg-error "" "long unsigned long int short" } */
+long unsigned long int int *x854; /* { dg-error "" "long unsigned long int int" } */
+long unsigned long int long *x855; /* { dg-error "" "long unsigned long int long" } */
+long unsigned long int float *x856; /* { dg-error "" "long unsigned long int float" } */
+long unsigned long int double *x857; /* { dg-error "" "long unsigned long int double" } */
+long unsigned long int signed *x858; /* { dg-error "" "long unsigned long int signed" } */
+long unsigned long int unsigned *x859; /* { dg-error "" "long unsigned long int unsigned" } */
+long unsigned long int _Bool *x860; /* { dg-error "" "long unsigned long int _Bool" } */
+signed int long long void *x861; /* { dg-error "" "signed int long long void" } */
+signed int long long char *x862; /* { dg-error "" "signed int long long char" } */
+signed int long long short *x863; /* { dg-error "" "signed int long long short" } */
+signed int long long int *x864; /* { dg-error "" "signed int long long int" } */
+signed int long long long *x865; /* { dg-error "" "signed int long long long" } */
+signed int long long float *x866; /* { dg-error "" "signed int long long float" } */
+signed int long long double *x867; /* { dg-error "" "signed int long long double" } */
+signed int long long signed *x868; /* { dg-error "" "signed int long long signed" } */
+signed int long long unsigned *x869; /* { dg-error "" "signed int long long unsigned" } */
+signed int long long _Bool *x870; /* { dg-error "" "signed int long long _Bool" } */
+signed long int long void *x871; /* { dg-error "" "signed long int long void" } */
+signed long int long char *x872; /* { dg-error "" "signed long int long char" } */
+signed long int long short *x873; /* { dg-error "" "signed long int long short" } */
+signed long int long int *x874; /* { dg-error "" "signed long int long int" } */
+signed long int long long *x875; /* { dg-error "" "signed long int long long" } */
+signed long int long float *x876; /* { dg-error "" "signed long int long float" } */
+signed long int long double *x877; /* { dg-error "" "signed long int long double" } */
+signed long int long signed *x878; /* { dg-error "" "signed long int long signed" } */
+signed long int long unsigned *x879; /* { dg-error "" "signed long int long unsigned" } */
+signed long int long _Bool *x880; /* { dg-error "" "signed long int long _Bool" } */
+signed long long int void *x881; /* { dg-error "" "signed long long int void" } */
+signed long long int char *x882; /* { dg-error "" "signed long long int char" } */
+signed long long int short *x883; /* { dg-error "" "signed long long int short" } */
+signed long long int int *x884; /* { dg-error "" "signed long long int int" } */
+signed long long int long *x885; /* { dg-error "" "signed long long int long" } */
+signed long long int float *x886; /* { dg-error "" "signed long long int float" } */
+signed long long int double *x887; /* { dg-error "" "signed long long int double" } */
+signed long long int signed *x888; /* { dg-error "" "signed long long int signed" } */
+signed long long int unsigned *x889; /* { dg-error "" "signed long long int unsigned" } */
+signed long long int _Bool *x890; /* { dg-error "" "signed long long int _Bool" } */
+unsigned int long long void *x891; /* { dg-error "" "unsigned int long long void" } */
+unsigned int long long char *x892; /* { dg-error "" "unsigned int long long char" } */
+unsigned int long long short *x893; /* { dg-error "" "unsigned int long long short" } */
+unsigned int long long int *x894; /* { dg-error "" "unsigned int long long int" } */
+unsigned int long long long *x895; /* { dg-error "" "unsigned int long long long" } */
+unsigned int long long float *x896; /* { dg-error "" "unsigned int long long float" } */
+unsigned int long long double *x897; /* { dg-error "" "unsigned int long long double" } */
+unsigned int long long signed *x898; /* { dg-error "" "unsigned int long long signed" } */
+unsigned int long long unsigned *x899; /* { dg-error "" "unsigned int long long unsigned" } */
+unsigned int long long _Bool *x900; /* { dg-error "" "unsigned int long long _Bool" } */
+unsigned long int long void *x901; /* { dg-error "" "unsigned long int long void" } */
+unsigned long int long char *x902; /* { dg-error "" "unsigned long int long char" } */
+unsigned long int long short *x903; /* { dg-error "" "unsigned long int long short" } */
+unsigned long int long int *x904; /* { dg-error "" "unsigned long int long int" } */
+unsigned long int long long *x905; /* { dg-error "" "unsigned long int long long" } */
+unsigned long int long float *x906; /* { dg-error "" "unsigned long int long float" } */
+unsigned long int long double *x907; /* { dg-error "" "unsigned long int long double" } */
+unsigned long int long signed *x908; /* { dg-error "" "unsigned long int long signed" } */
+unsigned long int long unsigned *x909; /* { dg-error "" "unsigned long int long unsigned" } */
+unsigned long int long _Bool *x910; /* { dg-error "" "unsigned long int long _Bool" } */
+unsigned long long int void *x911; /* { dg-error "" "unsigned long long int void" } */
+unsigned long long int char *x912; /* { dg-error "" "unsigned long long int char" } */
+unsigned long long int short *x913; /* { dg-error "" "unsigned long long int short" } */
+unsigned long long int int *x914; /* { dg-error "" "unsigned long long int int" } */
+unsigned long long int long *x915; /* { dg-error "" "unsigned long long int long" } */
+unsigned long long int float *x916; /* { dg-error "" "unsigned long long int float" } */
+unsigned long long int double *x917; /* { dg-error "" "unsigned long long int double" } */
+unsigned long long int signed *x918; /* { dg-error "" "unsigned long long int signed" } */
+unsigned long long int unsigned *x919; /* { dg-error "" "unsigned long long int unsigned" } */
+unsigned long long int _Bool *x920; /* { dg-error "" "unsigned long long int _Bool" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-1.c
new file mode 100644
index 000000000..ed89cfdee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-1.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+void abort (void);
+
+int main (void)
+{
+  int \u00C0 = 1;
+  int \u00C1 = 2;
+  int \U000000C2 = 3;
+  int wh\u00ff = 4;
+  int a\u00c4b\u0441\U000003b4e = 5;
+  
+  if (\u00C0 != 1)
+    abort ();
+  if (\u00c1 != 2)
+    abort ();
+  if (\u00C2 != 3)
+    abort ();
+  if (wh\u00ff != 4)
+    abort ();
+  if (a\u00c4b\u0441\U000003b4e != 5)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-2.c
new file mode 100644
index 000000000..d8e9186bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-2.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-xfail-if "" { powerpc-ibm-aix* *-*-solaris2.* } { "*" } { "" } } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+void abort (void);
+
+static int \u00C0 = 1;
+static int \u00C1 = 2;
+static int \U000000C2 = 3;
+static int wh\u00ff = 4;
+static int a\u00c4b\u0441\U000003b4e = 5;
+
+int main (void)
+{
+  
+  if (\u00C0 != 1)
+    abort ();
+  if (\u00c1 != 2)
+    abort ();
+  if (\u00C2 != 3)
+    abort ();
+  if (wh\u00ff != 4)
+    abort ();
+  if (a\u00c4b\u0441\U000003b4e != 5)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-3.c
new file mode 100644
index 000000000..1f3481bf3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-3.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-xfail-if "" { powerpc-ibm-aix* *-*-solaris2.* } { "*" } { "" } } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+void abort (void);
+
+int \u00C0 = 1;
+int \u00C1 = 2;
+int \U000000C2 = 3;
+int wh\u00ff = 4;
+int a\u00c4b\u0441\U000003b4e = 5;
+
+int main (void)
+{
+  
+  if (\u00C0 != 1)
+    abort ();
+  if (\u00c1 != 2)
+    abort ();
+  if (\u00C2 != 3)
+    abort ();
+  if (wh\u00ff != 4)
+    abort ();
+  if (a\u00c4b\u0441\U000003b4e != 5)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-4.c
new file mode 100644
index 000000000..0f1a12875
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-4.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-xfail-if "" { powerpc-ibm-aix* *-*-solaris2.* } { "*" } { "" } } */
+/* { dg-options "-std=c99 -fextended-identifiers" } */
+void abort (void);
+
+int \u00C0(void) { return 1; }
+int \u00C1(void) { return 2; }
+int \U000000C2(void) { return 3; }
+int wh\u00ff(void) { return 4; }
+int a\u00c4b\u0441\U000003b4e(void) { return 5; }
+
+int main (void)
+{
+  
+  if (\u00C0() != 1)
+    abort ();
+  if (\u00c1() != 2)
+    abort ();
+  if (\u00C2() != 3)
+    abort ();
+  if (wh\u00ff() != 4)
+    abort ();
+  if (a\u00c4b\u0441\U000003b4e() != 5)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-5.c
new file mode 100644
index 000000000..aea57ef06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-5.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-xfail-if "" { "powerpc-ibm-aix*" } { "*" } { "" } } */
+/* { dg-skip-if "No dollar in identfiers" { "avr-*-*" } { "*" } { "" } } */
+/* { dg-options "-std=c99 -fdollars-in-identifiers -fextended-identifiers" } */
+void abort (void);
+
+int a$b(void) { return 1; }
+
+int main (void)
+{
+  
+  if (a\u0024b() != 1)
+    abort ();
+  
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-6.c
new file mode 100644
index 000000000..37433a1eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/ucnid-6.c
@@ -0,0 +1,28 @@
+/* { dg-do run */
+/* { dg-xfail-if "" { "powerpc-ibm-aix*" } { "*" } { "" } } */
+/* { dg-options "-std=c99 -fextended-identifiers -save-temps" } */
+void abort (void);
+
+int \u00C0(void) { return 1; }
+int \u00C1(void) { return 2; }
+int \U000000C2(void) { return 3; }
+int wh\u00ff(void) { return 4; }
+int a\u00c4b\u0441\U000003b4e(void) { return 5; }
+
+int main (void)
+{
+  
+  if (\u00C0() != 1)
+    abort ();
+  if (\u00c1() != 2)
+    abort ();
+  if (\u00C2() != 3)
+    abort ();
+  if (wh\u00ff() != 4)
+    abort ();
+  if (a\u00c4b\u0441\U000003b4e() != 5)
+    abort ();
+  
+  return 0;
+}
+/* { dg-final { cleanup-saved-temps } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unaligned-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unaligned-1.c
new file mode 100644
index 000000000..5df1b37e3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unaligned-1.c
@@ -0,0 +1,49 @@
+/* PR middle-end/7847 */
+/* Originator: <jk@tools.de> */
+/* { dg-do run } */
+
+/* This used to fail on SPARC at runtime because of
+   an unaligned memory access.  */
+
+typedef char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+typedef struct {
+    uint32_t address;
+    uint16_t size;
+} __attribute__ ((packed)) sml_agl_data_t;
+
+typedef struct {
+  sml_agl_data_t data[9];
+} __attribute__ ((packed)) sml_agli_t;
+
+typedef struct {
+  sml_agli_t sml_agli;
+} __attribute__ ((packed)) dsi_t;
+
+typedef struct {
+  int a;
+  dsi_t dsi_pack;
+} dvd_priv_t;
+
+int dvd_read_sector(dvd_priv_t *d, unsigned char* data)
+{
+  int i, skip=0;
+
+  for (i=0; i < 9; i++)
+    if ((skip=d->dsi_pack.sml_agli.data[i].address) != 0)
+      break;
+
+  return skip;
+}
+
+int main(void)
+{
+  static dvd_priv_t dvd_priv;
+  dvd_read_sector(&dvd_priv, 0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-1-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-1-O0.c
new file mode 100644
index 000000000..4fe5d6b11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-1-O0.c
@@ -0,0 +1,30 @@
+/* Spurious uninitialized variable warnings, case 1.
+   Taken from cppfiles.c (merge_include_chains) */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+struct list
+{
+  struct list *next;
+  int id;
+};
+
+extern void free (void *);
+
+void remove_dupes (struct list *el)
+{
+  struct list *p, *q, *r;  /* { dg-bogus "r" "uninitialized variable warning" } */
+
+  for (p = el; p; p = p->next)
+  {
+    for (q = el; q != p; q = q->next)
+      if (q->id == p->id)
+      {
+	r->next = p->next;
+	free (p);
+	p = r;
+	break;
+      }
+    r = p;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-1.c
new file mode 100644
index 000000000..060ec250b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-1.c
@@ -0,0 +1,30 @@
+/* Spurious uninitialized variable warnings, case 1.
+   Taken from cppfiles.c (merge_include_chains) */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+struct list
+{
+  struct list *next;
+  int id;
+};
+
+extern void free (void *);
+
+void remove_dupes (struct list *el)
+{
+  struct list *p, *q, *r;  /* { dg-bogus "r" "uninitialized variable warning" } */
+
+  for (p = el; p; p = p->next)
+  {
+    for (q = el; q != p; q = q->next)
+      if (q->id == p->id)
+      {
+	r->next = p->next;
+	free (p);
+	p = r;
+	break;
+      }
+    r = p;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-10-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-10-O0.c
new file mode 100644
index 000000000..f761ac91c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-10-O0.c
@@ -0,0 +1,109 @@
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+/* On Alpha EV4, dead code elimination and cfg simplification conspired
+   to leave the register containing 'C' marked live, though all references
+   to the variable had been removed.  */
+
+struct operand_data
+{
+  struct operand_data *next;
+  int index;
+  const char *predicate;
+  const char *constraint;
+  int mode;
+  unsigned char n_alternatives;
+  char address_p;
+  char strict_low;
+  char eliminable;
+  char seen;
+};
+
+struct data
+{
+  struct data *next;
+  const char *name;
+  const char *template;
+  int code_number;
+  int index_number;
+  int lineno;
+  int n_operands;
+  int n_dups;
+  int n_alternatives;
+  int operand_number;
+  int output_format;
+  struct operand_data operand[40];
+};
+
+extern void message_with_line (int, const char *, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int have_error;
+
+extern char *strchr (__const char *__s, int __c) __attribute__ ((__pure__));
+
+void
+validate_insn_alternatives (d)
+     struct data *d;
+{
+  int n = 0, start;
+
+  for (start = 0; start < d->n_operands; start++)
+    if (d->operand[start].n_alternatives > 0)
+      {
+        int len, i;
+        const char *p;
+        char c;	 /* { dg-bogus "used uninitialized" "uninitialized variable warning" } */
+        int which_alternative = 0;
+        int alternative_count_unsure = 0;
+
+        for (p = d->operand[start].constraint; (c = *p); p += len)
+          {
+            len = 1;
+
+            if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
+              {
+                message_with_line (d->lineno,
+                                   "invalid length %d for char '%c' in alternative %d of operand %d",
+                                    len, c, which_alternative, start);
+                len = 1;
+                have_error = 1;
+              }
+
+            if (c == ',')
+              {
+                which_alternative++;
+                continue;
+              }
+
+            for (i = 1; i < len; i++)
+              if (p[i] == '\0')
+                {
+                  message_with_line (d->lineno,
+                                     "NUL in alternative %d of operand %d",
+                                     which_alternative, start);
+                  alternative_count_unsure = 1;
+                  break;
+                }
+              else if (strchr (",#*", p[i]))
+                {
+                  message_with_line (d->lineno,
+                                     "'%c' in alternative %d of operand %d",
+                                     p[i], which_alternative, start);
+                  alternative_count_unsure = 1;
+                }
+          }
+        if (alternative_count_unsure)
+          have_error = 1;
+        else if (n == 0)
+          n = d->operand[start].n_alternatives;
+        else if (n != d->operand[start].n_alternatives)
+          {
+            message_with_line (d->lineno,
+                               "wrong number of alternatives in operand %d",
+                               start);
+            have_error = 1;
+          }
+      }
+
+
+  d->n_alternatives = n;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-10.c
new file mode 100644
index 000000000..0d62020df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-10.c
@@ -0,0 +1,109 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+/* On Alpha EV4, dead code elimination and cfg simplification conspired
+   to leave the register containing 'C' marked live, though all references
+   to the variable had been removed.  */
+
+struct operand_data
+{
+  struct operand_data *next;
+  int index;
+  const char *predicate;
+  const char *constraint;
+  int mode;
+  unsigned char n_alternatives;
+  char address_p;
+  char strict_low;
+  char eliminable;
+  char seen;
+};
+
+struct data
+{
+  struct data *next;
+  const char *name;
+  const char *template;
+  int code_number;
+  int index_number;
+  int lineno;
+  int n_operands;
+  int n_dups;
+  int n_alternatives;
+  int operand_number;
+  int output_format;
+  struct operand_data operand[40];
+};
+
+extern void message_with_line (int, const char *, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int have_error;
+
+extern char *strchr (__const char *__s, int __c) __attribute__ ((__pure__));
+
+void
+validate_insn_alternatives (d)
+     struct data *d;
+{
+  int n = 0, start;
+
+  for (start = 0; start < d->n_operands; start++)
+    if (d->operand[start].n_alternatives > 0)
+      {
+        int len, i;
+        const char *p;
+        char c;	 /* { dg-bogus "used uninitialized" "uninitialized variable warning" } */
+        int which_alternative = 0;
+        int alternative_count_unsure = 0;
+
+        for (p = d->operand[start].constraint; (c = *p); p += len)
+          {
+            len = 1;
+
+            if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
+              {
+                message_with_line (d->lineno,
+                                   "invalid length %d for char '%c' in alternative %d of operand %d",
+                                    len, c, which_alternative, start);
+                len = 1;
+                have_error = 1;
+              }
+
+            if (c == ',')
+              {
+                which_alternative++;
+                continue;
+              }
+
+            for (i = 1; i < len; i++)
+              if (p[i] == '\0')
+                {
+                  message_with_line (d->lineno,
+                                     "NUL in alternative %d of operand %d",
+                                     which_alternative, start);
+                  alternative_count_unsure = 1;
+                  break;
+                }
+              else if (strchr (",#*", p[i]))
+                {
+                  message_with_line (d->lineno,
+                                     "'%c' in alternative %d of operand %d",
+                                     p[i], which_alternative, start);
+                  alternative_count_unsure = 1;
+                }
+          }
+        if (alternative_count_unsure)
+          have_error = 1;
+        else if (n == 0)
+          n = d->operand[start].n_alternatives;
+        else if (n != d->operand[start].n_alternatives)
+          {
+            message_with_line (d->lineno,
+                               "wrong number of alternatives in operand %d",
+                               start);
+            have_error = 1;
+          }
+      }
+
+
+  d->n_alternatives = n;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-11-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-11-O0.c
new file mode 100644
index 000000000..23af4f69a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-11-O0.c
@@ -0,0 +1,42 @@
+/* Positive test for uninitialized variables.  */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+int sink;
+
+void f1(int parm)	/* { dg-bogus "uninitialized" "parameter" } */
+{
+  sink = parm;		/* { dg-bogus "uninitialized" "parameter" } */
+}
+
+void f2(void)
+{
+  int x;
+  sink = x;		/* { dg-warning "is used" "unconditional" } */
+}
+
+void f3(int p)
+{
+  int x;		/* { dg-warning "may be used" "conditional" { xfail *-*-* } } */
+  if (p)
+    x = p;
+  sink = x;
+}
+
+void f4(int p)
+{
+  int x;		/* { dg-bogus "uninitialized" "easy if" } */
+  if (p)
+    x = 1;
+  else
+    x = 2;
+  sink = x;
+}
+
+void f5(void)
+{
+  int x, i;		/* { dg-bogus "uninitialized" "easy loop" } */
+  for (i = 0; i < 10; ++i)
+    x = 1;
+  sink = x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-11.c
new file mode 100644
index 000000000..2730534e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-11.c
@@ -0,0 +1,42 @@
+/* Positive test for uninitialized variables.  */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+int sink;
+
+void f1(int parm)	/* { dg-bogus "uninitialized" "parameter" } */
+{
+  sink = parm;		/* { dg-bogus "uninitialized" "parameter" } */
+}
+
+void f2(void)
+{
+  int x;
+  sink = x;		/* { dg-warning "is used" "unconditional" } */
+}
+
+void f3(int p)
+{
+  int x;		
+  if (p)
+    x = p;
+  sink = x;            /* { dg-warning "may be used" "conditional" } */
+}
+
+void f4(int p)
+{
+  int x;		/* { dg-bogus "uninitialized" "easy if" } */
+  if (p)
+    x = 1;
+  else
+    x = 2;
+  sink = x;
+}
+
+void f5(void)
+{
+  int x, i;		/* { dg-bogus "uninitialized" "easy loop" } */
+  for (i = 0; i < 10; ++i)
+    x = 1;
+  sink = x;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-12-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-12-O0.c
new file mode 100644
index 000000000..7c0664e4d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-12-O0.c
@@ -0,0 +1,12 @@
+/* PR 23497 */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+typedef _Complex float C;
+C foo()
+{
+  C f;
+  __real__ f = 0;
+  __imag__ f = 0;
+  return f;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-12.c
new file mode 100644
index 000000000..7889e5370
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-12.c
@@ -0,0 +1,12 @@
+/* PR 23497 */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+typedef _Complex float C;
+C foo()
+{
+  C f;
+  __real__ f = 0;
+  __imag__ f = 0;
+  return f;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-13-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-13-O0.c
new file mode 100644
index 000000000..af80fa88c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-13-O0.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+typedef _Complex float C;
+C foo()
+{
+  C f;
+  __imag__ f = 0;	/* { dg-warning "is used" "unconditional" { xfail *-*-* } } */
+  return f;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-13.c
new file mode 100644
index 000000000..631e8de3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-13.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+typedef _Complex float C;
+C foo()
+{
+  C f;
+  __imag__ f = 0;	/* { dg-warning "is used" "unconditional" } */
+  return f;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-14-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-14-O0.c
new file mode 100644
index 000000000..abde6ca86
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-14-O0.c
@@ -0,0 +1,20 @@
+/* PR 24931 */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+struct p {
+        short x, y;
+};
+
+struct s {
+        int i;
+        struct p p;
+};
+
+struct s f()
+{
+        struct s s;
+        s.p = (struct p){};
+        s.i = (s.p.x || s.p.y);
+        return s;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-14.c
new file mode 100644
index 000000000..41b4f622a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-14.c
@@ -0,0 +1,20 @@
+/* PR 24931 */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+struct p {
+        short x, y;
+};
+
+struct s {
+        int i;
+        struct p p;
+};
+
+struct s f()
+{
+        struct s s;
+        s.p = (struct p){};
+        s.i = (s.p.x || s.p.y);
+        return s;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-15-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-15-O0.c
new file mode 100644
index 000000000..a3fd2b63b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-15-O0.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+/* XFAIL for now, the uninitialized pass runs before inlining only at -O0.  */
+
+inline int __attribute__((always_inline))
+foo (int i)
+{
+    if (i) return 1; /* { dg-warning "is used uninitialized" {} { xfail *-*-* } } */
+    return 0;
+}
+
+void baz();
+
+void bar()
+{
+    int j;           /* { dg-message "was declared here" {} { xfail *-*-* } } */
+    for (; foo(j); ++j)
+        baz();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-15.c
new file mode 100644
index 000000000..20bea95ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-15.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/17506
+   We issue an uninitialized variable warning at a wrong location at
+   line 11, which is very confusing.  Make sure we print out a note to
+   make it less confusing.  (xfailed alternative)
+   But it is of course ok if we warn in bar about uninitialized use
+   of j.  (not xfailed alternative)  */
+/* { dg-do compile } */
+/* { dg-options "-O1 -Wuninitialized" } */
+
+inline int
+foo (int i)
+{
+  if (i) /* { dg-warning "used uninitialized in this function" "" { xfail *-*-* } } */
+    return 1;
+  return 0;
+}
+
+void baz (void);
+
+void
+bar (void)
+{
+  int j; /* { dg-message "note: 'j' was declared here" "" { xfail *-*-* } } */
+  for (; foo (j); ++j)  /* { dg-warning "'j' is used uninitialized" } */
+    baz ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-16.c
new file mode 100644
index 000000000..e039f7026
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-16.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+int foo, bar;
+
+static
+void decode_reloc(int reloc, int *is_alt)
+{
+  if (reloc >= 20)
+      *is_alt = 1;
+  else if (reloc >= 10)
+      *is_alt = 0;
+}
+
+void testfunc()
+{
+  int alt_reloc;
+
+  decode_reloc(foo, &alt_reloc);
+
+  if (alt_reloc) /* { dg-warning "may be used uninitialized" } */
+    bar = 42;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-2-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-2-O0.c
new file mode 100644
index 000000000..62a23fa6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-2-O0.c
@@ -0,0 +1,52 @@
+/* Spurious uninitialized variable warnings, case 2.
+   Taken from cpphash.c (macroexpand) */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+struct definition
+{
+  int nargs;
+  int rest_args;
+};
+
+struct cpp_reader;
+
+enum cpp_token
+{
+  CPP_EOF, CPP_POP, CPP_COMMA, CPP_RPAREN
+};
+
+extern enum cpp_token macarg (struct cpp_reader *, int);
+
+void
+macroexpand (struct cpp_reader *pfile, struct definition *defn)
+{
+  int nargs = defn->nargs;
+
+  if (nargs >= 0)
+    {
+      enum cpp_token token;  /* { dg-bogus "token" "uninitialized variable warning" } */
+      int i, rest_args;
+      i = 0;
+      rest_args = 0;
+      do
+	{
+	  if (rest_args)
+	    continue;
+	  if (i < nargs || (nargs == 0 && i == 0))
+	    {
+	      /* if we are working on last arg which absorbs rest of args... */
+	      if (i == nargs - 1 && defn->rest_args)
+		rest_args = 1;
+	      token = macarg (pfile, rest_args);
+	    }
+	  else
+	    token = macarg (pfile, 0);
+	  if (token == CPP_EOF || token == CPP_POP)
+	    return;
+
+	  i++;
+	}
+      while (token == CPP_COMMA);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-2.c
new file mode 100644
index 000000000..352bbac06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-2.c
@@ -0,0 +1,52 @@
+/* Spurious uninitialized variable warnings, case 2.
+   Taken from cpphash.c (macroexpand) */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+struct definition
+{
+  int nargs;
+  int rest_args;
+};
+
+struct cpp_reader;
+
+enum cpp_token
+{
+  CPP_EOF, CPP_POP, CPP_COMMA, CPP_RPAREN
+};
+
+extern enum cpp_token macarg (struct cpp_reader *, int);
+
+void
+macroexpand (struct cpp_reader *pfile, struct definition *defn)
+{
+  int nargs = defn->nargs;
+
+  if (nargs >= 0)
+    {
+      enum cpp_token token;  /* { dg-bogus "token" "uninitialized variable warning" } */
+      int i, rest_args;
+      i = 0;
+      rest_args = 0;
+      do
+	{
+	  if (rest_args)
+	    continue;
+	  if (i < nargs || (nargs == 0 && i == 0))
+	    {
+	      /* if we are working on last arg which absorbs rest of args... */
+	      if (i == nargs - 1 && defn->rest_args)
+		rest_args = 1;
+	      token = macarg (pfile, rest_args);
+	    }
+	  else
+	    token = macarg (pfile, 0);
+	  if (token == CPP_EOF || token == CPP_POP)
+	    return;
+
+	  i++;
+	}
+      while (token == CPP_COMMA);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-3-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-3-O0.c
new file mode 100644
index 000000000..d3dcf14ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-3-O0.c
@@ -0,0 +1,33 @@
+/* Spurious uninit variable warnings, case 3.
+   Inspired by cppexp.c (parse_charconst) */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+extern void error (char *);
+
+int
+parse_charconst (const char *start, const char *end)
+{
+  int c; /* { dg-bogus "c" "uninitialized variable warning" } */
+  int nchars, retval;
+
+  nchars = 0;
+  retval = 0;
+  while (start < end)
+    {
+      c = *start++;
+      if (c == '\'')
+	break;
+      nchars++;
+      retval += c;
+      retval <<= 8;
+    }
+
+  if (nchars == 0)
+    return 0;
+
+  if (c != '\'')
+    error ("malformed character constant");
+
+  return retval;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-3.c
new file mode 100644
index 000000000..ac5bfec8e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-3.c
@@ -0,0 +1,33 @@
+/* Spurious uninit variable warnings, case 3.
+   Inspired by cppexp.c (parse_charconst) */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+extern void error (char *);
+
+int
+parse_charconst (const char *start, const char *end)
+{
+  int c; /* { dg-bogus "c" "uninitialized variable warning" } */
+  int nchars, retval;
+
+  nchars = 0;
+  retval = 0;
+  while (start < end)
+    {
+      c = *start++;
+      if (c == '\'')
+	break;
+      nchars++;
+      retval += c;
+      retval <<= 8;
+    }
+
+  if (nchars == 0)
+    return 0;
+
+  if (c != '\'')
+    error ("malformed character constant");
+
+  return retval;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-4-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-4-O0.c
new file mode 100644
index 000000000..0b9aeea7d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-4-O0.c
@@ -0,0 +1,52 @@
+/* Spurious uninit variable warnings, case 4.
+   Simplified version of cppexp.c (cpp_parse_expr).
+
+   This one is really fragile, it gets it right if you take out case
+   1, or if the structure is replaced by an int, or if the structure
+   has fewer members (!) */
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+extern void abort (void);
+
+struct operation {
+    short op;
+    char rprio;
+    char flags;
+    char unsignedp;
+    long value;
+};
+
+extern struct operation cpp_lex (void);
+
+void
+cpp_parse_expr (void)
+{
+  int rprio; /* { dg-bogus "rprio" "uninitialized variable warning PR19833" } */
+  struct operation op;
+
+  for (;;)
+    {
+      op = cpp_lex ();
+
+      switch (op.op)
+	{
+	case 0:
+	  break;
+	case 1:
+	  return;
+	case 2:
+	  rprio = 1;
+	  break;
+	default:
+	  return;
+	}
+
+      if (op.op == 0)
+	return;
+
+      if (rprio != 1)
+	abort();
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-4.c
new file mode 100644
index 000000000..d39ecac77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-4.c
@@ -0,0 +1,52 @@
+/* Spurious uninit variable warnings, case 4.
+   Simplified version of cppexp.c (cpp_parse_expr).
+
+   This one is really fragile, it gets it right if you take out case
+   1, or if the structure is replaced by an int, or if the structure
+   has fewer members (!) */
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+extern void abort (void);
+
+struct operation {
+    short op;
+    char rprio;
+    char flags;
+    char unsignedp;
+    long value;
+};
+
+extern struct operation cpp_lex (void);
+
+void
+cpp_parse_expr (void)
+{
+  int rprio; /* { dg-bogus "rprio" "uninitialized variable warning PR19833" } */
+  struct operation op;
+
+  for (;;)
+    {
+      op = cpp_lex ();
+
+      switch (op.op)
+	{
+	case 0:
+	  break;
+	case 1:
+	  return;
+	case 2:
+	  rprio = 1;
+	  break;
+	default:
+	  return;
+	}
+
+      if (op.op == 0)
+	return;
+
+      if (rprio != 1)
+	abort();
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-5-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-5-O0.c
new file mode 100644
index 000000000..d9784b3f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-5-O0.c
@@ -0,0 +1,39 @@
+/* Spurious uninitialized-variable warnings.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+extern void use(int);
+extern void foo(void);
+
+void
+func1(int cond)
+{
+    int x;  /* { dg-bogus "x" "uninitialized variable warning" } */
+
+    if(cond)
+	x = 1;
+
+    foo();
+
+    if(cond)
+	use(x);
+}
+
+void
+func2 (int cond)
+{
+    int x;  /* { dg-bogus "x" "uninitialized variable warning" } */
+    int flag = 0;
+
+    if(cond)
+    {
+	x = 1;
+	flag = 1;
+    }
+
+    foo();
+
+    if(flag)
+	use(x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-5.c
new file mode 100644
index 000000000..df2a27c44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-5.c
@@ -0,0 +1,39 @@
+/* Spurious uninitialized-variable warnings.  */
+/* Disable jump threading, etc to test compiler analysis.  */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized -fno-tree-dce -fno-tree-vrp -fno-tree-dominator-opts" } */
+
+extern void use(int);
+extern void foo(void);
+
+void
+func1(int cond)
+{
+    int x;  /* { dg-bogus "x" "uninitialized variable warning" } */
+
+    if(cond)
+	x = 1;
+
+    foo();
+
+    if(cond)
+	use(x);
+}
+
+void
+func2 (int cond)
+{
+    int x;  /* { dg-bogus "x" "uninitialized variable warning" } */
+    int flag = 0;
+
+    if(cond)
+    {
+	x = 1;
+	flag = 1;
+    }
+
+    foo();
+
+    if(flag)
+	use(x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-6-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-6-O0.c
new file mode 100644
index 000000000..e3fefe5e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-6-O0.c
@@ -0,0 +1,47 @@
+/* Spurious uninitialized variable warnings.
+   This one inspired by java/class.c:build_utf8_ref.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+#include <stddef.h>
+
+struct tree
+{
+    struct tree *car;
+    struct tree *cdr;
+    int type, data;
+};
+
+extern void *malloc(size_t);
+
+#define INTEGER_T 1
+#define PTR_T	  2
+
+#define APPEND(TREE, LAST, TYPE, VALUE)				\
+do {								\
+     struct tree *tmp = malloc (sizeof (struct tree));		\
+     tmp->car = 0; tmp->cdr = 0; tmp->type = TYPE;		\
+     tmp->data = VALUE;						\
+     if (TREE->car)						\
+	 LAST->cdr = tmp;					\
+     else							\
+	 TREE->car = tmp;					\
+     LAST = tmp;						\
+} while(0)
+ 
+struct tree *
+make_something(int a, int b, int c)
+{
+    struct tree *rv;
+    struct tree *field;
+
+    rv = malloc (sizeof (struct tree));
+    rv->car = 0;
+
+    APPEND(rv, field, INTEGER_T, a);  /* { dg-bogus "field" "uninitialized variable warning" { xfail *-*-* } } */
+    APPEND(rv, field, PTR_T, b);
+    APPEND(rv, field, INTEGER_T, c);
+
+    return rv;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-6.c
new file mode 100644
index 000000000..b0f2083ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-6.c
@@ -0,0 +1,47 @@
+/* Spurious uninitialized variable warnings.
+   This one inspired by java/class.c:build_utf8_ref.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+#include <stddef.h>
+
+struct tree
+{
+    struct tree *car;
+    struct tree *cdr;
+    int type, data;
+};
+
+extern void *malloc(size_t);
+
+#define INTEGER_T 1
+#define PTR_T	  2
+
+#define APPEND(TREE, LAST, TYPE, VALUE)				\
+do {								\
+     struct tree *tmp = malloc (sizeof (struct tree));		\
+     tmp->car = 0; tmp->cdr = 0; tmp->type = TYPE;		\
+     tmp->data = VALUE;						\
+     if (TREE->car)						\
+	 LAST->cdr = tmp;					\
+     else							\
+	 TREE->car = tmp;					\
+     LAST = tmp;						\
+} while(0)
+ 
+struct tree *
+make_something(int a, int b, int c)
+{
+    struct tree *rv;
+    struct tree *field;
+
+    rv = malloc (sizeof (struct tree));
+    rv->car = 0;
+
+    APPEND(rv, field, INTEGER_T, a);  /* { dg-bogus "field" "uninitialized variable warning" { xfail *-*-* } } */
+    APPEND(rv, field, PTR_T, b);
+    APPEND(rv, field, INTEGER_T, c);
+
+    return rv;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-8-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-8-O0.c
new file mode 100644
index 000000000..b386896c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-8-O0.c
@@ -0,0 +1,32 @@
+/* Uninitialized variable warning tests...
+   Inspired by part of optabs.c:expand_binop.
+   May be the same as uninit-1.c.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+#include <limits.h>
+
+void
+add_bignums (int *out, int *x, int *y)
+{
+    int p, sum;
+    int carry; /* { dg-bogus "carry" "uninitialized variable warning" } */
+
+    p = 0;
+    for (; *x; x++, y++, out++, p++)
+    {
+	if (p)
+	    sum = *x + *y + carry;
+	else
+	    sum = *x + *y;
+
+	if (sum < 0)
+	{
+	    carry = 1;
+	    sum -= INT_MAX;
+	}
+	else
+	    carry = 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-8.c
new file mode 100644
index 000000000..98700f4aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-8.c
@@ -0,0 +1,32 @@
+/* Uninitialized variable warning tests...
+   Inspired by part of optabs.c:expand_binop.
+   May be the same as uninit-1.c.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+#include <limits.h>
+
+void
+add_bignums (int *out, int *x, int *y)
+{
+    int p, sum;
+    int carry; /* { dg-bogus "carry" "uninitialized variable warning" } */
+
+    p = 0;
+    for (; *x; x++, y++, out++, p++)
+    {
+	if (p)
+	    sum = *x + *y + carry;
+	else
+	    sum = *x + *y;
+
+	if (sum < 0)
+	{
+	    carry = 1;
+	    sum -= INT_MAX;
+	}
+	else
+	    carry = 0;
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-9-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-9-O0.c
new file mode 100644
index 000000000..493dd68d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-9-O0.c
@@ -0,0 +1,41 @@
+/* Spurious uninitialized variable warnings.  Slight variant on the
+   documented case, inspired by reg-stack.c:record_asm_reg_life.  */
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+struct foo
+{
+    int type;
+    struct foo *car;
+    struct foo *cdr;
+    char *data;
+    int data2;
+};
+
+extern void use(struct foo *);
+
+#define CLOBBER 6
+#define PARALLEL 3
+
+void
+func(struct foo *list, int count)
+{
+    int n_clobbers = 0;
+    int i;
+    struct foo **clob_list;   /* { dg-bogus "clob_list" "uninitialized variable warning" } */
+
+    if(list[0].type == PARALLEL)
+    {
+	clob_list = __builtin_alloca(count * sizeof(struct foo *));
+	
+	for(i = 1; i < count; i++)
+	{
+	    if(list[i].type == CLOBBER)
+		clob_list[n_clobbers++] = &list[i];
+	}
+    }
+
+    for(i = 0; i < n_clobbers; i++)
+	use(clob_list[i]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-9.c
new file mode 100644
index 000000000..2a8ccb69f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-9.c
@@ -0,0 +1,41 @@
+/* Spurious uninitialized variable warnings.  Slight variant on the
+   documented case, inspired by reg-stack.c:record_asm_reg_life.  */
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+struct foo
+{
+    int type;
+    struct foo *car;
+    struct foo *cdr;
+    char *data;
+    int data2;
+};
+
+extern void use(struct foo *);
+
+#define CLOBBER 6
+#define PARALLEL 3
+
+void
+func(struct foo *list, int count)
+{
+    int n_clobbers = 0;
+    int i;
+    struct foo **clob_list;   /* { dg-bogus "clob_list" "uninitialized variable warning" } */
+
+    if(list[0].type == PARALLEL)
+    {
+	clob_list = __builtin_alloca(count * sizeof(struct foo *));
+	
+	for(i = 1; i < count; i++)
+	{
+	    if(list[i].type == CLOBBER)
+		clob_list[n_clobbers++] = &list[i];
+	}
+    }
+
+    for(i = 0; i < n_clobbers; i++)
+	use(clob_list[i]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-A-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-A-O0.c
new file mode 100644
index 000000000..693769115
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-A-O0.c
@@ -0,0 +1,117 @@
+/* Inspired by part of java/parse.y.
+   May be a real bug in CSE. */
+
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+struct tree
+{
+    struct tree *car, *cdr, *wfl;
+    int code;
+    struct { unsigned int renp:1;
+      unsigned int rtnp:1;
+      unsigned int rpnp:1; } flags;
+};
+typedef struct tree *tree;
+#define NULL_TREE ((tree)0)
+
+/* Codes */
+enum
+{
+    CALL_EXPR, NEW_ARRAY_EXPR, NEW_CLASS_EXPR, CONVERT_EXPR,
+    ARRAY_REF, CONDITIONAL_EXPR, STRING_CST, EXPR_WITH_FILE_LOCATION
+};
+
+/* Flags */
+#define RESOLVE_EXPRESSION_NAME_P(t) ((t)->flags.renp)
+#define RESOLVE_TYPE_NAME_P(t) ((t)->flags.rtnp)
+#define RESOLVE_PACKAGE_NAME_P(t) ((t)->flags.rpnp)
+
+/* Macros */
+#define EXPR_WFL_QUALIFICATION(t) ((t)->wfl)
+#define QUAL_WFL(t) ((t)->wfl)
+#define EXPR_WFL_NODE(t) ((t)->wfl)
+#define TREE_CODE(t) ((t)->code)
+#define TREE_OPERAND(t,x) ((t)->car)
+#define CLASSTYPE_SUPER(t) ((t)->car)
+#define IDENTIFIER_LOCAL_VALUE(t) ((t)->car)
+#define TREE_CHAIN(t) ((t)->cdr)
+#define QUAL_RESOLUTION(t) ((t)->cdr)
+
+extern tree current_class, this_identifier_node;
+extern tree super_identifier_node, length_identifier_node;
+
+tree resolve_and_layout (tree, tree);
+tree lookup_field_wrapper (tree, tree);
+
+void
+qualify_ambiguous_name (id)
+     tree id;
+{
+  tree qual, qual_wfl, decl;
+  tree name;	 /* { dg-bogus "name" "uninitialized variable warning" } */
+  tree ptr_type; /* { dg-bogus "ptr_type" "uninitialized variable warning" } */
+  int again, new_array_found = 0;
+  int super_found = 0, this_found = 0;
+
+  qual = EXPR_WFL_QUALIFICATION (id);
+  do {
+    qual_wfl = QUAL_WFL (qual);
+    switch (TREE_CODE (qual_wfl))
+      {
+      case CALL_EXPR:
+	qual_wfl = TREE_OPERAND (qual_wfl, 0);
+	if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+	  {
+	    qual = EXPR_WFL_QUALIFICATION (qual_wfl);
+	    qual_wfl = QUAL_WFL (qual);
+	  }
+	break;
+      case NEW_ARRAY_EXPR:
+	qual = TREE_CHAIN (qual);
+	new_array_found = again = 1;
+	continue;
+      case NEW_CLASS_EXPR:
+      case CONVERT_EXPR:
+	qual_wfl = TREE_OPERAND (qual_wfl, 0);
+	break;
+      case ARRAY_REF:
+	while (TREE_CODE (qual_wfl) == ARRAY_REF)
+	  qual_wfl = TREE_OPERAND (qual_wfl, 0);
+	break;
+      default:
+	break;
+      }
+
+    name = EXPR_WFL_NODE (qual_wfl);
+    ptr_type = current_class;
+    again = 0;
+
+  } while (again);
+
+  /* If you put straightforward uses of name and ptr_type here
+     instead of the if-else sequence below, the warnings go away.
+     Therefore I suspect a real bug. */
+  
+  if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name)))
+    {
+      RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+      QUAL_RESOLUTION (qual) = decl;
+    }
+  else if ((decl = lookup_field_wrapper (ptr_type, name))
+	   || (new_array_found && name == length_identifier_node))
+    {
+      RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+      QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
+    }
+  else if ((decl = resolve_and_layout (name, NULL_TREE)))
+    {
+      RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
+      QUAL_RESOLUTION (qual) = decl;
+    }
+  else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
+	   || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF)
+    RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+  else 
+    RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-A.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-A.c
new file mode 100644
index 000000000..28f7fe9fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-A.c
@@ -0,0 +1,117 @@
+/* Inspired by part of java/parse.y.
+   May be a real bug in CSE. */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wall" } */
+
+struct tree
+{
+    struct tree *car, *cdr, *wfl;
+    int code;
+    struct { unsigned int renp:1;
+      unsigned int rtnp:1;
+      unsigned int rpnp:1; } flags;
+};
+typedef struct tree *tree;
+#define NULL_TREE ((tree)0)
+
+/* Codes */
+enum
+{
+    CALL_EXPR, NEW_ARRAY_EXPR, NEW_CLASS_EXPR, CONVERT_EXPR,
+    ARRAY_REF, CONDITIONAL_EXPR, STRING_CST, EXPR_WITH_FILE_LOCATION
+};
+
+/* Flags */
+#define RESOLVE_EXPRESSION_NAME_P(t) ((t)->flags.renp)
+#define RESOLVE_TYPE_NAME_P(t) ((t)->flags.rtnp)
+#define RESOLVE_PACKAGE_NAME_P(t) ((t)->flags.rpnp)
+
+/* Macros */
+#define EXPR_WFL_QUALIFICATION(t) ((t)->wfl)
+#define QUAL_WFL(t) ((t)->wfl)
+#define EXPR_WFL_NODE(t) ((t)->wfl)
+#define TREE_CODE(t) ((t)->code)
+#define TREE_OPERAND(t,x) ((t)->car)
+#define CLASSTYPE_SUPER(t) ((t)->car)
+#define IDENTIFIER_LOCAL_VALUE(t) ((t)->car)
+#define TREE_CHAIN(t) ((t)->cdr)
+#define QUAL_RESOLUTION(t) ((t)->cdr)
+
+extern tree current_class, this_identifier_node;
+extern tree super_identifier_node, length_identifier_node;
+
+tree resolve_and_layout (tree, tree);
+tree lookup_field_wrapper (tree, tree);
+
+void
+qualify_ambiguous_name (id)
+     tree id;
+{
+  tree qual, qual_wfl, decl;
+  tree name;	 /* { dg-bogus "name" "uninitialized variable warning" } */
+  tree ptr_type; /* { dg-bogus "ptr_type" "uninitialized variable warning" } */
+  int again, new_array_found = 0;
+  int super_found = 0, this_found = 0;
+
+  qual = EXPR_WFL_QUALIFICATION (id);
+  do {
+    qual_wfl = QUAL_WFL (qual);
+    switch (TREE_CODE (qual_wfl))
+      {
+      case CALL_EXPR:
+	qual_wfl = TREE_OPERAND (qual_wfl, 0);
+	if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+	  {
+	    qual = EXPR_WFL_QUALIFICATION (qual_wfl);
+	    qual_wfl = QUAL_WFL (qual);
+	  }
+	break;
+      case NEW_ARRAY_EXPR:
+	qual = TREE_CHAIN (qual);
+	new_array_found = again = 1;
+	continue;
+      case NEW_CLASS_EXPR:
+      case CONVERT_EXPR:
+	qual_wfl = TREE_OPERAND (qual_wfl, 0);
+	break;
+      case ARRAY_REF:
+	while (TREE_CODE (qual_wfl) == ARRAY_REF)
+	  qual_wfl = TREE_OPERAND (qual_wfl, 0);
+	break;
+      default:
+	break;
+      }
+
+    name = EXPR_WFL_NODE (qual_wfl);
+    ptr_type = current_class;
+    again = 0;
+
+  } while (again);
+
+  /* If you put straightforward uses of name and ptr_type here
+     instead of the if-else sequence below, the warnings go away.
+     Therefore I suspect a real bug. */
+  
+  if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name)))
+    {
+      RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+      QUAL_RESOLUTION (qual) = decl;
+    }
+  else if ((decl = lookup_field_wrapper (ptr_type, name))
+	   || (new_array_found && name == length_identifier_node))
+    {
+      RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+      QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
+    }
+  else if ((decl = resolve_and_layout (name, NULL_TREE)))
+    {
+      RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
+      QUAL_RESOLUTION (qual) = decl;
+    }
+  else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
+	   || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF)
+    RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+  else 
+    RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-2.c
new file mode 100644
index 000000000..ee8a88581
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-2.c
@@ -0,0 +1,16 @@
+/* Origin: PR c/179 inverse of uninit-B-O0.c, we should not warn.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+extern void foo (int *);
+extern void bar (int);
+
+void
+baz (void)
+{
+  int i;
+  foo (&i); /* { dg-bogus "is used uninitialized" "uninit i warning" } */
+  if (i) 
+    bar (i);
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-O0-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-O0-2.c
new file mode 100644
index 000000000..dfa3de97e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-O0-2.c
@@ -0,0 +1,16 @@
+/* Origin: PR c/179 inverse of uninit-B-O0.c, we should not warn.  */
+/* { dg-do compile } */
+/* { dg-options "-O0 -Wuninitialized" } */
+extern void foo (int *);
+extern void bar (int);
+
+void
+baz (void)
+{
+  int i;
+  foo (&i); /* { dg-bogus "is used uninitialized" "uninit i warning" } */
+  if (i) 
+    bar (i);
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-O0.c
new file mode 100644
index 000000000..e2883a38e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B-O0.c
@@ -0,0 +1,15 @@
+/* Origin: PR c/179 from Gray Watson <gray@256.com>, adapted as a testcase
+   by Joseph Myers <jsm28@cam.ac.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+extern void foo (int *);
+extern void bar (int);
+
+void
+baz (void)
+{
+  int i;
+  if (i) /* { dg-warning "uninit" "uninit i warning" { xfail *-*-* } } */
+    bar (i);
+  foo (&i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B.c
new file mode 100644
index 000000000..adb1461d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-B.c
@@ -0,0 +1,15 @@
+/* Origin: PR c/179 from Gray Watson <gray@256.com>, adapted as a testcase
+   by Joseph Myers <jsm28@cam.ac.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+extern void foo (int *);
+extern void bar (int);
+
+void
+baz (void)
+{
+  int i;
+  if (i) /* { dg-warning "is used uninitialized" "uninit i warning" } */
+    bar (i);
+  foo (&i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-C-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-C-O0.c
new file mode 100644
index 000000000..305dd3670
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-C-O0.c
@@ -0,0 +1,21 @@
+/* Spurious uninitialized variable warning, inspired by libgcc2.c.  */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+/* Not all platforms support TImode integers.  */
+#if defined(__LP64__) && !defined(__hppa__)
+typedef int TItype __attribute__ ((mode (TI)));
+#else
+typedef long TItype;
+#endif
+
+
+TItype
+__subvdi3 (TItype a, TItype b)
+{
+  TItype w;
+  
+  w = a - b;
+  
+  return w;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-C.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-C.c
new file mode 100644
index 000000000..741106cb4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-C.c
@@ -0,0 +1,21 @@
+/* Spurious uninitialized variable warning, inspired by libgcc2.c.  */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+/* Not all platforms support TImode integers.  */
+#if defined(__LP64__) && !defined(__hppa__)
+typedef int TItype __attribute__ ((mode (TI)));
+#else
+typedef long TItype;
+#endif
+
+
+TItype
+__subvdi3 (TItype a, TItype b)
+{
+  TItype w;
+  
+  w = a - b;
+  
+  return w;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-D-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-D-O0.c
new file mode 100644
index 000000000..e63cb80ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-D-O0.c
@@ -0,0 +1,9 @@
+/* Test we do not warn about initializing variable with self. */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+int f()
+{
+  int i = i;
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-D.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-D.c
new file mode 100644
index 000000000..ea957e49e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-D.c
@@ -0,0 +1,9 @@
+/* Test we do not warn about initializing variable with self. */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+int f()
+{
+  int i = i;
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-E-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-E-O0.c
new file mode 100644
index 000000000..2cc245966
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-E-O0.c
@@ -0,0 +1,9 @@
+/* Test we do warn about initializing variable with self when -Winit-self is supplied. */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -Winit-self" } */
+
+int f()
+{
+  int i = i; /* { dg-warning "i" "uninitialized variable warning" }  */
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-E.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-E.c
new file mode 100644
index 000000000..eb356c3ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-E.c
@@ -0,0 +1,9 @@
+/* Test we do warn about initializing variable with self when -Winit-self is supplied. */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized -Winit-self" } */
+
+int f()
+{
+  int i = i; /* { dg-warning "i" "uninitialized variable warning" }  */
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-F-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-F-O0.c
new file mode 100644
index 000000000..737cc6500
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-F-O0.c
@@ -0,0 +1,9 @@
+/* Test we do warn about initializing variable with self in the initialization. */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+int f()
+{
+  int i = i + 1; /* { dg-warning "i" "uninitialized variable warning" }  */
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-F.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-F.c
new file mode 100644
index 000000000..1dbb365e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-F.c
@@ -0,0 +1,9 @@
+/* Test we do warn about initializing variable with self in the initialization. */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+int f()
+{
+  int i = i + 1; /* { dg-warning "i" "uninitialized variable warning" }  */
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-G-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-G-O0.c
new file mode 100644
index 000000000..d6edffede
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-G-O0.c
@@ -0,0 +1,9 @@
+/* Test we do not warn about initializing variable with address of self in the initialization. */
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+void *f()
+{
+  void *i = &i;
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-G.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-G.c
new file mode 100644
index 000000000..08f5f5321
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-G.c
@@ -0,0 +1,9 @@
+/* Test we do not warn about initializing variable with address of self in the initialization. */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+void *f()
+{
+  void *i = &i;
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-H-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-H-O0.c
new file mode 100644
index 000000000..97221462c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-H-O0.c
@@ -0,0 +1,33 @@
+/* PR 14204 */
+/* { dg-do compile } */
+/* { dg-options "-Wall -Werror" } */
+
+#if defined __alpha__
+# define ASM __asm__("$30")
+#elif defined __i386__
+# define ASM __asm__("esp")
+#elif defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) || defined (_POWER)
+# define ASM __asm__("r1")
+#elif defined __s390__
+# define ASM __asm__("r15")
+#elif defined __mips
+# define ASM __asm__("$sp")
+#elif defined __sparc__
+# define ASM __asm__("sp")
+#elif defined __ia64__
+# define ASM __asm__("r12")
+#elif defined __hppa__
+# define ASM __asm__("%r30")
+#elif defined __xtensa__
+# define ASM __asm__("sp")
+#else
+/* The register name should be target-dependent so for other targets,
+   we just silence the test.  */
+# define ASM = 0
+#endif
+
+void *load_PCB (void)
+{
+  register void *sp ASM;
+  return sp;			/* { dg-bogus "uninitialized" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-H.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-H.c
new file mode 100644
index 000000000..b93bf8daa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-H.c
@@ -0,0 +1,33 @@
+/* PR 14204 */
+/* { dg-do compile } */
+/* { dg-options "-O -Wall -Werror" } */
+
+#if defined __alpha__
+# define ASM __asm__("$30")
+#elif defined __i386__
+# define ASM __asm__("esp")
+#elif defined (__powerpc__) || defined (__PPC__) || defined (__ppc__) || defined (_POWER)
+# define ASM __asm__("r1")
+#elif defined __s390__
+# define ASM __asm__("r15")
+#elif defined __mips
+# define ASM __asm__("$sp")
+#elif defined __sparc__
+# define ASM __asm__("sp")
+#elif defined __ia64__
+# define ASM __asm__("r12")
+#elif defined __hppa__
+# define ASM __asm__("%r30")
+#elif defined __xtensa__
+# define ASM __asm__("sp")
+#else
+/* The register name should be target-dependent so for other targets,
+   we just silence the test.  */
+# define ASM = 0
+#endif
+
+void *load_PCB (void)
+{
+  register void *sp ASM;
+  return sp;			/* { dg-bogus "uninitialized" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-I-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-I-O0.c
new file mode 100644
index 000000000..655f54892
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-I-O0.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized" } */
+
+int sys_msgctl (void)
+{
+  struct { int mode; } setbuf;  /* { dg-warning "'setbuf\.mode' is used" {} { xfail *-*-* } } */
+  return setbuf.mode;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-I.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-I.c
new file mode 100644
index 000000000..2bed232c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-I.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+int sys_msgctl (void)
+{
+  struct { int mode; } setbuf;
+  return setbuf.mode;
+} /* { dg-warning "'setbuf\.mode' is used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430-2.c
new file mode 100644
index 000000000..361a6a0bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+
+int  *p, *q;
+
+int foo (int b)
+{
+  int i, j = 0;
+  int *x;
+  p = &i;
+  q = &j;
+  if (b)
+    x = p;
+  else
+    x = q;
+  return *x;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430-O0.c
new file mode 100644
index 000000000..4ce258653
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430-O0.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O0 -Wuninitialized" } */
+extern int bar (int);
+extern void baz (int *);
+
+int
+foo (int i)
+{
+  int j; /* { dg-warning "'j' may be used uninitialized in this function" "uninitialized" { xfail *-*-* } 9 } */
+
+  if (bar (i)) {
+    baz (&j);
+  } else {
+  }
+
+  return j;
+}
+
+
+int foo2( void ) {
+  int rc;  /* { dg-warning "'rc' is used uninitialized in this function" "uninitialized" { xfail *-*-* } 21 } */
+  return rc;
+  *&rc = 0;
+}
+
+extern int printf(const char *, ...);
+void frob(int *pi);
+
+int main(void)
+{
+  int i; 
+  printf("i = %d\n", i); /* { dg-warning "'i' is used uninitialized in this function" "uninitialized" { xfail *-*-* } 32 } */
+  frob(&i);
+
+  return 0;
+}
+
+void foo3(int*);
+void bar3(void) { 
+  int x; 
+  if(x) /* { dg-warning "'x' is used uninitialized in this function" "uninitialized" { xfail *-*-* } 41 } */
+    foo3(&x); 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430.c
new file mode 100644
index 000000000..19b5105b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr19430.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+extern int bar (int);
+extern void baz (int *);
+int
+foo (int i)
+{
+  int j; /* { dg-warning "'j' may be used uninitialized in this function" "uninitialized" { xfail *-*-* } 8 } */
+
+  if (bar (i)) { 
+    baz (&j);
+  } else {
+  }
+
+  return j;
+}
+
+
+
+int foo2( void ) {
+  int rc;
+  return rc;
+  *&rc = 0;
+} /* { dg-warning "'rc' is used uninitialized in this function" } */
+
+extern int printf(const char *, ...);
+void frob(int *pi);
+
+int main(void)
+{
+  int i; 
+  printf("i = %d\n", i); /* { dg-warning "'i' is used uninitialized in this function" } */
+  frob(&i);
+
+  return 0;
+}
+
+void foo3(int*);
+void bar3(void) { 
+  int x; 
+  if(x) /* { dg-warning "'x' is used uninitialized in this function" "uninitialized" } */
+    foo3(&x); 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr20644-O0.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr20644-O0.c
new file mode 100644
index 000000000..092d41164
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr20644-O0.c
@@ -0,0 +1,24 @@
+/* PR 20644 */
+/* { dg-do compile } */
+/* { dg-options "-O0 -Wuninitialized" } */
+int foo ()
+{
+  int i = 0;
+  int j;
+
+  if (1 == i)
+    return j; /* { dg-bogus "uninitialized" "uninitialized" { xfail *-*-* } 10 } */
+
+  return 0;
+}
+
+int bar ()
+{
+  int i = 1;
+  int j; 
+
+  if (1 == i)
+    return j; /* { dg-warning "uninitialized" "uninitialized" { target *-*-* } 21 } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr20644.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr20644.c
new file mode 100644
index 000000000..23c21b957
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr20644.c
@@ -0,0 +1,24 @@
+/* PR 20644 */
+/* { dg-do compile } */
+/* { dg-options "-O -Wuninitialized" } */
+int foo ()
+{
+  int i = 0;
+  int j;
+
+  if (1 == i)
+    return j;
+
+  return 0;
+}
+
+int bar ()
+{
+  int i = 1;
+  int j;
+
+  if (1 == i)
+    return j; /* { dg-warning "uninitialized" "uninitialized" { target *-*-* } 24 } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr40943.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr40943.c
new file mode 100644
index 000000000..2b6e9131c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pr40943.c
@@ -0,0 +1,10 @@
+/* PR middle-end/40943 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+void
+foo (void)
+{
+  int *p;
+  *p = 3;	/* { dg-warning "is used uninitialized" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_a.c
new file mode 100644
index 000000000..5edf21d30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_a.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar (void);
+void blah (int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v;
+
+  if (n)
+    {
+      v = r;
+      flag = 1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (flag)
+    blah(v); /* { dg-bogus "uninitialized" "bogus uninitialized var warning" } */ 
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_b.c
new file mode 100644
index 000000000..ac7697e3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_b.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar (void);
+void blah (int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v; 
+
+  if (n)
+    {
+      v = r;
+      flag = 1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  /* Wrong guard */
+  if (!flag)
+    blah(v); /* { dg-warning "uninitialized" "real uninitialized var warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_c.c
new file mode 100644
index 000000000..941f6328d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-2_c.c
@@ -0,0 +1,48 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar (void);
+void blah (int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v; 
+
+  if (n)
+    {
+      v = r;
+      flag = 1;
+    }
+
+  if (m) g++;
+  else bar();
+
+  if (flag)
+    blah(v); /* { dg-bogus "uninitialized" "bogus uninitialized var warning" } */ 
+
+  return 0;
+}
+
+int foo_2 (int n, int m, int r)
+{
+  int flag = 0;
+  int v; 
+
+  if (n)
+    {
+      v = r;
+      flag = 1;
+    }
+
+  if (m) g++;
+  else bar();
+
+  if (flag)
+    blah(v); /* { dg-bogus "uninitialized" "bogus uninitialized var warning" } */ 
+  else
+    blah(v); /* { dg-warning "uninitialized" "real uninitialized var warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_a.c
new file mode 100644
index 000000000..0ef0650ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_a.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v;
+
+  if (n)
+    {
+      v = r;
+      flag = 1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (r > 0)
+    if (flag)
+      blah(v); /* {dg-bogus "uninitialized" "bogus warning" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_b.c
new file mode 100644
index 000000000..978210d50
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_b.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v;
+
+  if (n)
+    {
+      v = r;
+      flag = 1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (r > 0)
+     goto use;
+  if (flag)
+    {
+use:
+      blah(v); /* { dg-warning "uninitialized" "real warning" } */
+    }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_c.c
new file mode 100644
index 000000000..130979078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_c.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v;
+
+  if (n)
+    {
+      v = r;
+      flag = -1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (r > 0)
+    if (flag < 0)
+      blah(v); /* {dg-bogus "uninitialized" "bogus warning" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_d.c
new file mode 100644
index 000000000..9f938763c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_d.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v;
+
+  if (n)
+    {
+      v = r;
+      flag = -1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (r > 0)
+    if (flag  == -1)
+      blah(v); /* {dg-bogus "uninitialized" "bogus warning" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_e.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_e.c
new file mode 100644
index 000000000..66e2a3a93
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-3_e.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int m, int r)
+{
+  int flag = 0;
+  int v;
+
+  if (n)
+    {
+      v = r;
+      flag = -1;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (r > 0)
+    if (flag  <= 0 )
+      blah(v); /* { dg-warning "uninitialized" "real warning" } */
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-4_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-4_a.c
new file mode 100644
index 000000000..7b2d291a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-4_a.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+int foo (int n, int m, int r, int t)
+{
+  int flag = 0;
+  int v;
+
+  if (t)
+    {
+      if (n)
+        {
+          v = r;    /* init path 1 */
+          flag = 1;
+        }
+
+      if (m)
+        g++;
+      else 
+        bar();
+
+      if (flag)  /* properly  guarded */
+        blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+    }
+  else
+    {
+      v = r+1; /* init path 2 */
+      flag = 2;
+    }
+
+  if (m)
+    g++;
+  else 
+    bar();
+
+  if (flag)  /* properly guarded */
+    blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-4_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-4_b.c
new file mode 100644
index 000000000..376639588
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-4_b.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+int foo (int n, int m, int r, int t)
+{
+  int flag = 0;
+  int v;
+
+  if (t)
+    {
+      if (n)
+        {
+          v = r;    /* init path 1 */
+          flag = 1;
+        }
+
+      if (m) g++;
+      else bar();
+
+      if (flag)  /* properly  guarded */
+        blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+    }
+  else
+    {
+      v = r+1; /* init path 2 */
+      flag = 2;
+    }
+
+  if (m) g++;
+  else bar();
+
+  if (g)   /* guard can not be determined statically to be safe */
+    blah(v); /* { dg-warning "uninitialized" "real warning" } */
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-5_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-5_a.c
new file mode 100644
index 000000000..845f3c461
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-5_a.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+int bar();
+int blah(int);
+void t(int);
+
+__attribute__((always_inline)) 
+int foo (int n, int* v, int r)
+{
+  int flag = 0;
+  if (r > n)
+    {
+      *v = bar();
+      flag = 1;
+    }
+
+  if (n > g)
+    g++;
+  else 
+    bar();
+
+  return flag;
+}
+
+int a[100];
+int b[100];
+int blah(int n)
+{
+  int i;
+   for (i = 0 ; i < n; i++)
+     {
+       int v;
+       if (!foo (n, &v, b[i]))
+         return 0;
+       t (v); /* { dg-bogus "uninitialized" "bogus warning" } */
+     }
+   return 1;
+}
+	
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-5_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-5_b.c
new file mode 100644
index 000000000..13f1e31f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-5_b.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+int bar();
+int blah(int);
+void t(int);
+
+__attribute__((always_inline)) 
+int foo (int n, int* v, int r)
+{
+  int flag = 0;
+  if (r > n)
+    {
+      *v = bar();
+      flag = 1;
+    }
+
+  if (n > g)
+    g++;
+  else 
+    bar();
+
+  return flag;
+}
+
+int a[100];
+int b[100];
+int blah(int n)
+{
+  int i;
+   for (i = 0 ; i < n; i++)
+     {
+       int v;
+       if (foo (n, &v, b[i]))
+         return 0;
+       t (v); /* { dg-warning "uninitialized" "real warning" } */
+     }
+   return 1;
+}
+	
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_a.c
new file mode 100644
index 000000000..aa44f7616
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_a.c
@@ -0,0 +1,40 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n && l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n && l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n && l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if (n)
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_b.c
new file mode 100644
index 000000000..dcc9a14a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_b.c
@@ -0,0 +1,46 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n)
+    if (l)
+      v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n && l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if (l)
+    if (n)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n)
+    if (l)
+      v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if (n || l)
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_c.c
new file mode 100644
index 000000000..f60868dad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_c.c
@@ -0,0 +1,46 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n > 10)
+    if (l)
+      v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( (n > 10) && l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if (l)
+    if (n > 12)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n > 10)
+    if (l)
+      v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if (n > 8 )
+    if (l)
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_d.c
new file mode 100644
index 000000000..704c3e6e1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_d.c
@@ -0,0 +1,24 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n && l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_e.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_e.c
new file mode 100644
index 000000000..21f429daf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-6_e.c
@@ -0,0 +1,43 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n > 10)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( (n > 10) && (l < 100))
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( n > 100 )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n > 10)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n < 10)
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_a.c
new file mode 100644
index 000000000..c2ba2a424
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_a.c
@@ -0,0 +1,54 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n || l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n && l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( n )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( l )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n || l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n && l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( n )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if (m || l)
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+
+  if ( l )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_b.c
new file mode 100644
index 000000000..338d18c95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_b.c
@@ -0,0 +1,23 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n > 10)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if (( n > 10) || (l != 100))
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_c.c
new file mode 100644
index 000000000..1bbe5014d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-7_c.c
@@ -0,0 +1,33 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if (n )
+    {
+      if (l)
+        g++;
+      else 
+        goto l;
+    }
+  else
+    {
+l:
+      blah (v); /* { dg-warning "uninitialized" "warning" } */
+    }
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_a.c
new file mode 100644
index 000000000..1b7c47242
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_a.c
@@ -0,0 +1,45 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n || m || r || l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n ||  m || r || l)
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( n )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( l )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n || m || r )
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n || m || r || l)
+      blah(v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_b.c
new file mode 100644
index 000000000..06e2eba27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_b.c
@@ -0,0 +1,45 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n < 10 || m > 100 || r < 20 || l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n < 10 ||  m > 100 || r < 20 )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( n < 10 ||  m > 100 || r < 10 )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n < 10 || m > 100 || r < 20 || l)
+    v = r;
+
+  if (m) g++;
+  else   bar();
+
+  if ( n < 10 ||  m > 100 || r < 20 )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( n < 10 ||  m > 100 || r < 30 )
+      blah(v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_c.c
new file mode 100644
index 000000000..39d1bcd93
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-8_c.c
@@ -0,0 +1,39 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n < 10 && m > 100  && r < 20 )
+    v = r;
+
+  if (m) g++; 
+  else  bar();
+
+  if ( n <= 8 &&  m > 101  && r < 19 )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if (n < 10 && m > 100  && r < 20 )
+    v = r;
+
+  if (m) g++; 
+  else  bar();
+
+  if ( n <= 8 &&  m > 99  && r < 19 )
+      blah(v); /* { dg-warning "uninitialized" "warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-9_a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-9_a.c
new file mode 100644
index 000000000..67fb8ab97
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-9_a.c
@@ -0,0 +1,23 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if ( (n < 10) && (m == l)  && (r < 20) )
+    v = r;
+
+  if (m) g++; 
+  else  bar();
+
+  if ( (n <= 8) &&  (m == l)  && (r < 19) )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-9_b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-9_b.c
new file mode 100644
index 000000000..d9ae75e07
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/uninit-pred-9_b.c
@@ -0,0 +1,44 @@
+
+/* { dg-do compile } */
+/* { dg-options "-Wuninitialized -O2" } */
+
+int g;
+void bar();
+void blah(int);
+
+int foo (int n, int l, int m, int r)
+{
+  int v;
+
+  if ( (n < 10) && (m != 100)  && (r < 20) )
+    v = r;
+
+  if (m) g++; 
+  else  bar();
+
+  if (l > 100)
+    if ( (n <= 9) &&  (m < 100)  && (r < 19) )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  if ( (n <= 8) &&  (m < 99)  && (r < 19) )
+      blah(v); /* { dg-bogus "uninitialized" "bogus warning" } */
+
+  return 0;
+}
+
+int foo_2 (int n, int l, int m, int r)
+{
+  int v;
+
+  if ( (n < 10) && (m != 100)  && (r < 20) )
+    v = r;
+
+  if (m) g++; 
+  else  bar();
+
+  if (l > 100)
+    if ( (n <= 8) &&  (m < 101)  && (r < 19) )
+      blah(v); /* { dg-warning "uninitialized" "real warning" } */
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-1.c
new file mode 100644
index 000000000..0dd2df9b0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-1.c
@@ -0,0 +1,22 @@
+/* PR target/15783 */
+/* Origin: Paul Pluzhnikov <ppluzhnikov@charter.net> */
+
+/* This used to ICE on SPARC 64-bit because the back-end was
+   returning an invalid construct for the return value of fu2.  */
+
+/* { dg-do compile } */
+
+union u2 {
+    struct
+    {
+        int u2s_a, u2s_b, u2s_c, u2s_d, u2s_e;
+    } u2_s;
+    double u2_d;
+} u2a;
+
+union u2 fu2();
+
+void unions()
+{
+    u2a = fu2();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-2.c
new file mode 100644
index 000000000..edc8a7abf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-2.c
@@ -0,0 +1,28 @@
+/* This used to segfault on SPARC 64-bit at runtime because
+   the stack pointer was clobbered by the function call.   */
+
+/* { dg-do run } */
+
+#include <stdarg.h>
+
+union U
+{
+  long l1[2];
+};
+
+union U u;
+
+void foo (int z, ...)
+{
+  int i;
+  va_list ap;
+  va_start(ap,z);
+  i = va_arg(ap, int);
+  va_end(ap);
+}
+
+int main(void)
+{
+  foo (1, 1, 1, 1, 1, u);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-3.c
new file mode 100644
index 000000000..3e89b755a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-3.c
@@ -0,0 +1,10 @@
+/* PR target/27421 */
+/* { dg-do compile } */
+
+union A
+{
+  int i;
+  void x[1];  /* { dg-error "array of voids" } */
+};
+
+void foo(union A a) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-4.c
new file mode 100644
index 000000000..df9f36da0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-4.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-rtl-cse1" } */
+
+extern void abort(void);
+
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
+
+typedef union {
+  uint32 i32;
+  uint64 i64;
+} u64;
+
+void foo(void)
+{
+  u64 data;
+  data.i64 = 1;
+  if (data.i32 != 1)
+    abort ();
+}
+
+/* { dg-final { scan-rtl-dump-not "abort" "cse1" { target i?86-*-* } } } */
+/* { dg-final { cleanup-rtl-dump "cse1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-5.c
new file mode 100644
index 000000000..ea65f4b02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-5.c
@@ -0,0 +1,46 @@
+/* { dg-do run { target i?86-*-* x86_64-*-* } } */
+/* { dg-options "-O -fgcse -fno-split-wide-types" } */
+
+extern void abort(void);
+
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+typedef struct
+{
+  uint16_t thread;
+  uint16_t phase;
+} s32;
+
+typedef union
+{
+  uint32_t i;
+  s32 s;
+} u32;
+
+typedef union
+{
+  uint64_t i;
+  u32 u;
+} u64;
+
+static __attribute__((noinline))
+void foo(int val)
+{
+  u64 data;
+  uint32_t thread;
+
+  data.u.i = 0x10000L;
+  thread = data.u.s.thread;
+  if (val)
+    abort ();
+  if (thread)
+    abort ();
+}
+
+int main(void)
+{
+  foo (0);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-1.c
new file mode 100644
index 000000000..1d7f4d549
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89" } */
+/* A combine of two extensions to C89 are used here.
+   First casts to unions is used.
+   Second subscripting non lvalue arrays, this is in C99. */
+
+union vx {short f[8]; int v;};
+int vec;
+
+void
+foo5 (int vec)
+{
+  ((union vx) vec).f[5] = 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-2.c
new file mode 100644
index 000000000..9aac5caa2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-2.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -pedantic-errors" } */
+/* PR 23155
+   We should get two error messages, one about union cast
+   and the other about array access for non lvalues.  */
+
+
+union vx {short f[8]; int v;};
+int vec;
+
+void
+foo5 (int vec)
+{
+  ((union vx) vec).f[5] = 1; /* { dg-error "(forbids subscripting)|(forbids casts to union type)" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-3.c
new file mode 100644
index 000000000..5f9b9f868
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-3.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+/* PR 23155
+   We should get one error messag, one about union cast. */
+
+
+union vx {short f[8]; int v;};
+int vec;
+
+void
+foo5 (int vec)
+{
+  ((union vx) vec).f[5] = 1; /* { dg-error "forbids casts to union type" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-4.c
new file mode 100644
index 000000000..a1c98ba14
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/union-cast-4.c
@@ -0,0 +1,8 @@
+/* PR c/35748 */
+
+union U { void x[1]; }; /* { dg-error "array of voids" } */
+
+void foo()
+{
+  (union U)0; /* { dg-error "type not present" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-1.c
new file mode 100644
index 000000000..1310532de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+void bar (int);
+
+void foo (int i, float f)
+{
+  bar (__builtin_isgreater (i, i));	/* { dg-error "non-floating-point" } */
+  bar (__builtin_isgreater (f, i));
+  bar (__builtin_isgreater (i, f));
+  bar (__builtin_isgreater (f, 2));
+  bar (__builtin_isgreater (f, 2.0f));
+  bar (__builtin_isgreater (f, 2.0));
+  bar (__builtin_isgreater (2, f));
+  bar (__builtin_isgreater (2.0f, f));
+  bar (__builtin_isgreater (2.0, f));
+  bar (__builtin_isgreater (&f, i));	/* { dg-error "non-floating-point" } */
+  bar (__builtin_isgreater (f, &i));	/* { dg-error "non-floating-point" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-2.c
new file mode 100644
index 000000000..0696d37cf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-2.c
@@ -0,0 +1,51 @@
+/* { dg-do link } */
+
+void link_error ();
+
+int main()
+{
+  if (__builtin_isgreater(1.0,2.0) != 0)
+    link_error ();
+  if (__builtin_isgreater(3.0,3.0) != 0)
+    link_error ();
+  if (__builtin_isgreater(5.0,4.0) == 0)
+    link_error ();
+
+  if (__builtin_isgreaterequal(1.0,2.0) != 0)
+    link_error ();
+  if (__builtin_isgreaterequal(3.0,3.0) == 0)
+    link_error ();
+  if (__builtin_isgreaterequal(5.0,4.0) == 0)
+    link_error ();
+
+  if (__builtin_isless(1.0,2.0) == 0)
+    link_error ();
+  if (__builtin_isless(3.0,3.0) != 0)
+    link_error ();
+  if (__builtin_isless(5.0,4.0) != 0)
+    link_error ();
+
+  if (__builtin_islessequal(1.0,2.0) == 0)
+    link_error ();
+  if (__builtin_islessequal(3.0,3.0) == 0)
+    link_error ();
+  if (__builtin_islessequal(5.0,4.0) != 0)
+    link_error ();
+
+  if (__builtin_islessgreater(1.0,2.0) == 0)
+    link_error ();
+  if (__builtin_islessgreater(3.0,3.0) != 0)
+    link_error ();
+  if (__builtin_islessgreater(5.0,4.0) == 0)
+    link_error ();
+
+  if (__builtin_isunordered(1.0,2.0) != 0)
+    link_error ();
+  if (__builtin_isunordered(3.0,3.0) != 0)
+    link_error ();
+  if (__builtin_isunordered(5.0,4.0) != 0)
+    link_error ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-3.c
new file mode 100644
index 000000000..d08abd0ca
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unordered-3.c
@@ -0,0 +1,80 @@
+/* { dg-do link } */
+/* { dg-options "-fno-finite-math-only" }  */
+
+void link_error ();
+
+void test1()
+{
+  if (__builtin_isgreater(1.0,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_isgreater(__builtin_nan(""),1.0) != 0)
+    link_error ();
+
+  if (__builtin_isgreaterequal(1.0,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_isgreaterequal(__builtin_nan(""),1.0) != 0)
+    link_error ();
+
+  if (__builtin_isless(1.0,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_isless(__builtin_nan(""),1.0) != 0)
+    link_error ();
+
+  if (__builtin_islessequal(1.0,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_islessequal(__builtin_nan(""),1.0) != 0)
+    link_error ();
+
+  if (__builtin_islessgreater(1.0,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_islessgreater(__builtin_nan(""),1.0) != 0)
+    link_error ();
+
+  if (__builtin_isunordered(1.0,__builtin_nan("")) == 0)
+    link_error ();
+  if (__builtin_isunordered(__builtin_nan(""),1.0) == 0)
+    link_error ();
+}
+
+
+void test2(double x)
+{
+  if (__builtin_isgreater(x,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_isgreater(__builtin_nan(""),x) != 0)
+    link_error ();
+
+  if (__builtin_isgreaterequal(x,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_isgreaterequal(__builtin_nan(""),x) != 0)
+    link_error ();
+
+  if (__builtin_isless(x,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_isless(__builtin_nan(""),x) != 0)
+    link_error ();
+
+  if (__builtin_islessequal(x,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_islessequal(__builtin_nan(""),x) != 0)
+    link_error ();
+
+  if (__builtin_islessgreater(x,__builtin_nan("")) != 0)
+    link_error ();
+  if (__builtin_islessgreater(__builtin_nan(""),x) != 0)
+    link_error ();
+
+  if (__builtin_isunordered(x,__builtin_nan("")) == 0)
+    link_error ();
+  if (__builtin_isunordered(__builtin_nan(""),x) == 0)
+    link_error ();
+}
+
+
+int main()
+{
+  test1 ();
+  test2 (1.0);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unroll-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unroll-1.c
new file mode 100644
index 000000000..5ff07e21e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unroll-1.c
@@ -0,0 +1,27 @@
+/* PR optimization/8599 */
+/* { dg-do run } */
+/* { dg-options "-O2 -funroll-loops" } */
+/* { dg-options "-mtune=k6 -O2 -funroll-loops" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */
+
+
+extern void abort (void);
+
+int array[6] = { 1,2,3,4,5,6 };
+
+void foo()
+{
+  int i;
+
+  for (i = 0; i < 5; i++)
+    array[i] = 0;
+}
+
+int main()
+{
+  foo();
+  if (array[0] || array [1] || array[2] || array[3] || array[4])
+    abort ();
+  if (array[5] != 6)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unsigned-long-compare.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unsigned-long-compare.c
new file mode 100644
index 000000000..74e7638f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unsigned-long-compare.c
@@ -0,0 +1,24 @@
+/* Copyright (C) 2006 Free Software Foundation, Inc. */
+/* Contributed by Carlos O'Donell on 2006-01-30 */
+
+/* Test a division corner case where the expression simplifies
+   to a comparison, and the optab expansion is wrong. The optab 
+   expansion emits a function whose return is unbiased and needs
+   adjustment. */
+/* Origin: Carlos O'Donell <carlos@codesourcery.com> */
+/* { dg-do run } */
+/* { dg-options "" } */
+#include <stdlib.h>
+
+#define BIG_CONSTANT 0xFFFFFFFF80000000ULL
+
+int main (void)
+{
+  unsigned long long OneULL = 1ULL;
+  unsigned long long result;
+
+  result = OneULL / BIG_CONSTANT; 
+  if (result)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-1.c
new file mode 100644
index 000000000..8db7c2ccf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-1.c
@@ -0,0 +1,11 @@
+/* Missing `unused parameter' warning.
+   egcs-1.1.2 fails, egcs-ss-19990418 passes.
+   http://gcc.gnu.org/ml/gcc-bugs/1998-09/msg00199.html */
+/* { dg-do compile } */
+/* { dg-options "-O -Wall -W" } */
+int
+f(c)
+     char c; /* { dg-warning "unused parameter" "unused parameter warning" } */
+{
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-2.c
new file mode 100644
index 000000000..454606ec9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-2.c
@@ -0,0 +1,18 @@
+/* Copyright (C) 2000  Free Software Foundation.
+
+   by Alexandre Oliva  <oliva@lsd.ic.unicamp.br>  */
+
+/* { dg-do compile } */
+/* { dg-options "-O2 -finline-functions -Wunused -Wreturn-type" } */
+
+static void
+foo ()
+{
+  skip_it: ; /* { dg-warning "defined but not used" "unused label warning" } */
+}
+
+void
+bar ()
+{
+  foo ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-3.c
new file mode 100644
index 000000000..120562448
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-3.c
@@ -0,0 +1,14 @@
+/* Copyright (C) 2000  Free Software Foundation.  */
+/* Added extra line-breaks to check that diagnostics refer to correct token.
+   --Per Bothner. */
+/* { dg-do compile } */
+/* { dg-options "-Wunused" } */
+
+typedef short unused_type __attribute__ ((unused));
+main ()
+{
+  short
+    x   /* { dg-warning "unused variable" "unused variable warning" } */
+    ;
+  unused_type y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-4.c
new file mode 100644
index 000000000..99e845f45
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-4.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-Wunused -O3" } */
+
+static const int i = 0;
+static void f() { }		/* { dg-warning "defined but not used" } */
+static inline void g() { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-5.c
new file mode 100644
index 000000000..5ccc3f3be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-5.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-Wunused" } */
+/* { dg-final { scan-assembler "string_to_look_for" } } */
+
+/* 'volatile' variables get output and don't produce a warning about being
+   unused.  */
+static volatile char string[] 
+  = "string_to_look_for";  /* { dg-bogus "not used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6-WallWextra.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6-WallWextra.c
new file mode 100644
index 000000000..d2d80be06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6-WallWextra.c
@@ -0,0 +1,11 @@
+/* PR 28875 */
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wextra -Wall" } */
+static int t(int i) /* { dg-warning "unused parameter" "unused parameter warning" } */
+{
+  return 0;
+}
+int tt()
+{
+  return t(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6-no.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6-no.c
new file mode 100644
index 000000000..0923cfb81
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6-no.c
@@ -0,0 +1,11 @@
+/* PR 28875 */
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wextra -Wno-unused-parameter -Wall" } */
+static int t(int i) /* { dg-bogus "unused parameter" "unused parameter warning" } */
+{
+  return 0;
+}
+int tt()
+{
+  return t(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6.c
new file mode 100644
index 000000000..7651ecb28
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-6.c
@@ -0,0 +1,11 @@
+
+/* { dg-do compile } */
+/* { dg-options "-O3 -Wunused-parameter" } */
+static int t(int i) /* { dg-warning "unused parameter" "unused parameter warning" } */
+{
+  return 0;
+}
+int tt()
+{
+  return t(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-7.c
new file mode 100644
index 000000000..d2b9c3c1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unused-7.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-Wunused" } */
+
+static int a = 10; /* { dg-warning "defined but not used" } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/unwind-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/unwind-1.c
new file mode 100644
index 000000000..95bbb2daa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/unwind-1.c
@@ -0,0 +1,7 @@
+/* { dg-do assemble { target { ! { powerpc-ibm-aix* } } } } */
+/* { dg-options "-fleading-underscore -funwind-tables" } */
+
+void func(void) __asm("_func");
+void _func(int x) {}
+void func(void) {}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-array-short-wchar.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-array-short-wchar.c
new file mode 100644
index 000000000..55d164fc2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-array-short-wchar.c
@@ -0,0 +1,41 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Expected errors for char16_t/char32_t string literals. */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -fshort-wchar" } */
+
+#include <wchar.h>
+
+typedef __CHAR16_TYPE__ char16_t;
+typedef __CHAR32_TYPE__ char32_t;
+
+const char	s_0[]	= "ab";
+const char	s_1[]	= u"ab";	/* { dg-error "from wide string" } */
+const char	s_2[]	= U"ab";	/* { dg-error "from wide string" } */
+const char	s_3[]	= L"ab";	/* { dg-error "from wide string" } */
+
+const char16_t	s16_0[]	= "ab";		/* { dg-error "from non-wide" } */
+const char16_t	s16_1[]	= u"ab";
+const char16_t	s16_2[]	= U"ab";	/* { dg-error "from incompatible" } */
+const char16_t	s16_3[]	= L"ab";
+
+const char16_t	s16_4[0] = u"ab";	/* { dg-warning "chars is too long" } */
+const char16_t	s16_5[1] = u"ab";	/* { dg-warning "chars is too long" } */
+const char16_t	s16_6[2] = u"ab";
+const char16_t	s16_7[3] = u"ab";
+const char16_t	s16_8[4] = u"ab";
+
+const char32_t	s32_0[]	= "ab";		/* { dg-error "from non-wide" } */
+const char32_t	s32_1[]	= u"ab";	/* { dg-error "from incompatible" } */
+const char32_t	s32_2[]	= U"ab";
+const char32_t	s32_3[]	= L"ab";	/* { dg-error "from incompatible" } */
+
+const char32_t	s32_4[0] = U"ab";	/* { dg-warning "chars is too long" } */
+const char32_t	s32_5[1] = U"ab";	/* { dg-warning "chars is too long" } */
+const char32_t	s32_6[2] = U"ab";	/* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+const char32_t	s32_7[3] = U"ab";	/* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+const char32_t	s32_8[4] = U"ab";	/* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+
+const wchar_t	sw_0[]	= "ab";		/* { dg-error "from non-wide" } */
+const wchar_t	sw_1[]	= u"ab";
+const wchar_t	sw_2[]	= U"ab";	/* { dg-error "from incompatible" } */
+const wchar_t	sw_3[]	= L"ab";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-array.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-array.c
new file mode 100644
index 000000000..bbe0976a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-array.c
@@ -0,0 +1,41 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Expected errors for char16_t/char32_t string literals. */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+#include <wchar.h>
+
+typedef __CHAR16_TYPE__	char16_t;
+typedef __CHAR32_TYPE__	char32_t;
+
+const char	s_0[]	= "ab";
+const char	s_1[]	= u"ab";	/* { dg-error "from wide string" } */
+const char	s_2[]	= U"ab";	/* { dg-error "from wide string" } */
+const char	s_3[]	= L"ab";	/* { dg-error "from wide string" } */
+
+const char16_t	s16_0[]	= "ab";		/* { dg-error "from non-wide" } */
+const char16_t	s16_1[]	= u"ab";
+const char16_t	s16_2[]	= U"ab";	/* { dg-error "from incompatible" } */
+const char16_t	s16_3[]	= L"ab";	/* { dg-error "from incompatible" "" { target { ! wchar_t_char16_t_compatible } } } */
+
+const char16_t	s16_4[0] = u"ab";	/* { dg-warning "chars is too long" } */
+const char16_t	s16_5[1] = u"ab";	/* { dg-warning "chars is too long" } */
+const char16_t	s16_6[2] = u"ab";
+const char16_t	s16_7[3] = u"ab";
+const char16_t	s16_8[4] = u"ab";
+
+const char32_t	s32_0[]	= "ab";		/* { dg-error "from non-wide" } */
+const char32_t	s32_1[]	= u"ab";	/* { dg-error "from incompatible" } */
+const char32_t	s32_2[]	= U"ab";
+const char32_t	s32_3[]	= L"ab";	/* { dg-error "from incompatible" "" { target { ! wchar_t_char32_t_compatible } } } */
+
+const char32_t	s32_4[0] = U"ab";	/* { dg-warning "chars is too long" } */
+const char32_t	s32_5[1] = U"ab";	/* { dg-warning "chars is too long" } */
+const char32_t	s32_6[2] = U"ab";	/* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+const char32_t	s32_7[3] = U"ab";	/* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+const char32_t	s32_8[4] = U"ab";	/* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+
+const wchar_t	sw_0[]	= "ab";		/* { dg-error "from non-wide" } */
+const wchar_t	sw_1[]	= u"ab";	/* { dg-error "from incompatible" "" { target { ! wchar_t_char16_t_compatible } } } */
+const wchar_t	sw_2[]	= U"ab";	/* { dg-error "from incompatible" "" { target { ! wchar_t_char32_t_compatible } } } */
+const wchar_t	sw_3[]	= L"ab";
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-badconcat.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-badconcat.c
new file mode 100644
index 000000000..61ce495ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-badconcat.c
@@ -0,0 +1,22 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test unsupported concatenation of char16_t/char32_t* string literals. */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+void	*s0	= u"a"  "b";
+void	*s1	=  "a" u"b";
+void	*s2	= u"a" U"b";	/* { dg-error "non-standard concatenation" } */
+void	*s3	= U"a" u"b";	/* { dg-error "non-standard concatenation" } */
+void	*s4	= u"a" L"b";	/* { dg-error "non-standard concatenation" } */
+void	*s5	= L"a" u"b";	/* { dg-error "non-standard concatenation" } */
+void	*s6	= u"a" u"b";
+void	*s7	= U"a"  "b";
+void	*s8	=  "a" U"b";
+void	*s9	= U"a" L"b";	/* { dg-error "non-standard concatenation" } */
+void	*sa	= L"a" U"b";	/* { dg-error "non-standard concatenation" } */
+void	*sb	= U"a" U"b";
+void	*sc	= L"a"  "b";
+void	*sd	=  "a" L"b";
+void	*se	= L"a" L"b";
+
+int main () {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-cvt.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-cvt.c
new file mode 100644
index 000000000..4c82dda2f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-cvt.c
@@ -0,0 +1,59 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test the char16_t and char32_t promotion rules. */
+/* { dg-do compile } */
+/* { dg-excess-errors "short and int are 16bit" { target { "avr-*-*" } } } */
+/* { dg-options "-std=gnu99 -Wall -Wconversion -Wsign-conversion" } */
+
+typedef __CHAR16_TYPE__ char16_t;
+typedef __CHAR32_TYPE__ char32_t;
+
+extern void f_c (char);
+extern void fsc (signed char);
+extern void fuc (unsigned char);
+extern void f_s (short);
+extern void fss (signed short);
+extern void fus (unsigned short);
+extern void f_i (int);
+extern void fsi (signed int);
+extern void fui (unsigned int);
+extern void f_l (long);
+extern void fsl (signed long);
+extern void ful (unsigned long);
+extern void f_ll (long long);
+extern void fsll (signed long long);
+extern void full (unsigned long long);
+
+void m (char16_t c0, char32_t c1)
+{
+    f_c (c0);	/* { dg-warning "alter its value" } */
+    fsc (c0);	/* { dg-warning "alter its value" } */
+    fuc (c0);	/* { dg-warning "alter its value" } */
+    f_s (c0);	/* { dg-warning "change the sign" } */
+    fss (c0);	/* { dg-warning "change the sign" } */
+    fus (c0);
+    f_i (c0);
+    fsi (c0);
+    fui (c0);
+    f_l (c0);
+    fsl (c0);
+    ful (c0);
+    f_ll (c0);
+    fsll (c0);
+    full (c0);
+
+    f_c (c1);	/* { dg-warning "alter its value" } */
+    fsc (c1);	/* { dg-warning "alter its value" } */
+    fuc (c1);	/* { dg-warning "alter its value" } */
+    f_s (c1);	/* { dg-warning "alter its value" "" { target { ! "avr-*-*" } } } */
+    fss (c1);	/* { dg-warning "alter its value" "" { target { ! "avr-*-*" } } } */
+    fus (c1);	/* { dg-warning "alter its value" "" { target { ! "avr-*-*" } } } */
+    f_i (c1);	/* { dg-warning "change the sign" } */
+    fsi (c1);	/* { dg-warning "change the sign" } */
+    fui (c1);
+    f_l (c1);	/* { dg-warning "change the sign" "" { target { llp64 || ilp32 } } } */
+    fsl (c1);	/* { dg-warning "change the sign" "" { target { llp64 || ilp32 } } } */
+    ful (c1);
+    f_ll (c1);
+    fsll (c1);
+    full (c1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-dflt.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-dflt.c
new file mode 100644
index 000000000..7281ef3c7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-dflt.c
@@ -0,0 +1,25 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* If not gnu99, the u and U prefixes should be parsed as separate tokens. */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+const unsigned short	c0	= u'a';		/* { dg-error "undeclared" } */
+		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 6 } */
+const unsigned long	c1	= U'a';		/* { dg-error "undeclared" } */
+		/* { dg-error "expected ',' or ';'" "" { target *-*-* } 8 } */
+
+#define u	1 +
+#define U	2 +
+
+const unsigned short	c2	= u'a';
+const unsigned long	c3	= U'a';
+
+#undef u
+#undef U
+#define u	"a"
+#define U	"b"
+
+const void		*s0	= u"a";
+const void		*s1	= U"a";
+
+int main () {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-inc-init.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-inc-init.c
new file mode 100644
index 000000000..531d21b26
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-inc-init.c
@@ -0,0 +1,45 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test incremental initializers for char16_t/char32_t arrays. */
+/* { dg-do run { target int32plus } } */
+/* { dg-options "-std=gnu99" } */
+
+typedef __SIZE_TYPE__ size_t;
+typedef __CHAR16_TYPE__ char16_t;
+typedef __CHAR32_TYPE__ char32_t;
+
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+
+struct A {
+  char16_t S[6];
+  int M;
+} a[] = { { { u"foo" }, 1 }, [0].S[2] = u'x', [0].S[4] = u'y' };
+struct A b[] = { { { u"foo" }, 1 }, [0] = { .S[0] = u'b' } };
+struct A c[] = { { { u"foo" }, 1 }, [0].S = { u"a" }, [0].M = 2 };
+
+struct B {
+  char32_t S[6];
+  int M;
+} d[] = { { { U"foo" }, 1 }, [0].S[2] = U'x', [0].S[4] = U'y' };
+struct B e[] = { { { U"foo" }, 1 }, [0] = { .S[0] = U'b' } };
+struct B f[] = { { { U"foo" }, 1 }, [0].S = { U"a" }, [0].M = 2 };
+
+int main (void)
+{
+  if (memcmp (a[0].S, u"fox\0y", 6 * sizeof(char16_t)) || a[0].M != 1)
+    abort ();
+  if (memcmp (b[0].S, u"b\0\0\0\0", 6) || b[0].M)
+    abort ();
+  if (memcmp (c[0].S, u"a\0\0\0\0", 6) || c[0].M != 2)
+    abort ();
+
+  if (memcmp (d[0].S, U"fox\0y", 6 * sizeof(char32_t)) || d[0].M != 1)
+    abort ();
+  if (memcmp (e[0].S, U"b\0\0\0\0", 6) || e[0].M)
+    abort ();
+  if (memcmp (f[0].S, U"a\0\0\0\0", 6) || f[0].M != 2)
+    abort ();
+
+  exit(0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-type.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-type.c
new file mode 100644
index 000000000..1aa6020cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf-type.c
@@ -0,0 +1,18 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Ensure that __CHAR16_TYPE__ and __CHAR32_TYPE__ exist, and are of the
+   correct width. */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR16_TYPE__ char16_t;
+typedef __CHAR32_TYPE__ char32_t;
+
+extern void abort (void);
+
+int main ()
+{
+    if (sizeof (char16_t) != sizeof (u'a'))
+	abort();
+    if (sizeof (char32_t) != sizeof (U'a'))
+	abort();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-1.c
new file mode 100644
index 000000000..f2343d2a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-1.c
@@ -0,0 +1,67 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test the support for char16_t character constants. */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR16_TYPE__ char16_t;
+
+extern void abort (void);
+
+char16_t	c0 = u'a';
+char16_t	c1 = u'\0';
+char16_t	c2 = u'\u0024';
+char16_t	c3 = u'\u2029';
+char16_t	c4 = u'\u8010';
+
+char16_t	c5 = 'a';
+char16_t	c6 = U'a';
+char16_t	c7 = U'\u2029';
+char16_t	c8 = U'\u8010';
+char16_t	c9 = L'a';
+char16_t	ca = L'\u2029';
+char16_t	cb = L'\u8010';
+
+#define A	0x0061
+#define D	0x0024
+#define X	0x2029
+#define Y	0x8010
+
+int main ()
+{
+    if (sizeof (u'a') != sizeof (char16_t))
+	abort ();
+    if (sizeof (u'\0') != sizeof (char16_t))
+	abort ();
+    if (sizeof (u'\u0024') != sizeof (char16_t))
+	abort ();
+    if (sizeof (u'\u2029') != sizeof (char16_t))
+	abort ();
+    if (sizeof (u'\u8010') != sizeof (char16_t))
+	abort ();
+
+    if (c0 != A)
+	abort ();
+    if (c1 != 0x0000)
+	abort ();
+    if (c2 != D)
+	abort ();
+    if (c3 != X)
+	abort ();
+    if (c4 != Y)
+	abort ();
+
+    if (c5 != A)
+	abort ();
+    if (c6 != A)
+	abort ();
+    if (c7 != X)
+	abort ();
+    if (c8 != Y)
+	abort ();
+    if (c9 != A)
+	abort ();
+    if (ca != X)
+	abort ();
+    if (cb != Y)
+	abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-2.c
new file mode 100644
index 000000000..7fc5ef1ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-2.c
@@ -0,0 +1,32 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test the support for char16_t* string literals. */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR16_TYPE__ char16_t;
+
+extern void abort (void);
+
+char16_t	*s0 = u"ab";
+char16_t	*s1 = u"a\u0024";
+char16_t	*s2 = u"a\u2029";
+char16_t	*s3 = u"a\U00064321";
+
+#define A	0x0061
+#define B	0x0062
+#define D	0x0024
+#define X	0x2029
+#define Y1	0xD950
+#define Y2	0xDF21
+
+int main ()
+{
+    if (s0[0] != A || s0[1] != B || s0[2] != 0x0000)
+	abort ();
+    if (s1[0] != A || s1[1] != D || s0[2] != 0x0000)
+	abort ();
+    if (s2[0] != A || s2[1] != X || s0[2] != 0x0000)
+	abort ();
+    if (s3[0] != A || s3[1] != Y1 || s3[2] != Y2 || s3[3] != 0x0000)
+	abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-3.c
new file mode 100644
index 000000000..ed2eb408b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-3.c
@@ -0,0 +1,49 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test concatenation of char16_t* string literals. */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR16_TYPE__ char16_t;
+
+extern void abort (void);
+
+char16_t	*s0 = u"a" u"b";
+
+char16_t	*s1 = u"a" "b";
+char16_t	*s2 = "a" u"b";
+char16_t	*s3 = u"a" "\u2029";
+char16_t	*s4 = "\u2029" u"b";
+char16_t	*s5 = u"a" "\U00064321";
+char16_t	*s6 = "\U00064321" u"b";
+
+#define A	0x0061
+#define B	0x0062
+#define X	0x2029
+#define Y1	0xD950
+#define Y2	0xDF21
+
+int main ()
+{
+    if (sizeof ((u"a" u"b")[0]) != sizeof (char16_t))
+	abort ();
+    if (sizeof ((u"a"  "b")[0]) != sizeof (char16_t))
+	abort ();
+    if (sizeof (( "a" u"b")[0]) != sizeof (char16_t))
+	abort ();
+
+    if (s0[0] != A || s0[1] != B || s0[2] != 0x0000)
+	abort ();
+
+    if (s1[0] != A || s1[1] != B || s1[2] != 0x0000)
+	abort ();
+    if (s2[0] != A || s2[1] != B || s2[2] != 0x0000)
+	abort ();
+    if (s3[0] != A || s3[1] != X || s3[2] != 0x0000)
+	abort ();
+    if (s4[0] != X || s4[1] != B || s4[2] != 0x0000)
+	abort ();
+    if (s5[0] != A || s5[1] != Y1 || s5[2] != Y2 || s5[3] != 0x0000)
+	abort ();
+    if (s6[0] != Y1 || s6[1] != Y2 || s6[2] != B || s6[3] != 0x0000)
+	abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-4.c
new file mode 100644
index 000000000..61cb10a1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf16-4.c
@@ -0,0 +1,21 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Expected errors for char16_t character constants. */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+typedef __CHAR16_TYPE__ char16_t;
+
+char16_t	c0 = u'';		/* { dg-error "empty character" } */
+char16_t	c1 = u'ab';		/* { dg-warning "constant too long" } */
+char16_t	c2 = u'\U00064321';	/* { dg-warning "constant too long" } */
+
+char16_t	c3 = 'a';
+char16_t	c4 = U'a';
+char16_t	c5 = U'\u2029';
+char16_t	c6 = U'\U00064321';	/* { dg-warning "implicitly truncated" } */
+char16_t	c7 = L'a';
+char16_t	c8 = L'\u2029';
+char16_t 	c9 = L'\U00064321';	/* { dg-warning "implicitly truncated" "" { target { 4byte_wchar_t } } 18 } */
+					/* { dg-warning "constant too long" "" { target { ! 4byte_wchar_t } } 18 } */
+
+int main () {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-1.c
new file mode 100644
index 000000000..7919faa63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-1.c
@@ -0,0 +1,45 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test the support for char32_t character constants. */
+/* { dg-do run } */
+/* { dg-xfail-run-if "PR36470" { "avr-*-*" "m32c-*-*" } { "*" } { "" } } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR32_TYPE__ char32_t;
+
+extern void abort (void);
+
+char32_t	c0 = U'a';
+char32_t	c1 = U'\0';
+char32_t	c2 = U'\u0024';
+char32_t	c3 = U'\u2029';
+char32_t	c4 = U'\U00064321';
+
+#define A	0x00000061
+#define D	0x00000024
+#define X	0x00002029
+#define Y	0x00064321
+
+int main ()
+{
+    if (sizeof (U'a') != sizeof (char32_t))
+	abort ();
+    if (sizeof (U'\0') != sizeof (char32_t))
+	abort ();
+    if (sizeof (U'\u0024') != sizeof (char32_t))
+	abort ();
+    if (sizeof (U'\u2029') != sizeof (char32_t))
+	abort ();
+    if (sizeof (U'\U00064321') != sizeof (char32_t))
+	abort ();
+
+    if (c0 != A)
+	abort ();
+    if (c1 != 0x0000)
+	abort ();
+    if (c2 != D)
+	abort ();
+    if (c3 != X)
+	abort ();
+    if (c4 != Y)
+	abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-2.c
new file mode 100644
index 000000000..3fd1cf1fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-2.c
@@ -0,0 +1,32 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test the support for char32_t* string constants. */
+/* { dg-do run } */
+/* { dg-xfail-run-if "PR36470" { "avr-*-*" "m32c-*-*" } { "*" } { "" } } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR32_TYPE__ char32_t;
+
+extern void abort (void);
+
+char32_t	*s0 = U"ab";
+char32_t	*s1 = U"a\u0024";
+char32_t	*s2 = U"a\u2029";
+char32_t	*s3 = U"a\U00064321";
+
+#define A	0x00000061
+#define B	0x00000062
+#define D	0x00000024
+#define X	0x00002029
+#define Y	0x00064321
+
+int main ()
+{
+    if (s0[0] != A || s0[1] != B || s0[2] != 0x00000000)
+	abort ();
+    if (s1[0] != A || s1[1] != D || s0[2] != 0x00000000)
+	abort ();
+    if (s2[0] != A || s2[1] != X || s0[2] != 0x00000000)
+	abort ();
+    if (s3[0] != A || s3[1] != Y || s3[2] != 0x00000000)
+	abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-3.c
new file mode 100644
index 000000000..486d04f94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-3.c
@@ -0,0 +1,49 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Test concatenation of char32_t* string literals. */
+/* { dg-do run } */
+/* { dg-xfail-run-if "PR36470" { "avr-*-*" "m32c-*-*" } { "*" } { "" } } */
+/* { dg-options "-std=gnu99 -Wall -Werror" } */
+
+typedef __CHAR32_TYPE__ char32_t;
+
+extern void abort (void);
+
+char32_t	*s0 = U"a" U"b";
+
+char32_t	*s1 = U"a" "b";
+char32_t	*s2 = "a" U"b";
+char32_t	*s3 = U"a" "\u2029";
+char32_t	*s4 = "\u2029" U"b";
+char32_t	*s5 = U"a" "\U00064321";
+char32_t	*s6 = "\U00064321" U"b";
+
+#define A	0x00000061
+#define B	0x00000062
+#define X	0x00002029
+#define Y	0x00064321
+
+int main ()
+{
+    if (sizeof ((U"a" U"b")[0]) != sizeof (char32_t))
+	abort ();
+    if (sizeof ((U"a"  "b")[0]) != sizeof (char32_t))
+	abort ();
+    if (sizeof (( "a" U"b")[0]) != sizeof (char32_t))
+	abort ();
+
+    if (s0[0] != A || s0[1] != B || s0[2] != 0x00000000)
+	abort ();
+
+    if (s1[0] != A || s1[1] != B || s1[2] != 0x00000000)
+	abort ();
+    if (s2[0] != A || s2[1] != B || s2[2] != 0x00000000)
+	abort ();
+    if (s3[0] != A || s3[1] != X || s3[2] != 0x00000000)
+	abort ();
+    if (s4[0] != X || s4[1] != B || s4[2] != 0x00000000)
+	abort ();
+    if (s5[0] != A || s5[1] != Y || s5[2] != 0x00000000)
+	abort ();
+    if (s6[0] != Y || s6[1] != B || s6[2] != 0x00000000)
+	abort ();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-4.c
new file mode 100644
index 000000000..34a78da5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/utf32-4.c
@@ -0,0 +1,20 @@
+/* Contributed by Kris Van Hees <kris.van.hees@oracle.com> */
+/* Expected errors for char32_t character constants. */
+/* { dg-do compile { target int32plus } } */
+/* { dg-options "-std=gnu99" } */
+
+typedef __CHAR32_TYPE__ char32_t;
+
+char32_t	c0 = U'';		/* { dg-error "empty character" } */
+char32_t	c1 = U'ab';		/* { dg-warning "constant too long" } */
+char32_t	c2 = U'\U00064321';
+
+char32_t	c3 = 'a';
+char32_t	c4 = u'a';
+char32_t	c5 = u'\u2029';
+char32_t	c6 = u'\U00064321';	/* { dg-warning "constant too long" } */
+char32_t	c7 = L'a';
+char32_t	c8 = L'\u2029';
+char32_t	c9 = L'\U00064321';     /* { dg-warning "constant too long" "" { target { ! 4byte_wchar_t } } } */
+
+int main () {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-1.c
new file mode 100644
index 000000000..ecd0e4d84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+
+#include <stdarg.h>
+
+va_list v;
+volatile int i;
+
+void foo()
+{
+  i = va_arg(v, char); /* { dg-warning "is promoted to|so you should|abort" "char" } */
+  i = va_arg(v, short); /* { dg-warning "is promoted to|abort" "short" } */
+  i = va_arg(v, float); /* { dg-warning "is promoted to|abort" "float" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-2.c
new file mode 100644
index 000000000..2fd0ed97e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-2.c
@@ -0,0 +1,12 @@
+/* <varargs.h> is not supported anymore, but we do install a stub
+   file which issues an #error telling the user to convert their code.  */
+
+/* { dg-do compile } */
+
+#include <varargs.h>  /* { dg-bogus "varargs.h" "missing file" } */
+
+/* { dg-message "" "In file included from" { target *-*-* } 6 } */
+/* { dg-error "no longer implements" "#error 1" { target *-*-* } 4 } */
+/* { dg-error "Revise your code" "#error 2" { target *-*-* } 5 } */
+
+int x;  /* prevent empty-translation-unit warning */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-3.c
new file mode 100644
index 000000000..ef2344b4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-3.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+/* PR 14498.  */
+#include <stdarg.h>
+extern void baz(char *);
+void bar (va_list *args)
+{
+  if (args)
+    {
+      char *s = va_arg(*args, char *);
+      baz(s);
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-1.c
new file mode 100644
index 000000000..09ae97917
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-1.c
@@ -0,0 +1,52 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+int bar (int, const char *, int, ...);
+int baz (int, const char *, long int);
+
+int
+f1 (int x, ...)
+{
+  return bar (5, "", 6, __builtin_va_arg_pack ());	/* { dg-error "invalid use of" } */
+}
+
+extern inline __attribute__((always_inline)) int
+f2 (int y, ...)
+{
+  return bar (y, "", __builtin_va_arg_pack ());		/* { dg-error "invalid use of" } */
+}
+
+extern inline __attribute__((always_inline)) int
+f3 (int y, ...)
+{
+  return bar (y, "", 5, __builtin_va_arg_pack ());
+}
+
+extern inline __attribute__((always_inline)) int
+f4 (int y, ...)
+{
+  return bar (y, "", 4, __builtin_va_arg_pack (), 6);	/* { dg-error "invalid use of" } */
+}
+
+extern inline __attribute__((always_inline)) int
+f5 (int y, ...)
+{
+  return baz (y, "", __builtin_va_arg_pack ());		/* { dg-error "invalid use of" } */
+}
+
+extern inline __attribute__((always_inline)) int
+f6 (int y, ...)
+{
+  return __builtin_va_arg_pack ();			/* { dg-error "invalid use of" } */
+}
+
+int
+test (void)
+{
+  int a = f2 (5, "a", 6);
+  a += f3 (6, "ab", 17LL);
+  a += f4 (7, 1, 2, 3);
+  a += f5 (8, 7L);
+  a += f6 (9);
+  return a;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-2.c
new file mode 100644
index 000000000..417248a2a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+extern void noreturn (int status, ...);
+
+extern inline __attribute ((always_inline)) void
+error (int status, ...)
+{
+  if (__builtin_constant_p (status))
+    noreturn (status, __builtin_va_arg_pack ());
+}
+
+void
+f (void)
+{
+  error (1);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-len-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-len-1.c
new file mode 100644
index 000000000..409c34585
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-len-1.c
@@ -0,0 +1,122 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+#include <stdarg.h>
+
+extern int error_open_missing_mode (void)
+  __attribute__((__error__ ("open with O_CREAT needs 3 arguments, only 2 were given")));
+extern int warn_open_too_many_arguments (void)
+  __attribute__((__warning__ ("open called with more than 3 arguments")));
+extern void abort (void);
+
+char expected_char;
+
+__attribute__((noinline)) int
+myopen2 (const char *path, int oflag)
+{
+  if (expected_char++ != path[0] || path[1] != '\0')
+    abort ();
+  switch (path[0])
+    {
+    case 'f':
+      if (oflag != 0x2)
+	abort ();
+      break;
+    case 'g':
+      if (oflag != 0x43)
+	abort ();
+      /* In real __open_2 this would terminate the program:
+	 open with O_CREAT without third argument.  */
+      return -6;
+    default:
+      abort ();
+    }
+  return 0;
+}
+
+__attribute__((noinline)) int
+myopenva (const char *path, int oflag, ...)
+{
+  int mode = 0;
+  va_list ap;
+  if ((oflag & 0x40) != 0)
+    {
+      va_start (ap, oflag);
+      mode = va_arg (ap, int);
+      va_end (ap);
+    }
+  if (expected_char++ != path[0] || path[1] != '\0')
+    abort ();
+  switch (path[0])
+    {
+    case 'a':
+      if (oflag != 0x43 || mode != 0644)
+	abort ();
+      break;
+    case 'b':
+      if (oflag != 0x3)
+	abort ();
+      break;
+    case 'c':
+      if (oflag != 0x2)
+	abort ();
+      break;
+    case 'd':
+      if (oflag != 0x43 || mode != 0600)
+	abort ();
+      break;
+    case 'e':
+      if (oflag != 0x3)
+	abort ();
+      break;
+    default:
+      abort ();
+    }
+  return 0;
+}
+
+extern inline __attribute__((always_inline, gnu_inline)) int
+myopen (const char *path, int oflag, ...)
+{
+  if (__builtin_va_arg_pack_len () > 1)
+    warn_open_too_many_arguments ();
+
+  if (__builtin_constant_p (oflag))
+    {
+      if ((oflag & 0x40) != 0 && __builtin_va_arg_pack_len () < 1)
+	{
+	  error_open_missing_mode ();
+	  return myopen2 (path, oflag);
+	}
+      return myopenva (path, oflag, __builtin_va_arg_pack ());
+    }
+
+  if (__builtin_va_arg_pack_len () < 1)
+    return myopen2 (path, oflag);
+
+  return myopenva (path, oflag, __builtin_va_arg_pack ());
+}
+
+volatile int l0;
+
+int
+main (void)
+{
+  expected_char = 'a';
+  if (myopen ("a", 0x43, 0644))
+    abort ();
+  if (myopen ("b", 0x3, 0755))
+    abort ();
+  if (myopen ("c", 0x2))
+    abort ();
+  if (myopen ("d", l0 + 0x43, 0600))
+    abort ();
+  if (myopen ("e", l0 + 0x3, 0700))
+    abort ();
+  if (myopen ("f", l0 + 0x2))
+    abort ();
+  /* Invalid use of myopen, but only detectable at runtime.  */
+  if (myopen ("g", l0 + 0x43) != -6)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-len-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-len-2.c
new file mode 100644
index 000000000..c3fa856fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/va-arg-pack-len-2.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+#include <stdarg.h>
+
+extern int error_open_missing_mode (void)
+  __attribute__((__error__ ("open with O_CREAT needs 3 arguments, only 2 were given")));
+extern int warn_open_too_many_arguments (void)
+  __attribute__((__warning__ ("open called with more than 3 arguments")));
+
+extern int myopen2 (const char *path, int oflag);
+extern int myopenva (const char *path, int oflag, ...);
+
+extern inline __attribute__((always_inline, gnu_inline)) int
+myopen (const char *path, int oflag, ...)
+{
+  if (__builtin_va_arg_pack_len () > 1)
+    warn_open_too_many_arguments ();	/* { dg-warning "called with more than 3" } */
+
+  if (__builtin_constant_p (oflag))
+    {
+      if ((oflag & 0x40) != 0 && __builtin_va_arg_pack_len () < 1)
+	{
+	  error_open_missing_mode ();	/* { dg-error "needs 3 arguments, only 2 were given" } */
+	  return myopen2 (path, oflag);
+	}
+      return myopenva (path, oflag, __builtin_va_arg_pack ());
+    }
+
+  if (__builtin_va_arg_pack_len () < 1)
+    return myopen2 (path, oflag);
+
+  return myopenva (path, oflag, __builtin_va_arg_pack ());
+}
+
+int
+main (void)
+{
+  myopen ("h", 0x43);
+  myopen ("i", 0x43, 0644, 0655);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand1.c
new file mode 100644
index 000000000..3904407c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand1.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* We don't (and don't want to) perform this optimisation on soft-float
+   targets, where each addition is a library call.  */
+/* { dg-require-effective-target hard_float } */
+/* { dg-options "-O2 -funroll-loops --fast-math -fvariable-expansion-in-unroller -fdump-rtl-loop2_unroll" } */
+
+extern void abort (void);
+
+float array[10] = { 1,2,3,4,5,6,7,8,9,10 };
+
+int foo (int n)
+{
+  unsigned i;
+  float accum = 1.0;
+
+  for (i = 0; i < n; i++)
+    accum += array[i];
+
+  return accum;
+}
+
+int main (void)
+{
+  return foo (10);
+}
+
+/* { dg-final { scan-rtl-dump "Expanding Accumulator" "loop2_unroll" } } */
+/* { dg-final { cleanup-rtl-dump "loop*" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand2.c
new file mode 100644
index 000000000..499de55cb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand2.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -funroll-loops -ffast-math -fvariable-expansion-in-unroller" } */
+
+extern void abort (void);
+
+float array[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+int
+foo (int n)
+{
+  unsigned i;
+  float accum = 0;
+
+  for (i = 0; i < n; i++)
+    accum += array[i];
+
+  if (accum != 55)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  return foo (10);
+}
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand3.c
new file mode 100644
index 000000000..a9d0fe917
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/var-expand3.c
@@ -0,0 +1,58 @@
+/* { dg-do run { target { powerpc*-*-* && vmx_hw } } }} */
+/* { dg-options "-O2 -funroll-loops -ffast-math -fvariable-expansion-in-unroller -maltivec -fdump-rtl-loop2_unroll" } */
+
+#include "altivec.h"
+extern void abort (void);
+extern void exit (int);
+
+#define N 256
+
+float in1[N] __attribute__ ((__aligned__ (16))) = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57};
+float in2[N] __attribute__ ((__aligned__ (16))) = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+
+float
+foo (int n)
+{
+  unsigned i;
+  vector float vp1, vp2, vp3, vaccum, vzero, vtmp;
+  float accum = 1.0;
+
+  vzero = (vector float){0, 0, 0, 0};
+
+  vaccum = vzero;
+
+  for (i = 0; i < n; i++)
+    {
+      vp1 = vec_ld (i * 16, in1);
+      vp2 = vec_ld (i * 16, in2);
+
+      vaccum = vec_madd (vp1, vp2, vaccum);
+
+    }
+  vtmp = vec_sld (vaccum, vaccum, 8);
+  vp1 = vec_add (vaccum, vtmp);
+  vtmp = vec_sld (vp1, vp1, 4);
+  vp2 = vec_add (vp1, vtmp);
+
+  vec_ste (vp2, 0, &accum);
+  if (accum != 1518)
+    return 0;
+ 
+  return accum;
+}
+
+int
+main (void)
+{
+  if (!foo (3))
+    abort ();
+
+   exit (0);
+}
+
+/* { dg-final { scan-rtl-dump "Expanding Accumulator" "loop2_unroll" } } */
+/* { dg-final { cleanup-rtl-dump "loop*" } } */
+
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/varpool-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/varpool-1.c
new file mode 100644
index 000000000..48f1cd359
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/varpool-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-final { scan-assembler-not "unnecesary_static_initialized_variable" } } */
+
+static int unnecesary_static_initialized_variable;
+static int *unnecesary_static_initialized_variable2 =
+  &unnecesary_static_initialized_variable;
+static inline
+simplify_after_inline (int param1, int *param2)
+{
+  if (unnecesary_static_initialized_variable != param1)
+    return unnecesary_static_initialized_variable;
+  if (unnecesary_static_initialized_variable2 != param2)
+    return unnecesary_static_initialized_variable;
+}
+
+main ()
+{
+  return simplify_after_inline (unnecesary_static_initialized_variable,
+				unnecesary_static_initialized_variable2) +
+    simplify_after_inline (unnecesary_static_initialized_variable,
+			   unnecesary_static_initialized_variable2);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O1-pr33854.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O1-pr33854.c
new file mode 100644
index 000000000..4d4171fc4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O1-pr33854.c
@@ -0,0 +1,22 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+/* { dg-do compile } */
+
+extern void *malloc (__SIZE_TYPE__ __size);
+typedef struct VMatrix_ VMatrix;
+struct VMatrix_
+{
+  int dim;
+  int t2;
+};
+void uniform_correlation_matrix (VMatrix * v)
+{
+  double *xbar = ((void *) 0);
+  int m = v->dim;
+  int i;
+  xbar = malloc (m * sizeof *xbar);
+  for (i = 0; i < m; i++)
+    xbar[i] /= m;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O1-pr41008.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O1-pr41008.c
new file mode 100644
index 000000000..bbdea127c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O1-pr41008.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+double heating[2][2];
+
+void foo (int, int);
+
+void map_do()
+{
+  int jsav, ksav, k, j;
+
+  for(k = 0; k < 2; k++)
+    for(j = 0; j < 2; j++)
+      if (heating[k][j] > 0.)
+        {
+          jsav = j;
+          ksav = k;
+        }
+
+  foo (jsav, ksav);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-pr36098.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-pr36098.c
new file mode 100644
index 000000000..1c445be9e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-pr36098.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+typedef struct {
+  int iatom[3];
+  int blocknr;
+} t_sortblock;
+
+#define DIM 3
+
+void foo (int ncons, t_sortblock *sb, int *iatom)
+{
+ int i, m;
+
+ for(i=0; (i<ncons); i++,iatom+=3)
+   for(m=0; (m<DIM); m++)
+     iatom[m]=sb[i].iatom[m];
+}
+
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-pr39675-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-pr39675-1.c
new file mode 100644
index 000000000..42c9d890f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-pr39675-1.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+
+typedef struct {
+    float vertexAttrib[16][4];
+    float vertexAttribPre[16][4];
+    float rasterAttrib[16][4];
+    float rasterAttribPre[16][4];
+} CRCurrentState;
+void crStateCurrentInit(CRCurrentState *c)
+{
+  unsigned int i;
+  for (i = 0; i < 16; i++)
+    {
+      (c->vertexAttribPre[i])[0] = (c->vertexAttrib[i])[0];
+      (c->vertexAttribPre[i])[1] = (c->vertexAttrib[i])[1];
+      (c->vertexAttribPre[i])[2] = (c->vertexAttrib[i])[2];
+      (c->vertexAttribPre[i])[3] = (c->vertexAttrib[i])[3];
+      (c->rasterAttrib[i])[0] = (c->vertexAttrib[i])[0];
+      (c->rasterAttrib[i])[1] = (c->vertexAttrib[i])[1];
+      (c->rasterAttrib[i])[2] = (c->vertexAttrib[i])[2];
+      (c->rasterAttrib[i])[3] = (c->vertexAttrib[i])[3];
+      (c->rasterAttribPre[i])[0] = (c->vertexAttrib[i])[0];
+      (c->rasterAttribPre[i])[1] = (c->vertexAttrib[i])[1];
+      (c->rasterAttribPre[i])[2] = (c->vertexAttrib[i])[2];
+      (c->rasterAttribPre[i])[3] = (c->vertexAttrib[i])[3];
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-vect-pr32243.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-vect-pr32243.c
new file mode 100644
index 000000000..0116c33fb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-vect-pr32243.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+typedef struct __GLcontextRec GLcontext;
+
+struct gl_renderbuffer
+{
+  struct gl_renderbuffer *Wrapped;
+  void (*PutValues) (GLcontext * ctx, struct gl_renderbuffer * rb,
+		     int count, const int x[], const int y[],
+		     const void *values, const char *mask);
+};
+
+void
+put_mono_values_s8 (GLcontext * ctx, struct gl_renderbuffer *s8rb,
+		    int count, const int x[], const int y[],
+		    const void *value, const char *mask)
+{
+  struct gl_renderbuffer *dsrb = s8rb->Wrapped;
+  int temp[4096], i;
+  const char val = *((char *) value);
+  for (i = 0; i < count; i++)
+    if (!mask || mask[i])
+      temp[i] = (temp[i] & 0xffffff) | val;
+  dsrb->PutValues (ctx, dsrb, count, x, y, temp, mask);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-vect-pr34223.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-vect-pr34223.c
new file mode 100644
index 000000000..ef7ddfc8a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/O3-vect-pr34223.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-options "[vect_cflags] --param max-completely-peel-times=16" } */
+
+#include "tree-vect.h"
+
+#define M 10
+#define N 3
+
+void __attribute__((noinline))
+foo (int n, int *ub, int *uc)
+{
+  int i, j, tmp1;
+
+  for (i = 0; i < n; i++)
+    {
+      tmp1 = 0;
+      for (j = 0; j < M; j++)
+        {
+          tmp1 += uc[i] * ((int)(j << N) / M);
+        }
+      ub[i] = tmp1;
+    }
+}
+
+int main()
+{
+  int uc[16], ub[16];
+  check_vect ();
+  foo (16, uc, ub);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_int_mult } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/Os-vect-95.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/Os-vect-95.c
new file mode 100644
index 000000000..be7168b30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/Os-vect-95.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+void bar (float *pd, float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+      if (pd[i] != 5.0)
+	abort ();
+    }
+
+  return;
+}
+
+
+int
+main1 (int n, float * __restrict__ pd, float * __restrict__ pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+      pd[i] = 5.0;
+    }
+
+  bar (pd,pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float d[N+1] __attribute__ ((__aligned__(16)));
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (N,&d[1],a,b,c);
+  main1 (N-2,&d[1],a,b,c);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 2 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c
new file mode 100644
index 000000000..5627c2655
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-fast-math-vect-pr29925.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdlib.h>
+#include "../../tree-vect.h"
+
+__attribute__ ((noinline)) void
+interp_pitch(float *exc, float *interp, int pitch, int len)
+{
+   int i,k;
+   int maxj;
+
+   maxj=3;
+   for (i=0;i<len;i++)
+   {
+      float tmp = 0;
+      for (k=0;k<7;k++)
+      {
+         tmp += exc[i-pitch+k+maxj-6];
+      }
+      interp[i] = tmp;
+   }
+}
+
+int main()
+{
+   float *exc = calloc(126,sizeof(float));
+   float *interp = calloc(80,sizeof(float));
+   int pitch = -35;
+
+   check_vect ();
+
+   interp_pitch(exc, interp, pitch, 80);
+   free(exc);
+   free(interp);
+   return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-31.c
new file mode 100644
index 000000000..c61517aab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-31.c
@@ -0,0 +1,92 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+struct s tmp;
+
+int main1 ()
+{  
+  int i;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } }
+ */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-33.c
new file mode 100644
index 000000000..feaf58591
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-33.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+struct test {
+  char ca[N];
+};
+
+extern struct test s;
+ 
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-68.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-68.c
new file mode 100644
index 000000000..b916cd91d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-68.c
@@ -0,0 +1,88 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1.a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.e.n[1][2][i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 7)
+        abort ();
+    }
+
+  /* 4. unaligned */
+  for (i = 3; i < N-3; i++)
+    {
+      tmp1.e.n[1][2][i] = 8;
+    }
+ 
+  /* check results:  */
+  for (i = 3; i <N-3; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-reduc-1char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-reduc-1char.c
new file mode 100644
index 000000000..a7b86cebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/costmodel-vect-reduc-1char.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+#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};
+
+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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/i386-costmodel-vect.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/i386-costmodel-vect.exp
new file mode 100644
index 000000000..3518de059
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/i386/i386-costmodel-vect.exp
@@ -0,0 +1,72 @@
+# Copyright (C) 1997, 2004, 2005, 2006, 2007, 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
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Exit immediately if this isn't a x86 target.
+if { ![istarget i?86*-*-*] && ![istarget x86_64-*-*] } then {
+  return
+}
+
+# Set up flags used for tests that don't specify options.
+set DEFAULT_VECTCFLAGS ""
+
+# These flags are used for all targets.
+lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" "-fvect-cost-model"
+
+# If the target system supports vector instructions, the default action
+# for a test is 'run', otherwise it's 'compile'.  Save current default.
+# Executing vector instructions on a system without hardware vector support
+# is also disabled by a call to check_vect, but disabling execution here is
+# more efficient.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+
+lappend DEFAULT_VECTCFLAGS "-msse2"
+if [check_sse2_hw_available] {
+    set dg-do-what-default run
+} else {
+    set dg-do-what-default compile
+}
+
+# Initialize `dg'.
+dg-init
+
+lappend DEFAULT_VECTCFLAGS "-fdump-tree-vect-details"
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-vect-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+#### Tests with special options
+global SAVED_DEFAULT_VECTCFLAGS
+set SAVED_DEFAULT_VECTCFLAGS $DEFAULT_VECTCFLAGS
+
+# -ffast-math tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-ffast-math"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-fast-math-vect*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# Clean up.
+set dg-do-what-default ${save-dg-do-what-default}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-fast-math-vect-pr29925.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-fast-math-vect-pr29925.c
new file mode 100644
index 000000000..00e631b13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-fast-math-vect-pr29925.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdlib.h>
+#include "../../tree-vect.h"
+
+__attribute__ ((noinline)) void
+interp_pitch(float *exc, float *interp, int pitch, int len)
+{
+   int i,k;
+   int maxj;
+
+   maxj=3;
+   for (i=0;i<len;i++)
+   {
+      float tmp = 0;
+      for (k=0;k<7;k++)
+      {
+         tmp += exc[i-pitch+k+maxj-6];
+      }
+      interp[i] = tmp;
+   }
+}
+
+int main()
+{
+   float *exc = calloc(126,sizeof(float));
+   float *interp = calloc(80,sizeof(float));
+   int pitch = -35;
+
+   check_vect ();
+
+   interp_pitch(exc, interp, pitch, 80);
+   free(exc);
+   free(interp);
+   return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-pr37194.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-pr37194.c
new file mode 100644
index 000000000..76c7850fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-pr37194.c
@@ -0,0 +1,28 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-do compile } */
+
+#include <stdlib.h>
+#include "../../tree-vect.h"
+
+__attribute__ ((noinline)) void 
+ggSpectrum_Set8(float * data, float d) 
+{
+   int i;
+
+   for (i = 0; i < 8; i++)
+      data[i] = d;
+}
+
+__attribute__ ((noinline)) void 
+ggSpectrum_Set20(float * data, float d) 
+{
+   int i;
+
+   for (i = 0; i < 20; i++)
+      data[i] = d;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-12.c
new file mode 100644
index 000000000..5eb01ebba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-12.c
@@ -0,0 +1,120 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "../../tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  float out2[N*8], fa[N*4];
+  unsigned int ia[N], ib[N*2];
+
+  for (i = 0; i < N; i++)
+    {
+      
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] + 6;
+      a2 = in[i*8 + 2] + 7;
+      a3 = in[i*8 + 3] + 8;
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+
+      b0 = a0 * 3;
+      b1 = a1 * 2;
+      b2 = a2 * 12;
+      b3 = a3 * 5;
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+
+      ia[i] = b6;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] + 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7
+         || ia[i] != (in[i*8 + 6] + 11) * 3)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = (in[i*4] + 2) * 3;
+      out[i*4 + 1] = (in[i*4 + 1] + 2) * 7;
+      out[i*4 + 2] = (in[i*4 + 2] + 7) * 3;
+      out[i*4 + 3] = (in[i*4 + 3] + 7) * 7;
+
+      ib[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  (in[i*4] + 2) * 3
+         || out[i*4 + 1] != (in[i*4 + 1] + 2) * 7
+         || out[i*4 + 2] != (in[i*4 + 2] + 7) * 3
+         || out[i*4 + 3] != (in[i*4 + 3] + 7) * 7
+         || ib[i] != 7)
+        abort ();
+    }
+
+  for (i = 0; i < N*4; i++)
+    {
+      out2[i*2] = (float) (in[i*2] * 2 + 11) ;
+      out2[i*2 + 1] = (float) (in[i*2 + 1] * 3 + 7);
+    
+      fa[i] = (float) in[i*2+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*4; i++)
+    {
+      if (out2[i*2] !=  (float) (in[i*2] * 2 + 11)
+         || out2[i*2 + 1] != (float) (in[i*2 + 1] * 3 + 7)
+         || fa[i] != (float) in[i*2+1])
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target { vect_strided && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" {target { vect_strided && vect_int_mult } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-33.c
new file mode 100644
index 000000000..9cae12fdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-33.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  short a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 2B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N/4; i++)
+    {
+      tmp.b[2*i] = 5;
+      tmp.b[2*i+1] = 15;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/4; i++)
+    {
+      if (tmp.b[2*i] != 5
+          || tmp.b[2*i+1] != 15)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c
new file mode 100644
index 000000000..376c7e4ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c
@@ -0,0 +1,74 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+struct mystr {
+  int f1;
+  int f2;
+};
+
+struct mystr af[16] = {
+  10, 11, 12, 13, 14, 15, 16, 17,
+  20, 21, 22, 23, 24, 25, 26, 27,
+  30, 31, 32, 33, 34, 35, 36, 37,
+  40, 41, 42, 43, 44, 45, 46, 47
+};
+
+struct mystr bf[16] = {
+  12, 13, 14, 15, 16, 17, 18, 19,
+  22, 23, 24, 25, 26, 27, 28, 29,
+  32, 33, 34, 35, 36, 37, 38, 39,
+  42, 43, 44, 45, 46, 47, 48, 49
+};
+
+struct mystr cf[16];
+
+int res1[16] = {
+  22, 26, 30, 34, 42, 46, 50, 54,
+  62, 66, 70, 74, 82, 86, 90, 94,
+};
+
+int res2[16] = {
+  24, 28, 32, 36, 44, 48, 52, 56,
+  64, 68, 72, 76, 84, 88, 92, 96,
+};
+
+__attribute__ ((noinline)) void
+foo (void)
+{
+  int i;
+
+  for (i = 0; i < 16; i++)
+  {
+    cf[i].f1 = af[i].f1 + bf[i].f1;
+    cf[i].f2 = af[i].f2 + bf[i].f2;
+  }
+}
+
+
+
+int
+main (void)
+{ 
+  int i;
+
+  check_vect ();
+  foo ();
+
+  /* Check resiults. */ 
+  for (i = 0; i < 16; i++)
+    {
+      if (cf[i].f1 != res1[i])
+	abort ();
+      if (cf[i].f2 != res2[i])
+        abort ();
+
+    }
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c
new file mode 100644
index 000000000..272b3f0d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31b.c
new file mode 100644
index 000000000..b3224f943
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31b.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31c.c
new file mode 100644
index 000000000..9dcd09aba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31c.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31d.c
new file mode 100644
index 000000000..d9ea5d126
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31d.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 5 
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-33.c
new file mode 100644
index 000000000..11036b0bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-33.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+struct test {
+  char ca[N];
+};
+
+extern struct test s;
+ 
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  return main1 ();
+} 
+
+/* Peeling to align the store is used. Overhead of peeling is too high.  */
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" { target vector_alignment_reachable } } } */
+
+/* Versioning to align the store is used. Overhead of versioning is not too high.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target {! vector_alignment_reachable} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68a.c
new file mode 100644
index 000000000..d0d40ac33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68a.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68b.c
new file mode 100644
index 000000000..4e52af8b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68b.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1.a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68c.c
new file mode 100644
index 000000000..58c5e9fdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68c.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.e.n[1][2][i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 7)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68d.c
new file mode 100644
index 000000000..7fc259465
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-68d.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 11 
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 4. unaligned */
+  for (i = 3; i < N-3; i++)
+    {
+      tmp1.e.n[1][2][i] = 8;
+    }
+ 
+  /* check results:  */
+  for (i = 3; i <N-3; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76a.c
new file mode 100644
index 000000000..41fe3aebf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76a.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 8
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+  int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = pib[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != pib[i - OFF])
+        abort ();
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76b.c
new file mode 100644
index 000000000..8723d266f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76b.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 8
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+  int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+  for (i = OFF; i < N; i++)
+    {
+      pib[i - OFF] = ic[i];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (pib[i - OFF] != ic[i])
+        abort ();
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+/* Peeling to align the store is used. Overhead of peeling is too high.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" { target { vector_alignment_reachable && {! vect_no_align} } } } } */
+
+/* Versioning to align the store is used. Overhead of versioning is not too high.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_no_align || {! vector_alignment_reachable} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76c.c
new file mode 100644
index 000000000..1142e7a27
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-76c.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32 
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = ic[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != ic[i - OFF])
+        abort ();  
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-outer-fir.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-outer-fir.c
new file mode 100644
index 000000000..49a909805
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-outer-fir.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 40
+#define M 128
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Should be vectorized. Fixed misaligment in the inner-loop.  */
+/* Currently not vectorized because we get too many BBs in the inner-loop,
+   because the compiler doesn't realize that the inner-loop executes at
+   least once (cause k<4), and so there's no need to create a guard code
+   to skip the inner-loop in case it doesn't execute.  */
+__attribute__ ((noinline)) void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+  out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = k; j < M; j+=4) {
+      diff += in[j+i]*coeff[j];
+    }
+    out[i] += diff;
+  }
+ }
+}
+
+/* Vectorized. Changing misalignment in the inner-loop.  */
+__attribute__ ((noinline)) void fir (){
+  int i,j,k;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j++) {
+      diff += in[j+i]*coeff[j];
+    }
+    fir_out[i] = diff;
+  }
+}
+
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < M; i++)
+    coeff[i] = i;
+  for (i = 0; i < N+M; i++)
+    in[i] = i;
+
+  foo ();
+  fir ();
+
+  for (i = 0; i < N; i++) {
+    if (out[i] != fir_out[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-reduc-1char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-reduc-1char.c
new file mode 100644
index 000000000..55334fdd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-reduc-1char.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+void
+main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
+{
+  int i;
+  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};
+  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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/ppc-costmodel-vect.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/ppc-costmodel-vect.exp
new file mode 100644
index 000000000..7401cca75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/ppc/ppc-costmodel-vect.exp
@@ -0,0 +1,84 @@
+# Copyright (C) 1997, 2004, 2005, 2006, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Exit immediately if this isn't a powerpc target.
+if { ![istarget powerpc*-*-*] } then {
+  return
+}
+
+# Skip targets not supporting -maltivec.
+if ![is-effective-target powerpc_altivec_ok] {
+  return
+}
+
+# Set up flags used for tests that don't specify options.
+set DEFAULT_VECTCFLAGS ""
+
+# These flags are used for all targets.
+lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" "-fvect-cost-model"
+
+# If the target system supports vector instructions, the default action
+# for a test is 'run', otherwise it's 'compile'.  Save current default.
+# Executing vector instructions on a system without hardware vector support
+# is also disabled by a call to check_vect, but disabling execution here is
+# more efficient.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+
+lappend DEFAULT_VECTCFLAGS "-maltivec"
+if [check_vmx_hw_available] {
+    set dg-do-what-default run
+} else {
+    if [is-effective-target ilp32] {
+        # Specify a cpu that supports VMX for compile-only tests.
+        lappend DEFAULT_VECTCFLAGS "-mcpu=970"
+    }
+    set dg-do-what-default compile
+}
+
+# Initialize `dg'.
+dg-init
+
+lappend DEFAULT_VECTCFLAGS "-fdump-tree-vect-details"
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-pr*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-vect-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-slp-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+#### Tests with special options
+global SAVED_DEFAULT_VECTCFLAGS
+set SAVED_DEFAULT_VECTCFLAGS $DEFAULT_VECTCFLAGS
+
+# -ffast-math tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-ffast-math"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-fast-math-vect*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# Clean up.
+set dg-do-what-default ${save-dg-do-what-default}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-fast-math-vect-pr29925.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-fast-math-vect-pr29925.c
new file mode 100644
index 000000000..00e631b13
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-fast-math-vect-pr29925.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdlib.h>
+#include "../../tree-vect.h"
+
+__attribute__ ((noinline)) void
+interp_pitch(float *exc, float *interp, int pitch, int len)
+{
+   int i,k;
+   int maxj;
+
+   maxj=3;
+   for (i=0;i<len;i++)
+   {
+      float tmp = 0;
+      for (k=0;k<7;k++)
+      {
+         tmp += exc[i-pitch+k+maxj-6];
+      }
+      interp[i] = tmp;
+   }
+}
+
+int main()
+{
+   float *exc = calloc(126,sizeof(float));
+   float *interp = calloc(80,sizeof(float));
+   int pitch = -35;
+
+   check_vect ();
+
+   interp_pitch(exc, interp, pitch, 80);
+   free(exc);
+   free(interp);
+   return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31a.c
new file mode 100644
index 000000000..272b3f0d7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31a.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31b.c
new file mode 100644
index 000000000..b3224f943
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31b.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31c.c
new file mode 100644
index 000000000..9dcd09aba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31c.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31d.c
new file mode 100644
index 000000000..736804fd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-31d.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-33.c
new file mode 100644
index 000000000..3e0db3d84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-33.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 17
+struct test {
+  char ca[N];
+};
+
+extern struct test s;
+ 
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68a.c
new file mode 100644
index 000000000..d0d40ac33
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68a.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68b.c
new file mode 100644
index 000000000..4e52af8b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68b.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1.a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68c.c
new file mode 100644
index 000000000..58c5e9fdb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68c.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.e.n[1][2][i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 7)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68d.c
new file mode 100644
index 000000000..9cec93633
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-68d.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 20
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 4. unaligned */
+  for (i = 3; i < N-3; i++)
+    {
+      tmp1.e.n[1][2][i] = 8;
+    }
+ 
+  /* check results:  */
+  for (i = 3; i <N-3; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76a.c
new file mode 100644
index 000000000..41fe3aebf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76a.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 8
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+  int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = pib[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != pib[i - OFF])
+        abort ();
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76b.c
new file mode 100644
index 000000000..4969a31e0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76b.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 0, 1, 3, 5, 7, 11, 13, 17};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 0, 1, 3, 5, 7, 11, 13, 17};
+
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+
+  for (i = OFF; i < N; i++)
+    {
+      pib[i - OFF] = ic[i];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (pib[i - OFF] != ic[i])
+        abort ();
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76c.c
new file mode 100644
index 000000000..573d8aacd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-76c.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 8
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = ic[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != ic[i - OFF])
+        abort ();  
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-iv-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-iv-9.c
new file mode 100644
index 000000000..af694a36d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/costmodel-vect-iv-9.c
@@ -0,0 +1,38 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 26
+int a[N];
+ 
+__attribute__ ((noinline)) int main1 (int X)
+{  
+  int s = X;
+  int i;
+
+  /* vectorization of reduction with induction.  */
+  for (i = 0; i < N; i++)
+    s += (i + a[i]);
+
+  return s;
+}
+
+int main (void)
+{ 
+  int s, i;
+  check_vect ();
+  
+  for (i = 0; i < N; i++)
+    a[i] = 2*i;
+
+  s = main1 (3);
+  if (s != 978)
+    abort ();
+
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_int_mult } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target {! vect_int_mult } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/spu-costmodel-vect.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/spu-costmodel-vect.exp
new file mode 100644
index 000000000..cde70c54a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/spu/spu-costmodel-vect.exp
@@ -0,0 +1,69 @@
+# Copyright (C) 1997, 2004, 2005, 2006, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Exit immediately if this isn't a powerpc target.
+if { ![istarget spu*-*-*] } then {
+  return
+}
+
+
+# Set up flags used for tests that don't specify options.
+set DEFAULT_VECTCFLAGS ""
+
+# These flags are used for all targets.
+lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" "-fvect-cost-model"
+
+# If the target system supports vector instructions, the default action
+# for a test is 'run', otherwise it's 'compile'.  Save current default.
+# Executing vector instructions on a system without hardware vector support
+# is also disabled by a call to check_vect, but disabling execution here is
+# more efficient.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+
+set dg-do-what-default run
+
+# Initialize `dg'.
+dg-init
+
+lappend DEFAULT_VECTCFLAGS "-fdump-tree-vect-details"
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-pr*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-vect-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+#### Tests with special options
+global SAVED_DEFAULT_VECTCFLAGS
+set SAVED_DEFAULT_VECTCFLAGS $DEFAULT_VECTCFLAGS
+
+# -ffast-math tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-ffast-math"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-fast-math-vect*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# Clean up.
+set dg-do-what-default ${save-dg-do-what-default}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c
new file mode 100644
index 000000000..5627c2655
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-fast-math-vect-pr29925.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdlib.h>
+#include "../../tree-vect.h"
+
+__attribute__ ((noinline)) void
+interp_pitch(float *exc, float *interp, int pitch, int len)
+{
+   int i,k;
+   int maxj;
+
+   maxj=3;
+   for (i=0;i<len;i++)
+   {
+      float tmp = 0;
+      for (k=0;k<7;k++)
+      {
+         tmp += exc[i-pitch+k+maxj-6];
+      }
+      interp[i] = tmp;
+   }
+}
+
+int main()
+{
+   float *exc = calloc(126,sizeof(float));
+   float *interp = calloc(80,sizeof(float));
+   int pitch = -35;
+
+   check_vect ();
+
+   interp_pitch(exc, interp, pitch, 80);
+   free(exc);
+   free(interp);
+   return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-pr30843.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-pr30843.c
new file mode 100644
index 000000000..5d5d41587
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-pr30843.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_long } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+
+void dacP98FillRGBMap (unsigned char *pBuffer)
+{
+    unsigned long dw, dw1;
+    unsigned long *pdw = (unsigned long *)(pBuffer);
+
+    for( dw = 256, dw1 = 0; dw; dw--, dw1 += 0x01010101) 
+    {
+       *pdw++ = dw1;
+       *pdw++ = dw1;
+       *pdw++ = dw1;
+       *pdw++ = dw1;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" { target vect_interleave
+} } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-31.c
new file mode 100644
index 000000000..c61517aab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-31.c
@@ -0,0 +1,92 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+struct s tmp;
+
+int main1 ()
+{  
+  int i;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } }
+ */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-33.c
new file mode 100644
index 000000000..feaf58591
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-33.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+struct test {
+  char ca[N];
+};
+
+extern struct test s;
+ 
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-68.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-68.c
new file mode 100644
index 000000000..b916cd91d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-68.c
@@ -0,0 +1,88 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1.a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.e.n[1][2][i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 7)
+        abort ();
+    }
+
+  /* 4. unaligned */
+  for (i = 3; i < N-3; i++)
+    {
+      tmp1.e.n[1][2][i] = 8;
+    }
+ 
+  /* check results:  */
+  for (i = 3; i <N-3; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-reduc-1char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-reduc-1char.c
new file mode 100644
index 000000000..a7b86cebd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-vect-reduc-1char.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "../../tree-vect.h"
+
+#define N 16
+#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};
+
+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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { scan-tree-dump-times "vectorization not profitable" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/x86_64-costmodel-vect.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/x86_64-costmodel-vect.exp
new file mode 100644
index 000000000..ff3650ce2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/x86_64-costmodel-vect.exp
@@ -0,0 +1,75 @@
+# Copyright (C) 1997, 2004, 2005, 2006, 2007, 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
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Exit immediately if this isn't a x86 target.
+if { (![istarget x86_64-*-*] && ![istarget i?86-*-*])
+     || ![is-effective-target lp64] } then {
+  return
+}
+
+# Set up flags used for tests that don't specify options.
+set DEFAULT_VECTCFLAGS ""
+
+# These flags are used for all targets.
+lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" "-fvect-cost-model"
+
+# If the target system supports vector instructions, the default action
+# for a test is 'run', otherwise it's 'compile'.  Save current default.
+# Executing vector instructions on a system without hardware vector support
+# is also disabled by a call to check_vect, but disabling execution here is
+# more efficient.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+
+lappend DEFAULT_VECTCFLAGS "-msse2"
+if [check_sse2_hw_available] {
+    set dg-do-what-default run
+} else {
+    set dg-do-what-default compile
+}
+
+# Initialize `dg'.
+dg-init
+
+lappend DEFAULT_VECTCFLAGS "-fdump-tree-vect-details"
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-pr*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-vect-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+#### Tests with special options
+global SAVED_DEFAULT_VECTCFLAGS
+set SAVED_DEFAULT_VECTCFLAGS $DEFAULT_VECTCFLAGS
+
+# -ffast-math tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-ffast-math"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/costmodel-fast-math-vect*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# Clean up.
+set dg-do-what-default ${save-dg-do-what-default}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/dump-tree-dceloop-pr26359.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/dump-tree-dceloop-pr26359.c
new file mode 100644
index 000000000..ea9b3837c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/dump-tree-dceloop-pr26359.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+int a[256], b[256], c[256];
+
+foo () {
+  int i;
+
+  for (i=0; i<256; i++){
+    a[i] = b[i] + c[i];
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "Deleting : vect_" 0 "dceloop2" } } */
+/* { dg-final { cleanup-tree-dump "dceloop\[1-2\]" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-pr35982.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-pr35982.c
new file mode 100644
index 000000000..6a01782bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-pr35982.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+
+struct mem 
+{
+  float avg;
+  int len;
+};
+
+float method2_int16 (struct mem *mem)
+{
+  int i;
+  float avg;
+
+  for (i = 0; i < 100; ++i)
+     avg += mem[i].avg * (float) mem[i].len;
+
+  return avg;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_extract_even_odd_wide  } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail vect_extract_even_odd_wide  } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-slp-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-slp-27.c
new file mode 100644
index 000000000..d4c7d1992
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-slp-27.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+float x[256];
+
+void foo(void)
+{
+  int i;
+  for (i=0; i<256; ++i)
+   {
+    x[2*i] = x[2*i] * x[2*i];
+    x[2*i+1] = x[2*i+1] * x[2*i+1];
+   }
+}
+
+/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" { target vect_strided } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-complex-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-complex-3.c
new file mode 100644
index 000000000..6110a2319
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-complex-3.c
@@ -0,0 +1,61 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+_Complex float a[N] =
+    { 10.0F + 20.0iF, 11.0F + 21.0iF, 12.0F + 22.0iF, 13.0F + 23.0iF,
+      14.0F + 24.0iF, 15.0F + 25.0iF, 16.0F + 26.0iF, 17.0F + 27.0iF,
+      18.0F + 28.0iF, 19.0F + 29.0iF, 20.0F + 30.0iF, 21.0F + 31.0iF,
+      22.0F + 32.0iF, 23.0F + 33.0iF, 24.0F + 34.0iF, 25.0F + 35.0iF };
+_Complex float b[N] =
+    { 30.0F + 40.0iF, 31.0F + 41.0iF, 32.0F + 42.0iF, 33.0F + 43.0iF,
+      34.0F + 44.0iF, 35.0F + 45.0iF, 36.0F + 46.0iF, 37.0F + 47.0iF,
+      38.0F + 48.0iF, 39.0F + 49.0iF, 40.0F + 50.0iF, 41.0F + 51.0iF,
+      42.0F + 52.0iF, 43.0F + 53.0iF, 44.0F + 54.0iF, 45.0F + 55.0iF };
+
+_Complex float c[N];
+_Complex float res[N] =
+    { -500.0F + 1000.0iF, -520.0F + 1102.0iF,
+      -540.0F + 1208.0iF, -560.0F + 1318.0iF,
+      -580.0F + 1432.0iF, -600.0F + 1550.0iF,
+      -620.0F + 1672.0iF, -640.0F + 1798.0iF,
+      -660.0F + 1928.0iF, -680.0F + 2062.0iF,
+      -700.0F + 2200.0iF, -720.0F + 2342.0iF,
+      -740.0F + 2488.0iF, -760.0F + 2638.0iF,
+      -780.0F + 2792.0iF, -800.0F + 2950.0iF };
+
+
+__attribute__ ((noinline)) void
+foo (void)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    c[i] = a[i] * b[i];
+
+}
+
+int
+main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  foo ();
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+  {
+    if (c[i] != res[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave  && vect_extract_even_odd_wide } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pow-1.c
new file mode 100644
index 000000000..4d000f192
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pow-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+float x[256];
+
+void foo(void)
+{
+  int i;
+  for (i=0; i<256; ++i)
+    x[i] = x[i] * x[i];
+}
+
+/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pow-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pow-2.c
new file mode 100644
index 000000000..a9d927b3f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pow-2.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+
+typedef double d_type;
+struct
+{
+  d_type x;
+  d_type y;
+} S[100];
+
+#define N 16
+d_type foo (d_type t);
+
+d_type
+main1 ()
+{
+  int i;
+  d_type t;
+
+  for (i = 0; i < N; i++)
+    {
+      t = (d_type) i / (d_type) 10;
+      S[5].x = t * t;
+    }
+  return S[5].x;
+}
+
+int
+main (void)
+{
+  d_type tmp = main1 ();
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pr25911.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pr25911.c
new file mode 100644
index 000000000..633382f5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pr25911.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+
+float bessel_Kn_scaled_small_x(int n)
+{
+  int k;
+  float k_term, sum1;
+  for(k=1; k<=n-1; k++)
+  {
+    k_term *= -1/(k * (n-k));
+    sum1 += k_term;
+  }
+  return sum1;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pr29925.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pr29925.c
new file mode 100644
index 000000000..be2f1a913
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-pr29925.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdlib.h>
+#include "tree-vect.h"
+
+__attribute__ ((noinline))
+void interp_pitch(float *exc, float *interp, int pitch, int len)
+{
+   int i,k;
+   int maxj;
+
+   maxj=3;
+   for (i=0;i<len;i++)
+   {
+      float tmp = 0;
+      for (k=0;k<7;k++)
+      {
+         tmp += exc[i-pitch+k+maxj-6];
+      }
+      interp[i] = tmp;
+   }
+}
+
+int main()
+{
+   float *exc = calloc(126,sizeof(float));
+   float *interp = calloc(80,sizeof(float));
+   int pitch = -35;
+
+   check_vect ();
+
+   interp_pitch(exc, interp, pitch, 80);
+   free(exc);
+   free(interp);
+   return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-reduc-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-reduc-5.c
new file mode 100644
index 000000000..377d74b77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-reduc-5.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_float } */
+
+/* need -funsafe-math-optimizations to vectorize the summation.
+   also need -ffinite-math-only to create the min/max expr.  */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+int main1 (float x, float max_result)
+{
+  int i;
+  float diff = 2;
+  float max = x;
+  float min = 10;
+
+  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 != 0)
+    abort ();
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100);
+  main1 (0, 15);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-reduc-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-reduc-7.c
new file mode 100644
index 000000000..9f36db2e7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/fast-math-vect-reduc-7.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_double } */
+
+/* need -funsafe-math-optimizations to vectorize the summation.
+   also need -ffinite-math-only to create the min/max expr.  */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+double b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+double c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+int main1 (double x, double max_result)
+{
+  int i;
+  double diff = 2;
+  double max = x;
+  double min = 10;
+
+  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 != 0)
+    abort ();
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100);
+  main1 (0, 15);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/ggc-pr37574.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/ggc-pr37574.c
new file mode 100644
index 000000000..176aa7eaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/ggc-pr37574.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+
+#include <stdarg.h>
+
+unsigned short in[40 +128];
+int main (void) {
+  int i = 0, j = 0;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+  for (i = 0; i < 40;i++)
+   {
+     diff = 0;
+     for (j = 0; j < 128;j+=8)
+       diff += in[j+i];
+     s += ((unsigned short)diff>>3);
+   }
+   if (s != sum)
+     return -1;
+   return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-math-errno-slp-32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-math-errno-slp-32.c
new file mode 100644
index 000000000..c952e7f1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-math-errno-slp-32.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_double } */
+
+double x[256];
+
+void foo(void)
+{
+  int i;
+  for (i=0; i<128; ++i)
+   {
+    x[2*i] = __builtin_pow (x[2*i], 0.5);
+    x[2*i+1] = __builtin_pow (x[2*i+1], 0.5);
+   }
+}
+
+/* { dg-final { scan-tree-dump "pattern recognized" "vect" { xfail spu*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-math-errno-vect-pow-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-math-errno-vect-pow-1.c
new file mode 100644
index 000000000..03de93bf4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-math-errno-vect-pow-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_double } */
+
+double x[256];
+
+void foo(void)
+{
+  int i;
+  for (i=0; i<256; ++i)
+    x[i] = __builtin_pow (x[i], 0.5);
+}
+
+/* { dg-final { scan-tree-dump "pattern recognized" "vect" { xfail spu*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-1.c
new file mode 100644
index 000000000..9d8a403fe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-1.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j,k=0;
+  int sum,x;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += (i + j);
+      i++;
+    }
+    a[k++] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j,k=0;
+  int sum;
+
+  check_vect ();
+
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++){
+        sum += (j + i);
+	i++;
+      }
+      if (a[k++] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-2.c
new file mode 100644
index 000000000..9a4fa3f25
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-2.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+int a[200*N+N];
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  int sum,s=0;
+
+  for (i = 0; i < 200*N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += (i + j);
+      i++;
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j,k=0;
+  int sum,s=0;
+
+  check_vect ();
+
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<200*N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++){
+        sum += (j + i);
+	i++;
+      }
+      if (a[i] != sum)
+	abort ();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-3.c
new file mode 100644
index 000000000..a4755e13a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-3.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum,x;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += (i + j);
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++){
+        sum += (j + i);
+      }
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-4.c
new file mode 100644
index 000000000..afd2bc414
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-4.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum,s=0;
+
+  for (i = 0; i < 200*N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += (i + j);
+      i++;
+    }
+    s += sum;
+  }
+  return s;
+}
+
+__attribute__ ((noinline))
+int bar (int i, int j)
+{
+return (i + j);
+}
+
+int main (void)
+{
+  int i,j,k=0;
+  int sum,s=0;
+  int res; 
+
+  check_vect ();
+
+  res = foo ();
+
+    /* check results:  */
+  for (i=0; i<200*N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++){
+        sum += bar (i, j);
+	i++;
+      }
+      s += sum;
+    }
+  if (res != s)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-5.c
new file mode 100644
index 000000000..0246a3cda
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-noreassoc-outer-5.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum,x;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    x = a[i];
+    for (j = 0; j < N; j++) {
+      sum += (x + j);
+    }
+    a[i] = sum + i + x;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+  int aa[N];
+
+  check_vect ();
+
+  for (i=0; i<N; i++){
+    a[i] = i;
+    aa[i] = i;
+  }
+ 
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += (j + aa[i]);
+      if (a[i] != sum + i + aa[i])
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-1.c
new file mode 100644
index 000000000..01fcbaa95
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-1.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+
+#define N 40
+signed short image[N][N];
+signed short block[N][N];
+
+/* memory references in the inner-loop */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff = 0;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      diff += (image[i][j] - block[i][j]);
+    }
+  }
+  return diff;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10.c
new file mode 100644
index 000000000..e4d6f23f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+int b[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum,x,y;
+
+  for (i = 0; i < N/2; i++) {
+    sum = 0;
+    x = b[2*i];
+    y = b[2*i+1];
+    for (j = 0; j < n; j++) {
+      sum += j;
+    }
+    a[2*i] = sum + x;
+    a[2*i+1] = sum + y;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    b[i] = i;
+ 
+  foo (N-1);
+
+    /* check results:  */
+  for (i=0; i<N/2; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N-1; j++)
+        sum += j;
+      if (a[2*i] != sum + b[2*i] || a[2*i+1] != sum + b[2*i+1])
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10a.c
new file mode 100644
index 000000000..9a71b498d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10a.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+int b[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum,x,y;
+
+  if (n<=0)
+    return 0;
+
+  for (i = 0; i < N/2; i++) {
+    sum = 0;
+    x = b[2*i];
+    y = b[2*i+1];
+    j = 0;
+    do {
+      sum += j;
+    } while (++j < n);
+    a[2*i] = sum + x;
+    a[2*i+1] = sum + y;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    b[i] = i;
+ 
+  foo (N-1);
+
+    /* check results:  */
+  for (i=0; i<N/2; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N-1; j++)
+        sum += j;
+      if (a[2*i] != sum + b[2*i] || a[2*i+1] != sum + b[2*i+1])
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10b.c
new file mode 100644
index 000000000..b28111c22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-10b.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+int b[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum,x,y;
+
+  if (n<=0)
+    return 0;
+
+  for (i = 0; i < N/2; i++) {
+    sum = 0;
+    x = b[2*i];
+    y = b[2*i+1];
+    for (j = 0; j < n; j++) {
+      sum += j;
+    }
+    a[2*i] = sum + x;
+    a[2*i+1] = sum + y;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    b[i] = i;
+ 
+  foo (N-1);
+
+    /* check results:  */
+  for (i=0; i<N/2; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N-1; j++)
+        sum += j;
+      if (a[2*i] != sum + b[2*i] || a[2*i+1] != sum + b[2*i+1])
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-11.c
new file mode 100644
index 000000000..16b0cc0c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-11.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < n; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (N);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-12.c
new file mode 100644
index 000000000..90ea32ddd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-12.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+int a[N];
+short b[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+    b[i] = (short)sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum  || b[i] != (short)sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* Until we support multiple types in the inner loop  */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c
new file mode 100644
index 000000000..b70aabd84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+unsigned short in[N];
+
+__attribute__ ((noinline)) unsigned int
+foo (short scale){
+  int i;
+  unsigned short j;
+  unsigned int sum = 0;
+  unsigned short sum_j;
+
+  for (i = 0; i < N; i++) {
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+    sum += ((unsigned int) in[i] * (unsigned int) sum_j) >> scale;
+  }
+  return sum;
+}
+
+__attribute__ ((noinline)) unsigned short
+bar (void)
+{
+  unsigned short j;
+  unsigned short sum_j;
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+  return sum_j;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short j, sum_j;
+  unsigned int sum = 0;
+  unsigned int res;
+
+  check_vect ();
+
+  for (i=0; i<N; i++){
+    in[i] = i;
+  }
+ 
+  res = foo (2);
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum_j = bar ();
+      sum += ((unsigned int) in[i] * (unsigned int) sum_j) >> 2;
+    }
+  if (res != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-14.c
new file mode 100644
index 000000000..d7614dc9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-14.c
@@ -0,0 +1,61 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+__attribute__ ((noinline)) unsigned short
+foo (short scale){
+  int i;
+  unsigned short j;
+  unsigned short sum = 0;
+  unsigned short sum_j;
+
+  for (i = 0; i < N; i++) {
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+    sum += sum_j;
+  }
+  return sum;
+}
+
+__attribute__ ((noinline)) unsigned short
+bar (void)
+{
+  unsigned short j;
+  unsigned short sum_j;
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+  return sum_j;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short j, sum_j;
+  unsigned short sum = 0;
+  unsigned short res;
+
+  check_vect ();
+
+  res = foo (2);
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum_j = bar();
+      sum += sum_j;
+    }
+  if (res != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-15.c
new file mode 100644
index 000000000..b90167675
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-15.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int x){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum + i + x;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+  int aa[N];
+
+  check_vect ();
+ 
+  foo (3);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum + i + 3)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-16.c
new file mode 100644
index 000000000..ea58d395c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-16.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i;
+  unsigned short j;
+  int sum = 0;
+  unsigned short sum_j;
+
+  for (i = 0; i < N; i++) {
+    sum += i;
+
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+    a[i] = sum_j + 5;
+  }
+  return sum;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short j, sum_j;
+  int sum = 0;
+  int res;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  res = foo ();
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum += i;
+
+      sum_j = 0;
+      for (j = 0; j < N; j++){
+        sum_j += j;
+      }
+      if (a[i] != sum_j + 5)
+        abort();
+    }
+  if (res != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail { ! {vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-17.c
new file mode 100644
index 000000000..c11a1aa49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-17.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+int b[N];
+int c[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i;
+  unsigned short j;
+  int sum = 0;
+  unsigned short sum_j;
+
+  for (i = 0; i < N; i++) {
+    int diff = b[i] - c[i];
+
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+    a[i] = sum_j + 5;
+
+    sum += diff;
+  }
+  return sum;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short j, sum_j;
+  int sum = 0;
+  int res;
+
+  check_vect ();
+
+  for (i=0; i<N; i++){
+    b[i] = i;
+    c[i] = 2*i;
+  }
+ 
+  res = foo ();
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum += (b[i] - c[i]);
+
+      sum_j = 0;
+      for (j = 0; j < N; j++){
+        sum_j += j;
+      }
+      if (a[i] != sum_j + 5)
+        abort();
+    }
+  if (res != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail { ! {vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-18.c
new file mode 100644
index 000000000..7a6788a0d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-18.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < N/2; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[2*i] = sum;
+    a[2*i+1] = 2*sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N/2; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[2*i] != sum || a[2*i+1] != 2*sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target vect_interleave } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-19.c
new file mode 100644
index 000000000..58bcf0870
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-19.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned short a[N];
+unsigned int b[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  unsigned short i,j;
+  unsigned short sum;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+    b[i] = (unsigned int)sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  short sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum  || b[i] != (unsigned int)sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail { ! {vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-2.c
new file mode 100644
index 000000000..a9ac09c4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+#define N 40
+
+int
+foo (){
+  int i,j;
+  int diff = 0;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      diff += j;
+    }
+  }
+  return diff;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-20.c
new file mode 100644
index 000000000..18e50874a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-20.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+int b[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum,x,y;
+
+  for (i = 0; i < N/2; i++) {
+    sum = 0;
+    x = b[2*i];
+    y = b[2*i+1];
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[2*i] = sum + x;
+    a[2*i+1] = sum + y;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    b[i] = i;
+ 
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N/2; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[2*i] != sum + b[2*i] || a[2*i+1] != sum + b[2*i+1])
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-21.c
new file mode 100644
index 000000000..f955e4a12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-21.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i;
+  unsigned short j;
+  int sum = 0;
+  unsigned short sum_j;
+
+  for (i = 0; i < N; i++) {
+    sum += i;
+
+    sum_j = i;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+    a[i] = sum_j + 5;
+  }
+  return sum;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short j, sum_j;
+  int sum = 0;
+  int res;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  res = foo ();
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum += i;
+
+      sum_j = i;
+      for (j = 0; j < N; j++){
+        sum_j += j;
+      }
+      if (a[i] != sum_j + 5)
+        abort();
+    }
+  if (res != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail { ! { vect_pack_trunc } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-22.c
new file mode 100644
index 000000000..ac24b05d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-22.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum;
+
+  if (n<=0)
+    return 0;
+
+  /* inner-loop index j used after the inner-loop */
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < n; j+=2) {
+      sum += j;
+    }
+    a[i] = sum + j;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (N);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j+=2)
+        sum += j;
+      if (a[i] != sum + j)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-3.c
new file mode 100644
index 000000000..15afdfd5d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-3.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum;
+
+  /* inner-loop step > 1 */
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j+=2) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j+=2)
+        sum += j;
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-4.c
new file mode 100644
index 000000000..5cf9ade11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-4.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+/* induction variable k advances through inner and outer loops.  */
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j,k=0;
+  int sum;
+
+  if (n<=0)
+    return 0;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < n; j+=2) {
+      sum += k++;
+    }
+    a[i] = sum + j;
+  }
+}
+
+int main (void)
+{
+  int i,j,k=0;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (N);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j+=2)
+        sum += k++;
+      if (a[i] != sum + j)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-5.c
new file mode 100644
index 000000000..338e0283b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-5.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] += sum + i;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+  int aa[N];
+
+  check_vect ();
+
+  for (i=0; i<N; i++){
+    a[i] = i;
+    aa[i] = i;
+  }
+ 
+  foo ();
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != aa[i] + sum + i)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-6-global.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-6-global.c
new file mode 100644
index 000000000..a87367b3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-6-global.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int * __restrict__ b, int k){
+  int i,j;
+  int sum,x;
+
+  for (i = 0; i < N; i++) {
+    sum = b[i];
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+  
+  return a[k];
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+  int b[N];
+  int a[N];
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    b[i] = i + 2;
+
+  for (i=0; i<N; i++)
+    a[i] = foo (b,i);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = b[i];
+      for (j = 0; j < N; j++){
+        sum += j;
+      }
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* "Too many BBs in loop"  */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-6.c
new file mode 100644
index 000000000..70cf520d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-6.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+__attribute__ ((noinline)) int
+foo (int * __restrict__ b, int k){
+  int i,j;
+  int sum,x;
+  int a[N];
+
+  for (i = 0; i < N; i++) {
+    sum = b[i];
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+  
+  return a[k];
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+  int b[N];
+  int a[N];
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    b[i] = i + 2;
+
+  for (i=0; i<N; i++)
+    a[i] = foo (b,i);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = b[i];
+      for (j = 0; j < N; j++){
+        sum += j;
+      }
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail { unaligned_stack || vect_no_align } } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c
new file mode 100644
index 000000000..9606d300c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c
@@ -0,0 +1,75 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+unsigned short in[N];
+unsigned short coef[N];
+unsigned short a[N];
+
+__attribute__ ((noinline)) unsigned int
+foo (short scale){
+  int i;
+  unsigned short j;
+  unsigned int sum = 0;
+  unsigned short sum_j;
+
+  for (i = 0; i < N; i++) {
+    sum_j = 0;
+    for (j = 0; j < N; j++) {
+      sum_j += j;
+    }
+    a[i] = sum_j;
+    sum += ((unsigned int) in[i] * (unsigned int) coef[i]) >> scale;
+  }
+  return sum;
+}
+
+unsigned short
+bar (void)
+{
+  unsigned short j;
+  unsigned short sum_j;
+
+  sum_j = 0;
+  for (j = 0; j < N; j++) {
+    sum_j += j;
+  }
+
+  return sum_j;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short j, sum_j;
+  unsigned int sum = 0;
+  unsigned int res;
+
+  check_vect ();
+
+  for (i=0; i<N; i++){
+    in[i] = 2*i;
+    coef[i] = i;
+  }
+ 
+  res = foo (2);
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      if (a[i] != bar ())
+	abort ();
+      sum += ((unsigned int) in[i] * (unsigned int) coef[i]) >> 2;
+    }
+  if (res != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-8.c
new file mode 100644
index 000000000..629cb9497
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-8.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+
+__attribute__ ((noinline)) int
+foo (int *a){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < N; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+  int a[N];
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (a);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9.c
new file mode 100644
index 000000000..e0031274f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < n; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (N);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9a.c
new file mode 100644
index 000000000..730600a7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9a.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum;
+
+  if (n<=0)
+    return 0;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    j = 0;
+    do {
+      sum += j;
+    }while (++j < n);
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (N);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9b.c
new file mode 100644
index 000000000..a8a52b963
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-9b.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+
+int a[N];
+
+__attribute__ ((noinline)) int
+foo (int n){
+  int i,j;
+  int sum;
+
+  if (n<=0)
+    return 0;
+
+  for (i = 0; i < N; i++) {
+    sum = 0;
+    for (j = 0; j < n; j++) {
+      sum += j;
+    }
+    a[i] = sum;
+  }
+}
+
+int main (void)
+{
+  int i,j;
+  int sum;
+
+  check_vect ();
+
+  for (i=0; i<N; i++)
+    a[i] = i;
+ 
+  foo (N);
+
+    /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      sum = 0;
+      for (j = 0; j < N; j++)
+        sum += j;
+      if (a[i] != sum)
+        abort();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-slp-30.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-slp-30.c
new file mode 100644
index 000000000..30cb947be
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-slp-30.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 ()
+{
+  int i, j;
+  unsigned short out[N*8], a[N];
+   
+ for (j = 0; j < N; j++)
+   {
+    for (i = 0; i < N; i++)
+      {
+        out[i*4] = 8;
+        out[i*4 + 1] = 18;
+        out[i*4 + 2] = 28;
+        out[i*4 + 3] = 38;
+      }
+    a[j] = 8;
+   }
+
+  /* check results:  */
+   for (j = 0; j < N; j++)
+   {
+    for (i = 0; i < N; i++)
+      {
+        if (out[i*4] != 8
+            || out[i*4 + 1] != 18
+            || out[i*4 + 2] != 28
+            || out[i*4 + 3] != 38)
+          abort();
+      }
+   
+    if (a[j] != 8)
+       abort ();
+   }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-slp-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-slp-31.c
new file mode 100644
index 000000000..2e43db136
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-slp-31.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 ()
+{
+  int i, j;
+  unsigned short out[N*8], a[N][N];
+   
+ for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+      {
+        a[i][j] = 8;
+      }
+    out[i*4] = 8;
+    out[i*4 + 1] = 18;
+    out[i*4 + 2] = 28;
+    out[i*4 + 3] = 38;
+   }
+
+  /* check results:  */
+ for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++) 
+      {
+        if (a[i][j] != 8)
+           abort ();
+      }
+    if (out[i*4] != 8
+        || out[i*4 + 1] != 18
+        || out[i*4 + 2] != 28
+        || out[i*4 + 3] != 38)
+      abort();
+   }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-1.c
new file mode 100644
index 000000000..9793a129e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-1.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 26
+ 
+__attribute__ ((noinline)) int main1 (int X)
+{  
+  int s = X;
+  int i;
+
+  /* vectorization of reduction with induction. 
+     Need -fno-tree-scev-cprop or else the loop is eliminated.  */
+  for (i = 0; i < N; i++)
+    s += i;
+
+  return s;
+}
+
+int main (void)
+{ 
+  int s;
+  check_vect ();
+  
+  s = main1 (3);
+  if (s != 328)
+    abort ();
+
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-2.c
new file mode 100644
index 000000000..adca5cba5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-2.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int arr1[N];
+  int k = 0;
+  int m = 3, i = 0;
+  
+  /* Vectorization of induction that is used after the loop.  
+     Currently vectorizable because scev_ccp disconnects the
+     use-after-the-loop from the iv def inside the loop.  */
+
+   do { 
+        k = k + 2;
+        arr1[i] = k;
+	m = m + k;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (arr1[i] != 2+2*i)
+        abort ();
+    }
+
+  return m + k;
+}
+
+int main (void)
+{ 
+  int res;
+
+  check_vect ();
+  
+  res = main1 ();
+  if (res != 32 + 275)
+    abort ();
+
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-3.c
new file mode 100644
index 000000000..9bf3b4b76
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-scevccp-vect-iv-3.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 26
+ 
+__attribute__ ((noinline))
+unsigned int main1 ()
+{  
+  unsigned short i;
+  unsigned int intsum = 0;
+
+  /* vectorization of reduction with induction, and widenning sum: 
+     sum shorts into int. 
+     Need -fno-tree-scev-cprop or else the loop is eliminated.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += i;
+    } 
+
+  return intsum;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_hi_to_si } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" { target vect_widen_sum_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-31.c
new file mode 100644
index 000000000..21b87a396
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-31.c
@@ -0,0 +1,92 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+struct s tmp;
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-34.c
new file mode 100644
index 000000000..2eac33e41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-34.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+struct {
+  char ca[N];
+} s;
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-36.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-36.c
new file mode 100644
index 000000000..351463bb1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-36.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+struct {
+  char ca[N];
+  char cb[N];
+} s;
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.cb[i] = 3*i;
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = s.cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != s.cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-64.c
new file mode 100644
index 000000000..1ce3fa7f2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-64.c
@@ -0,0 +1,88 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N][4][N+1];
+int ic[N][N][3][13];
+int id[N][N][N];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+
+  /* Multidimensional array. Not aligned: vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][j] = ib[i];
+        }
+    }
+
+  /* Multidimensional array. Aligned: vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ic[i][1][1][j] = ib[i];
+        }
+    }
+
+  /* Multidimensional array. Not aligned: vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           id[i][1][j+1] = ib[i];
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][j] != ib[i])
+              abort();
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ic[i][1][1][j] != ib[i])
+              abort();
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (id[i][1][j+1] != ib[i])
+              abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-65.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-65.c
new file mode 100644
index 000000000..b1e74a9f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-65.c
@@ -0,0 +1,85 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define M 4
+
+int ib[M][M][N] = {{{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
+                   {{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
+                   {{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
+                   {{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                    {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}}};
+int ia[M][M][N];
+int ic[N];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Load and store. */
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][j] = ib[2][i][j];
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][j] != ib[2][i][j])
+              abort();
+        }
+    }
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Load. */
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ic[j] = ib[2][i][j];
+        }
+    }
+
+  /* check results: */
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ic[j] != ib[2][i][j])
+              abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-66.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-66.c
new file mode 100644
index 000000000..d590975e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-66.c
@@ -0,0 +1,83 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+
+int ia[8][5][N+2];
+int ic[16][16][5][N+2];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+
+  /* Multidimensional array. Aligned. */
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[2][6][j] = 5;
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[2][6][j] != 5)
+                abort();
+        }
+    }
+  /* Multidimensional array. Aligned. */
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+           ia[3][6][j+2] = 5;
+    }
+
+  /* check results: */  
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 2; j < N+2; j++)
+        {
+           if (ia[3][6][j] != 5)
+                abort();
+        }
+    }
+
+  /* Multidimensional array. Not aligned. */
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ic[2][1][6][j+1] = 5;
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ic[2][1][6][j+1] != 5)
+                abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c
new file mode 100644
index 000000000..de036e88e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c
@@ -0,0 +1,92 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+struct test1 tmp1;
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i,j;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1.a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.e.n[1][2][i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 7)
+        abort ();
+    }
+
+  /* 4. unaligned */
+  for (i = 3; i < N-3; i++)
+    {
+      tmp1.e.n[1][2][i] = 8;
+    }
+ 
+  /* check results:  */
+  for (i = 3; i <N-3; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-69.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-69.c
new file mode 100644
index 000000000..c63ae2fd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-69.c
@@ -0,0 +1,120 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 12
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct s2{
+  int m;
+  int n[N-1][N-1][N-1];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+struct test2{
+  struct s2 a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s2 e; /* array e.n is aligned */
+};
+
+
+struct test1 tmp1[4];
+struct test2 tmp2[4];
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i,j;
+
+  /* 1. unaligned (known misalignment) */
+  for (i = 0; i < N; i++)
+    {
+      tmp1[2].a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1[2].a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1[2].a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1[2].a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+          tmp1[2].e.n[1][i][j] = 8;
+	}
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+          if (tmp1[2].e.n[1][i][j] != 8)
+	    abort ();
+	}
+    }
+
+  /* 4. unaligned (unknown misalignment) */
+  for (i = 0; i < N-4; i++)
+    {
+      for (j = 0; j < N-4; j++)
+	{
+          tmp2[2].e.n[1][i][j] = 8;
+	}
+    }
+
+  /* check results:  */
+  for (i = 0; i < N-4; i++)
+    {
+      for (j = 0; j < N-4; j++)
+	{
+          if (tmp2[2].e.n[1][i][j] != 8)
+	    abort ();
+	}
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" { xfail {! vector_alignment_reachable} } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target {! vector_alignment_reachable} } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target {! vector_alignment_reachable} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-outer-4h.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-outer-4h.c
new file mode 100644
index 000000000..fc99122b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-outer-4h.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+
+#define N 40
+#define M 128
+unsigned short a[M][N];
+unsigned int out[N];
+
+/* Outer-loop vectorization. */
+
+__attribute__ ((noinline))
+void
+foo (){
+  int i,j;
+  unsigned int diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < M; j++) {
+      a[j][i] = 4;
+    }
+    out[i]=5;
+  }
+}
+
+int main (void)
+{
+  int i, j;
+  check_vect ();
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < M; j++) {
+      if (a[j][i] != 4)
+        abort ();
+    }
+    if (out[i] != 5)
+      abort ();
+  }
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-1.c
new file mode 100644
index 000000000..e9d957014
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-1.c
@@ -0,0 +1,12 @@
+/* Test for pr30485.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_condition } */
+void
+foo (float a[32], float b[2][32])
+{
+  int i;
+  for (i = 0; i < 32; i++)
+    a[i] = (b[0][i] > b[1][i]) ? b[0][i] : b[1][i];
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-2.c
new file mode 100644
index 000000000..3971c920a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-2.c
@@ -0,0 +1,39 @@
+/* Test for pr30485.  */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N];
+
+  /* Condition in loop.  */
+  /* This loop is vectorized on platforms that support vect_condition.  */
+  for (i = 0; i < N; i++)
+  {
+    a[i] = (b[i] > 0 ? b[i] : 0);
+  }
+
+  for (i = 0; i < N; i++)
+  {
+    if (a[i] != b[i])
+	abort ();
+  }
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_condition } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-111.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-111.c
new file mode 100644
index 000000000..673346a67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-111.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N];
+
+  /* Condition in loop.  */
+  /* This loop is vectorized on platforms that support vect_condition.  */
+  for (i = 0; i < N; i++)
+  {
+    a[i] = (b[i] > 0 ? b[i] : 0);
+  }
+
+  for (i = 0; i < N; i++)
+  {
+    if (a[i] != b[i])
+	abort ();
+  }
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target powerpc*-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target i?86-*-* x86_64-*-* ia64-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-11.c
new file mode 100644
index 000000000..a35b7ade8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-11.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+float A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+float B[N] = {0,0,42,42,42,0,0,0,0,0,42,42,42,42,42,0};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] >= MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-12.c
new file mode 100644
index 000000000..485e88cf3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-12.c
@@ -0,0 +1,33 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+float A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+float B[N] = {0,0,0,42,42,0,0,0,0,0,42,42,42,42,42,0};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] > MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-13.c
new file mode 100644
index 000000000..58e6dc0a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-13.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+float A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+float B[N] = {42,42,42,0,0,42,42,42,42,42,0,0,0,0,0,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] <= MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-14.c
new file mode 100644
index 000000000..58e6dc0a9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-14.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+float A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+float B[N] = {42,42,42,0,0,42,42,42,42,42,0,0,0,0,0,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] <= MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-15.c
new file mode 100644
index 000000000..a15a0b127
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-trapping-math-vect-ifcvt-15.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+float A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+float B[N] = {42,42,0,0,0,42,42,42,42,42,0,0,0,0,0,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] < MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-tree-dom-vect-bug.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-tree-dom-vect-bug.c
new file mode 100644
index 000000000..d94aa3a64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-tree-dom-vect-bug.c
@@ -0,0 +1,30 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+long stack_vars_sorted[32];
+
+__attribute__ ((noinline)) int
+main1 (long n)
+{
+  long si;
+
+  for (si = 0; si < n; ++si)
+    stack_vars_sorted[si] = si;
+}
+
+int main ()
+{
+  long si;
+
+  check_vect ();
+  main1 (32);
+
+  for (si = 0; si < 32; ++si)
+    if (stack_vars_sorted[si] != si)
+      abort ();
+
+  return 0;
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-tree-pre-slp-29.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-tree-pre-slp-29.c
new file mode 100644
index 000000000..9c75e9dc5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-tree-pre-slp-29.c
@@ -0,0 +1,79 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned short in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 (unsigned short *in)
+{
+  int i;
+  unsigned short out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3])
+        abort ();
+    }
+
+  return 0;
+}
+
+int
+main2 (unsigned short * __restrict__ in, unsigned short * __restrict__ out)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  unsigned short out[N*8];
+
+  check_vect ();
+
+  main1 (&in2[5]);
+  main2 (&in2[3], &out[3]);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-pr29145.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-pr29145.c
new file mode 100644
index 000000000..954fe25df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-pr29145.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+__attribute__ ((noinline))
+void with_restrict(int * __restrict p)
+{
+  int i;
+  int *q = p - 2;
+
+  for (i = 0; i < 1000; ++i) {
+    p[i] = q[i];
+  }
+}
+
+__attribute__ ((noinline))
+void without_restrict(int * p)
+{
+  int i;
+  int *q = p - 2;
+
+  for (i = 0; i < 1000; ++i) {
+    p[i] = q[i];
+  }
+}
+
+int main(void)
+{
+  int i;
+  int a[1002];
+  int b[1002];
+
+  check_vect ();
+
+  for (i = 0; i < 1002; ++i) {
+    a[i] = b[i] = i;
+  }
+
+  with_restrict(a + 2);
+  without_restrict(b + 2);
+
+  for (i = 0; i < 1002; ++i) {
+    if (a[i] != b[i])
+      abort();
+  }
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 2 "vect"  { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-101.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-101.c
new file mode 100644
index 000000000..1830eb8aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-101.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+  int a[N];
+  int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,0};
+
+__attribute__ ((noinline))
+int main1 (int x, int y) {
+  int i;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  /* Not vectorizable: different unknown offset.  */
+  for (i = 0; i < N; i++)
+    {
+      *((int *)p + x + i) = a[i];
+      *((int *)p + y + i) = b[i];
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (p->a[i] != a[i] || p->b[i] != b[i])
+         abort();
+    }
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-102.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-102.c
new file mode 100644
index 000000000..e49633e02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-102.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+  int a[N];
+  int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,9};
+volatile int foo;
+
+__attribute__ ((noinline))
+int main1 (int x, int y) {
+  int i;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  for (i = 0; i < N; i++)
+    {
+       p->a[i] = a[i];
+       if (foo == 135)
+	 abort (); /* to avoid vectorization  */
+    }
+
+  /* Not vectorizable: distance 1.  */
+  for (i = 0; i < N - 1; i++)
+    {
+       *((int *)p + x + i + 1) = *((int *)p + x + i);
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (p->a[i] != 1) 
+         abort();
+    }
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  foo = 0;
+  return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-102a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-102a.c
new file mode 100644
index 000000000..da8afaa1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-102a.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+  int a[N];
+  int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,9};
+volatile int foo;
+
+__attribute__ ((noinline))
+int main1 (int x, int y) {
+  int i;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  for (i = 0; i < N; i++)
+    {
+       p->a[i] = a[i];
+       if (foo == 135)
+	 abort (); /* to avoid vectorization  */
+    }
+
+  /* Not vectorizable: distance 1.  */
+  for (i = 0; i < N - 1; i++)
+    {
+       p->a[x + i + 1] = p->a[x + i];
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (p->a[i] != 1)
+         abort();
+    }
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  foo = 0;
+  return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-37.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-37.c
new file mode 100644
index 000000000..bfa0802c0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-37.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+char x[N] __attribute__ ((__aligned__(16)));
+char cb[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+ 
+__attribute__ ((noinline))
+int main1 (char *y)
+{  
+  struct {
+    char *p;
+    char *q;
+  } s;
+  int i;
+
+  /* Not vectorized - can't antialias the pointer s.p from the array cb.  */
+  s.p = y;
+  for (i = 0; i < N; i++)
+    {
+      s.p[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.p[i] != cb[i])
+        abort ();
+    }
+
+  /* Not vectorized - can't antialias the pointer s.p from the pointer s.q.  */
+  s.q = cb;
+  for (i = 0; i < N; i++)
+    {
+      s.p[i] = s.q[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.p[i] != s.q[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (x);
+} 
+
+/* Currently the loops fail to vectorize due to aliasing problems.
+   If/when the aliasing problems are resolved, unalignment may
+   prevent vectorization on some targets.  */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence between" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-43.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-43.c
new file mode 100644
index 000000000..b64427f6d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-43.c
@@ -0,0 +1,79 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+
+__attribute__ ((noinline)) int
+main1 (float *pa)
+{
+  int i;
+  float pb[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float pc[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+ /* Not vectorizable: pa may alias pb and/or pc, since their addresses escape.  */
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+__attribute__ ((noinline)) int
+main2 (float * pa)
+{
+  int i;
+  float pb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float pc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  /* Vectorizable: pb and pc addresses do not escape.  */
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }   
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+        abort ();
+    }
+  
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+
+  main1 (a);
+  main2 (a);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-45.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-45.c
new file mode 100644
index 000000000..38328c1fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-45.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (const float *pa, const float *pb, const float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer accesses, with unknown alignment.
+   The loop bound is known and divisible by the vectorization factor.
+   Can't prove that the pointers don't alias.
+   vect-51.c is similar to this one with one difference:
+        the loop bound is unknown.
+   vect-44.c is similar to this one with one difference:
+        Aliasing is not a problem.  */
+
+__attribute__ ((noinline)) int
+main1 (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N];
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (a,b,c);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-49.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-49.c
new file mode 100644
index 000000000..6c3367541
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-49.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer read accesses, aligned pointer write access.
+   The loop bound is known and divisible by the vectorization factor.
+   Can't prove that the pointers don't alias.
+   vect-53.c is similar to this one with one difference:
+        the loop bound is unknown.
+   vect-48.c is similar to this one with one difference:
+        aliasing is not a problem.  */
+
+__attribute__ ((noinline)) int
+main1 (float *pb, float *pc)
+{
+  float pa[N] __attribute__ ((__aligned__(16)));
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float b[N+1] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (b,c);
+  main1 (&b[1],c);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-51.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-51.c
new file mode 100644
index 000000000..df463df6a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-51.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (const float *pa, const float *pb, const float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer accesses, with unknown alignment.
+   The loop bound is unknown.
+   Can't prove that the pointers don't alias.
+   vect-45.c is similar to this one with one difference:
+        the loop bound is known.
+   vect-50.c is similar to this one with one difference:
+        Aliasing is not a problem.  */
+
+__attribute__ ((noinline)) int
+main1 (int n, float *pa, float *pb, float *pc)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N];
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (N,a,b,c);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-53.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-53.c
new file mode 100644
index 000000000..02926b0f5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-53.c
@@ -0,0 +1,63 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (const float *pa, const float *pb, const float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer read accesses, aligned pointer write access.
+   The loop bound is unknown.
+   Can't prove that the pointers don't alias.
+   vect-49.c is similar to this one with one difference:
+        the loop bound is known.
+   vect-52.c is similar to this one with one difference:
+        aliasing is not a problem.  */
+
+__attribute__ ((noinline)) int
+main1 (int n, float *pb, float *pc)
+{
+  float pa[N] __attribute__ ((__aligned__(16)));
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N+1] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60};
+  float c[N+1] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+
+  check_vect ();
+
+  main1 (N,&b[1],c);
+  main1 (N,&b[1],&c[1]);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-57.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-57.c
new file mode 100644
index 000000000..8d630b89a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-57.c
@@ -0,0 +1,63 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i] != (pb[i+1] * pc[i+1]))
+        abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer read accesses with known alignment,
+   and an unaligned write access with unknown alignment.
+   The loop bound is known and divisible by the vectorization factor.
+   Can't prove that the pointers don't alias.
+   vect-61.c is similar to this one with one difference:
+        the loop bound is unknown.
+   vect-56.c is similar to this one with two differences:
+        aliasing is a problem, and the write access is aligned.  */
+
+__attribute__ ((noinline)) int
+main1 (float *pa)
+{
+  int i;
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < N/2; i++)
+    {
+      pa[i] = pb[i+1] * pc[i+1];
+    }
+
+  bar (pa, pb, pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+  main1 (a);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-61.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-61.c
new file mode 100644
index 000000000..61cfec2bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-61.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer read accesses with known alignment,
+   and an unaligned write access with unknown alignment.
+   The loop bound is iunknown.
+   Can't prove that the pointers don't alias.
+   vect-57.c is similar to this one with one difference:
+        the loop bound is known.
+   vect-60.c is similar to this one with two differences:
+        aliasing is not a problem, and the write access is unaligned.  */
+
+__attribute__ ((noinline)) int
+main1 (int n , float *pa)
+{
+  int i;
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < n/2; i++)
+    {
+      pa[i] = pb[i+1] * pc[i+1];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  int n=N;
+  float a[N] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+  main1 (n,a);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-79.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-79.c
new file mode 100644
index 000000000..f65371494
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-79.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float fa[N] __attribute__ ((__aligned__(16)));
+float fb[N+4] __attribute__ ((__aligned__(16))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
+float fc[N] __attribute__ ((__aligned__(16))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
+
+/* Like vect-80.c but the pointers are not annotated as restricted,
+   and therefore can't be antialiased.  */
+
+__attribute__ ((noinline)) int
+main1 (float *pa, float *pb, float *pc)
+{
+  int i;
+  float *q = pb + 4;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = q[i] * pc[i];
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != q[i] * pc[i])
+	abort();
+    }
+  
+  return 0;
+}
+
+
+int main (void)
+{ 
+  check_vect ();
+
+  main1 (fa, fb, fc);
+
+  return 0;	
+}
+
+/* Currently the loops fail to vectorize due to aliasing problems.
+  If/when the aliasing problems are resolved, unalignment may
+  prevent vectorization on some targets.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence between" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-depend-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-depend-1.c
new file mode 100644
index 000000000..329478d39
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-depend-1.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 17
+
+int ia[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48};
+int res[N] = {12,24,36,48,60,72,84,96,108,120,132,144,156,168,180,192,48};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  /* Not vectorizable due to data dependence: dependence distance 1.  */ 
+  for (i = 0; i < N - 1; i++)
+    {
+      ia[i+1] = ia[i] * 4;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N - 1; i++)
+    {
+      if (ia[i] != 0)
+        abort ();
+    } 
+
+  /* Vectorizable. Dependence distance -1.  */
+  for (i = 0; i < N - 1; i++)
+    {
+      ib[i] = ib[i+1] * 4;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N - 1; i++)
+    {
+      if (ib[i] != res[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "dependence distance >= VF or negative" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-dv-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-dv-2.c
new file mode 100644
index 000000000..1a49ef269
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/no-vfa-vect-dv-2.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 64
+#define MAX 42
+
+extern void abort(void); 
+
+int main ()
+{  
+  int A[N];
+  int B[N];
+  int C[N];
+  int D[N];
+  int E[N] = {0,1,2,0};
+
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      A[i] = i;
+      B[i] = i;
+      C[i] = i;
+      D[i] = i;
+    }
+
+  /* Vectorizable */
+  for (i = 0; i < N-20; i++)
+    {
+      A[i] = A[i+20];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N-20; i++)
+    {
+      if (A[i] != D[i+20])
+	abort ();
+    }
+
+  /* Vectorizable */
+  for (i = 0; i < 16; i++)
+    {
+      B[i] = B[i] + 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < 16; i++)
+    {
+      if (B[i] != C[i] + 5)
+	abort ();
+    }
+
+  /* Not vectorizable */
+  for (i = 0; i < 4; i++)
+    {
+      C[i+3] = C[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < 4; i++)
+    {
+      if (C[i] != E[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+
+/* The initialization induction loop (with aligned access) is also vectorized.  */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "accesses have the same alignment." 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/nodump-pr23073.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/nodump-pr23073.c
new file mode 100644
index 000000000..d13279919
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/nodump-pr23073.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+extern struct {
+  int o[2];
+  int p[2];
+} d;
+
+void C()
+{
+  int i;
+
+  for( i=0; i<2; ++i )
+    {
+      d.o[i] = 0;
+      d.p[i] = 0;
+    }
+  return;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr16105.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr16105.c
new file mode 100644
index 000000000..c59fe0573
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr16105.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+#define VECTOR_SIZE 512
+
+extern void check(const float * __restrict__ v);
+
+void square(const float * __restrict__ a,
+	    float * __restrict__ out)
+{
+    unsigned int i;
+    for (i = 0; i < VECTOR_SIZE; i++) {
+	float ai = a[i];
+	float a2 = ai * ai;
+	out[i] = a2; 
+    }
+    check(out);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18308.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18308.c
new file mode 100644
index 000000000..02aaed2f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18308.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O -ftree-vectorize -funroll-loops" } */
+void foo();
+
+void bar(int j)
+{
+  int i, k=0;
+  for (i = 0; i < 2; ++i)
+    if (j) k = 2;
+
+  if (k) foo();
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18400.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18400.c
new file mode 100644
index 000000000..6bc3b5c83
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18400.c
@@ -0,0 +1,38 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+
+int b[N] = {0,3,6,9,12,15,18,21};
+int a[N];
+ 
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != b[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18425.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18425.c
new file mode 100644
index 000000000..08f7b65cc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18425.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* ??? Using "long" isn't quite right; we're testing vectors of pointers here.
+   But since no extant target supports sizeof(long) != sizeof(void*)...  */
+/* { dg-require-effective-target vect_long } */
+
+char **      _M_allocate();
+void
+_M_fill_insert(unsigned int __n)
+{
+   char **__new_start = _M_allocate();
+   char *__tmp = 0;
+   for (; __n > 0; --__n, ++__new_start)
+     *__new_start = __tmp;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18536.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18536.c
new file mode 100644
index 000000000..4bf41bec4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr18536.c
@@ -0,0 +1,35 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int main1 (short a, short *b)
+{
+  while (++a < 4) *b++ = 2;
+
+  return 0;
+}
+
+int main (void)
+{
+  int i = 0;
+  short x[N];
+
+  check_vect ();
+
+  main1 (0, x);
+
+  /* check results:  */
+  while (++i < 4)
+    {
+      if (x[i-1] != 2)
+        abort ();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr20122.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr20122.c
new file mode 100644
index 000000000..05948c7fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr20122.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+short Kernshort[24] __attribute__ ((__aligned__(16)));
+static void VecBug(short Kernel[8][24]) __attribute__((noinline));
+static void VecBug2(short Kernel[8][24]) __attribute__((noinline));
+
+/* Kernel may alias Kernshort - a global array.
+   Use versioning for aliasing.  */
+static void VecBug(short Kernel[8][24])
+{
+  int k,i;
+    for (k = 0; k<8; k++)
+        for (i = 0; i<24; i++)
+            Kernshort[i] = Kernel[k][i];
+}
+
+/* Vectorizable: Kernshort2 is local.  */
+static void VecBug2(short Kernel[8][24])
+{
+  int k,i;
+  short Kernshort2[24] __attribute__ ((__aligned__(16)));
+    for (k = 0; k<8; k++)
+        for (i = 0; i<24; i++)
+            Kernshort2[i] = Kernel[k][i];
+
+    for (k = 0; k<8; k++)
+        for (i = 0; i<24; i++)
+            if (Kernshort2[i] != Kernel[k][i])
+                abort ();
+}
+
+int main (int argc, char **argv)
+{
+    check_vect ();
+
+    short Kernel[8][24] __attribute__ ((__aligned__(16)));
+    int k,i;
+
+    for (k = 0; k<8; k++)
+        for (i = 0; i<24; i++)
+            Kernel[k][i] = 0;
+
+    VecBug(Kernel);
+    VecBug2(Kernel);
+
+    return 0;
+}
+
+/* The loops in VecBug and VecBug2 require versioning for alignment.
+   The loop in main is aligned.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr21591.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr21591.c
new file mode 100644
index 000000000..8c3bef42a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr21591.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+struct a
+{
+  int length;
+  int a1[256];
+};
+
+struct a *malloc1(__SIZE_TYPE__) __attribute__((malloc));
+void free(void*);
+
+void f(void)
+{
+   struct a *a = malloc1(sizeof(struct a));
+   struct a *b = malloc1(sizeof(struct a));
+   struct a *c = malloc1(sizeof(struct a));
+   int i;
+
+   for (i = 0; i < 256; i++) 
+   {
+      b->a1[i] = i;
+      c->a1[i] = i;
+   }
+   for (i = 0; i < 256; i++) 
+   {
+      a->a1[i] = b->a1[i] + c->a1[i];
+   }
+   free(a);
+   free(b);
+   free(c);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr21969.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr21969.c
new file mode 100644
index 000000000..388fc3129
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr21969.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+typedef float vsf __attribute__((vector_size(2048)));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr22480.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr22480.c
new file mode 100644
index 000000000..a7e238f22
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr22480.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_shift } */
+
+void
+test_1 (void)
+{
+  static unsigned int bm[16];
+  int j;
+  for (j = 0; j < 16; j++)
+    bm[j] <<= 8;
+}
+
+void
+test_2 (int a)
+{
+  static unsigned int bm[16];
+  int j;
+  for (j = 0; j < 16; j++)
+    bm[j] <<= a;
+}
+
+void
+test_3 (void)
+{
+ static unsigned bm[16];
+ int am[16];
+ int j;
+ for (j = 0; j < 16;j++)
+   bm[j] <<= am[j];
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr22506.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr22506.c
new file mode 100644
index 000000000..5a2d74995
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr22506.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+float x[3];
+
+void foo()
+{
+    int i;
+
+    for (i=0; i<5; ++i) x[i]=0;
+    for (i=0; i<4; ++i) ;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23816-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23816-1.c
new file mode 100644
index 000000000..9c76d2e9d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23816-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_condition } */
+
+void
+foo (float a[32], float b[2][32])
+{
+  int i;
+  for (i = 0; i < 32; i++)
+    a[i] = (b[0][i] > b[1][i]) ? b[0][i] : b[1][i];
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23816-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23816-2.c
new file mode 100644
index 000000000..408eb4972
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23816-2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_condition } */
+
+void
+foo (double a[32], double b[2][32])
+{
+  int i;
+  for (i = 0; i < 32; i++)
+    a[i] = (b[0][i] > b[1][i]) ? b[0][i] : b[1][i];
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23831.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23831.c
new file mode 100644
index 000000000..dfa21ce0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr23831.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+void foo (void)
+{
+  static unsigned int bm[16];
+  int j;
+  for (j = 0; j < 16; j++)
+    bm[j] = bm[j] * 8;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24049.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24049.c
new file mode 100644
index 000000000..ee03fe3ea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24049.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-vectorize --param ggc-min-heapsize=0 --param ggc-min-expand=0" } */
+
+int DES_CBCUpdate(unsigned char * output, int len)
+{
+  int work[2];
+  unsigned int i;
+  for(i = 0;i < len/8;i++)
+    unscrunch (&output[8*i], work);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24059.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24059.c
new file mode 100644
index 000000000..0849d15c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24059.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_condition } */
+
+struct pred_data
+{
+  unsigned char codes[((int) 100)];
+};
+
+void compute_predicate_codes (char *codes, struct pred_data *p)
+{
+  int i;
+  for (i = 0; i < ((int) 100); i++)
+    codes[i] = p->codes[i] ? 2 : 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24300.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24300.c
new file mode 100644
index 000000000..7a79e96c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr24300.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+
+static int *** foo (int);
+
+void
+bar ()
+{
+  int ***p = foo (2);
+}
+
+extern int *nd;
+extern int ***tc;
+extern int *ap;
+extern int *as;
+extern float ss;
+
+static int ***
+foo (int Fc)
+{
+  int i, j, s, p, n, t;
+
+  n = 0;
+  for (s = 0; s < 4; s++)
+    n += nd[s];
+
+  for (i = 0; i < n; i++)
+    {
+      p = ap[i];
+      s = as[i];
+      for (j = 0; j < Fc; j++)
+	tc[p][s][j] = i * ss + j;
+    }
+
+  return (tc);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25371.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25371.c
new file mode 100644
index 000000000..ad962f47c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25371.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+
+void slow_close(int n)
+{
+  int i;
+  double *mm;
+
+  for (i=0;i<2*n;i++)
+    for (i=0;i<2*n;i++)
+      *(mm+i*2*n+i) = 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25413.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25413.c
new file mode 100644
index 000000000..1cb33e3b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25413.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+
+struct
+{
+  char c;
+  double d[N];
+} a;
+
+__attribute__ ((noinline))
+int main1()
+{
+  int i;
+  for ( i=0; i<N; ++i )
+    a.d[i]=1;
+  return 0;
+}
+
+int main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  main1 ();
+  for (i=0; i<N; i++)
+    if (a.d[i] != 1)
+      abort ();
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vector_alignment_reachable_for_64bit } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vector_alignment_reachable_for_64bit } } } } */
+/* { dg-final { scan-tree-dump-times "vector alignment may not be reachable" 1 "vect" { target { ! vector_alignment_reachable_for_64bit } } } } */
+/* { dg-final { scan-tree-dump-times "not vectorized: unsupported unaligned store" 1 "vect" { target { ! vector_alignment_reachable_for_64bit } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25413a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25413a.c
new file mode 100644
index 000000000..b9bef5f5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr25413a.c
@@ -0,0 +1,129 @@
+/* { dg-require-effective-target vect_double } */
+
+#include "tree-vect.h"
+
+#define N 8
+
+typedef __SIZE_TYPE__ size_t;
+
+extern void *malloc (size_t __size) __attribute__ ((__nothrow__,
+						    __malloc__));
+
+typedef double num_t;
+static const num_t num__infty = ((num_t)1.0)/((num_t)0.0);
+
+struct oct_tt;
+typedef struct oct_tt oct_t;
+
+typedef unsigned int var_t;
+typedef enum {
+  OCT_EMPTY = 0,
+  OCT_NORMAL = 1,
+  OCT_CLOSED = 2
+} oct_state;
+
+struct oct_tt {
+  var_t n;
+
+  int ref;
+
+  oct_state state;
+  struct oct_tt* closed;
+
+  num_t* c;
+};
+
+void* octfapg_mm_malloc (size_t t);
+oct_t* octfapg_alloc (var_t n);
+oct_t* octfapg_full_copy (oct_t* m);
+
+struct mmalloc_tt;
+typedef struct mmalloc_tt mmalloc_t;
+
+struct mmalloc_tt
+{
+  int id;
+
+  int nb_alloc;
+  int nb_realloc;
+  int nb_free;
+
+  size_t rem;
+  size_t max;
+  size_t tot;
+
+};
+
+typedef struct
+{
+  size_t size;
+
+  mmalloc_t* mm;
+  int id;
+
+  double dummy;
+
+} mmheader_t;
+
+void*
+octfapg_mm_malloc (size_t t)
+{
+  char* m = (char*)malloc(t+sizeof(mmheader_t));
+  return m+sizeof(mmheader_t);
+}
+
+oct_t* octfapg_empty (var_t n);
+
+oct_t*
+octfapg_empty (const var_t n)
+{
+  oct_t* m;
+  /*octfapg_timing_enter("oct_empty",3);*/
+  m = ((oct_t*) octfapg_mm_malloc (sizeof(oct_t)));
+  m->n = n;
+  m->ref = 1;
+  m->state = OCT_EMPTY;
+  m->closed = (oct_t*)((void *)0);
+  m->c = (num_t*)((void *)0);
+  /*octfapg_timing_exit("oct_empty",3);*/
+  return m;
+}
+
+oct_t*
+octfapg_alloc (const var_t n)
+{
+  size_t nn = (2*(size_t)(n)*((size_t)(n)+1));
+  oct_t* m;
+  m = octfapg_empty(n);
+  m->c = ((num_t*) octfapg_mm_malloc (sizeof(num_t)*(nn)));
+  ;
+  m->state = OCT_NORMAL;
+  m->closed = (oct_t*)((void *)0);
+  return m;
+}
+
+oct_t*
+octfapg_universe (const var_t n)
+{
+  oct_t* m;
+  size_t i, nn = (2*(size_t)(n)*((size_t)(n)+1));
+  m = octfapg_alloc(n);
+  for (i=0;i<nn;i++) *(m->c+i) = num__infty;
+  for (i=0;i<2*n;i++) *(m->c+((size_t)(i)+(((size_t)(i)+1)*((size_t)(i)+1))/2)) = (num_t)(0);
+  m->state = OCT_CLOSED;
+  return m;
+}
+
+int main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  oct_t *p = octfapg_universe(10);
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vector alignment may not be reachable" 1 "vect" { target { ! vector_alignment_reachable  } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { ! vector_alignment_reachable } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr27151.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr27151.c
new file mode 100644
index 000000000..81f89b1a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr27151.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+/* We were creating a float vector for the vis_type == 1
+   test, which we ICEd on.  Now we simply punt here.  */
+
+float vs_data[75];
+void vis_clear_data ()
+{
+  int vis_type, i;
+  for (i = 0; i < 75; i++)
+    {
+      vs_data[i] = (vis_type == 1);
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr28952.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr28952.c
new file mode 100644
index 000000000..7305e607c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr28952.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+
+/* We were  ICE because we wanted to check the type of the
+   elements of a conditional before we knew it was a conditional.  */
+
+struct player_spaceship
+{
+  _Bool structure[32];
+};
+struct player
+{
+  struct player_spaceship spaceship;
+};
+struct packet_spaceship_info
+{
+  char structure[32 + 1];
+};
+send_spaceship_info (void)
+{
+  int j;
+  struct player *pplayer;
+  struct packet_spaceship_info info;
+  struct player_spaceship *ship = &pplayer->spaceship;
+  for (j = 0; j < 32; j++)
+  {
+    info.structure[j] = ship->structure[j] ? '1' : '0';
+  }
+  lsend_packet_spaceship_info (&info);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30771.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30771.c
new file mode 100644
index 000000000..e9f4bd2ab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30771.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+int a[128];
+
+int
+main()
+{
+  short i;
+
+  for (i=0; i<64; i++){
+    a[i] = (int)i;
+  }
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30784.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30784.c
new file mode 100644
index 000000000..3df9afe3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30784.c
@@ -0,0 +1,30 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+long stack_vars_sorted[32];
+
+int
+main1 (long n)
+{
+  long si;
+
+  for (si = 0; si < n; ++si)
+    stack_vars_sorted[si] = si;
+}
+
+int main ()
+{
+  long si;
+
+  check_vect ();
+  main1 (32);
+
+  for (si = 0; si < 32; ++si)
+    if (stack_vars_sorted[si] != si)
+      abort ();
+
+  return 0;
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30795.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30795.c
new file mode 100644
index 000000000..53dc9fa51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30795.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+char bigDone[260];
+int runningOrder[260];
+
+int
+main()
+{
+  int i;
+  for (i = 0; i <= 255; i++) {
+      bigDone [i] = ((char)0);
+      runningOrder[i] = i;
+  }
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30843.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30843.c
new file mode 100644
index 000000000..616b618f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30843.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_long } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+void dacP98FillRGBMap (unsigned char *pBuffer)
+{
+    unsigned long dw, dw1;
+    unsigned long *pdw = (unsigned long *)(pBuffer);
+
+    for( dw = 256, dw1 = 0; dw; dw--, dw1 += 0x01010101) 
+    {
+       *pdw++ = dw1;
+       *pdw++ = dw1;
+       *pdw++ = dw1;
+       *pdw++ = dw1;
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30858.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30858.c
new file mode 100644
index 000000000..0af2f8e9a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr30858.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+int
+foo (int ko)
+{
+ int j,i;
+  for (j = 0; j < ko; j++)
+   i += (i > 10) ? -5 : 7;
+ return i;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Unknown def-use cycle pattern." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31041.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31041.c
new file mode 100644
index 000000000..361b358b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31041.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+struct UNewTrie
+{
+  int index[(0x110000 >> 1)];
+};
+typedef struct UNewTrie UNewTrie;
+utrie_open_3_4 ()
+{
+  UNewTrie *trie;
+  int i, j;
+    {
+      i = 0;
+      do
+        {
+          trie->index[i++] = j;
+          j += 1;
+        }
+      while (i < 5);
+    }
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31343.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31343.c
new file mode 100644
index 000000000..856422221
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31343.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+
+#define N 16
+ 
+struct
+{
+  unsigned int x;
+  unsigned int y;
+} pS [100];
+
+void
+main1 ()
+{
+  int i, j;
+  unsigned int ub[N] =
+    { 1, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45 };
+  unsigned int uc[N] =
+    { 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+  unsigned int udiffx, udiffy;
+
+  for (i = 0; i < N; i++)
+    {
+      pS[i].x = 0;
+      pS[i].y = 0;
+      for (j = 0; j < N; j++)
+      {
+        udiffx = (ub[j] - uc[j]);
+        udiffy = (ub[j] - uc[j]);
+        pS[i].x = udiffx;
+        pS[i].y = udiffy;
+      }
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31699.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31699.c
new file mode 100644
index 000000000..cbc596d46
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr31699.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+float x[256];
+
+void foo(void)
+{
+ double *z = malloc (sizeof(double) * 256);
+
+ int i;
+ for (i=0; i<256; ++i)
+   z[i] = x[i] + 1.0f;
+}
+
+
+int main()
+{
+ int i;
+
+ check_vect ();
+
+ for (i = 0; i < 256; i++)
+   x[i] = (float) i;
+
+ foo();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_intfloat_cvt } } } */
+/* { dg-final { scan-tree-dump-times "vector alignment may not be reachable" 1 "vect" { target { ! vector_alignment_reachable } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { ! vector_alignment_reachable } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32216.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32216.c
new file mode 100644
index 000000000..cf2744125
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32216.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_floatint_cvt } */
+
+unsigned int wlookup2[203];
+
+SetSoundVariables (int x)
+{
+  for (x = 1; x < 32; x++)
+  {
+    wlookup2[x] = (double) 16 / x;
+  }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32224.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32224.c
new file mode 100644
index 000000000..6f3a36b4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32224.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+typedef unsigned long int *mp_ptr;
+typedef const unsigned long int *mp_srcptr;
+gmpz_export (void *data)
+{
+  mp_srcptr zp;
+  int count, i;
+  mp_ptr __dst = ((mp_ptr) data);
+  mp_srcptr __src = (zp);
+
+  for (i = 0; i < count; i++)
+  {
+    __asm__ ("checkme": "=r" (*__dst):"0" (*(__src)));
+    __src++;
+  }
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32230.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32230.c
new file mode 100644
index 000000000..ed1e7b146
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32230.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+
+typedef struct filter_buffer filter_buffer_t;
+struct filter_buffer
+{
+  char buf[1];
+};
+typedef struct sbuf_header sbuf_header_t;
+struct sbuf_header
+{
+  char buf[1];
+}
+const_f (filter_buffer_t *buf)
+{
+  float val;
+  int i;
+
+  for (i = 0; i < 10; i++)
+    ((float*) (&((sbuf_header_t *) ((buf) == (filter_buffer_t *)&(buf)->buf[0]))->buf[0]))[i] = val;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32366.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32366.c
new file mode 100644
index 000000000..e83d579e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32366.c
@@ -0,0 +1,14 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+stream_test (void)
+{
+  static float input[20];
+  int k;
+  for (k = 0; k < 20; k++)
+    input[k] = k * 1.0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32421.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32421.c
new file mode 100644
index 000000000..68d51bd74
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr32421.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+
+
+int f(int **__restrict a, int ** __restrict b)
+{
+  int i;
+  for(i= 0;i<32;i++)
+    a[i] = b[i] + 1;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33369.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33369.c
new file mode 100644
index 000000000..1aaf4e366
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33369.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+typedef struct tagPOINT
+{
+  int x;
+  int y;
+} POINT;
+
+void
+f (POINT * ptBuf)
+{
+  int i;
+  for (i = 0; i < 4; i++)
+    {
+      ptBuf[i].x = ((ptBuf[i].x) << 4);
+      ptBuf[i].y = ((ptBuf[i].y) << 4);
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33373.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33373.c
new file mode 100644
index 000000000..b11cfb4eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33373.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+void DOSMEM_FillIsrTable(int*isr) {
+    int i;
+
+    for (i=0; i<256; i++)
+        isr[i]=(((short)((i*4) & 0xFFFF)) | (0xf000 & 0xFFFF) << 16);
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33373b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33373b.c
new file mode 100644
index 000000000..c294a385c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33373b.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+void f (unsigned int *d, unsigned int *s, int w)
+{
+  int i;
+  for (i = 0; i < w; ++i)
+    d [i] = s [i] * (unsigned short) (~d [i] >> 24);
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33597.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33597.c
new file mode 100644
index 000000000..7fdcde07f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33597.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+
+void
+rgb15to24_C (const uint8_t * src, uint8_t * dst, long src_size)
+{
+  const uint16_t *end;
+  const uint16_t *s = (uint16_t *)src;
+  uint8_t *d = (uint8_t *)dst;
+
+  end = s + src_size/2;
+  while (s < end)
+    {
+      uint16_t bgr = *s++;
+
+      *d++ = (bgr&0x1F)<<3;
+      *d++ = (bgr&0x3E0)>>2;
+      *d++ = (bgr&0x7C00)>>7;
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33804.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33804.c
new file mode 100644
index 000000000..3ae7df0a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33804.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+void f(unsigned char *s, unsigned char *d, int n) {
+    int i;
+    for (i = 0; i < n; i += 4) {
+        d[i + 0] += s[i + 0];
+        d[i + 1] += s[i + 1];
+        d[i + 2] += s[i + 2];
+        d[i + 3] += s[i + 3];
+    }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" {xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33833.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33833.c
new file mode 100644
index 000000000..ebdfcb1f8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33833.c
@@ -0,0 +1,35 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+/* { dg-do compile } */
+
+#define signed
+typedef unsigned __PTRDIFF_TYPE__ uintptr_t;
+#undef signed
+
+struct list_head
+{
+  struct list_head *prev;
+};
+struct prio_array
+{
+  struct list_head queue[100];
+};
+struct rq
+{
+  struct prio_array *active, arrays[2];
+} per_cpu__runqueues;
+
+void sched_init (uintptr_t __ptr)
+{
+  int j, k;
+  struct prio_array *array;
+  struct rq *rq;
+  rq = (&(*( { (typeof (&per_cpu__runqueues)) (__ptr); } )));
+  for (j = 0; j < 2; j++)
+  {
+    array = rq->arrays + j;
+    for (k = 0; k < 100; k++)
+        (array->queue + k)->prev = array->queue;
+  }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33846.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33846.c
new file mode 100644
index 000000000..3f421c9b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33846.c
@@ -0,0 +1,24 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_shift } */
+
+int clamp_val (int i)
+{
+  return ~i >> 31;
+}
+
+typedef __PTRDIFF_TYPE__ intptr_t;
+
+void _mix_some_samples (intptr_t buf, int *mix_buffer, int mix_size)
+{
+  int i;
+  signed int *p = mix_buffer;
+  for (i = mix_size ; i > 0; i--)
+  {
+    *((short *) buf) = clamp_val ((*p) + 0x800000);
+    buf += 2;
+    p++;
+  }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33866.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33866.c
new file mode 100644
index 000000000..9beaeff5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33866.c
@@ -0,0 +1,32 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_long } */
+
+typedef struct
+{
+  long *coords;
+}
+fill_iter_info;
+
+extern H5Diterate (fill_iter_info *);
+
+void test_select_fill_hyper_simple (long *offset)
+{
+  long start[2];
+  int num_points;
+  long points[16][2];
+  fill_iter_info iter_info;
+  int i, j;
+  iter_info.coords = (long *) points;
+  for (i = 0, num_points = 0; j < (int) start[1]; j++, num_points++)
+  {
+    points[num_points][0] = i + start[0];
+    points[num_points][1] = j + start[1];
+  }
+  H5Diterate (&iter_info);
+}
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33953.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33953.c
new file mode 100644
index 000000000..f501a452e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr33953.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+typedef unsigned int UINT32;
+
+void blockmove_NtoN_blend_noremap32 (const UINT32 *srcdata, int srcwidth,
+                                     int srcheight, int srcmodulo,
+                                     UINT32 *dstdata, int dstmodulo, 
+                                     int srcshift) 
+{
+ UINT32 *end;
+
+ while (srcheight) 
+   {
+     while (dstdata <= end - 8) 
+       {
+         dstdata[0] |= srcdata[0] << srcshift;
+         dstdata[1] |= srcdata[1] << srcshift;
+         dstdata[2] |= srcdata[2] << srcshift;
+         dstdata[3] |= srcdata[3] << srcshift;
+         dstdata[4] |= srcdata[4] << srcshift;
+         dstdata[5] |= srcdata[5] << srcshift;
+         dstdata[6] |= srcdata[6] << srcshift;
+         dstdata[7] |= srcdata[7] << srcshift;
+         dstdata += 8;
+         srcdata += 8;
+       }
+   }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" {xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34005.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34005.c
new file mode 100644
index 000000000..813f950b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34005.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/34005 */
+/* { dg-do compile } */
+
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+
+void XdmcpUnwrap (unsigned char *output, int k)
+{
+  int i;
+  unsigned char blocks[2][8];
+  k = (k == 0) ? 1 : 0;
+  for (i = 0; i < 32; i++)
+    output[i] = blocks[k][i];
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34407.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34407.c
new file mode 100644
index 000000000..3da2ed7b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34407.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+extern int ReadBlobByte (void);
+
+void ReadRLEImage (unsigned char *p)
+{
+  unsigned char background_color[4] = { 0, 1, 2, 3 };
+  long j;
+
+  unsigned long number_planes = ReadBlobByte();
+
+  for (j = 0; j < (long) number_planes; j++)
+    *p++ = background_color[j];
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34591.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34591.c
new file mode 100644
index 000000000..1f02544c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr34591.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+
+int av_resample(int filter_length, short *src, short *filter)
+{
+    int i;
+    int val=0;
+    for(i=0; i<filter_length; i++)
+      val += src[ i ] * filter[i];
+    return val;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr35821-altivec.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr35821-altivec.c
new file mode 100644
index 000000000..79fa926ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr35821-altivec.c
@@ -0,0 +1,24 @@
+/* { dg-do compile { target { powerpc_altivec_ok } } } */
+
+#include "altivec.h"
+
+void
+foo (float f_gain1, int n_tail, float * __restrict__ f_in_hptr,
+     float * __restrict__ f_out_hptr)
+{
+  int i;
+  vector float *v_f_in_hptr, *v_f_out_hptr;
+
+  f_in_hptr = ( float* )v_f_in_hptr;
+  f_out_hptr = ( float* )v_f_out_hptr;
+
+  for( i = 0 ; i < n_tail ; i++ ) {
+   f_out_hptr[0] = f_in_hptr[0] * f_gain1;
+   f_in_hptr++;
+   f_out_hptr++;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr35821-spu.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr35821-spu.c
new file mode 100644
index 000000000..4cc255f07
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr35821-spu.c
@@ -0,0 +1,22 @@
+/* { dg-do compile { target { spu-*-* } } } */
+
+void
+foo (float f_gain1, int n_tail, float * __restrict__ f_in_hptr,
+     float * __restrict__ f_out_hptr)
+{
+  int i;
+  __attribute__((__spu_vector__)) float *v_f_in_hptr, *v_f_out_hptr;
+
+  f_in_hptr = ( float* )v_f_in_hptr;
+  f_out_hptr = ( float* )v_f_out_hptr;
+
+  for( i = 0 ; i < n_tail ; i++ ) {
+   f_out_hptr[0] = f_in_hptr[0] * f_gain1;
+   f_in_hptr++;
+   f_out_hptr++;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36228.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36228.c
new file mode 100644
index 000000000..73933754c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36228.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fdump-tree-vect-details" } */
+
+#define COLS         8
+#define ROWS         8
+
+int
+t_run_test(void);
+
+int
+t_run_test()
+{
+     int k_1,i_1, j_1;
+     static signed char f_1[ROWS][COLS] ;
+     static long F_1[ROWS][COLS] ;
+     long cosMatrixA[ROWS][COLS] ;
+
+     for( k_1 = 0 ; k_1 < COLS ; k_1++ )
+        {
+            for( i_1 = 0 ; i_1 < ROWS ; i_1++ )
+            {
+                for( j_1 = 0 ; j_1 < COLS ; j_1++ )
+                    F_1[i_1][j_1] += f_1[i_1][k_1] * cosMatrixA[k_1][j_1] ;
+            }
+        }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "versioning for alias required" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36493.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36493.c
new file mode 100644
index 000000000..0a3d2029c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36493.c
@@ -0,0 +1,23 @@
+/* { dg-require-effective-target vect_long } */
+
+#include "tree-vect.h"
+
+int
+main (void)
+{
+  int i;
+  long x[12] __attribute__((aligned(16)));
+
+  x[0] = 1;
+  for (i = 0; i < 12; i++)
+    x[i] = i;
+
+  if (x[0] != 0)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36630.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36630.c
new file mode 100644
index 000000000..2253f7574
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr36630.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+void
+foo (unsigned char *x, short y)
+{
+  short i;
+
+  i = 2;
+  while (i < y)
+    {
+      x[i - 1] = x[i];
+      i = i + 1;
+    }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37385.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37385.c
new file mode 100644
index 000000000..d6a477e63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37385.c
@@ -0,0 +1,20 @@
+/* Testcase by Martin Michlmayr <tbm@cyrius.com> */
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+typedef int int_t;
+typedef void (*fun_t) (int);
+fun_t fun_tab[400] __attribute__ ((__aligned__(16)));
+
+void foo (int_t a);
+
+void
+bar ()
+{
+  int i;
+
+  for (i = 0; i < 400; i++)
+      fun_tab[i] = foo;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37474.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37474.c
new file mode 100644
index 000000000..b6d01c269
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37474.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+
+#define M00 100
+#define M10 216
+#define M01 1322
+#define M11 13
+#define M02 74
+#define M12 191
+
+#define N 16
+
+void foo (unsigned int *__restrict__ pInput, unsigned int *__restrict__ pOutput)
+{
+  unsigned int i, a, b, c, d, e, f;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+       d = *pInput++;
+       e = *pInput++;
+       f = *pInput++;
+
+       a = a + d;
+       b = b + e;
+       c = c + f;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c;
+       *pOutput++ = M10 * a + M11 * b + M12 * c;
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37482.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37482.c
new file mode 100644
index 000000000..0b3bed33a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37482.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+void SexiALI_Convert(void *vdest, void *vsrc, unsigned int frames)
+{
+ unsigned int x;
+ short *src = vsrc;
+ unsigned char *dest = vdest;
+ for(x=0;x<256;x++)
+ {
+  int tmp;
+  tmp = *src;
+  src++;
+  tmp += *src;
+  src++;
+  *dest++ = tmp;
+  *dest++ = tmp;
+ }
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37539.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37539.c
new file mode 100644
index 000000000..1d569a998
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37539.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+__attribute__ ((noinline)) void
+ayuv2yuyv_ref (int *d, int *src, int n)
+{
+  char *dest = (char *)d;
+  int i;
+
+  for(i=0;i<n/2;i++){
+    dest[i*4 + 0] = (src[i*2 + 0])>>16;
+    dest[i*4 + 1] = (src[i*2 + 1])>>8;
+    dest[i*4 + 2] = (src[i*2 + 0])>>16;
+    dest[i*4 + 3] = (src[i*2 + 0])>>0;
+  }
+
+  /* Check results.  */
+  for(i=0;i<n/2;i++){
+   if (dest[i*4 + 0] != (src[i*2 + 0])>>16
+       || dest[i*4 + 1] != (src[i*2 + 1])>>8
+       || dest[i*4 + 2] != (src[i*2 + 0])>>16
+       || dest[i*4 + 3] != (src[i*2 + 0])>>0) 
+     abort();
+  }
+}
+
+int main ()
+{
+  int d[256], src[128], i;
+ 
+  for (i = 0; i < 128; i++)
+    src[i] = i; 
+  
+  ayuv2yuyv_ref(d, src, 128);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_strided_wide } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37730.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37730.c
new file mode 100644
index 000000000..876f5499e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr37730.c
@@ -0,0 +1,16 @@
+/* PR middle-end/37730 */
+/* { dg-do compile } */
+
+void
+add_opush (void)
+{
+  unsigned char formats[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
+  void *dtds[sizeof (formats)];
+  unsigned int i;
+  unsigned char dtd = 0x08;
+  for (i = 0; i < sizeof (formats); i++)
+    dtds[i] = &dtd;
+  sdp_seq_alloc (dtds);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr38529.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr38529.c
new file mode 100644
index 000000000..496aa43f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr38529.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+float a[4];
+
+void foo()
+{
+  int i, j;
+
+  for (i = 0; i < 4; ++i)
+    for (j = 0; j < 17; ++j)
+      a[i] = 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr39529.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr39529.c
new file mode 100644
index 000000000..4853c1350
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr39529.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+
+void
+foo (void)
+{
+  char a[1024];
+  char *p = &a[0];
+  char *p2;
+
+  p2 = p + 1024;
+  do
+    {
+      p += 2;
+      *(p-2) = 1;
+      *(p-1) = 1;
+    } while (p < p2);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40074.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40074.c
new file mode 100644
index 000000000..6459f1b55
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40074.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+} s;
+
+
+s arr[N] = {{7,0,1,5}, {7,2,3,5}, {7,4,5,5}, {7,6,7,5}, {7,8,9,5}, {7,10,11,5}, {7,12,13,5}, {7,14,15,5}, {7,16,17,5}, {7,18,19,5}, {7,20,21,5}, {7,22,23,5}, {7,24,25,5}, {7,26,27,5}, {7,28,29,5}, {7,30,31,5}};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s *p = arr, *q = arr + 1;
+  int res[N];
+  int i;
+
+  for (i = 0; i < N-1; i++)
+    {
+      res[i] = p->b + p->d + q->b;
+      p++;
+      q++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N-1; i++)
+    {
+      if (res[i] != arr[i].b + arr[i].d + arr[i+1].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40238.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40238.c
new file mode 100644
index 000000000..91cf09824
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40238.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+
+extern int xdo_rb_ctr_row( int *pos_code);
+
+int xgp_ahd_interpolate (int tile)
+{
+ int p[4];
+
+ switch (tile) {
+ default:
+ case 0:
+ case 1:
+  p[0] = 0; p[1] = 1; p[2] = 2; p[3] = 3;
+  break;
+ case 2:
+ case 3:
+  p[0] = 1; p[1] = 0; p[2] = 3; p[3] = 2;
+  break;
+ case 4:
+ case 5:
+  p[0] = 3; p[1] = 2; p[2] = 1; p[3] = 0;
+  break;
+ case 6:
+ case 7:
+  p[0] = 2; p[1] = 3; p[2] = 0; p[3] = 1;
+  break;
+ }
+
+ xdo_rb_ctr_row(p);
+ xdo_rb_ctr_row(p);
+ return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40254.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40254.c
new file mode 100644
index 000000000..b890a4493
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40254.c
@@ -0,0 +1,39 @@
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+struct s
+{
+  int *x;
+  int x1;
+  int x2;
+  int x3;
+  int *y;
+};
+
+struct s arr[64] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+__attribute__ ((noinline)) void
+foo (int i, int *in_x, int *in_y)
+{
+  arr[i].x = in_x;
+  arr[i].y = in_y;
+}
+
+int
+main (void)
+{
+  int a, b;
+
+  check_vect ();
+
+  foo (5, &a, &b);
+
+  if (arr[5].x != &a || arr[5].y != &b)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40542.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40542.c
new file mode 100644
index 000000000..0a827724d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr40542.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+
+void
+volarr_cpy(char *d, volatile char *s)
+{
+  int i;
+  
+  for (i = 0; i < 16; i++)
+    d[i] = s[i];
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr41956.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr41956.c
new file mode 100644
index 000000000..cbd046527
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr41956.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+void K (int *gpwgts, int *badminpwgt, int *badmaxpwgt)
+{
+  int i;
+  for (i = 0; i < 10; i += 2) {
+    badminpwgt[i] = badminpwgt[i+1] = gpwgts[i]+gpwgts[i];
+    badmaxpwgt[i] = badmaxpwgt[i+1] = gpwgts[i]+gpwgts[i];
+  }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr42193.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr42193.c
new file mode 100644
index 000000000..01609c982
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/pr42193.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_long } */
+
+#include <stdarg.h>
+
+unsigned long in[6], out[6];
+
+void foo ()
+{
+  unsigned long a, b, c, d, e, f;
+
+  a = in[0];
+  b = in[1];
+  c = in[2];
+  d = in[3];
+  e = in[4];
+  f = in[5];
+
+  out[0] = 2 * a + 7 * b + 8  * c + 31 * d + 10 * e + 21 * f;
+  out[1] = 3 * a + 6 * b + 12 * c + 13 * d + 15 * e + 28 * f;
+  out[2] = 4 * a + 5 * b + 72  * c + 23 * d + 14 * e + 24 * f;
+  out[3] = 8 * a + 71 * b + 18  * c + 33 * d + 13 * e + 25 * f;
+  out[4] = 12 * a + 16 * b + 19 * c + 41 * d + 22 * e + 26 * f;
+  out[5] = 17 * a + 15 * b + 13  * c + 14 * d + 11 * e + 9 * f;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/section-anchors-pr27770.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/section-anchors-pr27770.c
new file mode 100644
index 000000000..7513d93a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/section-anchors-pr27770.c
@@ -0,0 +1,31 @@
+/* { dg-require-effective-target section_anchors } */ 
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+short x;
+static short f[100] = {0};
+int
+bar (void)
+{
+  return f[0];
+}
+void
+foo (void)
+{
+  int i;
+  for (i = 0; i < 100; i++)
+    f[i]++;
+}
+int main (void)
+{
+  int i;
+  check_vect ();
+  foo ();
+  for (i = 0; i < 100; i++)
+    if (f[i]!=1) 
+      abort ();
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/section-anchors-vect-69.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/section-anchors-vect-69.c
new file mode 100644
index 000000000..7b5ce7348
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/section-anchors-vect-69.c
@@ -0,0 +1,120 @@
+/* { dg-require-effective-target section_anchors } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct s2{
+  int m;
+  int n[N-1][N-1][N-1];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+struct test2{
+  struct s2 a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s2 e; /* array e.n is aligned */
+};
+
+
+struct test1 tmp1[4];
+struct test2 tmp2[4];
+
+int main1 ()
+{  
+  int i,j;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1[2].a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1[2].a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1[2].a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1[2].a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+          tmp1[2].e.n[1][i][j] = 8;
+	}
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+	{
+          if (tmp1[2].e.n[1][i][j] != 8)
+	    abort ();
+	}
+    }
+
+  /* 4. unaligned */
+  for (i = 0; i < N-4; i++)
+    {
+      for (j = 0; j < N-4; j++)
+	{
+          tmp2[2].e.n[1][i][j] = 8;
+	}
+    }
+
+  /* check results:  */
+  for (i = 0; i < N-4; i++)
+    {
+      for (j = 0; j < N-4; j++)
+	{
+          if (tmp2[2].e.n[1][i][j] != 8)
+	    abort ();
+	}
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" { target vect_int } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* Alignment forced using versioning until the pass that increases alignment
+  is extended to handle structs.  */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 4 "vect" { target {vect_int && vector_alignment_reachable } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 4 "vect" { target {vect_int && {! vector_alignment_reachable} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-1.c
new file mode 100644
index 000000000..f7e209738
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-1.c
@@ -0,0 +1,124 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*4] = 8;
+      out[i*4 + 1] = 18;
+      out[i*4 + 2] = 28;
+      out[i*4 + 3] = 38;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] != 8 
+         || out[i*4 + 1] != 18
+         || out[i*4 + 2] != 28
+         || out[i*4 + 3] != 38)
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = 8;
+      out[i*8 + 1] = 7;
+      out[i*8 + 2] = 81;
+      out[i*8 + 3] = 28;
+      out[i*8 + 4] = 18;
+      out[i*8 + 5] = 85;
+      out[i*8 + 6] = 5;
+      out[i*8 + 7] = 4;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] != 8
+         || out[i*8 + 1] != 7
+         || out[i*8 + 2] != 81
+         || out[i*8 + 3] != 28
+         || out[i*8 + 4] != 18
+         || out[i*8 + 5] != 85
+         || out[i*8 + 6] != 5
+         || out[i*8 + 7] != 4)
+        abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*5] = 8;
+      out[i*5 + 1] = 7;
+      out[i*5 + 2] = 81;
+      out[i*5 + 3] = 28;
+      out[i*5 + 4] = 18;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*5] != 8
+         || out[i*5 + 1] != 7
+         || out[i*5 + 2] != 81
+         || out[i*5 + 3] != 28
+         || out[i*5 + 4] != 18)
+        abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*9] = 8;
+      out[i*9 + 1] = 7;
+      out[i*9 + 2] = 81;
+      out[i*9 + 3] = 28;
+      out[i*9 + 4] = 18;
+      out[i*9 + 5] = 85;
+      out[i*9 + 6] = 5;
+      out[i*9 + 7] = 4;
+      out[i*9 + 8] = 14;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*9] != 8
+         || out[i*9 + 1] != 7
+         || out[i*9 + 2] != 81
+         || out[i*9 + 3] != 28
+         || out[i*9 + 4] != 18
+         || out[i*9 + 5] != 85
+         || out[i*9 + 6] != 5
+         || out[i*9 + 7] != 4
+         || out[i*9 + 8] != 14)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-10.c
new file mode 100644
index 000000000..9185c7eeb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-10.c
@@ -0,0 +1,114 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  float out2[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] + 6;
+      a2 = in[i*8 + 2] + 7;
+      a3 = in[i*8 + 3] + 8;
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+
+      b0 = a0 * 3;
+      b1 = a1 * 2;
+      b2 = a2 * 12;
+      b3 = a3 * 5;
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] + 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = (in[i*4] + 2) * 3;
+      out[i*4 + 1] = (in[i*4 + 1] + 2) * 7;
+      out[i*4 + 2] = (in[i*4 + 2] + 7) * 3;
+      out[i*4 + 3] = (in[i*4 + 3] + 7) * 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  (in[i*4] + 2) * 3
+         || out[i*4 + 1] != (in[i*4 + 1] + 2) * 7
+         || out[i*4 + 2] != (in[i*4 + 2] + 7) * 3
+         || out[i*4 + 3] != (in[i*4 + 3] + 7) * 7)
+        abort ();
+    }
+
+  for (i = 0; i < N*4; i++)
+    {
+      out2[i*2] = (float) (in[i*2] * 2 + 5) ;
+      out2[i*2 + 1] = (float) (in[i*2 + 1] * 3 + 7);
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*4; i++)
+    {
+      if (out2[i*2] !=  (float) (in[i*2] * 2 + 5)
+         || out2[i*2 + 1] != (float) (in[i*2 + 1] * 3 + 7))
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target {vect_uintfloat_cvt && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target {{! { vect_uintfloat_cvt}} && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target {{! { vect_uintfloat_cvt}} && { ! {vect_int_mult}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" {target {vect_uintfloat_cvt && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  {target {{! { vect_uintfloat_cvt}} && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target {{! { vect_uintfloat_cvt}} && { ! {vect_int_mult}}} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-11.c
new file mode 100644
index 000000000..7e9c89c6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-11.c
@@ -0,0 +1,114 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  float out2[N*8];
+
+  /* Different operations - not SLPable.  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] * 6;
+      a2 = in[i*8 + 2] + 7;
+      a3 = in[i*8 + 3] + 8;
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+
+      b0 = a0 * 3;
+      b1 = a1 * 2;
+      b2 = a2 * 12;
+      b3 = a3 * 5;
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] * 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
+	abort ();
+    }
+
+  /* Requires permutation - not SLPable.  */
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = (in[i*4] + 2) * 3;
+      out[i*4 + 1] = (in[i*4 + 2] + 2) * 7;
+      out[i*4 + 2] = (in[i*4 + 1] + 7) * 3;
+      out[i*4 + 3] = (in[i*4 + 3] + 3) * 4;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  (in[i*4] + 2) * 3
+         || out[i*4 + 1] != (in[i*4 + 2] + 2) * 7
+         || out[i*4 + 2] != (in[i*4 + 1] + 7) * 3
+         || out[i*4 + 3] != (in[i*4 + 3] + 3) * 4)
+        abort ();
+    }
+
+  /* Different operations - not SLPable.  */
+  for (i = 0; i < N*4; i++)
+    {
+      out2[i*2] = ((float) in[i*2] * 2 + 6) ;
+      out2[i*2 + 1] = (float) (in[i*2 + 1] * 3 + 7);
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*4; i++)
+    {
+      if (out2[i*2] !=  ((float) in[i*2] * 2 + 6)
+         || out2[i*2 + 1] != (float) (in[i*2 + 1] * 3 + 7))
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  { target { { vect_uintfloat_cvt && vect_strided_wide } &&  vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  { target { { { ! vect_uintfloat_cvt } && vect_strided_wide } &&  vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target  { ! { vect_int_mult && vect_strided_wide } } } } }  */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0  "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-12a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-12a.c
new file mode 100644
index 000000000..5cf404100
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-12a.c
@@ -0,0 +1,105 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned int ia[N], ib[N*2];
+
+  for (i = 0; i < N; i++)
+    {
+      
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] + 6;
+      a2 = in[i*8 + 2] + 7;
+      a3 = in[i*8 + 3] + 8;
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+
+      b0 = a0 * 3;
+      b1 = a1 * 2;
+      b2 = a2 * 12;
+      b3 = a3 * 5;
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+
+      ia[i] = b6;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] + 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7
+         || ia[i] != (in[i*8 + 6] + 11) * 3)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = (in[i*4] + 2) * 3;
+      out[i*4 + 1] = (in[i*4 + 1] + 2) * 7;
+      out[i*4 + 2] = (in[i*4 + 2] + 7) * 3;
+      out[i*4 + 3] = (in[i*4 + 3] + 7) * 7;
+
+      ib[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  (in[i*4] + 2) * 3
+         || out[i*4 + 1] != (in[i*4 + 1] + 2) * 7
+         || out[i*4 + 2] != (in[i*4 + 2] + 7) * 3
+         || out[i*4 + 3] != (in[i*4 + 3] + 7) * 7 
+         || ib[i] != 7)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target { vect_strided_wide && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  {target { {! {vect_strided_wide}} && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target  { ! vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" {target { vect_strided_wide && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" {target { {! {vect_strided_wide}} && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" {target  { ! vect_int_mult } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-12b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-12b.c
new file mode 100644
index 000000000..5c5d133f7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-12b.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_uintfloat_cvt } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 64 
+
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 ()
+{
+  int i;
+  float out2[N*8], fa[N*4];
+
+  for (i = 0; i < N; i++)
+    {
+      out2[i*2] = (float) (in[i*2] * 2 + 11) ;
+      out2[i*2 + 1] = (float) (in[i*2 + 1] * 3 + 7);
+    
+      fa[i] = (float) in[i*2+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out2[i*2] !=  (float) (in[i*2] * 2 + 11)
+         || out2[i*2 + 1] != (float) (in[i*2 + 1] * 3 + 7)
+         || fa[i] != (float) in[i*2+1])
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  {target { vect_strided_wide && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target { { ! { vect_int_mult }} || { ! {vect_strided_wide}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  {target { vect_strided_wide && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target { { ! { vect_int_mult }} || { ! {vect_strided_wide}}} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-13.c
new file mode 100644
index 000000000..0041526b9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-13.c
@@ -0,0 +1,134 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned int in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned int out2[N*8];
+
+  /* Induction is not SLPable yet.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8] + i;
+      out[i*8 + 1] = in[i*8 + 1] + i;
+      out[i*8 + 2] = in[i*8 + 2] + i;
+      out[i*8 + 3] = in[i*8 + 3] + i;
+      out[i*8 + 4] = in[i*8 + 4] + i;
+      out[i*8 + 5] = in[i*8 + 5] + i;
+      out[i*8 + 6] = in[i*8 + 6] + i;
+      out[i*8 + 7] = in[i*8 + 7] + i;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8] + i
+         || out[i*8 + 1] != in[i*8 + 1] + i
+         || out[i*8 + 2] != in[i*8 + 2] + i
+         || out[i*8 + 3] != in[i*8 + 3] + i
+         || out[i*8 + 4] != in[i*8 + 4] + i
+         || out[i*8 + 5] != in[i*8 + 5] + i
+         || out[i*8 + 6] != in[i*8 + 6] + i
+         || out[i*8 + 7] != in[i*8 + 7] + i)
+	abort ();
+    }
+
+  /* Induction is not SLPable yet and strided group size must be a power of 2 
+     to get vectorized.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out2[i*12] = in2[i*12] + i;
+      out2[i*12 + 1] = in2[i*12 + 1] + i;
+      out2[i*12 + 2] = in2[i*12 + 2] + i;
+      out2[i*12 + 3] = in2[i*12 + 3] + i;
+      out2[i*12 + 4] = in2[i*12 + 4] + i;
+      out2[i*12 + 5] = in2[i*12 + 5] + i;
+      out2[i*12 + 6] = in2[i*12 + 6] + i;
+      out2[i*12 + 7] = in2[i*12 + 7] + i;
+      out2[i*12 + 8] = in2[i*12 + 8] + i;
+      out2[i*12 + 9] = in2[i*12 + 9] + i;
+      out2[i*12 + 10] = in2[i*12 + 10] + i;
+      out2[i*12 + 11] = in2[i*12 + 11] + i;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+        if (out2[i*12] != in2[i*12] + i
+            || out2[i*12 + 1] != in2[i*12 + 1] + i
+            || out2[i*12 + 2] != in2[i*12 + 2] + i
+            || out2[i*12 + 3] != in2[i*12 + 3] + i
+            || out2[i*12 + 4] != in2[i*12 + 4] + i
+            || out2[i*12 + 5] != in2[i*12 + 5] + i
+            || out2[i*12 + 6] != in2[i*12 + 6] + i
+            || out2[i*12 + 7] != in2[i*12 + 7] + i
+            || out2[i*12 + 8] != in2[i*12 + 8] + i
+            || out2[i*12 + 9] != in2[i*12 + 9] + i
+            || out2[i*12 + 10] != in2[i*12 + 10] + i
+            || out2[i*12 + 11] != in2[i*12 + 11] + i)
+          abort ();
+    }
+
+  /* Not power of 2 but SLPable.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out2[i*12] = in2[i*12] + 1;
+      out2[i*12 + 1] = in2[i*12 + 1] + 2;
+      out2[i*12 + 2] = in2[i*12 + 2] + 3;
+      out2[i*12 + 3] = in2[i*12 + 3] + 4;
+      out2[i*12 + 4] = in2[i*12 + 4] + 5;
+      out2[i*12 + 5] = in2[i*12 + 5] + 6;
+      out2[i*12 + 6] = in2[i*12 + 6] + 7;
+      out2[i*12 + 7] = in2[i*12 + 7] + 8;
+      out2[i*12 + 8] = in2[i*12 + 8] + 9;
+      out2[i*12 + 9] = in2[i*12 + 9] + 10;
+      out2[i*12 + 10] = in2[i*12 + 10] + 11;
+      out2[i*12 + 11] = in2[i*12 + 11] + 12;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+        if (out2[i*12] != in2[i*12] + 1
+            || out2[i*12 + 1] != in2[i*12 + 1] + 2
+            || out2[i*12 + 2] != in2[i*12 + 2] + 3
+            || out2[i*12 + 3] != in2[i*12 + 3] + 4
+            || out2[i*12 + 4] != in2[i*12 + 4] + 5
+            || out2[i*12 + 5] != in2[i*12 + 5] + 6
+            || out2[i*12 + 6] != in2[i*12 + 6] + 7
+            || out2[i*12 + 7] != in2[i*12 + 7] + 8
+            || out2[i*12 + 8] != in2[i*12 + 8] + 9
+            || out2[i*12 + 9] != in2[i*12 + 9] + 10
+            || out2[i*12 + 10] != in2[i*12 + 10] + 11
+            || out2[i*12 + 11] != in2[i*12 + 11] + 12)
+          abort ();
+    }
+
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { xfail *-*-* }  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-14.c
new file mode 100644
index 000000000..98a203cf5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-14.c
@@ -0,0 +1,117 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned short in2[N*16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 (int n)
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned short out2[N*16];
+
+  /* Multiple types are now SLPable.  */
+  for (i = 0; i < n; i++)
+    {
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] + 6; 
+      a2 = in[i*8 + 2] + 7; 
+      a3 = in[i*8 + 3] + 8; 
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+    
+      b0 = a0 * 3;
+      b1 = a1 * 2; 
+      b2 = a2 * 12;
+      b3 = a3 * 5; 
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+    
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+    
+      out2[i*16] = in2[i*16] + 2;
+      out2[i*16 + 1] = in2[i*16 + 1] + 3;
+      out2[i*16 + 2] = in2[i*16 + 2] + 4;
+      out2[i*16 + 3] = in2[i*16 + 3] + 3;
+      out2[i*16 + 4] = in2[i*16 + 4] + 2;
+      out2[i*16 + 5] = in2[i*16 + 5] + 3;
+      out2[i*16 + 6] = in2[i*16 + 6] + 2;
+      out2[i*16 + 7] = in2[i*16 + 7] + 4;
+      out2[i*16 + 8] = in2[i*16 + 8] + 2;
+      out2[i*16 + 9] = in2[i*16 + 9] + 5;
+      out2[i*16 + 10] = in2[i*16 + 10] + 2;
+      out2[i*16 + 11] = in2[i*16 + 11] + 3;
+      out2[i*16 + 12] = in2[i*16 + 12] + 4;
+      out2[i*16 + 13] = in2[i*16 + 13] + 4;
+      out2[i*16 + 14] = in2[i*16 + 14] + 3;
+      out2[i*16 + 15] = in2[i*16 + 15] + 2;
+}
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] + 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
+        abort ();
+
+      if (out2[i*16] !=  in2[i*16] + 2
+         || out2[i*16 + 1] != in2[i*16 + 1] + 3
+         || out2[i*16 + 2] != in2[i*16 + 2] + 4
+         || out2[i*16 + 3] != in2[i*16 + 3] + 3
+         || out2[i*16 + 4] != in2[i*16 + 4] + 2
+         || out2[i*16 + 5] != in2[i*16 + 5] + 3
+         || out2[i*16 + 6] != in2[i*16 + 6] + 2
+         || out2[i*16 + 7] != in2[i*16 + 7] + 4
+         || out2[i*16 + 8] != in2[i*16 + 8] + 2
+         || out2[i*16 + 9] != in2[i*16 + 9] + 5
+         || out2[i*16 + 10] != in2[i*16 + 10] + 2
+         || out2[i*16 + 11] != in2[i*16 + 11] + 3
+         || out2[i*16 + 12] != in2[i*16 + 12] + 4
+         || out2[i*16 + 13] != in2[i*16 + 13] + 4
+         || out2[i*16 + 14] != in2[i*16 + 14] + 3
+         || out2[i*16 + 15] != in2[i*16 + 15] + 2)
+        abort ();
+    
+    }
+
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (N);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_int_mult } } }  */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_int_mult } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-15.c
new file mode 100644
index 000000000..dde0b746f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-15.c
@@ -0,0 +1,119 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned int in2[N*16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned int out2[N*16];
+
+int
+main1 (int n)
+{
+  int i;
+  unsigned int a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+
+  for (i = 0; i < n; i++)
+    {
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] + 6; 
+      a2 = in[i*8 + 2] + 7; 
+      a3 = in[i*8 + 3] + 8; 
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+    
+      b0 = a0 * 3;
+      b1 = a1 * 2; 
+      b2 = a2 * 12;
+      b3 = a3 * 5; 
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+    
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+    
+      out2[i*16] = in2[i*16] * 2;
+      out2[i*16 + 1] = in2[i*16 + 1] * 3;
+      out2[i*16 + 2] = in2[i*16 + 2] * 4;
+      out2[i*16 + 3] = in2[i*16 + 3] * 3;
+      out2[i*16 + 4] = in2[i*16 + 4] * 2;
+      out2[i*16 + 5] = in2[i*16 + 5] * 3;
+      out2[i*16 + 6] = in2[i*16 + 6] * 2;
+      out2[i*16 + 7] = in2[i*16 + 7] * 4;
+      out2[i*16 + 8] = in2[i*16 + 8] * 2;
+      out2[i*16 + 9] = in2[i*16 + 9] * 5;
+      out2[i*16 + 10] = in2[i*16 + 10] * 2;
+      out2[i*16 + 11] = in2[i*16 + 11] * 3;
+      out2[i*16 + 12] = in2[i*16 + 12] * 4;
+      out2[i*16 + 13] = in2[i*16 + 13] * 4;
+      out2[i*16 + 14] = in2[i*16 + 14] * 3;
+      out2[i*16 + 15] = in2[i*16 + 15] * 2;
+}
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] + 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
+        abort ();
+
+      if (out2[i*16] !=  in2[i*16] * 2
+         || out2[i*16 + 1] != in2[i*16 + 1] * 3
+         || out2[i*16 + 2] != in2[i*16 + 2] * 4
+         || out2[i*16 + 3] != in2[i*16 + 3] * 3
+         || out2[i*16 + 4] != in2[i*16 + 4] * 2
+         || out2[i*16 + 5] != in2[i*16 + 5] * 3
+         || out2[i*16 + 6] != in2[i*16 + 6] * 2
+         || out2[i*16 + 7] != in2[i*16 + 7] * 4
+         || out2[i*16 + 8] != in2[i*16 + 8] * 2
+         || out2[i*16 + 9] != in2[i*16 + 9] * 5
+         || out2[i*16 + 10] != in2[i*16 + 10] * 2
+         || out2[i*16 + 11] != in2[i*16 + 11] * 3
+         || out2[i*16 + 12] != in2[i*16 + 12] * 4
+         || out2[i*16 + 13] != in2[i*16 + 13] * 4
+         || out2[i*16 + 14] != in2[i*16 + 14] * 3
+         || out2[i*16 + 15] != in2[i*16 + 15] * 2)
+        abort ();
+    
+    }
+
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (N);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  {target vect_int_mult } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target  { ! { vect_int_mult } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" {target vect_int_mult } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" {target { ! { vect_int_mult } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-16.c
new file mode 100644
index 000000000..5ca698f7d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-16.c
@@ -0,0 +1,72 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int out[N*8];
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned int in2[N*16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned int out2[N*16];
+
+int
+main1 ()
+{
+  int i;
+  unsigned int a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+
+  /* SLP group of size that is not a multiple of vector size. 
+     Unrolling by 2.  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*2] + 5;
+      a1 = in[i*2 + 1] + 6; 
+    
+      b0 = a0 * 3;
+      b1 = a1 * 2; 
+    
+      out[i*2] = b0 - 2;
+      out[i*2 + 1] = b1 - 3; 
+    
+      out2[i*6] = in2[i*6] * 2;
+      out2[i*6 + 1] = in2[i*6 + 1] * 3;
+      out2[i*6 + 2] = in2[i*6 + 2] * 4;
+      out2[i*6 + 3] = in2[i*6 + 3] * 2;
+      out2[i*6 + 4] = in2[i*6 + 4] * 4;
+      out2[i*6 + 5] = in2[i*6 + 5] * 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*2] !=  (in[i*2] + 5) * 3 - 2
+         || out[i*2 + 1] != (in[i*2 + 1] + 6) * 2 - 3
+         || out2[i*6] != in2[i*6] * 2
+         || out2[i*6 + 1] != in2[i*6 + 1] * 3
+         || out2[i*6 + 2] != in2[i*6 + 2] * 4
+         || out2[i*6 + 3] != in2[i*6 + 3] * 2
+         || out2[i*6 + 4] != in2[i*6 + 4] * 4
+         || out2[i*6 + 5] != in2[i*6 + 5] * 3)
+        abort ();
+    }
+
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_int_mult } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_int_mult } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-17.c
new file mode 100644
index 000000000..0939f74d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-17.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned short out[N*8];
+unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned short in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned short out2[N*8];
+
+int
+main1 ()
+{
+  int i;
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*2] = in[i*2] + 5;
+      out[i*2 + 1] = in[i*2 + 1] + 6;
+
+      out2[i*4] = in2[i*4] + 2;
+      out2[i*4 + 1] = in2[i*4 + 1] + 2;
+      out2[i*4 + 2] = in2[i*4 + 2] + 1;
+      out2[i*4 + 3] = in2[i*4 + 3] + 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*2] != in[i*2] + 5
+         || out[i*2 + 1] != in[i*2 + 1] + 6
+         || out2[i*4] !=  in2[i*4] + 2
+         || out2[i*4 + 1] != in2[i*4 + 1] + 2
+         || out2[i*4 + 2] != in2[i*4 + 2] + 1
+         || out2[i*4 + 3] != in2[i*4 + 3] + 3)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-18.c
new file mode 100644
index 000000000..91e1e114c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-18.c
@@ -0,0 +1,98 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  float out2[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      
+      a0 = in[i*8] + 5;
+      a1 = in[i*8 + 1] + 6;
+      a2 = in[i*8 + 2] + 7;
+      a3 = in[i*8 + 3] + 8;
+      a4 = in[i*8 + 4] + 9;
+      a5 = in[i*8 + 5] + 10;
+      a6 = in[i*8 + 6] + 11;
+      a7 = in[i*8 + 7] + 12;
+
+      b0 = a0 * 3;
+      b1 = a1 * 2;
+      b2 = a2 * 12;
+      b3 = a3 * 5;
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+      b7 = a7 * 2;
+
+      out[i*8] = b0 - 2;
+      out[i*8 + 1] = b1 - 3; 
+      out[i*8 + 2] = b2 - 2;
+      out[i*8 + 3] = b3 - 1;
+      out[i*8 + 4] = b4 - 8;
+      out[i*8 + 5] = b5 - 7;
+      out[i*8 + 6] = b6 - 3;
+      out[i*8 + 7] = b7 - 7;
+
+
+      out2[i*8] = (float) b0;
+      out2[i*8 + 1] = (float) b1;
+      out2[i*8 + 2] = (float) b2; 
+      out2[i*8 + 3] = (float) b3; 
+      out2[i*8 + 4] = (float) b4; 
+      out2[i*8 + 5] = (float) b5; 
+      out2[i*8 + 6] = (float) b6;
+      out2[i*8 + 7] = (float) b7;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
+         || out[i*8 + 1] != (in[i*8 + 1] + 6) * 2 - 3
+         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
+         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
+         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
+         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
+         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
+         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
+	abort ();
+
+      if (out2[i*8] != (float) ((in[i*8] + 5) * 3)
+         || out2[i*8 + 1] != (float) ((in[i*8 + 1] + 6) * 2)
+         || out2[i*8 + 2] != (float) ((in[i*8 + 2] + 7) * 12)
+         || out2[i*8 + 3] != (float) ((in[i*8 + 3] + 8) * 5)
+         || out2[i*8 + 4] != (float) ((in[i*8 + 4] + 9) * 8)
+         || out2[i*8 + 5] != (float) ((in[i*8 + 5] + 10) * 4)
+         || out2[i*8 + 6] != (float) ((in[i*8 + 6] + 11) * 3)
+         || out2[i*8 + 7] != (float) ((in[i*8 + 7] + 12) * 2))
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_strided } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target { vect_strided } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-19.c
new file mode 100644
index 000000000..1133df4f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-19.c
@@ -0,0 +1,155 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+int
+main1 ()
+{
+  unsigned int i;
+  unsigned int out[N*8];
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned int ia[N*2], a0, a1, a2, a3;
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8];
+      out[i*8 + 1] = in[i*8 + 1];
+      out[i*8 + 2] = in[i*8 + 2];
+      out[i*8 + 3] = in[i*8 + 3];
+      out[i*8 + 4] = in[i*8 + 4];
+      out[i*8 + 5] = in[i*8 + 5];
+      out[i*8 + 6] = in[i*8 + 6];
+      out[i*8 + 7] = in[i*8 + 7];
+    
+      ia[i] = in[i*8 + 2];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8]
+         || out[i*8 + 1] != in[i*8 + 1]
+         || out[i*8 + 2] != in[i*8 + 2]
+         || out[i*8 + 3] != in[i*8 + 3]
+         || out[i*8 + 4] != in[i*8 + 4]
+         || out[i*8 + 5] != in[i*8 + 5]
+         || out[i*8 + 6] != in[i*8 + 6]
+         || out[i*8 + 7] != in[i*8 + 7]
+         || ia[i] != in[i*8 + 2])
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      a0 = in[i*4] + 1;
+      a1 = in[i*4 + 1] + 2;
+      a2 = in[i*4 + 2] + 3;
+      a3 = in[i*4 + 3] + 4;
+
+      out[i*4] = a0;
+      out[i*4 + 1] = a1;
+      out[i*4 + 2] = a2;
+      out[i*4 + 3] = a3;
+
+      ia[i] = a2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4] + 1
+         || out[i*4 + 1] != in[i*4 + 1] + 2
+         || out[i*4 + 2] != in[i*4 + 2] + 3
+         || out[i*4 + 3] != in[i*4 + 3] + 4
+         || ia[i] != in[i*4 + 2] + 3)
+        abort ();
+    }
+
+  /* The last stmt requires interleaving of not power of 2 size - not 
+     vectorizable.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*12] = in[i*12];
+      out[i*12 + 1] = in[i*12 + 1];
+      out[i*12 + 2] = in[i*12 + 2];
+      out[i*12 + 3] = in[i*12 + 3];
+      out[i*12 + 4] = in[i*12 + 4];
+      out[i*12 + 5] = in[i*12 + 5];
+      out[i*12 + 6] = in[i*12 + 6];
+      out[i*12 + 7] = in[i*12 + 7];
+      out[i*12 + 8] = in[i*12 + 8];
+      out[i*12 + 9] = in[i*12 + 9];
+      out[i*12 + 10] = in[i*12 + 10];
+      out[i*12 + 11] = in[i*12 + 11];
+
+      ia[i] = in[i*12 + 7];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*12] !=  in[i*12]
+         || out[i*12 + 1] != in[i*12 + 1]
+         || out[i*12 + 2] != in[i*12 + 2]
+         || out[i*12 + 3] != in[i*12 + 3]
+         || out[i*12 + 4] != in[i*12 + 4]
+         || out[i*12 + 5] != in[i*12 + 5]
+         || out[i*12 + 6] != in[i*12 + 6]
+         || out[i*12 + 7] != in[i*12 + 7]
+         || out[i*12 + 8] != in[i*12 + 8]
+         || out[i*12 + 9] != in[i*12 + 9]
+         || out[i*12 + 10] != in[i*12 + 10]
+         || out[i*12 + 11] != in[i*12 + 11]
+         || ia[i] != in[i*12 + 7])
+        abort ();
+    }
+
+  /* Hybrid SLP with unrolling by 2.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*6] = in[i*6];
+      out[i*6 + 1] = in[i*6 + 1];
+      out[i*6 + 2] = in[i*6 + 2];
+      out[i*6 + 3] = in[i*6 + 3];
+      out[i*6 + 4] = in[i*6 + 4];
+      out[i*6 + 5] = in[i*6 + 5];
+    
+      ia[i] = i;
+    } 
+    
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*6] !=  in[i*6]
+         || out[i*6 + 1] != in[i*6 + 1]
+         || out[i*6 + 2] != in[i*6 + 2]
+         || out[i*6 + 3] != in[i*6 + 3]
+         || out[i*6 + 4] != in[i*6 + 4]
+         || out[i*6 + 5] != in[i*6 + 5]
+         || ia[i] != i)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { target  vect_strided_wide  } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target  { ! { vect_strided_wide } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  { target  vect_strided_wide  } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target { ! { vect_strided_wide } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-2.c
new file mode 100644
index 000000000..2731747db
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-2.c
@@ -0,0 +1,146 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 (unsigned short a0, unsigned short a1, unsigned short a2, 
+       unsigned short a3, unsigned short a4, unsigned short a5,
+       unsigned short a6, unsigned short a7, unsigned short a8,
+       unsigned short a9, unsigned short a10, unsigned short a11,
+       unsigned short a12, unsigned short a13, unsigned short a14,
+       unsigned short a15)
+{
+  int i;
+  unsigned short out[N*16];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*4] = a8;
+      out[i*4 + 1] = a1;
+      out[i*4 + 2] = a2;
+      out[i*4 + 3] = a3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] != a8 
+         || out[i*4 + 1] != a1
+         || out[i*4 + 2] != a2
+         || out[i*4 + 3] != a3)
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*16] = a8;
+      out[i*16 + 1] = a7;
+      out[i*16 + 2] = a1;
+      out[i*16 + 3] = a2;
+      out[i*16 + 4] = a8;
+      out[i*16 + 5] = a5;
+      out[i*16 + 6] = a5;
+      out[i*16 + 7] = a4;
+      out[i*16 + 8] = a12;
+      out[i*16 + 9] = a13;
+      out[i*16 + 10] = a14;
+      out[i*16 + 11] = a15;
+      out[i*16 + 12] = a6;
+      out[i*16 + 13] = a9;
+      out[i*16 + 14] = a0;
+      out[i*16 + 15] = a7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*16] != a8
+          || out[i*16 + 1] != a7
+          || out[i*16 + 2] != a1
+          || out[i*16 + 3] != a2
+          || out[i*16 + 4] != a8
+          || out[i*16 + 5] != a5
+          || out[i*16 + 6] != a5
+          || out[i*16 + 7] != a4
+          || out[i*16 + 8] != a12
+          || out[i*16 + 9] != a13
+          || out[i*16 + 10] != a14
+          || out[i*16 + 11] != a15
+          || out[i*16 + 12] != a6
+          || out[i*16 + 13] != a9
+          || out[i*16 + 14] != a0
+          || out[i*16 + 15] != a7)
+        abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*3] = a8;
+      out[i*3 + 1] = a1;
+      out[i*3 + 2] = a2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*3] != a8
+         || out[i*3 + 1] != a1
+         || out[i*3 + 2] != a2)
+        abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*11] = a8;
+      out[i*11 + 1] = a7;
+      out[i*11 + 2] = a1;
+      out[i*11 + 3] = a2;
+      out[i*11 + 4] = a8;
+      out[i*11 + 5] = a5;
+      out[i*11 + 6] = a5;
+      out[i*11 + 7] = a4;
+      out[i*11 + 8] = a12;
+      out[i*11 + 9] = a13;
+      out[i*11 + 10] = a14;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*11] != a8
+          || out[i*11 + 1] != a7
+          || out[i*11 + 2] != a1
+          || out[i*11 + 3] != a2
+          || out[i*11 + 4] != a8
+          || out[i*11 + 5] != a5
+          || out[i*11 + 6] != a5
+          || out[i*11 + 7] != a4
+          || out[i*11 + 8] != a12
+          || out[i*11 + 9] != a13
+          || out[i*11 + 10] != a14)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-20.c
new file mode 100644
index 000000000..86d3927a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-20.c
@@ -0,0 +1,116 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 (unsigned short a0, unsigned short a1, unsigned short a2, 
+       unsigned short a3, unsigned short a4, unsigned short a5,
+       unsigned short a6, unsigned short a7, unsigned short a8)
+{
+  int i;
+  unsigned short out[N*8], out2[N*8], b0, b1, b2, b3, b4, b5, b6, b7, b8;
+
+  for (i = 0; i < N; i++)
+    {
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 + 5;
+      b4 = a4 + 4;
+      b5 = a5 + 3;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*4] = b0;
+      out2[i*4 + 1] = b1;
+      out2[i*4 + 2] = b4;
+      out2[i*4 + 3] = b5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] != b0 
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+	abort ();
+
+      if (out2[i*4] != b0  
+         || out2[i*4 + 1] != b1
+         || out2[i*4 + 2] != b4
+         || out2[i*4 + 3] != b5)
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 + 5;
+      b4 = a4 + 4;
+      b5 = a5 + 3;
+      b6 = a6 + 2;
+      b7 = a7 + 1;
+      b8 = a8 + 9;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*8] = b0;
+      out2[i*8 + 1] = b1;
+      out2[i*8 + 2] = b4;
+      out2[i*8 + 3] = b5;
+      out2[i*8 + 4] = b6;
+      out2[i*8 + 5] = b2;
+      out2[i*8 + 6] = b7;
+      out2[i*8 + 7] = b8;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] != b0 
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+        abort ();
+
+      if (out2[i*8] != b0
+         || out2[i*8 + 1] != b1
+         || out2[i*8 + 2] != b4
+         || out2[i*8 + 3] != b5
+         || out2[i*8 + 4] != b6
+         || out2[i*8 + 5] != b2
+         || out2[i*8 + 6] != b7
+         || out2[i*8 + 7] != b8)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (8,7,6,5,4,3,2,1,0);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-21.c
new file mode 100644
index 000000000..327045e47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-21.c
@@ -0,0 +1,208 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 ()
+{
+  unsigned short i;
+  unsigned short out[N*8], out2[N*8], b0, b1, b2, b3, b4, a0, a1, a2, a3, b5;
+  unsigned short in[N*8];
+
+  for (i = 0; i < N*8; i++)
+    {
+      in[i] = i;
+    }
+
+  /* Different operations in both cases - vectorization with interleaving.  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*4];
+      a1 = in[i*4 + 1];
+      a2 = in[i*4 + 2];
+      a3 = in[i*4 + 3];
+
+      b0 = a0 * 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 * 5;
+      
+      b4 = a2 + 4;
+      b5 = a3 + 3;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*4] = b0;
+      out2[i*4 + 1] = b1;
+      out2[i*4 + 2] = b4;
+      out2[i*4 + 3] = b5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*4];
+      a1 = in[i*4 + 1];
+      a2 = in[i*4 + 2];
+      a3 = in[i*4 + 3];
+
+      b0 = a0 * 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 * 5;
+
+      b4 = a2 + 4;
+      b5 = a3 + 3;
+
+      if (out[i*4] != b0 
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+	abort ();
+
+      if (out2[i*4] != b0  
+         || out2[i*4 + 1] != b1
+         || out2[i*4 + 2] != b4
+         || out2[i*4 + 3] != b5)
+        abort ();
+    }
+
+  /* Different operations in the first case - vectorization with interleaving.  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*4];
+      a1 = in[i*4 + 1];
+      a2 = in[i*4 + 2];
+      a3 = in[i*4 + 3];
+
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 * 5;
+
+      b4 = a2 + 4;
+      b5 = a3 + 3;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*4] = b0;
+      out2[i*4 + 1] = b1;
+      out2[i*4 + 2] = b4;
+      out2[i*4 + 3] = b5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*4];
+      a1 = in[i*4 + 1];
+      a2 = in[i*4 + 2];
+      a3 = in[i*4 + 3];
+
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 * 5;
+
+      b4 = a2 + 4;
+      b5 = a3 + 3;
+
+      if (out[i*4] != b0
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+        abort ();
+
+      if (out2[i*4] != b0
+         || out2[i*4 + 1] != b1
+         || out2[i*4 + 2] != b4
+         || out2[i*4 + 3] != b5)
+        abort ();
+    }
+
+
+  /* Different operations in the second case - vectorization with interleaving.  */
+  for (i = 0; i < N; i++) 
+    { 
+      a0 = in[i*4];
+      a1 = in[i*4 + 1];
+      a2 = in[i*4 + 2];
+      a3 = in[i*4 + 3];
+
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 + 5;
+
+      b4 = a2 * 4;
+      b5 = a3 + 3;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*4] = b0;
+      out2[i*4 + 1] = b1;
+      out2[i*4 + 2] = b4;
+      out2[i*4 + 3] = b5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*4];
+      a1 = in[i*4 + 1];
+      a2 = in[i*4 + 2];
+      a3 = in[i*4 + 3];
+
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 + 5;
+
+      b4 = a2 * 4;
+      b5 = a3 + 3;
+
+      if (out[i*4] != b0
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+        abort ();
+
+      if (out2[i*4] != b0
+         || out2[i*4 + 1] != b1
+         || out2[i*4 + 2] != b4
+         || out2[i*4 + 3] != b5)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect"  { target vect_strided } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target  { ! { vect_strided } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_strided }  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  { target { ! { vect_strided } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-22.c
new file mode 100644
index 000000000..18df4269a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-22.c
@@ -0,0 +1,135 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+int
+main1 (unsigned short a0, unsigned short a1, unsigned short a2, 
+       unsigned short a3, unsigned short a4, unsigned short a5,
+       unsigned short a6, unsigned short a7, unsigned short a8)
+{
+  int i;
+  unsigned short out[N*8], out2[N*8], out3[N*8], b0, b1, b2, b3, b4, b5, b6, b7, b8;
+
+  for (i = 0; i < N; i++)
+    {
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 + 5;
+      b4 = a4 + 4;
+      b5 = a5 + 3;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*4] = b0;
+      out2[i*4 + 1] = b1;
+      out2[i*4 + 2] = b4;
+      out2[i*4 + 3] = b5;
+
+      out3[i*4] = b2;
+      out3[i*4 + 1] = b1;
+      out3[i*4 + 2] = b4;
+      out3[i*4 + 3] = b5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] != b0 
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+	abort ();
+
+    
+      if (out2[i*4] != b0
+         || out2[i*4 + 1] != b1
+         || out2[i*4 + 2] != b4
+         || out2[i*4 + 3] != b5)
+        abort ();
+   
+      if (out3[i*4] != b2  
+         || out3[i*4 + 1] != b1
+         || out3[i*4 + 2] != b4
+         || out3[i*4 + 3] != b5)
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      b0 = a0 + 8;
+      b1 = a1 + 7;
+      b2 = a2 + 6;
+      b3 = a3 + 5;
+      b4 = a4 + 4;
+      b5 = a5 + 3;
+      b6 = a6 + 2;
+      b7 = a7 + 1;
+      b8 = a8 + 9;
+
+      out[i*4] = b0;
+      out[i*4 + 1] = b1;
+      out[i*4 + 2] = b2;
+      out[i*4 + 3] = b3;
+
+      out2[i*8] = b0;
+      out2[i*8 + 1] = b1;
+      out2[i*8 + 2] = b4;
+      out2[i*8 + 3] = b5;
+      out2[i*8 + 4] = b6;
+      out2[i*8 + 5] = b2;
+      out2[i*8 + 6] = b7;
+      out2[i*8 + 7] = b8;
+
+      out3[2*i + 1] = a0;
+      out3[2*i] = b8; 
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] != b0 
+         || out[i*4 + 1] != b1
+         || out[i*4 + 2] != b2
+         || out[i*4 + 3] != b3)
+        abort ();
+
+      if (out2[i*8] != b0
+         || out2[i*8 + 1] != b1
+         || out2[i*8 + 2] != b4
+         || out2[i*8 + 3] != b5
+         || out2[i*8 + 4] != b6
+         || out2[i*8 + 5] != b2
+         || out2[i*8 + 6] != b7
+         || out2[i*8 + 7] != b8)
+        abort ();
+
+      if (out3[2*i] != b8
+          || out3[2*i+1] != a0)
+        abort();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (8,7,6,5,4,3,2,1,0);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 6 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-23.c
new file mode 100644
index 000000000..27ec12587
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-23.c
@@ -0,0 +1,113 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+   int e;
+   int f;
+   int g;
+   int h;
+} s;
+
+int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->c + ptr->c;
+      res[i].a = ptr->a + ptr->a;
+      res[i].d = ptr->d + ptr->d;
+      res[i].b = ptr->b + ptr->b;
+      res[i].f = ptr->f + ptr->f;
+      res[i].e = ptr->e + ptr->e; 
+      res[i].h = ptr->h + ptr->h;   
+      res[i].g = ptr->g + ptr->g;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].c + arr[i].c
+          || res[i].a != arr[i].a + arr[i].a
+          || res[i].d != arr[i].d + arr[i].d
+          || res[i].b != arr[i].b + arr[i].b
+          || res[i].f != arr[i].f + arr[i].f
+          || res[i].e != arr[i].e + arr[i].e
+          || res[i].h != arr[i].h + arr[i].h
+          || res[i].g != arr[i].g + arr[i].g)
+         abort();
+    }
+
+  ptr = arr;
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->c + ptr->c;
+      res[i].a = ptr->a + ptr->a;
+      res[i].d = ptr->d + ptr->d;
+      res[i].b = ptr->b + ptr->b;
+      res[i].f = ptr->f + ptr->f;
+      res[i].e = ptr->e + ptr->e;
+      res[i].h = ptr->e + ptr->e;
+      res[i].g = ptr->g + ptr->g;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].c + arr[i].c
+          || res[i].a != arr[i].a + arr[i].a
+          || res[i].d != arr[i].d + arr[i].d
+          || res[i].b != arr[i].b + arr[i].b
+          || res[i].f != arr[i].f + arr[i].f
+          || res[i].e != arr[i].e + arr[i].e
+          || res[i].h != arr[i].e + arr[i].e
+          || res[i].g != arr[i].g + arr[i].g)
+         abort();
+    }
+
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { vect_strided_wide } && {! { vect_no_align} } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { ! { vect_strided_wide || vect_no_align} } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-24.c
new file mode 100644
index 000000000..bd9c7515e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-24.c
@@ -0,0 +1,83 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+} s;
+
+unsigned char ub[N*2] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,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};
+
+void
+main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *arr)
+{
+  int i;
+  unsigned char udiff = 2;
+  unsigned char umax = x;
+  unsigned char umin = x;
+  unsigned char ua1[N*2];
+  s *pIn = arr;
+  s out[N];
+
+  for (i = 0; i < N; i++) {
+    udiff += (unsigned char)(ub[i] - uc[i]);
+
+    ua1[2*i+1] = ub[2*i+1];
+    ua1[2*i] = ub[2*i];
+
+    out[i].d = pIn->d - 1;
+    out[i].b = pIn->b - 4;
+    out[i].c = pIn->c - 8;
+    out[i].a = pIn->a - 3;
+
+    pIn++;
+  }
+
+  for (i = 0; i < N; i++) {
+    if (ua1[2*i] != ub[2*i]
+        || ua1[2*i+1] != ub[2*i+1]
+        || out[i].a != arr[i].a - 3
+        || out[i].b != arr[i].b - 4
+        || out[i].c != arr[i].c - 8
+        || out[i].d != arr[i].d - 1)
+      abort();
+  }
+
+  /* check results:  */
+  if (udiff != DIFF)
+    abort ();
+}
+
+int main (void)
+{
+  int i; 
+  s arr[N];
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i + 9;
+      arr[i].b = i * 2 + 10;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      if (arr[i].a == 178)
+         abort();
+    }
+  check_vect ();
+  
+  main1 (100, 100, 1, arr);
+  main1 (0, 15, 0, arr);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-25.c
new file mode 100644
index 000000000..23022fd2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-25.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* Unaligned stores.  */
+
+int ia[N+1];
+short sa[N+1];
+
+int main1 (int n)
+{
+  int i;
+
+  for (i = 1; i <= N/2; i++)
+    {
+      ia[2*i] = 25;
+      ia[2*i + 1] = 5;
+    }
+
+  /* check results:  */
+  for (i = 1; i <= N/2; i++)
+    {
+      if (ia[2*i] != 25
+          || ia[2*i + 1] != 5)
+        abort ();
+    }
+
+  for (i = 1; i <= n/2; i++)
+    {
+      sa[2*i] = 25;
+      sa[2*i + 1] = 5;
+    }
+
+  /* check results:  */
+  for (i = 1; i <= n/2; i++)
+    {
+      if (sa[2*i] != 25
+          || sa[2*i + 1] != 5)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{ 
+
+  check_vect ();
+  
+  return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-26.c
new file mode 100644
index 000000000..14be68bd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-26.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned short out[N*8], a[N], b[N] = {3,6,9,12,15,18,21,24};
+
+  /* Partial SLP is not supported.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+
+      a[i] = b[i] / 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3]
+         || a[i] != b[i] / 3)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-28.c
new file mode 100644
index 000000000..780a4472b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-28.c
@@ -0,0 +1,87 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 32 
+
+unsigned short in[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+unsigned short in2[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+unsigned short in3[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+unsigned short check[N] = {0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,20,21,22,23,25,26,27,28,30,31,32,33,35,36,37,38};
+unsigned short check3[N] = {0,1,2,3,4,5,6,7,8,9,10,11,5,6,7,8,9,10,11,12,13,14,15,16,10,11,12,13,14,15,16,17};
+
+int
+main1 ()
+{
+  int i;
+
+  for (i = 0; i < N/4; i++)
+    {
+      in[i*4] = in[i*4] + 5;
+      in[i*4 + 1] = in[i*4 + 1] + 5;
+      in[i*4 + 2] = in[i*4 + 2] + 5;
+      in[i*4 + 3] = in[i*4 + 3] + 5;
+
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (in[i] != i+5)
+        abort ();
+    }
+
+  /* Not vectorizable because of data dependencies.  */
+  for (i = 1; i < N/4; i++)
+    {
+      in2[i*4] = in2[(i-1)*4] + 5;
+      in2[i*4 + 1] = in2[(i-1)*4 + 1] + 5;
+      in2[i*4 + 2] = in2[(i-1)*4 + 2] + 5;
+      in2[i*4 + 3] = in2[(i-1)*4 + 3] + 5;
+
+    }
+
+  /* check results:  */
+  for (i = 4; i < N; i++)
+    {
+      if (in2[i] != check[i])
+        abort ();
+    }
+  
+  /* Not vectorizable because of data dependencies: distance 3 is greater than 
+     the actual VF with SLP (2), but the analysis fail to detect that for now.  */
+  for (i = 3; i < N/4; i++)
+    {
+      in3[i*4] = in3[(i-3)*4] + 5;
+      in3[i*4 + 1] = in3[(i-3)*4 + 1] + 5;
+      in3[i*4 + 2] = in3[(i-3)*4 + 2] + 5;
+      in3[i*4 + 3] = in3[(i-3)*4 + 3] + 5;
+
+    }
+
+  /* check results:  */
+  for (i = 12; i < N; i++)
+    {
+      if (in3[i] != check3[i])
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-3.c
new file mode 100644
index 000000000..070715371
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-3.c
@@ -0,0 +1,148 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8];
+      out[i*8 + 1] = in[i*8 + 1];
+      out[i*8 + 2] = in[i*8 + 2];
+      out[i*8 + 3] = in[i*8 + 3];
+      out[i*8 + 4] = in[i*8 + 4];
+      out[i*8 + 5] = in[i*8 + 5];
+      out[i*8 + 6] = in[i*8 + 6];
+      out[i*8 + 7] = in[i*8 + 7];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8]
+         || out[i*8 + 1] != in[i*8 + 1]
+         || out[i*8 + 2] != in[i*8 + 2]
+         || out[i*8 + 3] != in[i*8 + 3]
+         || out[i*8 + 4] != in[i*8 + 4]
+         || out[i*8 + 5] != in[i*8 + 5]
+         || out[i*8 + 6] != in[i*8 + 6]
+         || out[i*8 + 7] != in[i*8 + 7])
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3])
+        abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*16] = in[i*16];
+      out[i*16 + 1] = in[i*16 + 1];
+      out[i*16 + 2] = in[i*16 + 2];
+      out[i*16 + 3] = in[i*16 + 3];
+      out[i*16 + 4] = in[i*16 + 4];
+      out[i*16 + 5] = in[i*16 + 5];
+      out[i*16 + 6] = in[i*16 + 6];
+      out[i*16 + 7] = in[i*16 + 7];
+      out[i*16 + 8] = in[i*16 + 8];
+      out[i*16 + 9] = in[i*16 + 9];
+      out[i*16 + 10] = in[i*16 + 10];
+      out[i*16 + 11] = in[i*16 + 11];
+      out[i*16 + 12] = in[i*16 + 12];
+      out[i*16 + 13] = in[i*16 + 13];
+      out[i*16 + 14] = in[i*16 + 14];
+      out[i*16 + 15] = in[i*16 + 15];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*16] !=  in[i*16]
+         || out[i*16 + 1] != in[i*16 + 1]
+         || out[i*16 + 2] != in[i*16 + 2]
+         || out[i*16 + 3] != in[i*16 + 3]
+         || out[i*16 + 4] != in[i*16 + 4]
+         || out[i*16 + 5] != in[i*16 + 5]
+         || out[i*16 + 6] != in[i*16 + 6]
+         || out[i*16 + 7] != in[i*16 + 7]
+         || out[i*16 + 8] != in[i*16 + 8]
+         || out[i*16 + 9] != in[i*16 + 9]
+         || out[i*16 + 10] != in[i*16 + 10]
+         || out[i*16 + 11] != in[i*16 + 11]
+         || out[i*16 + 12] != in[i*16 + 12]
+         || out[i*16 + 13] != in[i*16 + 13]
+         || out[i*16 + 14] != in[i*16 + 14]
+         || out[i*16 + 15] != in[i*16 + 15])
+        abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*9] = in[i*9];
+      out[i*9 + 1] = in[i*9 + 1];
+      out[i*9 + 2] = in[i*9 + 2];
+      out[i*9 + 3] = in[i*9 + 3];
+      out[i*9 + 4] = in[i*9 + 4];
+      out[i*9 + 5] = in[i*9 + 5];
+      out[i*9 + 6] = in[i*9 + 6];
+      out[i*9 + 7] = in[i*9 + 7];
+      out[i*9 + 8] = in[i*9 + 8];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*9] !=  in[i*9]
+         || out[i*9 + 1] != in[i*9 + 1]
+         || out[i*9 + 2] != in[i*9 + 2]
+         || out[i*9 + 3] != in[i*9 + 3]
+         || out[i*9 + 4] != in[i*9 + 4]
+         || out[i*9 + 5] != in[i*9 + 5]
+         || out[i*9 + 6] != in[i*9 + 6]
+         || out[i*9 + 7] != in[i*9 + 7]
+         || out[i*9 + 8] != in[i*9 + 8])
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-33.c
new file mode 100644
index 000000000..288c748af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-33.c
@@ -0,0 +1,112 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  float out2[N*8];
+
+  /* SLP with unrolling by 4.  */
+  for (i = 0; i < N; i++)
+    {
+      a0 = in[i*7] + 5;
+      a1 = in[i*7 + 1] + 6;
+      a2 = in[i*7 + 2] + 7;
+      a3 = in[i*7 + 3] + 8;
+      a4 = in[i*7 + 4] + 9;
+      a5 = in[i*7 + 5] + 10;
+      a6 = in[i*7 + 6] + 11;
+
+      b0 = a0 * 3;
+      b1 = a1 * 2;
+      b2 = a2 * 12;
+      b3 = a3 * 5;
+      b4 = a4 * 8;
+      b5 = a5 * 4;
+      b6 = a6 * 3;
+
+      out[i*7] = b0 - 2;
+      out[i*7 + 1] = b1 - 3; 
+      out[i*7 + 2] = b2 - 2;
+      out[i*7 + 3] = b3 - 1;
+      out[i*7 + 4] = b4 - 8;
+      out[i*7 + 5] = b5 - 7;
+      out[i*7 + 6] = b6 - 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*7] !=  (in[i*7] + 5) * 3 - 2
+         || out[i*7 + 1] != (in[i*7 + 1] + 6) * 2 - 3
+         || out[i*7 + 2] != (in[i*7 + 2] + 7) * 12 - 2
+         || out[i*7 + 3] != (in[i*7 + 3] + 8) * 5 - 1
+         || out[i*7 + 4] != (in[i*7 + 4] + 9) * 8 - 8
+         || out[i*7 + 5] != (in[i*7 + 5] + 10) * 4 - 7
+         || out[i*7 + 6] != (in[i*7 + 6] + 11) * 3 - 3)
+	abort ();
+    }
+
+  /* SLP with unrolling by 4.  */
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*3] = (in[i*3] + 2) * 3;
+      out[i*3 + 1] = (in[i*3 + 1] + 2) * 7;
+      out[i*3 + 2] = (in[i*3 + 2] + 7) * 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*3] !=  (in[i*3] + 2) * 3
+         || out[i*3 + 1] != (in[i*3 + 1] + 2) * 7
+         || out[i*3 + 2] != (in[i*3 + 2] + 7) * 3)
+        abort ();
+    }
+
+  /* SLP with unrolling by 4.  */
+  for (i = 0; i < N*2; i++)
+    {
+      out2[i*3] = (float) (in[i*3] * 2 + 5) ;
+      out2[i*3 + 1] = (float) (in[i*3 + 1] * 3 + 7);
+      out2[i*3 + 2] = (float) (in[i*3 + 2] * 5 + 4);
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out2[i*3] !=  (float) (in[i*3] * 2 + 5)
+         || out2[i*3 + 1] != (float) (in[i*3 + 1] * 3 + 7)
+         || out2[i*3 + 2] != (float) (in[i*3 + 2] * 5 + 4))
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target {vect_uintfloat_cvt && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target {{! { vect_uintfloat_cvt}} && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target {{! { vect_uintfloat_cvt}} && {! {vect_int_mult}}} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" {target {vect_uintfloat_cvt && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  {target {{! { vect_uintfloat_cvt}} && vect_int_mult} } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  {target {{! { vect_uintfloat_cvt}} && {! {vect_int_mult}}} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-34.c
new file mode 100644
index 000000000..3ed56eae4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-34.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned short in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned short out2[N*8];
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*3] = in[i*3] + 5;
+      out[i*3 + 1] = in[i*3 + 1] + 6;
+      out[i*3 + 2] = in[i*3 + 2] + 16;
+
+      out2[i*5] = in2[i*5] + 2;
+      out2[i*5 + 1] = in2[i*5 + 1] + 2;
+      out2[i*5 + 2] = in2[i*5 + 2] + 1;
+      out2[i*5 + 3] = in2[i*5 + 3] + 3;
+      out2[i*5 + 4] = in2[i*5 + 4] + 13;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*3] != in[i*3] + 5
+          || out[i*3 + 1] != in[i*3 + 1] + 6
+          || out[i*3 + 2] != in[i*3 + 2] + 16
+          || out2[i*5] != in2[i*5] + 2
+          || out2[i*5 + 1] != in2[i*5 + 1] + 2
+          || out2[i*5 + 2] != in2[i*5 + 2] + 1
+          || out2[i*5 + 3] != in2[i*5 + 3] + 3
+          || out2[i*5 + 4] != in2[i*5 + 4] + 13)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-35.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-35.c
new file mode 100644
index 000000000..39a7089ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-35.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+   int e;
+} s;
+
+int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  /* SLP with unrolling by 4.  */
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->c + ptr->c;
+      res[i].a = ptr->a + ptr->a;
+      res[i].d = ptr->d + ptr->d;
+      res[i].b = ptr->b + ptr->b;
+      res[i].e = ptr->e + ptr->e; 
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].c + arr[i].c
+          || res[i].a != arr[i].a + arr[i].a
+          || res[i].d != arr[i].d + arr[i].d
+          || res[i].b != arr[i].b + arr[i].b
+          || res[i].e != arr[i].e + arr[i].e)
+         abort();
+    }
+
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-36.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-36.c
new file mode 100644
index 000000000..8480c4a05
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-36.c
@@ -0,0 +1,76 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#define N 32
+
+/* All the loops are vectorizable on platforms with vector shift argument.  */
+
+void
+test_1 (void)
+{
+  static unsigned int bm[N];
+  static unsigned int cm[N];
+  int j;
+
+  /* Vectorizable on platforms with scalar shift argument.  */
+  for (j = 0; j < N/2; j++)
+   {
+    bm[2*j] <<= 8;
+    bm[2*j+1] <<= 8;
+   }
+
+  /* Not vectorizable on platforms with scalar shift argument.  */
+  for (j = 0; j < N/2; j++)
+   {
+    cm[2*j] <<= 8;
+    cm[2*j+1] <<= 7;
+   }
+}
+
+void
+test_2 (int a, int b)
+{
+  static unsigned int bm[N];
+  static unsigned int cm[N];
+  int j;
+
+  /* Vectorizable on platforms with scalar shift argument.  */
+  for (j = 0; j < N/2; j++)
+   {
+    bm[2*j] <<= a;
+    bm[2*j+1] <<= a;
+   }
+
+  /* Not vectorizable on platforms with scalar shift argument.  */
+  for (j = 0; j < N/2; j++)
+   {
+    cm[2*j] <<= a;
+    cm[2*j+1] <<= b;
+   }
+}
+
+void
+test_3 (void)
+{
+ static unsigned int bm[N];
+ int am[N];
+ int j;
+
+ /* Not vectorizable on platforms with scalar shift argument.  */
+ for (j = 0; j < N/2; j++)
+   {
+    bm[2*j] <<= am[j];
+    bm[2*j+1] <<= am[j];
+   }
+
+ /* Not vectorizable on platforms with scalar shift argument.  */
+ for (j = 0; j < N/2; j++)
+   {
+    bm[2*j] <<= am[2*j];
+    bm[2*j+1] <<= am[2*j+1];
+   }
+
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-37.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-37.c
new file mode 100644
index 000000000..48642db96
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-37.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   void *c;
+} s1;
+
+int
+foo1 (s1 *arr)
+{
+  int i;
+  s1 *ptr = arr;
+
+  /* Different constant types - not SLPable.  The group size is not power of 2,
+     interleaving is not supported either.  */
+  for (i = 0; i < N; i++)
+    {
+      ptr->a = 6;
+      ptr->b = 7;
+      ptr->c = NULL;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+       if (arr[i].a != 6 
+           || arr[i].b != 7
+           || arr[i].c != NULL)
+         abort();
+    }
+}
+
+int main (void)
+{
+  int i;
+  s1 arr1[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr1[i].a = i;
+      arr1[i].b = i * 2;
+      arr1[i].c = (void *)arr1;
+
+      if (arr1[i].a == 178)
+         abort(); 
+    } 
+
+
+  foo1 (arr1);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-4.c
new file mode 100644
index 000000000..e1353584f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-4.c
@@ -0,0 +1,128 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned int ia[N*2];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8];
+      out[i*8 + 1] = in[i*8 + 1];
+      out[i*8 + 2] = in[i*8 + 2];
+      out[i*8 + 3] = in[i*8 + 3];
+      out[i*8 + 4] = in[i*8 + 4];
+      out[i*8 + 5] = in[i*8 + 5];
+      out[i*8 + 6] = in[i*8 + 6];
+      out[i*8 + 7] = in[i*8 + 7];
+    
+      ia[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8]
+         || out[i*8 + 1] != in[i*8 + 1]
+         || out[i*8 + 2] != in[i*8 + 2]
+         || out[i*8 + 3] != in[i*8 + 3]
+         || out[i*8 + 4] != in[i*8 + 4]
+         || out[i*8 + 5] != in[i*8 + 5]
+         || out[i*8 + 6] != in[i*8 + 6]
+         || out[i*8 + 7] != in[i*8 + 7]
+         || ia[i] != 7)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+
+      ia[i] = 12;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3]
+         || ia[i] != 12)
+        abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*16] = in[i*16];
+      out[i*16 + 1] = in[i*16 + 1];
+      out[i*16 + 2] = in[i*16 + 2];
+      out[i*16 + 3] = in[i*16 + 3];
+      out[i*16 + 4] = in[i*16 + 4];
+      out[i*16 + 5] = in[i*16 + 5];
+      out[i*16 + 6] = in[i*16 + 6];
+      out[i*16 + 7] = in[i*16 + 7];
+      out[i*16 + 8] = in[i*16 + 8];
+      out[i*16 + 9] = in[i*16 + 9];
+      out[i*16 + 10] = in[i*16 + 10];
+      out[i*16 + 11] = in[i*16 + 11];
+      out[i*16 + 12] = in[i*16 + 12];
+      out[i*16 + 13] = in[i*16 + 13];
+      out[i*16 + 14] = in[i*16 + 14];
+      out[i*16 + 15] = in[i*16 + 15];
+
+      ia[i] = 21;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*16] !=  in[i*16]
+         || out[i*16 + 1] != in[i*16 + 1]
+         || out[i*16 + 2] != in[i*16 + 2]
+         || out[i*16 + 3] != in[i*16 + 3]
+         || out[i*16 + 4] != in[i*16 + 4]
+         || out[i*16 + 5] != in[i*16 + 5]
+         || out[i*16 + 6] != in[i*16 + 6]
+         || out[i*16 + 7] != in[i*16 + 7]
+         || out[i*16 + 8] != in[i*16 + 8]
+         || out[i*16 + 9] != in[i*16 + 9]
+         || out[i*16 + 10] != in[i*16 + 10]
+         || out[i*16 + 11] != in[i*16 + 11]
+         || out[i*16 + 12] != in[i*16 + 12]
+         || out[i*16 + 13] != in[i*16 + 13]
+         || out[i*16 + 14] != in[i*16 + 14]
+         || out[i*16 + 15] != in[i*16 + 15]
+         || ia[i] != 21)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-5.c
new file mode 100644
index 000000000..033de778d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-5.c
@@ -0,0 +1,127 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8];
+  unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+  unsigned short ia[N];
+  unsigned int ib[N*2];
+
+  /* Multiple types with SLP of the smaller type.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8];
+      out[i*8 + 1] = in[i*8 + 1];
+      out[i*8 + 2] = in[i*8 + 2];
+      out[i*8 + 3] = in[i*8 + 3];
+      out[i*8 + 4] = in[i*8 + 4];
+      out[i*8 + 5] = in[i*8 + 5];
+      out[i*8 + 6] = in[i*8 + 6];
+      out[i*8 + 7] = in[i*8 + 7];
+    
+      ia[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8]
+         || out[i*8 + 1] != in[i*8 + 1]
+         || out[i*8 + 2] != in[i*8 + 2]
+         || out[i*8 + 3] != in[i*8 + 3]
+         || out[i*8 + 4] != in[i*8 + 4]
+         || out[i*8 + 5] != in[i*8 + 5]
+         || out[i*8 + 6] != in[i*8 + 6]
+         || out[i*8 + 7] != in[i*8 + 7]
+         || ia[i] != 7)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+
+      ib[i] = 12;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3]
+         || ib[i] != 12)
+        abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*16] = in[i*16];
+      out[i*16 + 1] = in[i*16 + 1];
+      out[i*16 + 2] = in[i*16 + 2];
+      out[i*16 + 3] = in[i*16 + 3];
+      out[i*16 + 4] = in[i*16 + 4];
+      out[i*16 + 5] = in[i*16 + 5];
+      out[i*16 + 6] = in[i*16 + 6];
+      out[i*16 + 7] = in[i*16 + 7];
+      out[i*16 + 8] = in[i*16 + 8];
+      out[i*16 + 9] = in[i*16 + 9];
+      out[i*16 + 10] = in[i*16 + 10];
+      out[i*16 + 11] = in[i*16 + 11];
+      out[i*16 + 12] = in[i*16 + 12];
+      out[i*16 + 13] = in[i*16 + 13];
+      out[i*16 + 14] = in[i*16 + 14];
+      out[i*16 + 15] = in[i*16 + 15];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*16] !=  in[i*16]
+         || out[i*16 + 1] != in[i*16 + 1]
+         || out[i*16 + 2] != in[i*16 + 2]
+         || out[i*16 + 3] != in[i*16 + 3]
+         || out[i*16 + 4] != in[i*16 + 4]
+         || out[i*16 + 5] != in[i*16 + 5]
+         || out[i*16 + 6] != in[i*16 + 6]
+         || out[i*16 + 7] != in[i*16 + 7]
+         || out[i*16 + 8] != in[i*16 + 8]
+         || out[i*16 + 9] != in[i*16 + 9]
+         || out[i*16 + 10] != in[i*16 + 10]
+         || out[i*16 + 11] != in[i*16 + 11]
+         || out[i*16 + 12] != in[i*16 + 12]
+         || out[i*16 + 13] != in[i*16 + 13]
+         || out[i*16 + 14] != in[i*16 + 14]
+         || out[i*16 + 15] != in[i*16 + 15])
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-6.c
new file mode 100644
index 000000000..672b1d6e2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-6.c
@@ -0,0 +1,123 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned int in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned int out2[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8] + 5;
+      out[i*8 + 1] = in[i*8 + 1] + 6;
+      out[i*8 + 2] = in[i*8 + 2] + 7;
+      out[i*8 + 3] = in[i*8 + 3] + 8;
+      out[i*8 + 4] = in[i*8 + 4] + 9;
+      out[i*8 + 5] = in[i*8 + 5] + 10;
+      out[i*8 + 6] = in[i*8 + 6] + 11;
+      out[i*8 + 7] = in[i*8 + 7] + 12;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8] + 5
+         || out[i*8 + 1] != in[i*8 + 1] + 6
+         || out[i*8 + 2] != in[i*8 + 2] + 7
+         || out[i*8 + 3] != in[i*8 + 3] + 8
+         || out[i*8 + 4] != in[i*8 + 4] + 9
+         || out[i*8 + 5] != in[i*8 + 5] + 10
+         || out[i*8 + 6] != in[i*8 + 6] + 11
+         || out[i*8 + 7] != in[i*8 + 7] + 12)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4] + 2;
+      out[i*4 + 1] = in[i*4 + 1] + 2;
+      out[i*4 + 2] = in[i*4 + 2] + 1;
+      out[i*4 + 3] = in[i*4 + 3] + 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4] + 2
+         || out[i*4 + 1] != in[i*4 + 1] + 2
+         || out[i*4 + 2] != in[i*4 + 2] + 1
+         || out[i*4 + 3] != in[i*4 + 3] + 3)
+        abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      out2[i*16] = in2[i*16] * 2;
+      out2[i*16 + 1] = in2[i*16 + 1] * 3;
+      out2[i*16 + 2] = in2[i*16 + 2] * 4;
+      out2[i*16 + 3] = in2[i*16 + 3] * 3;
+      out2[i*16 + 4] = in2[i*16 + 4] * 2;
+      out2[i*16 + 5] = in2[i*16 + 5] * 3;
+      out2[i*16 + 6] = in2[i*16 + 6] * 2;
+      out2[i*16 + 7] = in2[i*16 + 7] * 4;
+      out2[i*16 + 8] = in2[i*16 + 8] * 2;
+      out2[i*16 + 9] = in2[i*16 + 9] * 5;
+      out2[i*16 + 10] = in2[i*16 + 10] * 2;
+      out2[i*16 + 11] = in2[i*16 + 11] * 3;
+      out2[i*16 + 12] = in2[i*16 + 12] * 4;
+      out2[i*16 + 13] = in2[i*16 + 13] * 4;
+      out2[i*16 + 14] = in2[i*16 + 14] * 3;
+      out2[i*16 + 15] = in2[i*16 + 15] * 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out2[i*16] !=  in2[i*16] * 2
+         || out2[i*16 + 1] != in2[i*16 + 1] * 3
+         || out2[i*16 + 2] != in2[i*16 + 2] * 4
+         || out2[i*16 + 3] != in2[i*16 + 3] * 3
+         || out2[i*16 + 4] != in2[i*16 + 4] * 2
+         || out2[i*16 + 5] != in2[i*16 + 5] * 3
+         || out2[i*16 + 6] != in2[i*16 + 6] * 2
+         || out2[i*16 + 7] != in2[i*16 + 7] * 4
+         || out2[i*16 + 8] != in2[i*16 + 8] * 2
+         || out2[i*16 + 9] != in2[i*16 + 9] * 5
+         || out2[i*16 + 10] != in2[i*16 + 10] * 2
+         || out2[i*16 + 11] != in2[i*16 + 11] * 3
+         || out2[i*16 + 12] != in2[i*16 + 12] * 4
+         || out2[i*16 + 13] != in2[i*16 + 13] * 4
+         || out2[i*16 + 14] != in2[i*16 + 14] * 3
+         || out2[i*16 + 15] != in2[i*16 + 15] * 2)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target vect_int_mult} } } */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target  { ! { vect_int_mult } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" {target vect_int_mult  } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" {target  { ! { vect_int_mult } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-7.c
new file mode 100644
index 000000000..f00bf54aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-7.c
@@ -0,0 +1,129 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int in[N*8]  __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned short in2[N*16]  __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8], ia[N*2];
+  unsigned short sa[N], out2[N*16];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8] + 5;
+      out[i*8 + 1] = in[i*8 + 1] + 6;
+      out[i*8 + 2] = in[i*8 + 2] + 7;
+      out[i*8 + 3] = in[i*8 + 3] + 8;
+      out[i*8 + 4] = in[i*8 + 4] + 9;
+      out[i*8 + 5] = in[i*8 + 5] + 10;
+      out[i*8 + 6] = in[i*8 + 6] + 11;
+      out[i*8 + 7] = in[i*8 + 7] + 12;
+
+      ia[i] = in[i]; 
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8] + 5
+         || out[i*8 + 1] != in[i*8 + 1] + 6
+         || out[i*8 + 2] != in[i*8 + 2] + 7
+         || out[i*8 + 3] != in[i*8 + 3] + 8
+         || out[i*8 + 4] != in[i*8 + 4] + 9
+         || out[i*8 + 5] != in[i*8 + 5] + 10
+         || out[i*8 + 6] != in[i*8 + 6] + 11
+         || out[i*8 + 7] != in[i*8 + 7] + 12
+         || ia[i] != in[i])
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4] + 1; 
+      out[i*4 + 1] = in[i*4 + 1] + 2;
+      out[i*4 + 2] = in[i*4 + 2] + 3;
+      out[i*4 + 3] = in[i*4 + 3] + 4;
+
+      ia[i] = in[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4] + 1
+         || out[i*4 + 1] != in[i*4 + 1] + 2
+         || out[i*4 + 2] != in[i*4 + 2] + 3 
+         || out[i*4 + 3] != in[i*4 + 3] + 4
+         || ia[i] != in[i])
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      out2[i*16] = in2[i*16] * 2;
+      out2[i*16 + 1] = in2[i*16 + 1] * 3;
+      out2[i*16 + 2] = in2[i*16 + 2] * 4;
+      out2[i*16 + 3] = in2[i*16 + 3] * 3;
+      out2[i*16 + 4] = in2[i*16 + 4] * 2;
+      out2[i*16 + 5] = in2[i*16 + 5] * 3;
+      out2[i*16 + 6] = in2[i*16 + 6] * 2;
+      out2[i*16 + 7] = in2[i*16 + 7] * 4;
+      out2[i*16 + 8] = in2[i*16 + 8] * 2;
+      out2[i*16 + 9] = in2[i*16 + 9] * 5;
+      out2[i*16 + 10] = in2[i*16 + 10] * 2;
+      out2[i*16 + 11] = in2[i*16 + 11] * 3;
+      out2[i*16 + 12] = in2[i*16 + 12] * 4;
+      out2[i*16 + 13] = in2[i*16 + 13] * 4;
+      out2[i*16 + 14] = in2[i*16 + 14] * 3;
+      out2[i*16 + 15] = in2[i*16 + 15] * 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out2[i*16] !=  in2[i*16] * 2
+         || out2[i*16 + 1] != in2[i*16 + 1] * 3
+         || out2[i*16 + 2] != in2[i*16 + 2] * 4
+         || out2[i*16 + 3] != in2[i*16 + 3] * 3
+         || out2[i*16 + 4] != in2[i*16 + 4] * 2
+         || out2[i*16 + 5] != in2[i*16 + 5] * 3
+         || out2[i*16 + 6] != in2[i*16 + 6] * 2
+         || out2[i*16 + 7] != in2[i*16 + 7] * 4
+         || out2[i*16 + 8] != in2[i*16 + 8] * 2
+         || out2[i*16 + 9] != in2[i*16 + 9] * 5
+         || out2[i*16 + 10] != in2[i*16 + 10] * 2
+         || out2[i*16 + 11] != in2[i*16 + 11] * 3
+         || out2[i*16 + 12] != in2[i*16 + 12] * 4
+         || out2[i*16 + 13] != in2[i*16 + 13] * 4
+         || out2[i*16 + 14] != in2[i*16 + 14] * 3
+         || out2[i*16 + 15] != in2[i*16 + 15] * 2)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  { target vect_short_mult } } }*/
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  { target { ! { vect_short_mult } } } } }*/
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  { target vect_short_mult } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  { target { ! { vect_short_mult } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+ 
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-8.c
new file mode 100644
index 000000000..76db4e1c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-8.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+int main1 ()
+{
+  int i;
+  float fa[N];
+
+  /* int -> float */
+  for (i = 0; i < N/4; i++)
+    {
+      fa[4*i] = (float) ib[4*i];	
+      fa[4*i + 1] = (float) ib[4*i + 1];	
+      fa[4*i + 2] = (float) ib[4*i + 2];	
+      fa[4*i + 3] = (float) ib[4*i + 3];	
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/4; i++)
+    {
+      if (fa[4*i] != (float) ib[4*i]      
+          || fa[4*i + 1] != (float) ib[4*i + 1]
+          || fa[4*i + 2] != (float) ib[4*i + 2]
+          || fa[4*i + 3] != (float) ib[4*i + 3])
+        abort (); 
+    }   
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target powerpc*-*-* i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target powerpc*-*-* i?86-*-* x86_64-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-9.c
new file mode 100644
index 000000000..461f32e82
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-9.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+short X[N] __attribute__ ((__aligned__(16)));
+short Y[N] __attribute__ ((__aligned__(16)));
+int result[N];
+
+/* short->int widening-mult */
+int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len/2; i++) {
+    result[2*i] = X[2*i] * Y[2*i];
+    result[2*i+1] = X[2*i+1] * Y[2*i+1];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_hi_to_si } } }*/
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-1.c
new file mode 100644
index 000000000..a3b93b5f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-1.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  unsigned short sout[N*8];
+  unsigned int iout[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      sout[i*4] = 8;
+      sout[i*4 + 1] = 18;
+      sout[i*4 + 2] = 28;
+      sout[i*4 + 3] = 38;
+
+      iout[i*4] = 8;
+      iout[i*4 + 1] = 18;
+      iout[i*4 + 2] = 28;
+      iout[i*4 + 3] = 38;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sout[i*4] != 8 
+         || sout[i*4 + 1] != 18
+         || sout[i*4 + 2] != 28
+         || sout[i*4 + 3] != 38
+         || iout[i*4] != 8
+         || iout[i*4 + 1] != 18
+         || iout[i*4 + 2] != 28
+         || iout[i*4 + 3] != 38)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-10.c
new file mode 100644
index 000000000..28274017d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-10.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+struct s 
+{
+  unsigned char a;
+  unsigned char b;
+};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  struct s out[N*4];
+
+  for (i = 0; i < N*4; i++)
+    {
+      out[i].a = (unsigned char) in[i*2] + 1;
+      out[i].b = (unsigned char) in[i*2 + 1] + 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*4; i++)
+    {
+      if (out[i].a !=  (unsigned char) in[i*2] + 1
+         || out[i].b != (unsigned char) in[i*2 + 1] + 2)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_pack_trunc } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c
new file mode 100644
index 000000000..2a04ce0c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 18 
+
+struct s 
+{
+  int a;
+  int b;
+  int c;
+};
+
+char in[N*3] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  struct s out[N];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i].a = (int) in[i*3] + 1;
+      out[i].b = (int) in[i*3 + 1] + 2;
+      out[i].c = (int) in[i*3 + 2] + 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i].a !=  (int) in[i*3] + 1
+         || out[i].b != (int) in[i*3 + 1] + 2
+         || out[i].c != (int) in[i*3 + 2] + 3)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-12.c
new file mode 100644
index 000000000..5d2140fda
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-12.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  unsigned short sout[N*8];
+  unsigned int iout[N*8];
+  unsigned char cout[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      sout[i*4] = 8;
+      sout[i*4 + 1] = 18;
+      sout[i*4 + 2] = 28;
+      sout[i*4 + 3] = 38;
+
+      iout[i*4] = 8;
+      iout[i*4 + 1] = 18;
+      iout[i*4 + 2] = 28;
+      iout[i*4 + 3] = 38;
+
+      cout[i*4] = 1;
+      cout[i*4 + 1] = 2;
+      cout[i*4 + 2] = 3;
+      cout[i*4 + 3] = 4;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sout[i*4] != 8 
+         || sout[i*4 + 1] != 18
+         || sout[i*4 + 2] != 28
+         || sout[i*4 + 3] != 38
+         || iout[i*4] != 8
+         || iout[i*4 + 1] != 18
+         || iout[i*4 + 2] != 28
+         || iout[i*4 + 3] != 38
+         || cout[i*4] != 1
+         || cout[i*4 + 1] != 2
+         || cout[i*4 + 2] != 3
+         || cout[i*4 + 3] != 4)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-2.c
new file mode 100644
index 000000000..02faec741
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-2.c
@@ -0,0 +1,83 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+__attribute__ ((noinline)) int
+main1 (unsigned short a0, unsigned short a1, unsigned short a2, 
+       unsigned short a3, unsigned short a4, unsigned short a5,
+       unsigned short a6, unsigned short a7, unsigned short a8,
+       unsigned short a9, unsigned short a10, unsigned short a11,
+       unsigned short a12, unsigned short a13, unsigned short a14,
+       unsigned short a15, unsigned char b0, unsigned char b1)
+{
+  int i;
+  unsigned short out[N*16];
+  unsigned char out2[N*16];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*16] = a8;
+      out[i*16 + 1] = a7;
+      out[i*16 + 2] = a1;
+      out[i*16 + 3] = a2;
+      out[i*16 + 4] = a8;
+      out[i*16 + 5] = a5;
+      out[i*16 + 6] = a5;
+      out[i*16 + 7] = a4;
+      out[i*16 + 8] = a12;
+      out[i*16 + 9] = a13;
+      out[i*16 + 10] = a14;
+      out[i*16 + 11] = a15;
+      out[i*16 + 12] = a6;
+      out[i*16 + 13] = a9;
+      out[i*16 + 14] = a0;
+      out[i*16 + 15] = a7;
+
+      out2[i*2] = b1;
+      out2[i*2+1] = b0;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*16] != a8
+          || out[i*16 + 1] != a7
+          || out[i*16 + 2] != a1
+          || out[i*16 + 3] != a2
+          || out[i*16 + 4] != a8
+          || out[i*16 + 5] != a5
+          || out[i*16 + 6] != a5
+          || out[i*16 + 7] != a4
+          || out[i*16 + 8] != a12
+          || out[i*16 + 9] != a13
+          || out[i*16 + 10] != a14
+          || out[i*16 + 11] != a15
+          || out[i*16 + 12] != a6
+          || out[i*16 + 13] != a9
+          || out[i*16 + 14] != a0
+          || out[i*16 + 15] != a7
+          || out2[i*2] != b1
+          || out2[i*2 + 1] != b0)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,20,21);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-3.c
new file mode 100644
index 000000000..926cc28a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-3.c
@@ -0,0 +1,94 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned char in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  unsigned int out[N*8];
+  unsigned char out2[N*8];
+
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*8] = in[i*8] + 5;
+      out[i*8 + 1] = in[i*8 + 1] + 6;
+      out[i*8 + 2] = in[i*8 + 2] + 7;
+      out[i*8 + 3] = in[i*8 + 3] + 8;
+      out[i*8 + 4] = in[i*8 + 4] + 9;
+      out[i*8 + 5] = in[i*8 + 5] + 10;
+      out[i*8 + 6] = in[i*8 + 6] + 11;
+      out[i*8 + 7] = in[i*8 + 7] + 12;
+
+      out2[i*16] = in2[i*16] + 2;
+      out2[i*16 + 1] = in2[i*16 + 1] + 3;
+      out2[i*16 + 2] = in2[i*16 + 2] + 4;
+      out2[i*16 + 3] = in2[i*16 + 3] + 3;
+      out2[i*16 + 4] = in2[i*16 + 4] + 2;
+      out2[i*16 + 5] = in2[i*16 + 5] + 3;
+      out2[i*16 + 6] = in2[i*16 + 6] + 2;
+      out2[i*16 + 7] = in2[i*16 + 7] + 4;
+      out2[i*16 + 8] = in2[i*16 + 8] + 2;
+      out2[i*16 + 9] = in2[i*16 + 9] + 5;
+      out2[i*16 + 10] = in2[i*16 + 10] + 2;
+      out2[i*16 + 11] = in2[i*16 + 11] + 3;
+      out2[i*16 + 12] = in2[i*16 + 12] + 4;
+      out2[i*16 + 13] = in2[i*16 + 13] + 4;
+      out2[i*16 + 14] = in2[i*16 + 14] + 3;
+      out2[i*16 + 15] = in2[i*16 + 15] + 2;
+
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*8] !=  in[i*8] + 5
+         || out[i*8 + 1] != in[i*8 + 1] + 6
+         || out[i*8 + 2] != in[i*8 + 2] + 7
+         || out[i*8 + 3] != in[i*8 + 3] + 8
+         || out[i*8 + 4] != in[i*8 + 4] + 9
+         || out[i*8 + 5] != in[i*8 + 5] + 10
+         || out[i*8 + 6] != in[i*8 + 6] + 11
+         || out[i*8 + 7] != in[i*8 + 7] + 12
+         || out2[i*16] !=  in2[i*16] + 2
+         || out2[i*16 + 1] != in2[i*16 + 1] + 3
+         || out2[i*16 + 2] != in2[i*16 + 2] + 4
+         || out2[i*16 + 3] != in2[i*16 + 3] + 3
+         || out2[i*16 + 4] != in2[i*16 + 4] + 2
+         || out2[i*16 + 5] != in2[i*16 + 5] + 3
+         || out2[i*16 + 6] != in2[i*16 + 6] + 2
+         || out2[i*16 + 7] != in2[i*16 + 7] + 4
+         || out2[i*16 + 8] != in2[i*16 + 8] + 2
+         || out2[i*16 + 9] != in2[i*16 + 9] + 5
+         || out2[i*16 + 10] != in2[i*16 + 10] + 2
+         || out2[i*16 + 11] != in2[i*16 + 11] + 3
+         || out2[i*16 + 12] != in2[i*16 + 12] + 4
+         || out2[i*16 + 13] != in2[i*16 + 13] + 4
+         || out2[i*16 + 14] != in2[i*16 + 14] + 3
+         || out2[i*16 + 15] != in2[i*16 + 15] + 2)
+ 
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { sparc*-*-* && ilp32 } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { xfail { sparc*-*-* && ilp32 } }} } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-4.c
new file mode 100644
index 000000000..770ccfcea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-4.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  int out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = (int) in[i*8] + 1;
+      out[i*8 + 1] = (int) in[i*8 + 1] + 2;
+      out[i*8 + 2] = (int) in[i*8 + 2] + 3;
+      out[i*8 + 3] = (int) in[i*8 + 3] + 4;
+      out[i*8 + 4] = (int) in[i*8 + 4] + 5;
+      out[i*8 + 5] = (int) in[i*8 + 5] + 6;
+      out[i*8 + 6] = (int) in[i*8 + 6] + 7;
+      out[i*8 + 7] = (int) in[i*8 + 7] + 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (int) in[i*8] + 1
+         || out[i*8 + 1] != (int) in[i*8 + 1] + 2
+         || out[i*8 + 2] != (int) in[i*8 + 2] + 3
+         || out[i*8 + 3] != (int) in[i*8 + 3] + 4
+         || out[i*8 + 4] != (int) in[i*8 + 4] + 5
+         || out[i*8 + 5] != (int) in[i*8 + 5] + 6
+         || out[i*8 + 6] != (int) in[i*8 + 6] + 7
+         || out[i*8 + 7] != (int) in[i*8 + 7] + 8)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-5.c
new file mode 100644
index 000000000..869d87dbc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-5.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  int out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = (short) in[i*8] + 1;
+      out[i*8 + 1] = (short) in[i*8 + 1] + 2;
+      out[i*8 + 2] = (short) in[i*8 + 2] + 3;
+      out[i*8 + 3] = (short) in[i*8 + 3] + 4;
+      out[i*8 + 4] = (short) in[i*8 + 4] + 5;
+      out[i*8 + 5] = (short) in[i*8 + 5] + 6;
+      out[i*8 + 6] = (short) in[i*8 + 6] + 7;
+      out[i*8 + 7] = (short) in[i*8 + 7] + 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (short) in[i*8] + 1
+         || out[i*8 + 1] != (short) in[i*8 + 1] + 2
+         || out[i*8 + 2] != (short) in[i*8 + 2] + 3
+         || out[i*8 + 3] != (short) in[i*8 + 3] + 4
+         || out[i*8 + 4] != (short) in[i*8 + 4] + 5
+         || out[i*8 + 5] != (short) in[i*8 + 5] + 6
+         || out[i*8 + 6] != (short) in[i*8 + 6] + 7
+         || out[i*8 + 7] != (short) in[i*8 + 7] + 8)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-6.c
new file mode 100644
index 000000000..34f4f0b84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-6.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  unsigned char out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = (unsigned char) in[i*8] + 1;
+      out[i*8 + 1] = (unsigned char) in[i*8 + 1] + 2;
+      out[i*8 + 2] = (unsigned char) in[i*8 + 2] + 3;
+      out[i*8 + 3] = (unsigned char) in[i*8 + 3] + 4;
+      out[i*8 + 4] = (unsigned char) in[i*8 + 4] + 5;
+      out[i*8 + 5] = (unsigned char) in[i*8 + 5] + 6;
+      out[i*8 + 6] = (unsigned char) in[i*8 + 6] + 7;
+      out[i*8 + 7] = (unsigned char) in[i*8 + 7] + 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (unsigned char) in[i*8] + 1
+         || out[i*8 + 1] != (unsigned char) in[i*8 + 1] + 2
+         || out[i*8 + 2] != (unsigned char) in[i*8 + 2] + 3
+         || out[i*8 + 3] != (unsigned char) in[i*8 + 3] + 4
+         || out[i*8 + 4] != (unsigned char) in[i*8 + 4] + 5
+         || out[i*8 + 5] != (unsigned char) in[i*8 + 5] + 6
+         || out[i*8 + 6] != (unsigned char) in[i*8 + 6] + 7
+         || out[i*8 + 7] != (unsigned char) in[i*8 + 7] + 8)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_pack_trunc } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-7.c
new file mode 100644
index 000000000..8021c4946
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-7.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+char in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  int out[N*8];
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = (int) in[i*8] + 1;
+      out[i*8 + 1] = (int) in[i*8 + 1] + 2;
+      out[i*8 + 2] = (int) in[i*8 + 2] + 3;
+      out[i*8 + 3] = (int) in[i*8 + 3] + 4;
+      out[i*8 + 4] = (int) in[i*8 + 4] + 5;
+      out[i*8 + 5] = (int) in[i*8 + 5] + 6;
+      out[i*8 + 6] = (int) in[i*8 + 6] + 7;
+      out[i*8 + 7] = (int) in[i*8 + 7] + 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  (int) in[i*8] + 1
+         || out[i*8 + 1] != (int) in[i*8 + 1] + 2
+         || out[i*8 + 2] != (int) in[i*8 + 2] + 3
+         || out[i*8 + 3] != (int) in[i*8 + 3] + 4
+         || out[i*8 + 4] != (int) in[i*8 + 4] + 5
+         || out[i*8 + 5] != (int) in[i*8 + 5] + 6
+         || out[i*8 + 6] != (int) in[i*8 + 6] + 7
+         || out[i*8 + 7] != (int) in[i*8 + 7] + 8)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-8.c
new file mode 100644
index 000000000..3d3340ae8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-8.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+char in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  int out[N*8];
+
+  for (i = 0; i < N*4; i++)
+    {
+      out[i*2] = (int) in[i*2] + 1;
+      out[i*2 + 1] = (int) in[i*2 + 1] + 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*4; i++)
+    {
+      if (out[i*2] !=  (int) in[i*2] + 1
+         || out[i*2 + 1] != (int) in[i*2 + 1] + 2)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-9.c
new file mode 100644
index 000000000..7d317e2e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-multitypes-9.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 8 
+
+unsigned int in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  unsigned char out[N*8];
+
+  for (i = 0; i < N*4; i++)
+    {
+      out[i*2] = (unsigned char) in[i*2] + 1;
+      out[i*2 + 1] = (unsigned char) in[i*2 + 1] + 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*4; i++)
+    {
+      if (out[i*2] !=  (unsigned char) in[i*2] + 1
+         || out[i*2 + 1] != (unsigned char) in[i*2 + 1] + 2)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_pack_trunc } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-1.c
new file mode 100644
index 000000000..afd66b634
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-1.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M20 23
+#define M01 1322
+#define M11 13
+#define M21 27271
+#define M02 74
+#define M12 191
+#define M22 500
+
+#define N 16
+
+void foo (unsigned int *__restrict__ pInput, unsigned int *__restrict__ pOutput)
+{
+  unsigned int i, a, b, c;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c;
+       *pOutput++ = M10 * a + M11 * b + M12 * c;
+       *pOutput++ = M20 * a + M21 * b + M22 * c;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  unsigned int input[N], output[N], i;
+  unsigned int check_results[N] = {1470, 395, 28271, 5958, 1655, 111653, 10446, 2915, 195035, 14934, 4175, 278417, 19422, 5435, 361799, 0};
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      if (input[i] > 200)
+        abort();
+      output[i] = 0;
+    }
+
+  foo (input, output);
+
+  for (i = 0; i < N; i++)
+     if (output[i] != check_results[i])
+       abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-2.c
new file mode 100644
index 000000000..a033498d5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-2.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M01 1322
+#define M11 13
+#define M02 74
+#define M12 191
+
+#define N 16
+
+void foo (unsigned int *__restrict__ pInput, unsigned int *__restrict__ pOutput)
+{
+  unsigned int i, a, b;
+
+  for (i = 0; i < N / 2; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+
+       *pOutput++ = M00 * a + M01 * b;
+       *pOutput++ = M10 * a + M11 * b;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  unsigned int input[N], output[N], i;
+  unsigned int check_results[N] = {1322, 13, 4166, 471, 7010, 929, 9854, 1387, 12698, 1845, 15542, 2303, 18386, 2761, 21230, 3219};
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      if (input[i] > 200)
+        abort();
+      output[i] = 0;
+    }
+
+  foo (input, output);
+
+  for (i = 0; i < N; i++)
+    if (output[i] != check_results[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-3.c
new file mode 100644
index 000000000..33c09a6d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-3.c
@@ -0,0 +1,72 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M20 23
+#define M30 237
+#define M01 1322
+#define M11 13
+#define M21 27271
+#define M31 2280
+#define M02 74
+#define M12 191
+#define M22 500
+#define M32 111
+#define M03 134
+#define M13 117
+#define M23 11
+#define M33 771
+
+#define N 16
+
+void foo (unsigned int *__restrict__ pInput, unsigned int *__restrict__ pOutput)
+{
+  unsigned int i, a, b, c, d;
+
+  for (i = 0; i < N / 4; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+       d = *pInput++;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c + M03 * d;
+       *pOutput++ = M10 * a + M11 * b + M12 * c + M13 * d;
+       *pOutput++ = M20 * a + M21 * b + M22 * c + M23 * d;
+       *pOutput++ = M30 * a + M31 * b + M32 * c + M33 * d;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  unsigned int input[N], output[N], i;
+  unsigned int check_results[N] = {1872, 746, 28304, 4815, 8392, 2894, 139524, 18411, 14912, 5042, 250744, 32007, 21432, 7190, 361964, 45603};
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      if (input[i] > 200)
+        abort();
+      output[i] = 0;
+    }
+
+  foo (input, output);
+
+  for (i = 0; i < N - N; i++)
+    if (output[i] != check_results[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-4.c
new file mode 100644
index 000000000..867dfd4aa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-4.c
@@ -0,0 +1,87 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M20 23
+#define M30 237
+#define M40 437
+
+#define M01 1322
+#define M11 13
+#define M21 27271
+#define M31 2280
+#define M41 284
+
+#define M02 74
+#define M12 191
+#define M22 500
+#define M32 111
+#define M42 1114
+
+#define M03 134
+#define M13 117
+#define M23 11
+#define M33 771
+#define M43 71
+
+#define M04 334
+#define M14 147
+#define M24 115
+#define M34 7716
+#define M44 16
+
+#define N 16
+
+void foo (unsigned int *__restrict__ pInput, unsigned int *__restrict__ pOutput)
+{
+  unsigned int i, a, b, c, d, e;
+
+  for (i = 0; i < N / 5; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+       d = *pInput++;
+       e = *pInput++;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c + M03 * d + M04 * e;
+       *pOutput++ = M10 * a + M11 * b + M12 * c + M13 * d + M14 * e;
+       *pOutput++ = M20 * a + M21 * b + M22 * c + M23 * d + M24 * e;
+       *pOutput++ = M30 * a + M31 * b + M32 * c + M33 * d + M34 * e;
+       *pOutput++ = M40 * a + M41 * b + M42 * c + M43 * d + M44 * e;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  unsigned int input[N], output[N], i;
+  unsigned int check_results[N] = {3208, 1334, 28764, 35679, 2789, 13028, 4754, 168364, 91254, 12399, 22848, 8174, 307964, 146829, 22009, 0};
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      if (input[i] > 200)
+        abort();
+      output[i] = 0;
+    }
+
+  foo (input, output);
+
+  for (i = 0; i < N - N; i++)
+    if (output[i] != check_results[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "permutation requires at least three vectors" 1 "vect" { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-5.c
new file mode 100644
index 000000000..e7c9f7fea
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-5.c
@@ -0,0 +1,81 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M20 23
+#define M01 1322
+#define M11 13
+#define M21 27271
+#define M02 74
+#define M12 191
+#define M22 500
+
+#define K00 405
+#define K10 112
+#define K01 4322
+#define K11 135
+
+#define N 16
+
+void foo (int *__restrict__ pInput, int *__restrict__ pOutput,
+          int *__restrict__ pInput2, int *__restrict__ pOutput2)
+{
+  int i, a, b, c, d, e;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+
+       d = *pInput2++;
+       e = *pInput2++;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c;
+       *pOutput++ = M10 * a + M11 * b + M12 * c;
+       *pOutput++ = M20 * a + M21 * b + M22 * c;
+
+       *pOutput2++ = K00 * d + K01 * e;
+       *pOutput2++ = K10 * d + K11 * e;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  int input[N], output[N], i;
+  int check_results[N] = {1470, 395, 28271, 5958, 1655, 111653, 10446, 2915, 195035, 14934, 4175, 278417, 19422, 5435, 361799, 0};
+  int input2[N], output2[N];
+  int check_results2[N] = {4322, 135, 13776, 629, 23230, 1123, 32684, 1617, 42138, 2111, 0, 0, 0, 0, 0, 0};
+
+  check_vect ();
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      input2[i] = i%256;
+      output[i] = 0;
+      output2[i] = 0;
+      if (input[i] > 256)
+        abort ();
+    }
+
+  foo (input, output, input2, output2);
+
+  for (i = 0; i < N; i++)
+     if (output[i] != check_results[i] || output2[i] != check_results2[i])
+       abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-6.c
new file mode 100644
index 000000000..430415c5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-6.c
@@ -0,0 +1,79 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M20 23
+#define M01 1322
+#define M11 13
+#define M21 27271
+#define M02 74
+#define M12 191
+#define M22 500
+
+#define K00 405
+#define K10 112
+#define K01 4322
+#define K11 135
+
+#define N 16
+
+void foo (int *__restrict__ pInput, int *__restrict__ pOutput,
+          int *__restrict__ pInput2, int *__restrict__ pOutput2)
+{
+  int i, a, b, c, d, e;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+
+       d = *pInput2++;
+       e = *pInput2++;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c;
+       *pOutput++ = M10 * a + M11 * b + M12 * c;
+       *pOutput++ = M20 * a + M21 * b + M22 * c;
+
+       /* Regular SLP - no permutation required.  */
+       *pOutput2++ = K00 * d;
+       *pOutput2++ = K10 * e;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  int input[N], output[N], i;
+  int check_results[N] = {1470, 395, 28271, 5958, 1655, 111653, 10446, 2915, 195035, 14934, 4175, 278417, 19422, 5435, 361799, 0};
+  int input2[N], output2[N];
+  int check_results2[N] = {0, 112, 810, 336, 1620, 560, 2430, 784, 3240, 1008, 0, 0, 0, 0, 0, 0};
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      input2[i] = i%256;
+      output[i] = 0;
+      output2[i] = 0;
+      if (input[i] > 256)
+        abort ();
+    }
+
+  foo (input, output, input2, output2);
+
+  for (i = 0; i < N; i++)
+     if (output[i] != check_results[i] || output2[i] != check_results2[i])
+       abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-7.c
new file mode 100644
index 000000000..664a0f084
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-7.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define M00 100
+#define M10 216
+#define M20 23
+#define M01 1322
+#define M11 13
+#define M21 27271
+#define M02 74
+#define M12 191
+#define M22 500
+
+#define K00 405
+#define K10 112
+#define K01 4322
+#define K11 135
+
+#define N 16
+
+/* SLP with load permutation and loop-based vectorization.  */
+void foo (int *__restrict__ pInput, int *__restrict__ pOutput,
+          int *__restrict__ pInput2, int *__restrict__ pOutput2)
+{
+  int i, a, b, c, d;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+       d = *pInput2++;
+
+       *pOutput++ = M00 * a + M01 * b + M02 * c;
+       *pOutput++ = M10 * a + M11 * b + M12 * c;
+       *pOutput++ = M20 * a + M21 * b + M22 * c;
+
+       /* Loop-based vectorization.  */
+       *pOutput2++ = K00 * d;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  int input[N], output[N], i;
+  int check_results[N] = {1470, 395, 28271, 5958, 1655, 111653, 10446, 2915, 195035, 14934, 4175, 278417, 19422, 5435, 361799, 0};
+  int input2[N], output2[N];
+  int check_results2[N] = {0, 405, 810, 1215, 1620, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i%256;
+      input2[i] = i%256;
+      output[i] = 0;
+      output2[i] = 0;
+      if (input[i] > 200)
+        abort ();
+    }
+
+  foo (input, output, input2, output2);
+
+  for (i = 0; i < N; i++)
+     if (output[i] != check_results[i] || output2[i] != check_results2[i])
+       abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-8.c
new file mode 100644
index 000000000..28c3529c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-8.c
@@ -0,0 +1,59 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 200
+
+void foo (unsigned char *__restrict__ pInput, unsigned char *__restrict__ pOutput)
+{
+  unsigned char i, a, b, c;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+
+       *pOutput++ = a + b + c + 3;
+       *pOutput++ = a + b + c + 12;
+       *pOutput++ = a + b + c + 1;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  unsigned char input[N], output[N], i;
+  unsigned char check_results[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i;
+      output[i] = 0;
+      if (input[i] > 256)
+        abort ();
+    }
+
+  for (i = 0; i < N / 3; i++)
+    {
+      check_results[3*i] = 9 * i + 6;
+      check_results[3*i+1] = 9 * i + 15;
+      check_results[3*i+2] = 9 * i + 4;
+    }
+
+  foo (input, output);
+
+  for (i = 0; i < N - (N % 3); i++)
+     if (output[i] != check_results[i])
+       abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_perm } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-9.c
new file mode 100644
index 000000000..5c5176e71
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-perm-9.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 200
+
+void foo (unsigned short *__restrict__ pInput, unsigned short *__restrict__ pOutput)
+{
+  unsigned short i, a, b, c;
+
+  for (i = 0; i < N / 3; i++)
+    {
+       a = *pInput++;
+       b = *pInput++;
+       c = *pInput++;
+
+       *pOutput++ = a + b + c + 3;
+       *pOutput++ = a + b + c + 12;
+       *pOutput++ = a + b + c + 1;
+    }
+}
+
+int main (int argc, const char* argv[])
+{
+  unsigned short input[N], output[N], i;
+  unsigned short check_results[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      input[i] = i;
+      output[i] = 0;
+      if (input[i] > 256)
+        abort ();
+    }
+
+  for (i = 0; i < N / 3; i++)
+    {
+      check_results[3*i] = 9 * i + 6;
+      check_results[3*i+1] = 9 * i + 15;
+      check_results[3*i+2] = 9 * i + 4;
+    }
+
+  foo (input, output);
+
+  for (i = 0; i < N - (N % 3); i++)
+     if (output[i] != check_results[i])
+       abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "permutation requires at least three vectors" 1 "vect" { target vect_perm } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-widen-mult-s16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-widen-mult-s16.c
new file mode 100644
index 000000000..a60420b41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-widen-mult-s16.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+short X[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+short Y[N] __attribute__ ((__aligned__(16))) = {64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+
+int result[N];
+
+/* short->int widening-mult */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len/2; i++) {
+    result[2*i] = X[2*i] * Y[2*i];
+    result[2*i+1] = X[2*i+1] * Y[2*i+1];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_hi_to_si || vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target { vect_widen_mult_hi_to_si || vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-widen-mult-u8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-widen-mult-u8.c
new file mode 100644
index 000000000..bba1a8e92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/slp-widen-mult-u8.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char X[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned char Y[N] __attribute__ ((__aligned__(16))) = {64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+
+unsigned short result[N];
+
+/* char->short widening-mult */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len/2; i++) {
+    result[2*i] = X[2*i] * Y[2*i];
+    result[2*i+1] = X[2*i+1] * Y[2*i+1];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target { vect_widen_mult_hi_to_si || vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/trapv-vect-reduc-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/trapv-vect-reduc-4.c
new file mode 100644
index 000000000..78ff73237
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/trapv-vect-reduc-4.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-do compile } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+int main1 (int x, int max_result)
+{
+  int i;
+  int b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  int c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  int diff = 2;
+  int max = x;
+  int min = 10;
+
+  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 != 0)
+    abort ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100);
+  main1 (0, 15);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/tree-vect.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/tree-vect.h
new file mode 100644
index 000000000..e080a6d35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/tree-vect.h
@@ -0,0 +1,41 @@
+/* Check if system supports SIMD */
+#include <signal.h>
+
+extern void abort (void);
+extern void exit (int);
+
+void
+sig_ill_handler (int sig)
+{
+  exit(0);
+}
+
+void check_vect (void)
+{
+  signal(SIGILL, sig_ill_handler);
+#if defined(__PAIRED__)
+  /* 750CL paired-single instruction, 'ps_mul %v0,%v0,%v0'.  */
+ asm volatile (".long 0x10000032");
+#elif defined(__ppc__) || defined(__ppc64__) || defined(__powerpc__) || defined(powerpc)
+  /* Altivec instruction, 'vor %v0,%v0,%v0'.  */
+  asm volatile (".long 0x10000484");
+#elif defined(__i386__) || defined(__x86_64__)
+  /* SSE2 instruction: movsd %xmm0,%xmm0 */
+  asm volatile (".byte 0xf2,0x0f,0x10,0xc0");
+#elif defined(__sparc__)
+  asm volatile (".word\t0x81b007c0");
+#elif defined(__arm__)
+  {
+    /* On some processors without NEON support, this instruction may
+       be a no-op, on others it may trap, so check that it executes
+       correctly.  */
+    long long a = 0, b = 1;
+    asm ("vorr %P0, %P1, %P2"
+	 : "=w" (a)
+	 : "0" (a), "w" (b));
+    if (a != 1)
+      exit (0);
+  }
+#endif
+  signal (SIGILL, SIG_DFL);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/unswitch-loops-pr26969.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/unswitch-loops-pr26969.c
new file mode 100644
index 000000000..b92a7fb7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/unswitch-loops-pr26969.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+void
+ruby_re_compile_fastmap (char *fastmap, int options)
+{
+  int j;
+  for (j = 0; j < (1 << 8); j++)
+    {
+      if (j != '\n' || (options & 4))
+	fastmap[j] = 1;
+    }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-1.c
new file mode 100644
index 000000000..7a570541c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-1.c
@@ -0,0 +1,91 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#define N 16
+
+void fbar (float *);
+void ibar (int *);
+void sbar (short *);
+
+/* multiple loops */
+
+foo (int n)
+{
+  float a[N+1];
+  float b[N];
+  float c[N];
+  float d[N];
+  int ia[N];
+  int ib[N];
+  int ic[N];
+  int i,j;
+  int diff = 0;
+  char cb[N];
+  char cc[N];
+  char image[N][N];
+  char block[N][N];
+
+  /* Not vectorizable yet (cross-iteration cycle).  */
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    diff += (cb[i] - cc[i]);
+  }
+  ibar (&diff);
+
+
+  /* Not vectorizable yet (outer-loop: not attempted. 
+     inner-loop: cross iteration cycle; multi-dimensional arrays).  */
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    for (i = 0; i < N; i++) {
+      diff += (image[i][j] - block[i][j]);
+    }
+  }
+  ibar (&diff);
+
+
+  /* Vectorizable.  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i];
+  }
+  fbar (a);
+
+
+  /* Vectorizable.  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i] + c[i] + d[i];
+  }
+  fbar (a);
+
+
+  /* Strided access. Vectorizable on platforms that support load of strided 
+     accesses (extract of even/odd vector elements).  */
+  for (i = 0; i < N/2; i++){
+    a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+    d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+  }
+  fbar (a);
+
+
+  /* Vectorizable.  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i] + c[i];
+    d[i] = b[i] + c[i];
+    ia[i] = ib[i] + ic[i];
+  }
+  ibar (ia);
+  fbar (a);
+  fbar (d);
+
+  /* Not vetorizable yet (too conservative dependence test).  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i] + c[i];
+    a[i+1] = b[i] + c[i];
+  }
+  fbar (a);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" { target vect_extract_even_odd_wide } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_extract_even_odd_wide } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-10.c
new file mode 100644
index 000000000..903db3e24
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-10.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#define N 16
+
+short a[N];
+short d[N];
+
+int foo ()
+{
+  int i;
+  short b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  short c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+
+  /* Not vectorizable yet (strided access pattern).  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+      d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+    } 
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-100.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-100.c
new file mode 100644
index 000000000..9388084dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-100.c
@@ -0,0 +1,80 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+  int a[N];
+  int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,0};
+
+__attribute__ ((noinline))
+int main1 () {
+  int i;
+  struct extraction *p;
+  
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  /* Vectorizable: alias analysis determines that p can't point to a and/or b.  */
+  for (i = 0; i < N; i++)
+    {
+      p->a[i] = a[i];
+      p->b[i] = b[i];
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (p->a[i] != a[i] || p->b[i] != b[i])
+         abort();
+    }
+
+  return 0;
+}
+
+__attribute__ ((noinline))
+int main2 () {
+  int i;
+  int c[N] = {1,2,3,4,5,6,7,8,9};
+  int d[N] = {2,3,4,5,6,7,8,9,0};
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  /* Vectorizable: c and d are local arrays.  */
+  for (i = 0; i < N; i++)
+    {
+      p->a[i] = c[i];
+      p->b[i] = d[i];
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (p->a[i] != c[i] || p->b[i] != d[i])
+         abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  main1 ();
+  main2 ();
+  
+  return 0;	
+}
+
+/* Requires versioning.  */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-103.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-103.c
new file mode 100644
index 000000000..108f56d37
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-103.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+  int a[N];
+  int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {17,24,7,0,2,3,4,31,82};
+static int c[N] = {9,17,24,7,0,2,3,4,31};
+volatile int foo;
+
+__attribute__ ((noinline))
+int main1 (int x, int y) {
+  int i;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  for (i = 0; i < N; i++)
+    {
+       p->a[i] = a[i];
+       p->b[i] = b[i];
+       if (foo == 135)
+	 abort (); /* to avoid vectorization  */
+    }
+
+  /* Vectorizable: distance > VF.  */
+  for (i = 0; i < N; i++)
+    {
+       *((int *)p + x + i) = *((int *)p + x + i + 8);
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (p->a[i] != c[i])
+         abort();
+    }
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  foo = 0;
+  return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "dependence distance modulo vf == 0" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-104.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-104.c
new file mode 100644
index 000000000..5ea2f801a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-104.c
@@ -0,0 +1,69 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 3
+
+struct extraction
+{
+  int a[N][N];
+  int b[N][N];
+};
+
+static int a[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
+static int b[N][N] = {{17,24,7},{0,2,3},{4,31,82}};
+static int c[N][N] = {{1,2,3},{4,5,5},{5,5,5}};
+volatile int foo;
+
+__attribute__ ((noinline))
+int main1 (int x) {
+  int i,j;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       p->a[i][j] = a[i][j];
+       p->b[i][j] = b[i][j];
+       if (foo == 135)
+	 abort (); /* to avoid vectorization  */
+     }
+   }
+
+  /* Not vectorizable: distance = 1.  */
+  for (i = 1; i < N; i++)
+  {
+    for (j = 0; j < N; j++)
+    {
+       *((int *)p + x + i + j + 1) = *((int *)p + x + i + j);
+    }
+  }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       if (p->a[i][j] != c[i][j])
+         abort();
+     }
+  }
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  foo = 0;
+  return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-105.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-105.c
new file mode 100644
index 000000000..bbf42af89
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-105.c
@@ -0,0 +1,72 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 4
+
+struct extraction
+{
+  int a[N][N];
+  int b[N][N];
+};
+
+static int a[N][N] = {{1,2,3,11},{4,5,6,12},{7,8,9,13},{34,45,67,83}};
+static int b[N][N] = {{17,28,15,23},{0,2,3,24},{4,31,82,25},{29,31,432,256}};
+static int c[N][N] = {{1,2,3,11},{4,9,13,34},{45,67,83,13},{34,45,67,83}};
+
+volatile int y;
+
+__attribute__ ((noinline))
+int main1 (int x) {
+  int i,j;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       p->a[i][j] = a[i][j];
+       p->b[i][j] = b[i][j];
+       /* Because Y is volatile, the compiler cannot move this check out
+	  of the loop.  */
+       if (y)
+	 abort (); /* to avoid vectorization  */
+     }
+   }
+
+  /* Vectorizable: distance > number of iterations.  */
+  for (i = 1; i < N; i++)
+  {
+    for (j = 0; j < N; j++)
+    {
+       *((int *)p + x + i + j) = *((int *)p + x + i + j + 5);
+    }
+  }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       if (p->a[i][j] != c[i][j])
+         abort();
+     }
+  }
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-106.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-106.c
new file mode 100644
index 000000000..d578d8143
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-106.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,0};
+
+__attribute__ ((noinline))
+int main1 () {
+  int i;
+  int *p, *q, *p1, *q1;
+  p = (unsigned int *) malloc (sizeof (unsigned int) * N);
+  q = (unsigned int *) malloc (sizeof (unsigned int) * N);
+
+  p1 = p; q1 = q;
+
+  /* Vectorizable, before pointer plus we would get a redundant cast
+     (caused by pointer arithmetics), alias analysis fails to distinguish
+     between the pointers.  */
+  for (i = 0; i < N; i++)
+    {
+      *(q + i) = a[i];
+      *(p + i) = b[i];
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (*q != a[i] || *p != b[i])
+         abort();
+       q++; 
+       p++;
+    }
+  
+  q = q1;
+  p = p1;
+  /* Vectorizable.  */ 
+  for (i = 0; i < N; i++)
+    {
+      *q = b[i];
+      *p = a[i];
+      q++;
+      p++;
+    }
+
+  q = q1;
+  p = p1;
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (*q != b[i] || *p != a[i])
+         abort();
+       q++;
+       p++;
+    }
+
+  return 0; 
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-107.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-107.c
new file mode 100644
index 000000000..201d4ab4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-107.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N];
+
+  /* Strided access. Vectorizable on platforms that support load of strided 
+     accesses (extract of even/odd vector elements).  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+      d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (a[i] != b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i]
+	  || d[i] != b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i])
+	abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_extract_even_odd_wide } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail vect_extract_even_odd_wide } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-108.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-108.c
new file mode 100644
index 000000000..28e85b2e9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-108.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_int_mult } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N];
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+
+  /* This loop is vectorized on platforms that support vect_int_mult.  */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] * ic[i];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] * ic[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-109.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-109.c
new file mode 100644
index 000000000..d4e017f1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-109.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+short sa[N];
+short sc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
+		16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+short sb[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
+		16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+int ia[N];
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
+	       0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
+	       0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+__attribute__ ((noinline)) 
+int main1 (int n)
+{
+  int i;
+
+  /* Multiple types with different sizes, used in idependent
+     copmutations. Vectorizable.  */
+  for (i = 0; i < n; i++)
+    {
+      sa[i+2] = sb[i] + sc[i];
+      ia[i+1] = ib[i] + ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (sa[i+2] != sb[i] + sc[i] || ia[i+1] != ib[i] + ic[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main2 (int n)
+{
+  int i;
+
+  /* Multiple types with different sizes, used in idependent
+     copmutations. Vectorizable.  */
+  for (i = 0; i < n; i++)
+    {
+      ia[i+1] = ib[i] + ic[i];
+      sa[i] = sb[i] + sc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (sa[i] != sb[i] + sc[i] || ia[i+1] != ib[i] + ic[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N-2);
+  main2 (N-1);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 2 "vect" } } */
+/* { dg-final { scan-tree-dump-times "not vectorized: unsupported unaligned store" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-11.c
new file mode 100644
index 000000000..3df8f47b5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-11.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_int_mult } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int ia[N];
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline)) 
+int main1 ()
+{
+  int i;
+
+  /* Not vectorizable yet (integer mult).  */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] * ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] * ic[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-110.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-110.c
new file mode 100644
index 000000000..b62ad94fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-110.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+static __attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N];
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+  /* Too conservative dependence test.  */
+  for (i = 0; i < N - 1; i++){
+    a[i] = b[i] + c[i];
+    a[i+1] = b[i] + c[i];
+  }
+
+  /* Check results.  */
+  for (i = 0; i < N - 1; i++){
+    if (a[i] != b[i] + c[i])
+	abort ();
+  }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+     
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-112.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-112.c
new file mode 100644
index 000000000..4d954d108
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-112.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+char cb[N] = {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};
+char cc[N] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  int diff = 0;
+
+  /* Cross-iteration cycle.  */
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    diff += (cb[i] - cc[i]);
+  }
+
+  /* Check results.  */
+  if (diff != 16)
+    abort();
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-113.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-113.c
new file mode 100644
index 000000000..0d36c16c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-113.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N];
+
+  /* Induction and type conversion.  */
+  for ( i = 0; i < N; i++) 
+  {
+    a[i] = i;
+  }
+
+  for ( i = 0; i < N; i++) 
+  {
+    if (a[i] != i)
+	abort ();
+  }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target powerpc*-*-* i?86-*-* x86_64-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-114.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-114.c
new file mode 100644
index 000000000..035c9a89c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-114.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N];
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+  /* Reverse access and forward access.  */
+  for (i = N; i > 0; i--)
+    {
+      a[N-i] = b[i-1];
+    }
+
+  /* Check results.  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != b[N-1-i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-115.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-115.c
new file mode 100644
index 000000000..ce6eaf454
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-115.c
@@ -0,0 +1,77 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct s{
+  int b[N];
+  int c[N];
+  int m;
+};
+
+struct t{
+  struct s strc_s;
+  int m;
+};
+
+struct test1{
+  struct t strc_t;
+  struct t *ptr_t;
+  int k;
+  int l;
+};
+
+int a[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  struct test1 tmp1;
+  struct t tmp2;
+
+  tmp1.ptr_t = &tmp2;
+
+  /* DR bases comparison: record and array.  */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.strc_t.strc_s.b[i] = a[i];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.strc_t.strc_s.b[i] != a[i])
+	abort();
+    }
+
+  /* DR bases comparison: record containing ptr and array.  */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.ptr_t->strc_s.c[i] = a[i];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.ptr_t->strc_s.c[i] != a[i])
+	abort();
+    }
+
+    
+  return 0;
+}
+       
+int main (void)
+{
+  check_vect ();
+    
+  return main1 ();
+}
+          
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-116.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-116.c
new file mode 100644
index 000000000..f59e8abf9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-116.c
@@ -0,0 +1,33 @@
+/* { dg-require-effective-target vect_int } */
+/* Assuming we can vectorize char multiplication, here's an execute test.  */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+extern void abort (void);
+
+__attribute__ ((noinline))
+void foo()
+{
+  static unsigned char A[256], B[256], C[256];
+  int i;
+
+  for (i = 0; i < 256; ++i)
+    A[i] = B[i] = i;
+
+  for (i = 0; i < 256; ++i)
+    C[i] = A[i] * B[i];
+
+  for (i = 0; i < 256; ++i)
+    if (C[i] != (unsigned char)(i * i))
+      abort ();
+}
+
+int main()
+{
+  check_vect ();
+  foo();
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-117.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-117.c
new file mode 100644
index 000000000..920e29314
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-117.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 5
+
+static  int a[N][N] = {{ 1, 2, 3, 4, 5},
+		       { 6, 7, 8, 9,10},
+		       {11,12,13,14,15},
+		       {16,17,18,19,20},
+		       {21,22,23,24,25}};
+
+static  int c[N][N] = {{ 1, 2, 3, 4, 5},
+		       { 7, 9,11, 13,15},
+		       {18,21,24,27,30},
+		       {34,38,42,46,50},
+		       {55,60,65,70,75}};
+
+volatile int foo;
+
+__attribute__ ((noinline))
+int main1 (int A[N][N], int n) 
+{
+
+  int i,j;
+
+  /* vectorizable */
+  for (i = 1; i < N; i++)
+  {
+    for (j = 0; j < n; j++)
+    {
+      A[i][j] = A[i-1][j] + A[i][j];
+    }
+  }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  int i,j;
+
+  check_vect ();
+
+  foo = 0;
+  main1 (a, N);
+
+  /* check results: */
+
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       if (a[i][j] != c[i][j])
+         abort();
+     }
+  }
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-11a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-11a.c
new file mode 100644
index 000000000..2da903b1b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-11a.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_int_mult } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+extern void abort (void);
+
+unsigned int A[8] = {0x08000000,0xffffffff,0xff0000ff,0xf0000001,
+		     0x08000000,0xffffffff,0xff0000ff,0xf0000001};
+unsigned int B[8] = {0x08000000,0x08000001,0xff0000ff,0xf0000001,
+		     0x08000000,0x08000001,0xff0000ff,0xf0000001};
+unsigned int Answer[8] = {0,0xf7ffffff,0x0200fe01,0xe0000001,
+			  0,0xf7ffffff,0x0200fe01,0xe0000001};
+unsigned int C[8];
+
+__attribute__ ((noinline))
+void u ()
+{  
+  int i, j;
+  
+  for (i=0; i<8; i++)
+    C[i] = A[i] * B[i];
+  for (i=0; i<8; i++)
+    if (C[i] != Answer[i])
+      abort ();
+}
+
+signed int D[8] = {0x08000000,0xffffffff,0xff0000ff,0xf0000001,
+		   0x08000000,0xffffffff,0xff0000ff,0xf0000001};
+signed int E[8] = {0x08000000,0x08000001,0xff0000ff,0xf0000001,
+		   0x08000000,0x08000001,0xff0000ff,0xf0000001};
+signed int Dnswer[8] = {0,0xf7ffffff,0x0200fe01, 0xe0000001,
+			0,0xf7ffffff,0x0200fe01, 0xe0000001};
+signed int F[8];
+
+__attribute__ ((noinline))
+void s()
+{
+  int i, j;
+  
+  for (i=0; i<8; i++)
+    F[i] = D[i] * E[i];
+  for (i=0; i<8; i++)
+    if (F[i] != Dnswer[i])
+      abort ();
+}
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  u();
+  s();
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-12.c
new file mode 100644
index 000000000..e3d35cca0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-12.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  int ia[N];
+  int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  short sa[N];
+  short sc[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  short sb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+  /* Not vectorizable yet (multiple types with different nunits in vector).  */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] + ic[i];
+      sa[i] = sb[i] + sc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] + ic[i] || sa[i] != sb[i] + sc[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-13.c
new file mode 100644
index 000000000..ba8665bdc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-13.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int a[N];
+int results[N] = {0,1,2,3,0,0,0,0,0,0,0,0,12,13,14,15};
+int b[N] = {0,1,2,3,-4,-5,-6,-7,-8,-9,-10,-11,12,13,14,15};
+
+__attribute__ ((noinline))
+int main1()
+{
+  int i;
+
+  /* Max pattern.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = (b[i] >= 0 ? b[i] : 0);
+    }
+
+  /* Check results  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != results[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-14.c
new file mode 100644
index 000000000..35e48cc36
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-14.c
@@ -0,0 +1,37 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  int ia[N];
+
+  /* Induction.  */
+  for ( i = 0; i < N; i++) {
+    ia[i] = i;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != i)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-15.c
new file mode 100644
index 000000000..b2ae9c847
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-15.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  int a[N];
+  int b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+  /* Not vectorizable yet (reverse access and forward access).  */
+  for (i = N; i > 0; i--)
+    {
+      a[N-i] = b[i-1];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != b[N-1-i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-16.c
new file mode 100644
index 000000000..698370529
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-16.c
@@ -0,0 +1,38 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 240
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  float diff;
+
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    diff += (b[i] - c[i]);
+  }
+
+  /* check results:  */
+  if (diff != DIFF)
+    abort ();
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* Requires fast-math.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-17.c
new file mode 100644
index 000000000..f1bef7f49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-17.c
@@ -0,0 +1,129 @@
+/* { dg-require-effective-target vect_int } */
+  
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  int ic[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char ca[N];
+  char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char cc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] & ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != ib[i] & ic[i])
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i] & cc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != cb[i] & cc[i])
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = sb[i] & sc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != sb[i] & sc[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_bitwise } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-18.c
new file mode 100644
index 000000000..8a2baab3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-18.c
@@ -0,0 +1,128 @@
+/* { dg-require-effective-target vect_int } */
+  
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+  int ic[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char ca[N];
+  char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char cc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = (ib[i] | ic[i]);
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != (ib[i] | ic[i]))
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = (cb[i] | cc[i]);
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != (cb[i] | cc[i]))
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = (sb[i] | sc[i]);
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != (sb[i] | sc[i]))
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_bitwise } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-19.c
new file mode 100644
index 000000000..022ba1f75
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-19.c
@@ -0,0 +1,128 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+  int ic[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char ca[N];
+  char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char cc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] ^ ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != ib[i] ^ ic[i])
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i] ^ cc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != cb[i] ^ cc[i])
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = sb[i] ^ sc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != sb[i] ^ sc[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_bitwise } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-2.c
new file mode 100644
index 000000000..5d4fc914a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-2.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char ca[N];
+
+__attribute__ ((noinline)) 
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-20.c
new file mode 100644
index 000000000..deed2da44
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-20.c
@@ -0,0 +1,100 @@
+/* { dg-require-effective-target vect_int } */
+  
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  signed char ca[N];
+  signed char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ~ib[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != ~ib[i])
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = ~cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != ~cb[i])
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = ~sb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != ~sb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_bitwise } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-21.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-21.c
new file mode 100644
index 000000000..7a57506a2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-21.c
@@ -0,0 +1,129 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+  int ic[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char ca[N];
+  char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char cc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = !ib[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != !ib[i])
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = !cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != !cb[i])
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = !sb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != !sb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-22.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-22.c
new file mode 100644
index 000000000..369fab112
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-22.c
@@ -0,0 +1,126 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  signed char ca[N];
+  signed char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  float fa[N];
+  float fb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = -ib[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != -ib[i])
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = -cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != -cb[i])
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = -sb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != -sb[i])
+        abort ();
+    }
+
+  /* Check floats.  */
+
+  for (i = 0; i < N; i++)
+    {
+      fa[i] = -fb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (fa[i] != -fb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-23.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-23.c
new file mode 100644
index 000000000..7991bb2d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-23.c
@@ -0,0 +1,128 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+  int ic[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char ca[N];
+  char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char cc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] && ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != ib[i] && ic[i])
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i] && cc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != cb[i] && cc[i])
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = sb[i] && sc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != sb[i] && sc[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-24.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-24.c
new file mode 100644
index 000000000..c1ae6b702
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-24.c
@@ -0,0 +1,128 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  int ia[N];
+  int ib[N]= 
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+  int ic[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char ca[N];
+  char cb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  char cc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sa[N];
+  short sb[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  short sc[N] =
+    {1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0,
+     1,1,0,0,1,0,1,0};
+
+  /* Check ints.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = (ib[i] || ic[i]);
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ia[i] != (ib[i] || ic[i]))
+        abort ();
+    }
+
+  /* Check chars.  */
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = (cb[i] || cc[i]);
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (ca[i] != (cb[i] || cc[i]))
+        abort ();
+    }
+
+  /* Check shorts.  */
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = (sb[i] || sc[i]);
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (sa[i] != (sb[i] || sc[i]))
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-25.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-25.c
new file mode 100644
index 000000000..769df4f4f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-25.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 (int n, int *p)
+{
+  int i;
+  int ib[N];
+  int ia[N];
+  int k;
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = n;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != n)
+        abort ();
+    }
+
+  k = *p;
+  for (i = 0; i < N; i++)
+    {
+      ib[i] = k;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ib[i] != k)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  int m = 8;
+
+  check_vect ();
+  
+  return main1 (m, &m);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-26.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-26.c
new file mode 100644
index 000000000..3cb9fb674
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-26.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* unaligned store.  */
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  int ia[N+1];
+
+  for (i = 1; i <= N; i++)
+    {
+      ia[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 1; i <= N; i++)
+    {
+      if (ia[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-27.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-27.c
new file mode 100644
index 000000000..4a2da227e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-27.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* unaligned load.  */
+
+int ia[N];
+int ib[N+1];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i=0; i <= N; i++)
+    {
+      ib[i] = i;
+    }
+
+  for (i = 1; i <= N; i++)
+    {
+      ia[i-1] = ib[i];
+    }
+
+  /* check results:  */
+  for (i = 1; i <= N; i++)
+    {
+      if (ia[i-1] != ib[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* The initialization induction loop (with aligned access) is also vectorized.  */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-28.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-28.c
new file mode 100644
index 000000000..e698eef93
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-28.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+#define OFF 3
+
+/* unaligned store.  */
+
+__attribute__ ((noinline))
+int main1 (int off)
+{
+  int i;
+  int ia[N+OFF];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i+off] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i+off] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (0); /* aligned */
+  main1 (OFF); /* unaligned */
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { ! vector_alignment_reachable } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-29.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-29.c
new file mode 100644
index 000000000..0ad284880
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-29.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+#define OFF 3
+
+/* unaligned load.  */
+
+int ia[N];
+int ib[N+OFF];
+
+__attribute__ ((noinline))
+int main1 (int off)
+{
+  int i;
+
+  for (i = 0; i < N+OFF; i++)
+    {
+      ib[i] = i;
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (0); /* aligned */
+  main1 (OFF); /* unaligned */
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the load.
+   (The store is aligned).  */
+
+/* The initialization induction loop (with aligned access) is also vectorized.  */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" {target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-3.c
new file mode 100644
index 000000000..d494deb85
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-3.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 20
+
+float a[N];
+float e[N];
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N];
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i] + c[i] + d[i];
+      e[i] = b[i] + c[i] + d[i];
+      ia[i] = ib[i] + ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      float fres = b[i] + c[i] + d[i];
+      int ires = ib[i] + ic[i];	
+      if (a[i] != fres || e[i] != fres || ia[i] != ires)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-30.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-30.c
new file mode 100644
index 000000000..408cbca4e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-30.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float b[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+float a[N];
+float c[N];
+
+__attribute__ ((noinline))
+int main1 (int n)
+{
+  int i=0;
+
+  /* Vectorized: unknown loop bound.  */
+  while (n--) {
+    a[i] = b[i];
+    i++;
+  }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (a[i] != b[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+__attribute__ ((noinline))
+int main2 (unsigned int n)
+{
+  int i=0;
+  int nn = n;
+
+  /* Vectorized: unknown loop bound.  */
+  while (n--) {
+    c[i] = b[i];
+    i++;
+  }
+
+  /* check results:  */
+  for (i = 0; i < nn; i++)
+    {
+      if (c[i] != b[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N);
+  main2 (N);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-31.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-31.c
new file mode 100644
index 000000000..8719fc9d2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-31.c
@@ -0,0 +1,90 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+struct t{
+  int k[N];
+  int l; 
+};
+  
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-32.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-32.c
new file mode 100644
index 000000000..c869f5ec9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-32.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  struct {
+    char ca[N];
+  } s;
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-33.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-33.c
new file mode 100644
index 000000000..c1e89c44c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-33.c
@@ -0,0 +1,44 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+struct test {
+  char ca[N];
+};
+
+extern struct test s;
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  return main1 ();
+} 
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { ! vector_alignment_reachable } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-34.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-34.c
new file mode 100644
index 000000000..df18f774e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-34.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct {
+  char ca[N];
+} s;
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-35.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-35.c
new file mode 100644
index 000000000..c6c3bf338
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-35.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  union {
+    unsigned char a[N] __attribute__ ((__aligned__(16)));
+    unsigned char b[N] __attribute__ ((__aligned__(16)));
+  } s;
+  int i;
+
+  /* Initialization.  */
+  for (i = 0; i < N; i++)
+    {
+      s.b[i] = i;
+    }
+
+  /* Dependence analysis fails cause s.a and s.b may overlap.
+     Use runtime aliasing test with versioning.  */
+  for (i = 0; i < N; i++)
+    {
+      s.a[i] = s.b[i] + 1;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.a[i] != i + 1)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence between" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-36.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-36.c
new file mode 100644
index 000000000..bc6232dd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-36.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+  struct {
+    char ca[N];
+    char cb[N];
+  } s;
+
+
+  for (i = 0; i < N; i++)
+    {
+      s.cb[i] = 3*i;
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = s.cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != s.cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-38.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-38.c
new file mode 100644
index 000000000..8df8b5c9b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-38.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+double cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+double ca[N];
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-4.c
new file mode 100644
index 000000000..d86fea11e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-4.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 20
+
+float a[N];
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i] * c[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != b[i] * c[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-40.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-40.c
new file mode 100644
index 000000000..83d8cabcd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-40.c
@@ -0,0 +1,59 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Aligned pointer accesses.
+   The loop bound is known and divisible by the vectorization factor.
+   No aliasing problems.
+   vect-46.c is similar to this one with one difference: 
+        the loop bound is unknown.  */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pa = a;
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  main1 ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"} } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-42.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-42.c
new file mode 100644
index 000000000..324e2f8da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-42.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned write access, aligned read accesses.
+   Since we are handling an unaligned store by peeling the loop,
+   the loads will become unaligned.
+   The loop bound is known and divisible by the vectorization factor.
+   No aliasing problems.  */
+
+__attribute__ ((noinline)) int
+main1 (float * __restrict__ pa)
+{
+  int i;
+  float pb[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float pc[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (a);
+  bar (a,b,c);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { vect_no_align || { ! vector_alignment_reachable } } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align || { ! vector_alignment_reachable } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail {vect_no_align || { ! vector_alignment_reachable } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-44.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-44.c
new file mode 100644
index 000000000..d80df10bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-44.c
@@ -0,0 +1,72 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer accesses, with unknown alignment.
+   The loop bound is known and divisible by the vectorization factor.
+   No aliasing problems.
+   vect-50.c is similar to this one with one difference:
+        the loop bound is unknown.
+   vect-45.c is similar to this one with one difference:
+        can't prove that pointers don't alias.  */
+
+__attribute__ ((noinline)) int
+main1 (float * __restrict__ pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N+4] __attribute__ ((__aligned__(16)));
+  float b[N+4] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69};
+  float c[N+4] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
+
+  check_vect ();
+
+  main1 (a,b,c);
+  main1 (&a[1],b,c);
+  main1 (a,&b[1],c);
+  main1 (&a[1],&b[1],&c[1]);
+
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the 
+   all three accesses (peeling to align the store will not force the
+   two loads to be aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && {! vect_no_align} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-46.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-46.c
new file mode 100644
index 000000000..abe35b401
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-46.c
@@ -0,0 +1,59 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort();
+    }
+
+  return;
+}
+
+/* Aligned pointer accesses.
+   The loop bound is unknown.
+   No aliasing problems.
+   vect-40.c is similar to this one with one difference:
+        the loop bound is known.  */
+
+__attribute__ ((noinline)) int
+main1 (int n)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pa = a;
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  int n=N;
+  check_vect ();
+  main1 (n);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-48.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-48.c
new file mode 100644
index 000000000..011b86863
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-48.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+/* Unaligned pointer read accesses, aligned write access.
+   The loop bound is known and divisible by the vectorization factor.
+   No aliasing problems.
+   vect-56.c is similar to this one with one difference:
+        the alignment of the read accesses is known.
+   vect-52.c is similar to this one with one difference:
+        the loop bound is unknown.
+   vect-49.c is similar to this one with one difference:
+        aliasing is a problem.  */
+
+__attribute__ ((noinline)) int
+main1 (float *pb, float *pc)
+{
+  float pa[N] __attribute__ ((__aligned__(16)));
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float b[N+1] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (b,c);
+  main1 (&b[1],c);
+
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the two loads.
+   (The store is aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-5.c
new file mode 100644
index 000000000..b5938ceae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-5.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float a[N];
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+
+  i = 0;
+  j = 0;
+  while (i < 5*N)
+    {
+      a[j] = c[j];
+      i += 5;
+      j++;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != c[i])
+        abort ();
+    }
+
+
+  for (i = N; i > 0; i--)
+    {
+      a[N-i] = d[N-i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != d[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-50.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-50.c
new file mode 100644
index 000000000..ea4d7ff47
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-50.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+    }
+
+  return;
+}
+
+__attribute__ ((noinline)) int
+main1 (int n, float * __restrict__ pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  bar (pa,pb,pc);
+
+  return 0;
+}
+
+/* Unaligned pointer accesses, with unknown alignment.
+   The loop bound is unknown.
+   No aliasing problems.
+   vect-44.c is similar to this one with one difference:
+        the loop bound is known.  
+   vect-51.c is similar to this one with one difference:
+        can't prove that pointers don't alias.  */
+
+int main (void)
+{
+  int i;
+  float a[N];
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (N,a,b,c);
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the
+   all three accesses (peeling to align the store will not force the
+   two loads to be aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && {! vect_no_align} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-52.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-52.c
new file mode 100644
index 000000000..207e7007c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-52.c
@@ -0,0 +1,61 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+/* Unaligned pointer read accesses, aligned write access.
+   The loop bound is unknown.
+   No aliasing problems.
+   vect-60.c is similar to this one with one difference:
+        the alignment of the read accesses is known.
+   vect-48.c is similar to this one with one difference:
+        the loop bound is known.
+   vect-53.c is similar to this one with one difference:
+        aliasing is a problem.  */
+
+__attribute__ ((noinline)) int
+main1 (int n, float *pb, float *pc)
+{
+  float pa[N] __attribute__ ((__aligned__(16)));
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (pa[i] != (pb[i] * pc[i]))
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N+1] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60};
+  float c[N+1] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+
+  check_vect ();
+
+  main1 (N,&b[1],c);
+  main1 (N,&b[1],&c[1]);
+
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the two loads.
+   (The store is aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-54.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-54.c
new file mode 100644
index 000000000..6e1aa549a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-54.c
@@ -0,0 +1,63 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline)) 
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i+1] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer accesses, with a known alignment.
+   The loop bound is known and divisible by the vectorization factor.
+   No aliasing problems.
+   vect-58.c is similar to this one with one difference:
+        the loop bound is unknown.  */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pa = a;
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < N/2; i++)
+    {
+      pa[i+1] = pb[i+1] * pc[i+1];
+    }
+
+  bar (a,b,c);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-56.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-56.c
new file mode 100644
index 000000000..387bd3ab8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-56.c
@@ -0,0 +1,72 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i] != (pb[i+1] * pc[i+1]))
+        abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer read accesses, aligned write access.
+   The loop bound is known and divisible by the vectorization factor.
+   No aliasing problems.
+   vect-48.c is similar to this one with one difference:
+        the alignment of the read accesses is unknown.
+   vect-60.c is similar to this one with one difference:
+        the loop bound is unknown.
+   vect-57.c is similar to this one with two differences:
+        aliasing is a problem, and the write access has unknown alignment.  */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pa = a;
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < N/2; i++)
+    {
+      pa[i] = pb[i+1] * pc[i+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i] != (pb[i+1] * pc[i+1]))
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-58.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-58.c
new file mode 100644
index 000000000..94cc3efa4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-58.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i+1] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer accesses, with a known alignment.
+   The loop bound is unknown.
+   No aliasing problems.
+   vect-54.c is similar to this one with one difference:
+        the loop bound is known.  */
+
+__attribute__ ((noinline)) int
+main1 (int n)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pa = a;
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < n/2; i++)
+    {
+      pa[i+1] = pb[i+1] * pc[i+1];
+    }
+
+  bar (a,b,c);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  int n=N;
+
+  check_vect ();
+  main1 (n);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-6.c
new file mode 100644
index 000000000..5f2e0ea59
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-6.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float results1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,0.00};
+float results2[N] = {0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
+float a[N] = {0};
+float e[N] = {0};
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i = 0; i < N/2; i++)
+    { 
+      a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+      e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+    }
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      if (a[i] != results1[i] || e[i] != results2[i])
+	abort(); 
+    }
+
+
+  for (i = 1; i <=N-4; i++)
+    {
+      a[i+3] = b[i-1];
+    }
+
+  /* check results:  */
+  for (i = 1; i <=N-4; i++)
+    {
+      if (a[i+3] != b[i-1])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-60.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-60.c
new file mode 100644
index 000000000..97e614c06
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-60.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pa, float *pb, float *pc)
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return;
+}
+
+/* Unaligned pointer read accesses, aligned write access.
+   The loop bound is unknown
+   No aliasing problems.
+   vect-52.c is similar to this one with one difference:
+        the alignment of the read accesses is unknown.
+   vect-56.c is similar to this one with one difference:
+        the loop bound is known.
+   vect-61.c is similar to this one with two differences:
+        aliasing is not a problem, and the write access has unknown alignment.  */
+
+__attribute__ ((noinline)) int
+main1 (int n)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+  float *pa = a;
+  float *pb = b;
+  float *pc = c;
+
+  for (i = 0; i < n/2; i++)
+    {
+      pa[i] = pb[i+1] * pc[i+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (pa[i] != (pb[i+1] * pc[i+1]))
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  int n=N;
+
+  check_vect ();
+  main1 (n);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-62.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-62.c
new file mode 100644
index 000000000..724b646fd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-62.c
@@ -0,0 +1,70 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+  int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  int ia[N][4][N+8];
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Store. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][j+8] = ib[i];
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][j+8] != ib[i])
+              abort();
+        }
+    }
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Vectorizable, but the
+     vectorizer detects that everything is invariant and that
+     the loop is better left untouched. (it should be optimized away). */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][8] = ib[i];
+        }
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][8] != ib[i])
+              abort();
+        }
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-63.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-63.c
new file mode 100644
index 000000000..70628da2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-63.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+  int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  int ia[N*2][4][N];
+
+  /* Multidimensional array. Aligned. 
+     The first dimension depends on j: not vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i + j][1][j] = ib[i];
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i + j][1][j] != ib[i])
+              abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-64.c
new file mode 100644
index 000000000..4f9d97bbb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-64.c
@@ -0,0 +1,86 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+  int ia[N][4][N+1];
+  int ic[N][N][3][13];
+  int id[N][N][N];
+
+  /* Multidimensional array. Not aligned: vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][j] = ib[i];
+        }
+    }
+
+  /* Multidimensional array. Aligned: vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ic[i][1][1][j] = ib[i];
+        }
+    }
+
+  /* Multidimensional array. Not aligned: vectorizable. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           id[i][1][j+1] = ib[i];
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][j] != ib[i])
+              abort();
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ic[i][1][1][j] != ib[i])
+              abort();
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (id[i][1][j+1] != ib[i])
+              abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-65.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-65.c
new file mode 100644
index 000000000..ba3ab3a9b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-65.c
@@ -0,0 +1,83 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define M 4
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+  int ib[M][M][N] = {{{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+		      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
+                     {{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}, 
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}, 
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
+                     {{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}, 
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}, 
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
+                     {{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}, 
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}, 
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
+                      {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}}};
+  int ia[M][M][N];
+  int ic[N];	
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Load and store. */
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][j] = ib[2][i][j];
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][j] != ib[2][i][j])
+              abort();
+        }
+    }
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Load. */
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ic[j] = ib[2][i][j];
+        }
+    }
+
+  /* check results: */
+  for (i = 0; i < M; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ic[j] != ib[2][i][j])
+              abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-66.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-66.c
new file mode 100644
index 000000000..a332fa024
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-66.c
@@ -0,0 +1,96 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+
+__attribute__ ((noinline))
+void main1 ()
+{
+  int i, j;
+  int ia[8][5][N+2];
+
+  /* Multidimensional array. Aligned. */
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[2][6][j] = 5;
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[2][6][j] != 5)
+                abort();
+        }
+    }
+}
+
+__attribute__ ((noinline))
+void main2 ()
+{
+  int i, j;
+  int ia[8][5][N+2];
+
+  /* Multidimensional array. Aligned. */
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+           ia[3][6][j+2] = 5;
+    }
+
+  /* check results: */  
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 2; j < N+2; j++)
+        {
+           if (ia[3][6][j] != 5)
+                abort();
+        }
+    }
+}
+
+__attribute__ ((noinline))
+void main3 ()
+{
+  int i, j;
+  int ic[16][16][5][N+2];
+
+  /* Multidimensional array. Not aligned. */
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ic[2][1][6][j+1] = 5;
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < 16; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ic[2][1][6][j+1] != 5)
+                abort();
+        }
+    }
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  main1 ();
+  main2 ();
+  main3 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-67.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-67.c
new file mode 100644
index 000000000..1ddab5c2e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-67.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 (int a, int b)
+{
+  int i, j;
+  int ia[N][4][N+8];
+
+  /* Multidimensional array. Aligned. The "inner" dimensions
+     are invariant in the inner loop. Store. 
+     Not vectorizable: unsupported operation. */
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           ia[i][1][j+8] = (a == b);
+        }
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+           if (ia[i][1][j+8] != (a == b))
+              abort();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 (2 ,7);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-68.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-68.c
new file mode 100644
index 000000000..c4f8857ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-68.c
@@ -0,0 +1,89 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e; /* array e.n is aligned */
+};
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i,j;
+  struct test1 tmp1;
+
+  /* 1. unaligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.a.n[1][2][i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 5)
+        abort ();
+    }
+
+  /* 2. aligned */
+  for (i = 3; i < N-1; i++)
+    {
+      tmp1.a.n[1][2][i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 3; i < N-1; i++)
+    {
+      if (tmp1.a.n[1][2][i] != 6)
+        abort ();
+    }
+
+  /* 3. aligned */
+  for (i = 0; i < N; i++)
+    {
+      tmp1.e.n[1][2][i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 7)
+        abort ();
+    }
+
+  /* 4. unaligned */
+  for (i = 3; i < N-3; i++)
+    {
+      tmp1.e.n[1][2][i] = 8;
+    }
+ 
+  /* check results:  */
+  for (i = 3; i <N-3; i++)
+    {
+      if (tmp1.e.n[1][2][i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-7.c
new file mode 100644
index 000000000..35dc08bbd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-7.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+short sa[N];
+short sb[N];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  
+  for (i = 0; i < N; i++)
+    {
+      sb[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sb[i] != 5)
+        abort ();
+    }
+  
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = sb[i] + 100;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sa[i] != 105)
+        abort ();
+    }
+  
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* Fails for 32-bit targets that don't vectorize PLUS.  */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-70.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-70.c
new file mode 100644
index 000000000..df7de31f3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-70.c
@@ -0,0 +1,69 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 12
+
+struct s{
+  int m;
+  int n[N][N][N];
+};
+
+struct test1{
+  struct s a; /* array a.n is unaligned */
+  int b;
+  int c;
+  struct s e[N]; /* array e.n is aligned */
+};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i,j;
+  struct test1 tmp1;
+
+  for (i = 0; i < N; i++)
+    for (j = 3; j < N-3; j++)
+      {
+        tmp1.e[i].n[1][2][j] = 8;
+      }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    for (j = 3; j < N-3; j++)
+    {
+      if (tmp1.e[i].n[1][2][j] != 8)
+          abort ();
+    }
+  
+  /* not consecutive */
+  for (i = 0; i < N; i++)
+    for (j = 3; j < N-3; j++)
+      { 
+        tmp1.e[j].n[1][2][j] = 8;
+      }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    for (j = 3; j < N-3; j++)
+    {
+      if (tmp1.e[j].n[1][2][j] != 8)
+          abort ();
+    }
+    
+  return 0;
+}
+       
+int main (void)
+{
+  check_vect ();
+    
+  return main1 ();
+}
+          
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" {target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" {target {! vector_alignment_reachable} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-71.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-71.c
new file mode 100644
index 000000000..7416b4333
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-71.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+/* indirect access.  */
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  unsigned ia[N];
+  unsigned ib[N+1] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2};
+
+  for (i = 2; i < N+1; i++)
+    {
+      ia[ib[i]] = 0;
+    }
+
+  /* check results:  */
+  for (i = 2; i < N+1; i++)
+    {
+      if (ia[ib[i]] != 0)
+        abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-72.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-72.c
new file mode 100644
index 000000000..67a197519
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-72.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* unaligned load.  */
+
+char ia[N];
+char ib[N+1];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i=0; i < N+1; i++)
+    {
+      ib[i] = i;
+      /* Avoid vectorization.  */
+      if (i%3 == 0)
+        ib[i] = 5;
+    }
+
+  for (i = 1; i < N+1; i++)
+    {
+      ia[i-1] = ib[i];
+    }
+
+  /* check results:  */
+  for (i = 1; i <= N; i++)
+    {
+      if (ia[i-1] != ib[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-73.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-73.c
new file mode 100644
index 000000000..ee3c6e60e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-73.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int ic[N*2];
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+#define ia (ic+N)
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+
+  for (i = 0; i < N; i++)
+    {
+       ia[i] = ib[i];
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+       if (ia[i] != ib[i])
+         abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-74.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-74.c
new file mode 100644
index 000000000..e1e2805c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-74.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+float a[N] __attribute__ ((__aligned__(16)));
+float b[N+4] __attribute__ ((__aligned__(16))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0}; 
+float c[N] __attribute__ ((__aligned__(16))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
+
+__attribute__ ((noinline)) int
+main1 (float *__restrict__  pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+  int i;
+  float *q = pb + 4;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = q[i] * pc[i];
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != q[i] * pc[i])
+	abort();
+    }
+  
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  main1 (a, b, c);
+
+  return 0;	
+}
+
+/* Xfail until handling restrict is refined.  See pr29145 */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* Uncomment when this testcase gets vectorized again:    
+ dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" { target vect_no_align } } 
+ dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } 
+ dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } }  
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-75.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-75.c
new file mode 100644
index 000000000..03c1868e4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-75.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+
+__attribute__ ((noinline))
+int main1 (int *ib)
+{
+  int i;
+  int ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+OFF];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+OFF])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-76.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-76.c
new file mode 100644
index 000000000..8a2f7514e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-76.c
@@ -0,0 +1,74 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 12
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+__attribute__ ((noinline))
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+  int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = pib[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != pib[i - OFF])
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = pib[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != pib[i - OFF])
+        abort ();
+    }
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = ic[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != ic[i - OFF])
+        abort ();  
+    }
+
+  return 0;  
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77-alignchecks.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77-alignchecks.c
new file mode 100644
index 000000000..a3d1b4cd6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77-alignchecks.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+
+__attribute__ ((noinline))
+int main1 (int *ib, int off)
+{
+  int i;
+  int ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib, 8);
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the load.
+   The store is aligned if alignment can be forced on the stack. Otherwise, we need to
+   peel the loop in order to align the store. For targets that can't align variables
+   using peeling (don't guarantee natural alignment) versioning the loop is required
+   both for the load and the store.  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail { vect_no_align } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target { {! vect_no_align} && { unaligned_stack && vector_alignment_reachable } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { { {! unaligned_stack} && vect_no_align } || {unaligned_stack && { {! vector_alignment_reachable} && {! vect_no_align} } } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target { { unaligned_stack && { vector_alignment_reachable && vect_no_align } } || {unaligned_stack && { {! vector_alignment_reachable} && vect_no_align } } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77-global.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77-global.c
new file mode 100644
index 000000000..38f1443bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77-global.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+int ia[N];
+
+__attribute__ ((noinline))
+int main1 (int *ib, int off)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib, 8);
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the load.
+   (The store is aligned).  */
+/* Requires versioning for aliasing.  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail { vect_no_align } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77.c
new file mode 100644
index 000000000..a6eb2ad8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-77.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+
+__attribute__ ((noinline))
+int main1 (int *ib, int off)
+{
+  int i;
+  int ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib, 8);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78-alignchecks.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78-alignchecks.c
new file mode 100644
index 000000000..5c97b4109
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78-alignchecks.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+int off = 8;
+
+__attribute__ ((noinline))
+int main1 (int *ib)
+{
+  int i;
+  int ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib);
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the load.
+   The store is aligned if alignment can be forced on the stack. Otherwise, we need to 
+   peel the loop in order to align the store. For targets that can't align variables
+   using peeling (don't guarantee natural alignment) versioning the loop is required
+   both for the load and the store.  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail { vect_no_align } } } } */ 
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target { {! vect_no_align} && { unaligned_stack && vector_alignment_reachable } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { { {! unaligned_stack} && vect_no_align } || {unaligned_stack && { {! vector_alignment_reachable} && {! vect_no_align} } } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 2 "vect" { target { { unaligned_stack && { vector_alignment_reachable && vect_no_align } } || {unaligned_stack && { {! vector_alignment_reachable} && vect_no_align } } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78-global.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78-global.c
new file mode 100644
index 000000000..dccc83903
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78-global.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ia[N];
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+int off = 8;
+
+__attribute__ ((noinline))
+int main1 (int *ib)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib);
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the load.
+   (The store is aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail { vect_no_align } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78.c
new file mode 100644
index 000000000..67ce20fda
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-78.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(16))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
+int off = 8;
+
+__attribute__ ((noinline))
+int main1 (int *ib)
+{
+  int i;
+  int ia[N];
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+off];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+off])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-8.c
new file mode 100644
index 000000000..62f819e04
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-8.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float b[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+float a[N];
+
+__attribute__ ((noinline))
+int main1 (int n)
+{
+  int i;
+
+  /* Vectorized: unknown loop bound).  */
+  for (i = 0; i < n; i++){
+    a[i] = b[i];
+  }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (a[i] != b[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-80.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-80.c
new file mode 100644
index 000000000..beb8d259a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-80.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float fa[N] __attribute__ ((__aligned__(16)));
+float fb[N+4] __attribute__ ((__aligned__(16))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
+float fc[N] __attribute__ ((__aligned__(16))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+__attribute__ ((noinline)) int
+main1 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
+{
+  int i;
+  float *q = pb + 4;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = q[i] * pc[i];
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != q[i] * pc[i])
+	abort();
+    }
+  
+  return 0;
+}
+
+
+int main (void)
+{ 
+  check_vect ();
+
+  main1 (fa, fb, fc);
+
+  return 0;	
+}
+
+/* For targets that don't support misaligned loads we version for the
+   all three accesses (peeling to align the store will not force the
+   two loads to be aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* Uncomment when this testcase gets vectorized again:
+ dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } 
+ dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } } 
+ dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } } 
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-82.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-82.c
new file mode 100644
index 000000000..7fbaa9216
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-82.c
@@ -0,0 +1,37 @@
+/* { dg-skip-if "powerpc and integer vectorization only" { ! { powerpc*-*-* && vect_int } } { "*" } { "" }  } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  long long unsigned int ca[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = 0;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != 0)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-82_64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-82_64.c
new file mode 100644
index 000000000..71de0ce2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-82_64.c
@@ -0,0 +1,39 @@
+/* { dg-do run { target { { powerpc*-*-* && lp64 } && powerpc_altivec_ok } } } */
+/* { dg-do compile { target { { powerpc*-*-* && ilp32 } && powerpc_altivec_ok } } } */
+/* { dg-options "-O2 -ftree-vectorize -mpowerpc64 -fdump-tree-vect-stats -maltivec" } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  long long unsigned int ca[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = 0;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != 0)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-83.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-83.c
new file mode 100644
index 000000000..c031db9df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-83.c
@@ -0,0 +1,37 @@
+/* { dg-skip-if "powerpc and integer vectorization only" { ! { powerpc*-*-* && vect_int } } { "*" } { "" }  } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  long long unsigned int ca[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != 2)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-83_64.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-83_64.c
new file mode 100644
index 000000000..8734a5271
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-83_64.c
@@ -0,0 +1,39 @@
+/* { dg-do run { target { { powerpc*-*-* && lp64 } && powerpc_altivec_ok } } } */
+/* { dg-do compile { target { { powerpc*-*-* && ilp32 } && powerpc_altivec_ok } } } */
+/* { dg-options "-O2 -ftree-vectorize -mpowerpc64 -fdump-tree-vect-stats -maltivec" } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  long long unsigned int ca[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = 2;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != 2)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-85.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-85.c
new file mode 100644
index 000000000..6e8b43e79
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-85.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 (int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+	  k = i + N;
+          a[j] = k;
+        }
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < N; j++)
+    if (a[j] != i + N - 1)
+      abort();	
+
+  for (j = 0; j < N; j++)
+    if (b[j] != j + N)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{ 
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+
+  main1 (a);
+
+  return 0;
+}
+
+/* Fails for targets that don't vectorize PLUS (e.g alpha).  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-86.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-86.c
new file mode 100644
index 000000000..334e54ee4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-86.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int a[N];
+
+__attribute__ ((noinline))
+int main1 (int n)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+        {
+	  k = i + n;
+          a[j] = k;
+        }
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (i = 0; i < n; i++)
+    if (b[i] != i + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  main1 (N);
+  main1 (0);
+  main1 (1);
+  main1 (2);
+  main1 (N-1);
+
+  return 0;
+}
+
+/* Fails for targets that don't vectorize PLUS (e.g alpha).  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-87.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-87.c
new file mode 100644
index 000000000..20a0d2ded
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-87.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+        {
+	  k = i + n;
+          a[j] = k;
+        }
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{ 
+  int a[N] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+
+  main1 (N, a);
+  main1 (0, a);
+  main1 (1, a);
+  main1 (2, a);
+  main1 (N-1, a);
+
+  return 0;
+}
+
+/* Fails for targets that don't vectorize PLUS (e.g alpha).  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" {target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" {target {! vector_alignment_reachable} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-88.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-88.c
new file mode 100644
index 000000000..8c231c092
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-88.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+__attribute__ ((noinline))
+int main1 (int n, int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < n; i++)
+    {
+      for (j = 0; j < n; j++)
+        {
+	  k = i + n;
+          a[j] = k;
+        }
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < n; j++)
+    if (a[j] != i + n - 1)
+      abort();	
+
+  for (j = 0; j < n; j++)
+    if (b[j] != j + n)
+      abort();	
+
+  return 0;
+}
+
+int main (void)
+{ 
+  int a[N+1] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+
+  main1 (N, a+1);
+  main1 (0, a+1);
+  main1 (1, a+1);
+  main1 (2, a+1);
+  main1 (N-1, a+1);
+
+  return 0;
+}
+
+/* Fails for targets that don't vectorize PLUS (e.g alpha).  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" {target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" {target {! vector_alignment_reachable} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-89.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-89.c
new file mode 100644
index 000000000..131efeab5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-89.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct tmp_struct
+{
+  int x;
+  int y[N];
+};
+	 
+__attribute__ ((noinline))
+int main1 ()
+{  
+  int i, *q;
+  struct tmp_struct tmp, *p;
+
+  p = &tmp;
+  q = p->y;
+
+  for (i = 0; i < N; i++)
+    {
+      *q++ = 5;
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+      if (p->y[i] != 5)
+        {
+          abort ();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-9.c
new file mode 100644
index 000000000..c11784a4b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-9.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+short sb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N];
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  /* Requires type promotion (vector unpacking) support.  */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = (int) sb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != (int) sb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-91.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-91.c
new file mode 100644
index 000000000..750736324
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-91.c
@@ -0,0 +1,64 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+extern int a[N];
+
+/* The alignment of 'pa' is unknown. 
+   Yet we do know that both the read access and write access have 
+   the same alignment. Peeling to align one of the accesses will 
+   align the other.  */
+
+__attribute__ ((noinline)) int
+main1 (int * pa)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = pa[i] + 1;
+    }
+
+  return 0;
+}
+
+/* The alignment of 'a' is unknown. 
+   Yet we do know that both the read access and write access have 
+   the same alignment. Peeling to align one of the accesses will 
+   align the other.  */
+
+__attribute__ ((noinline)) int
+main2 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = a[i] + 1;
+    }
+
+  return 0;
+}
+
+__attribute__ ((noinline)) int
+main3 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = a[i+20];
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" { xfail vect_no_int_add } } } */
+/* { dg-final { scan-tree-dump-times "accesses have the same alignment." 3 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 3 "vect" {target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" {target {! vector_alignment_reachable} } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-92.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-92.c
new file mode 100644
index 000000000..94fff9800
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-92.c
@@ -0,0 +1,96 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+float pa[N] __attribute__ ((__aligned__(16)));
+float pb[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+float pc[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+/* Check handling of unaligned accesses when the misalignment is
+   known at compile time and different accesses have the same
+   misalignment (e.g. peeling to align one access will align all
+   accesses with the same misalignment.  Also, the number of 
+   peeled iterations is known in this case, and the vectorizer
+   can use this information (generate prolog and epilog loops
+   with known number of iterations, and only if needed).  */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+
+  for (i = 0; i < 5; i++)
+    {
+      pa[i+1] = pb[i+1] * pc[i+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < 5; i++)
+    {
+      if (pa[i+1] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return 0;
+}
+
+__attribute__ ((noinline)) int
+main2 ()
+{
+  int i;
+
+  for (i = 0; i < 6; i++)
+    {
+      pa[i+1] = pb[i+1] * pc[i+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < 6; i++)
+    {
+      if (pa[i+1] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return 0;
+}
+
+__attribute__ ((noinline)) int
+main3 (int n)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i+1] = pb[i+1] * pc[i+1];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (pa[i+1] != (pb[i+1] * pc[i+1]))
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+  main2 ();
+  main3 (N-1);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 3 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-93.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-93.c
new file mode 100644
index 000000000..b2245c85a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-93.c
@@ -0,0 +1,85 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 3001
+
+
+__attribute__ ((noinline))
+main1 (float *pa)
+{
+  int i;
+
+  for (i = 0; i < 3001; i++)
+    {
+      pa[i] = 2.0;
+    }
+
+  /* check results:  */
+  for (i = 0; i < 3001; i++)
+    {
+      if (pa[i] != 2.0)
+	abort ();
+    }
+
+  for (i = 1; i <= 10; i++)
+    {
+      pa[i] = 3.0;
+    }
+
+  /* check results:  */
+  for (i = 1; i <= 10; i++)
+    {
+      if (pa[i] != 3.0)
+	abort ();
+    }
+  
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float b[N] __attribute__ ((__aligned__(16)));
+
+  check_vect ();
+
+  /* from bzip2: */
+  for (i=0; i<N; i++) b[i] = i;
+  a[0] = 0;
+  for (i = 1; i <= 256; i++) a[i] = b[i-1];
+
+  /* check results:  */
+  for (i = 1; i <= 256; i++)
+    {
+      if (a[i] != i-1)
+	abort ();
+    }
+  if (a[0] != 0)
+    abort ();
+
+  main1 (a);
+
+  return 0;
+}
+
+/* 2 loops vectorized in main1, 2 loops vectorized in main:
+   the first loop in main requires vectorization of conversions,
+   the second loop in main requires vectorization of misaligned load.  */
+
+/* main && main1 together: */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 2 "vect" { target powerpc*-*-* i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" { target { vect_no_align && {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 3 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } } */
+
+/* in main1: */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target !powerpc*-*-* !i?86-*-* !x86_64-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target vect_no_align } } } */
+
+/* in main: */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-95.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-95.c
new file mode 100644
index 000000000..aeb5042ec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-95.c
@@ -0,0 +1,69 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+__attribute__ ((noinline))
+void bar (float *pd, float *pa, float *pb, float *pc) 
+{
+  int i;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != (pb[i] * pc[i]))
+	abort ();
+      if (pd[i] != 5.0)
+	abort ();
+    }
+
+  return;
+}
+
+
+__attribute__ ((noinline)) int
+main1 (int n, float * __restrict__ pd, float * __restrict__ pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+  int i;
+
+  for (i = 0; i < n; i++)
+    {
+      pa[i] = pb[i] * pc[i];
+      pd[i] = 5.0;
+    }
+
+  bar (pd,pa,pb,pc);
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  float a[N] __attribute__ ((__aligned__(16)));
+  float d[N+1] __attribute__ ((__aligned__(16)));
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+  check_vect ();
+
+  main1 (N,&d[1],a,b,c);
+  main1 (N-2,&d[1],a,b,c);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+
+/* For targets that support unaligned loads we version for the two unaligned 
+   stores and generate misaligned accesses for the loads. For targets that 
+   don't support unaligned loads we version for all four accesses.  */
+
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { xfail vect_no_align } } } */
+/*  { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" { target vect_no_align } } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 4 "vect" { target vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-96.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-96.c
new file mode 100644
index 000000000..d92b28d5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-96.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct tmp
+{
+     int x;
+     int ia[N];
+};
+
+__attribute__ ((noinline))
+int main1 (int off)
+{
+  struct tmp sb[N];
+  struct tmp *pp = &sb[off];
+  int i, ib[N];
+
+  for (i = 0; i < N; i++)
+      pp->ia[i] = ib[i];
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+       if (pp->ia[i] != ib[i])
+         abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+
+  return main1 (8);
+}
+
+/* The store is unaligned, the load is aligned. For targets that support unaligned
+   loads, peel to align the store and generate an unaligned access for the load.
+   For targets that don't support unaligned loads, version for the store.  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { target { {! vect_no_align} && vector_alignment_reachable } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { vect_no_align || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { vect_no_align || {! vector_alignment_reachable} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-97.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-97.c
new file mode 100644
index 000000000..c95c503c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-97.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+char x[N] __attribute__ ((__aligned__(16)));
+char cb[N] __attribute__ ((__aligned__(16))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  struct {
+    char *p;
+    char *q;
+  } s;
+  int i;
+
+  /* Check that datarefs analysis can determine that the access via pointer
+     s.p is based off array x, which enables us to antialias this access from
+     the access to array cb.  */
+  s.p = x;
+  for (i = 0; i < N; i++)
+    {
+      s.p[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.p[i] != cb[i])
+        abort ();
+    }
+
+  /* Check that datarefs analysis can determine that the access via pointer
+     s.p is based off array x, and that the access via pointer s.q is based off
+     array cb, which enables us to antialias these two accesses.  */
+  s.q = cb;
+  for (i = 0; i < N; i++)
+    {
+      s.p[i] = s.q[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.p[i] != s.q[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-98.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-98.c
new file mode 100644
index 000000000..118f28fd3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-98.c
@@ -0,0 +1,43 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 4
+#define DOT4( a, b )  ( a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] )
+
+__attribute__ ((noinline))
+int main1 (int ia[][N])
+{
+  int i, j;
+  int ib[N] = {0,3,6,9};
+  int ic[N][N];
+
+  for (i = 0; i < N; i++)
+    {
+	ic[0][i] = DOT4 (ia[i], ib);
+    }
+
+  /* check results: */  
+  for (i = 0; i < N; i++)
+    {
+       if (ic[0][i] != DOT4 (ia[i], ib))
+           abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  int ia[N][N] = {{1,2,3,4},{2,3,5,7},{2,4,6,8},{22,43,55,77}};
+
+  check_vect ();
+
+  return main1 (ia);
+}
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd_wide } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { xfail  { vect_interleave && vect_extract_even_odd_wide } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-99.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-99.c
new file mode 100644
index 000000000..d29023c73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-99.c
@@ -0,0 +1,33 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include "tree-vect.h"
+
+int ca[100];
+
+__attribute__ ((noinline))
+void foo (int n)
+{
+  unsigned int i;
+
+  for (i = 0; i < n; i++)
+    ca[i] = 2;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  foo(100);
+
+  for (i = 0; i < 100; ++i) {
+    if (ca[i] != 2)
+      abort();
+  }
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-align-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-align-1.c
new file mode 100644
index 000000000..f6bf22da9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-align-1.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+/* Compile time known misalignment. Cannot use loop peeling to align
+   the store.  */
+
+#define N 16
+
+struct foo {
+  char x;
+  int y[N];
+} __attribute__((packed));
+
+int x[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+__attribute__ ((noinline)) int
+main1 (struct foo * __restrict__ p)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      p->y[i] = x[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (p->y[i] != x[i])
+	abort ();
+    }
+  return 0;
+}
+
+
+int main (void)
+{
+  int i;
+  struct foo *p = malloc (2*sizeof (struct foo));
+  check_vect ();
+  
+  main1 (p);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-align-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-align-2.c
new file mode 100644
index 000000000..ec2f3eefb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-align-2.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+/* Compile time unknown misalignment. Cannot use loop peeling to align
+   the store.  */
+
+#define N 17
+
+struct foo {
+  char x0;
+  int y[N][N];
+} __attribute__ ((packed));
+
+struct foo f2;
+int z[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+__attribute__ ((noinline))
+void fbar(struct foo *fp)
+{
+  int i,j;
+   for (i=0; i<N; i++)
+      for (j=0; j<N; j++)
+        f2.y[i][j] = z[i];
+
+   for (i=0; i<N; i++)
+      for (j=0; j<N; j++)
+	if (f2.y[i][j] != z[i])
+	  abort ();
+}
+
+int main (void)
+{
+  struct foo  *fp = (struct foo *) malloc (2*sizeof (struct foo));
+
+  check_vect ();
+
+  fbar(fp);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-all.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-all.c
new file mode 100644
index 000000000..6adb7bf88
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-all.c
@@ -0,0 +1,220 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int iadd_results[N] = {0,6,12,18,24,30,36,42,48,54,60,66,72,78,84,90};
+float fadd_results[N] = {0.0,6.0,12.0,18.0,24.0,30.0,36.0,42.0,48.0,54.0,60.0,66.0,72.0,78.0,84.0,90.0};
+float fmul_results[N] = {0.0,3.0,12.0,27.0,48.0,75.0,108.0,147.0,192.0,243.0,300.0,363.0,432.0,507.0,588.0,675.0};
+float fresults1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,48.00,54.00,60.00,66.00,72.00,78.00,84.00,90.00};
+float fresults2[N] = {0.00,6.00,12.00,18.00,24.00,30.00,36.00,42.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
+
+/****************************************************/
+__attribute__ ((noinline))
+void icheck_results (int *a, int *results)
+{
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != results[i])
+	abort ();
+    }
+}
+
+__attribute__ ((noinline))
+void fcheck_results (float *a, float *results)
+{
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != results[i])
+	abort ();
+    }
+}   
+
+__attribute__ ((noinline)) void 
+fbar_mul (float *a)
+{
+  fcheck_results (a, fmul_results);
+} 
+
+__attribute__ ((noinline)) void 
+fbar_add (float *a)
+{
+  fcheck_results (a, fadd_results);
+} 
+
+__attribute__ ((noinline)) void 
+ibar_add (int *a)
+{
+  icheck_results (a, iadd_results);
+} 
+
+__attribute__ ((noinline)) void 
+fbar1 (float *a)
+{
+  fcheck_results (a, fresults1);
+} 
+
+__attribute__ ((noinline)) void 
+fbar2 (float *a)
+{
+  fcheck_results (a, fresults2);
+} 
+
+float a[N];
+float e[N];
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N];
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char ca[N];
+short sa[N];
+
+/* All of the loops below are currently vectorizable.  */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i,j;
+
+  /* Test 1: copy chars.  */
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i];
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != cb[i])
+	abort ();
+    }
+
+
+  /* Test 2: fp mult.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i] * c[i];
+    }
+  fbar_mul (a);
+
+
+  /* Test 3: mixed types (int, fp), same nunits in vector.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i] + c[i] + d[i];
+      e[i] = b[i] + c[i] + d[i];
+      ia[i] = ib[i] + ic[i];
+    }
+  ibar_add (ia);
+  fbar_add (a);
+  fbar_add (e);
+
+
+  /* Test 4: access with offset.  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+      e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+    }
+  fbar1 (a);
+  fbar2 (e);
+
+
+  /* Test 5: access with offset */
+  for (i = 1; i <=N-4; i++)
+    {
+      a[i+3] = b[i-1];
+    }
+  /* check results:  */
+  for (i = 1; i <=N-4; i++)
+    {
+      if (a[i+3] != b[i-1])
+	abort ();
+    }
+
+
+  /* Test 6 - loop induction with stride != 1.  */
+  i = 0;
+  j = 0;
+  while (i < 5*N)
+    {
+      a[j] = c[j];
+      i += 5;
+      j++;
+    }
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != c[i])
+        abort ();
+    }
+
+
+  /* Test 7 - reverse access.  */
+  for (i = N; i > 0; i--)
+    {
+      a[N-i] = d[N-i];
+    }
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != d[i])
+        abort ();
+    }
+
+
+  /* Tests 8,9,10 - constants.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = 5.0;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != 5.0)
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = 5;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sa[i] != 5)
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] + 5;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] + 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-1.c
new file mode 100644
index 000000000..e2d0adcf9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-1.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+_Complex float a[N]  __attribute__ ((__aligned__(16))) =
+    { 10.0F + 20.0iF, 11.0F + 21.0iF, 12.0F + 22.0iF, 13.0F + 23.0iF,
+      14.0F + 24.0iF, 15.0F + 25.0iF, 16.0F + 26.0iF, 17.0F + 27.0iF,
+      18.0F + 28.0iF, 19.0F + 29.0iF, 20.0F + 30.0iF, 21.0F + 31.0iF,
+      22.0F + 32.0iF, 23.0F + 33.0iF, 24.0F + 34.0iF, 25.0F + 35.0iF };
+_Complex float b[N]  __attribute__ ((__aligned__(16))) =
+    { 30.0F + 40.0iF, 31.0F + 41.0iF, 32.0F + 42.0iF, 33.0F + 43.0iF,
+      34.0F + 44.0iF, 35.0F + 45.0iF, 36.0F + 46.0iF, 37.0F + 47.0iF,
+      38.0F + 48.0iF, 39.0F + 49.0iF, 40.0F + 50.0iF, 41.0F + 51.0iF,
+      42.0F + 52.0iF, 43.0F + 53.0iF, 44.0F + 54.0iF, 45.0F + 55.0iF };
+
+_Complex float c[N] __attribute__ ((__aligned__(16)));
+_Complex float res[N] __attribute__ ((__aligned__(16))) =
+    { 40.0F + 60.0iF, 42.0F + 62.0iF, 44.0F + 64.0iF, 46.0F + 66.0iF,
+      48.0F + 68.0iF, 50.0F + 70.0iF, 52.0F + 72.0iF, 54.0F + 74.0iF,
+      56.0F + 76.0iF, 58.0F + 78.0iF, 60.0F + 80.0iF, 62.0F + 82.0iF,
+      64.0F + 84.0iF, 66.0F + 86.0iF, 68.0F + 88.0iF, 70.0F + 90.0iF };
+
+
+__attribute__ ((noinline)) void
+foo (void)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    c[i] = a[i] + b[i];
+
+}
+
+int
+main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  foo ();
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (c[i] != res[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-2.c
new file mode 100644
index 000000000..a034082cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-2.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+_Complex double a[N] =
+    { 10.0F + 20.0iF, 11.0F + 21.0iF, 12.0F + 22.0iF, 13.0F + 23.0iF,
+      14.0F + 24.0iF, 15.0F + 25.0iF, 16.0F + 26.0iF, 17.0F + 27.0iF,
+      18.0F + 28.0iF, 19.0F + 29.0iF, 20.0F + 30.0iF, 21.0F + 31.0iF,
+      22.0F + 32.0iF, 23.0F + 33.0iF, 24.0F + 34.0iF, 25.0F + 35.0iF };
+_Complex double b[N] =
+    { 30.0F + 40.0iF, 31.0F + 41.0iF, 32.0F + 42.0iF, 33.0F + 43.0iF,
+      34.0F + 44.0iF, 35.0F + 45.0iF, 36.0F + 46.0iF, 37.0F + 47.0iF,
+      38.0F + 48.0iF, 39.0F + 49.0iF, 40.0F + 50.0iF, 41.0F + 51.0iF,
+      42.0F + 52.0iF, 43.0F + 53.0iF, 44.0F + 54.0iF, 45.0F + 55.0iF };
+
+_Complex double c[N];
+_Complex double res[N] =
+    { 40.0F + 60.0iF, 42.0F + 62.0iF, 44.0F + 64.0iF, 46.0F + 66.0iF,
+      48.0F + 68.0iF, 50.0F + 70.0iF, 52.0F + 72.0iF, 54.0F + 74.0iF,
+      56.0F + 76.0iF, 58.0F + 78.0iF, 60.0F + 80.0iF, 62.0F + 82.0iF,
+      64.0F + 84.0iF, 66.0F + 86.0iF, 68.0F + 88.0iF, 70.0F + 90.0iF };
+
+
+__attribute__ ((noinline)) void
+foo (void)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    c[i] = a[i] + b[i];
+
+}
+
+int
+main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  foo ();
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (c[i] != res[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-4.c
new file mode 100644
index 000000000..85c416597
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-4.c
@@ -0,0 +1,109 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct foostr {
+  _Complex short f1;
+  _Complex short f2;
+};
+
+struct foostr a[16] __attribute__ ((__aligned__(16))) =
+  {
+    11 + 23i, 24 + 22i,
+    11 + 26i, 24 + 35i,
+    19 + 20i, 29 + 14i,
+    23 + 31i, 26 + 30i,
+    29 + 39i, 24 + 18i,
+    20 + 32i, 16 + 23i,
+    13 + 26i, 37 + 34i,
+    12 + 23i, 26 + 14i,
+    36 + 14i, 31 + 17i,
+    35 + 17i, 17 + 36i,
+    13 + 34i, 19 + 12i,
+    27 + 34i, 36 + 19i,
+    21 + 39i, 16 + 33i,
+    28 + 18i, 39 + 26i,
+    32 + 27i, 13 + 38i,
+    35 + 36i, 34 + 28i,
+  };
+
+struct foostr b[16] __attribute__ ((__aligned__(16))) =
+  {
+    37 + 12i, 23 + 15i,
+    14 + 11i, 13 + 25i,
+    35 + 29i, 22 + 34i,
+    24 + 34i, 16 + 39i,
+    34 + 32i, 26 + 21i,
+    34 + 36i, 11 + 37i,
+    25 + 21i, 10 + 39i,
+    10 + 36i, 35 + 22i,
+    39 + 29i, 23 + 21i,
+    34 + 33i, 39 + 14i,
+    16 + 31i, 32 + 33i,
+    20 + 14i, 35 + 30i,
+    26 + 24i, 36 + 37i,
+    31 + 20i, 32 + 28i,
+    25 + 27i, 15 + 30i,
+    10 + 31i, 37 + 37i,
+  };
+struct foostr c[16] __attribute__ ((__aligned__(16)));
+struct foostr res[N] =
+  {
+    48 + 35i, 47 + 37i,
+    25 + 37i, 37 + 60i,
+    54 + 49i, 51 + 48i,
+    47 + 65i, 42 + 69i,
+    63 + 71i, 50 + 39i,
+    54 + 68i, 27 + 60i,
+    38 + 47i, 47 + 73i,
+    22 + 59i, 61 + 36i,
+    75 + 43i, 54 + 38i,
+    69 + 50i, 56 + 50i,
+    29 + 65i, 51 + 45i,
+    47 + 48i, 71 + 49i,
+    47 + 63i, 52 + 70i,
+    59 + 38i, 71 + 54i,
+    57 + 54i, 28 + 68i,
+    45 + 67i, 71 + 65i,
+  };
+
+__attribute__ ((noinline)) void
+foo (void)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      c[i].f1 = a[i].f1 + b[i].f1;
+      c[i].f2 = a[i].f2 + b[i].f2;
+    }
+
+}
+
+int
+main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  foo ();
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (c[i].f1 != res[i].f1)
+	abort ();
+      if (c[i].f2 != res[i].f2)
+	abort ();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-5.c
new file mode 100644
index 000000000..91eb1f54b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-complex-5.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct foostr {
+  _Complex short f1;
+  _Complex short f2;
+};
+
+_Complex short a1[64] __attribute__ ((__aligned__(16)));
+_Complex short a2[64] __attribute__ ((__aligned__(16)));
+_Complex short b1[64] __attribute__ ((__aligned__(16)));
+_Complex short b2[64] __attribute__ ((__aligned__(16)));
+struct foostr c[64] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo (void)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      c[i].f1 = a1[i] + b1[i];
+      c[i].f2 = a2[i] + b2[i];
+    }
+
+}
+
+int
+main (void)
+{ 
+  int i;
+  check_vect ();
+  
+  foo ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-debug-pr41926.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-debug-pr41926.c
new file mode 100644
index 000000000..6eea84ae1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-debug-pr41926.c
@@ -0,0 +1,20 @@
+/* PR debug/41926 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -g -ffast-math -funroll-loops -ftree-vectorize -msse2" { target { i?86-*-* x86_64-*-* } } } */
+
+void
+foo (double (*__restrict p)[4], double (*__restrict q)[4],
+     double *__restrict prim, double scale, double pp, double pq)
+{
+  int md, mc, mb, ma, p_index = 0;
+
+  for (md = 0; md < 1; md++)
+    for (mc = 0; mc < 1; mc++)
+      for (mb = 0; mb < 1; mb++)
+	for (ma = 0; ma < 4; ma++)
+	  {
+	    double tmp = scale * prim[p_index++];
+	    p[md][ma] = p[md][ma] - tmp * pp;
+	    q[mc][ma] = q[mc][ma] - tmp * pq;
+	  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-dv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-dv-1.c
new file mode 100644
index 000000000..0da4cd978
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-dv-1.c
@@ -0,0 +1,22 @@
+/* Test compiler crash when dependence analyzer can not represent
+   dependence relation by distance vector.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+int x[199];
+
+void foo()
+  
+{
+  int t,j;
+
+  for (j=99;j>0;j--) 
+    x [j+j]=x[j];
+
+  for (j=198;j>=100;j--) 
+    if(x[j]) 
+      {
+	x[j-63]=x[j-3]-x[j];
+      }
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-float-extend-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-float-extend-1.c
new file mode 100644
index 000000000..3035ee392
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-float-extend-1.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+float fb[N] = {0.4,3.5,6.6,9.4,12.5,15.6,18.4,21.5,24.6,27.4,30.5,33.6,36.4,39.5,42.6,45.4,0.5,3.6,6.4,9.5,12.6,15.4,18.5,21.6,24.4,27.5,30.6,33.4,36.5,39.6,42.4,45.5};
+double da[N];
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+
+  /* float -> double */
+  for (i = 0; i < N; i++)
+    {
+      da[i] = (double) fb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (da[i] != (double) fb[i])
+       abort ();
+    }
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail spu*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-float-truncate-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-float-truncate-1.c
new file mode 100644
index 000000000..b7a9b47bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-float-truncate-1.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  double db[N] = {0.4,3.5,6.6,9.4,12.5,15.6,18.4,21.5,24.6,27.4,30.5,33.6,36.4,39.5,42.6,45.4,0.5,3.6,6.4,9.5,12.6,15.4,18.5,21.6,24.4,27.5,30.6,33.4,36.5,39.6,42.4,45.5};
+  float fa[N];
+
+  /* double -> float */
+  for (i = 0; i < N; i++)
+    {
+      fa[i] = (float) db[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (fa[i] != (float) db[i])
+       abort ();
+    }
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail spu*-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-floatint-conversion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-floatint-conversion-1.c
new file mode 100644
index 000000000..e5b72f1ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-floatint-conversion-1.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+float fb[N] = {0.4,3.5,6.6,9.4,12.5,15.6,18.4,21.5,24.6,27.4,30.5,33.6,36.4,39.5,42.6,45.4,0.5,3.6,6.4,9.5,12.6,15.4,18.5,21.6,24.4,27.5,30.6,33.4,36.5,39.6,42.4,45.5};
+int ia[N];
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+
+  /* float -> int */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = (int) fb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != (int) fb[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_floatint_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-floatint-conversion-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-floatint-conversion-2.c
new file mode 100644
index 000000000..683b43c51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-floatint-conversion-2.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  double db[N] = {0.4,3.5,6.6,9.4,12.5,15.6,18.4,21.5,24.6,27.4,30.5,33.6,36.4,39.5,42.6,45.4,0.5,3.6,6.4,9.5,12.6,15.4,18.5,21.6,24.4,27.5,30.6,33.4,36.5,39.6,42.4,45.5};
+  int ia[N];
+
+  /* double -> int */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = (int) db[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != (int) db[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_floatint_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-fold-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-fold-1.c
new file mode 100644
index 000000000..8aca1e420
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-fold-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ccp1" } */
+
+typedef unsigned char v4qi __attribute__ ((vector_size (4)));
+
+v4qi c;
+
+void foo()
+{
+  v4qi a = { 1, 2, 3, 4 };
+  v4qi b = { 5, 6, 7, 8 };
+  c = a + b;
+}
+
+/* { dg-final { scan-tree-dump-times "c =.* { 6, 8, 10, 12 }" 1 "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-10.c
new file mode 100644
index 000000000..8a4b24ed4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-10.c
@@ -0,0 +1,12 @@
+/* PR 21272 */
+/* { dg-do compile } */
+double
+foo (int j, double *v, double x)
+{
+  int i;
+  for (i = 0; i < j; i++)
+    if (v[i] < x)
+      x = v[i];
+  return x;
+}
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-16.c
new file mode 100644
index 000000000..8071c87d0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-16.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+extern void abort(void); 
+
+float A[N] = {36,39,42,45,43,32,21,42,23,34,45,56,67,42,89,11};
+float B[N] = {42,42,0,42,42,42,42,0,42,42,42,42,42,0,42,42};
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] != MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-17.c
new file mode 100644
index 000000000..a02c8984e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-17.c
@@ -0,0 +1,34 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+float A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,42,78,89,11};
+float B[N] = {42,42,0,42,42,42,42,42,42,42,42,42,0,42,42,42};
+
+extern void abort(void);
+
+int main ()
+{
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] == MAX ? 0 : MAX);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-2.c
new file mode 100644
index 000000000..e899f126d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-2.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+int B[N] = {0,0,42,42,42,0,0,0,0,0,42,42,42,42,42,0};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] >= MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-3.c
new file mode 100644
index 000000000..1d8e9f52b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-3.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+int B[N] = {0,0,0,42,42,0,0,0,0,0,42,42,42,42,42,0};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] > MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-4.c
new file mode 100644
index 000000000..1680cba8a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-4.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+int B[N] = {42,42,42,0,0,42,42,42,42,42,0,0,0,0,0,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] <= MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-5.c
new file mode 100644
index 000000000..5fc9674b3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-5.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+int B[N] = {42,42,0,0,0,42,42,42,42,42,0,0,0,0,0,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] < MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-6.c
new file mode 100644
index 000000000..24e8c969e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-6.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,42,23,34,45,56,67,42,89,11};
+int B[N] = {42,42,0,42,42,42,42,0,42,42,42,42,42,0,42,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] != MAX ? MAX : 0); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-7.c
new file mode 100644
index 000000000..fa4cf3a58
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-7.c
@@ -0,0 +1,36 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,42,78,89,11};
+int B[N] = {42,42,0,42,42,42,42,42,42,42,42,42,0,42,42,42};
+
+extern void abort(void); 
+
+int main ()
+{  
+  int i, j;
+
+  check_vect ();
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] == MAX ? 0 : MAX); 
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-9.c
new file mode 100644
index 000000000..50eedb1d4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-ifcvt-9.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_condition } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 16
+#define MAX 42
+
+extern void abort(void); 
+
+int A[N] = {36,39,42,45,43,32,21,12,23,34,45,56,67,78,89,11};
+int B[N] = {0,0,42,42,42,0,0,0,0,0,42,42,42,42,42,0};
+inline void foo ()  __attribute__((always_inline));
+void foo ()
+{  
+  int i, j;
+
+  for (i = 0; i < 16; i++)
+    A[i] = ( A[i] >= MAX ? MAX : 0); 
+}
+
+int main ()
+{
+
+  int i, j;
+  check_vect ();
+  foo ();
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-1.c
new file mode 100644
index 000000000..90f33a508
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-1.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float fa[N];
+
+__attribute__ ((noinline)) int main1 ()
+{
+  int i;
+
+  /* int -> float */
+  for (i = 0; i < N; i++)
+    {
+      fa[i] = (float) ib[i];	
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (fa[i] != (float) ib[i]) 
+        abort (); 
+    }   
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_intfloat_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-2.c
new file mode 100644
index 000000000..87f200119
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-2.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+int int_arr[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float float_arr[N];
+char char_arr[N];
+
+__attribute__ ((noinline)) int main1 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++){
+    float_arr[i] = (float) int_arr[i];
+    char_arr[i] = 0;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (float_arr[i] != (float) int_arr[i]) 
+        abort (); 
+      if (char_arr[i] != 0)
+	abort ();
+    }   
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_intfloat_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-3.c
new file mode 100644
index 000000000..d5f25df71
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-3.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_double } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+double da[N];
+
+__attribute__ ((noinline)) int main1 ()
+{
+  int i;
+
+  /* int -> double */
+  for (i = 0; i < N; i++)
+    {
+      da[i] = (double) ib[i];	
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (da[i] != (double) ib[i]) 
+        abort (); 
+    }   
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_intfloat_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-4a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-4a.c
new file mode 100644
index 000000000..af8344ba6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-4a.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+short sb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,-3,-6,-9,-12,-15,-18,-21,-24,-27,-30,-33,-36,-39,-42,-45};
+float fa[N];
+
+__attribute__ ((noinline)) int main1 ()
+{
+  int i;
+
+  /* short -> float */
+  for (i = 0; i < N; i++)
+    {
+      fa[i] = (float) sb[i];	
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (fa[i] != (float) sb[i]) 
+        abort (); 
+    }   
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_intfloat_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-4b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-4b.c
new file mode 100644
index 000000000..51ea056fa
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-intfloat-conversion-4b.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+unsigned short usb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,65533,65530,65527,65524,65521,65518,65515,65512,65509,65506,65503,65500,65497,65494,65491};
+float fa[N];
+
+__attribute__ ((noinline)) int main1 ()
+{
+  int i;
+
+  /* unsigned short -> float */
+  for (i = 0; i < N; i++)
+    {
+      fa[i] = (float) usb[i];	
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (fa[i] != (float) usb[i]) 
+        abort (); 
+    }   
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_intfloat_cvt } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-1.c
new file mode 100644
index 000000000..5d6ab5cd2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-1.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+int result[N] = {8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38};
+ 
+__attribute__ ((noinline)) int main1 (int X)
+{  
+  int arr[N];
+  int k = X;
+  int m, i=0;
+  
+   /* vectorization of induction.  */
+
+   do { 
+        m = k + 5;
+        arr[i] = m;
+        k = k + 2;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (arr[i] != result[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (3);
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-10.c
new file mode 100644
index 000000000..e4242009b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-10.c
@@ -0,0 +1,35 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int main1 ()
+{
+  int i,j;
+  int ia[N];
+
+  /* Induction.  */
+  for (j=0,i=N;  j<N,i>0;  i--,j++) {
+    ia[j] = i;
+  }
+
+  /* check results:  */
+  for (j=0,i=N;  j<N,i>0;  i--,j++) {
+      if (ia[j] != i)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-11.c
new file mode 100644
index 000000000..bcf2e36fc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-11.c
@@ -0,0 +1,32 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+int main1 (int len)
+{  
+  int s = 0;
+  int i = len;
+
+  /* vectorization of induction with reduction.  */
+  for ( ; i > 1; i -=2)
+    s += i;
+
+  return s;
+}
+
+int main (void)
+{ 
+  int s;
+  check_vect ();
+  
+  s = main1 (26);
+  if (s != 182)
+    abort ();
+
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-2.c
new file mode 100644
index 000000000..df34a99c1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-2.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline)) int main1 ()
+{  
+  int arr1[N];
+  int k = 0;
+  int m = 3, i = 0;
+  
+  /* Vectorization of induction that is used after the loop.  
+     Currently vectorizable because scev_ccp disconnects the
+     use-after-the-loop from the iv def inside the loop.  */
+
+   do { 
+        k = k + 2;
+        arr1[i] = k;
+	m = m + k;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (arr1[i] != 2+2*i)
+        abort ();
+    }
+
+  return m + k;
+}
+
+int main (void)
+{ 
+  int res;
+
+  check_vect ();
+  
+  res = main1 ();
+  if (res != 32 + 275)
+    abort ();
+
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-3.c
new file mode 100644
index 000000000..fac303a67
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-3.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline)) int main1 ()
+{  
+  int arr1[N];
+  int arr2[N];
+  int k = 0;
+  int m = 3, i = 0;
+  
+  /* vectorization of induction. 
+     Peeling to align the store is also applied.  */
+
+   do { 
+        k = k + 2;
+        arr1[i] = k;
+	m = k + 3;
+	arr2[i] = m;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (arr1[i] != 2+2*i || arr2[i] != 5 + 2*i)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-4.c
new file mode 100644
index 000000000..fe29cff18
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-4.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline)) int main1 ()
+{  
+  unsigned int arr1[N];
+  unsigned short arr2[N];
+  unsigned int k = 0;
+  unsigned short m = 3;
+  int i = 0;
+  
+  /* Vectorization of induction with multiple data types.  */
+
+   do { 
+        k = k + 2;
+        arr1[i] = k;
+	m = k + 3;
+	arr2[i] = m;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (arr1[i] != 2+2*i || arr2[i] != 5 + 2*i)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-5.c
new file mode 100644
index 000000000..1766ae6a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-5.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline)) int main1 ()
+{  
+  float arr[N];
+  float f = 1.0;
+  int i;
+  
+  /* Vectorization of fp induction.  */
+
+  for (i=0; i<N; i++)
+    {
+      arr[i] = f;
+      f += 2.0;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (arr[i] != 1.0 + 2.0*i)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-6.c
new file mode 100644
index 000000000..f9fa57813
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-6.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int_mult } */
+#include <stdio.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+ 
+__attribute__ ((noinline)) int main1 (int X)
+{  
+  int arr1[N+1];
+  int arr2[N+1];
+  int k = X;
+  int m, i=0;
+  
+   /* Vectorization of induction with non-constant initial condition X. 
+      Also we have here two uses of the induction-variable k as defined
+      by the loop-header phi (as opposed to the other uses of k that are
+      defined in the loop), in which case we exercise the fact that we
+      reuse the same vector def-use-cycle for both uses. 
+      Peeling to align the store is also applied. This peeling also aligns
+      the load (as they have the same misalignment).  */
+
+   do { 
+	arr2[i+1] = 2*k;
+        k = k + 2;
+        arr1[i+1] = k;
+        k = k + 4;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (arr1[i+1] != X+6*i+2
+	  || arr2[i+1] != 2*(X+6*i))
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (3);
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-7.c
new file mode 100644
index 000000000..140d903a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-7.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+int result[N] = {8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38};
+ 
+__attribute__ ((noinline)) int main1 (int X)
+{  
+  int arr[N];
+  int k = 3;
+  int m, i=0;
+  
+   /* Vectorization of induction with non-constant step X.  */
+
+   do { 
+        m = k + 5;
+        arr[i] = m;
+        k = k + X;
+	i++;
+   } while (i < N);
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (arr[i] != result[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (2);
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-8.c
new file mode 100644
index 000000000..c932fa9b1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-8.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 26
+ 
+__attribute__ ((noinline)) int main1 (short X)
+{  
+  unsigned char a[N];
+  unsigned short b[N];
+  unsigned int c[N];
+  short myX = X;
+  int i;
+
+  /* vectorization of induction with type conversions.  */
+  for (i = 0; i < N; i++)
+  {
+    a[i] = (unsigned char)X;
+    b[i] = X;
+    c[i] = (unsigned int)X;
+    X++;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != (unsigned char)myX || b[i] != myX || c[i] != (unsigned int)myX++)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (3);
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* Fails to get vectorized due to a redundant cast. Once this is fixed, 
+   should be vectorized as follows:
+   dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_pack_trunc && vect_unpack } } } 
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c
new file mode 100644
index 000000000..dc742eb84
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c
@@ -0,0 +1,43 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 26
+ 
+__attribute__ ((noinline)) int main1 (short X)
+{  
+  signed char a[N];
+  short b[N];
+  int c[N];
+  short myX = X;
+  int i;
+
+  /* vectorization of induction with type conversions.  */
+  for (i = 0; i < N; i++)
+  {
+    a[i] = (signed char)X;
+    b[i] = X;
+    c[i] = (int)X;
+    X++;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != (signed char)myX || b[i] != myX || c[i] != (int)myX++)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 (3);
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_pack_trunc && vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-9.c
new file mode 100644
index 000000000..28ce927bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-iv-9.c
@@ -0,0 +1,38 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 26
+int a[N];
+ 
+__attribute__ ((noinline)) int main1 (int X)
+{  
+  int s = X;
+  int i;
+
+  /* vectorization of reduction with induction.  */
+  for (i = 0; i < N; i++)
+    s += (i + a[i]);
+
+  return s;
+}
+
+int main (void)
+{ 
+  int s, i;
+  check_vect ();
+  
+  for (i = 0; i < N; i++)
+    a[i] = 2*i;
+
+  s = main1 (3);
+  if (s != 978)
+    abort ();
+
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_int_mult } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target {! vect_int_mult } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-1.c
new file mode 100644
index 000000000..2ebececc8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-1.c
@@ -0,0 +1,88 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+short sa[N];
+short sb[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
+		16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+int ia[N];
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
+	       0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* Current peeling-for-alignment scheme will consider the 'sa[i+7]'
+   access for peeling, and therefore will examine the option of
+   using a peeling factor = V-7%V = 1,3 for V=8,4 respectively, 
+   which will also align the access to 'ia[i+3]', and the loop could be 
+   vectorized on all targets that support unaligned loads.  */
+
+__attribute__ ((noinline)) int main1 (int n)
+{
+  int i;
+
+  /* Multiple types with different sizes, used in idependent
+     copmutations. Vectorizable.  */
+  for (i = 0; i < n; i++)
+    {
+      sa[i+7] = sb[i];
+      ia[i+3] = ib[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (sa[i+7] != sb[i] || ia[i+3] != ib[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+/* Current peeling-for-alignment scheme will consider the 'ia[i+3]'
+   access for peeling, and therefore will examine the option of
+   using a peeling factor = (V-3)%V = 1 for V=2,4. 
+   This will not align the access 'sa[i+3]' (for which we need to
+   peel 5 iterations), so the loop can not be vectorized.  */
+
+__attribute__ ((noinline)) int main2 (int n)
+{
+  int i;
+
+  /* Multiple types with different sizes, used in independent
+     copmutations.  */
+  for (i = 0; i < n; i++)
+    {
+      ia[i+3] = ib[i];
+      sa[i+3] = sb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (sa[i+3] != sb[i] || ia[i+3] != ib[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N-7);
+  main2 (N-3);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 4 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-10.c
new file mode 100644
index 000000000..757af63f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-10.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char uX[N] __attribute__ ((__aligned__(16)));
+unsigned short uY[N] __attribute__ ((__aligned__(16)));
+unsigned int uresult[N];
+signed char X[N] __attribute__ ((__aligned__(16)));
+signed short Y[N] __attribute__ ((__aligned__(16)));
+int result[N];
+
+/* Unsigned type promotion (hi->si) */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uX[i] = 5;
+    uresult[i] = (unsigned int)uY[i];
+  }
+}
+
+/* Signed type promotion (hi->si) */
+__attribute__ ((noinline)) int
+foo2(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uX[i] = 5;
+    result[i] = (int)Y[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = 16-i;
+    uX[i] = 16-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (uresult[i] != (unsigned short)uY[i])
+      abort ();
+  }
+  
+  foo2 (N);
+  
+  for (i=0; i<N; i++) {
+    if (result[i] != (short)Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-11.c
new file mode 100644
index 000000000..ef66c734e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-11.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+short x[N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) int
+foo (int len, int *z) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    z[i] = x[i];
+  }
+}
+
+
+int main (void)
+{
+  short i;
+  int z[N+4];
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    x[i] = i;
+  }
+
+  foo (N,z+2);
+
+  for (i=0; i<N; i++) {
+    if (z[i+2] != x[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { ! vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-12.c
new file mode 100644
index 000000000..a6fadc8a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-12.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+char x[N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) int
+foo (int len, int *z) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    z[i] = x[i];
+  }
+}
+
+
+int main (void)
+{
+  char i;
+  int z[N+4];
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    x[i] = i;
+  }
+
+  foo (N,z+2);
+
+  for (i=0; i<N; i++) {
+    if (z[i+2] != x[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_unpack } } } */
+/* { dg-final { if [ istarget sparc*-*-* ] { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail ilp32 } } else { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-13.c
new file mode 100644
index 000000000..32b3131ee
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-13.c
@@ -0,0 +1,63 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char uX[N] __attribute__ ((__aligned__(16)));
+unsigned int uresult[N];
+signed char X[N] __attribute__ ((__aligned__(16)));
+int result[N];
+
+/* Unsigned type promotion (qi->si) */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uresult[i] = (unsigned int)uX[i];
+  }
+}
+
+/* Signed type promotion (qi->si) */
+__attribute__ ((noinline)) int
+foo2(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    result[i] = (int)X[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = 16-i;
+    uX[i] = 16-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (uresult[i] != (unsigned int)uX[i])
+      abort ();
+  }
+  
+  foo2 (N);
+  
+  for (i=0; i<N; i++) {
+    if (result[i] != (int)X[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-14.c
new file mode 100644
index 000000000..970535ff6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-14.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char uX[N] __attribute__ ((__aligned__(16)));
+unsigned char uresultX[N];
+unsigned int uY[N] __attribute__ ((__aligned__(16)));
+unsigned char uresultY[N];
+
+/* Unsigned type demotion (si->qi) */
+
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uresultX[i] = uX[i];
+    uresultY[i] = (unsigned char)uY[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    uX[i] = 16-i;
+    uY[i] = 16-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (uresultX[i] != uX[i])
+      abort ();
+    if (uresultY[i] != (unsigned char)uY[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-15.c
new file mode 100644
index 000000000..ad09ff956
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-15.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+#include <stdio.h>
+
+#define N 64
+
+#define DOT1 43680
+#define DOT2 -20832
+
+signed char X[N] __attribute__ ((__aligned__(16)));
+signed char Y[N] __attribute__ ((__aligned__(16)));
+unsigned char CX[N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo1(int len) {
+  int i;
+  int result1 = 0;
+
+  for (i=0; i<len; i++) {
+    result1 += (X[i] * Y[i]);
+    CX[i] = 5;
+  }
+
+  if (result1 != DOT1)
+    abort ();
+}
+
+
+int main (void)
+{
+  int i, dot1, dot2;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+    CX[i] = i;
+  }
+
+  foo1 (N);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_sdot_hi  || vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-16.c
new file mode 100644
index 000000000..d7a121c5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-16.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_long_long } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+char x[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+
+__attribute__ ((noinline)) int
+foo (int len, long long *z) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    z[i] = x[i];
+  }
+}
+
+
+int main (void)
+{
+  char i;
+  long long z[N+4];
+
+  check_vect ();
+
+  foo (N,z+2);
+
+  for (i=0; i<N; i++) {
+    if (z[i+2] != x[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-17.c
new file mode 100644
index 000000000..ffa1d5ac4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-17.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_long_long } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char uX[N] __attribute__ ((__aligned__(16))) = {16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+unsigned char uresultX[N];
+unsigned long long uY[N] __attribute__ ((__aligned__(16))) = {16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+unsigned char uresultY[N];
+
+/* Unsigned type demotion (si->qi) */
+
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uresultX[i] = uX[i];
+    uresultY[i] = (unsigned char)uY[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (uresultX[i] != uX[i])
+      abort ();
+    if (uresultY[i] != (unsigned char)uY[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-2.c
new file mode 100644
index 000000000..4ae47f2c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-2.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+int ia[N];
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+short sa[N];
+short sb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char ca[N];
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline)) int main1 ()
+{
+  int i;
+
+  /* Multiple types with different sizes, used in independent
+     cmputations. Vectorizable. All accesses aligned.   */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i];
+      sa[i] = sb[i];
+      ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] 
+	  || sa[i] != sb[i] 
+	  || ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-3.c
new file mode 100644
index 000000000..22711aa0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-3.c
@@ -0,0 +1,59 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+int ib[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+short sb[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char cb[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline)) 
+int main1 (int n, int * __restrict__ pib, 
+	   short * __restrict__ psb, 
+	   char * __restrict__ pcb)
+{
+  int i;
+  int ia[N];
+  short sa[N];
+  char ca[N];
+
+  /* Multiple types with different sizes, used in independent
+     computations. Vectorizable. The loads are misaligned.  */
+  for (i = 0; i < n; i++)
+    {
+      ia[i] = pib[i];
+      sa[i] = psb[i];
+      ca[i] = pcb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (ia[i] != pib[i] 
+	  || sa[i] != psb[i] 
+	  || ca[i] != pcb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N, ib, sb, cb);
+  main1 (N-3, ib, sb, &cb[2]);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 3 "vect" {xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-4.c
new file mode 100644
index 000000000..7ac336723
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-4.c
@@ -0,0 +1,95 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+unsigned short sa[N];
+unsigned short sc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
+		16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+unsigned short sb[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
+		16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+unsigned int ia[N];
+unsigned int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
+	       0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+unsigned int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,
+	       0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* Current peeling-for-alignment scheme will consider the 'sa[i+7]'
+   access for peeling, and therefore will examine the option of
+   using a peeling factor = VF-7%VF. This will result in a peeling factor 1,
+   which will also align the access to 'ia[i+3]', and the loop could be
+   vectorized on all targets that support unaligned loads.  */
+
+__attribute__ ((noinline))
+int main1 (int n)
+{
+  int i;
+
+  /* Multiple types with different sizes, used in independent
+     copmutations. Vectorizable.  */
+  for (i = 0; i < n; i++)
+    {
+      sa[i+7] = sb[i] + sc[i];
+      ia[i+3] = ib[i] + ic[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (sa[i+7] != sb[i] + sc[i] || ia[i+3] != ib[i] + ic[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+/* Current peeling-for-alignment scheme will consider the 'ia[i+3]'
+   access for peeling, and therefore will examine the option of
+   using a peeling factor = VF-3%VF. This will result in a peeling factor
+   1 if VF=4,2. This will not align the access to 'sa[i+3]', for which we 
+   need to peel 5,1 iterations for VF=4,2 respectively, so the loop can not 
+   be vectorized.  */
+
+__attribute__ ((noinline))
+int main2 (int n)
+{
+  int i;
+
+  /* Multiple types with different sizes, used in independent
+     copmutations. Vectorizable.  */
+  for (i = 0; i < n; i++)
+    {
+      ia[i+3] = ib[i] + ic[i];
+      sa[i+3] = sb[i] + sc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (sa[i+3] != sb[i] + sc[i] || ia[i+3] != ib[i] + ic[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N-7);
+  main2 (N-3);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 8 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 4 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-5.c
new file mode 100644
index 000000000..30ec68406
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-5.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+unsigned int ia[N];
+unsigned int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned  int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned short sa[N];
+unsigned short sc[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned short sb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char ca[N];
+unsigned char cc[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  /* Multiple types with different sizes, used in independent
+     computations. Vectorizable. All accesses aligned.  */
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] + ic[i];
+      sa[i] = sb[i] + sc[i];
+      ca[i] = cb[i] + cc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] + ic[i] 
+	  || sa[i] != sb[i] + sc[i] 
+	  || ca[i] != cb[i] + cc[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { sparc*-*-* && ilp32 } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-6.c
new file mode 100644
index 000000000..56bba706b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-6.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32
+
+unsigned int ic[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned int ib[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned short sc[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned short sb[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char cc[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char cb[N] __attribute__ ((__aligned__(16))) = 
+	{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
+__attribute__ ((noinline))
+int main1 (int n, 
+	   unsigned int * __restrict__ pic, unsigned int * __restrict__ pib, 
+	   unsigned short * __restrict__ psc, unsigned short * __restrict__ psb,
+	   unsigned char * __restrict__ pcc, unsigned char * __restrict__ pcb)
+{
+  int i;
+  unsigned int ia[N];
+  unsigned short sa[N];
+  unsigned char ca[N];
+
+  /* Multiple types with different sizes, used in independent
+     computations. Vectorizable. The loads are misaligned.  */
+  for (i = 0; i < n; i++)
+    {
+      ia[i] = pib[i] + pic[i];
+      sa[i] = psb[i] + psc[i];
+      ca[i] = pcb[i] + pcc[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < n; i++)
+    {
+      if (ia[i] != pib[i] + pic[i] 
+	  || sa[i] != psb[i] + psc[i] 
+	  || ca[i] != pcb[i] + pcc[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N, ic, ib, sc, sb, cc, cb);
+  main1 (N-3, ic, ib, &sc[1], sb, cc, &cb[2]);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { sparc*-*-* && ilp32 } }} } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 6 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 6 "vect" {xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-7.c
new file mode 100644
index 000000000..80604321b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-7.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+#include <stdio.h>
+
+#define N 64
+
+#define DOT1 43680
+#define DOT2 -20832
+
+signed short X[N] __attribute__ ((__aligned__(16)));
+signed short Y[N] __attribute__ ((__aligned__(16)));
+unsigned char CX[N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo1(int len) {
+  int i;
+  int result1 = 0;
+  short prod;
+
+  for (i=0; i<len; i++) {
+    result1 += (X[i] * Y[i]);
+    CX[i] = 5;
+  }
+
+  if (result1 != DOT1)
+    abort ();
+}
+
+
+int main (void)
+{
+  int i, dot1, dot2;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+    CX[i] = i;
+  }
+
+  foo1 (N);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_sdot_hi } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-8.c
new file mode 100644
index 000000000..6a71298a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-8.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char uX[N] __attribute__ ((__aligned__(16)));
+unsigned char uresultX[N];
+unsigned int uY[N] __attribute__ ((__aligned__(16)));
+unsigned short uresultY[N];
+
+/* Unsigned type demotion (si->hi) */
+
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uresultX[i] = uX[i];
+    uresultY[i] = (unsigned short)uY[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    uX[i] = 16-i;
+    uY[i] = 16-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (uresultX[i] != uX[i])
+      abort ();
+    if (uresultY[i] != (unsigned short)uY[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-9.c
new file mode 100644
index 000000000..4ac2d0c1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-multitypes-9.c
@@ -0,0 +1,63 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char uX[N] __attribute__ ((__aligned__(16)));
+unsigned short uresult[N];
+signed char X[N] __attribute__ ((__aligned__(16)));
+short result[N];
+
+/* Unsigned type promotion (qi->hi) */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    uresult[i] = (unsigned short)uX[i];
+  }
+}
+
+/* Signed type promotion (qi->hi) */
+__attribute__ ((noinline)) int
+foo2(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    result[i] = (short)X[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = 16-i;
+    uX[i] = 16-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (uresult[i] != (unsigned short)uX[i])
+      abort ();
+  }
+  
+  foo2 (N);
+  
+  for (i=0; i<N; i++) {
+    if (result[i] != (short)X[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1.c
new file mode 100644
index 000000000..f18924886
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#define N 64
+signed short image[N][N] __attribute__ ((__aligned__(16)));
+signed short block[N][N] __attribute__ ((__aligned__(16)));
+signed short out[N] __attribute__ ((__aligned__(16)));
+
+/* Can't do outer-loop vectorization because of non-consecutive access. */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j+=8) {
+      diff += (image[i][j] - block[i][j]);
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c
new file mode 100644
index 000000000..2d903937f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+
+#define N 64
+signed short image[N][N] __attribute__ ((__aligned__(16)));
+signed short block[N][N] __attribute__ ((__aligned__(16)));
+
+/* Can't do outer-loop vectorization because of non-consecutive access.
+   Currently fails to vectorize because the reduction pattern is not
+   recognized.  */
+
+int
+foo (){
+  int i,j;
+  int diff = 0;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j+=8) {
+      diff += (image[i][j] - block[i][j]);
+    }
+  }
+  return diff;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* FORNOW */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "unexpected pattern" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c
new file mode 100644
index 000000000..e093d0ea3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#define N 40
+signed short image[N][N];
+signed short block[N][N];
+signed short out[N];
+
+/* Outer-loop cannot get vectorized because of non-consecutive access.  */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j+=4) {
+      diff += (image[i][j] - block[i][j]);
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2.c
new file mode 100644
index 000000000..604c35a0c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N] __attribute__ ((__aligned__(16)));
+float out[N];
+
+/* Outer-loop vectorization.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[j][i] = j+i;
+    }
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      if (image[j][i] != j+i)
+	abort ();
+    }
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c
new file mode 100644
index 000000000..aee79735e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N][N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j,k;
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[k][j][i] = j+i+k;
+    }
+  }
+ }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j, k;
+
+  foo ();
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      if (image[k][j][i] != j+i+k)
+	abort ();
+    }
+  }
+ }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2b.c
new file mode 100644
index 000000000..9d9fb5cb5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2b.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[2*N][N][N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j,k;
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[k+i][j][i] = j+i+k;
+    }
+  }
+ }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j, k;
+
+  foo ();
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      if (image[k+i][j][i] != j+i+k)
+	abort ();
+    }
+  }
+ }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "strided access in outer loop." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c
new file mode 100644
index 000000000..da3748dc2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[2*N][2*N][N] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j,k;
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j+=2) {
+      image[k][j][i] = j+i+k;
+    }
+  }
+ }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j, k;
+
+  foo ();
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j+=2) {
+      if (image[k][j][i] != j+i+k)
+	abort ();
+    }
+  }
+ }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2d.c
new file mode 100644
index 000000000..af1986705
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-2d.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N][N+1] __attribute__ ((__aligned__(16)));
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j,k;
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < i+1; j++) {
+      image[k][j][i] = j+i+k;
+    }
+  }
+ }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j, k;
+
+  foo ();
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < i+1; j++) {
+      if (image[k][j][i] != j+i+k)
+       abort ();
+    }
+  }
+ }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3.c
new file mode 100644
index 000000000..5f7a802f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N] __attribute__ ((__aligned__(16)));
+float out[N];
+
+/* Outer-loop vectoriation.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[i][j]=i+j;
+    }
+  }
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c
new file mode 100644
index 000000000..beade07c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N+1] __attribute__ ((__aligned__(16)));
+float out[N];
+
+/* Outer-loop vectorization with misaliged accesses in the inner-loop.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[i][j]=i+j;
+    }
+  }
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3b.c
new file mode 100644
index 000000000..a0ff0906c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3b.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N] __attribute__ ((__aligned__(16)));
+float out[N];
+
+/* Outer-loop vectorization with non-consecutive access. Not vectorized yet.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N/2; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][2*i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[i][j]=i+j;
+    }
+  }
+
+  foo ();
+
+  for (i = 0; i < N/2; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][2*i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3c.c
new file mode 100644
index 000000000..149823a5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-3c.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+float image[N][N+1] __attribute__ ((__aligned__(16)));
+float out[N];
+
+/* Outer-loop vectorization.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j+=4) {
+      diff += image[j][i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[i][j]=i+j;
+    }
+  }
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j+=4) {
+      diff += image[j][i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4.c
new file mode 100644
index 000000000..8f53f2553
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+#define M 128
+float in[N+M];
+float coeff[M];
+float out[N];
+
+/* Outer-loop vectorization.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=4) {
+      diff += in[j+i]*coeff[j]; 
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < M; i++)
+    coeff[i] = i;
+  for (i = 0; i < N+M; i++)
+    in[i] = i;
+
+  foo ();
+  
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=4) {
+      diff += in[j+i]*coeff[j];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c
new file mode 100644
index 000000000..d7bcc9a2e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#define N 40
+#define M 128
+signed short in[N+M];
+signed short coeff[M];
+signed short out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i]*coeff[j]; 
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_widen_mult_hi_to_si && vect_pack_trunc } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c
new file mode 100644
index 000000000..407315a8d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#define N 40
+#define M 128
+signed short in[N+M];
+signed short coeff[M];
+int out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i]*coeff[j]; 
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c
new file mode 100644
index 000000000..3342b79b2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+#define N 40
+#define M 128
+unsigned short in[N+M];
+unsigned short coeff[M];
+unsigned int out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+  int i,j;
+  unsigned short diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i]*coeff[j]; 
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_short_mult && { ! vect_no_align } } } } } */
+/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c
new file mode 100644
index 000000000..c344fb1d6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+#define M 128
+float in[N+M];
+float out[N];
+
+/* Outer-loop vectorization.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=4) {
+      diff += in[j+i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++)
+    in[i] = i;
+
+  foo ();
+  
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=4) {
+      diff += in[j+i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4e.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4e.c
new file mode 100644
index 000000000..243cc1af7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4e.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+#define N 40
+#define M 128
+unsigned int in[N+M];
+unsigned short out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+  int i,j;
+  unsigned int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    out[i]=(unsigned short)diff;
+  }
+
+  return;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c
new file mode 100644
index 000000000..88d6b7abc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c
@@ -0,0 +1,70 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+#define M 128
+unsigned short in[N+M];
+unsigned int out[N];
+unsigned char arr[N];
+
+/* Outer-loop vectorization. */
+/* Not vectorized due to multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff;
+  unsigned int s=0;
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=diff;
+  }
+  return s;
+}
+
+__attribute__ ((noinline)) unsigned int
+bar (int i, unsigned int diff, unsigned short *in)
+{
+    int j;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    return diff;
+}
+
+int main (void)
+{
+  int i, j;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+
+  check_vect ();
+
+  for (i = 0; i < N+M; i++) {
+    in[i] = i;
+  }
+
+  sum=foo ();
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    diff = bar (i, diff, in);
+    s += diff;
+  }
+
+  if (s != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: not allowed" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c
new file mode 100644
index 000000000..88d6b7abc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c
@@ -0,0 +1,70 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+#define M 128
+unsigned short in[N+M];
+unsigned int out[N];
+unsigned char arr[N];
+
+/* Outer-loop vectorization. */
+/* Not vectorized due to multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff;
+  unsigned int s=0;
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=diff;
+  }
+  return s;
+}
+
+__attribute__ ((noinline)) unsigned int
+bar (int i, unsigned int diff, unsigned short *in)
+{
+    int j;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    return diff;
+}
+
+int main (void)
+{
+  int i, j;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+
+  check_vect ();
+
+  for (i = 0; i < N+M; i++) {
+    in[i] = i;
+  }
+
+  sum=foo ();
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    diff = bar (i, diff, in);
+    s += diff;
+  }
+
+  if (s != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: not allowed" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c
new file mode 100644
index 000000000..a244ac20a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+#define M 128
+unsigned char in[N+M];
+unsigned short out[N];
+
+/* Outer-loop vectorization. */
+/* Multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline))
+unsigned short
+foo (){
+  int i,j;
+  unsigned short diff;
+  unsigned short s=0;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=diff;
+  }
+  return s;
+}
+
+int main (void)
+{
+  check_vect ();
+  int i;
+  unsigned short s;
+
+  for (i = 0; i < N+M; i++)
+    in[i] = (unsigned char)i;
+
+  s = foo ();
+
+  if (s != 34048)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c
new file mode 100644
index 000000000..db8f61c5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+
+#define N 96
+#define M 128
+unsigned char in[N+M];
+unsigned short out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+  int i,j;
+  unsigned short diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c
new file mode 100644
index 000000000..88d6b7abc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c
@@ -0,0 +1,70 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+#define M 128
+unsigned short in[N+M];
+unsigned int out[N];
+unsigned char arr[N];
+
+/* Outer-loop vectorization. */
+/* Not vectorized due to multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff;
+  unsigned int s=0;
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=diff;
+  }
+  return s;
+}
+
+__attribute__ ((noinline)) unsigned int
+bar (int i, unsigned int diff, unsigned short *in)
+{
+    int j;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    return diff;
+}
+
+int main (void)
+{
+  int i, j;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+
+  check_vect ();
+
+  for (i = 0; i < N+M; i++) {
+    in[i] = i;
+  }
+
+  sum=foo ();
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    diff = bar (i, diff, in);
+    s += diff;
+  }
+
+  if (s != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: not allowed" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c
new file mode 100644
index 000000000..88d6b7abc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c
@@ -0,0 +1,70 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+#define M 128
+unsigned short in[N+M];
+unsigned int out[N];
+unsigned char arr[N];
+
+/* Outer-loop vectorization. */
+/* Not vectorized due to multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff;
+  unsigned int s=0;
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=diff;
+  }
+  return s;
+}
+
+__attribute__ ((noinline)) unsigned int
+bar (int i, unsigned int diff, unsigned short *in)
+{
+    int j;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    return diff;
+}
+
+int main (void)
+{
+  int i, j;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+
+  check_vect ();
+
+  for (i = 0; i < N+M; i++) {
+    in[i] = i;
+  }
+
+  sum=foo ();
+
+  for (i = 0; i < N; i++) {
+    arr[i] = 3;
+    diff = 0;
+    diff = bar (i, diff, in);
+    s += diff;
+  }
+
+  if (s != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: not allowed" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c
new file mode 100644
index 000000000..6e032f13c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+#define M 128
+unsigned short in[N+M];
+unsigned int out[N];
+
+/* Outer-loop vectorization. */
+/* Not vectorized due to multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff;
+  unsigned int s=0;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=((unsigned short)diff>>3);
+  }
+  return s;
+}
+
+int main (void)
+{
+  int i, j;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+
+  check_vect ();
+
+  for (i = 0; i < N+M; i++) {
+    in[i] = i;
+  }
+
+  sum=foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s += ((unsigned short)diff>>3);
+  }
+
+  if (s != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect"  { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-5.c
new file mode 100644
index 000000000..28dce1b94
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-5.c
@@ -0,0 +1,83 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 64
+#define MAX 42
+
+extern void abort(void); 
+
+__attribute__ ((noinline)) 
+int main1 ()
+{  
+  float A[N] __attribute__ ((__aligned__(16)));
+  float B[N] __attribute__ ((__aligned__(16)));
+  float C[N] __attribute__ ((__aligned__(16)));
+  float D[N] __attribute__ ((__aligned__(16)));
+  float E[4] = {0,1,2,480};
+  float s;
+
+  int i, j;
+
+  for (i = 0; i < N; i++)
+    {
+      A[i] = i;
+      B[i] = i;
+      C[i] = i;
+      D[i] = i;
+    }
+
+  /* Outer-loop 1: Vectorizable with respect to dependence distance. */
+  for (i = 0; i < N-20; i++)
+    {
+      s = 0;
+      for (j=0; j<N; j+=4)
+        s += C[j];
+      A[i] = A[i+20] + s;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N-20; i++)
+    {
+      s = 0;
+      for (j=0; j<N; j+=4)
+        s += C[j];
+      if (A[i] != D[i+20] + s)
+        abort ();
+    }
+
+  /* Outer-loop 2: Not vectorizable because of dependence distance. */
+  for (i = 0; i < 4; i++)
+    {
+      s = 0;
+      for (j=0; j<N; j+=4)
+	s += C[j];
+      B[i+3] = B[i] + s;
+    }
+
+  /* check results:  */
+  for (i = 0; i < 4; i++)
+    {
+      if (B[i] != E[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main ()
+{
+  check_vect ();
+  return main1();
+}
+
+/* NOTE: We temporarily xfail the following check until versioning for
+   aliasing is fixed to avoid versioning when the dependence distance
+   is known.  */
+/* { dg-final { scan-tree-dump-times "not vectorized: possible dependence between data-refs" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-6.c
new file mode 100644
index 000000000..c83943a5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-6.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include <signal.h>
+#include "tree-vect.h"
+
+#define N 64
+#define MAX 42
+
+float A[N] __attribute__ ((__aligned__(16)));
+float B[N] __attribute__ ((__aligned__(16)));
+float C[N] __attribute__ ((__aligned__(16)));
+float D[N] __attribute__ ((__aligned__(16)));
+extern void abort(void); 
+
+__attribute__ ((noinline))
+int main1 ()
+{  
+  float s;
+
+  int i, j;
+
+  for (i = 0; i < N; i++)
+    {
+      s = 0;
+      for (j = 0; j < N; j += 4)
+	s += C[j];
+      A[i] = s;
+    }
+
+  return 0;
+}
+
+int main ()
+{
+  int i,j;
+  float s;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      A[i] = i;
+      B[i] = i;
+      C[i] = i;
+      D[i] = i;
+    }
+
+  main1();
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      s = 0;
+      for (j = 0; j < N; j += 4)
+        s += C[j];
+      if (A[i] != s)
+        abort ();
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c
new file mode 100644
index 000000000..bdc07f9af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c
@@ -0,0 +1,82 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+#define M 64
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Should be vectorized. Fixed misaligment in the inner-loop.  */
+/* Currently not vectorized because the loop-count for the inner-loop
+   has a maybe_zero component. Will be fixed when we incorporate the
+   "cond_expr in rhs" patch.  */
+__attribute__ ((noinline))
+void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+  out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    j = k;
+
+    do {
+      diff += in[j+i]*coeff[j];
+      j+=4;	
+    } while (j < M);
+
+    out[i] += diff;
+  }
+ }
+
+}
+
+/* Vectorized. Changing misalignment in the inner-loop.  */
+__attribute__ ((noinline))
+void fir (){
+  int i,j,k;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j++) {
+      diff += in[j+i]*coeff[j];
+    }
+    fir_out[i] = diff;
+  }
+}
+
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < M; i++)
+    coeff[i] = i;
+  for (i = 0; i < N+M; i++)
+    in[i] = i;
+
+  foo ();
+  fir ();
+  
+  for (i = 0; i < N; i++) {
+    if (out[i] != fir_out[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c
new file mode 100644
index 000000000..30a1c15b4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c
@@ -0,0 +1,79 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 40
+#define M 128
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Should be vectorized. Fixed misaligment in the inner-loop.  */
+/* Currently not vectorized because we get too many BBs in the inner-loop,
+   because the compiler doesn't realize that the inner-loop executes at
+   least once (cause k<4), and so there's no need to create a guard code
+   to skip the inner-loop in case it doesn't execute.  */
+__attribute__ ((noinline))
+void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+  out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = k; j < M; j+=4) {
+      diff += in[j+i]*coeff[j]; 
+    }
+    out[i] += diff;
+  }
+ }
+
+}
+
+/* Vectorized. Changing misalignment in the inner-loop.  */
+__attribute__ ((noinline))
+void fir (){
+  int i,j,k;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j++) {
+      diff += in[j+i]*coeff[j];
+    }
+    fir_out[i] = diff;
+  }
+}
+
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < M; i++)
+    coeff[i] = i;
+  for (i = 0; i < N+M; i++)
+    in[i] = i;
+
+  foo ();
+  fir ();
+  
+  for (i = 0; i < N; i++) {
+    if (out[i] != fir_out[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-recip.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-recip.c
new file mode 100644
index 000000000..4f130b05c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-recip.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_float } */
+
+void f(float *__restrict__ qa, float *__restrict__ qb,
+       float *__restrict__ qc, float *__restrict__ rtrms)
+{
+  int i;
+  static float qam[600];
+  static float qbm[600];
+  static float qcm[600];
+  for(i=0;i<600;i++)
+  {
+    float a = rtrms[i];
+    qam[i] = qa[i]/a;
+    qbm[i] = qb[i]/a;
+    qcm[i] = qc[i]/a;
+  }
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1.c
new file mode 100644
index 000000000..dbb154d12
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+unsigned int ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned int uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* Test vectorization of reduction of unsigned-int.  */
+
+__attribute__ ((noinline))
+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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail { vect_no_int_add || vect_no_int_max } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c
new file mode 100644
index 000000000..5a1c03d11
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1short.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1short.c
new file mode 100644
index 000000000..145722a19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-1short.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2.c
new file mode 100644
index 000000000..912e69c93
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 240
+
+int b[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* Test vectorization of 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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail { vect_no_int_add || vect_no_int_max } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c
new file mode 100644
index 000000000..6d01f0317
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 121
+
+__attribute__ ((noinline))
+void main1 (signed char x, signed char max_result, signed char min_result)
+{
+  int i;
+  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};
+  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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2short.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2short.c
new file mode 100644
index 000000000..7d19e7001
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-2short.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+__attribute__ ((noinline))
+void main1 (short x, short max_result, short min_result)
+{
+  int i;
+  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};
+  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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-3.c
new file mode 100644
index 000000000..3e6f17c48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-3.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+unsigned int ub[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned int uc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+
+/* Test vectorization of reduction of unsigned-int in the presence
+   of unknown-loop-bound.  */
+
+__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;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (N, 240);
+  main1 (N-1, 210);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_int_add } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-6.c
new file mode 100644
index 000000000..4b27be8c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-6.c
@@ -0,0 +1,53 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DIFF 242
+
+__attribute__ ((noinline))
+int main1 (float x, float max_result)
+{
+  int i;
+  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  float diff = 2;
+  float max = x;
+  float min = 10;
+
+  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 != 0)
+    abort ();
+
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100 ,100);
+  main1 (0, 15);
+  return 0;
+}
+
+/* need -ffast-math to vectorizer these loops.  */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-7.c
new file mode 100644
index 000000000..a59a24ac7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-7.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+
+#define N 32
+
+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 const 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 const 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 const 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,
+  };
+
+  check_vect ();
+  
+  testmin (A, 10, 1);
+  testmin (B, 0x7f, 0x70);
+  testmin (C, 0x7f, 0x09);
+
+  testmax (A, 0, 0x7f);
+  testmax (B, 0, 0x8f);
+  testmax (C, 0, 0xff);
+
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-8.c
new file mode 100644
index 000000000..fdfec0a8b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-8.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+
+#define N 32
+
+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 const 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 const 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 const 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,
+  };
+
+  check_vect ();
+  
+  testmin (A, 0, 0);
+  testmin (B, 0, 0x80);
+  testmin (C, 0, 0x80);
+
+  testmax (A, 0, 0x7f);
+  testmax (B, 0, 0x7f);
+  testmax (C, 0, 0x77);
+
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-9.c
new file mode 100644
index 000000000..ecf3bf1ac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-9.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+
+#define N 32
+
+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 const 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 const 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 const 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,
+  };
+
+  check_vect ();
+  
+  testmin (A, 10, 1);
+  testmin (B, 0x7fff, 0x7000);
+  testmin (C, 0x7fff, 0x0009);
+
+  testmax (A, 0, 0x7fff);
+  testmax (B, 0, 0x800f);
+  testmax (C, 0, 0xffff);
+
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s16a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s16a.c
new file mode 100644
index 000000000..b768c6c85
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s16a.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+#define DOT 43680
+
+signed short X[N] __attribute__ ((__aligned__(16)));
+signed short Y[N] __attribute__ ((__aligned__(16)));
+
+/* short->int->int dot product.
+   Detected as a dot-product pattern.
+   Vectorized on targets that support dot-product for signed shorts.  */
+
+__attribute__ ((noinline)) int
+foo (int len)
+{
+  int i;
+  int result = 0;
+
+  for (i = 0; i < len; i++)
+    {
+      result += (X[i] * Y[i]);
+    }
+  return result;
+}
+
+
+int
+main (void)
+{
+  int i;
+  int dot;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      X[i] = i;
+      Y[i] = N - i;
+    }
+
+  dot = foo (N);
+  if (dot != DOT)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_sdot_hi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s16b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s16b.c
new file mode 100644
index 000000000..587800c03
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s16b.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT 43680
+
+signed short X[N] __attribute__ ((__aligned__(16)));
+signed short Y[N] __attribute__ ((__aligned__(16)));
+
+/* short->short->int dot product.  Should be vectorized on architectures
+   supporting vectorized multiplication of two short args with short result,
+   e.g "mulv4hi3" and widenning sum */
+__attribute__ ((noinline)) int
+foo (int len)
+{
+  int i;
+  int result = 0;
+  short prod;
+
+  for (i = 0; i < len; i++)
+    {
+      prod = X[i] * Y[i];
+      result += prod;
+    }
+  return result;
+}
+
+int
+main (void)
+{
+  int i, dot;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      X[i] = i;
+      Y[i] = 64 - i;
+    }
+
+  dot = foo (N);
+  if (dot != DOT)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_short_mult && { vect_widen_sum_hi_to_si || vect_unpack } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_short_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_hi_to_si } && { ! vect_unpack } } } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8a.c
new file mode 100644
index 000000000..66ca021a5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8a.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT1 43680
+
+signed char X[N] __attribute__ ((__aligned__(16)));
+signed char Y[N] __attribute__ ((__aligned__(16)));
+
+/* char->short->int dot product.
+   The dot-product pattern should be detected.
+   Vectorizable on vect_sdot_qi targets (targets that support dot-product of 
+   signed chars).
+
+   In the future could also be vectorized as widening-mult + widening-summation,
+   or with type-conversion support.
+ */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+  int result = 0;
+  short prod;
+
+  for (i=0; i<len; i++) {
+    prod = X[i] * Y[i];
+    result += prod;
+  }
+  return result;
+}
+
+int main (void)
+{
+  int i, dot1;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  dot1 = foo1 (N);
+  if (dot1 != DOT1)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_sdot_qi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi && vect_widen_sum_hi_to_si } } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8b.c
new file mode 100644
index 000000000..8db779704
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8b.c
@@ -0,0 +1,64 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT2 -21856
+
+signed char X[N] __attribute__ ((__aligned__(16)));
+signed char Y[N] __attribute__ ((__aligned__(16)));
+
+/* char->short->short dot product.
+   The dot-product pattern should be detected.
+   The reduction is currently not vectorized becaus of the signed->unsigned->signed
+   casts, since this patch:
+
+     2005-12-26  Kazu Hirata  <kazu@codesourcery.com>
+                                                                                                
+        PR tree-optimization/25125
+
+   When the dot-product is detected, the loop should be vectorized on vect_sdot_qi 
+   targets (targets that support dot-product of signed char).  
+   This test would currently fail to vectorize on targets that support
+   dot-product of chars into an int accumulator.
+   Alternatively, the loop could also be vectorized as widening-mult + summation,
+   or with type-conversion support.
+ */
+__attribute__ ((noinline)) short
+foo2(int len) {
+  int i;
+  short result = 0;
+
+  for (i=0; i<len; i++) {
+    result += (X[i] * Y[i]);
+  }
+  return result;
+}
+
+int main (void)
+{
+  int i;
+  short dot2;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  dot2 = foo2 (N);
+  if (dot2 != DOT2)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" } } */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c
new file mode 100644
index 000000000..80377bae9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT3 43680
+
+signed char X[N] __attribute__ ((__aligned__(16)));
+signed char Y[N] __attribute__ ((__aligned__(16)));
+
+/* char->int->int dot product. 
+   Not detected as a dot-product pattern.  */
+__attribute__ ((noinline)) int
+foo3(int len) {
+  int i;
+  int result = 0;
+
+  for (i=0; i<len; i++) {
+    result += (X[i] * Y[i]);
+  }
+  return result;
+}
+
+int main (void)
+{
+  int i, dot3;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  dot3 = foo3 (N);
+  if (dot3 != DOT3)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u16a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u16a.c
new file mode 100644
index 000000000..eb89ac779
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u16a.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT1 43680
+#define DOT2 43680
+
+unsigned short X[N] __attribute__ ((__aligned__(16)));
+unsigned short Y[N] __attribute__ ((__aligned__(16)));
+
+/* short->short->int dot product. 
+   Not detected as a dot-product pattern.
+   Requires support for non-widneing multiplication and widening-summation.  */
+__attribute__ ((noinline)) unsigned int
+foo1(int len) {
+  int i;
+  unsigned int result = 0;
+  unsigned short prod;
+
+  for (i=0; i<len; i++) {
+    prod = X[i] * Y[i];
+    result += prod;
+  }
+  return result;
+}
+
+int main (void)
+{
+  unsigned int dot1;
+  unsigned short i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  dot1 = foo1 (N);
+  if (dot1 != DOT1)
+    abort ();
+
+  return 0;
+}
+
+/* The initialization loop in main also gets vectorized.  */
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target { vect_short_mult && vect_widen_sum_hi_to_si } } } } */ 
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u16b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u16b.c
new file mode 100644
index 000000000..270a3f420
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u16b.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT2 43680
+
+unsigned short X[N] __attribute__ ((__aligned__(16)));
+unsigned short Y[N] __attribute__ ((__aligned__(16)));
+
+/* short->int->int dot product. 
+   Currently not detected as a dot-product pattern: the multiplication 
+   promotes the ushorts to int, and then the product is promoted to unsigned 
+   int for the addition.  Which results in an int->unsigned int cast, which 
+   since no bits are modified in the cast should be trivially vectorizable.  */
+__attribute__ ((noinline)) unsigned int
+foo2(int len) {
+  int i;
+  unsigned int result = 0;
+
+  for (i=0; i<len; i++) {
+    result += (X[i] * Y[i]);
+  }
+  return result;
+}
+
+
+int main (void)
+{
+  unsigned int  dot2;
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  dot2 = foo2 (N);
+  if (dot2 != DOT2)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" { xfail *-*-* } } } */
+
+/* Once the dot-product pattern is detected, we expect
+   that loop to be vectorized on vect_udot_hi targets (targets that support 
+   dot-product of unsigned shorts) and targets that support widening multiplication.  */
+/* The induction loop in main is vectorized.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail *-*-* } } } */ 
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */ 
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c
new file mode 100644
index 000000000..2931b4f52
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT 43680
+
+unsigned char X[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned char Y[N] __attribute__ ((__aligned__(16))) = {64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+
+/* char->short->int dot product. 
+   Detected as a dot-product pattern.
+   Should be vectorized on targets that support dot-product for unsigned chars
+   (vect_udot_qi),
+   and on targets that support widening-multiplication and widening-summation
+   (vect_widen_mult_qi && vec_widen_sum_qi_to_si).
+   Widening-multiplication can also be supported by type promotion and non-widening 
+   multiplication (vect_unpack && vect_short_mult);
+   Widening summation can also be supported by type promotion and non-widening 
+   summation (vect_unpack).
+   */
+__attribute__ ((noinline)) unsigned int
+foo (int len) {
+  int i;
+  unsigned int result = 0;
+  unsigned short prod;
+
+  for (i=0; i<len; i++) {
+    prod = X[i] * Y[i];
+    result += prod;
+  }
+  return result;
+}
+
+int main (void)
+{
+  unsigned int dot;
+  int i;
+
+  check_vect ();
+
+  dot = foo (N);
+  if (dot != DOT)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_udot_qi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi && vect_widen_sum_qi_to_si } } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c
new file mode 100644
index 000000000..e7156de48
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT 43680
+
+unsigned char X[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned char Y[N] __attribute__ ((__aligned__(16))) = {64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+
+/* char->short->short dot product. 
+   Detected as a dot-product pattern.
+   Should be vectorized on targets that support dot-product for unsigned chars,
+   but currently this test cannot be vectorized as a dot-product on targets
+   that support char->short->int dot-product. 
+   Alternatively, this test can be vectorized using vect_widen_mult_qi (or
+   vect_unpack and non-widening multplication: vect_unpack && vect_short_mult).
+   */
+__attribute__ ((noinline)) unsigned short
+foo (int len) {
+  int i;
+  unsigned short result = 0;
+
+  for (i=0; i<len; i++) {
+    result += (unsigned short)(X[i] * Y[i]);
+  }
+  return result;
+}
+
+int main (void)
+{
+  unsigned short dot;
+  int i;
+
+  check_vect ();
+
+  dot = foo (N);
+  if (dot != DOT)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" } } */
+
+/* When the vectorizer is enhanced to vectorize accumulation into short for 
+   targets that support accumulation into int (powerpc, ia64) we'd have:
+dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_udot_qi || vect_widen_mult_qi_to_hi } }
+*/
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1a.c
new file mode 100644
index 000000000..2d5c5b9a8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1a.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+unsigned short udata_sh[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  unsigned int intsum = 0;
+
+  /* widenning sum: sum shorts into int.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += udata_sh[i];
+    }
+
+  /* check results:  */
+  if (intsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_hi_to_si } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_hi_to_si } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c
new file mode 100644
index 000000000..6effa87eb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+unsigned char udata_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  unsigned int intsum = 0;
+
+  /* widenning sum: sum chars into int.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += udata_ch[i];
+    }
+
+  /* check results:  */
+  if (intsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si || vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c
new file mode 100644
index 000000000..872e6e82e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+unsigned char udata_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  unsigned short shortsum = 0;
+
+  /* widenning sum: sum chars into short.  */
+  for (i = 0; i < N; i++)
+    {
+      shortsum += udata_ch[i];
+    }
+
+  /* check results:  */
+  if (shortsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_qi_to_hi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_hi } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2a.c
new file mode 100644
index 000000000..695738629
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2a.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+signed short data_sh[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  signed int intsum = 0;
+
+  /* widenning sum: sum shorts into int.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += data_sh[i];
+    }
+
+  /* check results:  */
+  if (intsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_hi_to_si } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_hi_to_si } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c
new file mode 100644
index 000000000..53d5f0d5c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+signed char data_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  signed int intsum = 0;
+
+  /* widenning sum: sum chars into int.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += data_ch[i];
+    }
+
+  /* check results:  */
+  if (intsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si && vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2c.c
new file mode 100644
index 000000000..36f51496f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2c.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+signed char data_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  signed short shortsum = 0;
+
+  /* widenning sum: sum chars into short.
+     The widening-summation pattern is currently not detected because of this
+     patch:
+
+     2005-12-26  Kazu Hirata  <kazu@codesourcery.com>
+                                                                                
+        PR tree-optimization/25125
+   */
+
+  for (i = 0; i < N; i++)
+    {
+      shortsum += data_ch[i];
+    }
+
+  /* check results:  */
+  if (shortsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_hi } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-shift-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-shift-1.c
new file mode 100644
index 000000000..79699047e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-shift-1.c
@@ -0,0 +1,32 @@
+/* { dg-require-effective-target vect_shift } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 8
+
+unsigned int A[N] = { 0x08000000, 0x08000001, 0x0ff0000ff, 0xf0000001,
+		      0x08000000, 0x08000001, 0x0ff0000ff, 0xf0000001 };
+unsigned int B[N] = { 0x01000000, 0x01000000, 0x01fe0001f, 0x1e000000,
+		      0x01000000, 0x01000000, 0x01fe0001f, 0x1e000000 };
+
+int main ()
+{
+  int i;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    A[i] = A[i] >> 3;
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    if (A[i] != B[i])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-mult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-mult.c
new file mode 100644
index 000000000..c88814297
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-mult.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  ii iarr[N];
+  ii *iptr = iarr;
+  s res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || res[i].a != arr[i].b + arr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a
+)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}   
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i2.c
new file mode 100644
index 000000000..702d911ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i2.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b - ptr->a;
+      res[i].b = ptr->b + ptr->a;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b - arr[i].a
+          || res[i].b != arr[i].a + arr[i].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c
new file mode 100644
index 000000000..93c1b582c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+   unsigned short c;
+   unsigned short d;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+  unsigned short x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      x = ptr->b - ptr->a;
+      y = ptr->d - ptr->c;
+      res[i].c = x + y;
+      z =  ptr->a + ptr->c;
+      w = ptr->b + ptr->d;
+      res[i].a = z + w;
+      res[i].d = x + y;
+      res[i].b = x + y;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].c + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-mult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-mult.c
new file mode 100644
index 000000000..afb2f4697
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-mult.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  unsigned int iarr[N];
+  unsigned int *iptr = iarr;
+  s res[N];
+  unsigned int ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i] = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i] = *iptr;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a
+          || ires[i] != iarr[i]
+          || res[i].a != arr[i].b + arr[i].a)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u32-mult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u32-mult.c
new file mode 100644
index 000000000..d58679adc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u32-mult.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  unsigned short arr[N];
+  unsigned short *ptr = arr;
+  ii iarr[N];
+  ii *iptr = iarr;
+  unsigned short res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i] = i;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i] == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i] = *ptr;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i] != arr[i]
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i2-gap.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i2-gap.c
new file mode 100644
index 000000000..cda573935
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i2-gap.c
@@ -0,0 +1,74 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->a;
+      res[i].b = ptr->a;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].a
+          || res[i].b != arr[i].a)
+	abort ();
+    }
+
+  ptr = arr;
+  /* Not vectorizable: gap in store.  */ 
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c
new file mode 100644
index 000000000..243961b43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c
@@ -0,0 +1,82 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i + 5;
+      arr[i].f = i * 2 + 2;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->a;
+      res[i].a = ptr->f + ptr->a;
+      res[i].d = ptr->f - ptr->a;
+      res[i].b = ptr->f;
+      res[i].f = ptr->a;
+      res[i].e = ptr->f - ptr->a; 
+      res[i].h = ptr->f;   
+      res[i].g = ptr->f - ptr->a;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].a
+          || res[i].a != arr[i].f + arr[i].a
+          || res[i].d != arr[i].f - arr[i].a
+          || res[i].b != arr[i].f
+          || res[i].f != arr[i].a
+          || res[i].e != arr[i].f - arr[i].a
+          || res[i].h != arr[i].f
+          || res[i].g != arr[i].f - arr[i].a)
+          abort();
+   }
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c
new file mode 100644
index 000000000..8dfb21be9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c
@@ -0,0 +1,86 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  unsigned char u, t, s, x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 67;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      u = ptr->b - ptr->a;
+      t = ptr->d - ptr->c;
+      res[i].c = u + t;
+      x = ptr->b + ptr->d;
+      res[i].a = ptr->a + x;
+      res[i].d = u + t;
+      s = ptr->h - ptr->a;
+      res[i].b = s + t;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b + ptr->e;
+      res[i].h = ptr->d;
+      res[i].g = u + t;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+          || res[i].f != arr[i].f + arr[i].h
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].d
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+         abort();
+   }
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-float.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-float.c
new file mode 100644
index 000000000..38c50b9cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-float.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+float b[N*2] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93};
+float c[N*2] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  float a[N*2];
+
+  /* Strided access pattern.  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i*2] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+      a[i*2+1] = b[2*i+8] * c[2*i+9] + b[2*i+9] * c[2*i+8];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (a[i*2] != b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i]
+	  || a[i*2+1] != b[2*i+8] * c[2*i+9] + b[2*i+9] * c[2*i+8])
+	abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd_wide } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail { vect_interleave && vect_extract_even_odd_wide } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-mult-char-ls.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-mult-char-ls.c
new file mode 100644
index 000000000..3890a7968
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-mult-char-ls.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+__attribute__ ((noinline)) int
+main1 (s *arr, ii *iarr)
+{
+  s *ptr = arr;
+  ii *iptr = iarr;
+  s res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b;
+      ires[i].b = iptr->a;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a 
+          || ires[i].a != iarr[i].b
+          || res[i].a != arr[i].b + arr[i].a
+          || ires[i].b != iarr[i].a
+)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  ii iarr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  main1 (arr, iarr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-mult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-mult.c
new file mode 100644
index 000000000..6ddf09324
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-mult.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+__attribute__ ((noinline)) int
+main1 (s *arr, ii *iarr)
+{
+  s *ptr = arr;
+  ii *iptr = iarr;
+  s res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || res[i].a != arr[i].b + arr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a
+)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  ii iarr[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  main1 (arr, iarr); 
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-same-dr.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-same-dr.c
new file mode 100644
index 000000000..5f18baab4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-same-dr.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+s buffer1[N], buffer2[N];
+
+__attribute__ ((noinline)) int
+main1 (s * __restrict__  pIn, s* __restrict__ pOut)
+{
+  unsigned short i, x, y, d;
+  s *p, *q;
+
+  p = pIn;
+  q = pOut;
+
+  for (i = 0; i < N/2; i++)
+    {
+      x = pIn->a + 5;
+      y = pIn->a + 2;
+      pOut->a = x;
+      pOut->b = pIn->b;
+      pOut++;
+      pOut->a = y;
+      pOut->b = pIn->b;
+      pOut++;
+      pIn++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (q->a != p->a + 5
+          || q->b != p->b)
+         abort ();
+      q++;
+      if (q->a != p->a + 2
+          || q->b != p->b)
+        abort ();
+      q++;
+      p++;
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  short i;
+
+  for (i = 0; i < N; i++)
+    {
+      buffer1[i].a = i;
+      buffer1[i].b = i + 8;
+      buffer2[i].a = i * 3;
+      buffer2[i].b = i * 2;
+      if (buffer1[i].a == 500)
+         abort();
+    }
+
+  check_vect ();
+
+  main1 (buffer1, buffer2);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c
new file mode 100644
index 000000000..8548d267e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+  unsigned char a[N], b[N];
+
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = i;
+      b[i] = i * 2;
+      if (i%3 == 0)
+        a[i] = 10; 
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = a[i] + 3;
+      res[i].b = a[i] + b[i];
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != a[i] + 3
+          || res[i].b != a[i] + b[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-u16-i4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-u16-i4.c
new file mode 100644
index 000000000..5c02c0da2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-u16-i4.c
@@ -0,0 +1,72 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+   unsigned short c;
+   unsigned short d;
+} s;
+
+unsigned short a[N];
+unsigned short b[N];
+unsigned short c[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned short x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = a[i];
+      res[i].a = b[i];
+      res[i].d = c[i];
+      res[i].b = a[i] + b [i];
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != a[i]
+          || res[i].a != b[i]
+          || res[i].d != c[i]
+          || res[i].b != a[i] + b[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      a[i] = i;
+      b[i] = i * 2;
+      c[i] = 17;
+    }
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect"  { target { vect_interleave && vect_pack_trunc  } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { { ! { vect_interleave } } && { vect_pack_trunc } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-u32-i2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-u32-i2.c
new file mode 100644
index 000000000..1eaad4354
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-store-u32-i2.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int a[N*2];
+int b[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+int c[N] = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31};
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+
+  /* Strided access pattern.  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i*2] = b[i] + c[i];
+      a[i*2+1] = b[i] * c[i];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (a[i*2] != b[i] + c[i]
+          || a[i*2+1] != b[i] * c[i])
+        abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail { vect_interleave } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i2.c
new file mode 100644
index 000000000..eb6ecc69b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i2.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b - ptr->a;
+      res[i].b = ptr->b + ptr->a;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b - arr[i].a
+          || res[i].b != arr[i].a + arr[i].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i4.c
new file mode 100644
index 000000000..da5a72855
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i4.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+   unsigned short c;
+   unsigned short d;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned short x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      x = ptr->b - ptr->a;
+      y = ptr->d - ptr->c;
+      res[i].c = x + y;
+      z =  ptr->a + ptr->c;
+      w = ptr->b + ptr->d;
+      res[i].a = z + w;
+      res[i].d = x + y;
+      res[i].b = x + y;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].c + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i4.c
new file mode 100644
index 000000000..96ee25442
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i4.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].a = ptr->a + ptr->c + ptr->b + ptr->d;
+      res[i].d = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].b = ptr->b - ptr->a + ptr->d - ptr->c;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].c + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i8.c
new file mode 100644
index 000000000..5f5a66e63
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i8.c
@@ -0,0 +1,82 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+   int e;
+   int f;
+   int g;
+   int h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].a = ptr->a + ptr->g + ptr->b + ptr->d;
+      res[i].d = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].b = ptr->h - ptr->a + ptr->d - ptr->c;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b - ptr->e; 
+      res[i].h = ptr->d - ptr->g;   
+      res[i].g = ptr->b - ptr->a + ptr->d - ptr->c;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].g + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+          || res[i].f != arr[i].f + arr[i].h
+          || res[i].e != arr[i].b - arr[i].e
+          || res[i].h != arr[i].d - arr[i].g
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+         abort();
+    }
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-mult.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-mult.c
new file mode 100644
index 000000000..e271a9203
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u32-mult.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+__attribute__ ((noinline)) int
+main1 (unsigned short *arr, ii *iarr)
+{
+  unsigned short *ptr = arr;
+  ii *iptr = iarr;
+  unsigned short res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i] = *ptr;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i] != arr[i]
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short arr[N];
+  ii iarr[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i] = i;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i] == 178)
+         abort();
+    }
+  main1 (arr, iarr); 
+    
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2-gap.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2-gap.c
new file mode 100644
index 000000000..b18b66058
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2-gap.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      res[i].b = ptr->b;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b
+          || res[i].b != arr[i].b)
+	abort ();
+    }
+
+  ptr = arr;
+  /* Not vectorizable: gap in store.  */ 
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2.c
new file mode 100644
index 000000000..2f44b8e4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2.c
@@ -0,0 +1,59 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b - ptr->a;
+      res[i].b = ptr->b + ptr->a;
+      ptr++;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b - arr[i].a
+          || res[i].b != arr[i].a + arr[i].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+   
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c
new file mode 100644
index 000000000..259e91f49
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c
@@ -0,0 +1,84 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b;
+      res[i].a = ptr->f + ptr->b;
+      res[i].d = ptr->f - ptr->b;
+      res[i].b = ptr->f;
+      res[i].f = ptr->b;
+      res[i].e = ptr->f - ptr->b; 
+      res[i].h = ptr->f;   
+      res[i].g = ptr->f - ptr->b;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b
+          || res[i].a != arr[i].f + arr[i].b
+          || res[i].d != arr[i].f - arr[i].b
+          || res[i].b != arr[i].f
+          || res[i].f != arr[i].b
+          || res[i].e != arr[i].f - arr[i].b
+          || res[i].h != arr[i].f
+          || res[i].g != arr[i].f - arr[i].b)
+          abort();
+   }
+}
+
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i + 5;
+      arr[i].f = i * 2 + 2;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c
new file mode 100644
index 000000000..1bd932b8a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c
@@ -0,0 +1,103 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned char x;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b + ptr->c;
+      x = ptr->c + ptr->f;
+      res[i].a = x + ptr->b;
+      res[i].d = ptr->b + ptr->c;
+      res[i].b = ptr->c;
+      res[i].f = ptr->f + ptr->e;
+      res[i].e = ptr->b + ptr->e; 
+      res[i].h = ptr->c;   
+      res[i].g = ptr->b + ptr->c;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b + arr[i].c
+          || res[i].a != arr[i].c + arr[i].f + arr[i].b
+          || res[i].d != arr[i].b + arr[i].c
+          || res[i].b != arr[i].c
+          || res[i].f != arr[i].f + arr[i].e
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].c
+          || res[i].g != arr[i].b + arr[i].c)
+          abort ();
+   }
+
+  ptr = arr;
+  /* Not vectorizable: gap in store. */
+  for (i = 0; i < N; i++)
+    { 
+      res[i].a = ptr->b;
+      res[i].b = ptr->c;
+      ptr++; 
+    }
+  
+  /* Check results.  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b 
+	  || res[i].b != arr[i].c)
+          abort ();
+    }
+
+}
+
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c
new file mode 100644
index 000000000..be8ef671a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c
@@ -0,0 +1,88 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned char u, t, s, x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      u = ptr->b - ptr->a;
+      t = ptr->d - ptr->c;
+      res[i].c = u + t;
+      x = ptr->b + ptr->d;
+      res[i].a = ptr->a + x;
+      res[i].d = u + t;
+      s = ptr->h - ptr->a;
+      res[i].b = s + t;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b + ptr->e;
+      res[i].h = ptr->d;
+      res[i].g = u + t;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+          || res[i].f != arr[i].f + arr[i].h
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].d
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+         abort();
+   }
+}
+
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 67;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8.c
new file mode 100644
index 000000000..6609f59df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8.c
@@ -0,0 +1,91 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 32 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned char u, t, s, x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      u = ptr->b - ptr->a;
+      t = ptr->d - ptr->c;
+      res[i].c = u + t;
+      s =  ptr->a + ptr->g;
+      x = ptr->b + ptr->d;
+      res[i].a = s + x;
+      res[i].d = u + t;
+      s = ptr->h - ptr->a;
+      x = ptr->d - ptr->c;
+      res[i].b = s + x;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b + ptr->e; 
+      res[i].h = ptr->d - ptr->g;   
+      res[i].g = u + t;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].g + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+          || res[i].f != arr[i].f + arr[i].h
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].d - arr[i].g
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+       )
+          abort();
+   }
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    { 
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i;
+      arr[i].f = i + 5;
+      arr[i].g = i + 3;
+      arr[i].h = 67;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-01.c
new file mode 100644
index 000000000..4ae967a19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-01.c
@@ -0,0 +1,39 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+int result[N] = {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27};
+int X[N] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25};
+int Y[N] = {};
+ 
+__attribute__ ((noinline)) void
+foo (int *in, int *out)
+{  
+  int i;
+  
+  for (i = 0; i < N; i++)
+    out[i] = in[i] + 2;
+}
+
+int
+main (void)
+{ 
+  int i;
+
+  check_vect ();
+
+  foo (X, Y);
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (Y[i] != result[i])
+	abort ();
+    }
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-02.c
new file mode 100644
index 000000000..13ab54a98
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-02.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+int resultY[N] = {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27};
+int resultZ[N] = {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28};
+int X[N] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25};
+int Y[N] = {};
+int Z[N] = {};
+ 
+__attribute__ ((noinline)) void
+foo (int *in, int *out1, int *out2)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      out1[i] = in[i] + 2;
+      out2[i] = in[i] + 3;
+    }
+}
+
+int
+main (void)
+{ 
+  int i;
+
+  check_vect ();
+
+  foo (X, Y, Z);
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (Y[i] != resultY[i])
+	abort ();
+
+      if (Z[i] != resultZ[i])
+	abort ();
+    }
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-03.c
new file mode 100644
index 000000000..7d684aa1f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-03.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+struct S
+{
+  unsigned short a;
+  unsigned short b;
+};
+
+struct S result[N] = {20, 13, 22, 14, 24, 15, 26, 16, 28, 17, 30, 18,
+                      32, 19, 34, 20, 36, 21, 38, 22, 40, 23, 42, 24,
+		      44, 25, 46, 26, 48, 27, 50, 28};
+struct S X[N] = {10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16,
+                 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+		 23, 23, 24, 24, 25, 25};
+struct S Y[N] = {};
+ 
+__attribute__ ((noinline)) void
+foo (struct S * in, struct S * out)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      out[i].a = in[i].a * 2;
+      out[i].b = in[i].b + 3;
+    }
+}
+
+int
+main (void)
+{ 
+  int i;
+
+  check_vect ();
+
+  foo (X, Y);
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (Y[i].a != result[i].a)  
+	abort ();
+
+      if (Y[i].b != result[i].b) 
+	abort ();
+
+    }
+  return 0;
+} 
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { xfail  { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-04.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-04.c
new file mode 100644
index 000000000..bbe2996af
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-04.c
@@ -0,0 +1,38 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+int result[] = {10, 11, 15, 16, 20, 21, 25, 26, 30, 31, 35, 36, 40, 41, 45, 46, 50, 51};
+int X[] =      {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0};
+ 
+__attribute__ ((noinline)) void
+foo (int *in, int *out)
+{  
+  int i;
+  
+  for (i = 0; i < N; i++)
+    out[i] = in[i] + 5;
+}
+
+int
+main (void)
+{ 
+  int i;
+
+  check_vect ();
+
+  foo (X, &X[2]);
+  
+  /* check results:  */
+  for (i = 0; i < N+2; i++)
+    {
+      if (X[i] != result[i])
+	abort ();
+    }
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-slp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-slp.c
new file mode 100644
index 000000000..27f3ae762
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-vfa-slp.c
@@ -0,0 +1,56 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+struct S
+{
+  unsigned short a;
+  unsigned short b;
+};
+
+struct S result[N] = {12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18,
+                      18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24,
+		      24, 25, 25, 26, 26, 27, 27, 28};
+struct S X[N] = {10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16,
+                 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+		 23, 23, 24, 24, 25, 25};
+struct S Y[N] = {};
+ 
+__attribute__ ((noinline)) void
+foo (struct S * in, struct S * out)
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      out[i].a = in[i].a + 2;
+      out[i].b = in[i].b + 3;
+    }
+}
+
+int
+main (void)
+{ 
+  int i;
+
+  check_vect ();
+
+  foo (X, Y);
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (Y[i].a != result[i].a)
+	abort ();
+
+      if (Y[i].b != result[i].b)
+	abort ();
+
+    }
+  return 0;
+} 
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-s16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-s16.c
new file mode 100644
index 000000000..e63373b2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-s16.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+short X[N] __attribute__ ((__aligned__(16)));
+short Y[N] __attribute__ ((__aligned__(16)));
+int result[N];
+
+/* short->int widening-mult */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    result[i] = X[i] * Y[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-s8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-s8.c
new file mode 100644
index 000000000..8f79e2271
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-s8.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+signed char X[N] __attribute__ ((__aligned__(16)));
+signed char Y[N] __attribute__ ((__aligned__(16)));
+short result[N];
+
+/* char->short widening-mult */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    result[i] = X[i] * Y[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_qi_to_hi } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-sum.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-sum.c
new file mode 100644
index 000000000..19804bd5b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-sum.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+#define SUM 0 
+ 
+/* Require widening-mult or data-unpacking (for the type promotion).  */
+__attribute__ ((noinline)) int
+main1 (short *in, int off, short scale, int n)
+{
+ int i;
+ int sum = 0;
+
+ for (i = 0; i < n; i++) {
+   sum += ((int) in[i] * (int) in[i+off]) >> scale;
+ }
+
+ return sum;
+}
+
+int main (void)
+{
+  int i;
+  int sum;
+  short X[N];
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = 16-i; 
+  }
+
+  sum = main1 (X, 1, 16, N-1);
+  
+  if (sum != SUM)
+    abort ();
+
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u16.c
new file mode 100644
index 000000000..3aa0ff10d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u16.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned short X[N] __attribute__ ((__aligned__(16)));
+unsigned short Y[N] __attribute__ ((__aligned__(16)));
+unsigned int result[N];
+
+/* short->int widening-mult */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  /* Not vectorized because X[i] and Y[i] are casted to 'int'
+     so the widening multiplication pattern is not recognized.  */
+  for (i=0; i<len; i++) {
+    result[i] = (unsigned int)(X[i] * Y[i]);
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/*The induction loop is vectorized  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_pack_trunc } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c
new file mode 100644
index 000000000..63bd00227
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned char X[N] __attribute__ ((__aligned__(16)));
+unsigned char Y[N] __attribute__ ((__aligned__(16)));
+unsigned short result[N];
+
+/* char->short widening-mult */
+__attribute__ ((noinline)) int
+foo1(int len) {
+  int i;
+
+  for (i=0; i<len; i++) {
+    result[i] = X[i] * Y[i];
+  }
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  for (i=0; i<N; i++) {
+    X[i] = i;
+    Y[i] = 64-i;
+    if (i%4 == 0)
+      X[i] = 5;
+  }
+
+  foo1 (N);
+
+  for (i=0; i<N; i++) {
+    if (result[i] != X[i] * Y[i])
+      abort ();
+  }
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect.exp
new file mode 100644
index 000000000..c1e19850f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/vect.exp
@@ -0,0 +1,276 @@
+# Copyright (C) 1997, 2004, 2005, 2006, 2007, 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
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Set up flags used for tests that don't specify options.
+set DEFAULT_VECTCFLAGS ""
+
+# These flags are used for all targets.
+lappend DEFAULT_VECTCFLAGS "-ftree-vectorize" "-fno-vect-cost-model"
+
+# So that we can read flags in individual tests.
+proc vect_cflags { } {
+  global DEFAULT_VECTCFLAGS
+  return $DEFAULT_VECTCFLAGS
+}
+
+# If the target system supports vector instructions, the default action
+# for a test is 'run', otherwise it's 'compile'.  Save current default.
+# Executing vector instructions on a system without hardware vector support
+# is also disabled by a call to check_vect, but disabling execution here is
+# more efficient.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+
+# Skip these tests for targets that do not support generating vector
+# code.  Set additional target-dependent vector flags, which can be
+# overridden by using dg-options in individual tests.
+if  [istarget "powerpc-*paired*"]  {
+   lappend DEFAULT_VECTCFLAGS "-mpaired"
+    if [check_750cl_hw_available] {
+        set dg-do-what-default run 
+    } else {
+        set dg-do-what-default compile
+    }
+} elseif [istarget "powerpc*-*-*"] {
+    # Skip targets not supporting -maltivec.
+    if ![is-effective-target powerpc_altivec_ok] {
+	return
+    }
+
+    lappend DEFAULT_VECTCFLAGS "-maltivec"
+    if [check_vmx_hw_available] {
+	set dg-do-what-default run
+    } else {
+	if [is-effective-target ilp32] {
+	    # Specify a cpu that supports VMX for compile-only tests.
+	    lappend DEFAULT_VECTCFLAGS "-mcpu=970"
+	}
+	set dg-do-what-default compile
+    }
+} elseif { [istarget  "spu-*-*"] } {
+   set dg-do-what-default run
+} elseif { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } {
+    lappend DEFAULT_VECTCFLAGS "-msse2"
+    if [check_sse2_hw_available] {
+	set dg-do-what-default run
+    } else {
+	set dg-do-what-default compile
+    }
+} elseif { [istarget "mips*-*-*"]
+	   && [check_effective_target_mpaired_single]
+	   && [check_effective_target_nomips16] } {
+    lappend DEFAULT_VECTCFLAGS "-mpaired-single"
+    set dg-do-what-default run
+} elseif [istarget "sparc*-*-*"] {
+    lappend DEFAULT_VECTCFLAGS "-mcpu=ultrasparc" "-mvis"
+    if [check_effective_target_ultrasparc_hw] {
+	set dg-do-what-default run
+    } else {
+	set dg-do-what-default compile
+    }
+} elseif [istarget "alpha*-*-*"] {
+    # Alpha's vectorization capabilities are extremely limited.
+    # It's more effort than its worth disabling all of the tests
+    # that it cannot pass.  But if you actually want to see what
+    # does work, command out the return.
+    return
+
+    lappend DEFAULT_VECTCFLAGS "-mmax"
+    if [check_alpha_max_hw_available] {
+	set dg-do-what-default run
+    } else {
+	set dg-do-what-default compile
+    }
+} elseif [istarget "ia64-*-*"] {
+    set dg-do-what-default run
+} elseif [is-effective-target arm_neon_ok] {
+    lappend DEFAULT_VECTCFLAGS "-mfpu=neon" "-mfloat-abi=softfp"
+    if [is-effective-target arm_neon_hw] {
+      set dg-do-what-default run
+    } else {
+      set dg-do-what-default compile
+    }
+} else {
+    return
+}
+
+# Initialize `dg'.
+dg-init
+
+global O1_VECTCFLAGS
+set O1_VECTCFLAGS $DEFAULT_VECTCFLAGS
+lappend O1_VECTCFLAGS "-O1"
+lappend O1_VECTCFLAGS "-fdump-tree-vect-details"
+
+lappend DEFAULT_VECTCFLAGS "-O2"
+
+# Tests that should be run without generating dump info
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/nodump-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+lappend DEFAULT_VECTCFLAGS "-fdump-tree-vect-details" 
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/pr*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/vect-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/slp-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+#### Tests with special options
+global SAVED_DEFAULT_VECTCFLAGS
+set SAVED_DEFAULT_VECTCFLAGS $DEFAULT_VECTCFLAGS
+
+# --param vect-max-version-for-alias-checks=0 tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "--param" "vect-max-version-for-alias-checks=0"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-vfa-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -ffast-math tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-ffast-math"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/fast-math-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fno-math-errno tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-math-errno"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-math-errno-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fwrapv tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fwrapv"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/wrapv-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# -ftrapv tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-ftrapv"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/trapv-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fdump-tree-dceloop-details tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fdump-tree-dceloop-details"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/dump-tree-dceloop-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-dce tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-dce"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-tree-dce-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fsection-anchors tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fsection-anchors"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/section-anchors-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fno-section-anchors tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-section-anchors"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-section-anchors-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -funswitch-loops tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-funswitch-loops"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/unswitch-loops-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fno-trapping-math tests
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-trapping-math"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-trapping-math-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-scev-cprop
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-scev-cprop"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-scevccp-vect-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-scev-cprop
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-scev-cprop"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-scevccp-outer-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-scev-cprop -fno-tree-reassoc
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-scev-cprop" "-fno-tree-reassoc"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-scevccp-noreassoc-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-scev-cprop
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-scev-cprop"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-scevccp-slp-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-dominator-opts
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-dominator-opts"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-tree-dom-*.\[cS\]]]  \
+	"" $DEFAULT_VECTCFLAGS
+
+# -fno-tree-pre
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-fno-tree-pre"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/no-tree-pre-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# With -Os
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-Os"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/Os-vect-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# With --param ggc-min-expand=0 --param ggc-min-heapsize=0 
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "--param" "ggc-min-expand=0" "--param" "ggc-min-heapsize=0"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/ggc-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# With -O3
+set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS
+lappend DEFAULT_VECTCFLAGS "-O3"
+if  [istarget "spu-*-*"] {
+  lappend DEFAULT_VECTCFLAGS "-funroll-loops"
+}
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/O3-*.\[cS\]]]  \
+        "" $DEFAULT_VECTCFLAGS
+
+# With -O1
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/O1-*.\[cS\]]]  \
+        "" $O1_VECTCFLAGS
+
+
+# Clean up.
+set dg-do-what-default ${save-dg-do-what-default}
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-7.c
new file mode 100644
index 000000000..5d495440f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-7.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+short sa[N];
+short sb[N];
+
+int main1 ()
+{
+  int i;
+  
+  for (i = 0; i < N; i++)
+    {
+      sb[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sb[i] != 5)
+        abort ();
+    }
+  
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = sb[i] + (short)100;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sa[i] != 105)
+        abort ();
+    }
+  
+  return 0;
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  return main1 ();
+}
+
+/* Fails for 32-bit targets that don't vectorize PLUS.  */
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-2char.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-2char.c
new file mode 100644
index 000000000..4b04a9d41
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-2char.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-2short.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-2short.c
new file mode 100644
index 000000000..0468b1966
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-2short.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#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 ();
+}
+
+int main (void)
+{ 
+  check_vect ();
+  
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c
new file mode 100644
index 000000000..7fc00e21a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+#define DOT -21856
+
+signed char X[N] __attribute__ ((__aligned__(16))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+signed char Y[N] __attribute__ ((__aligned__(16))) = {64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+
+/* char->short->short dot product.
+   The dot-product pattern should be detected.
+   Should be vectorized on vect_sdot_qi targets (targets that support 
+   dot-product of signed char).  
+   This test currently fails to vectorize on targets that support
+   dot-product of chars into and int accumulator.
+   Can also be vectorized as widening-mult + summation,
+   or with type-conversion support.
+ */
+__attribute__ ((noinline)) short
+foo(int len) {
+  int i;
+  short result = 0;
+
+  for (i=0; i<len; i++) {
+    result += (X[i] * Y[i]);
+  }
+  return result;
+}
+
+int main (void)
+{
+  int i;
+  short dot;
+
+  check_vect ();
+
+  dot = foo (N);
+  if (dot != DOT)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_dot_prod_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_mult_pattern: detected" 1 "vect" } } */
+
+/* When vectorizer is enhanced to vectorize accumulation into short for targets 
+   that support accumulation into int (e.g. ia64) we'd have:
+dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_sdot_qi } }
+*/
+/* In the meantime expect: */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-pattern-2c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-pattern-2c.c
new file mode 100644
index 000000000..12f365078
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-pattern-2c.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+signed char data_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  signed short shortsum = 0;
+
+  /* widenning sum: sum chars into short.  */
+
+  for (i = 0; i < N; i++)
+    {
+      shortsum += data_ch[i];
+    }
+
+  /* check results:  */
+  if (shortsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_qi_to_hi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_hi } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-1.c
new file mode 100644
index 000000000..288dd1e92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Check for application of ~ on vector types.  */
+
+#define vector __attribute__((vector_size(16) ))
+
+vector float a;
+vector int a1;
+
+int f(void)
+{
+ a =  ~a; /* { dg-error "" } */
+ a1 =  ~a1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-2.c
new file mode 100644
index 000000000..5f9f9561d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-2.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+/* Check for application of |, ^, and & on vector types.  */
+#define vector __attribute__((vector_size(16) ))
+
+vector float a;
+vector int a1;
+vector float b;
+vector int b1;
+
+int f(void)
+{
+ a =  a | b; /* { dg-error "" } */
+ a =  a & b; /* { dg-error "" } */
+ a =  a ^ b; /* { dg-error "" } */
+ a1 =  a1 | b1;
+ a1 =  a1 & b1;
+ a1 =  a1 ^ b1;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-3.c
new file mode 100644
index 000000000..3f86698b8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vector-3.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+
+/* Check that we error out when using vector_size on the bool type. */
+
+__attribute__((vector_size(16) )) _Bool a; /* { dg-error "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/verbose-asm.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/verbose-asm.c
new file mode 100644
index 000000000..7d105d31c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/verbose-asm.c
@@ -0,0 +1,27 @@
+/* Test whether -fverbose-asm works.  */
+/* { dg-do compile } */
+/* { dg-options "-fverbose-asm" } */
+
+void foo (int *x)
+{
+  (*x)++;
+}
+
+int bar (int *y)
+{
+  int a, b;
+  b = 10;
+  a = 26;
+  foo (&a);
+  a += 10;
+  foo (&a);
+  *y--;
+  return b;
+}
+   
+int
+main (int argc, char *argv [])
+{
+  bar (&argc);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-1.c
new file mode 100644
index 000000000..864b971dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-1.c
@@ -0,0 +1,9 @@
+/* Test visibility attribute on function definition. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+void
+__attribute__((visibility ("hidden")))
+foo()
+{ }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-10.c
new file mode 100644
index 000000000..d86ce1b1a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-10.c
@@ -0,0 +1,19 @@
+/* Test that a definition marked with dllexport has default
+   visibility.  */
+/* { dg-require-visibility "" } */
+/* { dg-require-dll "" } */
+/* { dg-options "-fvisibility=hidden" } */
+/* { dg-final { scan-not-hidden "g" } } */
+/* { dg-final { scan-not-hidden "h" } } */
+/* { dg-final { scan-not-hidden "k" } } */
+/* { dg-final { scan-not-hidden "l" } } */
+
+__declspec(dllexport) void g() {}
+
+__declspec(dllexport) void h();
+void h() {}
+
+__declspec(dllexport) int k;
+
+__declspec(dllexport) extern int l;
+int l;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-11.c
new file mode 100644
index 000000000..d616fe9ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-11.c
@@ -0,0 +1,26 @@
+/* PR middle-end/20297 */
+/* The memcpy FUNCTION_DECL built in the middle-end for block moves got
+   hidden visibility from the first push, so the call didn't use the PLT.  */
+
+/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-require-effective-target fpic } */
+/* { dg-options "-Os -fpic -mstringop-strategy=libcall" } */
+/* { dg-final { scan-assembler "memcpy@PLT" } } */
+
+#pragma GCC visibility push(hidden)
+#pragma GCC visibility push(default)
+extern void* memcpy (void *, const void *, __SIZE_TYPE__);
+#pragma GCC visibility pop
+
+struct a { int a[4096]; };
+
+extern void *bar (struct a *, struct a *, int);
+
+void *
+foo (struct a *a, struct a *b, int c)
+{
+  struct a cc = *b;
+  return bar (a, &cc, 4 * c);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-12.c
new file mode 100644
index 000000000..6012bd9ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-12.c
@@ -0,0 +1,10 @@
+/* Test that dllimport'd functions have default visibility.  */
+/* { dg-require-visibility "" } */
+/* { dg-require-dll "" } */
+/* { dg-options "-fvisibility=hidden" } */
+/* { dg-final { scan-not-hidden "f1" } } */
+
+extern void  __attribute__((dllimport)) f1();
+void f2() {
+  f1();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-13.c
new file mode 100644
index 000000000..5f7a7c7a0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-13.c
@@ -0,0 +1,19 @@
+/* { dg-require-visibility "" } */
+/* { dg-require-dll "" } */
+
+extern void __attribute__((dllimport, visibility("hidden"))) 
+  f1(); /* { dg-error "visibility" } */
+extern void __attribute__((visibility("hidden"), dllimport)) 
+  f2(); /* { dg-error "visibility" } */
+extern void __attribute__((dllexport, visibility("hidden"))) 
+  f3(); /* { dg-error "visibility" } */
+extern void __attribute__((visibility("hidden"), dllexport)) 
+  f4(); /* { dg-error "visibility" } */
+extern void __attribute__((visibility("default"), dllimport))
+  f5();
+extern void __attribute__((dllimport, visibility("default")))
+  f6();
+extern void __attribute__((visibility("default"), dllexport))
+  f7();
+extern void __attribute__((dllexport, visibility("default")))
+  f8();
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-14.c
new file mode 100644
index 000000000..1c01f8399
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-14.c
@@ -0,0 +1,10 @@
+/* Test that called external functions are marked. */
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+extern void foo(void) __attribute__ ((visibility ("hidden")));
+int f () {
+ foo();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-15.c
new file mode 100644
index 000000000..8d331d76c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-15.c
@@ -0,0 +1,12 @@
+/* Test that accessed external functions are marked. */
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+extern void foo(void) __attribute__ ((visibility ("hidden")));
+typedef void (*foo_t)(void);
+
+foo_t g(void) {
+  return foo;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-16.c
new file mode 100644
index 000000000..52a25cdef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-16.c
@@ -0,0 +1,10 @@
+/* Test that accessed external variables are marked. */
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+extern int foo __attribute__ ((visibility ("hidden")));
+int f () {
+  return foo;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-17.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-17.c
new file mode 100644
index 000000000..0ff3e83de
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-17.c
@@ -0,0 +1,10 @@
+/* Test that external variable whose address is taken are marked. */
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+extern int foo __attribute__ ((visibility ("hidden")));
+int *f () {
+  return &foo;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-18.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-18.c
new file mode 100644
index 000000000..f54c73b19
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-18.c
@@ -0,0 +1,8 @@
+/* Test that external variable whose address is taken are marked. */
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+extern int foo __attribute__ ((visibility ("hidden")));
+int *test = &foo;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-19.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-19.c
new file mode 100644
index 000000000..3c2455fb2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-19.c
@@ -0,0 +1,9 @@
+/* Test that accessed external functions are marked. */
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+extern void foo(void) __attribute__ ((visibility ("hidden")));
+typedef void (*foo_t)(void);
+foo_t test = foo;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-2.c
new file mode 100644
index 000000000..0977abac2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-2.c
@@ -0,0 +1,10 @@
+/* Test that visibility attribute on declaration extends to definition. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+void 
+__attribute__((visibility ("hidden")))
+foo();
+
+void foo() { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-20.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-20.c
new file mode 100644
index 000000000..5fc7447f0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-20.c
@@ -0,0 +1,18 @@
+/* PR target/39175 */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-options "-O2 -fvisibility=hidden -fpic" { target fpic } } */
+
+__attribute__((noinline)) int
+foo (int x)
+{
+  return x;
+}
+
+int foo (int x);
+
+int
+bar (int x)
+{
+  return foo (x);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-3.c
new file mode 100644
index 000000000..cb5a71524
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-3.c
@@ -0,0 +1,8 @@
+/* Test visibility attribute on forward declaration of global variable */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "xyzzy" } } */
+
+int
+__attribute__((visibility ("hidden")))
+xyzzy = 5;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-4.c
new file mode 100644
index 000000000..af0d461c3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-4.c
@@ -0,0 +1,10 @@
+/* Test visibility attribute on forward declaration of global variable */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "xyzzy" } } */
+
+extern int 
+__attribute__((visibility ("hidden")))
+xyzzy;
+
+int xyzzy = 5;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-5.c
new file mode 100644
index 000000000..0302768c9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-5.c
@@ -0,0 +1,12 @@
+/* Test visibility attribute on definition of a function that has
+   already had a forward declaration. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+void foo();
+
+void
+ __attribute__((visibility ("hidden")))
+foo()
+{ }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-6.c
new file mode 100644
index 000000000..4e9deebec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-6.c
@@ -0,0 +1,11 @@
+/* Test visibility attribute on definition of global variable that has
+   already had a forward declaration. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "xyzzy" } } */
+
+extern int xyzzy;
+
+int 
+__attribute__((visibility ("hidden"))) 
+xyzzy = 5;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-7.c
new file mode 100644
index 000000000..016f3dda6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-7.c
@@ -0,0 +1,12 @@
+/* Test warning from conflicting visibility specifications. */
+/* { dg-do compile } */
+/* { dg-require-visibility "protected" } */
+/* { dg-final { scan-hidden "xyzzy" } } */
+
+extern int 
+__attribute__((visibility ("hidden")))
+xyzzy; /* { dg-message "note: previous declaration" "" } */
+
+int 
+__attribute__((visibility ("protected")))
+xyzzy = 5; /* { dg-warning "different visibility" "" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-8.c
new file mode 100644
index 000000000..89f89c082
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-8.c
@@ -0,0 +1,16 @@
+/* Test hidden visibility on built-in functions (for libc).  PR 13856.  */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "__GI_fputs_unlocked" } } */
+
+int fputs_unlocked (const char *restrict, int *restrict)
+   __asm__ ("__GI_fputs_unlocked")
+   __attribute__ ((visibility ("hidden")));
+
+int
+fputs_unlocked (str, fp)
+     const char *str;
+     int *fp;
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-9.c
new file mode 100644
index 000000000..9d5751684
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-9.c
@@ -0,0 +1,9 @@
+/* Test that -fvisibility works. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-options "-fvisibility=hidden" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+void foo();
+
+void foo() { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-a.c
new file mode 100644
index 000000000..23a51d7e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-a.c
@@ -0,0 +1,10 @@
+/* Test that #pragma GCC visibility works. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-hidden "foo" } } */
+
+#pragma GCC visibility push(hidden)
+void foo();
+#pragma GCC visibility pop
+
+void foo() { }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-b.c
new file mode 100644
index 000000000..b1f15758a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-b.c
@@ -0,0 +1,13 @@
+/* { dg-do assemble { target *-*-darwin* } } */
+
+#define __private_extern__ extern __attribute__((visibility ("hidden")))
+
+__private_extern__ int n;
+
+int
+mach_error_type(int sub)
+{
+ if (sub >= n)
+     return 1;
+ return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-c.c
new file mode 100644
index 000000000..22412e02b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-c.c
@@ -0,0 +1,10 @@
+/* Test that visibility works on common symbols also. */
+/* { dg-do assemble } */
+/* { dg-require-visibility "" } */
+
+int options  __attribute__((__visibility__("hidden")));
+
+void f(void)
+{
+  options = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-d.c
new file mode 100644
index 000000000..6f8851b62
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/visibility-d.c
@@ -0,0 +1,205 @@
+/* PR middle-end/20303 */
+/* Test nesting of #pragma GCC visibility. */
+/* { dg-do compile } */
+/* { dg-require-visibility "" } */
+/* { dg-final { scan-not-hidden "foo00" } } */
+/* { dg-final { scan-hidden "foo01" } } */
+/* { dg-final { scan-not-hidden "foo02" } } */
+/* { dg-final { scan-hidden "foo03" } } */
+/* { dg-final { scan-not-hidden "foo04" } } */
+/* { dg-final { scan-not-hidden "foo05" } } */
+/* { dg-final { scan-not-hidden "foo06" } } */
+/* { dg-final { scan-hidden "foo07" } } */
+/* { dg-final { scan-not-hidden "foo08" } } */
+/* { dg-final { scan-hidden "foo09" } } */
+/* { dg-final { scan-not-hidden "foo10" } } */
+/* { dg-final { scan-hidden "foo11" } } */
+/* { dg-final { scan-hidden "foo12" } } */
+/* { dg-final { scan-hidden "foo13" } } */
+/* { dg-final { scan-not-hidden "foo14" } } */
+/* { dg-final { scan-hidden "foo15" } } */
+/* { dg-final { scan-not-hidden "foo16" } } */
+/* { dg-final { scan-hidden "foo17" } } */
+/* { dg-final { scan-not-hidden "foo18" } } */
+/* { dg-final { scan-hidden "foo19" } } */
+/* { dg-final { scan-not-hidden "foo20" } } */
+/* { dg-final { scan-hidden "foo21" } } */
+/* { dg-final { scan-not-hidden "foo22" } } */
+/* { dg-final { scan-hidden "foo23" } } */
+/* { dg-final { scan-not-hidden "foo24" } } */
+/* { dg-final { scan-hidden "foo25" } } */
+/* { dg-final { scan-not-hidden "foo26" } } */
+/* { dg-final { scan-hidden "foo27" } } */
+/* { dg-final { scan-not-hidden "foo28" } } */
+/* { dg-final { scan-hidden "foo29" } } */
+/* { dg-final { scan-not-hidden "foo30" } } */
+/* { dg-final { scan-hidden "foo31" } } */
+/* { dg-final { scan-not-hidden "foo32" } } */
+/* { dg-final { scan-hidden "foo33" } } */
+/* { dg-final { scan-not-hidden "foo34" } } */
+/* { dg-final { scan-hidden "foo35" } } */
+/* { dg-final { scan-not-hidden "foo36" } } */
+/* { dg-final { scan-hidden "foo37" } } */
+/* { dg-final { scan-not-hidden "foo38" } } */
+/* { dg-final { scan-hidden "foo39" } } */
+/* { dg-final { scan-not-hidden "foo40" } } */
+/* { dg-final { scan-hidden "foo41" } } */
+/* { dg-final { scan-not-hidden "foo42" } } */
+/* { dg-final { scan-hidden "foo43" } } */
+/* { dg-final { scan-not-hidden "foo44" } } */
+/* { dg-final { scan-hidden "foo45" } } */
+/* { dg-final { scan-hidden "foo46" } } */
+/* { dg-final { scan-hidden "foo47" } } */
+/* { dg-final { scan-not-hidden "foo48" } } */
+/* { dg-final { scan-hidden "foo49" } } */
+/* { dg-final { scan-not-hidden "foo50" } } */
+/* { dg-final { scan-hidden "foo51" } } */
+/* { dg-final { scan-not-hidden "foo52" } } */
+/* { dg-final { scan-not-hidden "foo53" } } */
+/* { dg-final { scan-not-hidden "foo54" } } */
+/* { dg-final { scan-hidden "foo55" } } */
+/* { dg-final { scan-not-hidden "foo56" } } */
+/* { dg-final { scan-hidden "foo57" } } */
+/* { dg-final { scan-not-hidden "foo58" } } */
+/* { dg-final { scan-hidden "foo59" } } */
+
+#pragma GCC visibility push(default)
+void foo00();
+#pragma GCC visibility push(hidden)
+void foo01();
+#pragma GCC visibility push(default)
+void foo02();
+#pragma GCC visibility push(hidden)
+void foo03();
+#pragma GCC visibility push(default)
+void foo04();
+#pragma GCC visibility push(default)
+void foo05();
+#pragma GCC visibility push(default)
+void foo06();
+#pragma GCC visibility push(hidden)
+void foo07();
+#pragma GCC visibility push(default)
+void foo08();
+#pragma GCC visibility push(hidden)
+void foo09();
+#pragma GCC visibility push(default)
+void foo10();
+#pragma GCC visibility push(hidden)
+void foo11();
+#pragma GCC visibility push(hidden)
+void foo12();
+#pragma GCC visibility push(hidden)
+void foo13();
+#pragma GCC visibility push(default)
+void foo14();
+#pragma GCC visibility push(hidden)
+void foo15();
+#pragma GCC visibility push(default)
+void foo16();
+#pragma GCC visibility push(hidden)
+void foo17();
+#pragma GCC visibility push(default)
+void foo18();
+#pragma GCC visibility push(hidden)
+void foo19();
+#pragma GCC visibility push(default)
+void foo20();
+#pragma GCC visibility push(hidden)
+void foo21();
+#pragma GCC visibility push(default)
+void foo22();
+#pragma GCC visibility push(hidden)
+void foo23();
+#pragma GCC visibility push(default)
+void foo24();
+#pragma GCC visibility push(hidden)
+void foo25();
+#pragma GCC visibility push(default)
+void foo26();
+#pragma GCC visibility push(hidden)
+void foo27();
+#pragma GCC visibility push(default)
+void foo28();
+#pragma GCC visibility push(hidden)
+void foo29();
+#pragma GCC visibility pop
+void foo30();
+#pragma GCC visibility pop
+void foo31();
+#pragma GCC visibility pop
+void foo32();
+#pragma GCC visibility pop
+void foo33();
+#pragma GCC visibility pop
+void foo34();
+#pragma GCC visibility pop
+void foo35();
+#pragma GCC visibility pop
+void foo36();
+#pragma GCC visibility pop
+void foo37();
+#pragma GCC visibility pop
+void foo38();
+#pragma GCC visibility pop
+void foo39();
+#pragma GCC visibility pop
+void foo40();
+#pragma GCC visibility pop
+void foo41();
+#pragma GCC visibility pop
+void foo42();
+#pragma GCC visibility pop
+void foo43();
+#pragma GCC visibility pop
+void foo44();
+#pragma GCC visibility pop
+void foo45();
+#pragma GCC visibility pop
+void foo46();
+#pragma GCC visibility pop
+void foo47();
+#pragma GCC visibility pop
+void foo48();
+#pragma GCC visibility pop
+void foo49();
+#pragma GCC visibility pop
+void foo50();
+#pragma GCC visibility pop
+void foo51();
+#pragma GCC visibility pop
+void foo52();
+#pragma GCC visibility pop
+void foo53();
+#pragma GCC visibility pop
+void foo54();
+#pragma GCC visibility pop
+void foo55();
+#pragma GCC visibility pop
+void foo56();
+#pragma GCC visibility pop
+void foo57();
+#pragma GCC visibility pop
+void foo58();
+#pragma GCC visibility push (hidden)
+void foo59();
+#pragma GCC visibility pop
+#pragma GCC visibility pop
+
+#define D(N) \
+void foo##N##0() { } \
+void foo##N##1() { } \
+void foo##N##2() { } \
+void foo##N##3() { } \
+void foo##N##4() { } \
+void foo##N##5() { } \
+void foo##N##6() { } \
+void foo##N##7() { } \
+void foo##N##8() { } \
+void foo##N##9() { }
+D(0)
+D(1)
+D(2)
+D(3)
+D(4)
+D(5)
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-10.c
new file mode 100644
index 000000000..47dff47c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-10.c
@@ -0,0 +1,7 @@
+/* ICE with VLA in nested parameter declaration: should be treated
+   like [*] instead of the size being expanded.  Bug 28504 from Volker
+   Reichelt <reichelt@gcc.gnu.org>.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void foo(void (*p)(int n, int x[n])) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-11.c
new file mode 100644
index 000000000..8948e6b77
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-11.c
@@ -0,0 +1,13 @@
+/* Further tests of [*] being rejected other that in declarations, as
+   per the consensus in DR#341 that the second example there should be
+   invalid (but warnings because the final wording appears to allow
+   these cases).  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+void foo11a(int x[sizeof(int *(*)[*])]);	/* { dg-warning "not in a declaration" } */
+void foo11b(__SIZE_TYPE__ x, int y[(__SIZE_TYPE__)(int (*)[*])x]);	/* { dg-warning "not in a declaration" } */
+void foo11c(struct s { int (*x)[*]; } *y);	/* { dg-error "a member of a structure or union cannot have a variably modified type" "variably modified" } */
+/* { dg-warning "'struct s' declared inside parameter list" "struct decl" { target *-*-* } 11 } */
+/* { dg-warning "its scope is only this definition or declaration" "struct scope" { target *-*-* } 11 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-2.c
new file mode 100644
index 000000000..72c646590
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-2.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* These are crash tests related to PR middle-end/6994; see also
+   g++.dg/ext/vla1.C.  Note that at present A and C cannot be inlined.  */
+
+static inline void A (int i)
+{
+  struct S { int ar[1][i]; } s;
+
+  s.ar[0][0] = 0;
+}
+
+void B(void)
+{
+  A(23);
+}
+
+static inline void C (int i)
+{
+  union U { int ar[1][i]; } u;
+
+  u.ar[0][0] = 0;
+}
+
+void D(void)
+{
+  C(23);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-3.c
new file mode 100644
index 000000000..619c0422a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-3.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99" } */
+
+/* This used to crash as we did not preserve the correct type
+   for __SIZE_TYPE__. See PR22439. */
+
+char foo(__SIZE_TYPE__ n)
+{
+    char c[1][n];
+    return c[0][0];
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-4.c
new file mode 100644
index 000000000..7ffbfb31b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-4.c
@@ -0,0 +1,48 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+/* PR c/18740 */
+
+static int i;
+
+int foo(int n)
+{
+  int (*t)[n];
+  i = 0;
+  int j = 0;
+  char b[1][n+3];			/* Variable length array.  */
+  int d[3][n];				/* Variable length array.  */
+  sizeof (b[i++ + sizeof(j++)]);	/* Outer sizeof is evaluated for vla, but not the inner one.  */
+  if (i != 1 || j != 0)
+    return 1;
+  __typeof__(b[i++]) c1;		/* typeof is evauluated when given a vm */
+  if (i != 2)
+    return 1;
+  __typeof__(t + (i++,0)) c2;		/* typeof is evauluated when given a vm */
+  if (i != 3)
+    return 1;
+  __typeof__(i + (i++,0)) c3;		/* typeof is not evauluated when not given a vm */
+  if (i != 3)
+    return 1;
+  sizeof (d[i++]);			/* sizeof is evaluated for vla.  */
+  if (i != 4)
+    return 1;
+  __alignof__(__typeof__(t + (i++,0)));	/* typeof is not evauluated when given a vm inside alignof*/
+  if (i != 4)
+    return 1;
+  sizeof(__typeof__(t + (i++,0)));	/* typeof is not evauluated when given a vm inside sizeof*/
+  if (i != 4)
+    return 1;
+  return 0;
+}
+
+int foo6(int a, int b[a][a], int (*c)[sizeof(*b)]) {
+  return sizeof (*c);
+}
+
+int main() {
+  int b[10][10];
+  int (*c)[sizeof(int)*10];
+  if (foo6(10, b, c) != 10*sizeof(int)*sizeof(int))
+    return 1;
+  return foo(10);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-5.c
new file mode 100644
index 000000000..f5256c4c4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-5.c
@@ -0,0 +1,24 @@
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+void foo1(int (*o)(int p[*])) { }
+
+void foo2(int o[*]);
+void foo3(int o[4][*]);
+
+void foo4(int j, int a[j]);
+void foo4(int, int a[*]);
+void foo4(int, int a[]);
+void foo4(int j, int a[j]) {
+}
+
+int foo5(int a, int b[*][*], int c[static sizeof(*b)]);
+int foo5(int a, int b[10][10], int c[400]) {
+  return sizeof (c);
+}
+
+int foo6(int a, int b[*][*], int c[static sizeof(*b)]);
+int foo6(int a, int b[a][a], int c[sizeof(*b)]) {
+  return sizeof (c);
+}
+
+void foo7(__typeof__ (int (*)(int o[*])) i);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-6.c
new file mode 100644
index 000000000..a7f5f0515
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-6.c
@@ -0,0 +1,29 @@
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+int a[*];			/* { dg-error "not allowed in other than function prototype scope" } */
+void foo1() { int a[*]; }	/* { dg-error "not allowed in other than function prototype scope" } */
+void foo2() { int a[*]; }	/* { dg-error "not allowed in other than function prototype scope" } */
+int foo3(int i)[*];		/* { dg-error "not allowed in other than function prototype scope" } */
+void foo4(int o[*][4]) { }	/* { dg-error "not allowed in other than function prototype scope" } */
+void foo5(int o[4][*]) { }	/* { dg-error "not allowed in other than function prototype scope" } */
+
+/* [*] can't be used in a type that's not a declaration (maybe, the
+   final wording for DR#341 would allow it although the first
+   discussed intent would not).  */
+void foo11(int x[sizeof(int (*)[*])]);	/* { dg-warning "not in a declaration" } */
+/* This case is allowed per DR#341.  */
+void foo12(int [*]);
+
+extern int n;
+int B[100];
+void foo10(int m) {
+  typedef int (*vla)[m];
+  struct tag {
+    vla x;			/* { dg-error "a member of a structure or union cannot have a variably modified type" } */
+    /* PR c/7948 */
+    int (*y)[n];		/* { dg-error "a member of a structure or union cannot have a variably modified type" } */
+    int z[n];			/* { dg-error "a member of a structure or union cannot have a variably modified type" } */
+  };
+  /* PR c/25802 */
+  extern int (*r)[m];		/* { dg-error "variably modified type must have no linkage" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-7.c
new file mode 100644
index 000000000..e8c8cd455
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-7.c
@@ -0,0 +1,3 @@
+/* { dg-options "-std=c99" } */
+
+int (*foo)(int (*a)[*]);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-8.c
new file mode 100644
index 000000000..e4c6ae415
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-8.c
@@ -0,0 +1,30 @@
+/* { dg-do compile  } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+/* Radar 4336222 */
+
+int a;
+struct s { void (*f)(int (*)[a]); };
+
+static int i;
+static int new_i() { i++; return i; }
+static int bar1(int a[new_i()][new_i()]);
+
+void foo(int n) {
+  extern void bar(int i[n][n]);			/* Since this isn't a VM type ensure we can have linkage.  */
+  extern int bar1(int a[new_i()][new_i()]);	/* Since this isn't a VM type ensure we can have linkage.  */
+}
+
+void foo1(int n) {
+  goto A;
+  void bar(int i[n][n]);			/* Not a VM type, as VM arguments don't matter. */
+  int bar1(int a[new_i()][new_i()]);		/* Not a VM type, as VM arguments don't matter. */
+ A:
+  ;
+}
+
+void foo2(int n) {
+  goto A;		/* { dg-error "jump into scope of identifier with variably modified type" } */
+  int (*(*bar2)(void))[n];
+ A:
+  ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-9.c
new file mode 100644
index 000000000..0b623b39d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-9.c
@@ -0,0 +1,9 @@
+/* { dg-do compile  } */
+/* { dg-options "-std=c99 -pedantic-errors -W -Wall" } */
+/* PR c/28280 */
+
+void f(__SIZE_TYPE__ d)
+{
+  typedef int t[d];
+  t *g = (__typeof (g)) d;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-1.c
new file mode 100644
index 000000000..68e7d6512
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-1.c
@@ -0,0 +1,15 @@
+/* Test for tree-checking error when initializing a variable-length array
+   (not allowed): constructor_max_index needs to be an INTEGER_CST.  */
+/* Origin: Joseph Myers <jsm28@cam.ac.uk>.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+int a;
+
+void
+foo (void)
+{
+  int x[a] = { 1 }; /* { dg-error "variable-sized object may not be initialized" "VLA init" } */
+  /* { dg-warning "excess elements in array initializer" "" { target *-*-* } 12 } */
+  /* { dg-warning "near initialization" "" { target *-*-* } 12 } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-2.c
new file mode 100644
index 000000000..e13d97cd1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-2.c
@@ -0,0 +1,10 @@
+/* Arrays of unknown size with element type a VLA type should not be
+   initialized (C99 isn't clear about whether such arrays are VLAs,
+   but this is the only reasonable interpretation).  Bug 16409, first
+   testcase.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+const int i = 1;
+void foo() { char a[][i] = {""}; } /* { dg-error "variable-sized object may not be initialized" } */
+/* { dg-error "array size missing in 'a'" "extra error" { target *-*-* } 9 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-3.c
new file mode 100644
index 000000000..710bcc038
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-3.c
@@ -0,0 +1,9 @@
+/* Arrays of unknown size with element type a VLA type should not be
+   initialized (C99 isn't clear about whether such arrays are VLAs,
+   but this is the only reasonable interpretation).  Bug 16409, second
+   testcase.  */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void foo(int i) { char a[][i] = {""}; } /* { dg-error "variable-sized object may not be initialized" } */
+/* { dg-error "array size missing in 'a'" "extra error" { target *-*-* } 8 } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-4.c
new file mode 100644
index 000000000..06351d04e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-4.c
@@ -0,0 +1,7 @@
+/* Test for ICE on VLA compound literal.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+const int i = 1;
+void foo() { char *p = (char [i]){ "" }; } /* { dg-error "compound literal has variable size" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-5.c
new file mode 100644
index 000000000..aa9f4910a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vla-init-5.c
@@ -0,0 +1,7 @@
+/* Test for ICE on incomplete-array-of-VLA compound literal.  */
+/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+const int i = 1;
+void foo() { void *p = (char [][i]){ "" }; } /* { dg-error "compound literal has variable size" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-01.c
new file mode 100644
index 000000000..8cdacb640
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-01.c
@@ -0,0 +1,11 @@
+#include "harness.h"
+
+vector unsigned char a;
+
+static void test()
+{ 
+  check(sizeof(a) == 16, "sizeof(a)");
+  check(((long)&a & 15) == 0, "alignof(a)");
+  check((long)&a != 0, "&a");
+  check(vec_all_eq(a,((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0})), "value(a)");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-02.c
new file mode 100644
index 000000000..2f9aca5da
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-02.c
@@ -0,0 +1,61 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned char u8;
+vector signed char s8;
+vector bool char b8;
+vector unsigned short u16;
+vector signed short s16;
+vector bool short b16;
+vector unsigned int u32;
+vector signed int s32;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+
+vector unsigned char const u8c;
+vector signed char const s8c;
+vector bool char const b8c;
+vector unsigned short const u16c;
+vector signed short const s16c;
+vector bool short const b16c;
+vector unsigned int const u32c;
+vector signed int const s32c;
+vector bool int const b32c;
+vector float const f32c;
+vector pixel const p16c;
+
+vector unsigned char volatile u8v;
+vector signed char volatile s8v;
+vector bool char volatile b8v;
+vector unsigned short volatile u16v;
+vector signed short volatile s16v;
+vector bool short volatile b16v;
+vector unsigned int volatile u32v;
+vector signed int volatile s32v;
+vector bool int volatile b32v;
+vector float volatile f32v;
+vector pixel volatile p16v;
+
+const vector unsigned char u8c_;
+const vector signed char s8c_;
+const vector bool char b8c_;
+const vector unsigned short u16c_;
+const vector signed short s16c_;
+const vector bool short b16c_;
+const vector unsigned int u32c_;
+const vector signed int s32c_;
+const vector bool int b32c_;
+const vector float f32c_;
+const vector pixel p16c_;
+
+volatile vector unsigned char u8v_;
+volatile vector signed char s8v_;
+volatile vector bool char b8v_;
+volatile vector unsigned short u16v_;
+volatile vector signed short s16v_;
+volatile vector bool short b16v_;
+volatile vector unsigned int u32v_;
+volatile vector signed int s32v_;
+volatile vector bool int b32v_;
+volatile vector float f32v_;
+volatile vector pixel p16v_;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-03.c
new file mode 100644
index 000000000..2f8f816ba
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-03.c
@@ -0,0 +1,64 @@
+#include <altivec.h>
+int main()
+{
+  vector unsigned char u8;
+  vector signed char s8;
+  vector bool char b8;
+  vector unsigned short u16;
+  vector signed short s16;
+  vector bool short b16;
+  vector unsigned int u32;
+  vector signed int s32;
+  vector bool int b32;
+  vector float f32;
+  vector pixel p16;
+
+  vector unsigned char const u8c;
+  vector signed char const s8c;
+  vector bool char const b8c;
+  vector unsigned short const u16c;
+  vector signed short const s16c;
+  vector bool short const b16c;
+  vector unsigned int const u32c;
+  vector signed int const s32c;
+  vector bool int const b32c;
+  vector float const f32c;
+  vector pixel const p16c;
+
+  vector unsigned char volatile u8v;
+  vector signed char volatile s8v;
+  vector bool char volatile b8v;
+  vector unsigned short volatile u16v;
+  vector signed short volatile s16v;
+  vector bool short volatile b16v;
+  vector unsigned int volatile u32v;
+  vector signed int volatile s32v;
+  vector bool int volatile b32v;
+  vector float volatile f32v;
+  vector pixel volatile p16v;
+
+  const vector unsigned char u8c_;
+  const vector signed char s8c_;
+  const vector bool char b8c_;
+  const vector unsigned short u16c_;
+  const vector signed short s16c_;
+  const vector bool short b16c_;
+  const vector unsigned int u32c_;
+  const vector signed int s32c_;
+  const vector bool int b32c_;
+  const vector float f32c_;
+  const vector pixel p16c_;
+
+  volatile vector unsigned char u8v_;
+  volatile vector signed char s8v_;
+  volatile vector bool char b8v_;
+  volatile vector unsigned short u16v_;
+  volatile vector signed short s16v_;
+  volatile vector bool short b16v_;
+  volatile vector unsigned int u32v_;
+  volatile vector signed int s32v_;
+  volatile vector bool int b32v_;
+  volatile vector float f32v_;
+  volatile vector pixel p16v_;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-04.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-04.c
new file mode 100644
index 000000000..5807ea335
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-04.c
@@ -0,0 +1,7 @@
+#include <altivec.h>
+int main()
+{
+  vector unsigned char a,b;
+  b = (vector unsigned char)a;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-05.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-05.c
new file mode 100644
index 000000000..63eb10b7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-05.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector float _0 ;
+vector pixel _1 ;
+vector bool int _2 ;
+vector unsigned int _3 ;
+vector signed int _4 ;
+vector bool short _5 ;
+vector unsigned short _6 ;
+vector signed short _7 ;
+vector bool char _8 ;
+vector unsigned char _9 ;
+vector signed char _10 ;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-06-ansi.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-06-ansi.c
new file mode 100644
index 000000000..780a4e6bc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-06-ansi.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-ansi -maltivec" } */
+
+#include <altivec.h>
+vector char bool _4 ;
+vector char unsigned _31 ;
+vector char signed _59 ;
+/* bool is permitted in the predefine method, as it is expanded
+   unconditionally to int.  */
+bool _84 ;
+vector pixel _89 ;
+vector int bool _95 ;
+vector short bool _102 ;
+vector unsigned int _122 ;
+vector unsigned short _129 ;
+vector signed int _150 ;
+vector signed short _157 ;
+vector int bool _179 ;
+vector int short bool _186 ;
+vector unsigned int _206 ;
+vector int unsigned short _213 ;
+vector signed int _234 ;
+vector int signed short _241 ;
+vector float _339 ;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-06.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-06.c
new file mode 100644
index 000000000..d25164c31
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-06.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector char bool _4 ;
+vector char unsigned _31 ;
+vector char signed _59 ;
+vector pixel _89 ;
+vector int bool _95 ;
+vector short bool _102 ;
+vector unsigned int _122 ;
+vector unsigned short _129 ;
+vector signed int _150 ;
+vector signed short _157 ;
+vector int bool _179 ;
+vector int short bool _186 ;
+vector unsigned int _206 ;
+vector int unsigned short _213 ;
+vector signed int _234 ;
+vector int signed short _241 ;
+vector float _339 ;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-07-ansi.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-07-ansi.c
new file mode 100644
index 000000000..cfc98639b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-07-ansi.c
@@ -0,0 +1,59 @@
+/* { dg-do compile } */
+/* { dg-options "-ansi -maltivec" } */
+
+#include <altivec.h>
+vector char bool _0 ;
+vector bool char _8 ;
+vector char unsigned _56 ;
+vector unsigned char _64 ;
+vector char signed _112 ;
+vector signed char _120 ;
+/* bool is permitted in the predefine method, as it is expanded
+   unconditionally to int.  */
+bool _168 ;
+vector pixel _170 ;
+vector int bool _178 ;
+vector bool int _186 ;
+vector short bool _234 ;
+vector bool short _242 ;
+vector unsigned int _290 ;
+vector int unsigned _298 ;
+vector unsigned short _346 ;
+vector short unsigned _354 ;
+vector signed int _402 ;
+vector int signed _410 ;
+vector signed short _458 ;
+vector short signed _466 ;
+vector int bool _514 ;
+vector int bool _544 ;
+vector int bool _559 ;
+vector bool int _589 ;
+vector int short bool _874 ;
+vector int bool short _889 ;
+vector short int bool _904 ;
+vector short bool int _919 ;
+vector bool int short _934 ;
+vector bool short int _949 ;
+vector unsigned int _1234 ;
+vector int unsigned _1249 ;
+vector unsigned int _1279 ;
+vector int unsigned _1294 ;
+vector unsigned int _1309 ;
+vector int unsigned short _1594 ;
+vector int short unsigned _1609 ;
+vector unsigned int short _1624 ;
+vector unsigned short int _1639 ;
+vector short int unsigned _1654 ;
+vector short unsigned int _1669 ;
+vector signed int _1954 ;
+vector int signed _1969 ;
+vector signed int _1999 ;
+vector int signed _2014 ;
+vector signed int _2029 ;
+vector int signed short _2314 ;
+vector int short signed _2329 ;
+vector signed int short _2344 ;
+vector signed short int _2359 ;
+vector short int signed _2374 ;
+vector short signed int _2389 ;
+vector float _2674 ;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-07.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-07.c
new file mode 100644
index 000000000..44bf4029f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1b-07.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector char bool _0 ;
+vector bool char _8 ;
+vector char unsigned _56 ;
+vector unsigned char _64 ;
+vector char signed _112 ;
+vector signed char _120 ;
+vector pixel _170 ;
+vector int bool _178 ;
+vector bool int _186 ;
+vector short bool _234 ;
+vector bool short _242 ;
+vector unsigned int _290 ;
+vector int unsigned _298 ;
+vector unsigned short _346 ;
+vector short unsigned _354 ;
+vector signed int _402 ;
+vector int signed _410 ;
+vector signed short _458 ;
+vector short signed _466 ;
+vector int bool _514 ;
+vector int bool _544 ;
+vector int bool _559 ;
+vector bool int _589 ;
+vector int short bool _874 ;
+vector int bool short _889 ;
+vector short int bool _904 ;
+vector short bool int _919 ;
+vector bool int short _934 ;
+vector bool short int _949 ;
+vector unsigned int _1234 ;
+vector int unsigned _1249 ;
+vector unsigned int _1279 ;
+vector int unsigned _1294 ;
+vector unsigned int _1309 ;
+vector int unsigned short _1594 ;
+vector int short unsigned _1609 ;
+vector unsigned int short _1624 ;
+vector unsigned short int _1639 ;
+vector short int unsigned _1654 ;
+vector short unsigned int _1669 ;
+vector signed int _1954 ;
+vector int signed _1969 ;
+vector signed int _1999 ;
+vector int signed _2014 ;
+vector signed int _2029 ;
+vector int signed short _2314 ;
+vector int short signed _2329 ;
+vector signed int short _2344 ;
+vector signed short int _2359 ;
+vector short int signed _2374 ;
+vector short signed int _2389 ;
+vector float _2674 ;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1c-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1c-01.c
new file mode 100644
index 000000000..974bda19e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1c-01.c
@@ -0,0 +1,56 @@
+#include <stddef.h>
+#include "harness.h"
+
+/* Declare vector types.  */
+vector unsigned char u8;
+vector signed char s8;
+vector bool char b8;
+vector unsigned short u16;
+vector signed short s16;
+vector bool short b16;
+vector unsigned int u32;
+vector signed int s32;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+
+vector unsigned char *u8c = &u8;
+vector signed char *s8c = &s8;
+vector bool char *b8c = &b8;
+vector unsigned short *u16c = &u16;
+vector signed short *s16c = &s16;
+vector bool short *b16c = &b16;
+vector unsigned int *u32c = &u32;
+vector signed int *s32c = &s32;
+vector bool int *b32c = &b32;
+vector float *f32c = &f32;
+vector pixel *p16c = &p16;
+
+static void test()
+{
+  check(((ptrdiff_t)u8c & 15) == 0, "alignof(u8)");
+  check(((ptrdiff_t)u8c & 15) == 0, "alignof(u8)");
+  check(((ptrdiff_t)s8c & 15) == 0, "alignof(s8)");
+  check(((ptrdiff_t)b8c & 15) == 0, "alignof(b8)");
+  check(((ptrdiff_t)u16c & 15) == 0, "alignof(u16)");
+  check(((ptrdiff_t)s16c & 15) == 0, "alignof(s16)");
+  check(((ptrdiff_t)b16c & 15) == 0, "alignof(b16)");
+  check(((ptrdiff_t)u32c & 15) == 0, "alignof(u32)");
+  check(((ptrdiff_t)s32c & 15) == 0, "alignof(s32)");
+  check(((ptrdiff_t)b32c & 15) == 0, "alignof(b32)");
+  check(((ptrdiff_t)f32c & 15) == 0, "alignof(f32)");
+  check(((ptrdiff_t)p16c & 15) == 0, "alignof(p16)");
+
+  check((ptrdiff_t)u8c == (ptrdiff_t)&u8, "u8c == &u8");
+  check((ptrdiff_t)u8c == (ptrdiff_t)&u8, "u8c == &u8");
+  check((ptrdiff_t)s8c == (ptrdiff_t)&s8, "s8c == &s8");
+  check((ptrdiff_t)b8c == (ptrdiff_t)&b8, "b8c == &b8");
+  check((ptrdiff_t)u16c == (ptrdiff_t)&u16, "u16c == &u16");
+  check((ptrdiff_t)s16c == (ptrdiff_t)&s16, "s16c == &s16");
+  check((ptrdiff_t)b16c == (ptrdiff_t)&b16, "b16c == &b16");
+  check((ptrdiff_t)u32c == (ptrdiff_t)&u32, "u32c == &u32");
+  check((ptrdiff_t)s32c == (ptrdiff_t)&s32, "s32c == &s32");
+  check((ptrdiff_t)b32c == (ptrdiff_t)&b32, "b32c == &b32");
+  check((ptrdiff_t)f32c == (ptrdiff_t)&f32, "f32c == &f32");
+  check((ptrdiff_t)p16c == (ptrdiff_t)&p16, "p16c == &p16");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1c-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1c-02.c
new file mode 100644
index 000000000..be6adf647
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/1c-02.c
@@ -0,0 +1,34 @@
+#include "harness.h"
+
+/* Vector types used in aggregates.  */
+struct { char b; vector unsigned char a; char e; } u8;
+struct { char b; vector signed char a; char e; } s8;
+struct { char b; vector bool char a; char e; } b8;
+struct { char b; vector unsigned short a; char e; } u16;
+struct { char b; vector signed short a; char e; } s16;
+struct { char b; vector bool short a; char e; } b16;
+struct { char b; vector unsigned int a; char e; } u32;
+struct { char b; vector signed int a; char e; } s32;
+struct { char b; vector bool int a; char e; } b32;
+struct { char b; vector float a; char e; } f32;
+struct { char b; vector pixel a; char e; } p16;
+
+union { char b; vector unsigned char a; } u8u;
+union { char b; vector signed char a; } s8u;
+union { char b; vector bool char a; } b8u;
+union { char b; vector unsigned short a; } u16u;
+union { char b; vector signed short a; } s16u;
+union { char b; vector bool short a; } b16u;
+union { char b; vector unsigned int a; } u32u;
+union { char b; vector signed int a; } s32u;
+union { char b; vector bool int a; } b32u;
+union { char b; vector float a; } f32u;
+union { char b; vector pixel a; } p16u;
+
+static void test()
+{
+  check((long)&u8.a - (long)&u8 == 16, "u8.a");
+  check((long)&u8.e - (long)&u8 == 32, "u8.e");
+  check(sizeof(u8) == 48, "sizeof(u8)");
+  check(sizeof(u8u) == 16, "sizeof(u8u)");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01.c
new file mode 100644
index 000000000..86e514d4a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01.c
@@ -0,0 +1,16 @@
+#include "harness.h"
+/* Simple use of a non-overloaded generic vector intrinsic.  */
+
+static vector unsigned int
+f(vector unsigned int a, vector unsigned int b) 
+{
+  return vec_addc(a,b);
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector unsigned int){1,1,3,2}),
+		     ((vector unsigned int){-1,-2,3,-4})),
+		   ((vector unsigned int){1,0,0,0})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01a.c
new file mode 100644
index 000000000..7619d1185
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01a.c
@@ -0,0 +1,17 @@
+#include "harness.h"
+
+/* Simple use of a non-overloaded specific vector intrinsic.  */
+
+vector unsigned int
+f(vector unsigned int a, vector unsigned int b)
+{
+  return vec_vaddcuw(a,b);
+}
+
+void test()
+{
+  check(vec_all_eq(f(((vector unsigned int){1,1,3,2}),
+		     ((vector unsigned int){-1,-2,3,-4})),
+		   ((vector unsigned int){1,0,0,0})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01m.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01m.c
new file mode 100644
index 000000000..d57287007
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-01m.c
@@ -0,0 +1,17 @@
+#include "harness.h"
+
+/* Simple use of a non-overloaded specific vector intrinsic.  */
+
+vector unsigned int
+f(vector unsigned int a, vector unsigned int b) 
+{
+  return vec_vaddcuw(a,b);
+}
+
+static void test() 
+{
+  check(vec_all_eq(f(((vector unsigned int){1,1,3,2}),
+		     ((vector unsigned int){-1,-2,3,-4})),
+		   ((vector unsigned int){1,0,0,0})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-03.c
new file mode 100644
index 000000000..5f46ee6f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-03.c
@@ -0,0 +1,18 @@
+#include "harness.h"
+
+/* Small expression involving non-overloaded generic vector intrinsics.  */
+
+vector float
+f(vector float a, vector float b, vector float c) 
+{
+  return vec_nmsub(a, vec_re(b), vec_nmsub(b, c, vec_expte(a)));
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){-249.181808, -369.230774, -495.294098, -575.368408})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-03m.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-03m.c
new file mode 100644
index 000000000..68feecee7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-03m.c
@@ -0,0 +1,18 @@
+#include "harness.h"
+
+/* Small expression involving non-overloaded specific vector intrinsics.  */
+
+vector float
+f(vector float a, vector float b, vector float c) 
+{
+  return vec_nmsub(a, vec_vrefp(b), vec_nmsub(b, c, vec_vexptefp(a)));
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){-249.181808, -369.230774, -495.294098, -575.368408})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-04.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-04.c
new file mode 100644
index 000000000..a04497bed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-04.c
@@ -0,0 +1,22 @@
+#include "harness.h"
+
+/* Small expression involving non-overloaded vector intrinsics.  */
+
+vector float
+f(vector float a, vector float b, vector float c) 
+{
+  return vec_vmaddfp(a, vec_re(b), vec_vmaxfp(c, vec_expte(a)));
+}
+
+static void test()
+{
+  check(vec_all_gt(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){23.18, 29.23, 32.29, 128.36}))
+	&& vec_all_lt(f(((vector float){2,3,5,7}),
+			((vector float){11,13,17,19}),
+			((vector float){23,29,31,37})),
+		      ((vector float){23.19, 29.24, 32.30, 128.37})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-04m.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-04m.c
new file mode 100644
index 000000000..b6e273bcc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-04m.c
@@ -0,0 +1,22 @@
+#include "harness.h"
+
+/* Small expression involving non-overloaded specific vector intrinsics.  */
+
+vector float
+f(vector float a, vector float b, vector float c) 
+{
+  return vec_vmaddfp(a, vec_vrefp(b), vec_vmaxfp(c, vec_vexptefp(a)));
+}
+
+static void test()
+{
+  check(vec_all_gt(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){23.18, 29.23, 32.29, 128.36}))
+	&& vec_all_lt(f(((vector float){2,3,5,7}),
+			((vector float){11,13,17,19}),
+			((vector float){23,29,31,37})),
+		      ((vector float){23.19, 29.24, 32.30, 128.37})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-05.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-05.c
new file mode 100644
index 000000000..8d6ba5eab
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-05.c
@@ -0,0 +1,26 @@
+#include "harness.h"
+
+/* Small expression involving non-overloaded specific vector intrinsics.  */
+
+vector float
+f(vector float a, vector float b, vector float c) 
+{
+  vector float q = vec_expte(a);
+  vector float r = vec_vsubfp(c, q);
+  vector float s = vec_re(b);
+  vector float t = vec_nmsub(s, c, r);
+  return t;
+}
+
+static void test()
+{
+  check(vec_all_gt(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){16.90, 18.76, -2.83, -92.95}))
+	&& vec_all_lt(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){16.91, 18.77, -2.82, -92.94})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-06.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-06.c
new file mode 100644
index 000000000..6f27b3860
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-06.c
@@ -0,0 +1,15 @@
+#include "harness.h"
+
+vector unsigned int
+f(vector unsigned int a, vector unsigned int b) 
+{
+  return vec_addc(vec_addc(a,b),b);
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector unsigned int){2,4,6,8}),
+		     ((vector unsigned int){-1,-2,-3,-4})),
+		   ((vector unsigned int){1,0,0,0})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-06m.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-06m.c
new file mode 100644
index 000000000..e616f9aef
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-06m.c
@@ -0,0 +1,15 @@
+#include "harness.h"
+
+vector unsigned int
+f(vector unsigned int a, vector unsigned int b) 
+{
+  return vec_vaddcuw(vec_vaddcuw(a,b),b);
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector unsigned int){2,4,6,8}),
+		     ((vector unsigned int){-1,-2,-3,-4})),
+		   ((vector unsigned int){1,0,0,0})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-07.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-07.c
new file mode 100644
index 000000000..197fd23c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3a-07.c
@@ -0,0 +1,16 @@
+#include "harness.h"
+
+static vector unsigned char 
+zero() 
+{
+  /* MCC allocates a stack slot for and loads an uninitialized local
+     variable.  */
+  vector unsigned char a;
+  return vec_sub(a,a);
+}
+
+static void test()
+{
+  static vector unsigned char zerov;
+  check(vec_all_eq(zero(), zerov), "zero");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-01.c
new file mode 100644
index 000000000..e8feec481
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-01.c
@@ -0,0 +1,18 @@
+#include "harness.h"
+
+/* Simple use of a overloaded generic vector intrinsic.  */
+
+vector unsigned int
+f(vector unsigned int a, vector unsigned int b) 
+{
+  return vec_subs(a,b);
+}
+
+static void test()
+{
+  static vector unsigned int zero;
+  check(vec_all_eq(f(((vector unsigned int){2,4,6,8}),
+		     ((vector unsigned int){2,4,6,8})),
+		   zero),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-02.c
new file mode 100644
index 000000000..66693e0ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-02.c
@@ -0,0 +1,16 @@
+#include "harness.h"
+
+vector unsigned char
+f(vector unsigned char a, vector unsigned char b) 
+{
+  return vec_vsububs(a,b);
+}
+
+static void test()
+{
+  static vector unsigned char zero;
+  check(vec_all_eq(f(((vector unsigned char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2}),
+		     ((vector unsigned char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2})),
+		   zero),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-10.c
new file mode 100644
index 000000000..5f8fb3adf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-10.c
@@ -0,0 +1,21 @@
+#include "harness.h"
+
+typedef vector unsigned int x;
+
+x f (x a)
+{
+  return vec_addc(a,a); 
+}
+
+void g (int b) 
+{
+  vec_dst(&b, 3, 3); 
+  vec_dst(&b, 1, 1);
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector unsigned int){0x80000000,0x7fffffff,3,4})),
+		   ((vector unsigned int){1,0,0,0})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-13.c
new file mode 100644
index 000000000..146f737ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-13.c
@@ -0,0 +1,15 @@
+#include "harness.h"
+
+vector signed int 
+f(vector float a, vector signed int b) 
+{
+  return vec_splat(vec_cts(vec_ctf(vec_ctu(a, 31),0),9),30);
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector float){1,2,3,4}),
+		     ((vector signed int){2,4,6,8})),
+		   ((vector signed int){2147483647, 2147483647, 2147483647, 2147483647})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-14.c
new file mode 100644
index 000000000..02b2d901e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-14.c
@@ -0,0 +1,29 @@
+#include "harness.h"
+
+static vector bool char x(void);
+static void g(void);
+
+static vector bool char
+f (void) 
+{
+  vector bool char a = x();
+  g();
+  return a;
+}
+
+static vector bool char
+x (void)
+{
+  static vector bool char zero;
+  return zero;
+}
+
+static void g ()
+{
+}
+
+static void test()
+{
+  static vector bool char zero;
+  check(vec_all_eq(f(), zero), "f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-15.c
new file mode 100644
index 000000000..ec9cf2c5a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3b-15.c
@@ -0,0 +1,19 @@
+#include "harness.h"
+
+vector unsigned char
+f (vector unsigned char a, vector unsigned char b, vector unsigned char c)
+{
+  return vec_perm(a,b,c); 
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector unsigned char){0,1,2,3,4,5,6,7,
+					    8,9,10,11,12,13,14,15}),
+		     ((vector unsigned char){70,71,72,73,74,75,76,77,
+					    78,79,80,81,82,83,84,85}),
+		     ((vector unsigned char){0x1,0x14,0x18,0x10,0x16,0x15,0x19,0x1a,
+					    0x1c,0x1c,0x1c,0x12,0x8,0x1d,0x1b,0xe})),
+		   ((vector unsigned char){1,74,78,70,76,75,79,80,82,82,82,72,8,83,81,14})),
+	"f");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-01.c
new file mode 100644
index 000000000..c6da229f4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-01.c
@@ -0,0 +1,86 @@
+#include "harness.h"
+
+vector unsigned char u8;
+vector signed char s8;
+vector bool char b8;
+vector unsigned short u16;
+vector signed short s16;
+vector bool short b16;
+vector unsigned int u32;
+vector signed int s32;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+
+static void g(void);
+
+static void f(void *p)
+{
+  u8 = vec_ld(16, (unsigned char *)p);
+  u16 = vec_ld(16, (unsigned short*)p);
+  u32 = vec_ld(16, (unsigned int*)p);
+  s8 = vec_ld(16, (signed char *)p);
+  s16 = vec_ld(16, (short*)p);
+  s32 = vec_ld(16, (int*)p);
+  g();
+  u8 = vec_ld(16, (vector unsigned char*)p);
+  s8 = vec_ld(16, (vector signed char*)p);
+  b8 = vec_ld(16, (vector bool char*)p);
+  g();
+  u16 = vec_ld(16, (vector unsigned short*)p);
+  s16 = vec_ld(16, (vector signed short*)p);
+  b16 = vec_ld(16, (vector bool short*)p);
+  g();
+  u32 = vec_ld(16, (vector unsigned int*)p);
+  s32 = vec_ld(16, (vector signed int*)p);
+  b32 = vec_ld(16, (vector bool int*)p);
+  f32 = vec_ld(16, (vector float*)p);
+  p16 = vec_ld(16, (vector pixel*)p);
+  g();
+  u8 = vec_lde(16, (unsigned char *)p);
+  u16 = vec_lde(16, (unsigned short*)p);
+  u32 = vec_lde(16, (unsigned int*)p);
+  s8 = vec_lde(16, (signed char *)p);
+  s16 = vec_lde(16, (short*)p);
+  s32 = vec_lde(16, (int*)p);
+  f32 = vec_ldl(16, (vector float*)p);
+  p16 = vec_ldl(16, (vector pixel*)p);
+  g();
+  u8 = vec_ldl(16, (vector unsigned char*)p);
+  s8 = vec_ldl(16, (vector signed char*)p);
+  b8 = vec_ldl(16, (vector bool char*)p);
+  g();
+  u16 = vec_ldl(16, (vector unsigned short*)p);
+  s16 = vec_ldl(16, (vector signed short*)p);
+  b16 = vec_ldl(16, (vector bool short*)p);
+  g();
+  u32 = vec_ldl(16, (vector unsigned int*)p);
+  s32 = vec_ldl(16, (vector signed int*)p);
+  b32 = vec_ldl(16, (vector bool int*)p);
+  f32 = vec_ldl(16, (vector float*)p);
+  p16 = vec_ldl(16, (vector pixel*)p);
+}
+
+static void g () 
+{
+}
+
+static void test()
+{
+  static vector unsigned int value = {1,-2,3,-4};
+  static vector unsigned int buffer[2];
+#define chek(v, s) check(vec_all_eq(v, value), s)
+  buffer[1] = value;
+  f((void *)buffer);
+  chek((vector unsigned int) u8, "u8");
+  chek((vector unsigned int) s8, "s8");
+  chek((vector unsigned int) b8, "b8");
+  chek((vector unsigned int) u16, "u16");
+  chek((vector unsigned int) s16, "s16");
+  chek((vector unsigned int) b16, "b16");
+  chek((vector unsigned int) u32, "u32");
+  chek((vector unsigned int) s32, "s32");
+  chek((vector unsigned int) b32, "b32");
+  chek((vector unsigned int) f32, "f32");
+  chek((vector unsigned int) p16, "p16");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-01a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-01a.c
new file mode 100644
index 000000000..2499ca665
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-01a.c
@@ -0,0 +1,1450 @@
+/* { dg-do compile } */
+#include <altivec.h>
+typedef const volatile unsigned int _1;
+typedef const  unsigned int _2;
+typedef  volatile unsigned int _3;
+typedef   unsigned int _4;
+typedef const volatile vector bool short _5;
+typedef const  vector bool short _6;
+typedef  volatile vector bool short _7;
+typedef   vector bool short _8;
+typedef const volatile signed short _9;
+typedef const  signed short _10;
+typedef  volatile signed short _11;
+typedef   signed short _12;
+typedef const volatile unsigned _13;
+typedef const  unsigned _14;
+typedef  volatile unsigned _15;
+typedef   unsigned _16;
+typedef const volatile signed short int _17;
+typedef const  signed short int _18;
+typedef  volatile signed short int _19;
+typedef   signed short int _20;
+typedef const volatile unsigned short int _21;
+typedef const  unsigned short int _22;
+typedef  volatile unsigned short int _23;
+typedef   unsigned short int _24;
+typedef const volatile vector pixel _25;
+typedef const  vector pixel _26;
+typedef  volatile vector pixel _27;
+typedef   vector pixel _28;
+typedef const volatile vector bool int _29;
+typedef const  vector bool int _30;
+typedef  volatile vector bool int _31;
+typedef   vector bool int _32;
+typedef const volatile vector signed char _33;
+typedef const  vector signed char _34;
+typedef  volatile vector signed char _35;
+typedef   vector signed char _36;
+typedef const volatile unsigned _37;
+typedef const  unsigned _38;
+typedef  volatile unsigned _39;
+typedef   unsigned _40;
+typedef const volatile signed int _41;
+typedef const  signed int _42;
+typedef  volatile signed int _43;
+typedef   signed int _44;
+typedef const volatile vector float _45;
+typedef const  vector float _46;
+typedef  volatile vector float _47;
+typedef   vector float _48;
+typedef const volatile vector signed short _49;
+typedef const  vector signed short _50;
+typedef  volatile vector signed short _51;
+typedef   vector signed short _52;
+typedef const volatile unsigned char _53;
+typedef const  unsigned char _54;
+typedef  volatile unsigned char _55;
+typedef   unsigned char _56;
+typedef const volatile signed int _57;
+typedef const  signed int _58;
+typedef  volatile signed int _59;
+typedef   signed int _60;
+typedef const volatile unsigned int _61;
+typedef const  unsigned int _62;
+typedef  volatile unsigned int _63;
+typedef   unsigned int _64;
+typedef const volatile unsigned short _65;
+typedef const  unsigned short _66;
+typedef  volatile unsigned short _67;
+typedef   unsigned short _68;
+typedef const volatile short _69;
+typedef const  short _70;
+typedef  volatile short _71;
+typedef   short _72;
+typedef const volatile int _73;
+typedef const  int _74;
+typedef  volatile int _75;
+typedef   int _76;
+typedef const volatile vector unsigned short _77;
+typedef const  vector unsigned short _78;
+typedef  volatile vector unsigned short _79;
+typedef   vector unsigned short _80;
+typedef const volatile vector bool char _81;
+typedef const  vector bool char _82;
+typedef  volatile vector bool char _83;
+typedef   vector bool char _84;
+typedef const volatile signed _85;
+typedef const  signed _86;
+typedef  volatile signed _87;
+typedef   signed _88;
+typedef const volatile vector signed int _89;
+typedef const  vector signed int _90;
+typedef  volatile vector signed int _91;
+typedef   vector signed int _92;
+typedef const volatile vector unsigned int _93;
+typedef const  vector unsigned int _94;
+typedef  volatile vector unsigned int _95;
+typedef   vector unsigned int _96;
+typedef const volatile signed _97;
+typedef const  signed _98;
+typedef  volatile signed _99;
+typedef   signed _100;
+typedef const volatile short int _101;
+typedef const  short int _102;
+typedef  volatile short int _103;
+typedef   short int _104;
+typedef const volatile int _105;
+typedef const  int _106;
+typedef  volatile int _107;
+typedef   int _108;
+typedef const volatile int _109;
+typedef const  int _110;
+typedef  volatile int _111;
+typedef   int _112;
+typedef const volatile vector unsigned char _113;
+typedef const  vector unsigned char _114;
+typedef  volatile vector unsigned char _115;
+typedef   vector unsigned char _116;
+typedef const volatile signed char _117;
+typedef const  signed char _118;
+typedef  volatile signed char _119;
+typedef   signed char _120;
+typedef const volatile float _121;
+typedef const  float _122;
+typedef  volatile float _123;
+typedef   float _124;
+
+vector unsigned char u8;
+vector signed char s8;
+vector bool char b8;
+vector unsigned short u16;
+vector signed short s16;
+vector bool short b16;
+vector unsigned int u32;
+vector signed int s32;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+
+void f(void *p)
+{
+  u8 = vec_lvsl(1,(const volatile unsigned int *)p);
+  u8 = vec_lvsl(1,(_1 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned int *)p);
+  u8 = vec_lvsr(1,(_1 *)p);
+  u8 = vec_lvsl(1,(const  unsigned int *)p);
+  u8 = vec_lvsl(1,(_2 *)p);
+  u8 = vec_lvsr(1,(const  unsigned int *)p);
+  u8 = vec_lvsr(1,(_2 *)p);
+  u32 = vec_ld(1,(const  unsigned int *)p);
+  u32 = vec_ld(1,(_2 *)p);
+  u32 = vec_lde(1,(const  unsigned int *)p);
+  u32 = vec_lde(1,(_2 *)p);
+  u32 = vec_ldl(1,(const  unsigned int *)p);
+  u32 = vec_ldl(1,(_2 *)p);
+  vec_dst((const  unsigned int *)p,1,1);
+  vec_dstst((const  unsigned int *)p,1,1);
+  vec_dststt((const  unsigned int *)p,1,1);
+  vec_dstt((const  unsigned int *)p,1,1);
+  vec_dst((_2 *)p,1,1);
+  vec_dstst((_2 *)p,1,1);
+  vec_dststt((_2 *)p,1,1);
+  vec_dstt((_2 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned int *)p);
+  u8 = vec_lvsl(1,(_3 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned int *)p);
+  u8 = vec_lvsr(1,(_3 *)p);
+  u8 = vec_lvsl(1,(  unsigned int *)p);
+  u8 = vec_lvsl(1,(_4 *)p);
+  u8 = vec_lvsr(1,(  unsigned int *)p);
+  u8 = vec_lvsr(1,(_4 *)p);
+  u32 = vec_ld(1,(  unsigned int *)p);
+  u32 = vec_ld(1,(_4 *)p);
+  u32 = vec_lde(1,(  unsigned int *)p);
+  u32 = vec_lde(1,(_4 *)p);
+  u32 = vec_ldl(1,(  unsigned int *)p);
+  u32 = vec_ldl(1,(_4 *)p);
+  vec_dst((  unsigned int *)p,1,1);
+  vec_dstst((  unsigned int *)p,1,1);
+  vec_dststt((  unsigned int *)p,1,1);
+  vec_dstt((  unsigned int *)p,1,1);
+  vec_dst((_4 *)p,1,1);
+  vec_dstst((_4 *)p,1,1);
+  vec_dststt((_4 *)p,1,1);
+  vec_dstt((_4 *)p,1,1);
+  vec_st(u32,1,(  unsigned int *)p);
+  vec_st(u32,1,(_4 *)p);
+  vec_ste(u32,1,(  unsigned int *)p);
+  vec_ste(u32,1,(_4 *)p);
+  vec_stl(u32,1,(  unsigned int *)p);
+  vec_stl(u32,1,(_4 *)p);
+  b16 = vec_ld(1,(const  vector bool short *)p);
+  b16 = vec_ld(1,(_6 *)p);
+  b16 = vec_ldl(1,(const  vector bool short *)p);
+  b16 = vec_ldl(1,(_6 *)p);
+  vec_dst((const  vector bool short *)p,1,1);
+  vec_dstst((const  vector bool short *)p,1,1);
+  vec_dststt((const  vector bool short *)p,1,1);
+  vec_dstt((const  vector bool short *)p,1,1);
+  vec_dst((_6 *)p,1,1);
+  vec_dstst((_6 *)p,1,1);
+  vec_dststt((_6 *)p,1,1);
+  vec_dstt((_6 *)p,1,1);
+  b16 = vec_ld(1,(  vector bool short *)p);
+  b16 = vec_ld(1,(_8 *)p);
+  b16 = vec_ldl(1,(  vector bool short *)p);
+  b16 = vec_ldl(1,(_8 *)p);
+  vec_dst((  vector bool short *)p,1,1);
+  vec_dstst((  vector bool short *)p,1,1);
+  vec_dststt((  vector bool short *)p,1,1);
+  vec_dstt((  vector bool short *)p,1,1);
+  vec_dst((_8 *)p,1,1);
+  vec_dstst((_8 *)p,1,1);
+  vec_dststt((_8 *)p,1,1);
+  vec_dstt((_8 *)p,1,1);
+  vec_st(b16,1,(  vector bool short *)p);
+  vec_st(b16,1,(_8 *)p);
+  vec_stl(b16,1,(  vector bool short *)p);
+  vec_stl(b16,1,(_8 *)p);
+  u8 = vec_lvsl(1,(const volatile signed short *)p);
+  u8 = vec_lvsl(1,(_9 *)p);
+  u8 = vec_lvsr(1,(const volatile signed short *)p);
+  u8 = vec_lvsr(1,(_9 *)p);
+  u8 = vec_lvsl(1,(const  signed short *)p);
+  u8 = vec_lvsl(1,(_10 *)p);
+  u8 = vec_lvsr(1,(const  signed short *)p);
+  u8 = vec_lvsr(1,(_10 *)p);
+  s16 = vec_ld(1,(const  signed short *)p);
+  s16 = vec_ld(1,(_10 *)p);
+  s16 = vec_lde(1,(const  signed short *)p);
+  s16 = vec_lde(1,(_10 *)p);
+  s16 = vec_ldl(1,(const  signed short *)p);
+  s16 = vec_ldl(1,(_10 *)p);
+  vec_dst((const  signed short *)p,1,1);
+  vec_dstst((const  signed short *)p,1,1);
+  vec_dststt((const  signed short *)p,1,1);
+  vec_dstt((const  signed short *)p,1,1);
+  vec_dst((_10 *)p,1,1);
+  vec_dstst((_10 *)p,1,1);
+  vec_dststt((_10 *)p,1,1);
+  vec_dstt((_10 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile signed short *)p);
+  u8 = vec_lvsl(1,(_11 *)p);
+  u8 = vec_lvsr(1,( volatile signed short *)p);
+  u8 = vec_lvsr(1,(_11 *)p);
+  u8 = vec_lvsl(1,(  signed short *)p);
+  u8 = vec_lvsl(1,(_12 *)p);
+  u8 = vec_lvsr(1,(  signed short *)p);
+  u8 = vec_lvsr(1,(_12 *)p);
+  s16 = vec_ld(1,(  signed short *)p);
+  s16 = vec_ld(1,(_12 *)p);
+  s16 = vec_lde(1,(  signed short *)p);
+  s16 = vec_lde(1,(_12 *)p);
+  s16 = vec_ldl(1,(  signed short *)p);
+  s16 = vec_ldl(1,(_12 *)p);
+  vec_dst((  signed short *)p,1,1);
+  vec_dstst((  signed short *)p,1,1);
+  vec_dststt((  signed short *)p,1,1);
+  vec_dstt((  signed short *)p,1,1);
+  vec_dst((_12 *)p,1,1);
+  vec_dstst((_12 *)p,1,1);
+  vec_dststt((_12 *)p,1,1);
+  vec_dstt((_12 *)p,1,1);
+  vec_st(s16,1,(  signed short *)p);
+  vec_st(s16,1,(_12 *)p);
+  vec_ste(s16,1,(  signed short *)p);
+  vec_ste(s16,1,(_12 *)p);
+  vec_stl(s16,1,(  signed short *)p);
+  vec_stl(s16,1,(_12 *)p);
+  u8 = vec_lvsl(1,(const volatile unsigned *)p);
+  u8 = vec_lvsl(1,(_13 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned *)p);
+  u8 = vec_lvsr(1,(_13 *)p);
+  u8 = vec_lvsl(1,(const  unsigned *)p);
+  u8 = vec_lvsl(1,(_14 *)p);
+  u8 = vec_lvsr(1,(const  unsigned *)p);
+  u8 = vec_lvsr(1,(_14 *)p);
+  u32 = vec_ld(1,(const  unsigned *)p);
+  u32 = vec_ld(1,(_14 *)p);
+  u32 = vec_lde(1,(const  unsigned *)p);
+  u32 = vec_lde(1,(_14 *)p);
+  u32 = vec_ldl(1,(const  unsigned *)p);
+  u32 = vec_ldl(1,(_14 *)p);
+  vec_dst((const  unsigned *)p,1,1);
+  vec_dstst((const  unsigned *)p,1,1);
+  vec_dststt((const  unsigned *)p,1,1);
+  vec_dstt((const  unsigned *)p,1,1);
+  vec_dst((_14 *)p,1,1);
+  vec_dstst((_14 *)p,1,1);
+  vec_dststt((_14 *)p,1,1);
+  vec_dstt((_14 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned *)p);
+  u8 = vec_lvsl(1,(_15 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned *)p);
+  u8 = vec_lvsr(1,(_15 *)p);
+  u8 = vec_lvsl(1,(  unsigned *)p);
+  u8 = vec_lvsl(1,(_16 *)p);
+  u8 = vec_lvsr(1,(  unsigned *)p);
+  u8 = vec_lvsr(1,(_16 *)p);
+  u32 = vec_ld(1,(  unsigned *)p);
+  u32 = vec_ld(1,(_16 *)p);
+  u32 = vec_lde(1,(  unsigned *)p);
+  u32 = vec_lde(1,(_16 *)p);
+  u32 = vec_ldl(1,(  unsigned *)p);
+  u32 = vec_ldl(1,(_16 *)p);
+  vec_dst((  unsigned *)p,1,1);
+  vec_dstst((  unsigned *)p,1,1);
+  vec_dststt((  unsigned *)p,1,1);
+  vec_dstt((  unsigned *)p,1,1);
+  vec_dst((_16 *)p,1,1);
+  vec_dstst((_16 *)p,1,1);
+  vec_dststt((_16 *)p,1,1);
+  vec_dstt((_16 *)p,1,1);
+  vec_st(u32,1,(  unsigned *)p);
+  vec_st(u32,1,(_16 *)p);
+  vec_ste(u32,1,(  unsigned *)p);
+  vec_ste(u32,1,(_16 *)p);
+  vec_stl(u32,1,(  unsigned *)p);
+  vec_stl(u32,1,(_16 *)p);
+  u8 = vec_lvsl(1,(const volatile signed short int *)p);
+  u8 = vec_lvsl(1,(_17 *)p);
+  u8 = vec_lvsr(1,(const volatile signed short int *)p);
+  u8 = vec_lvsr(1,(_17 *)p);
+  u8 = vec_lvsl(1,(const  signed short int *)p);
+  u8 = vec_lvsl(1,(_18 *)p);
+  u8 = vec_lvsr(1,(const  signed short int *)p);
+  u8 = vec_lvsr(1,(_18 *)p);
+  s16 = vec_ld(1,(const  signed short int *)p);
+  s16 = vec_ld(1,(_18 *)p);
+  s16 = vec_lde(1,(const  signed short int *)p);
+  s16 = vec_lde(1,(_18 *)p);
+  s16 = vec_ldl(1,(const  signed short int *)p);
+  s16 = vec_ldl(1,(_18 *)p);
+  vec_dst((const  signed short int *)p,1,1);
+  vec_dstst((const  signed short int *)p,1,1);
+  vec_dststt((const  signed short int *)p,1,1);
+  vec_dstt((const  signed short int *)p,1,1);
+  vec_dst((_18 *)p,1,1);
+  vec_dstst((_18 *)p,1,1);
+  vec_dststt((_18 *)p,1,1);
+  vec_dstt((_18 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile signed short int *)p);
+  u8 = vec_lvsl(1,(_19 *)p);
+  u8 = vec_lvsr(1,( volatile signed short int *)p);
+  u8 = vec_lvsr(1,(_19 *)p);
+  u8 = vec_lvsl(1,(  signed short int *)p);
+  u8 = vec_lvsl(1,(_20 *)p);
+  u8 = vec_lvsr(1,(  signed short int *)p);
+  u8 = vec_lvsr(1,(_20 *)p);
+  s16 = vec_ld(1,(  signed short int *)p);
+  s16 = vec_ld(1,(_20 *)p);
+  s16 = vec_lde(1,(  signed short int *)p);
+  s16 = vec_lde(1,(_20 *)p);
+  s16 = vec_ldl(1,(  signed short int *)p);
+  s16 = vec_ldl(1,(_20 *)p);
+  vec_dst((  signed short int *)p,1,1);
+  vec_dstst((  signed short int *)p,1,1);
+  vec_dststt((  signed short int *)p,1,1);
+  vec_dstt((  signed short int *)p,1,1);
+  vec_dst((_20 *)p,1,1);
+  vec_dstst((_20 *)p,1,1);
+  vec_dststt((_20 *)p,1,1);
+  vec_dstt((_20 *)p,1,1);
+  vec_st(s16,1,(  signed short int *)p);
+  vec_st(s16,1,(_20 *)p);
+  vec_ste(s16,1,(  signed short int *)p);
+  vec_ste(s16,1,(_20 *)p);
+  vec_stl(s16,1,(  signed short int *)p);
+  vec_stl(s16,1,(_20 *)p);
+  u8 = vec_lvsl(1,(const volatile unsigned short int *)p);
+  u8 = vec_lvsl(1,(_21 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned short int *)p);
+  u8 = vec_lvsr(1,(_21 *)p);
+  u8 = vec_lvsl(1,(const  unsigned short int *)p);
+  u8 = vec_lvsl(1,(_22 *)p);
+  u8 = vec_lvsr(1,(const  unsigned short int *)p);
+  u8 = vec_lvsr(1,(_22 *)p);
+  u16 = vec_ld(1,(const  unsigned short int *)p);
+  u16 = vec_ld(1,(_22 *)p);
+  u16 = vec_lde(1,(const  unsigned short int *)p);
+  u16 = vec_lde(1,(_22 *)p);
+  u16 = vec_ldl(1,(const  unsigned short int *)p);
+  u16 = vec_ldl(1,(_22 *)p);
+  vec_dst((const  unsigned short int *)p,1,1);
+  vec_dstst((const  unsigned short int *)p,1,1);
+  vec_dststt((const  unsigned short int *)p,1,1);
+  vec_dstt((const  unsigned short int *)p,1,1);
+  vec_dst((_22 *)p,1,1);
+  vec_dstst((_22 *)p,1,1);
+  vec_dststt((_22 *)p,1,1);
+  vec_dstt((_22 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned short int *)p);
+  u8 = vec_lvsl(1,(_23 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned short int *)p);
+  u8 = vec_lvsr(1,(_23 *)p);
+  u8 = vec_lvsl(1,(  unsigned short int *)p);
+  u8 = vec_lvsl(1,(_24 *)p);
+  u8 = vec_lvsr(1,(  unsigned short int *)p);
+  u8 = vec_lvsr(1,(_24 *)p);
+  u16 = vec_ld(1,(  unsigned short int *)p);
+  u16 = vec_ld(1,(_24 *)p);
+  u16 = vec_lde(1,(  unsigned short int *)p);
+  u16 = vec_lde(1,(_24 *)p);
+  u16 = vec_ldl(1,(  unsigned short int *)p);
+  u16 = vec_ldl(1,(_24 *)p);
+  vec_dst((  unsigned short int *)p,1,1);
+  vec_dstst((  unsigned short int *)p,1,1);
+  vec_dststt((  unsigned short int *)p,1,1);
+  vec_dstt((  unsigned short int *)p,1,1);
+  vec_dst((_24 *)p,1,1);
+  vec_dstst((_24 *)p,1,1);
+  vec_dststt((_24 *)p,1,1);
+  vec_dstt((_24 *)p,1,1);
+  vec_st(u16,1,(  unsigned short int *)p);
+  vec_st(u16,1,(_24 *)p);
+  vec_ste(u16,1,(  unsigned short int *)p);
+  vec_ste(u16,1,(_24 *)p);
+  vec_stl(u16,1,(  unsigned short int *)p);
+  vec_stl(u16,1,(_24 *)p);
+  p16 = vec_ld(1,(const  vector pixel *)p);
+  p16 = vec_ld(1,(_26 *)p);
+  p16 = vec_ldl(1,(const  vector pixel *)p);
+  p16 = vec_ldl(1,(_26 *)p);
+  vec_dst((const  vector pixel *)p,1,1);
+  vec_dstst((const  vector pixel *)p,1,1);
+  vec_dststt((const  vector pixel *)p,1,1);
+  vec_dstt((const  vector pixel *)p,1,1);
+  vec_dst((_26 *)p,1,1);
+  vec_dstst((_26 *)p,1,1);
+  vec_dststt((_26 *)p,1,1);
+  vec_dstt((_26 *)p,1,1);
+  p16 = vec_ld(1,(  vector pixel *)p);
+  p16 = vec_ld(1,(_28 *)p);
+  p16 = vec_ldl(1,(  vector pixel *)p);
+  p16 = vec_ldl(1,(_28 *)p);
+  vec_dst((  vector pixel *)p,1,1);
+  vec_dstst((  vector pixel *)p,1,1);
+  vec_dststt((  vector pixel *)p,1,1);
+  vec_dstt((  vector pixel *)p,1,1);
+  vec_dst((_28 *)p,1,1);
+  vec_dstst((_28 *)p,1,1);
+  vec_dststt((_28 *)p,1,1);
+  vec_dstt((_28 *)p,1,1);
+  vec_st(p16,1,(  vector pixel *)p);
+  vec_st(p16,1,(_28 *)p);
+  vec_stl(p16,1,(  vector pixel *)p);
+  vec_stl(p16,1,(_28 *)p);
+  b32 = vec_ld(1,(const  vector bool int *)p);
+  b32 = vec_ld(1,(_30 *)p);
+  b32 = vec_ldl(1,(const  vector bool int *)p);
+  b32 = vec_ldl(1,(_30 *)p);
+  vec_dst((const  vector bool int *)p,1,1);
+  vec_dstst((const  vector bool int *)p,1,1);
+  vec_dststt((const  vector bool int *)p,1,1);
+  vec_dstt((const  vector bool int *)p,1,1);
+  vec_dst((_30 *)p,1,1);
+  vec_dstst((_30 *)p,1,1);
+  vec_dststt((_30 *)p,1,1);
+  vec_dstt((_30 *)p,1,1);
+  b32 = vec_ld(1,(  vector bool int *)p);
+  b32 = vec_ld(1,(_32 *)p);
+  b32 = vec_ldl(1,(  vector bool int *)p);
+  b32 = vec_ldl(1,(_32 *)p);
+  vec_dst((  vector bool int *)p,1,1);
+  vec_dstst((  vector bool int *)p,1,1);
+  vec_dststt((  vector bool int *)p,1,1);
+  vec_dstt((  vector bool int *)p,1,1);
+  vec_dst((_32 *)p,1,1);
+  vec_dstst((_32 *)p,1,1);
+  vec_dststt((_32 *)p,1,1);
+  vec_dstt((_32 *)p,1,1);
+  vec_st(b32,1,(  vector bool int *)p);
+  vec_st(b32,1,(_32 *)p);
+  vec_stl(b32,1,(  vector bool int *)p);
+  vec_stl(b32,1,(_32 *)p);
+  s8 = vec_ld(1,(const  vector signed char *)p);
+  s8 = vec_ld(1,(_34 *)p);
+  s8 = vec_ldl(1,(const  vector signed char *)p);
+  s8 = vec_ldl(1,(_34 *)p);
+  vec_dst((const  vector signed char *)p,1,1);
+  vec_dstst((const  vector signed char *)p,1,1);
+  vec_dststt((const  vector signed char *)p,1,1);
+  vec_dstt((const  vector signed char *)p,1,1);
+  vec_dst((_34 *)p,1,1);
+  vec_dstst((_34 *)p,1,1);
+  vec_dststt((_34 *)p,1,1);
+  vec_dstt((_34 *)p,1,1);
+  s8 = vec_ld(1,(  vector signed char *)p);
+  s8 = vec_ld(1,(_36 *)p);
+  s8 = vec_ldl(1,(  vector signed char *)p);
+  s8 = vec_ldl(1,(_36 *)p);
+  vec_dst((  vector signed char *)p,1,1);
+  vec_dstst((  vector signed char *)p,1,1);
+  vec_dststt((  vector signed char *)p,1,1);
+  vec_dstt((  vector signed char *)p,1,1);
+  vec_dst((_36 *)p,1,1);
+  vec_dstst((_36 *)p,1,1);
+  vec_dststt((_36 *)p,1,1);
+  vec_dstt((_36 *)p,1,1);
+  vec_st(s8,1,(  vector signed char *)p);
+  vec_st(s8,1,(_36 *)p);
+  vec_stl(s8,1,(  vector signed char *)p);
+  vec_stl(s8,1,(_36 *)p);
+  u8 = vec_lvsl(1,(const volatile unsigned *)p);
+  u8 = vec_lvsl(1,(_37 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned *)p);
+  u8 = vec_lvsr(1,(_37 *)p);
+  u8 = vec_lvsl(1,(const  unsigned *)p);
+  u8 = vec_lvsl(1,(_38 *)p);
+  u8 = vec_lvsr(1,(const  unsigned *)p);
+  u8 = vec_lvsr(1,(_38 *)p);
+  u32 = vec_ld(1,(const  unsigned *)p);
+  u32 = vec_ld(1,(_38 *)p);
+  u32 = vec_lde(1,(const  unsigned *)p);
+  u32 = vec_lde(1,(_38 *)p);
+  u32 = vec_ldl(1,(const  unsigned *)p);
+  u32 = vec_ldl(1,(_38 *)p);
+  vec_dst((const  unsigned *)p,1,1);
+  vec_dstst((const  unsigned *)p,1,1);
+  vec_dststt((const  unsigned *)p,1,1);
+  vec_dstt((const  unsigned *)p,1,1);
+  vec_dst((_38 *)p,1,1);
+  vec_dstst((_38 *)p,1,1);
+  vec_dststt((_38 *)p,1,1);
+  vec_dstt((_38 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned *)p);
+  u8 = vec_lvsl(1,(_39 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned *)p);
+  u8 = vec_lvsr(1,(_39 *)p);
+  u8 = vec_lvsl(1,(  unsigned *)p);
+  u8 = vec_lvsl(1,(_40 *)p);
+  u8 = vec_lvsr(1,(  unsigned *)p);
+  u8 = vec_lvsr(1,(_40 *)p);
+  u32 = vec_ld(1,(  unsigned *)p);
+  u32 = vec_ld(1,(_40 *)p);
+  u32 = vec_lde(1,(  unsigned *)p);
+  u32 = vec_lde(1,(_40 *)p);
+  u32 = vec_ldl(1,(  unsigned *)p);
+  u32 = vec_ldl(1,(_40 *)p);
+  vec_dst((  unsigned *)p,1,1);
+  vec_dstst((  unsigned *)p,1,1);
+  vec_dststt((  unsigned *)p,1,1);
+  vec_dstt((  unsigned *)p,1,1);
+  vec_dst((_40 *)p,1,1);
+  vec_dstst((_40 *)p,1,1);
+  vec_dststt((_40 *)p,1,1);
+  vec_dstt((_40 *)p,1,1);
+  vec_st(u32,1,(  unsigned *)p);
+  vec_st(u32,1,(_40 *)p);
+  vec_ste(u32,1,(  unsigned *)p);
+  vec_ste(u32,1,(_40 *)p);
+  vec_stl(u32,1,(  unsigned *)p);
+  vec_stl(u32,1,(_40 *)p);
+  u8 = vec_lvsl(1,(const volatile signed int *)p);
+  u8 = vec_lvsl(1,(_41 *)p);
+  u8 = vec_lvsr(1,(const volatile signed int *)p);
+  u8 = vec_lvsr(1,(_41 *)p);
+  u8 = vec_lvsl(1,(const  signed int *)p);
+  u8 = vec_lvsl(1,(_42 *)p);
+  u8 = vec_lvsr(1,(const  signed int *)p);
+  u8 = vec_lvsr(1,(_42 *)p);
+  s32 = vec_ld(1,(const  signed int *)p);
+  s32 = vec_ld(1,(_42 *)p);
+  s32 = vec_lde(1,(const  signed int *)p);
+  s32 = vec_lde(1,(_42 *)p);
+  s32 = vec_ldl(1,(const  signed int *)p);
+  s32 = vec_ldl(1,(_42 *)p);
+  vec_dst((const  signed int *)p,1,1);
+  vec_dstst((const  signed int *)p,1,1);
+  vec_dststt((const  signed int *)p,1,1);
+  vec_dstt((const  signed int *)p,1,1);
+  vec_dst((_42 *)p,1,1);
+  vec_dstst((_42 *)p,1,1);
+  vec_dststt((_42 *)p,1,1);
+  vec_dstt((_42 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile signed int *)p);
+  u8 = vec_lvsl(1,(_43 *)p);
+  u8 = vec_lvsr(1,( volatile signed int *)p);
+  u8 = vec_lvsr(1,(_43 *)p);
+  u8 = vec_lvsl(1,(  signed int *)p);
+  u8 = vec_lvsl(1,(_44 *)p);
+  u8 = vec_lvsr(1,(  signed int *)p);
+  u8 = vec_lvsr(1,(_44 *)p);
+  s32 = vec_ld(1,(  signed int *)p);
+  s32 = vec_ld(1,(_44 *)p);
+  s32 = vec_lde(1,(  signed int *)p);
+  s32 = vec_lde(1,(_44 *)p);
+  s32 = vec_ldl(1,(  signed int *)p);
+  s32 = vec_ldl(1,(_44 *)p);
+  vec_dst((  signed int *)p,1,1);
+  vec_dstst((  signed int *)p,1,1);
+  vec_dststt((  signed int *)p,1,1);
+  vec_dstt((  signed int *)p,1,1);
+  vec_dst((_44 *)p,1,1);
+  vec_dstst((_44 *)p,1,1);
+  vec_dststt((_44 *)p,1,1);
+  vec_dstt((_44 *)p,1,1);
+  vec_st(s32,1,(  signed int *)p);
+  vec_st(s32,1,(_44 *)p);
+  vec_ste(s32,1,(  signed int *)p);
+  vec_ste(s32,1,(_44 *)p);
+  vec_stl(s32,1,(  signed int *)p);
+  vec_stl(s32,1,(_44 *)p);
+  f32 = vec_ld(1,(const  vector float *)p);
+  f32 = vec_ld(1,(_46 *)p);
+  f32 = vec_ldl(1,(const  vector float *)p);
+  f32 = vec_ldl(1,(_46 *)p);
+  vec_dst((const  vector float *)p,1,1);
+  vec_dstst((const  vector float *)p,1,1);
+  vec_dststt((const  vector float *)p,1,1);
+  vec_dstt((const  vector float *)p,1,1);
+  vec_dst((_46 *)p,1,1);
+  vec_dstst((_46 *)p,1,1);
+  vec_dststt((_46 *)p,1,1);
+  vec_dstt((_46 *)p,1,1);
+  f32 = vec_ld(1,(  vector float *)p);
+  f32 = vec_ld(1,(_48 *)p);
+  f32 = vec_ldl(1,(  vector float *)p);
+  f32 = vec_ldl(1,(_48 *)p);
+  vec_dst((  vector float *)p,1,1);
+  vec_dstst((  vector float *)p,1,1);
+  vec_dststt((  vector float *)p,1,1);
+  vec_dstt((  vector float *)p,1,1);
+  vec_dst((_48 *)p,1,1);
+  vec_dstst((_48 *)p,1,1);
+  vec_dststt((_48 *)p,1,1);
+  vec_dstt((_48 *)p,1,1);
+  vec_st(f32,1,(  vector float *)p);
+  vec_st(f32,1,(_48 *)p);
+  vec_stl(f32,1,(  vector float *)p);
+  vec_stl(f32,1,(_48 *)p);
+  s16 = vec_ld(1,(const  vector signed short *)p);
+  s16 = vec_ld(1,(_50 *)p);
+  s16 = vec_ldl(1,(const  vector signed short *)p);
+  s16 = vec_ldl(1,(_50 *)p);
+  vec_dst((const  vector signed short *)p,1,1);
+  vec_dstst((const  vector signed short *)p,1,1);
+  vec_dststt((const  vector signed short *)p,1,1);
+  vec_dstt((const  vector signed short *)p,1,1);
+  vec_dst((_50 *)p,1,1);
+  vec_dstst((_50 *)p,1,1);
+  vec_dststt((_50 *)p,1,1);
+  vec_dstt((_50 *)p,1,1);
+  s16 = vec_ld(1,(  vector signed short *)p);
+  s16 = vec_ld(1,(_52 *)p);
+  s16 = vec_ldl(1,(  vector signed short *)p);
+  s16 = vec_ldl(1,(_52 *)p);
+  vec_dst((  vector signed short *)p,1,1);
+  vec_dstst((  vector signed short *)p,1,1);
+  vec_dststt((  vector signed short *)p,1,1);
+  vec_dstt((  vector signed short *)p,1,1);
+  vec_dst((_52 *)p,1,1);
+  vec_dstst((_52 *)p,1,1);
+  vec_dststt((_52 *)p,1,1);
+  vec_dstt((_52 *)p,1,1);
+  vec_st(s16,1,(  vector signed short *)p);
+  vec_st(s16,1,(_52 *)p);
+  vec_stl(s16,1,(  vector signed short *)p);
+  vec_stl(s16,1,(_52 *)p);
+  u8 = vec_lvsl(1,(const volatile unsigned char *)p);
+  u8 = vec_lvsl(1,(_53 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned char *)p);
+  u8 = vec_lvsr(1,(_53 *)p);
+  u8 = vec_lvsl(1,(const  unsigned char *)p);
+  u8 = vec_lvsl(1,(_54 *)p);
+  u8 = vec_lvsr(1,(const  unsigned char *)p);
+  u8 = vec_lvsr(1,(_54 *)p);
+  u8 = vec_ld(1,(const  unsigned char *)p);
+  u8 = vec_ld(1,(_54 *)p);
+  u8 = vec_lde(1,(const  unsigned char *)p);
+  u8 = vec_lde(1,(_54 *)p);
+  u8 = vec_ldl(1,(const  unsigned char *)p);
+  u8 = vec_ldl(1,(_54 *)p);
+  vec_dst((const  unsigned char *)p,1,1);
+  vec_dstst((const  unsigned char *)p,1,1);
+  vec_dststt((const  unsigned char *)p,1,1);
+  vec_dstt((const  unsigned char *)p,1,1);
+  vec_dst((_54 *)p,1,1);
+  vec_dstst((_54 *)p,1,1);
+  vec_dststt((_54 *)p,1,1);
+  vec_dstt((_54 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned char *)p);
+  u8 = vec_lvsl(1,(_55 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned char *)p);
+  u8 = vec_lvsr(1,(_55 *)p);
+  u8 = vec_lvsl(1,(  unsigned char *)p);
+  u8 = vec_lvsl(1,(_56 *)p);
+  u8 = vec_lvsr(1,(  unsigned char *)p);
+  u8 = vec_lvsr(1,(_56 *)p);
+  u8 = vec_ld(1,(  unsigned char *)p);
+  u8 = vec_ld(1,(_56 *)p);
+  u8 = vec_lde(1,(  unsigned char *)p);
+  u8 = vec_lde(1,(_56 *)p);
+  u8 = vec_ldl(1,(  unsigned char *)p);
+  u8 = vec_ldl(1,(_56 *)p);
+  vec_dst((  unsigned char *)p,1,1);
+  vec_dstst((  unsigned char *)p,1,1);
+  vec_dststt((  unsigned char *)p,1,1);
+  vec_dstt((  unsigned char *)p,1,1);
+  vec_dst((_56 *)p,1,1);
+  vec_dstst((_56 *)p,1,1);
+  vec_dststt((_56 *)p,1,1);
+  vec_dstt((_56 *)p,1,1);
+  vec_st(u8,1,(  unsigned char *)p);
+  vec_st(u8,1,(_56 *)p);
+  vec_ste(u8,1,(  unsigned char *)p);
+  vec_ste(u8,1,(_56 *)p);
+  vec_stl(u8,1,(  unsigned char *)p);
+  vec_stl(u8,1,(_56 *)p);
+  u8 = vec_lvsl(1,(const volatile signed int *)p);
+  u8 = vec_lvsl(1,(_57 *)p);
+  u8 = vec_lvsr(1,(const volatile signed int *)p);
+  u8 = vec_lvsr(1,(_57 *)p);
+  u8 = vec_lvsl(1,(const  signed int *)p);
+  u8 = vec_lvsl(1,(_58 *)p);
+  u8 = vec_lvsr(1,(const  signed int *)p);
+  u8 = vec_lvsr(1,(_58 *)p);
+  s32 = vec_ld(1,(const  signed int *)p);
+  s32 = vec_ld(1,(_58 *)p);
+  s32 = vec_lde(1,(const  signed int *)p);
+  s32 = vec_lde(1,(_58 *)p);
+  s32 = vec_ldl(1,(const  signed int *)p);
+  s32 = vec_ldl(1,(_58 *)p);
+  vec_dst((const  signed int *)p,1,1);
+  vec_dstst((const  signed int *)p,1,1);
+  vec_dststt((const  signed int *)p,1,1);
+  vec_dstt((const  signed int *)p,1,1);
+  vec_dst((_58 *)p,1,1);
+  vec_dstst((_58 *)p,1,1);
+  vec_dststt((_58 *)p,1,1);
+  vec_dstt((_58 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile signed int *)p);
+  u8 = vec_lvsl(1,(_59 *)p);
+  u8 = vec_lvsr(1,( volatile signed int *)p);
+  u8 = vec_lvsr(1,(_59 *)p);
+  u8 = vec_lvsl(1,(  signed int *)p);
+  u8 = vec_lvsl(1,(_60 *)p);
+  u8 = vec_lvsr(1,(  signed int *)p);
+  u8 = vec_lvsr(1,(_60 *)p);
+  s32 = vec_ld(1,(  signed int *)p);
+  s32 = vec_ld(1,(_60 *)p);
+  s32 = vec_lde(1,(  signed int *)p);
+  s32 = vec_lde(1,(_60 *)p);
+  s32 = vec_ldl(1,(  signed int *)p);
+  s32 = vec_ldl(1,(_60 *)p);
+  vec_dst((  signed int *)p,1,1);
+  vec_dstst((  signed int *)p,1,1);
+  vec_dststt((  signed int *)p,1,1);
+  vec_dstt((  signed int *)p,1,1);
+  vec_dst((_60 *)p,1,1);
+  vec_dstst((_60 *)p,1,1);
+  vec_dststt((_60 *)p,1,1);
+  vec_dstt((_60 *)p,1,1);
+  vec_st(s32,1,(  signed int *)p);
+  vec_st(s32,1,(_60 *)p);
+  vec_ste(s32,1,(  signed int *)p);
+  vec_ste(s32,1,(_60 *)p);
+  vec_stl(s32,1,(  signed int *)p);
+  vec_stl(s32,1,(_60 *)p);
+  u8 = vec_lvsl(1,(const volatile unsigned int *)p);
+  u8 = vec_lvsl(1,(_61 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned int *)p);
+  u8 = vec_lvsr(1,(_61 *)p);
+  u8 = vec_lvsl(1,(const  unsigned int *)p);
+  u8 = vec_lvsl(1,(_62 *)p);
+  u8 = vec_lvsr(1,(const  unsigned int *)p);
+  u8 = vec_lvsr(1,(_62 *)p);
+  u32 = vec_ld(1,(const  unsigned int *)p);
+  u32 = vec_ld(1,(_62 *)p);
+  u32 = vec_lde(1,(const  unsigned int *)p);
+  u32 = vec_lde(1,(_62 *)p);
+  u32 = vec_ldl(1,(const  unsigned int *)p);
+  u32 = vec_ldl(1,(_62 *)p);
+  vec_dst((const  unsigned int *)p,1,1);
+  vec_dstst((const  unsigned int *)p,1,1);
+  vec_dststt((const  unsigned int *)p,1,1);
+  vec_dstt((const  unsigned int *)p,1,1);
+  vec_dst((_62 *)p,1,1);
+  vec_dstst((_62 *)p,1,1);
+  vec_dststt((_62 *)p,1,1);
+  vec_dstt((_62 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned int *)p);
+  u8 = vec_lvsl(1,(_63 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned int *)p);
+  u8 = vec_lvsr(1,(_63 *)p);
+  u8 = vec_lvsl(1,(  unsigned int *)p);
+  u8 = vec_lvsl(1,(_64 *)p);
+  u8 = vec_lvsr(1,(  unsigned int *)p);
+  u8 = vec_lvsr(1,(_64 *)p);
+  u32 = vec_ld(1,(  unsigned int *)p);
+  u32 = vec_ld(1,(_64 *)p);
+  u32 = vec_lde(1,(  unsigned int *)p);
+  u32 = vec_lde(1,(_64 *)p);
+  u32 = vec_ldl(1,(  unsigned int *)p);
+  u32 = vec_ldl(1,(_64 *)p);
+  vec_dst((  unsigned int *)p,1,1);
+  vec_dstst((  unsigned int *)p,1,1);
+  vec_dststt((  unsigned int *)p,1,1);
+  vec_dstt((  unsigned int *)p,1,1);
+  vec_dst((_64 *)p,1,1);
+  vec_dstst((_64 *)p,1,1);
+  vec_dststt((_64 *)p,1,1);
+  vec_dstt((_64 *)p,1,1);
+  vec_st(u32,1,(  unsigned int *)p);
+  vec_st(u32,1,(_64 *)p);
+  vec_ste(u32,1,(  unsigned int *)p);
+  vec_ste(u32,1,(_64 *)p);
+  vec_stl(u32,1,(  unsigned int *)p);
+  vec_stl(u32,1,(_64 *)p);
+  u8 = vec_lvsl(1,(const volatile unsigned short *)p);
+  u8 = vec_lvsl(1,(_65 *)p);
+  u8 = vec_lvsr(1,(const volatile unsigned short *)p);
+  u8 = vec_lvsr(1,(_65 *)p);
+  u8 = vec_lvsl(1,(const  unsigned short *)p);
+  u8 = vec_lvsl(1,(_66 *)p);
+  u8 = vec_lvsr(1,(const  unsigned short *)p);
+  u8 = vec_lvsr(1,(_66 *)p);
+  u16 = vec_ld(1,(const  unsigned short *)p);
+  u16 = vec_ld(1,(_66 *)p);
+  u16 = vec_lde(1,(const  unsigned short *)p);
+  u16 = vec_lde(1,(_66 *)p);
+  u16 = vec_ldl(1,(const  unsigned short *)p);
+  u16 = vec_ldl(1,(_66 *)p);
+  vec_dst((const  unsigned short *)p,1,1);
+  vec_dstst((const  unsigned short *)p,1,1);
+  vec_dststt((const  unsigned short *)p,1,1);
+  vec_dstt((const  unsigned short *)p,1,1);
+  vec_dst((_66 *)p,1,1);
+  vec_dstst((_66 *)p,1,1);
+  vec_dststt((_66 *)p,1,1);
+  vec_dstt((_66 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile unsigned short *)p);
+  u8 = vec_lvsl(1,(_67 *)p);
+  u8 = vec_lvsr(1,( volatile unsigned short *)p);
+  u8 = vec_lvsr(1,(_67 *)p);
+  u8 = vec_lvsl(1,(  unsigned short *)p);
+  u8 = vec_lvsl(1,(_68 *)p);
+  u8 = vec_lvsr(1,(  unsigned short *)p);
+  u8 = vec_lvsr(1,(_68 *)p);
+  u16 = vec_ld(1,(  unsigned short *)p);
+  u16 = vec_ld(1,(_68 *)p);
+  u16 = vec_lde(1,(  unsigned short *)p);
+  u16 = vec_lde(1,(_68 *)p);
+  u16 = vec_ldl(1,(  unsigned short *)p);
+  u16 = vec_ldl(1,(_68 *)p);
+  vec_dst((  unsigned short *)p,1,1);
+  vec_dstst((  unsigned short *)p,1,1);
+  vec_dststt((  unsigned short *)p,1,1);
+  vec_dstt((  unsigned short *)p,1,1);
+  vec_dst((_68 *)p,1,1);
+  vec_dstst((_68 *)p,1,1);
+  vec_dststt((_68 *)p,1,1);
+  vec_dstt((_68 *)p,1,1);
+  vec_st(u16,1,(  unsigned short *)p);
+  vec_st(u16,1,(_68 *)p);
+  vec_ste(u16,1,(  unsigned short *)p);
+  vec_ste(u16,1,(_68 *)p);
+  vec_stl(u16,1,(  unsigned short *)p);
+  vec_stl(u16,1,(_68 *)p);
+  u8 = vec_lvsl(1,(const volatile short *)p);
+  u8 = vec_lvsl(1,(_69 *)p);
+  u8 = vec_lvsr(1,(const volatile short *)p);
+  u8 = vec_lvsr(1,(_69 *)p);
+  u8 = vec_lvsl(1,(const  short *)p);
+  u8 = vec_lvsl(1,(_70 *)p);
+  u8 = vec_lvsr(1,(const  short *)p);
+  u8 = vec_lvsr(1,(_70 *)p);
+  s16 = vec_ld(1,(const  short *)p);
+  s16 = vec_ld(1,(_70 *)p);
+  s16 = vec_lde(1,(const  short *)p);
+  s16 = vec_lde(1,(_70 *)p);
+  s16 = vec_ldl(1,(const  short *)p);
+  s16 = vec_ldl(1,(_70 *)p);
+  vec_dst((const  short *)p,1,1);
+  vec_dstst((const  short *)p,1,1);
+  vec_dststt((const  short *)p,1,1);
+  vec_dstt((const  short *)p,1,1);
+  vec_dst((_70 *)p,1,1);
+  vec_dstst((_70 *)p,1,1);
+  vec_dststt((_70 *)p,1,1);
+  vec_dstt((_70 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile short *)p);
+  u8 = vec_lvsl(1,(_71 *)p);
+  u8 = vec_lvsr(1,( volatile short *)p);
+  u8 = vec_lvsr(1,(_71 *)p);
+  u8 = vec_lvsl(1,(  short *)p);
+  u8 = vec_lvsl(1,(_72 *)p);
+  u8 = vec_lvsr(1,(  short *)p);
+  u8 = vec_lvsr(1,(_72 *)p);
+  s16 = vec_ld(1,(  short *)p);
+  s16 = vec_ld(1,(_72 *)p);
+  s16 = vec_lde(1,(  short *)p);
+  s16 = vec_lde(1,(_72 *)p);
+  s16 = vec_ldl(1,(  short *)p);
+  s16 = vec_ldl(1,(_72 *)p);
+  vec_dst((  short *)p,1,1);
+  vec_dstst((  short *)p,1,1);
+  vec_dststt((  short *)p,1,1);
+  vec_dstt((  short *)p,1,1);
+  vec_dst((_72 *)p,1,1);
+  vec_dstst((_72 *)p,1,1);
+  vec_dststt((_72 *)p,1,1);
+  vec_dstt((_72 *)p,1,1);
+  vec_st(s16,1,(  short *)p);
+  vec_st(s16,1,(_72 *)p);
+  vec_ste(s16,1,(  short *)p);
+  vec_ste(s16,1,(_72 *)p);
+  vec_stl(s16,1,(  short *)p);
+  vec_stl(s16,1,(_72 *)p);
+  u8 = vec_lvsl(1,(const int volatile *)p);
+  u8 = vec_lvsl(1,(_73 *)p);
+  u8 = vec_lvsr(1,(const int volatile *)p);
+  u8 = vec_lvsr(1,(_73 *)p);
+  u8 = vec_lvsl(1,(const  int *)p);
+  u8 = vec_lvsl(1,(_74 *)p);
+  u8 = vec_lvsr(1,(const int *)p);
+  u8 = vec_lvsr(1,(_74 *)p);
+  s32 = vec_ld(1,(const int *)p);
+  s32 = vec_ld(1,(_74 *)p);
+  s32 = vec_lde(1,(const int *)p);
+  s32 = vec_lde(1,(_74 *)p);
+  s32 = vec_ldl(1,(const int *)p);
+  s32 = vec_ldl(1,(_74 *)p);
+  vec_dst((const int *)p,1,1);
+  vec_dstst((const int *)p,1,1);
+  vec_dststt((const int *)p,1,1);
+  vec_dstt((const int *)p,1,1);
+  vec_dst((_74 *)p,1,1);
+  vec_dstst((_74 *)p,1,1);
+  vec_dststt((_74 *)p,1,1);
+  vec_dstt((_74 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile int *)p);
+  u8 = vec_lvsl(1,(_75 *)p);
+  u8 = vec_lvsr(1,( volatile int *)p);
+  u8 = vec_lvsr(1,(_75 *)p);
+  u8 = vec_lvsl(1,( int *)p);
+  u8 = vec_lvsl(1,(_76 *)p);
+  u8 = vec_lvsr(1,( int *)p);
+  u8 = vec_lvsr(1,(_76 *)p);
+  s32 = vec_ld(1,( int *)p);
+  s32 = vec_ld(1,(_76 *)p);
+  s32 = vec_lde(1,(int *)p);
+  s32 = vec_lde(1,(_76 *)p);
+  s32 = vec_ldl(1,(int  *)p);
+  s32 = vec_ldl(1,(_76 *)p);
+  vec_dst((int  *)p,1,1);
+  vec_dstst((int  *)p,1,1);
+  vec_dststt((int  *)p,1,1);
+  vec_dstt((int  *)p,1,1);
+  vec_dst((_76 *)p,1,1);
+  vec_dstst((_76 *)p,1,1);
+  vec_dststt((_76 *)p,1,1);
+  vec_dstt((_76 *)p,1,1);
+  vec_st(s32,1,(int  *)p);
+  vec_st(s32,1,(_76 *)p);
+  vec_ste(s32,1,(int  *)p);
+  vec_ste(s32,1,(_76 *)p);
+  vec_stl(s32,1,(int  *)p);
+  vec_stl(s32,1,(_76 *)p);
+  u16 = vec_ld(1,(const  vector unsigned short *)p);
+  u16 = vec_ld(1,(_78 *)p);
+  u16 = vec_ldl(1,(const  vector unsigned short *)p);
+  u16 = vec_ldl(1,(_78 *)p);
+  vec_dst((const  vector unsigned short *)p,1,1);
+  vec_dstst((const  vector unsigned short *)p,1,1);
+  vec_dststt((const  vector unsigned short *)p,1,1);
+  vec_dstt((const  vector unsigned short *)p,1,1);
+  vec_dst((_78 *)p,1,1);
+  vec_dstst((_78 *)p,1,1);
+  vec_dststt((_78 *)p,1,1);
+  vec_dstt((_78 *)p,1,1);
+  u16 = vec_ld(1,(  vector unsigned short *)p);
+  u16 = vec_ld(1,(_80 *)p);
+  u16 = vec_ldl(1,(  vector unsigned short *)p);
+  u16 = vec_ldl(1,(_80 *)p);
+  vec_dst((  vector unsigned short *)p,1,1);
+  vec_dstst((  vector unsigned short *)p,1,1);
+  vec_dststt((  vector unsigned short *)p,1,1);
+  vec_dstt((  vector unsigned short *)p,1,1);
+  vec_dst((_80 *)p,1,1);
+  vec_dstst((_80 *)p,1,1);
+  vec_dststt((_80 *)p,1,1);
+  vec_dstt((_80 *)p,1,1);
+  vec_st(u16,1,(  vector unsigned short *)p);
+  vec_st(u16,1,(_80 *)p);
+  vec_stl(u16,1,(  vector unsigned short *)p);
+  vec_stl(u16,1,(_80 *)p);
+  b8 = vec_ld(1,(const  vector bool char *)p);
+  b8 = vec_ld(1,(_82 *)p);
+  b8 = vec_ldl(1,(const  vector bool char *)p);
+  b8 = vec_ldl(1,(_82 *)p);
+  vec_dst((const  vector bool char *)p,1,1);
+  vec_dstst((const  vector bool char *)p,1,1);
+  vec_dststt((const  vector bool char *)p,1,1);
+  vec_dstt((const  vector bool char *)p,1,1);
+  vec_dst((_82 *)p,1,1);
+  vec_dstst((_82 *)p,1,1);
+  vec_dststt((_82 *)p,1,1);
+  vec_dstt((_82 *)p,1,1);
+  b8 = vec_ld(1,(  vector bool char *)p);
+  b8 = vec_ld(1,(_84 *)p);
+  b8 = vec_ldl(1,(  vector bool char *)p);
+  b8 = vec_ldl(1,(_84 *)p);
+  vec_dst((  vector bool char *)p,1,1);
+  vec_dstst((  vector bool char *)p,1,1);
+  vec_dststt((  vector bool char *)p,1,1);
+  vec_dstt((  vector bool char *)p,1,1);
+  vec_dst((_84 *)p,1,1);
+  vec_dstst((_84 *)p,1,1);
+  vec_dststt((_84 *)p,1,1);
+  vec_dstt((_84 *)p,1,1);
+  vec_st(b8,1,(  vector bool char *)p);
+  vec_st(b8,1,(_84 *)p);
+  vec_stl(b8,1,(  vector bool char *)p);
+  vec_stl(b8,1,(_84 *)p);
+  u8 = vec_lvsl(1,(const volatile int signed *)p);
+  u8 = vec_lvsl(1,(_85 *)p);
+  u8 = vec_lvsr(1,(const volatile int signed *)p);
+  u8 = vec_lvsr(1,(_85 *)p);
+  u8 = vec_lvsl(1,(const int signed *)p);
+  u8 = vec_lvsl(1,(_86 *)p);
+  u8 = vec_lvsr(1,(const int signed *)p);
+  u8 = vec_lvsr(1,(_86 *)p);
+  s32 = vec_ld(1,(const int signed *)p);
+  s32 = vec_ld(1,(_86 *)p);
+  s32 = vec_lde(1,(const int signed *)p);
+  s32 = vec_lde(1,(_86 *)p);
+  s32 = vec_ldl(1,(const int signed *)p);
+  s32 = vec_ldl(1,(_86 *)p);
+  vec_dst((const int signed *)p,1,1);
+  vec_dstst((const int signed *)p,1,1);
+  vec_dststt((const int signed *)p,1,1);
+  vec_dstt((const int signed *)p,1,1);
+  vec_dst((_86 *)p,1,1);
+  vec_dstst((_86 *)p,1,1);
+  vec_dststt((_86 *)p,1,1);
+  vec_dstt((_86 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile int signed *)p);
+  u8 = vec_lvsl(1,(_87 *)p);
+  u8 = vec_lvsr(1,( volatile int signed *)p);
+  u8 = vec_lvsr(1,(_87 *)p);
+  u8 = vec_lvsl(1,(int  signed *)p);
+  u8 = vec_lvsl(1,(_88 *)p);
+  u8 = vec_lvsr(1,(int  signed *)p);
+  u8 = vec_lvsr(1,(_88 *)p);
+  s32 = vec_ld(1,(int  signed *)p);
+  s32 = vec_ld(1,(_88 *)p);
+  s32 = vec_lde(1,(int  signed *)p);
+  s32 = vec_lde(1,(_88 *)p);
+  s32 = vec_ldl(1,(int  signed *)p);
+  s32 = vec_ldl(1,(_88 *)p);
+  vec_dst((int signed *)p,1,1);
+  vec_dstst((int  signed *)p,1,1);
+  vec_dststt((int  signed *)p,1,1);
+  vec_dstt((int  signed *)p,1,1);
+  vec_dst((_88 *)p,1,1);
+  vec_dstst((_88 *)p,1,1);
+  vec_dststt((_88 *)p,1,1);
+  vec_dstt((_88 *)p,1,1);
+  vec_st(s32,1,(int  signed *)p);
+  vec_st(s32,1,(_88 *)p);
+  vec_ste(s32,1,(int  signed *)p);
+  vec_ste(s32,1,(_88 *)p);
+  vec_stl(s32,1,(int  signed *)p);
+  vec_stl(s32,1,(_88 *)p);
+  s32 = vec_ld(1,(const  vector signed int *)p);
+  s32 = vec_ld(1,(_90 *)p);
+  s32 = vec_ldl(1,(const  vector signed int *)p);
+  s32 = vec_ldl(1,(_90 *)p);
+  vec_dst((const  vector signed int *)p,1,1);
+  vec_dstst((const  vector signed int *)p,1,1);
+  vec_dststt((const  vector signed int *)p,1,1);
+  vec_dstt((const  vector signed int *)p,1,1);
+  vec_dst((_90 *)p,1,1);
+  vec_dstst((_90 *)p,1,1);
+  vec_dststt((_90 *)p,1,1);
+  vec_dstt((_90 *)p,1,1);
+  s32 = vec_ld(1,(  vector signed int *)p);
+  s32 = vec_ld(1,(_92 *)p);
+  s32 = vec_ldl(1,(  vector signed int *)p);
+  s32 = vec_ldl(1,(_92 *)p);
+  vec_dst((  vector signed int *)p,1,1);
+  vec_dstst((  vector signed int *)p,1,1);
+  vec_dststt((  vector signed int *)p,1,1);
+  vec_dstt((  vector signed int *)p,1,1);
+  vec_dst((_92 *)p,1,1);
+  vec_dstst((_92 *)p,1,1);
+  vec_dststt((_92 *)p,1,1);
+  vec_dstt((_92 *)p,1,1);
+  vec_st(s32,1,(  vector signed int *)p);
+  vec_st(s32,1,(_92 *)p);
+  vec_stl(s32,1,(  vector signed int *)p);
+  vec_stl(s32,1,(_92 *)p);
+  u32 = vec_ld(1,(const  vector unsigned int *)p);
+  u32 = vec_ld(1,(_94 *)p);
+  u32 = vec_ldl(1,(const  vector unsigned int *)p);
+  u32 = vec_ldl(1,(_94 *)p);
+  vec_dst((const  vector unsigned int *)p,1,1);
+  vec_dstst((const  vector unsigned int *)p,1,1);
+  vec_dststt((const  vector unsigned int *)p,1,1);
+  vec_dstt((const  vector unsigned int *)p,1,1);
+  vec_dst((_94 *)p,1,1);
+  vec_dstst((_94 *)p,1,1);
+  vec_dststt((_94 *)p,1,1);
+  vec_dstt((_94 *)p,1,1);
+  u32 = vec_ld(1,(  vector unsigned int *)p);
+  u32 = vec_ld(1,(_96 *)p);
+  u32 = vec_ldl(1,(  vector unsigned int *)p);
+  u32 = vec_ldl(1,(_96 *)p);
+  vec_dst((  vector unsigned int *)p,1,1);
+  vec_dstst((  vector unsigned int *)p,1,1);
+  vec_dststt((  vector unsigned int *)p,1,1);
+  vec_dstt((  vector unsigned int *)p,1,1);
+  vec_dst((_96 *)p,1,1);
+  vec_dstst((_96 *)p,1,1);
+  vec_dststt((_96 *)p,1,1);
+  vec_dstt((_96 *)p,1,1);
+  vec_st(u32,1,(  vector unsigned int *)p);
+  vec_st(u32,1,(_96 *)p);
+  vec_stl(u32,1,(  vector unsigned int *)p);
+  vec_stl(u32,1,(_96 *)p);
+  u8 = vec_lvsl(1,(const volatile int signed *)p);
+  u8 = vec_lvsl(1,(_97 *)p);
+  u8 = vec_lvsr(1,(const volatile int signed *)p);
+  u8 = vec_lvsr(1,(_97 *)p);
+  u8 = vec_lvsl(1,(const  int signed *)p);
+  u8 = vec_lvsl(1,(_98 *)p);
+  u8 = vec_lvsr(1,(const int signed *)p);
+  u8 = vec_lvsr(1,(_98 *)p);
+  s32 = vec_ld(1,(const int signed *)p);
+  s32 = vec_ld(1,(_98 *)p);
+  s32 = vec_lde(1,(const int signed *)p);
+  s32 = vec_lde(1,(_98 *)p);
+  s32 = vec_ldl(1,(const int signed *)p);
+  s32 = vec_ldl(1,(_98 *)p);
+  vec_dst((const int signed *)p,1,1);
+  vec_dstst((const int signed *)p,1,1);
+  vec_dststt((const int signed *)p,1,1);
+  vec_dstt((const int signed *)p,1,1);
+  vec_dst((_98 *)p,1,1);
+  vec_dstst((_98 *)p,1,1);
+  vec_dststt((_98 *)p,1,1);
+  vec_dstt((_98 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile int signed *)p);
+  u8 = vec_lvsl(1,(_99 *)p);
+  u8 = vec_lvsr(1,( volatile int signed *)p);
+  u8 = vec_lvsr(1,(_99 *)p);
+  u8 = vec_lvsl(1,(int  signed *)p);
+  u8 = vec_lvsl(1,(_100 *)p);
+  u8 = vec_lvsr(1,(int  signed *)p);
+  u8 = vec_lvsr(1,(_100 *)p);
+  s32 = vec_ld(1,(int  signed *)p);
+  s32 = vec_ld(1,(_100 *)p);
+  s32 = vec_lde(1,(int  signed *)p);
+  s32 = vec_lde(1,(_100 *)p);
+  s32 = vec_ldl(1,(int  signed *)p);
+  s32 = vec_ldl(1,(_100 *)p);
+  vec_dst((int  signed *)p,1,1);
+  vec_dstst((int  signed *)p,1,1);
+  vec_dststt((int  signed *)p,1,1);
+  vec_dstt((int  signed *)p,1,1);
+  vec_dst((_100 *)p,1,1);
+  vec_dstst((_100 *)p,1,1);
+  vec_dststt((_100 *)p,1,1);
+  vec_dstt((_100 *)p,1,1);
+  vec_st(s32,1,(int  signed *)p);
+  vec_st(s32,1,(_100 *)p);
+  vec_ste(s32,1,(int  signed *)p);
+  vec_ste(s32,1,(_100 *)p);
+  vec_stl(s32,1,(int  signed *)p);
+  vec_stl(s32,1,(_100 *)p);
+  u8 = vec_lvsl(1,(const volatile short int *)p);
+  u8 = vec_lvsl(1,(_101 *)p);
+  u8 = vec_lvsr(1,(const volatile short int *)p);
+  u8 = vec_lvsr(1,(_101 *)p);
+  u8 = vec_lvsl(1,(const  short int *)p);
+  u8 = vec_lvsl(1,(_102 *)p);
+  u8 = vec_lvsr(1,(const  short int *)p);
+  u8 = vec_lvsr(1,(_102 *)p);
+  s16 = vec_ld(1,(const  short int *)p);
+  s16 = vec_ld(1,(_102 *)p);
+  s16 = vec_lde(1,(const  short int *)p);
+  s16 = vec_lde(1,(_102 *)p);
+  s16 = vec_ldl(1,(const  short int *)p);
+  s16 = vec_ldl(1,(_102 *)p);
+  vec_dst((const  short int *)p,1,1);
+  vec_dstst((const  short int *)p,1,1);
+  vec_dststt((const  short int *)p,1,1);
+  vec_dstt((const  short int *)p,1,1);
+  vec_dst((_102 *)p,1,1);
+  vec_dstst((_102 *)p,1,1);
+  vec_dststt((_102 *)p,1,1);
+  vec_dstt((_102 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile short int *)p);
+  u8 = vec_lvsl(1,(_103 *)p);
+  u8 = vec_lvsr(1,( volatile short int *)p);
+  u8 = vec_lvsr(1,(_103 *)p);
+  u8 = vec_lvsl(1,(  short int *)p);
+  u8 = vec_lvsl(1,(_104 *)p);
+  u8 = vec_lvsr(1,(  short int *)p);
+  u8 = vec_lvsr(1,(_104 *)p);
+  s16 = vec_ld(1,(  short int *)p);
+  s16 = vec_ld(1,(_104 *)p);
+  s16 = vec_lde(1,(  short int *)p);
+  s16 = vec_lde(1,(_104 *)p);
+  s16 = vec_ldl(1,(  short int *)p);
+  s16 = vec_ldl(1,(_104 *)p);
+  vec_dst((  short int *)p,1,1);
+  vec_dstst((  short int *)p,1,1);
+  vec_dststt((  short int *)p,1,1);
+  vec_dstt((  short int *)p,1,1);
+  vec_dst((_104 *)p,1,1);
+  vec_dstst((_104 *)p,1,1);
+  vec_dststt((_104 *)p,1,1);
+  vec_dstt((_104 *)p,1,1);
+  vec_st(s16,1,(  short int *)p);
+  vec_st(s16,1,(_104 *)p);
+  vec_ste(s16,1,(  short int *)p);
+  vec_ste(s16,1,(_104 *)p);
+  vec_stl(s16,1,(  short int *)p);
+  vec_stl(s16,1,(_104 *)p);
+  u8 = vec_lvsl(1,(const volatile int *)p);
+  u8 = vec_lvsl(1,(_105 *)p);
+  u8 = vec_lvsr(1,(const volatile int *)p);
+  u8 = vec_lvsr(1,(_105 *)p);
+  u8 = vec_lvsl(1,(const  int *)p);
+  u8 = vec_lvsl(1,(_106 *)p);
+  u8 = vec_lvsr(1,(const  int *)p);
+  u8 = vec_lvsr(1,(_106 *)p);
+  s32 = vec_ld(1,(const  int *)p);
+  s32 = vec_ld(1,(_106 *)p);
+  s32 = vec_lde(1,(const  int *)p);
+  s32 = vec_lde(1,(_106 *)p);
+  s32 = vec_ldl(1,(const  int *)p);
+  s32 = vec_ldl(1,(_106 *)p);
+  vec_dst((const  int *)p,1,1);
+  vec_dstst((const  int *)p,1,1);
+  vec_dststt((const  int *)p,1,1);
+  vec_dstt((const  int *)p,1,1);
+  vec_dst((_106 *)p,1,1);
+  vec_dstst((_106 *)p,1,1);
+  vec_dststt((_106 *)p,1,1);
+  vec_dstt((_106 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile int *)p);
+  u8 = vec_lvsl(1,(_107 *)p);
+  u8 = vec_lvsr(1,( volatile int *)p);
+  u8 = vec_lvsr(1,(_107 *)p);
+  u8 = vec_lvsl(1,(  int *)p);
+  u8 = vec_lvsl(1,(_108 *)p);
+  u8 = vec_lvsr(1,(  int *)p);
+  u8 = vec_lvsr(1,(_108 *)p);
+  s32 = vec_ld(1,(  int *)p);
+  s32 = vec_ld(1,(_108 *)p);
+  s32 = vec_lde(1,(  int *)p);
+  s32 = vec_lde(1,(_108 *)p);
+  s32 = vec_ldl(1,(  int *)p);
+  s32 = vec_ldl(1,(_108 *)p);
+  vec_dst((  int *)p,1,1);
+  vec_dstst((  int *)p,1,1);
+  vec_dststt((  int *)p,1,1);
+  vec_dstt((  int *)p,1,1);
+  vec_dst((_108 *)p,1,1);
+  vec_dstst((_108 *)p,1,1);
+  vec_dststt((_108 *)p,1,1);
+  vec_dstt((_108 *)p,1,1);
+  vec_st(s32,1,(  int *)p);
+  vec_st(s32,1,(_108 *)p);
+  vec_ste(s32,1,(  int *)p);
+  vec_ste(s32,1,(_108 *)p);
+  vec_stl(s32,1,(  int *)p);
+  vec_stl(s32,1,(_108 *)p);
+  u8 = vec_lvsl(1,(const volatile int *)p);
+  u8 = vec_lvsl(1,(_109 *)p);
+  u8 = vec_lvsr(1,(const volatile int *)p);
+  u8 = vec_lvsr(1,(_109 *)p);
+  u8 = vec_lvsl(1,(const  int *)p);
+  u8 = vec_lvsl(1,(_110 *)p);
+  u8 = vec_lvsr(1,(const  int *)p);
+  u8 = vec_lvsr(1,(_110 *)p);
+  s32 = vec_ld(1,(const  int *)p);
+  s32 = vec_ld(1,(_110 *)p);
+  s32 = vec_lde(1,(const  int *)p);
+  s32 = vec_lde(1,(_110 *)p);
+  s32 = vec_ldl(1,(const  int *)p);
+  s32 = vec_ldl(1,(_110 *)p);
+  vec_dst((const  int *)p,1,1);
+  vec_dstst((const  int *)p,1,1);
+  vec_dststt((const  int *)p,1,1);
+  vec_dstt((const  int *)p,1,1);
+  vec_dst((_110 *)p,1,1);
+  vec_dstst((_110 *)p,1,1);
+  vec_dststt((_110 *)p,1,1);
+  vec_dstt((_110 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile int *)p);
+  u8 = vec_lvsl(1,(_111 *)p);
+  u8 = vec_lvsr(1,( volatile int *)p);
+  u8 = vec_lvsr(1,(_111 *)p);
+  u8 = vec_lvsl(1,(  int *)p);
+  u8 = vec_lvsl(1,(_112 *)p);
+  u8 = vec_lvsr(1,(  int *)p);
+  u8 = vec_lvsr(1,(_112 *)p);
+  s32 = vec_ld(1,(  int *)p);
+  s32 = vec_ld(1,(_112 *)p);
+  s32 = vec_lde(1,(  int *)p);
+  s32 = vec_lde(1,(_112 *)p);
+  s32 = vec_ldl(1,(  int *)p);
+  s32 = vec_ldl(1,(_112 *)p);
+  vec_dst((  int *)p,1,1);
+  vec_dstst((  int *)p,1,1);
+  vec_dststt((  int *)p,1,1);
+  vec_dstt((  int *)p,1,1);
+  vec_dst((_112 *)p,1,1);
+  vec_dstst((_112 *)p,1,1);
+  vec_dststt((_112 *)p,1,1);
+  vec_dstt((_112 *)p,1,1);
+  vec_st(s32,1,(  int *)p);
+  vec_st(s32,1,(_112 *)p);
+  vec_ste(s32,1,(  int *)p);
+  vec_ste(s32,1,(_112 *)p);
+  vec_stl(s32,1,(  int *)p);
+  vec_stl(s32,1,(_112 *)p);
+  u8 = vec_ld(1,(const  vector unsigned char *)p);
+  u8 = vec_ld(1,(_114 *)p);
+  u8 = vec_ldl(1,(const  vector unsigned char *)p);
+  u8 = vec_ldl(1,(_114 *)p);
+  vec_dst((const  vector unsigned char *)p,1,1);
+  vec_dstst((const  vector unsigned char *)p,1,1);
+  vec_dststt((const  vector unsigned char *)p,1,1);
+  vec_dstt((const  vector unsigned char *)p,1,1);
+  vec_dst((_114 *)p,1,1);
+  vec_dstst((_114 *)p,1,1);
+  vec_dststt((_114 *)p,1,1);
+  vec_dstt((_114 *)p,1,1);
+  u8 = vec_ld(1,(  vector unsigned char *)p);
+  u8 = vec_ld(1,(_116 *)p);
+  u8 = vec_ldl(1,(  vector unsigned char *)p);
+  u8 = vec_ldl(1,(_116 *)p);
+  vec_dst((  vector unsigned char *)p,1,1);
+  vec_dstst((  vector unsigned char *)p,1,1);
+  vec_dststt((  vector unsigned char *)p,1,1);
+  vec_dstt((  vector unsigned char *)p,1,1);
+  vec_dst((_116 *)p,1,1);
+  vec_dstst((_116 *)p,1,1);
+  vec_dststt((_116 *)p,1,1);
+  vec_dstt((_116 *)p,1,1);
+  vec_st(u8,1,(  vector unsigned char *)p);
+  vec_st(u8,1,(_116 *)p);
+  vec_stl(u8,1,(  vector unsigned char *)p);
+  vec_stl(u8,1,(_116 *)p);
+  u8 = vec_lvsl(1,(const volatile signed char *)p);
+  u8 = vec_lvsl(1,(_117 *)p);
+  u8 = vec_lvsr(1,(const volatile signed char *)p);
+  u8 = vec_lvsr(1,(_117 *)p);
+  u8 = vec_lvsl(1,(const  signed char *)p);
+  u8 = vec_lvsl(1,(_118 *)p);
+  u8 = vec_lvsr(1,(const  signed char *)p);
+  u8 = vec_lvsr(1,(_118 *)p);
+  s8 = vec_ld(1,(const  signed char *)p);
+  s8 = vec_ld(1,(_118 *)p);
+  s8 = vec_lde(1,(const  signed char *)p);
+  s8 = vec_lde(1,(_118 *)p);
+  s8 = vec_ldl(1,(const  signed char *)p);
+  s8 = vec_ldl(1,(_118 *)p);
+  vec_dst((const  signed char *)p,1,1);
+  vec_dstst((const  signed char *)p,1,1);
+  vec_dststt((const  signed char *)p,1,1);
+  vec_dstt((const  signed char *)p,1,1);
+  vec_dst((_118 *)p,1,1);
+  vec_dstst((_118 *)p,1,1);
+  vec_dststt((_118 *)p,1,1);
+  vec_dstt((_118 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile signed char *)p);
+  u8 = vec_lvsl(1,(_119 *)p);
+  u8 = vec_lvsr(1,( volatile signed char *)p);
+  u8 = vec_lvsr(1,(_119 *)p);
+  u8 = vec_lvsl(1,(  signed char *)p);
+  u8 = vec_lvsl(1,(_120 *)p);
+  u8 = vec_lvsr(1,(  signed char *)p);
+  u8 = vec_lvsr(1,(_120 *)p);
+  s8 = vec_ld(1,(  signed char *)p);
+  s8 = vec_ld(1,(_120 *)p);
+  s8 = vec_lde(1,(  signed char *)p);
+  s8 = vec_lde(1,(_120 *)p);
+  s8 = vec_ldl(1,(  signed char *)p);
+  s8 = vec_ldl(1,(_120 *)p);
+  vec_dst((  signed char *)p,1,1);
+  vec_dstst((  signed char *)p,1,1);
+  vec_dststt((  signed char *)p,1,1);
+  vec_dstt((  signed char *)p,1,1);
+  vec_dst((_120 *)p,1,1);
+  vec_dstst((_120 *)p,1,1);
+  vec_dststt((_120 *)p,1,1);
+  vec_dstt((_120 *)p,1,1);
+  vec_st(s8,1,(  signed char *)p);
+  vec_st(s8,1,(_120 *)p);
+  vec_ste(s8,1,(  signed char *)p);
+  vec_ste(s8,1,(_120 *)p);
+  vec_stl(s8,1,(  signed char *)p);
+  vec_stl(s8,1,(_120 *)p);
+  u8 = vec_lvsl(1,(const volatile float *)p);
+  u8 = vec_lvsl(1,(_121 *)p);
+  u8 = vec_lvsr(1,(const volatile float *)p);
+  u8 = vec_lvsr(1,(_121 *)p);
+  u8 = vec_lvsl(1,(const  float *)p);
+  u8 = vec_lvsl(1,(_122 *)p);
+  u8 = vec_lvsr(1,(const  float *)p);
+  u8 = vec_lvsr(1,(_122 *)p);
+  f32 = vec_ld(1,(const  float *)p);
+  f32 = vec_ld(1,(_122 *)p);
+  f32 = vec_lde(1,(const  float *)p);
+  f32 = vec_lde(1,(_122 *)p);
+  f32 = vec_ldl(1,(const  float *)p);
+  f32 = vec_ldl(1,(_122 *)p);
+  vec_dst((const  float *)p,1,1);
+  vec_dstst((const  float *)p,1,1);
+  vec_dststt((const  float *)p,1,1);
+  vec_dstt((const  float *)p,1,1);
+  vec_dst((_122 *)p,1,1);
+  vec_dstst((_122 *)p,1,1);
+  vec_dststt((_122 *)p,1,1);
+  vec_dstt((_122 *)p,1,1);
+  u8 = vec_lvsl(1,( volatile float *)p);
+  u8 = vec_lvsl(1,(_123 *)p);
+  u8 = vec_lvsr(1,( volatile float *)p);
+  u8 = vec_lvsr(1,(_123 *)p);
+  u8 = vec_lvsl(1,(  float *)p);
+  u8 = vec_lvsl(1,(_124 *)p);
+  u8 = vec_lvsr(1,(  float *)p);
+  u8 = vec_lvsr(1,(_124 *)p);
+  f32 = vec_ld(1,(  float *)p);
+  f32 = vec_ld(1,(_124 *)p);
+  f32 = vec_lde(1,(  float *)p);
+  f32 = vec_lde(1,(_124 *)p);
+  f32 = vec_ldl(1,(  float *)p);
+  f32 = vec_ldl(1,(_124 *)p);
+  vec_dst((  float *)p,1,1);
+  vec_dstst((  float *)p,1,1);
+  vec_dststt((  float *)p,1,1);
+  vec_dstt((  float *)p,1,1);
+  vec_dst((_124 *)p,1,1);
+  vec_dstst((_124 *)p,1,1);
+  vec_dststt((_124 *)p,1,1);
+  vec_dstt((_124 *)p,1,1);
+  vec_st(f32,1,(  float *)p);
+  vec_st(f32,1,(_124 *)p);
+  vec_ste(f32,1,(  float *)p);
+  vec_ste(f32,1,(_124 *)p);
+  vec_stl(f32,1,(  float *)p);
+  vec_stl(f32,1,(_124 *)p);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-02.c
new file mode 100644
index 000000000..1d105dde4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-02.c
@@ -0,0 +1,17 @@
+#include "harness.h"
+
+vector unsigned char u8;
+
+static void f(void *p)
+{
+  u8 = vec_ld(1, (unsigned char *)p);
+}
+
+static void test()
+{
+  static vector unsigned int value = {1,-2,3,-4};
+  static vector unsigned int buffer[2];
+  buffer[1] = value;
+  f((void *)(-1+(char*)(buffer+1)));
+  check(vec_all_eq((vector unsigned int) u8, value), "u8");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-03.c
new file mode 100644
index 000000000..2228c0357
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3c-03.c
@@ -0,0 +1,17 @@
+#include "harness.h"
+
+vector unsigned char u8;
+
+static void f(int i, void *p)
+{
+  u8 = vec_ld(i, (unsigned char *)p);
+}
+
+static void test()
+{
+  static vector unsigned int value = {1,-2,3,-4};
+  static vector unsigned int buffer[2];
+  buffer[1] = value;
+  f(37,(void *)(-37+(char*)(buffer+1)));
+  check(vec_all_eq((vector unsigned int) u8, value), "u8");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3d-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3d-01.c
new file mode 100644
index 000000000..48657c866
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/3d-01.c
@@ -0,0 +1,171 @@
+/* { dg-do compile } */
+#include <altivec.h>
+int i;
+
+void
+test_vec_all_gt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_all_gt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_all_le(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_all_le(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_any_gt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_any_gt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_any_le(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_any_le(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_all_lt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_all_lt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_all_ge(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_all_ge(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_any_lt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_any_lt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_any_ge(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_any_ge(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_all_eq(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_all_eq(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_all_ne(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_all_ne(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_any_eq(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_any_eq(u8a, u8b))
+    i = 1;
+}
+
+void
+test_vec_any_ne(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (vec_any_ne(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_all_gt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_all_gt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_all_le(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_all_le(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_any_gt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_any_gt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_any_le(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_any_le(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_all_lt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_all_lt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_all_ge(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_all_ge(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_any_lt(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_any_lt(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_any_ge(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_any_ge(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_all_eq(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_all_eq(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_all_ne(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_all_ne(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_any_eq(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_any_eq(u8a, u8b))
+    i = 1;
+}
+
+void
+test_not_vec_any_ne(vector unsigned char u8a, vector unsigned char u8b)
+{
+  if (!vec_any_ne(u8a, u8b))
+    i = 1;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/4-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/4-01.c
new file mode 100644
index 000000000..f454a2eda
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/4-01.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned int
+f(vector signed char a)
+{
+  return (vector unsigned int)(a); 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/4-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/4-03.c
new file mode 100644
index 000000000..1c3ccd746
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/4-03.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned int
+f(vector signed char a)
+{
+  return (vector unsigned int)a; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-01.c
new file mode 100644
index 000000000..c3cb6e990
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-01.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned int a = {1,1,1,1};
+vector unsigned int b = {1,2,3,4};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-02.c
new file mode 100644
index 000000000..0bb4eb008
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-02.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector float a = {1,1,1,1};
+vector float b = {1,2.0,3,4U};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-03.c
new file mode 100644
index 000000000..3d048e87b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-03.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned char u8 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+vector signed char s8 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+vector bool char b8 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+vector unsigned short u16 = {1,1,1,1,1,1,1,1};
+vector signed short s16 = {1,1,1,1,1,1,1,1};
+vector bool short b16 = {1,1,1,1,1,1,1,1};
+vector unsigned int u32 = {1,1,1,1};
+vector signed int s32 = {1,1,1,1};
+vector bool int b32 = {1,1,1,1};
+vector float f32 = {1,1,1,1};
+vector pixel p16 = {1,1,1,1,1,1,1,1};
+
+vector unsigned char u8_
+  = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+vector signed char s8_
+  = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+vector bool char b8_
+  = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+vector unsigned short u16_ = {1,2,3,4,5,6,7,8};
+vector signed short s16_ = {1,2,3,4,5,6,7,8};
+vector bool short b16_ = {1,2,3,4,5,6,7,8};
+vector unsigned int u32_ = {1,2,3,4};
+vector signed int s32_ = {1,2,3,4};
+vector bool int b32_ = {1,2,3,4};
+vector float f32_ = {1,2,3,4};
+vector pixel p16_ = {1,2,3,4,5,6,7,8};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-04.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-04.c
new file mode 100644
index 000000000..c5135e888
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-04.c
@@ -0,0 +1,10 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned int a;
+vector unsigned int b;
+void
+f(void) 
+{
+  a = ((vector unsigned int){1,1,1,1});
+  b = ((vector unsigned int){1,2,3,4});
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-07t.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-07t.c
new file mode 100644
index 000000000..c03e6558f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-07t.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+#include <altivec.h>
+typedef vector unsigned char t_u8;
+typedef vector signed char t_s8;
+typedef vector bool char t_b8;
+typedef vector unsigned short t_u16;
+typedef vector signed short t_s16;
+typedef vector bool short t_b16;
+typedef vector unsigned int t_u32;
+typedef vector signed int t_s32;
+typedef vector bool int t_b32;
+typedef vector float t_f32;
+typedef vector pixel t_p16;
+
+t_u8 u8 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+t_s8 s8 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+t_b8 b8 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+t_u16 u16 = {1,1,1,1,1,1,1,1};
+t_s16 s16 = {1,1,1,1,1,1,1,1};
+t_b16 b16 = {1,1,1,1,1,1,1,1};
+t_u32 u32 = {1,1,1,1};
+t_s32 s32 = {1,1,1,1};
+t_b32 b32 = {1,1,1,1};
+t_f32 f32 = {1,1,1,1};
+t_p16 p16 = {1,1,1,1,1,1,1,1};
+
+t_u8 u8_ = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+t_s8 s8_ = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+t_b8 b8_ = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+t_u16 u16_ = {1,2,3,4,5,6,7,8};
+t_s16 s16_ = {1,2,3,4,5,6,7,8};
+t_b16 b16_ = {1,2,3,4,5,6,7,8};
+t_u32 u32_ = {1,2,3,4};
+t_s32 s32_ = {1,2,3,4};
+t_b32 b32_ = {1,2,3,4};
+t_f32 f32_ = {1,2,3,4};
+t_p16 p16_ = {1,2,3,4,5,6,7,8};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-10.c
new file mode 100644
index 000000000..5f1b6ddc1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-10.c
@@ -0,0 +1,1352 @@
+/* { dg-do compile } */
+#include <altivec.h>
+void fu32a(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0,0,0,0});
+  *u32++ = ((vector unsigned int){1,1,1,1});
+  *u32++ = ((vector unsigned int){2,2,2,2});
+  *u32++ = ((vector unsigned int){3,3,3,3});
+  *u32++ = ((vector unsigned int){4,4,4,4});
+  *u32++ = ((vector unsigned int){5,5,5,5});
+  *u32++ = ((vector unsigned int){6,6,6,6});
+  *u32++ = ((vector unsigned int){7,7,7,7});
+  *u32++ = ((vector unsigned int){8,8,8,8});
+  *u32++ = ((vector unsigned int){9,9,9,9});
+  *u32++ = ((vector unsigned int){10,10,10,10});
+  *u32++ = ((vector unsigned int){11,11,11,11});
+  *u32++ = ((vector unsigned int){12,12,12,12});
+  *u32++ = ((vector unsigned int){13,13,13,13});
+  *u32++ = ((vector unsigned int){14,14,14,14});
+  *u32++ = ((vector unsigned int){15,15,15,15});
+}
+void fu32b(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){65537,65537,65537,65537});
+  *u32++ = ((vector unsigned int){131074,131074,131074,131074});
+  *u32++ = ((vector unsigned int){196611,196611,196611,196611});
+  *u32++ = ((vector unsigned int){262148,262148,262148,262148});
+  *u32++ = ((vector unsigned int){327685,327685,327685,327685});
+  *u32++ = ((vector unsigned int){393222,393222,393222,393222});
+  *u32++ = ((vector unsigned int){458759,458759,458759,458759});
+  *u32++ = ((vector unsigned int){524296,524296,524296,524296});
+  *u32++ = ((vector unsigned int){589833,589833,589833,589833});
+  *u32++ = ((vector unsigned int){655370,655370,655370,655370});
+  *u32++ = ((vector unsigned int){720907,720907,720907,720907});
+  *u32++ = ((vector unsigned int){786444,786444,786444,786444});
+  *u32++ = ((vector unsigned int){851981,851981,851981,851981});
+  *u32++ = ((vector unsigned int){917518,917518,917518,917518});
+  *u32++ = ((vector unsigned int){983055,983055,983055,983055});
+}
+void fu32c(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){16843009,16843009,16843009,16843009});
+  *u32++ = ((vector unsigned int){33686018,33686018,33686018,33686018});
+  *u32++ = ((vector unsigned int){50529027,50529027,50529027,50529027});
+  *u32++ = ((vector unsigned int){67372036,67372036,67372036,67372036});
+  *u32++ = ((vector unsigned int){84215045,84215045,84215045,84215045});
+  *u32++ = ((vector unsigned int){101058054,101058054,101058054,101058054});
+  *u32++ = ((vector unsigned int){117901063,117901063,117901063,117901063});
+  *u32++ = ((vector unsigned int){134744072,134744072,134744072,134744072});
+  *u32++ = ((vector unsigned int){151587081,151587081,151587081,151587081});
+  *u32++ = ((vector unsigned int){168430090,168430090,168430090,168430090});
+  *u32++ = ((vector unsigned int){185273099,185273099,185273099,185273099});
+  *u32++ = ((vector unsigned int){202116108,202116108,202116108,202116108});
+  *u32++ = ((vector unsigned int){218959117,218959117,218959117,218959117});
+  *u32++ = ((vector unsigned int){235802126,235802126,235802126,235802126});
+  *u32++ = ((vector unsigned int){252645135,252645135,252645135,252645135});
+}
+void fu32d(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){4042322160,4042322160,4042322160,4042322160});
+  *u32++ = ((vector unsigned int){4059165169,4059165169,4059165169,4059165169});
+  *u32++ = ((vector unsigned int){4076008178,4076008178,4076008178,4076008178});
+  *u32++ = ((vector unsigned int){4092851187,4092851187,4092851187,4092851187});
+  *u32++ = ((vector unsigned int){4109694196,4109694196,4109694196,4109694196});
+  *u32++ = ((vector unsigned int){4126537205,4126537205,4126537205,4126537205});
+  *u32++ = ((vector unsigned int){4143380214,4143380214,4143380214,4143380214});
+  *u32++ = ((vector unsigned int){4160223223,4160223223,4160223223,4160223223});
+  *u32++ = ((vector unsigned int){4177066232,4177066232,4177066232,4177066232});
+  *u32++ = ((vector unsigned int){4193909241,4193909241,4193909241,4193909241});
+  *u32++ = ((vector unsigned int){4210752250,4210752250,4210752250,4210752250});
+  *u32++ = ((vector unsigned int){4227595259,4227595259,4227595259,4227595259});
+  *u32++ = ((vector unsigned int){4244438268,4244438268,4244438268,4244438268});
+  *u32++ = ((vector unsigned int){4261281277,4261281277,4261281277,4261281277});
+  *u32++ = ((vector unsigned int){4278124286,4278124286,4278124286,4278124286});
+}
+void fu32e(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){4293984240,4293984240,4293984240,4293984240});
+  *u32++ = ((vector unsigned int){4294049777,4294049777,4294049777,4294049777});
+  *u32++ = ((vector unsigned int){4294115314,4294115314,4294115314,4294115314});
+  *u32++ = ((vector unsigned int){4294180851,4294180851,4294180851,4294180851});
+  *u32++ = ((vector unsigned int){4294246388,4294246388,4294246388,4294246388});
+  *u32++ = ((vector unsigned int){4294311925,4294311925,4294311925,4294311925});
+  *u32++ = ((vector unsigned int){4294377462,4294377462,4294377462,4294377462});
+  *u32++ = ((vector unsigned int){4294442999,4294442999,4294442999,4294442999});
+  *u32++ = ((vector unsigned int){4294508536,4294508536,4294508536,4294508536});
+  *u32++ = ((vector unsigned int){4294574073,4294574073,4294574073,4294574073});
+  *u32++ = ((vector unsigned int){4294639610,4294639610,4294639610,4294639610});
+  *u32++ = ((vector unsigned int){4294705147,4294705147,4294705147,4294705147});
+  *u32++ = ((vector unsigned int){4294770684,4294770684,4294770684,4294770684});
+  *u32++ = ((vector unsigned int){4294836221,4294836221,4294836221,4294836221});
+  *u32++ = ((vector unsigned int){4294901758,4294901758,4294901758,4294901758});
+}
+void fu32f(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){4294967280,4294967280,4294967280,4294967280});
+  *u32++ = ((vector unsigned int){4294967281,4294967281,4294967281,4294967281});
+  *u32++ = ((vector unsigned int){4294967282,4294967282,4294967282,4294967282});
+  *u32++ = ((vector unsigned int){4294967283,4294967283,4294967283,4294967283});
+  *u32++ = ((vector unsigned int){4294967284,4294967284,4294967284,4294967284});
+  *u32++ = ((vector unsigned int){4294967285,4294967285,4294967285,4294967285});
+  *u32++ = ((vector unsigned int){4294967286,4294967286,4294967286,4294967286});
+  *u32++ = ((vector unsigned int){4294967287,4294967287,4294967287,4294967287});
+  *u32++ = ((vector unsigned int){4294967288,4294967288,4294967288,4294967288});
+  *u32++ = ((vector unsigned int){4294967289,4294967289,4294967289,4294967289});
+  *u32++ = ((vector unsigned int){4294967290,4294967290,4294967290,4294967290});
+  *u32++ = ((vector unsigned int){4294967291,4294967291,4294967291,4294967291});
+  *u32++ = ((vector unsigned int){4294967292,4294967292,4294967292,4294967292});
+  *u32++ = ((vector unsigned int){4294967293,4294967293,4294967293,4294967293});
+  *u32++ = ((vector unsigned int){4294967294,4294967294,4294967294,4294967294});
+  *u32++ = ((vector unsigned int){4294967295,4294967295,4294967295,4294967295});
+}
+void fu32g(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){-252645136,-252645136,-252645136,-252645136});
+  *u32++ = ((vector unsigned int){-235802127,-235802127,-235802127,-235802127});
+  *u32++ = ((vector unsigned int){-218959118,-218959118,-218959118,-218959118});
+  *u32++ = ((vector unsigned int){-202116109,-202116109,-202116109,-202116109});
+  *u32++ = ((vector unsigned int){-185273100,-185273100,-185273100,-185273100});
+  *u32++ = ((vector unsigned int){-168430091,-168430091,-168430091,-168430091});
+  *u32++ = ((vector unsigned int){-151587082,-151587082,-151587082,-151587082});
+  *u32++ = ((vector unsigned int){-134744073,-134744073,-134744073,-134744073});
+  *u32++ = ((vector unsigned int){-117901064,-117901064,-117901064,-117901064});
+  *u32++ = ((vector unsigned int){-101058055,-101058055,-101058055,-101058055});
+  *u32++ = ((vector unsigned int){-84215046,-84215046,-84215046,-84215046});
+  *u32++ = ((vector unsigned int){-67372037,-67372037,-67372037,-67372037});
+  *u32++ = ((vector unsigned int){-50529028,-50529028,-50529028,-50529028});
+  *u32++ = ((vector unsigned int){-33686019,-33686019,-33686019,-33686019});
+  *u32++ = ((vector unsigned int){-16843010,-16843010,-16843010,-16843010});
+}
+void fu32h(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){-983056,-983056,-983056,-983056});
+  *u32++ = ((vector unsigned int){-917519,-917519,-917519,-917519});
+  *u32++ = ((vector unsigned int){-851982,-851982,-851982,-851982});
+  *u32++ = ((vector unsigned int){-786445,-786445,-786445,-786445});
+  *u32++ = ((vector unsigned int){-720908,-720908,-720908,-720908});
+  *u32++ = ((vector unsigned int){-655371,-655371,-655371,-655371});
+  *u32++ = ((vector unsigned int){-589834,-589834,-589834,-589834});
+  *u32++ = ((vector unsigned int){-524297,-524297,-524297,-524297});
+  *u32++ = ((vector unsigned int){-458760,-458760,-458760,-458760});
+  *u32++ = ((vector unsigned int){-393223,-393223,-393223,-393223});
+  *u32++ = ((vector unsigned int){-327686,-327686,-327686,-327686});
+  *u32++ = ((vector unsigned int){-262149,-262149,-262149,-262149});
+  *u32++ = ((vector unsigned int){-196612,-196612,-196612,-196612});
+  *u32++ = ((vector unsigned int){-131075,-131075,-131075,-131075});
+  *u32++ = ((vector unsigned int){-65538,-65538,-65538,-65538});
+}
+void fu32i(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){-16,-16,-16,-16});
+  *u32++ = ((vector unsigned int){-15,-15,-15,-15});
+  *u32++ = ((vector unsigned int){-14,-14,-14,-14});
+  *u32++ = ((vector unsigned int){-13,-13,-13,-13});
+  *u32++ = ((vector unsigned int){-12,-12,-12,-12});
+  *u32++ = ((vector unsigned int){-11,-11,-11,-11});
+  *u32++ = ((vector unsigned int){-10,-10,-10,-10});
+  *u32++ = ((vector unsigned int){-9,-9,-9,-9});
+  *u32++ = ((vector unsigned int){-8,-8,-8,-8});
+  *u32++ = ((vector unsigned int){-7,-7,-7,-7});
+  *u32++ = ((vector unsigned int){-6,-6,-6,-6});
+  *u32++ = ((vector unsigned int){-5,-5,-5,-5});
+  *u32++ = ((vector unsigned int){-4,-4,-4,-4});
+  *u32++ = ((vector unsigned int){-3,-3,-3,-3});
+  *u32++ = ((vector unsigned int){-2,-2,-2,-2});
+  *u32++ = ((vector unsigned int){-1,-1,-1,-1});
+}
+void fu32j(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0xfffffff0,0xfffffff0,0xfffffff0,0xfffffff0});
+  *u32++ = ((vector unsigned int){0xfffffff1,0xfffffff1,0xfffffff1,0xfffffff1});
+  *u32++ = ((vector unsigned int){0xfffffff2,0xfffffff2,0xfffffff2,0xfffffff2});
+  *u32++ = ((vector unsigned int){0xfffffff3,0xfffffff3,0xfffffff3,0xfffffff3});
+  *u32++ = ((vector unsigned int){0xfffffff4,0xfffffff4,0xfffffff4,0xfffffff4});
+  *u32++ = ((vector unsigned int){0xfffffff5,0xfffffff5,0xfffffff5,0xfffffff5});
+  *u32++ = ((vector unsigned int){0xfffffff6,0xfffffff6,0xfffffff6,0xfffffff6});
+  *u32++ = ((vector unsigned int){0xfffffff7,0xfffffff7,0xfffffff7,0xfffffff7});
+  *u32++ = ((vector unsigned int){0xfffffff8,0xfffffff8,0xfffffff8,0xfffffff8});
+  *u32++ = ((vector unsigned int){0xfffffff9,0xfffffff9,0xfffffff9,0xfffffff9});
+  *u32++ = ((vector unsigned int){0xfffffffa,0xfffffffa,0xfffffffa,0xfffffffa});
+  *u32++ = ((vector unsigned int){0xfffffffb,0xfffffffb,0xfffffffb,0xfffffffb});
+  *u32++ = ((vector unsigned int){0xfffffffc,0xfffffffc,0xfffffffc,0xfffffffc});
+  *u32++ = ((vector unsigned int){0xfffffffd,0xfffffffd,0xfffffffd,0xfffffffd});
+  *u32++ = ((vector unsigned int){0xfffffffe,0xfffffffe,0xfffffffe,0xfffffffe});
+  *u32++ = ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fu32k(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *u32++ = ((vector unsigned int){0x00000001,0x00000001,0x00000001,0x00000001});
+  *u32++ = ((vector unsigned int){0x00000002,0x00000002,0x00000002,0x00000002});
+  *u32++ = ((vector unsigned int){0x00000003,0x00000003,0x00000003,0x00000003});
+  *u32++ = ((vector unsigned int){0x00000004,0x00000004,0x00000004,0x00000004});
+  *u32++ = ((vector unsigned int){0x00000005,0x00000005,0x00000005,0x00000005});
+  *u32++ = ((vector unsigned int){0x00000006,0x00000006,0x00000006,0x00000006});
+  *u32++ = ((vector unsigned int){0x00000007,0x00000007,0x00000007,0x00000007});
+  *u32++ = ((vector unsigned int){0x00000008,0x00000008,0x00000008,0x00000008});
+  *u32++ = ((vector unsigned int){0x00000009,0x00000009,0x00000009,0x00000009});
+  *u32++ = ((vector unsigned int){0x0000000a,0x0000000a,0x0000000a,0x0000000a});
+  *u32++ = ((vector unsigned int){0x0000000b,0x0000000b,0x0000000b,0x0000000b});
+  *u32++ = ((vector unsigned int){0x0000000c,0x0000000c,0x0000000c,0x0000000c});
+  *u32++ = ((vector unsigned int){0x0000000d,0x0000000d,0x0000000d,0x0000000d});
+  *u32++ = ((vector unsigned int){0x0000000e,0x0000000e,0x0000000e,0x0000000e});
+  *u32++ = ((vector unsigned int){0x0000000f,0x0000000f,0x0000000f,0x0000000f});
+}
+void fu32l(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0xfff0fff0,0xfff0fff0,0xfff0fff0,0xfff0fff0});
+  *u32++ = ((vector unsigned int){0xfff1fff1,0xfff1fff1,0xfff1fff1,0xfff1fff1});
+  *u32++ = ((vector unsigned int){0xfff2fff2,0xfff2fff2,0xfff2fff2,0xfff2fff2});
+  *u32++ = ((vector unsigned int){0xfff3fff3,0xfff3fff3,0xfff3fff3,0xfff3fff3});
+  *u32++ = ((vector unsigned int){0xfff4fff4,0xfff4fff4,0xfff4fff4,0xfff4fff4});
+  *u32++ = ((vector unsigned int){0xfff5fff5,0xfff5fff5,0xfff5fff5,0xfff5fff5});
+  *u32++ = ((vector unsigned int){0xfff6fff6,0xfff6fff6,0xfff6fff6,0xfff6fff6});
+  *u32++ = ((vector unsigned int){0xfff7fff7,0xfff7fff7,0xfff7fff7,0xfff7fff7});
+  *u32++ = ((vector unsigned int){0xfff8fff8,0xfff8fff8,0xfff8fff8,0xfff8fff8});
+  *u32++ = ((vector unsigned int){0xfff9fff9,0xfff9fff9,0xfff9fff9,0xfff9fff9});
+  *u32++ = ((vector unsigned int){0xfffafffa,0xfffafffa,0xfffafffa,0xfffafffa});
+  *u32++ = ((vector unsigned int){0xfffbfffb,0xfffbfffb,0xfffbfffb,0xfffbfffb});
+  *u32++ = ((vector unsigned int){0xfffcfffc,0xfffcfffc,0xfffcfffc,0xfffcfffc});
+  *u32++ = ((vector unsigned int){0xfffdfffd,0xfffdfffd,0xfffdfffd,0xfffdfffd});
+  *u32++ = ((vector unsigned int){0xfffefffe,0xfffefffe,0xfffefffe,0xfffefffe});
+  *u32++ = ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fu32m(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *u32++ = ((vector unsigned int){0x00010001,0x00010001,0x00010001,0x00010001});
+  *u32++ = ((vector unsigned int){0x00020002,0x00020002,0x00020002,0x00020002});
+  *u32++ = ((vector unsigned int){0x00030003,0x00030003,0x00030003,0x00030003});
+  *u32++ = ((vector unsigned int){0x00040004,0x00040004,0x00040004,0x00040004});
+  *u32++ = ((vector unsigned int){0x00050005,0x00050005,0x00050005,0x00050005});
+  *u32++ = ((vector unsigned int){0x00060006,0x00060006,0x00060006,0x00060006});
+  *u32++ = ((vector unsigned int){0x00070007,0x00070007,0x00070007,0x00070007});
+  *u32++ = ((vector unsigned int){0x00080008,0x00080008,0x00080008,0x00080008});
+  *u32++ = ((vector unsigned int){0x00090009,0x00090009,0x00090009,0x00090009});
+  *u32++ = ((vector unsigned int){0x000a000a,0x000a000a,0x000a000a,0x000a000a});
+  *u32++ = ((vector unsigned int){0x000b000b,0x000b000b,0x000b000b,0x000b000b});
+  *u32++ = ((vector unsigned int){0x000c000c,0x000c000c,0x000c000c,0x000c000c});
+  *u32++ = ((vector unsigned int){0x000d000d,0x000d000d,0x000d000d,0x000d000d});
+  *u32++ = ((vector unsigned int){0x000e000e,0x000e000e,0x000e000e,0x000e000e});
+  *u32++ = ((vector unsigned int){0x000f000f,0x000f000f,0x000f000f,0x000f000f});
+}
+void fu32n(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0});
+  *u32++ = ((vector unsigned int){0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1});
+  *u32++ = ((vector unsigned int){0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2});
+  *u32++ = ((vector unsigned int){0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3});
+  *u32++ = ((vector unsigned int){0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4});
+  *u32++ = ((vector unsigned int){0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5});
+  *u32++ = ((vector unsigned int){0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6});
+  *u32++ = ((vector unsigned int){0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7});
+  *u32++ = ((vector unsigned int){0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8});
+  *u32++ = ((vector unsigned int){0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9});
+  *u32++ = ((vector unsigned int){0xfafafafa,0xfafafafa,0xfafafafa,0xfafafafa});
+  *u32++ = ((vector unsigned int){0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb});
+  *u32++ = ((vector unsigned int){0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc});
+  *u32++ = ((vector unsigned int){0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd});
+  *u32++ = ((vector unsigned int){0xfefefefe,0xfefefefe,0xfefefefe,0xfefefefe});
+  *u32++ = ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fu32o(vector unsigned int *u32) 
+{
+  *u32++ = ((vector unsigned int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *u32++ = ((vector unsigned int){0x01010101,0x01010101,0x01010101,0x01010101});
+  *u32++ = ((vector unsigned int){0x02020202,0x02020202,0x02020202,0x02020202});
+  *u32++ = ((vector unsigned int){0x03030303,0x03030303,0x03030303,0x03030303});
+  *u32++ = ((vector unsigned int){0x04040404,0x04040404,0x04040404,0x04040404});
+  *u32++ = ((vector unsigned int){0x05050505,0x05050505,0x05050505,0x05050505});
+  *u32++ = ((vector unsigned int){0x06060606,0x06060606,0x06060606,0x06060606});
+  *u32++ = ((vector unsigned int){0x07070707,0x07070707,0x07070707,0x07070707});
+  *u32++ = ((vector unsigned int){0x08080808,0x08080808,0x08080808,0x08080808});
+  *u32++ = ((vector unsigned int){0x09090909,0x09090909,0x09090909,0x09090909});
+  *u32++ = ((vector unsigned int){0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a});
+  *u32++ = ((vector unsigned int){0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b});
+  *u32++ = ((vector unsigned int){0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c});
+  *u32++ = ((vector unsigned int){0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d});
+  *u32++ = ((vector unsigned int){0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e});
+  *u32++ = ((vector unsigned int){0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f});
+}
+void fu16a(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0});
+  *u16++ = ((vector unsigned short){0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1});
+  *u16++ = ((vector unsigned short){0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2});
+  *u16++ = ((vector unsigned short){0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3});
+  *u16++ = ((vector unsigned short){0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4});
+  *u16++ = ((vector unsigned short){0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5});
+  *u16++ = ((vector unsigned short){0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6});
+  *u16++ = ((vector unsigned short){0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7});
+  *u16++ = ((vector unsigned short){0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8});
+  *u16++ = ((vector unsigned short){0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9});
+  *u16++ = ((vector unsigned short){0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa});
+  *u16++ = ((vector unsigned short){0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb});
+  *u16++ = ((vector unsigned short){0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc});
+  *u16++ = ((vector unsigned short){0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd});
+  *u16++ = ((vector unsigned short){0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe});
+  *u16++ = ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fu16b(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *u16++ = ((vector unsigned short){0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,0x0000,0x0001});
+  *u16++ = ((vector unsigned short){0x0000,0x0002,0x0000,0x0002,0x0000,0x0002,0x0000,0x0002});
+  *u16++ = ((vector unsigned short){0x0000,0x0003,0x0000,0x0003,0x0000,0x0003,0x0000,0x0003});
+  *u16++ = ((vector unsigned short){0x0000,0x0004,0x0000,0x0004,0x0000,0x0004,0x0000,0x0004});
+  *u16++ = ((vector unsigned short){0x0000,0x0005,0x0000,0x0005,0x0000,0x0005,0x0000,0x0005});
+  *u16++ = ((vector unsigned short){0x0000,0x0006,0x0000,0x0006,0x0000,0x0006,0x0000,0x0006});
+  *u16++ = ((vector unsigned short){0x0000,0x0007,0x0000,0x0007,0x0000,0x0007,0x0000,0x0007});
+  *u16++ = ((vector unsigned short){0x0000,0x0008,0x0000,0x0008,0x0000,0x0008,0x0000,0x0008});
+  *u16++ = ((vector unsigned short){0x0000,0x0009,0x0000,0x0009,0x0000,0x0009,0x0000,0x0009});
+  *u16++ = ((vector unsigned short){0x0000,0x000a,0x0000,0x000a,0x0000,0x000a,0x0000,0x000a});
+  *u16++ = ((vector unsigned short){0x0000,0x000b,0x0000,0x000b,0x0000,0x000b,0x0000,0x000b});
+  *u16++ = ((vector unsigned short){0x0000,0x000c,0x0000,0x000c,0x0000,0x000c,0x0000,0x000c});
+  *u16++ = ((vector unsigned short){0x0000,0x000d,0x0000,0x000d,0x0000,0x000d,0x0000,0x000d});
+  *u16++ = ((vector unsigned short){0x0000,0x000e,0x0000,0x000e,0x0000,0x000e,0x0000,0x000e});
+  *u16++ = ((vector unsigned short){0x0000,0x000f,0x0000,0x000f,0x0000,0x000f,0x0000,0x000f});
+}
+void fu16c(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0});
+  *u16++ = ((vector unsigned short){0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1});
+  *u16++ = ((vector unsigned short){0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2});
+  *u16++ = ((vector unsigned short){0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3});
+  *u16++ = ((vector unsigned short){0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4});
+  *u16++ = ((vector unsigned short){0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5});
+  *u16++ = ((vector unsigned short){0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6});
+  *u16++ = ((vector unsigned short){0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7});
+  *u16++ = ((vector unsigned short){0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8});
+  *u16++ = ((vector unsigned short){0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9});
+  *u16++ = ((vector unsigned short){0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa});
+  *u16++ = ((vector unsigned short){0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb});
+  *u16++ = ((vector unsigned short){0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc});
+  *u16++ = ((vector unsigned short){0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd});
+  *u16++ = ((vector unsigned short){0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe});
+  *u16++ = ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fu16d(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *u16++ = ((vector unsigned short){0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001});
+  *u16++ = ((vector unsigned short){0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002});
+  *u16++ = ((vector unsigned short){0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003});
+  *u16++ = ((vector unsigned short){0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004});
+  *u16++ = ((vector unsigned short){0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005});
+  *u16++ = ((vector unsigned short){0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006});
+  *u16++ = ((vector unsigned short){0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007});
+  *u16++ = ((vector unsigned short){0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008});
+  *u16++ = ((vector unsigned short){0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009});
+  *u16++ = ((vector unsigned short){0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a});
+  *u16++ = ((vector unsigned short){0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b});
+  *u16++ = ((vector unsigned short){0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c});
+  *u16++ = ((vector unsigned short){0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d});
+  *u16++ = ((vector unsigned short){0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e});
+  *u16++ = ((vector unsigned short){0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f});
+}
+void fu16e(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0});
+  *u16++ = ((vector unsigned short){0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1});
+  *u16++ = ((vector unsigned short){0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2});
+  *u16++ = ((vector unsigned short){0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3});
+  *u16++ = ((vector unsigned short){0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4});
+  *u16++ = ((vector unsigned short){0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5});
+  *u16++ = ((vector unsigned short){0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6});
+  *u16++ = ((vector unsigned short){0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7});
+  *u16++ = ((vector unsigned short){0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8});
+  *u16++ = ((vector unsigned short){0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9});
+  *u16++ = ((vector unsigned short){0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa});
+  *u16++ = ((vector unsigned short){0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb});
+  *u16++ = ((vector unsigned short){0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc});
+  *u16++ = ((vector unsigned short){0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd});
+  *u16++ = ((vector unsigned short){0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe});
+  *u16++ = ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fu16f(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *u16++ = ((vector unsigned short){0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101});
+  *u16++ = ((vector unsigned short){0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202});
+  *u16++ = ((vector unsigned short){0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303});
+  *u16++ = ((vector unsigned short){0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404});
+  *u16++ = ((vector unsigned short){0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505});
+  *u16++ = ((vector unsigned short){0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606});
+  *u16++ = ((vector unsigned short){0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707});
+  *u16++ = ((vector unsigned short){0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808});
+  *u16++ = ((vector unsigned short){0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909});
+  *u16++ = ((vector unsigned short){0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a});
+  *u16++ = ((vector unsigned short){0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b});
+  *u16++ = ((vector unsigned short){0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c});
+  *u16++ = ((vector unsigned short){0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d});
+  *u16++ = ((vector unsigned short){0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e});
+  *u16++ = ((vector unsigned short){0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f});
+}
+void fu16g(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){0,0,0,0,0,0,0,0});
+  *u16++ = ((vector unsigned short){1,1,1,1,1,1,1,1});
+  *u16++ = ((vector unsigned short){2,2,2,2,2,2,2,2});
+  *u16++ = ((vector unsigned short){3,3,3,3,3,3,3,3});
+  *u16++ = ((vector unsigned short){4,4,4,4,4,4,4,4});
+  *u16++ = ((vector unsigned short){5,5,5,5,5,5,5,5});
+  *u16++ = ((vector unsigned short){6,6,6,6,6,6,6,6});
+  *u16++ = ((vector unsigned short){7,7,7,7,7,7,7,7});
+  *u16++ = ((vector unsigned short){8,8,8,8,8,8,8,8});
+  *u16++ = ((vector unsigned short){9,9,9,9,9,9,9,9});
+  *u16++ = ((vector unsigned short){10,10,10,10,10,10,10,10});
+  *u16++ = ((vector unsigned short){11,11,11,11,11,11,11,11});
+  *u16++ = ((vector unsigned short){12,12,12,12,12,12,12,12});
+  *u16++ = ((vector unsigned short){13,13,13,13,13,13,13,13});
+  *u16++ = ((vector unsigned short){14,14,14,14,14,14,14,14});
+  *u16++ = ((vector unsigned short){15,15,15,15,15,15,15,15});
+}
+void fu16h(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){257,257,257,257,257,257,257,257});
+  *u16++ = ((vector unsigned short){514,514,514,514,514,514,514,514});
+  *u16++ = ((vector unsigned short){771,771,771,771,771,771,771,771});
+  *u16++ = ((vector unsigned short){1028,1028,1028,1028,1028,1028,1028,1028});
+  *u16++ = ((vector unsigned short){1285,1285,1285,1285,1285,1285,1285,1285});
+  *u16++ = ((vector unsigned short){1542,1542,1542,1542,1542,1542,1542,1542});
+  *u16++ = ((vector unsigned short){1799,1799,1799,1799,1799,1799,1799,1799});
+  *u16++ = ((vector unsigned short){2056,2056,2056,2056,2056,2056,2056,2056});
+  *u16++ = ((vector unsigned short){2313,2313,2313,2313,2313,2313,2313,2313});
+  *u16++ = ((vector unsigned short){2570,2570,2570,2570,2570,2570,2570,2570});
+  *u16++ = ((vector unsigned short){2827,2827,2827,2827,2827,2827,2827,2827});
+  *u16++ = ((vector unsigned short){3084,3084,3084,3084,3084,3084,3084,3084});
+  *u16++ = ((vector unsigned short){3341,3341,3341,3341,3341,3341,3341,3341});
+  *u16++ = ((vector unsigned short){3598,3598,3598,3598,3598,3598,3598,3598});
+  *u16++ = ((vector unsigned short){3855,3855,3855,3855,3855,3855,3855,3855});
+}
+void fu16i(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){61680,61680,61680,61680,61680,61680,61680,61680});
+  *u16++ = ((vector unsigned short){61937,61937,61937,61937,61937,61937,61937,61937});
+  *u16++ = ((vector unsigned short){62194,62194,62194,62194,62194,62194,62194,62194});
+  *u16++ = ((vector unsigned short){62451,62451,62451,62451,62451,62451,62451,62451});
+  *u16++ = ((vector unsigned short){62708,62708,62708,62708,62708,62708,62708,62708});
+  *u16++ = ((vector unsigned short){62965,62965,62965,62965,62965,62965,62965,62965});
+  *u16++ = ((vector unsigned short){63222,63222,63222,63222,63222,63222,63222,63222});
+  *u16++ = ((vector unsigned short){63479,63479,63479,63479,63479,63479,63479,63479});
+  *u16++ = ((vector unsigned short){63736,63736,63736,63736,63736,63736,63736,63736});
+  *u16++ = ((vector unsigned short){63993,63993,63993,63993,63993,63993,63993,63993});
+  *u16++ = ((vector unsigned short){64250,64250,64250,64250,64250,64250,64250,64250});
+  *u16++ = ((vector unsigned short){64507,64507,64507,64507,64507,64507,64507,64507});
+  *u16++ = ((vector unsigned short){64764,64764,64764,64764,64764,64764,64764,64764});
+  *u16++ = ((vector unsigned short){65021,65021,65021,65021,65021,65021,65021,65021});
+  *u16++ = ((vector unsigned short){65278,65278,65278,65278,65278,65278,65278,65278});
+}
+void fu16j(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){65520,65520,65520,65520,65520,65520,65520,65520});
+  *u16++ = ((vector unsigned short){65521,65521,65521,65521,65521,65521,65521,65521});
+  *u16++ = ((vector unsigned short){65522,65522,65522,65522,65522,65522,65522,65522});
+  *u16++ = ((vector unsigned short){65523,65523,65523,65523,65523,65523,65523,65523});
+  *u16++ = ((vector unsigned short){65524,65524,65524,65524,65524,65524,65524,65524});
+  *u16++ = ((vector unsigned short){65525,65525,65525,65525,65525,65525,65525,65525});
+  *u16++ = ((vector unsigned short){65526,65526,65526,65526,65526,65526,65526,65526});
+  *u16++ = ((vector unsigned short){65527,65527,65527,65527,65527,65527,65527,65527});
+  *u16++ = ((vector unsigned short){65528,65528,65528,65528,65528,65528,65528,65528});
+  *u16++ = ((vector unsigned short){65529,65529,65529,65529,65529,65529,65529,65529});
+  *u16++ = ((vector unsigned short){65530,65530,65530,65530,65530,65530,65530,65530});
+  *u16++ = ((vector unsigned short){65531,65531,65531,65531,65531,65531,65531,65531});
+  *u16++ = ((vector unsigned short){65532,65532,65532,65532,65532,65532,65532,65532});
+  *u16++ = ((vector unsigned short){65533,65533,65533,65533,65533,65533,65533,65533});
+  *u16++ = ((vector unsigned short){65534,65534,65534,65534,65534,65534,65534,65534});
+  *u16++ = ((vector unsigned short){65535,65535,65535,65535,65535,65535,65535,65535});
+}
+void fu16k(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){-3856,-3856,-3856,-3856,-3856,-3856,-3856,-3856});
+  *u16++ = ((vector unsigned short){-3599,-3599,-3599,-3599,-3599,-3599,-3599,-3599});
+  *u16++ = ((vector unsigned short){-3342,-3342,-3342,-3342,-3342,-3342,-3342,-3342});
+  *u16++ = ((vector unsigned short){-3085,-3085,-3085,-3085,-3085,-3085,-3085,-3085});
+  *u16++ = ((vector unsigned short){-2828,-2828,-2828,-2828,-2828,-2828,-2828,-2828});
+  *u16++ = ((vector unsigned short){-2571,-2571,-2571,-2571,-2571,-2571,-2571,-2571});
+  *u16++ = ((vector unsigned short){-2314,-2314,-2314,-2314,-2314,-2314,-2314,-2314});
+  *u16++ = ((vector unsigned short){-2057,-2057,-2057,-2057,-2057,-2057,-2057,-2057});
+  *u16++ = ((vector unsigned short){-1800,-1800,-1800,-1800,-1800,-1800,-1800,-1800});
+  *u16++ = ((vector unsigned short){-1543,-1543,-1543,-1543,-1543,-1543,-1543,-1543});
+  *u16++ = ((vector unsigned short){-1286,-1286,-1286,-1286,-1286,-1286,-1286,-1286});
+  *u16++ = ((vector unsigned short){-1029,-1029,-1029,-1029,-1029,-1029,-1029,-1029});
+  *u16++ = ((vector unsigned short){-772,-772,-772,-772,-772,-772,-772,-772});
+  *u16++ = ((vector unsigned short){-515,-515,-515,-515,-515,-515,-515,-515});
+  *u16++ = ((vector unsigned short){-258,-258,-258,-258,-258,-258,-258,-258});
+}
+void fu16l(vector unsigned short *u16) 
+{
+  *u16++ = ((vector unsigned short){-16,-16,-16,-16,-16,-16,-16,-16});
+  *u16++ = ((vector unsigned short){-15,-15,-15,-15,-15,-15,-15,-15});
+  *u16++ = ((vector unsigned short){-14,-14,-14,-14,-14,-14,-14,-14});
+  *u16++ = ((vector unsigned short){-13,-13,-13,-13,-13,-13,-13,-13});
+  *u16++ = ((vector unsigned short){-12,-12,-12,-12,-12,-12,-12,-12});
+  *u16++ = ((vector unsigned short){-11,-11,-11,-11,-11,-11,-11,-11});
+  *u16++ = ((vector unsigned short){-10,-10,-10,-10,-10,-10,-10,-10});
+  *u16++ = ((vector unsigned short){-9,-9,-9,-9,-9,-9,-9,-9});
+  *u16++ = ((vector unsigned short){-8,-8,-8,-8,-8,-8,-8,-8});
+  *u16++ = ((vector unsigned short){-7,-7,-7,-7,-7,-7,-7,-7});
+  *u16++ = ((vector unsigned short){-6,-6,-6,-6,-6,-6,-6,-6});
+  *u16++ = ((vector unsigned short){-5,-5,-5,-5,-5,-5,-5,-5});
+  *u16++ = ((vector unsigned short){-4,-4,-4,-4,-4,-4,-4,-4});
+  *u16++ = ((vector unsigned short){-3,-3,-3,-3,-3,-3,-3,-3});
+  *u16++ = ((vector unsigned short){-2,-2,-2,-2,-2,-2,-2,-2});
+  *u16++ = ((vector unsigned short){-1,-1,-1,-1,-1,-1,-1,-1});
+}
+void fu8a(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fu8b(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e});
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f});
+}
+void fu8c(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0});
+  *u8++ = ((vector unsigned char){0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1});
+  *u8++ = ((vector unsigned char){0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2});
+  *u8++ = ((vector unsigned char){0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3});
+  *u8++ = ((vector unsigned char){0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4});
+  *u8++ = ((vector unsigned char){0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5});
+  *u8++ = ((vector unsigned char){0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6});
+  *u8++ = ((vector unsigned char){0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7});
+  *u8++ = ((vector unsigned char){0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8});
+  *u8++ = ((vector unsigned char){0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9});
+  *u8++ = ((vector unsigned char){0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa});
+  *u8++ = ((vector unsigned char){0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb});
+  *u8++ = ((vector unsigned char){0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc});
+  *u8++ = ((vector unsigned char){0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd});
+  *u8++ = ((vector unsigned char){0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fu8d(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *u8++ = ((vector unsigned char){0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01});
+  *u8++ = ((vector unsigned char){0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02});
+  *u8++ = ((vector unsigned char){0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03});
+  *u8++ = ((vector unsigned char){0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04});
+  *u8++ = ((vector unsigned char){0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05});
+  *u8++ = ((vector unsigned char){0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06});
+  *u8++ = ((vector unsigned char){0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07});
+  *u8++ = ((vector unsigned char){0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08});
+  *u8++ = ((vector unsigned char){0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09});
+  *u8++ = ((vector unsigned char){0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a});
+  *u8++ = ((vector unsigned char){0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b});
+  *u8++ = ((vector unsigned char){0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c});
+  *u8++ = ((vector unsigned char){0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d});
+  *u8++ = ((vector unsigned char){0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e});
+  *u8++ = ((vector unsigned char){0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f});
+}
+void fu8e(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *u8++ = ((vector unsigned char){0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01});
+  *u8++ = ((vector unsigned char){0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02});
+  *u8++ = ((vector unsigned char){0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03});
+  *u8++ = ((vector unsigned char){0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04});
+  *u8++ = ((vector unsigned char){0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05});
+  *u8++ = ((vector unsigned char){0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06});
+  *u8++ = ((vector unsigned char){0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07});
+  *u8++ = ((vector unsigned char){0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08});
+  *u8++ = ((vector unsigned char){0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09});
+  *u8++ = ((vector unsigned char){0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a});
+  *u8++ = ((vector unsigned char){0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b});
+  *u8++ = ((vector unsigned char){0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c});
+  *u8++ = ((vector unsigned char){0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d});
+  *u8++ = ((vector unsigned char){0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e});
+  *u8++ = ((vector unsigned char){0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f});
+}
+void fu8f(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0});
+  *u8++ = ((vector unsigned char){0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1});
+  *u8++ = ((vector unsigned char){0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2});
+  *u8++ = ((vector unsigned char){0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3});
+  *u8++ = ((vector unsigned char){0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4});
+  *u8++ = ((vector unsigned char){0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5});
+  *u8++ = ((vector unsigned char){0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6});
+  *u8++ = ((vector unsigned char){0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7});
+  *u8++ = ((vector unsigned char){0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8});
+  *u8++ = ((vector unsigned char){0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9});
+  *u8++ = ((vector unsigned char){0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa});
+  *u8++ = ((vector unsigned char){0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb});
+  *u8++ = ((vector unsigned char){0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc});
+  *u8++ = ((vector unsigned char){0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd});
+  *u8++ = ((vector unsigned char){0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe});
+  *u8++ = ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fu8g(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0});
+  *u8++ = ((vector unsigned char){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1});
+  *u8++ = ((vector unsigned char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2});
+  *u8++ = ((vector unsigned char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  *u8++ = ((vector unsigned char){4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4});
+  *u8++ = ((vector unsigned char){5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5});
+  *u8++ = ((vector unsigned char){6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6});
+  *u8++ = ((vector unsigned char){7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7});
+  *u8++ = ((vector unsigned char){8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8});
+  *u8++ = ((vector unsigned char){9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9});
+  *u8++ = ((vector unsigned char){10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10});
+  *u8++ = ((vector unsigned char){11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11});
+  *u8++ = ((vector unsigned char){12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12});
+  *u8++ = ((vector unsigned char){13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13});
+  *u8++ = ((vector unsigned char){14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14});
+  *u8++ = ((vector unsigned char){15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15});
+}
+void fu8h(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){240,240,240,240,240,240,240,240,240,240,240,240,240,240,240,240});
+  *u8++ = ((vector unsigned char){241,241,241,241,241,241,241,241,241,241,241,241,241,241,241,241});
+  *u8++ = ((vector unsigned char){242,242,242,242,242,242,242,242,242,242,242,242,242,242,242,242});
+  *u8++ = ((vector unsigned char){243,243,243,243,243,243,243,243,243,243,243,243,243,243,243,243});
+  *u8++ = ((vector unsigned char){244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244});
+  *u8++ = ((vector unsigned char){245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245});
+  *u8++ = ((vector unsigned char){246,246,246,246,246,246,246,246,246,246,246,246,246,246,246,246});
+  *u8++ = ((vector unsigned char){247,247,247,247,247,247,247,247,247,247,247,247,247,247,247,247});
+  *u8++ = ((vector unsigned char){248,248,248,248,248,248,248,248,248,248,248,248,248,248,248,248});
+  *u8++ = ((vector unsigned char){249,249,249,249,249,249,249,249,249,249,249,249,249,249,249,249});
+  *u8++ = ((vector unsigned char){250,250,250,250,250,250,250,250,250,250,250,250,250,250,250,250});
+  *u8++ = ((vector unsigned char){251,251,251,251,251,251,251,251,251,251,251,251,251,251,251,251});
+  *u8++ = ((vector unsigned char){252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252});
+  *u8++ = ((vector unsigned char){253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253});
+  *u8++ = ((vector unsigned char){254,254,254,254,254,254,254,254,254,254,254,254,254,254,254,254});
+  *u8++ = ((vector unsigned char){255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255});
+}
+void fu8i(vector unsigned char *u8) 
+{
+  *u8++ = ((vector unsigned char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1});
+  *u8++ = ((vector unsigned char){-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2});
+  *u8++ = ((vector unsigned char){-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3});
+  *u8++ = ((vector unsigned char){-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4});
+  *u8++ = ((vector unsigned char){-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5});
+  *u8++ = ((vector unsigned char){-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6});
+  *u8++ = ((vector unsigned char){-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7});
+  *u8++ = ((vector unsigned char){-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8});
+  *u8++ = ((vector unsigned char){-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9});
+  *u8++ = ((vector unsigned char){-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10});
+  *u8++ = ((vector unsigned char){-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11});
+  *u8++ = ((vector unsigned char){-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12});
+  *u8++ = ((vector unsigned char){-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13});
+  *u8++ = ((vector unsigned char){-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14});
+  *u8++ = ((vector unsigned char){-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15});
+  *u8++ = ((vector unsigned char){-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16});
+}
+void fs32a(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0,0,0,0});
+  *s32++ = ((vector signed int){1,1,1,1});
+  *s32++ = ((vector signed int){2,2,2,2});
+  *s32++ = ((vector signed int){3,3,3,3});
+  *s32++ = ((vector signed int){4,4,4,4});
+  *s32++ = ((vector signed int){5,5,5,5});
+  *s32++ = ((vector signed int){6,6,6,6});
+  *s32++ = ((vector signed int){7,7,7,7});
+  *s32++ = ((vector signed int){8,8,8,8});
+  *s32++ = ((vector signed int){9,9,9,9});
+  *s32++ = ((vector signed int){10,10,10,10});
+  *s32++ = ((vector signed int){11,11,11,11});
+  *s32++ = ((vector signed int){12,12,12,12});
+  *s32++ = ((vector signed int){13,13,13,13});
+  *s32++ = ((vector signed int){14,14,14,14});
+  *s32++ = ((vector signed int){15,15,15,15});
+}
+void fs32b(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){65537,65537,65537,65537});
+  *s32++ = ((vector signed int){131074,131074,131074,131074});
+  *s32++ = ((vector signed int){196611,196611,196611,196611});
+  *s32++ = ((vector signed int){262148,262148,262148,262148});
+  *s32++ = ((vector signed int){327685,327685,327685,327685});
+  *s32++ = ((vector signed int){393222,393222,393222,393222});
+  *s32++ = ((vector signed int){458759,458759,458759,458759});
+  *s32++ = ((vector signed int){524296,524296,524296,524296});
+  *s32++ = ((vector signed int){589833,589833,589833,589833});
+  *s32++ = ((vector signed int){655370,655370,655370,655370});
+  *s32++ = ((vector signed int){720907,720907,720907,720907});
+  *s32++ = ((vector signed int){786444,786444,786444,786444});
+  *s32++ = ((vector signed int){851981,851981,851981,851981});
+  *s32++ = ((vector signed int){917518,917518,917518,917518});
+  *s32++ = ((vector signed int){983055,983055,983055,983055});
+}
+void fs32c(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){16843009,16843009,16843009,16843009});
+  *s32++ = ((vector signed int){33686018,33686018,33686018,33686018});
+  *s32++ = ((vector signed int){50529027,50529027,50529027,50529027});
+  *s32++ = ((vector signed int){67372036,67372036,67372036,67372036});
+  *s32++ = ((vector signed int){84215045,84215045,84215045,84215045});
+  *s32++ = ((vector signed int){101058054,101058054,101058054,101058054});
+  *s32++ = ((vector signed int){117901063,117901063,117901063,117901063});
+  *s32++ = ((vector signed int){134744072,134744072,134744072,134744072});
+  *s32++ = ((vector signed int){151587081,151587081,151587081,151587081});
+  *s32++ = ((vector signed int){168430090,168430090,168430090,168430090});
+  *s32++ = ((vector signed int){185273099,185273099,185273099,185273099});
+  *s32++ = ((vector signed int){202116108,202116108,202116108,202116108});
+  *s32++ = ((vector signed int){218959117,218959117,218959117,218959117});
+  *s32++ = ((vector signed int){235802126,235802126,235802126,235802126});
+  *s32++ = ((vector signed int){252645135,252645135,252645135,252645135});
+}
+void fs32d(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){4042322160,4042322160,4042322160,4042322160});
+  *s32++ = ((vector signed int){4059165169,4059165169,4059165169,4059165169});
+  *s32++ = ((vector signed int){4076008178,4076008178,4076008178,4076008178});
+  *s32++ = ((vector signed int){4092851187,4092851187,4092851187,4092851187});
+  *s32++ = ((vector signed int){4109694196,4109694196,4109694196,4109694196});
+  *s32++ = ((vector signed int){4126537205,4126537205,4126537205,4126537205});
+  *s32++ = ((vector signed int){4143380214,4143380214,4143380214,4143380214});
+  *s32++ = ((vector signed int){4160223223,4160223223,4160223223,4160223223});
+  *s32++ = ((vector signed int){4177066232,4177066232,4177066232,4177066232});
+  *s32++ = ((vector signed int){4193909241,4193909241,4193909241,4193909241});
+  *s32++ = ((vector signed int){4210752250,4210752250,4210752250,4210752250});
+  *s32++ = ((vector signed int){4227595259,4227595259,4227595259,4227595259});
+  *s32++ = ((vector signed int){4244438268,4244438268,4244438268,4244438268});
+  *s32++ = ((vector signed int){4261281277,4261281277,4261281277,4261281277});
+  *s32++ = ((vector signed int){4278124286,4278124286,4278124286,4278124286});
+}
+void fs32e(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){4293984240,4293984240,4293984240,4293984240});
+  *s32++ = ((vector signed int){4294049777,4294049777,4294049777,4294049777});
+  *s32++ = ((vector signed int){4294115314,4294115314,4294115314,4294115314});
+  *s32++ = ((vector signed int){4294180851,4294180851,4294180851,4294180851});
+  *s32++ = ((vector signed int){4294246388,4294246388,4294246388,4294246388});
+  *s32++ = ((vector signed int){4294311925,4294311925,4294311925,4294311925});
+  *s32++ = ((vector signed int){4294377462,4294377462,4294377462,4294377462});
+  *s32++ = ((vector signed int){4294442999,4294442999,4294442999,4294442999});
+  *s32++ = ((vector signed int){4294508536,4294508536,4294508536,4294508536});
+  *s32++ = ((vector signed int){4294574073,4294574073,4294574073,4294574073});
+  *s32++ = ((vector signed int){4294639610,4294639610,4294639610,4294639610});
+  *s32++ = ((vector signed int){4294705147,4294705147,4294705147,4294705147});
+  *s32++ = ((vector signed int){4294770684,4294770684,4294770684,4294770684});
+  *s32++ = ((vector signed int){4294836221,4294836221,4294836221,4294836221});
+  *s32++ = ((vector signed int){4294901758,4294901758,4294901758,4294901758});
+}
+void fs32f(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){4294967280,4294967280,4294967280,4294967280});
+  *s32++ = ((vector signed int){4294967281,4294967281,4294967281,4294967281});
+  *s32++ = ((vector signed int){4294967282,4294967282,4294967282,4294967282});
+  *s32++ = ((vector signed int){4294967283,4294967283,4294967283,4294967283});
+  *s32++ = ((vector signed int){4294967284,4294967284,4294967284,4294967284});
+  *s32++ = ((vector signed int){4294967285,4294967285,4294967285,4294967285});
+  *s32++ = ((vector signed int){4294967286,4294967286,4294967286,4294967286});
+  *s32++ = ((vector signed int){4294967287,4294967287,4294967287,4294967287});
+  *s32++ = ((vector signed int){4294967288,4294967288,4294967288,4294967288});
+  *s32++ = ((vector signed int){4294967289,4294967289,4294967289,4294967289});
+  *s32++ = ((vector signed int){4294967290,4294967290,4294967290,4294967290});
+  *s32++ = ((vector signed int){4294967291,4294967291,4294967291,4294967291});
+  *s32++ = ((vector signed int){4294967292,4294967292,4294967292,4294967292});
+  *s32++ = ((vector signed int){4294967293,4294967293,4294967293,4294967293});
+  *s32++ = ((vector signed int){4294967294,4294967294,4294967294,4294967294});
+  *s32++ = ((vector signed int){4294967295,4294967295,4294967295,4294967295});
+}
+void fs32g(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){-252645136,-252645136,-252645136,-252645136});
+  *s32++ = ((vector signed int){-235802127,-235802127,-235802127,-235802127});
+  *s32++ = ((vector signed int){-218959118,-218959118,-218959118,-218959118});
+  *s32++ = ((vector signed int){-202116109,-202116109,-202116109,-202116109});
+  *s32++ = ((vector signed int){-185273100,-185273100,-185273100,-185273100});
+  *s32++ = ((vector signed int){-168430091,-168430091,-168430091,-168430091});
+  *s32++ = ((vector signed int){-151587082,-151587082,-151587082,-151587082});
+  *s32++ = ((vector signed int){-134744073,-134744073,-134744073,-134744073});
+  *s32++ = ((vector signed int){-117901064,-117901064,-117901064,-117901064});
+  *s32++ = ((vector signed int){-101058055,-101058055,-101058055,-101058055});
+  *s32++ = ((vector signed int){-84215046,-84215046,-84215046,-84215046});
+  *s32++ = ((vector signed int){-67372037,-67372037,-67372037,-67372037});
+  *s32++ = ((vector signed int){-50529028,-50529028,-50529028,-50529028});
+  *s32++ = ((vector signed int){-33686019,-33686019,-33686019,-33686019});
+  *s32++ = ((vector signed int){-16843010,-16843010,-16843010,-16843010});
+}
+void fs32h(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){-983056,-983056,-983056,-983056});
+  *s32++ = ((vector signed int){-917519,-917519,-917519,-917519});
+  *s32++ = ((vector signed int){-851982,-851982,-851982,-851982});
+  *s32++ = ((vector signed int){-786445,-786445,-786445,-786445});
+  *s32++ = ((vector signed int){-720908,-720908,-720908,-720908});
+  *s32++ = ((vector signed int){-655371,-655371,-655371,-655371});
+  *s32++ = ((vector signed int){-589834,-589834,-589834,-589834});
+  *s32++ = ((vector signed int){-524297,-524297,-524297,-524297});
+  *s32++ = ((vector signed int){-458760,-458760,-458760,-458760});
+  *s32++ = ((vector signed int){-393223,-393223,-393223,-393223});
+  *s32++ = ((vector signed int){-327686,-327686,-327686,-327686});
+  *s32++ = ((vector signed int){-262149,-262149,-262149,-262149});
+  *s32++ = ((vector signed int){-196612,-196612,-196612,-196612});
+  *s32++ = ((vector signed int){-131075,-131075,-131075,-131075});
+  *s32++ = ((vector signed int){-65538,-65538,-65538,-65538});
+}
+void fs32i(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){-16,-16,-16,-16});
+  *s32++ = ((vector signed int){-15,-15,-15,-15});
+  *s32++ = ((vector signed int){-14,-14,-14,-14});
+  *s32++ = ((vector signed int){-13,-13,-13,-13});
+  *s32++ = ((vector signed int){-12,-12,-12,-12});
+  *s32++ = ((vector signed int){-11,-11,-11,-11});
+  *s32++ = ((vector signed int){-10,-10,-10,-10});
+  *s32++ = ((vector signed int){-9,-9,-9,-9});
+  *s32++ = ((vector signed int){-8,-8,-8,-8});
+  *s32++ = ((vector signed int){-7,-7,-7,-7});
+  *s32++ = ((vector signed int){-6,-6,-6,-6});
+  *s32++ = ((vector signed int){-5,-5,-5,-5});
+  *s32++ = ((vector signed int){-4,-4,-4,-4});
+  *s32++ = ((vector signed int){-3,-3,-3,-3});
+  *s32++ = ((vector signed int){-2,-2,-2,-2});
+  *s32++ = ((vector signed int){-1,-1,-1,-1});
+}
+void fs32j(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0xfffffff0,0xfffffff0,0xfffffff0,0xfffffff0});
+  *s32++ = ((vector signed int){0xfffffff1,0xfffffff1,0xfffffff1,0xfffffff1});
+  *s32++ = ((vector signed int){0xfffffff2,0xfffffff2,0xfffffff2,0xfffffff2});
+  *s32++ = ((vector signed int){0xfffffff3,0xfffffff3,0xfffffff3,0xfffffff3});
+  *s32++ = ((vector signed int){0xfffffff4,0xfffffff4,0xfffffff4,0xfffffff4});
+  *s32++ = ((vector signed int){0xfffffff5,0xfffffff5,0xfffffff5,0xfffffff5});
+  *s32++ = ((vector signed int){0xfffffff6,0xfffffff6,0xfffffff6,0xfffffff6});
+  *s32++ = ((vector signed int){0xfffffff7,0xfffffff7,0xfffffff7,0xfffffff7});
+  *s32++ = ((vector signed int){0xfffffff8,0xfffffff8,0xfffffff8,0xfffffff8});
+  *s32++ = ((vector signed int){0xfffffff9,0xfffffff9,0xfffffff9,0xfffffff9});
+  *s32++ = ((vector signed int){0xfffffffa,0xfffffffa,0xfffffffa,0xfffffffa});
+  *s32++ = ((vector signed int){0xfffffffb,0xfffffffb,0xfffffffb,0xfffffffb});
+  *s32++ = ((vector signed int){0xfffffffc,0xfffffffc,0xfffffffc,0xfffffffc});
+  *s32++ = ((vector signed int){0xfffffffd,0xfffffffd,0xfffffffd,0xfffffffd});
+  *s32++ = ((vector signed int){0xfffffffe,0xfffffffe,0xfffffffe,0xfffffffe});
+  *s32++ = ((vector signed int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fs32k(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *s32++ = ((vector signed int){0x00000001,0x00000001,0x00000001,0x00000001});
+  *s32++ = ((vector signed int){0x00000002,0x00000002,0x00000002,0x00000002});
+  *s32++ = ((vector signed int){0x00000003,0x00000003,0x00000003,0x00000003});
+  *s32++ = ((vector signed int){0x00000004,0x00000004,0x00000004,0x00000004});
+  *s32++ = ((vector signed int){0x00000005,0x00000005,0x00000005,0x00000005});
+  *s32++ = ((vector signed int){0x00000006,0x00000006,0x00000006,0x00000006});
+  *s32++ = ((vector signed int){0x00000007,0x00000007,0x00000007,0x00000007});
+  *s32++ = ((vector signed int){0x00000008,0x00000008,0x00000008,0x00000008});
+  *s32++ = ((vector signed int){0x00000009,0x00000009,0x00000009,0x00000009});
+  *s32++ = ((vector signed int){0x0000000a,0x0000000a,0x0000000a,0x0000000a});
+  *s32++ = ((vector signed int){0x0000000b,0x0000000b,0x0000000b,0x0000000b});
+  *s32++ = ((vector signed int){0x0000000c,0x0000000c,0x0000000c,0x0000000c});
+  *s32++ = ((vector signed int){0x0000000d,0x0000000d,0x0000000d,0x0000000d});
+  *s32++ = ((vector signed int){0x0000000e,0x0000000e,0x0000000e,0x0000000e});
+  *s32++ = ((vector signed int){0x0000000f,0x0000000f,0x0000000f,0x0000000f});
+}
+void fs32l(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0xfff0fff0,0xfff0fff0,0xfff0fff0,0xfff0fff0});
+  *s32++ = ((vector signed int){0xfff1fff1,0xfff1fff1,0xfff1fff1,0xfff1fff1});
+  *s32++ = ((vector signed int){0xfff2fff2,0xfff2fff2,0xfff2fff2,0xfff2fff2});
+  *s32++ = ((vector signed int){0xfff3fff3,0xfff3fff3,0xfff3fff3,0xfff3fff3});
+  *s32++ = ((vector signed int){0xfff4fff4,0xfff4fff4,0xfff4fff4,0xfff4fff4});
+  *s32++ = ((vector signed int){0xfff5fff5,0xfff5fff5,0xfff5fff5,0xfff5fff5});
+  *s32++ = ((vector signed int){0xfff6fff6,0xfff6fff6,0xfff6fff6,0xfff6fff6});
+  *s32++ = ((vector signed int){0xfff7fff7,0xfff7fff7,0xfff7fff7,0xfff7fff7});
+  *s32++ = ((vector signed int){0xfff8fff8,0xfff8fff8,0xfff8fff8,0xfff8fff8});
+  *s32++ = ((vector signed int){0xfff9fff9,0xfff9fff9,0xfff9fff9,0xfff9fff9});
+  *s32++ = ((vector signed int){0xfffafffa,0xfffafffa,0xfffafffa,0xfffafffa});
+  *s32++ = ((vector signed int){0xfffbfffb,0xfffbfffb,0xfffbfffb,0xfffbfffb});
+  *s32++ = ((vector signed int){0xfffcfffc,0xfffcfffc,0xfffcfffc,0xfffcfffc});
+  *s32++ = ((vector signed int){0xfffdfffd,0xfffdfffd,0xfffdfffd,0xfffdfffd});
+  *s32++ = ((vector signed int){0xfffefffe,0xfffefffe,0xfffefffe,0xfffefffe});
+  *s32++ = ((vector signed int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fs32m(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *s32++ = ((vector signed int){0x00010001,0x00010001,0x00010001,0x00010001});
+  *s32++ = ((vector signed int){0x00020002,0x00020002,0x00020002,0x00020002});
+  *s32++ = ((vector signed int){0x00030003,0x00030003,0x00030003,0x00030003});
+  *s32++ = ((vector signed int){0x00040004,0x00040004,0x00040004,0x00040004});
+  *s32++ = ((vector signed int){0x00050005,0x00050005,0x00050005,0x00050005});
+  *s32++ = ((vector signed int){0x00060006,0x00060006,0x00060006,0x00060006});
+  *s32++ = ((vector signed int){0x00070007,0x00070007,0x00070007,0x00070007});
+  *s32++ = ((vector signed int){0x00080008,0x00080008,0x00080008,0x00080008});
+  *s32++ = ((vector signed int){0x00090009,0x00090009,0x00090009,0x00090009});
+  *s32++ = ((vector signed int){0x000a000a,0x000a000a,0x000a000a,0x000a000a});
+  *s32++ = ((vector signed int){0x000b000b,0x000b000b,0x000b000b,0x000b000b});
+  *s32++ = ((vector signed int){0x000c000c,0x000c000c,0x000c000c,0x000c000c});
+  *s32++ = ((vector signed int){0x000d000d,0x000d000d,0x000d000d,0x000d000d});
+  *s32++ = ((vector signed int){0x000e000e,0x000e000e,0x000e000e,0x000e000e});
+  *s32++ = ((vector signed int){0x000f000f,0x000f000f,0x000f000f,0x000f000f});
+}
+void fs32n(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0,0xf0f0f0f0});
+  *s32++ = ((vector signed int){0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1,0xf1f1f1f1});
+  *s32++ = ((vector signed int){0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2,0xf2f2f2f2});
+  *s32++ = ((vector signed int){0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3,0xf3f3f3f3});
+  *s32++ = ((vector signed int){0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4,0xf4f4f4f4});
+  *s32++ = ((vector signed int){0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5,0xf5f5f5f5});
+  *s32++ = ((vector signed int){0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6,0xf6f6f6f6});
+  *s32++ = ((vector signed int){0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7,0xf7f7f7f7});
+  *s32++ = ((vector signed int){0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8,0xf8f8f8f8});
+  *s32++ = ((vector signed int){0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9,0xf9f9f9f9});
+  *s32++ = ((vector signed int){0xfafafafa,0xfafafafa,0xfafafafa,0xfafafafa});
+  *s32++ = ((vector signed int){0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb,0xfbfbfbfb});
+  *s32++ = ((vector signed int){0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc,0xfcfcfcfc});
+  *s32++ = ((vector signed int){0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd,0xfdfdfdfd});
+  *s32++ = ((vector signed int){0xfefefefe,0xfefefefe,0xfefefefe,0xfefefefe});
+  *s32++ = ((vector signed int){0xffffffff,0xffffffff,0xffffffff,0xffffffff});
+}
+void fs32o(vector signed int *s32) 
+{
+  *s32++ = ((vector signed int){0x00000000,0x00000000,0x00000000,0x00000000});
+  *s32++ = ((vector signed int){0x01010101,0x01010101,0x01010101,0x01010101});
+  *s32++ = ((vector signed int){0x02020202,0x02020202,0x02020202,0x02020202});
+  *s32++ = ((vector signed int){0x03030303,0x03030303,0x03030303,0x03030303});
+  *s32++ = ((vector signed int){0x04040404,0x04040404,0x04040404,0x04040404});
+  *s32++ = ((vector signed int){0x05050505,0x05050505,0x05050505,0x05050505});
+  *s32++ = ((vector signed int){0x06060606,0x06060606,0x06060606,0x06060606});
+  *s32++ = ((vector signed int){0x07070707,0x07070707,0x07070707,0x07070707});
+  *s32++ = ((vector signed int){0x08080808,0x08080808,0x08080808,0x08080808});
+  *s32++ = ((vector signed int){0x09090909,0x09090909,0x09090909,0x09090909});
+  *s32++ = ((vector signed int){0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a,0x0a0a0a0a});
+  *s32++ = ((vector signed int){0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b,0x0b0b0b0b});
+  *s32++ = ((vector signed int){0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c,0x0c0c0c0c});
+  *s32++ = ((vector signed int){0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d,0x0d0d0d0d});
+  *s32++ = ((vector signed int){0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e,0x0e0e0e0e});
+  *s32++ = ((vector signed int){0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f});
+}
+void fs16a(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0,0xffff,0xfff0});
+  *s16++ = ((vector signed short){0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1,0xffff,0xfff1});
+  *s16++ = ((vector signed short){0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2,0xffff,0xfff2});
+  *s16++ = ((vector signed short){0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3,0xffff,0xfff3});
+  *s16++ = ((vector signed short){0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4,0xffff,0xfff4});
+  *s16++ = ((vector signed short){0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5,0xffff,0xfff5});
+  *s16++ = ((vector signed short){0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6,0xffff,0xfff6});
+  *s16++ = ((vector signed short){0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7,0xffff,0xfff7});
+  *s16++ = ((vector signed short){0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8,0xffff,0xfff8});
+  *s16++ = ((vector signed short){0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9,0xffff,0xfff9});
+  *s16++ = ((vector signed short){0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa,0xffff,0xfffa});
+  *s16++ = ((vector signed short){0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb,0xffff,0xfffb});
+  *s16++ = ((vector signed short){0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc,0xffff,0xfffc});
+  *s16++ = ((vector signed short){0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd,0xffff,0xfffd});
+  *s16++ = ((vector signed short){0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe,0xffff,0xfffe});
+  *s16++ = ((vector signed short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fs16b(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *s16++ = ((vector signed short){0x0000,0x0001,0x0000,0x0001,0x0000,0x0001,0x0000,0x0001});
+  *s16++ = ((vector signed short){0x0000,0x0002,0x0000,0x0002,0x0000,0x0002,0x0000,0x0002});
+  *s16++ = ((vector signed short){0x0000,0x0003,0x0000,0x0003,0x0000,0x0003,0x0000,0x0003});
+  *s16++ = ((vector signed short){0x0000,0x0004,0x0000,0x0004,0x0000,0x0004,0x0000,0x0004});
+  *s16++ = ((vector signed short){0x0000,0x0005,0x0000,0x0005,0x0000,0x0005,0x0000,0x0005});
+  *s16++ = ((vector signed short){0x0000,0x0006,0x0000,0x0006,0x0000,0x0006,0x0000,0x0006});
+  *s16++ = ((vector signed short){0x0000,0x0007,0x0000,0x0007,0x0000,0x0007,0x0000,0x0007});
+  *s16++ = ((vector signed short){0x0000,0x0008,0x0000,0x0008,0x0000,0x0008,0x0000,0x0008});
+  *s16++ = ((vector signed short){0x0000,0x0009,0x0000,0x0009,0x0000,0x0009,0x0000,0x0009});
+  *s16++ = ((vector signed short){0x0000,0x000a,0x0000,0x000a,0x0000,0x000a,0x0000,0x000a});
+  *s16++ = ((vector signed short){0x0000,0x000b,0x0000,0x000b,0x0000,0x000b,0x0000,0x000b});
+  *s16++ = ((vector signed short){0x0000,0x000c,0x0000,0x000c,0x0000,0x000c,0x0000,0x000c});
+  *s16++ = ((vector signed short){0x0000,0x000d,0x0000,0x000d,0x0000,0x000d,0x0000,0x000d});
+  *s16++ = ((vector signed short){0x0000,0x000e,0x0000,0x000e,0x0000,0x000e,0x0000,0x000e});
+  *s16++ = ((vector signed short){0x0000,0x000f,0x0000,0x000f,0x0000,0x000f,0x0000,0x000f});
+}
+void fs16c(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0,0xfff0});
+  *s16++ = ((vector signed short){0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1,0xfff1});
+  *s16++ = ((vector signed short){0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2,0xfff2});
+  *s16++ = ((vector signed short){0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3,0xfff3});
+  *s16++ = ((vector signed short){0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4,0xfff4});
+  *s16++ = ((vector signed short){0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5,0xfff5});
+  *s16++ = ((vector signed short){0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6,0xfff6});
+  *s16++ = ((vector signed short){0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7,0xfff7});
+  *s16++ = ((vector signed short){0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8,0xfff8});
+  *s16++ = ((vector signed short){0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9,0xfff9});
+  *s16++ = ((vector signed short){0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa,0xfffa});
+  *s16++ = ((vector signed short){0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb,0xfffb});
+  *s16++ = ((vector signed short){0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc,0xfffc});
+  *s16++ = ((vector signed short){0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd});
+  *s16++ = ((vector signed short){0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe,0xfffe});
+  *s16++ = ((vector signed short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fs16d(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *s16++ = ((vector signed short){0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001});
+  *s16++ = ((vector signed short){0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002});
+  *s16++ = ((vector signed short){0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003,0x0003});
+  *s16++ = ((vector signed short){0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004});
+  *s16++ = ((vector signed short){0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005,0x0005});
+  *s16++ = ((vector signed short){0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006,0x0006});
+  *s16++ = ((vector signed short){0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007,0x0007});
+  *s16++ = ((vector signed short){0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008,0x0008});
+  *s16++ = ((vector signed short){0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009,0x0009});
+  *s16++ = ((vector signed short){0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a,0x000a});
+  *s16++ = ((vector signed short){0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b,0x000b});
+  *s16++ = ((vector signed short){0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c,0x000c});
+  *s16++ = ((vector signed short){0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d,0x000d});
+  *s16++ = ((vector signed short){0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e,0x000e});
+  *s16++ = ((vector signed short){0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f,0x000f});
+}
+void fs16e(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0,0xf0f0});
+  *s16++ = ((vector signed short){0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1,0xf1f1});
+  *s16++ = ((vector signed short){0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2,0xf2f2});
+  *s16++ = ((vector signed short){0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3,0xf3f3});
+  *s16++ = ((vector signed short){0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4,0xf4f4});
+  *s16++ = ((vector signed short){0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5,0xf5f5});
+  *s16++ = ((vector signed short){0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6,0xf6f6});
+  *s16++ = ((vector signed short){0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7,0xf7f7});
+  *s16++ = ((vector signed short){0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8,0xf8f8});
+  *s16++ = ((vector signed short){0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9,0xf9f9});
+  *s16++ = ((vector signed short){0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa,0xfafa});
+  *s16++ = ((vector signed short){0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb,0xfbfb});
+  *s16++ = ((vector signed short){0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc,0xfcfc});
+  *s16++ = ((vector signed short){0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd,0xfdfd});
+  *s16++ = ((vector signed short){0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe,0xfefe});
+  *s16++ = ((vector signed short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff});
+}
+void fs16f(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000});
+  *s16++ = ((vector signed short){0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101});
+  *s16++ = ((vector signed short){0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202,0x0202});
+  *s16++ = ((vector signed short){0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303,0x0303});
+  *s16++ = ((vector signed short){0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404});
+  *s16++ = ((vector signed short){0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505,0x0505});
+  *s16++ = ((vector signed short){0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606,0x0606});
+  *s16++ = ((vector signed short){0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707,0x0707});
+  *s16++ = ((vector signed short){0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808,0x0808});
+  *s16++ = ((vector signed short){0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909,0x0909});
+  *s16++ = ((vector signed short){0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a,0x0a0a});
+  *s16++ = ((vector signed short){0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b,0x0b0b});
+  *s16++ = ((vector signed short){0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c,0x0c0c});
+  *s16++ = ((vector signed short){0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d,0x0d0d});
+  *s16++ = ((vector signed short){0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e,0x0e0e});
+  *s16++ = ((vector signed short){0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f,0x0f0f});
+}
+void fs16g(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){0,0,0,0,0,0,0,0});
+  *s16++ = ((vector signed short){1,1,1,1,1,1,1,1});
+  *s16++ = ((vector signed short){2,2,2,2,2,2,2,2});
+  *s16++ = ((vector signed short){3,3,3,3,3,3,3,3});
+  *s16++ = ((vector signed short){4,4,4,4,4,4,4,4});
+  *s16++ = ((vector signed short){5,5,5,5,5,5,5,5});
+  *s16++ = ((vector signed short){6,6,6,6,6,6,6,6});
+  *s16++ = ((vector signed short){7,7,7,7,7,7,7,7});
+  *s16++ = ((vector signed short){8,8,8,8,8,8,8,8});
+  *s16++ = ((vector signed short){9,9,9,9,9,9,9,9});
+  *s16++ = ((vector signed short){10,10,10,10,10,10,10,10});
+  *s16++ = ((vector signed short){11,11,11,11,11,11,11,11});
+  *s16++ = ((vector signed short){12,12,12,12,12,12,12,12});
+  *s16++ = ((vector signed short){13,13,13,13,13,13,13,13});
+  *s16++ = ((vector signed short){14,14,14,14,14,14,14,14});
+  *s16++ = ((vector signed short){15,15,15,15,15,15,15,15});
+}
+void fs16h(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){257,257,257,257,257,257,257,257});
+  *s16++ = ((vector signed short){514,514,514,514,514,514,514,514});
+  *s16++ = ((vector signed short){771,771,771,771,771,771,771,771});
+  *s16++ = ((vector signed short){1028,1028,1028,1028,1028,1028,1028,1028});
+  *s16++ = ((vector signed short){1285,1285,1285,1285,1285,1285,1285,1285});
+  *s16++ = ((vector signed short){1542,1542,1542,1542,1542,1542,1542,1542});
+  *s16++ = ((vector signed short){1799,1799,1799,1799,1799,1799,1799,1799});
+  *s16++ = ((vector signed short){2056,2056,2056,2056,2056,2056,2056,2056});
+  *s16++ = ((vector signed short){2313,2313,2313,2313,2313,2313,2313,2313});
+  *s16++ = ((vector signed short){2570,2570,2570,2570,2570,2570,2570,2570});
+  *s16++ = ((vector signed short){2827,2827,2827,2827,2827,2827,2827,2827});
+  *s16++ = ((vector signed short){3084,3084,3084,3084,3084,3084,3084,3084});
+  *s16++ = ((vector signed short){3341,3341,3341,3341,3341,3341,3341,3341});
+  *s16++ = ((vector signed short){3598,3598,3598,3598,3598,3598,3598,3598});
+  *s16++ = ((vector signed short){3855,3855,3855,3855,3855,3855,3855,3855});
+}
+void fs16i(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){61680,61680,61680,61680,61680,61680,61680,61680});
+  *s16++ = ((vector signed short){61937,61937,61937,61937,61937,61937,61937,61937});
+  *s16++ = ((vector signed short){62194,62194,62194,62194,62194,62194,62194,62194});
+  *s16++ = ((vector signed short){62451,62451,62451,62451,62451,62451,62451,62451});
+  *s16++ = ((vector signed short){62708,62708,62708,62708,62708,62708,62708,62708});
+  *s16++ = ((vector signed short){62965,62965,62965,62965,62965,62965,62965,62965});
+  *s16++ = ((vector signed short){63222,63222,63222,63222,63222,63222,63222,63222});
+  *s16++ = ((vector signed short){63479,63479,63479,63479,63479,63479,63479,63479});
+  *s16++ = ((vector signed short){63736,63736,63736,63736,63736,63736,63736,63736});
+  *s16++ = ((vector signed short){63993,63993,63993,63993,63993,63993,63993,63993});
+  *s16++ = ((vector signed short){64250,64250,64250,64250,64250,64250,64250,64250});
+  *s16++ = ((vector signed short){64507,64507,64507,64507,64507,64507,64507,64507});
+  *s16++ = ((vector signed short){64764,64764,64764,64764,64764,64764,64764,64764});
+  *s16++ = ((vector signed short){65021,65021,65021,65021,65021,65021,65021,65021});
+  *s16++ = ((vector signed short){65278,65278,65278,65278,65278,65278,65278,65278});
+}
+void fs16j(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){65520,65520,65520,65520,65520,65520,65520,65520});
+  *s16++ = ((vector signed short){65521,65521,65521,65521,65521,65521,65521,65521});
+  *s16++ = ((vector signed short){65522,65522,65522,65522,65522,65522,65522,65522});
+  *s16++ = ((vector signed short){65523,65523,65523,65523,65523,65523,65523,65523});
+  *s16++ = ((vector signed short){65524,65524,65524,65524,65524,65524,65524,65524});
+  *s16++ = ((vector signed short){65525,65525,65525,65525,65525,65525,65525,65525});
+  *s16++ = ((vector signed short){65526,65526,65526,65526,65526,65526,65526,65526});
+  *s16++ = ((vector signed short){65527,65527,65527,65527,65527,65527,65527,65527});
+  *s16++ = ((vector signed short){65528,65528,65528,65528,65528,65528,65528,65528});
+  *s16++ = ((vector signed short){65529,65529,65529,65529,65529,65529,65529,65529});
+  *s16++ = ((vector signed short){65530,65530,65530,65530,65530,65530,65530,65530});
+  *s16++ = ((vector signed short){65531,65531,65531,65531,65531,65531,65531,65531});
+  *s16++ = ((vector signed short){65532,65532,65532,65532,65532,65532,65532,65532});
+  *s16++ = ((vector signed short){65533,65533,65533,65533,65533,65533,65533,65533});
+  *s16++ = ((vector signed short){65534,65534,65534,65534,65534,65534,65534,65534});
+  *s16++ = ((vector signed short){65535,65535,65535,65535,65535,65535,65535,65535});
+}
+void fs16k(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){-3856,-3856,-3856,-3856,-3856,-3856,-3856,-3856});
+  *s16++ = ((vector signed short){-3599,-3599,-3599,-3599,-3599,-3599,-3599,-3599});
+  *s16++ = ((vector signed short){-3342,-3342,-3342,-3342,-3342,-3342,-3342,-3342});
+  *s16++ = ((vector signed short){-3085,-3085,-3085,-3085,-3085,-3085,-3085,-3085});
+  *s16++ = ((vector signed short){-2828,-2828,-2828,-2828,-2828,-2828,-2828,-2828});
+  *s16++ = ((vector signed short){-2571,-2571,-2571,-2571,-2571,-2571,-2571,-2571});
+  *s16++ = ((vector signed short){-2314,-2314,-2314,-2314,-2314,-2314,-2314,-2314});
+  *s16++ = ((vector signed short){-2057,-2057,-2057,-2057,-2057,-2057,-2057,-2057});
+  *s16++ = ((vector signed short){-1800,-1800,-1800,-1800,-1800,-1800,-1800,-1800});
+  *s16++ = ((vector signed short){-1543,-1543,-1543,-1543,-1543,-1543,-1543,-1543});
+  *s16++ = ((vector signed short){-1286,-1286,-1286,-1286,-1286,-1286,-1286,-1286});
+  *s16++ = ((vector signed short){-1029,-1029,-1029,-1029,-1029,-1029,-1029,-1029});
+  *s16++ = ((vector signed short){-772,-772,-772,-772,-772,-772,-772,-772});
+  *s16++ = ((vector signed short){-515,-515,-515,-515,-515,-515,-515,-515});
+  *s16++ = ((vector signed short){-258,-258,-258,-258,-258,-258,-258,-258});
+}
+void fs16l(vector signed short *s16) 
+{
+  *s16++ = ((vector signed short){-16,-16,-16,-16,-16,-16,-16,-16});
+  *s16++ = ((vector signed short){-15,-15,-15,-15,-15,-15,-15,-15});
+  *s16++ = ((vector signed short){-14,-14,-14,-14,-14,-14,-14,-14});
+  *s16++ = ((vector signed short){-13,-13,-13,-13,-13,-13,-13,-13});
+  *s16++ = ((vector signed short){-12,-12,-12,-12,-12,-12,-12,-12});
+  *s16++ = ((vector signed short){-11,-11,-11,-11,-11,-11,-11,-11});
+  *s16++ = ((vector signed short){-10,-10,-10,-10,-10,-10,-10,-10});
+  *s16++ = ((vector signed short){-9,-9,-9,-9,-9,-9,-9,-9});
+  *s16++ = ((vector signed short){-8,-8,-8,-8,-8,-8,-8,-8});
+  *s16++ = ((vector signed short){-7,-7,-7,-7,-7,-7,-7,-7});
+  *s16++ = ((vector signed short){-6,-6,-6,-6,-6,-6,-6,-6});
+  *s16++ = ((vector signed short){-5,-5,-5,-5,-5,-5,-5,-5});
+  *s16++ = ((vector signed short){-4,-4,-4,-4,-4,-4,-4,-4});
+  *s16++ = ((vector signed short){-3,-3,-3,-3,-3,-3,-3,-3});
+  *s16++ = ((vector signed short){-2,-2,-2,-2,-2,-2,-2,-2});
+  *s16++ = ((vector signed short){-1,-1,-1,-1,-1,-1,-1,-1});
+}
+void fs8a(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0,0xff,0xff,0xff,0xf0});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xf1});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2,0xff,0xff,0xff,0xf2});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3,0xff,0xff,0xff,0xf3});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4,0xff,0xff,0xff,0xf4});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5,0xff,0xff,0xff,0xf5});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6,0xff,0xff,0xff,0xf6});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7,0xff,0xff,0xff,0xf7});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8,0xff,0xff,0xff,0xf8});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa,0xff,0xff,0xff,0xfa});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb,0xff,0xff,0xff,0xfb});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc,0xff,0xff,0xff,0xfc});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xfd});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fs8b(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x05});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x09});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x0a});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x0b});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x0c});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0e});
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f});
+}
+void fs8c(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0,0xff,0xf0});
+  *s8++ = ((vector signed char){0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1,0xff,0xf1});
+  *s8++ = ((vector signed char){0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2,0xff,0xf2});
+  *s8++ = ((vector signed char){0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3,0xff,0xf3});
+  *s8++ = ((vector signed char){0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4,0xff,0xf4});
+  *s8++ = ((vector signed char){0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5,0xff,0xf5});
+  *s8++ = ((vector signed char){0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6,0xff,0xf6});
+  *s8++ = ((vector signed char){0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7,0xff,0xf7});
+  *s8++ = ((vector signed char){0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8,0xff,0xf8});
+  *s8++ = ((vector signed char){0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9,0xff,0xf9});
+  *s8++ = ((vector signed char){0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa,0xff,0xfa});
+  *s8++ = ((vector signed char){0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb,0xff,0xfb});
+  *s8++ = ((vector signed char){0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc,0xff,0xfc});
+  *s8++ = ((vector signed char){0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd,0xff,0xfd});
+  *s8++ = ((vector signed char){0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe,0xff,0xfe});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fs8d(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *s8++ = ((vector signed char){0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01});
+  *s8++ = ((vector signed char){0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02});
+  *s8++ = ((vector signed char){0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x03});
+  *s8++ = ((vector signed char){0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04});
+  *s8++ = ((vector signed char){0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05});
+  *s8++ = ((vector signed char){0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06,0x00,0x06});
+  *s8++ = ((vector signed char){0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07,0x00,0x07});
+  *s8++ = ((vector signed char){0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08});
+  *s8++ = ((vector signed char){0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09,0x00,0x09});
+  *s8++ = ((vector signed char){0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a,0x00,0x0a});
+  *s8++ = ((vector signed char){0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b,0x00,0x0b});
+  *s8++ = ((vector signed char){0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c,0x00,0x0c});
+  *s8++ = ((vector signed char){0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d,0x00,0x0d});
+  *s8++ = ((vector signed char){0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e,0x00,0x0e});
+  *s8++ = ((vector signed char){0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f,0x00,0x0f});
+}
+void fs8e(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00});
+  *s8++ = ((vector signed char){0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01});
+  *s8++ = ((vector signed char){0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02});
+  *s8++ = ((vector signed char){0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03});
+  *s8++ = ((vector signed char){0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04});
+  *s8++ = ((vector signed char){0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05,0x05});
+  *s8++ = ((vector signed char){0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06});
+  *s8++ = ((vector signed char){0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x07});
+  *s8++ = ((vector signed char){0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08});
+  *s8++ = ((vector signed char){0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09,0x09});
+  *s8++ = ((vector signed char){0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a});
+  *s8++ = ((vector signed char){0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b});
+  *s8++ = ((vector signed char){0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c});
+  *s8++ = ((vector signed char){0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d,0x0d});
+  *s8++ = ((vector signed char){0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e,0x0e});
+  *s8++ = ((vector signed char){0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f});
+}
+void fs8f(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0});
+  *s8++ = ((vector signed char){0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1,0xf1});
+  *s8++ = ((vector signed char){0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2,0xf2});
+  *s8++ = ((vector signed char){0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3,0xf3});
+  *s8++ = ((vector signed char){0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4,0xf4});
+  *s8++ = ((vector signed char){0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5,0xf5});
+  *s8++ = ((vector signed char){0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6,0xf6});
+  *s8++ = ((vector signed char){0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7,0xf7});
+  *s8++ = ((vector signed char){0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8,0xf8});
+  *s8++ = ((vector signed char){0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9});
+  *s8++ = ((vector signed char){0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa});
+  *s8++ = ((vector signed char){0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb,0xfb});
+  *s8++ = ((vector signed char){0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc});
+  *s8++ = ((vector signed char){0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd});
+  *s8++ = ((vector signed char){0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe});
+  *s8++ = ((vector signed char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff});
+}
+void fs8g(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0});
+  *s8++ = ((vector signed char){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1});
+  *s8++ = ((vector signed char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2});
+  *s8++ = ((vector signed char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  *s8++ = ((vector signed char){4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4});
+  *s8++ = ((vector signed char){5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5});
+  *s8++ = ((vector signed char){6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6});
+  *s8++ = ((vector signed char){7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7});
+  *s8++ = ((vector signed char){8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8});
+  *s8++ = ((vector signed char){9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9});
+  *s8++ = ((vector signed char){10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10});
+  *s8++ = ((vector signed char){11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11});
+  *s8++ = ((vector signed char){12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12});
+  *s8++ = ((vector signed char){13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13});
+  *s8++ = ((vector signed char){14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14});
+  *s8++ = ((vector signed char){15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15});
+}
+void fs8h(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){240,240,240,240,240,240,240,240,240,240,240,240,240,240,240,240});
+  *s8++ = ((vector signed char){241,241,241,241,241,241,241,241,241,241,241,241,241,241,241,241});
+  *s8++ = ((vector signed char){242,242,242,242,242,242,242,242,242,242,242,242,242,242,242,242});
+  *s8++ = ((vector signed char){243,243,243,243,243,243,243,243,243,243,243,243,243,243,243,243});
+  *s8++ = ((vector signed char){244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244});
+  *s8++ = ((vector signed char){245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245});
+  *s8++ = ((vector signed char){246,246,246,246,246,246,246,246,246,246,246,246,246,246,246,246});
+  *s8++ = ((vector signed char){247,247,247,247,247,247,247,247,247,247,247,247,247,247,247,247});
+  *s8++ = ((vector signed char){248,248,248,248,248,248,248,248,248,248,248,248,248,248,248,248});
+  *s8++ = ((vector signed char){249,249,249,249,249,249,249,249,249,249,249,249,249,249,249,249});
+  *s8++ = ((vector signed char){250,250,250,250,250,250,250,250,250,250,250,250,250,250,250,250});
+  *s8++ = ((vector signed char){251,251,251,251,251,251,251,251,251,251,251,251,251,251,251,251});
+  *s8++ = ((vector signed char){252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252});
+  *s8++ = ((vector signed char){253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253});
+  *s8++ = ((vector signed char){254,254,254,254,254,254,254,254,254,254,254,254,254,254,254,254});
+  *s8++ = ((vector signed char){255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255});
+}
+void fs8i(vector signed char *s8) 
+{
+  *s8++ = ((vector signed char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1});
+  *s8++ = ((vector signed char){-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2});
+  *s8++ = ((vector signed char){-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3});
+  *s8++ = ((vector signed char){-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4});
+  *s8++ = ((vector signed char){-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5});
+  *s8++ = ((vector signed char){-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6});
+  *s8++ = ((vector signed char){-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7});
+  *s8++ = ((vector signed char){-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8});
+  *s8++ = ((vector signed char){-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9});
+  *s8++ = ((vector signed char){-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10});
+  *s8++ = ((vector signed char){-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11});
+  *s8++ = ((vector signed char){-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12});
+  *s8++ = ((vector signed char){-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13});
+  *s8++ = ((vector signed char){-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14,-14});
+  *s8++ = ((vector signed char){-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15});
+  *s8++ = ((vector signed char){-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16,-16});
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-11.c
new file mode 100644
index 000000000..7d9b3975f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/5-11.c
@@ -0,0 +1,289 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern void fu32(vector unsigned int, vector unsigned int,
+		 vector unsigned int, vector unsigned int);
+void fxu32(vector unsigned int u32a, vector unsigned int u32b,
+	   vector unsigned int u32c, vector unsigned int u32d)
+{
+ fu32 (u32a,
+       u32b,
+       u32c,
+       vec_avg(u32d, u32d));
+ fu32 (vec_or (u32a, u32a),
+       vec_and (u32b, u32b),
+       vec_max (u32c, u32c),
+       vec_min (u32d, u32d));
+ fu32 (vec_sld (u32a, u32a, 0),
+       vec_sld (u32b, u32b, 0),
+       vec_sld (u32c, u32c, 0),
+       vec_sld (u32d, u32d, 0));
+ fu32 (((vector unsigned int){0,0,0,0}),
+       ((vector unsigned int){0,0,0,0}),
+       ((vector unsigned int){0,0,0,0}),
+       ((vector unsigned int){0,0,0,0}));
+ fu32 (vec_xor(u32a, u32a),
+       vec_andc(u32b, u32b),
+       vec_sub(u32c, u32c),
+       vec_subs(u32d, u32d));
+ fu32 (vec_splat_u32(0),
+       vec_splat_u32(0),
+       vec_splat_u32(0),
+       vec_splat_u32(0));
+ fu32 (((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff}),
+       ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff}),
+       ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff}),
+       ((vector unsigned int){0xffffffff,0xffffffff,0xffffffff,0xffffffff}));
+ fu32 (vec_splat_u32(-1),
+       vec_splat_u32(-1),
+       vec_splat_u32(-1),
+       vec_splat_u32(-1));
+ fu32 ((vector unsigned int)vec_cmpeq(u32a, u32a),
+       (vector unsigned int)vec_cmpeq(u32b, u32b),
+       (vector unsigned int)vec_cmpeq(u32c, u32c),
+       (vector unsigned int)vec_cmpeq(u32d, u32d));
+}
+
+extern void fu16(vector unsigned short, vector unsigned short,
+		 vector unsigned short, vector unsigned short);
+void fxu16(vector unsigned short u16a, vector unsigned short u16b,
+	   vector unsigned short u16c, vector unsigned short u16d)
+{
+ fu16 (u16a,
+       u16b,
+       u16c,
+       vec_avg(u16d, u16d));
+ fu16 (vec_or (u16a, u16a),
+       vec_and (u16b, u16b),
+       vec_max (u16c, u16c),
+       vec_min (u16d, u16d));
+ fu16 (vec_sld (u16a, u16a, 0),
+       vec_sld (u16b, u16b, 0),
+       vec_sld (u16c, u16c, 0),
+       vec_sld (u16d, u16d, 0));
+ fu16 (((vector unsigned short){0,0,0,0,0,0,0,0}),
+       ((vector unsigned short){0,0,0,0,0,0,0,0}),
+       ((vector unsigned short){0,0,0,0,0,0,0,0}),
+       ((vector unsigned short){0,0,0,0,0,0,0,0}));
+ fu16 (vec_xor(u16a, u16a),
+       vec_andc(u16b, u16b),
+       vec_sub(u16c, u16c),
+       vec_subs(u16d, u16d));
+ fu16 (vec_splat_u16(0),
+       vec_splat_u16(0),
+       vec_splat_u16(0),
+       vec_splat_u16(0));
+ fu16 (((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}),
+       ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}),
+       ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}),
+       ((vector unsigned short){0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}));
+ fu16 (vec_splat_u16(-1),
+       vec_splat_u16(-1),
+       vec_splat_u16(-1),
+       vec_splat_u16(-1));
+ fu16 ((vector unsigned short)vec_cmpeq(u16a, u16a),
+       (vector unsigned short)vec_cmpeq(u16b, u16b),
+       (vector unsigned short)vec_cmpeq(u16c, u16c),
+       (vector unsigned short)vec_cmpeq(u16d, u16d));
+}
+
+extern void fu8(vector unsigned char, vector unsigned char,
+		vector unsigned char, vector unsigned char);
+void fxu8(vector unsigned char u8a, vector unsigned char u8b,
+	   vector unsigned char u8c, vector unsigned char u8d)
+{
+ fu8 (u8a,
+       u8b,
+       u8c,
+       vec_avg(u8d, u8d));
+ fu8 (vec_or (u8a, u8a),
+       vec_and (u8b, u8b),
+       vec_max (u8c, u8c),
+       vec_min (u8d, u8d));
+ fu8 (vec_sld (u8a, u8a, 0),
+       vec_sld (u8b, u8b, 0),
+       vec_sld (u8c, u8c, 0),
+       vec_sld (u8d, u8d, 0));
+ fu8 (((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}),
+       ((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}),
+       ((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}),
+       ((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}));
+ fu8 (vec_xor(u8a, u8a),
+       vec_andc(u8b, u8b),
+       vec_sub(u8c, u8c),
+       vec_subs(u8d, u8d));
+ fu8 (vec_splat_u8(0),
+       vec_splat_u8(0),
+       vec_splat_u8(0),
+       vec_splat_u8(0));
+ fu8 (((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}),
+       ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}),
+       ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}),
+       ((vector unsigned char){0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}));
+ fu8 (vec_splat_u8(-1),
+       vec_splat_u8(-1),
+       vec_splat_u8(-1),
+       vec_splat_u8(-1));
+ fu8 ((vector unsigned char)vec_cmpeq(u8a, u8a),
+       (vector unsigned char)vec_cmpeq(u8b, u8b),
+       (vector unsigned char)vec_cmpeq(u8c, u8c),
+       (vector unsigned char)vec_cmpeq(u8d, u8d));
+}
+
+extern void fs32(vector signed int, vector signed int,
+		 vector signed int, vector signed int);
+void fxs32(vector signed int s32a, vector signed int s32b,
+	   vector signed int s32c, vector signed int s32d)
+{
+ fs32 (s32a,
+       s32b,
+       s32c,
+       vec_avg(s32d, s32d));
+ fs32 (vec_or (s32a, s32a),
+       vec_and (s32b, s32b),
+       vec_max (s32c, s32c),
+       vec_min (s32d, s32d));
+ fs32 (vec_sld (s32a, s32a, 0),
+       vec_sld (s32b, s32b, 0),
+       vec_sld (s32c, s32c, 0),
+       vec_sld (s32d, s32d, 0));
+ fs32 (((vector signed int){0,0,0,0}),
+       ((vector signed int){0,0,0,0}),
+       ((vector signed int){0,0,0,0}),
+       ((vector signed int){0,0,0,0}));
+ fs32 (vec_xor(s32a, s32a),
+       vec_andc(s32b, s32b),
+       vec_sub(s32c, s32c),
+       vec_subs(s32d, s32d));
+ fs32 (vec_splat_s32(0),
+       vec_splat_s32(0),
+       vec_splat_s32(0),
+       vec_splat_s32(0));
+ fs32 (((vector signed int){-1,-1,-1,-1}),
+       ((vector signed int){-1,-1,-1,-1}),
+       ((vector signed int){-1,-1,-1,-1}),
+       ((vector signed int){-1,-1,-1,-1}));
+ fs32 (vec_splat_s32(-1),
+       vec_splat_s32(-1),
+       vec_splat_s32(-1),
+       vec_splat_s32(-1));
+ fs32 ((vector signed int)vec_cmpeq(s32a, s32a),
+       (vector signed int)vec_cmpeq(s32b, s32b),
+       (vector signed int)vec_cmpeq(s32c, s32c),
+       (vector signed int)vec_cmpeq(s32d, s32d));
+}
+
+extern void fs16(vector signed short, vector signed short,
+		 vector signed short, vector signed short);
+void fxs16(vector signed short s16a, vector signed short s16b,
+	   vector signed short s16c, vector signed short s16d)
+{
+ fs16 (s16a,
+       s16b,
+       s16c,
+       vec_avg(s16d, s16d));
+ fs16 (vec_or (s16a, s16a),
+       vec_and (s16b, s16b),
+       vec_max (s16c, s16c),
+       vec_min (s16d, s16d));
+ fs16 (vec_sld (s16a, s16a, 0),
+       vec_sld (s16b, s16b, 0),
+       vec_sld (s16c, s16c, 0),
+       vec_sld (s16d, s16d, 0));
+ fs16 (((vector signed short){0,0,0,0,0,0,0,0}),
+       ((vector signed short){0,0,0,0,0,0,0,0}),
+       ((vector signed short){0,0,0,0,0,0,0,0}),
+       ((vector signed short){0,0,0,0,0,0,0,0}));
+ fs16 (vec_xor(s16a, s16a),
+       vec_andc(s16b, s16b),
+       vec_sub(s16c, s16c),
+       vec_subs(s16d, s16d));
+ fs16 (vec_splat_s16(0),
+       vec_splat_s16(0),
+       vec_splat_s16(0),
+       vec_splat_s16(0));
+ fs16 (((vector signed short){-1,-1,-1,-1,-1,-1,-1,-1}),
+       ((vector signed short){-1,-1,-1,-1,-1,-1,-1,-1}),
+       ((vector signed short){-1,-1,-1,-1,-1,-1,-1,-1}),
+       ((vector signed short){-1,-1,-1,-1,-1,-1,-1,-1}));
+ fs16 (vec_splat_s16(-1),
+       vec_splat_s16(-1),
+       vec_splat_s16(-1),
+       vec_splat_s16(-1));
+ fs16 ((vector signed short)vec_cmpeq(s16a, s16a),
+       (vector signed short)vec_cmpeq(s16b, s16b),
+       (vector signed short)vec_cmpeq(s16c, s16c),
+       (vector signed short)vec_cmpeq(s16d, s16d));
+}
+
+extern void fs8(vector signed char, vector signed char,
+		vector signed char, vector signed char);
+void fxs8(vector signed char s8a, vector signed char s8b,
+	   vector signed char s8c, vector signed char s8d)
+{
+ fs8 (s8a,
+       s8b,
+       s8c,
+       vec_avg(s8d, s8d));
+ fs8 (vec_or (s8a, s8a),
+       vec_and (s8b, s8b),
+       vec_max (s8c, s8c),
+       vec_min (s8d, s8d));
+ fs8 (vec_sld (s8a, s8a, 0),
+       vec_sld (s8b, s8b, 0),
+       vec_sld (s8c, s8c, 0),
+       vec_sld (s8d, s8d, 0));
+ fs8 (((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}),
+       ((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}),
+       ((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}),
+       ((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}));
+ fs8 (vec_xor(s8a, s8a),
+       vec_andc(s8b, s8b),
+       vec_sub(s8c, s8c),
+       vec_subs(s8d, s8d));
+ fs8 (vec_splat_s8(0),
+       vec_splat_s8(0),
+       vec_splat_s8(0),
+       vec_splat_s8(0));
+ fs8 (((vector signed char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}),
+       ((vector signed char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}),
+       ((vector signed char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}),
+       ((vector signed char){-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}));
+ fs8 (vec_splat_s8(-1),
+       vec_splat_s8(-1),
+       vec_splat_s8(-1),
+       vec_splat_s8(-1));
+ fs8 ((vector signed char)vec_cmpeq(s8a, s8a),
+       (vector signed char)vec_cmpeq(s8b, s8b),
+       (vector signed char)vec_cmpeq(s8c, s8c),
+       (vector signed char)vec_cmpeq(s8d, s8d));
+}
+
+void fu32(vector unsigned int a, vector unsigned int b,
+	  vector unsigned int c, vector unsigned int d)
+{
+}
+
+void fu16(vector unsigned short a, vector unsigned short b,
+	  vector unsigned short c, vector unsigned short d)
+{
+}
+
+void fu8(vector unsigned char a, vector unsigned char b,
+	 vector unsigned char c, vector unsigned char d)
+{
+}
+
+void fs32(vector signed int a, vector signed int b,
+	  vector signed int c, vector signed int d)
+{
+}
+
+void fs16(vector signed short a, vector signed short b,
+	  vector signed short c, vector signed short d)
+{
+}
+
+void fs8(vector signed char a, vector signed char b,
+	 vector signed char c, vector signed char d)
+{
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7-01.c
new file mode 100644
index 000000000..f986d8fe5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7-01.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern vector signed short image[];
+extern vector signed short band[];
+
+#define load(a,b) (a[b])
+#define store(v,a,b) (a[b]) = (v)
+
+void
+haar (vector signed char a, vector signed char b, vector signed char c,
+      vector signed char d, unsigned int N, int XX)
+{
+  unsigned int i;
+  vector unsigned char high, low;
+  vector signed int zero = ((vector signed int){0,0,0,0});
+
+  for (i = 0; i < N; i++) {
+    high = (vector unsigned char) (vec_vmrghh (load(image, i+XX),
+					       load(image, i)));
+    low = (vector unsigned char) (vec_vmrglh (load(image, i+XX),
+					      load(image, i)));
+
+    store (vec_vpkswss (vec_vmsummbm (a, high, zero),
+			vec_vmsummbm (a, low, zero)),
+	   band, i);
+    store (vec_vpkswss (vec_vmsummbm (b, high, zero),
+			vec_vmsummbm (b, low, zero)),
+	   band, i+1);
+    store(vec_vpkswss (vec_vmsummbm (c, high, zero),
+		       vec_vmsummbm (c, low, zero)),
+	  band, i+2);
+    store(vec_vpkswss (vec_vmsummbm (d, high, zero),
+		       vec_vmsummbm (d, low, zero)),
+	  band, i+3);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7-01a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7-01a.c
new file mode 100644
index 000000000..c09835b43
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7-01a.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern vector signed short image[];
+extern vector signed short band[];
+
+#define load(a,b) vec_ld((b)*16, a)
+#define store(v,a,b) vec_st(v,(b)*16,a)
+
+void
+haar (vector signed char a, vector signed char b, vector signed char c,
+      vector signed char d, unsigned int N, int XX)
+{
+  unsigned int i;
+  vector unsigned char high, low;
+  vector signed int zero = ((vector signed int){0,0,0,0});
+
+  for (i = 0; i < N; i++) {
+    high = (vector unsigned char) (vec_vmrghh (load(image, i+XX),
+					       load(image, i)));
+    low = (vector unsigned char) (vec_vmrglh (load(image, i+XX),
+					      load(image, i)));
+
+    store (vec_vpkswss (vec_vmsummbm (a, high, zero),
+			vec_vmsummbm (a, low, zero)),
+	   band, i);
+    store (vec_vpkswss (vec_vmsummbm (b, high, zero),
+			vec_vmsummbm (b, low, zero)),
+	   band, i+1);
+    store(vec_vpkswss (vec_vmsummbm (c, high, zero),
+		       vec_vmsummbm (c, low, zero)),
+	  band, i+2);
+    store(vec_vpkswss (vec_vmsummbm (d, high, zero),
+		       vec_vmsummbm (d, low, zero)),
+	  band, i+3);
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7c-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7c-01.c
new file mode 100644
index 000000000..68e07aa30
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7c-01.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector float
+f(int i)
+{
+  switch (i) {
+  case 0:
+    return (vector float)(((vector unsigned char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3}));
+  }
+  return ((vector float){0,0,0,0});
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7d-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7d-01.c
new file mode 100644
index 000000000..dac5151ad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7d-01.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern vector unsigned char a[];
+
+vector unsigned char
+f(vector unsigned char *p, int i, int b)
+{
+  if (b)
+    return p[i];
+  return vec_ld(i*16,p);
+}
+
+vector unsigned char
+g(int i, int b)
+{
+  if (b)
+    return a[i];
+  return vec_ld(i*16,a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7d-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7d-02.c
new file mode 100644
index 000000000..6294cc99e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/7d-02.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern vector unsigned char a[];
+
+void f
+(vector unsigned char v, vector unsigned char *p, int i, int b)
+{
+  if (b)
+    p[i] = v;
+  else
+    vec_st(v, i*16,p);
+}
+
+void g
+(vector unsigned char v, int i, int b)
+{
+  if (b)
+    a[i] = v;
+  else
+    vec_st(v,i*16,a);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-01.c
new file mode 100644
index 000000000..d65815e3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-01.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+#include <altivec.h>
+
+int i = vec_step(vector unsigned short);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-02.c
new file mode 100644
index 000000000..72a4a907a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-02.c
@@ -0,0 +1,299 @@
+#include "harness.h"
+
+extern vector unsigned char u8;
+extern vector signed char s8;
+extern vector bool char b8;
+extern vector unsigned short u16;
+extern vector signed short s16;
+extern vector bool short b16;
+extern vector unsigned int u32;
+extern vector signed int s32;
+extern vector bool int b32;
+extern vector float f32;
+extern vector pixel p16;
+extern vector unsigned char const u8c;
+extern vector signed char const s8c;
+extern vector bool char const b8c;
+extern vector unsigned short const u16c;
+extern vector signed short const s16c;
+extern vector bool short const b16c;
+extern vector unsigned int const u32c;
+extern vector signed int const s32c;
+extern vector bool int const b32c;
+extern vector float const f32c;
+extern vector pixel const p16c;
+extern vector unsigned char volatile u8v;
+extern vector signed char volatile s8v;
+extern vector bool char volatile b8v;
+extern vector unsigned short volatile u16v;
+extern vector signed short volatile s16v;
+extern vector bool short volatile b16v;
+extern vector unsigned int volatile u32v;
+extern vector signed int volatile s32v;
+extern vector bool int volatile b32v;
+extern vector float volatile f32v;
+extern vector pixel volatile p16v;
+extern const vector unsigned char u8c_;
+extern const vector signed char s8c_;
+extern const vector bool char b8c_;
+extern const vector unsigned short u16c_;
+extern const vector signed short s16c_;
+extern const vector bool short b16c_;
+extern const vector unsigned int u32c_;
+extern const vector signed int s32c_;
+extern const vector bool int b32c_;
+extern const vector float f32c_;
+extern const vector pixel p16c_;
+extern volatile vector unsigned char u8v_;
+extern volatile vector signed char s8v_;
+extern volatile vector bool char b8v_;
+extern volatile vector unsigned short u16v_;
+extern volatile vector signed short s16v_;
+extern volatile vector bool short b16v_;
+extern volatile vector unsigned int u32v_;
+extern volatile vector signed int s32v_;
+extern volatile vector bool int b32v_;
+extern volatile vector float f32v_;
+extern volatile vector pixel p16v_;
+int i_u8 = vec_step(u8);
+int i_s8 = vec_step(s8);
+int i_b8 = vec_step(b8);
+int i_u16 = vec_step(u16);
+int i_s16 = vec_step(s16);
+int i_b16 = vec_step(b16);
+int i_u32 = vec_step(u32);
+int i_s32 = vec_step(s32);
+int i_b32 = vec_step(b32);
+int i_f32 = vec_step(f32);
+int i_p16 = vec_step(p16);
+int i_u8c = vec_step(u8c);
+int i_s8c = vec_step(s8c);
+int i_b8c = vec_step(b8c);
+int i_u16c = vec_step(u16c);
+int i_s16c = vec_step(s16c);
+int i_b16c = vec_step(b16c);
+int i_u32c = vec_step(u32c);
+int i_s32c = vec_step(s32c);
+int i_b32c = vec_step(b32c);
+int i_f32c = vec_step(f32c);
+int i_p16c = vec_step(p16c);
+int i_u8v = vec_step(u8v);
+int i_s8v = vec_step(s8v);
+int i_b8v = vec_step(b8v);
+int i_u16v = vec_step(u16v);
+int i_s16v = vec_step(s16v);
+int i_b16v = vec_step(b16v);
+int i_u32v = vec_step(u32v);
+int i_s32v = vec_step(s32v);
+int i_b32v = vec_step(b32v);
+int i_f32v = vec_step(f32v);
+int i_p16v = vec_step(p16v);
+int i_u8c_ = vec_step(u8c_);
+int i_s8c_ = vec_step(s8c_);
+int i_b8c_ = vec_step(b8c_);
+int i_u16c_ = vec_step(u16c_);
+int i_s16c_ = vec_step(s16c_);
+int i_b16c_ = vec_step(b16c_);
+int i_u32c_ = vec_step(u32c_);
+int i_s32c_ = vec_step(s32c_);
+int i_b32c_ = vec_step(b32c_);
+int i_f32c_ = vec_step(f32c_);
+int i_p16c_ = vec_step(p16c_);
+int i_u8v_ = vec_step(u8v_);
+int i_s8v_ = vec_step(s8v_);
+int i_b8v_ = vec_step(b8v_);
+int i_u16v_ = vec_step(u16v_);
+int i_s16v_ = vec_step(s16v_);
+int i_b16v_ = vec_step(b16v_);
+int i_u32v_ = vec_step(u32v_);
+int i_s32v_ = vec_step(s32v_);
+int i_b32v_ = vec_step(b32v_);
+int i_f32v_ = vec_step(f32v_);
+int i_p16v_ = vec_step(p16v_);
+int j_u8 = vec_step(vector unsigned char);
+int j_s8 = vec_step(vector signed char);
+int j_b8 = vec_step(vector bool char);
+int j_u16 = vec_step(vector unsigned short);
+int j_s16 = vec_step(vector signed short);
+int j_b16 = vec_step(vector bool short);
+int j_u32 = vec_step(vector unsigned int);
+int j_s32 = vec_step(vector signed int);
+int j_b32 = vec_step(vector bool int);
+int j_f32 = vec_step(vector float);
+int j_p16 = vec_step(vector pixel);
+int j_u8c = vec_step(vector unsigned char const);
+int j_s8c = vec_step(vector signed char const);
+int j_b8c = vec_step(vector bool char const);
+int j_u16c = vec_step(vector unsigned short const);
+int j_s16c = vec_step(vector signed short const);
+int j_b16c = vec_step(vector bool short const);
+int j_u32c = vec_step(vector unsigned int const);
+int j_s32c = vec_step(vector signed int const);
+int j_b32c = vec_step(vector bool int const);
+int j_f32c = vec_step(vector float const);
+int j_p16c = vec_step(vector pixel const);
+int j_u8v = vec_step(vector unsigned char volatile);
+int j_s8v = vec_step(vector signed char volatile);
+int j_b8v = vec_step(vector bool char volatile);
+int j_u16v = vec_step(vector unsigned short volatile);
+int j_s16v = vec_step(vector signed short volatile);
+int j_b16v = vec_step(vector bool short volatile);
+int j_u32v = vec_step(vector unsigned int volatile);
+int j_s32v = vec_step(vector signed int volatile);
+int j_b32v = vec_step(vector bool int volatile);
+int j_f32v = vec_step(vector float volatile);
+int j_p16v = vec_step(vector pixel volatile);
+int j_u8c_ = vec_step(const vector unsigned char);
+int j_s8c_ = vec_step(const vector signed char);
+int j_b8c_ = vec_step(const vector bool char);
+int j_u16c_ = vec_step(const vector unsigned short);
+int j_s16c_ = vec_step(const vector signed short);
+int j_b16c_ = vec_step(const vector bool short);
+int j_u32c_ = vec_step(const vector unsigned int);
+int j_s32c_ = vec_step(const vector signed int);
+int j_b32c_ = vec_step(const vector bool int);
+int j_f32c_ = vec_step(const vector float);
+int j_p16c_ = vec_step(const vector pixel);
+int j_u8v_ = vec_step(volatile vector unsigned char);
+int j_s8v_ = vec_step(volatile vector signed char);
+int j_b8v_ = vec_step(volatile vector bool char);
+int j_u16v_ = vec_step(volatile vector unsigned short);
+int j_s16v_ = vec_step(volatile vector signed short);
+int j_b16v_ = vec_step(volatile vector bool short);
+int j_u32v_ = vec_step(volatile vector unsigned int);
+int j_s32v_ = vec_step(volatile vector signed int);
+int j_b32v_ = vec_step(volatile vector bool int);
+int j_f32v_ = vec_step(volatile vector float);
+int j_p16v_ = vec_step(volatile vector pixel);
+
+static void test()
+{
+  int i_u8 = vec_step(u8);
+  int i_s8 = vec_step(s8);
+  int i_b8 = vec_step(b8);
+  int i_u16 = vec_step(u16);
+  int i_s16 = vec_step(s16);
+  int i_b16 = vec_step(b16);
+  int i_u32 = vec_step(u32);
+  int i_s32 = vec_step(s32);
+  int i_b32 = vec_step(b32);
+  int i_f32 = vec_step(f32);
+  int i_p16 = vec_step(p16);
+  int i_u8c = vec_step(u8c);
+  int i_s8c = vec_step(s8c);
+  int i_b8c = vec_step(b8c);
+  int i_u16c = vec_step(u16c);
+  int i_s16c = vec_step(s16c);
+  int i_b16c = vec_step(b16c);
+  int i_u32c = vec_step(u32c);
+  int i_s32c = vec_step(s32c);
+  int i_b32c = vec_step(b32c);
+  int i_f32c = vec_step(f32c);
+  int i_p16c = vec_step(p16c);
+  int i_u8v = vec_step(u8v);
+  int i_s8v = vec_step(s8v);
+  int i_b8v = vec_step(b8v);
+  int i_u16v = vec_step(u16v);
+  int i_s16v = vec_step(s16v);
+  int i_b16v = vec_step(b16v);
+  int i_u32v = vec_step(u32v);
+  int i_s32v = vec_step(s32v);
+  int i_b32v = vec_step(b32v);
+  int i_f32v = vec_step(f32v);
+  int i_p16v = vec_step(p16v);
+  int i_u8c_ = vec_step(u8c_);
+  int i_s8c_ = vec_step(s8c_);
+  int i_b8c_ = vec_step(b8c_);
+  int i_u16c_ = vec_step(u16c_);
+  int i_s16c_ = vec_step(s16c_);
+  int i_b16c_ = vec_step(b16c_);
+  int i_u32c_ = vec_step(u32c_);
+  int i_s32c_ = vec_step(s32c_);
+  int i_b32c_ = vec_step(b32c_);
+  int i_f32c_ = vec_step(f32c_);
+  int i_p16c_ = vec_step(p16c_);
+  int i_u8v_ = vec_step(u8v_);
+  int i_s8v_ = vec_step(s8v_);
+  int i_b8v_ = vec_step(b8v_);
+  int i_u16v_ = vec_step(u16v_);
+  int i_s16v_ = vec_step(s16v_);
+  int i_b16v_ = vec_step(b16v_);
+  int i_u32v_ = vec_step(u32v_);
+  int i_s32v_ = vec_step(s32v_);
+  int i_b32v_ = vec_step(b32v_);
+  int i_f32v_ = vec_step(f32v_);
+  int i_p16v_ = vec_step(p16v_);
+  int j_u8 = vec_step(vector unsigned char);
+  int j_s8 = vec_step(vector signed char);
+  int j_b8 = vec_step(vector bool char);
+  int j_u16 = vec_step(vector unsigned short);
+  int j_s16 = vec_step(vector signed short);
+  int j_b16 = vec_step(vector bool short);
+  int j_u32 = vec_step(vector unsigned int);
+  int j_s32 = vec_step(vector signed int);
+  int j_b32 = vec_step(vector bool int);
+  int j_f32 = vec_step(vector float);
+  int j_p16 = vec_step(vector pixel);
+  int j_u8c = vec_step(vector unsigned char const);
+  int j_s8c = vec_step(vector signed char const);
+  int j_b8c = vec_step(vector bool char const);
+  int j_u16c = vec_step(vector unsigned short const);
+  int j_s16c = vec_step(vector signed short const);
+  int j_b16c = vec_step(vector bool short const);
+  int j_u32c = vec_step(vector unsigned int const);
+  int j_s32c = vec_step(vector signed int const);
+  int j_b32c = vec_step(vector bool int const);
+  int j_f32c = vec_step(vector float const);
+  int j_p16c = vec_step(vector pixel const);
+  int j_u8v = vec_step(vector unsigned char volatile);
+  int j_s8v = vec_step(vector signed char volatile);
+  int j_b8v = vec_step(vector bool char volatile);
+  int j_u16v = vec_step(vector unsigned short volatile);
+  int j_s16v = vec_step(vector signed short volatile);
+  int j_b16v = vec_step(vector bool short volatile);
+  int j_u32v = vec_step(vector unsigned int volatile);
+  int j_s32v = vec_step(vector signed int volatile);
+  int j_b32v = vec_step(vector bool int volatile);
+  int j_f32v = vec_step(vector float volatile);
+  int j_p16v = vec_step(vector pixel volatile);
+  int j_u8c_ = vec_step(const vector unsigned char);
+  int j_s8c_ = vec_step(const vector signed char);
+  int j_b8c_ = vec_step(const vector bool char);
+  int j_u16c_ = vec_step(const vector unsigned short);
+  int j_s16c_ = vec_step(const vector signed short);
+  int j_b16c_ = vec_step(const vector bool short);
+  int j_u32c_ = vec_step(const vector unsigned int);
+  int j_s32c_ = vec_step(const vector signed int);
+  int j_b32c_ = vec_step(const vector bool int);
+  int j_f32c_ = vec_step(const vector float);
+  int j_p16c_ = vec_step(const vector pixel);
+  int j_u8v_ = vec_step(volatile vector unsigned char);
+  int j_s8v_ = vec_step(volatile vector signed char);
+  int j_b8v_ = vec_step(volatile vector bool char);
+  int j_u16v_ = vec_step(volatile vector unsigned short);
+  int j_s16v_ = vec_step(volatile vector signed short);
+  int j_b16v_ = vec_step(volatile vector bool short);
+  int j_u32v_ = vec_step(volatile vector unsigned int);
+  int j_s32v_ = vec_step(volatile vector signed int);
+  int j_b32v_ = vec_step(volatile vector bool int);
+  int j_f32v_ = vec_step(volatile vector float);
+  int j_p16v_ = vec_step(volatile vector pixel);
+  check((i_u8 + i_s8 + i_b8 + i_u16 + i_s16 + i_b16 + i_u32 + i_s32 +
+	 i_b32 + i_f32 + i_p16 + i_u8c + i_s8c + i_b8c + i_u16c +
+	 i_s16c + i_b16c + i_u32c + i_s32c + i_b32c + i_f32c + i_p16c
+	 + i_u8v + i_s8v + i_b8v + i_u16v + i_s16v + i_b16v + i_u32v
+	 + i_s32v + i_b32v + i_f32v + i_p16v + i_u8c_ + i_s8c_ +
+	 i_b8c_ + i_u16c_ + i_s16c_ + i_b16c_ + i_u32c_ + i_s32c_ +
+	 i_b32c_ + i_f32c_ + i_p16c_ + i_u8v_ + i_s8v_ + i_b8v_ +
+	 i_u16v_ + i_s16v_ + i_b16v_ + i_u32v_ + i_s32v_ + i_b32v_ +
+	 i_f32v_ + i_p16v_ + j_u8 + j_s8 + j_b8 + j_u16 + j_s16 +
+	 j_b16 + j_u32 + j_s32 + j_b32 + j_f32 + j_p16 + j_u8c +
+	 j_s8c + j_b8c + j_u16c + j_s16c + j_b16c + j_u32c + j_s32c +
+	 j_b32c + j_f32c + j_p16c + j_u8v + j_s8v + j_b8v + j_u16v +
+	 j_s16v + j_b16v + j_u32v + j_s32v + j_b32v + j_f32v + j_p16v
+	 + j_u8c_ + j_s8c_ + j_b8c_ + j_u16c_ + j_s16c_ + j_b16c_ +
+	 j_u32c_ + j_s32c_ + j_b32c_ + j_f32c_ + j_p16c_ + j_u8v_ +
+	 j_s8v_ + j_b8v_ + j_u16v_ + j_s16v_ + j_b16v_ + j_u32v_ +
+	 j_s32v_ + j_b32v_ + j_f32v_ + j_p16v_) == 960,
+	"vec_step");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-02a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-02a.c
new file mode 100644
index 000000000..cbea6ca6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/8-02a.c
@@ -0,0 +1,17 @@
+#include "harness.h"
+
+extern vector pixel p16;
+extern vector pixel const p16c;
+extern vector pixel volatile p16v;
+extern const vector pixel p16c_;
+extern volatile vector pixel p16v_;
+
+static void test()
+{
+  int i_p16 = vec_step(p16);
+  int i_p16c = vec_step(p16c);
+  int i_p16v = vec_step(p16v);
+  int i_p16c_ = vec_step(p16c_);
+  int i_p16v_ = vec_step(p16v_);
+  check((i_p16 + i_p16c + i_p16v + i_p16c_ + i_p16v_) == 40, "vec_step");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/brode-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/brode-1.c
new file mode 100644
index 000000000..234192bac
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/brode-1.c
@@ -0,0 +1,10 @@
+#include <altivec.h>
+ int  main( )
+ {
+    static int a[3][5][7];
+    {
+       vector signed int a4v;
+       a4v = vec_ldl(0, &a[0][0][0]);
+    }
+    return 0;
+ }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-1.c
new file mode 100644
index 000000000..fdf392d5f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-1.c
@@ -0,0 +1,39 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <altivec.h>
+
+#define NPAGES 20
+#define NSKIP 10
+static vector float big[NPAGES*4096/16] = { {1,1,1,1} };
+/* NPAGES pages worth.  */
+
+static int failed;
+
+static void f(vector float *p)
+{
+  int i = 1;
+  p = (vector float *)(((ptrdiff_t)p + 4095) & ~4095);
+
+  i += NSKIP;
+  p += NSKIP*4096/16;
+
+  while (i < NPAGES)
+    {
+      if (!vec_all_eq(*p,((vector float){0,0,0,0})))
+	{
+	  printf("*p isn't zero at 0x%p, page %d\n", p, i);
+	  failed++;
+	}
+      i++;
+      p += 4096/16;
+    }
+}
+
+int main(void)
+{
+  f(big);
+  if (failed)
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-2.c
new file mode 100644
index 000000000..5cdbc9856
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-2.c
@@ -0,0 +1,24 @@
+#include "harness.h"
+
+static vector unsigned char value =
+  { 0x7c, 0x12, 0x1, 0xd5,
+    0xc3, 0x99, 0x21, 0xe2,
+    0x12, 0x57, 0xde, 0x6b,
+    0x39, 0x66, 0xa8, 0x87 };
+
+void initn_c (int p1, int p2, signed char p3, int p4, double p5 ,
+	      vector unsigned char p6, signed char p7)
+{
+  check(p1 == 3, "p1");
+  check(p2 == 4, "p2");
+  check(p3 == 5, "p3");
+  check(p4 == 6, "p4");
+  check(p5 == 1, "p5");
+  check(vec_all_eq(p6, value), "p6");
+  check(p7 == 7, "p7");
+}
+         
+void test()
+{
+  initn_c (3, 4, 5, 6, 1, value, 7);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-3.c
new file mode 100644
index 000000000..aacca2667
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/bug-3.c
@@ -0,0 +1,45 @@
+#include "harness.h"
+
+static vector unsigned int value = { 9, 9, 9, 9 };
+
+void varargsC2 (int p1, int p2, int p3, int p4, int p5, int p6, int p7,
+		int p8, vector unsigned int p9, int p10)
+{
+  int i1;
+  int i2;
+  int i3;
+  int i4;
+  int i5;
+  int i6;
+  int i7;
+  int i8;
+  vector unsigned int i9;
+  int i10;
+
+  i1 = p1;
+  i2 = p2;
+  i3 = p3;
+  i4 = p4;
+  i5 = p5;
+  i6 = p6;
+  i7 = p7;
+  i8 = p8;
+  i9 = p9;
+  i10 = p10;
+
+  check(i1 == 1, "i1");
+  check(i2 == 2, "i2");
+  check(i3 == 3, "i3");
+  check(i4 == 4, "i4");
+  check(i5 == 5, "i5");
+  check(i6 == 6, "i6");
+  check(i7 == 7, "i7");
+  check(i8 == 8, "i8");
+  check(vec_all_eq(i9, value), "i9");
+  check(i10 == 10, "i10");
+}
+
+void test()
+{
+  varargsC2 (1, 2, 3, 4, 5, 6, 7, 8, ((vector unsigned int){9,9,9,9}), 10);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/cw-bug-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/cw-bug-1.c
new file mode 100644
index 000000000..0c3028b51
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/cw-bug-1.c
@@ -0,0 +1,12 @@
+#include <altivec.h>
+#include <stdlib.h>
+
+#define ZERO (((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}))
+
+int main(void)
+{
+  vector unsigned char a = ZERO;
+  if (vec_any_ne(a, ZERO))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/cw-bug-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/cw-bug-3.c
new file mode 100644
index 000000000..511a7e0ae
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/cw-bug-3.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector signed short hamming_window[1] = {
+  {2621,  2623,  2629,  2638, 2651,  2668,  2689,  2713}
+};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dct.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dct.c
new file mode 100644
index 000000000..00c4cd93c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dct.c
@@ -0,0 +1,176 @@
+/* { dg-do compile } */
+#include <altivec.h>
+
+inline void
+transpose_vmx (vector signed short *input, vector signed short *output)
+{
+  vector signed short v0, v1, v2, v3, v4, v5, v6, v7;
+  vector signed short x0, x1, x2, x3, x4, x5, x6, x7;
+
+  /* Matrix transpose */
+  v0 = vec_mergeh (input[0], input[4]);
+  v1 = vec_mergel (input[0], input[4]);
+  v2 = vec_mergeh (input[1], input[5]);
+  v3 = vec_mergel (input[1], input[5]);
+  v4 = vec_mergeh (input[2], input[6]);
+  v5 = vec_mergel (input[2], input[6]);
+  v6 = vec_mergeh (input[3], input[7]);
+  v7 = vec_mergel (input[3], input[7]);
+
+  x0 = vec_mergeh (v0, v4);
+  x1 = vec_mergel (v0, v4);
+  x2 = vec_mergeh (v1, v5);
+  x3 = vec_mergel (v1, v5);
+  x4 = vec_mergeh (v2, v6);
+  x5 = vec_mergel (v2, v6);
+  x6 = vec_mergeh (v3, v7);
+  x7 = vec_mergel (v3, v7);
+
+  output[0] = vec_mergeh (x0, x4);
+  output[1] = vec_mergel (x0, x4);
+  output[2] = vec_mergeh (x1, x5);
+  output[3] = vec_mergel (x1, x5);
+  output[4] = vec_mergeh (x2, x6);
+  output[5] = vec_mergel (x2, x6);
+  output[6] = vec_mergeh (x3, x7);
+  output[7] = vec_mergel (x3, x7);
+}
+
+void
+dct_vmx (vector signed short *input, vector signed short *output,
+	 vector signed short *postscale)
+{
+  vector signed short mul0, mul1, mul2, mul3, mul4, mul5, mul6, mul;
+  vector signed short v0, v1, v2, v3, v4, v5, v6, v7, v8, v9;
+  vector signed short v20, v21, v22, v23, v24, v25, v26, v27, v31;
+  int i;
+  vector signed short in[8], out[8];
+
+  /* Load first eight rows of input data */
+
+  /* Load multiplication constants */
+
+  /* Splat multiplication constants */
+  mul0 = vec_splat(input[8],0);
+  mul1 = vec_splat(input[8],1);
+  mul2 = vec_splat(input[8],2);
+  mul3 = vec_splat(input[8],3);
+  mul4 = vec_splat(input[8],4);
+  mul5 = vec_splat(input[8],5);
+  mul6 = vec_splat(input[8],6);
+
+  /* Perform DCT on the eight columns */
+
+  /*********** Stage 1 ***********/
+
+  v8 = vec_adds (input[0], input[7]);
+  v9 = vec_subs (input[0], input[7]);
+  v0 = vec_adds (input[1], input[6]);
+  v7 = vec_subs (input[1], input[6]);
+  v1 = vec_adds (input[2], input[5]);
+  v6 = vec_subs (input[2], input[5]);
+  v2 = vec_adds (input[3], input[4]);
+  v5 = vec_subs (input[3], input[4]);
+
+  /*********** Stage 2 ***********/
+
+  /* Top */
+  v3 = vec_adds (v8, v2);		/* (V0+V7) + (V3+V4) */
+  v4 = vec_subs (v8, v2);		/* (V0+V7) - (V3+V4) */
+  v2 = vec_adds (v0, v1);		/* (V1+V6) + (V2+V5) */
+  v8 = vec_subs (v0, v1);		/* (V1+V6) - (V2+V5) */
+
+  /* Bottom */
+  v0 = vec_subs (v7, v6);		/* (V1-V6) - (V2-V5) */
+  v1 = vec_adds (v7, v6);		/* (V1-V6) + (V2-V5) */
+
+  /*********** Stage 3 ***********/
+
+  /* Top */
+  in[0] = vec_adds (v3, v2);		/* y0 = v3 + v2 */
+  in[4] = vec_subs (v3, v2);		/* y4 = v3 - v2 */
+  in[2] = vec_mradds (v8, mul2, v4);	/* y2 = v8 * a0 + v4 */
+  v6 = vec_mradds (v4, mul2, mul6);	
+  in[6] = vec_subs (v6, v8);		/* y6 = v4 * a0 - v8 */
+
+  /* Bottom */
+  v6 = vec_mradds (v0, mul0, v5);	/* v6 = v0 * (c4) + v5 */
+  v7 = vec_mradds (v0, mul4, v5);	/* v7 = v0 * (-c4) + v5 */
+  v2 = vec_mradds (v1, mul4, v9);	/* v2 = v1 * (-c4) + v9 */
+  v3 = vec_mradds (v1, mul0, v9);	/* v3 = v1 * (c4) + v9 */
+
+  /*********** Stage 4 ***********/
+
+  /* Bottom */
+  in[1] = vec_mradds (v6, mul3, v3);	/* y1 = v6 * (a1) + v3 */
+  v23 = vec_mradds (v3, mul3, mul6);
+  in[7] = vec_subs (v23, v6);		/* y7 = v3 * (a1) - v6 */
+  in[5] = vec_mradds (v2, mul1, v7);	/* y5 = v2 * (a2) + v7 */
+  in[3] = vec_mradds (v7, mul5, v2);	/* y3 = v7 * (-a2) + v2 */
+
+  transpose_vmx (in, out);
+
+  /* Perform DCT on the eight rows */
+
+  /*********** Stage 1 ***********/
+
+  v8 = vec_adds (out[0], out[7]);
+  v9 = vec_subs (out[0], out[7]);
+  v0 = vec_adds (out[1], out[6]);
+  v7 = vec_subs (out[1], out[6]);
+  v1 = vec_adds (out[2], out[5]);
+  v6 = vec_subs (out[2], out[5]);
+  v2 = vec_adds (out[3], out[4]);
+  v5 = vec_subs (out[3], out[4]);
+
+  /*********** Stage 2 ***********/
+
+  /* Top */
+  v3 = vec_adds (v8, v2);		/* (V0+V7) + (V3+V4) */
+  v4 = vec_subs (v8, v2);		/* (V0+V7) - (V3+V4) */
+  v2 = vec_adds (v0, v1);		/* (V1+V6) + (V2+V5) */
+  v8 = vec_subs (v0, v1);		/* (V1+V6) - (V2+V5) */
+
+  /* Bottom */
+  v0 = vec_subs (v7, v6);		/* (V1-V6) - (V2-V5) */
+  v1 = vec_adds (v7, v6);		/* (V1-V6) + (V2-V5) */
+
+  /*********** Stage 3 ***********/
+
+  /* Top */
+  v25 = vec_subs (v25, v25);          /* reinit v25 = 0 */
+
+  v20 = vec_adds (v3, v2);		/* y0 = v3 + v2 */
+  v24 = vec_subs (v3, v2);		/* y4 = v3 - v2 */
+  v22 = vec_mradds (v8, mul2, v4);	/* y2 = v8 * a0 + v4 */
+  v6 = vec_mradds (v4, mul2, v25);	
+  v26 = vec_subs (v6, v8);		/* y6 = v4 * a0 - v8 */
+
+  /* Bottom */
+  v6 = vec_mradds (v0, mul0, v5);	/* v6 = v0 * (c4) + v5 */
+  v7 = vec_mradds (v0, mul4, v5);	/* v7 = v0 * (-c4) + v5 */
+  v2 = vec_mradds (v1, mul4, v9);	/* v2 = v1 * (-c4) + v9 */
+  v3 = vec_mradds (v1, mul0, v9);	/* v3 = v1 * (c4) + v9 */
+
+  /*********** Stage 4 ***********/
+
+  /* Bottom */
+  v21 = vec_mradds (v6, mul3, v3);	/* y1 = v6 * (a1) + v3 */
+  v23 = vec_mradds (v3, mul3, v25);
+  v27 = vec_subs (v23, v6);		/* y7 = v3 * (a1) - v6 */
+  v25 = vec_mradds (v2, mul1, v7);	/* y5 = v2 * (a2) + v7 */
+  v23 = vec_mradds (v7, mul5, v2);	/* y3 = v7 * (-a2) + v2 */
+
+  /* Post-scale and store reults */
+
+  v31 = vec_subs (v31, v31);          /* reinit v25 = 0 */
+
+  output[0] = vec_mradds (postscale[0], v20, v31);
+  output[2] = vec_mradds (postscale[2], v22, v31);
+  output[4] = vec_mradds (postscale[4], v24, v31);
+  output[6] = vec_mradds (postscale[6], v26, v31);
+  output[1] = vec_mradds (postscale[1], v21, v31);
+  output[3] = vec_mradds (postscale[3], v23, v31);
+  output[5] = vec_mradds (postscale[5], v25, v31);
+  output[7] = vec_mradds (postscale[7], v27, v31);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-1.c
new file mode 100644
index 000000000..c92435e09
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-1.c
@@ -0,0 +1,26 @@
+#include <altivec.h>
+vector unsigned char v;
+typedef unsigned char T[16];
+T t;
+typedef struct { unsigned char a[16]; } R;
+R r;
+typedef union {
+  unsigned char u8[16];
+  signed char s8[16];
+  unsigned short u16[8];
+  signed short s16[8];
+  unsigned int u32[4];
+  signed int s32[4];
+  float f32[4];
+} U;
+U u;
+static void use(void *p) {
+}
+int main() {
+  use (&v);
+  use (&t);
+  use (&r);
+  use (&u);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-2.c
new file mode 100644
index 000000000..60380bcfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-2.c
@@ -0,0 +1,42 @@
+#include <altivec.h>
+vector unsigned char u8 = {1, 2, 3, 4, 5, 6, 7, 8,
+			   9, 10,11,12,13,14,15,16};
+vector signed char s8 = {1, 2, 3, 4, 5, 6, 7, 8,
+			 9, 10,11,12,13,14,15,16};
+vector bool char b8 = {0, -1, 0, -1, 0, 0, 0, 0,
+		      -1, -1, -1, -1, 0, -1, 0, -1};
+vector unsigned short u16 = {1, 2, 3, 4, 5, 6, 7, 8};
+vector signed short s16 = {1, 2, 3, 4, 5, 6, 7, 8};
+vector bool short b16 = {-1, 0, -1, 0, -1, -1, 0, 0};
+vector unsigned int u32 = {1, 2, 3, 4};
+vector signed int s32 = {1, 2, 3, 4};
+vector bool int b32 = {0, -1, -1, 0};
+vector float f32 = {1, 2, 3, 4};
+vector pixel p16 = {1, 2, 3, 4, 5, 6, 7, 8};
+
+static void f_u8(vector unsigned char *p) {}
+static void f_s8(vector signed char *p) {}
+static void f_b8(vector bool char *p) {}
+static void f_u16(vector unsigned short *p) {}
+static void f_s16(vector signed short *p) {}
+static void f_b16(vector bool short *p) {}
+static void f_u32(vector unsigned int *p) {}
+static void f_s32(vector signed int *p) {}
+static void f_b32(vector bool int *p) {}
+static void f_f32(vector float *p) {}
+static void f_p16(vector pixel *p) {}
+
+int main() {
+  f_u8(&u8);
+  f_s8(&s8);
+  f_b8(&b8);
+  f_u16(&u16);
+  f_s16(&s16);
+  f_b16(&b16);
+  f_u32(&u32);
+  f_s32(&s32);
+  f_b32(&b32);
+  f_f32(&f32);
+  f_p16(&p16);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-3.c
new file mode 100644
index 000000000..a9fc86629
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-3.c
@@ -0,0 +1,75 @@
+#include <altivec.h>
+vector unsigned char u8;
+vector signed char s8;
+vector bool char b8;
+vector unsigned short u16;
+vector signed short s16;
+vector bool short b16;
+vector unsigned int u32;
+vector signed int s32;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+
+void f_u8(vector unsigned char *p) {
+  u8 = *p;
+}
+void f_s8(vector signed char *p) {
+  s8 = *p;
+}
+void f_b8(vector bool char *p) {
+  b8 = *p;
+}
+void f_u16(vector unsigned short *p) {
+  u16 = *p;
+}
+void f_s16(vector signed short *p) {
+  s16 = *p;
+}
+void f_b16(vector bool short *p) {
+  b16 = *p;
+}
+void f_u32(vector unsigned int *p) {
+  u32 = *p;
+}
+void f_s32(vector signed int *p) {
+  s32 = *p;
+}
+void f_b32(vector bool int *p) {
+  b32 = *p;
+}
+void f_f32(vector float *p) {
+  f32 = *p;
+}
+void f_p16(vector pixel *p) {
+  p16 = *p;
+}
+
+int main() {
+  vector unsigned char u8 = ((vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8,
+						   9, 10,11,12,13,14,15,16});
+  vector signed char s8 = ((vector signed char){1, 2, 3, 4, 5, 6, 7, 8,
+					       9, 10,11,12,13,14,15,16});
+  vector bool char b8 = ((vector bool char){0, -1, 0, -1, 0, 0, 0, 0,
+					   -1, -1, -1, -1, 0, -1, 0, -1});
+  vector unsigned short u16 = ((vector unsigned short){1, 2, 3, 4, 5, 6, 7, 8});
+  vector signed short s16 = ((vector signed short){1, 2, 3, 4, 5, 6, 7, 8});
+  vector bool short b16 = ((vector bool short){-1, 0, -1, 0, -1, -1, 0, 0});
+  vector unsigned int u32 = ((vector unsigned int){1, 2, 3, 4});
+  vector signed int s32 = ((vector signed int){1, 2, 3, 4});
+  vector bool int b32 = ((vector bool int){0, -1, -1, 0});
+  vector float f32 = ((vector float){1, 2, 3, 4});
+  vector pixel p16 = ((vector pixel){1, 2, 3, 4, 5, 6, 7, 8});
+  f_u8(&u8);
+  f_s8(&s8);
+  f_b8(&b8);
+  f_u16(&u16);
+  f_s16(&s16);
+  f_b16(&b16);
+  f_u32(&u32);
+  f_s32(&s32);
+  f_b32(&b32);
+  f_f32(&f32);
+  f_p16(&p16);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-4.c
new file mode 100644
index 000000000..e30ba2674
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/debug-4.c
@@ -0,0 +1,78 @@
+#include <altivec.h>
+vector unsigned char u8;
+vector signed char s8;
+vector bool char b8;
+vector unsigned short u16;
+vector signed short s16;
+vector bool short b16;
+vector unsigned int u32;
+vector signed int s32;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+
+void f_u8(vector unsigned char *p) {
+  u8 = vec_add(*p, *p);
+}
+void f_s8(vector signed char *p) {
+  s8 = vec_add(*p, *p);
+}
+void f_b8(vector bool char *p) {
+  b8 = vec_cmpgt(s8, s8);
+  b8 = vec_xor(b8, *p);
+}
+void f_u16(vector unsigned short *p) {
+  u16 = vec_add(*p, *p);
+}
+void f_s16(vector signed short *p) {
+  s16 = vec_add(*p, *p);
+}
+void f_b16(vector bool short *p) {
+  b16 = vec_cmpgt(s16, s16);
+  b16 = vec_xor(b16, *p);
+}
+void f_u32(vector unsigned int *p) {
+  u32 = vec_add(*p, *p);
+}
+void f_s32(vector signed int *p) {
+  s32 = vec_add(*p, *p);
+}
+void f_b32(vector bool int *p) {
+  b32 = vec_cmpgt(s32, s32);
+  b32 = vec_xor(b32, *p);
+}
+void f_f32(vector float *p) {
+  f32 = vec_add(*p, *p);
+}
+void f_p16(vector pixel *p) {
+  p16 = *p;
+}
+
+int main() {
+  vector unsigned char u8 = ((vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8,
+						   9, 10,11,12,13,14,15,16});
+  vector signed char s8 = ((vector signed char){1, 2, 3, 4, 5, 6, 7, 8,
+					       9, 10,11,12,13,14,15,16});
+  vector bool char b8 = ((vector bool char){0, -1, 0, -1, 0, 0, 0, 0,
+					   -1, -1, -1, -1, 0, -1, 0, -1});
+  vector unsigned short u16 = ((vector unsigned short){1, 2, 3, 4, 5, 6, 7, 8});
+  vector signed short s16 = ((vector signed short){1, 2, 3, 4, 5, 6, 7, 8});
+  vector bool short b16 = ((vector bool short){-1, 0, -1, 0, -1, -1, 0, 0});
+  vector unsigned int u32 = ((vector unsigned int){1, 2, 3, 4});
+  vector signed int s32 = ((vector signed int){1, 2, 3, 4});
+  vector bool int b32 = ((vector bool int){0, -1, -1, 0});
+  vector float f32 = ((vector float){1, 2, 3, 4});
+  vector pixel p16 = ((vector pixel){1, 2, 3, 4, 5, 6, 7, 8});
+  f_u8(&u8);
+  f_s8(&s8);
+  f_b8(&b8);
+  f_u16(&u16);
+  f_s16(&s16);
+  f_b16(&b16);
+  f_u32(&u32);
+  f_s32(&s32);
+  f_b32(&b32);
+  f_f32(&f32);
+  f_p16(&p16);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dos-bug-1-gdb.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dos-bug-1-gdb.c
new file mode 100644
index 000000000..dc4c4d3d9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dos-bug-1-gdb.c
@@ -0,0 +1,7 @@
+#include <altivec.h>
+static vector unsigned int v = {0x01020304,0x05060708,0x21324354,0x65768798};
+static vector unsigned int f() { return v; }
+int main() {
+  vector unsigned int x = f();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dos-bug-2-gdb.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dos-bug-2-gdb.c
new file mode 100644
index 000000000..4ec47b12d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/dos-bug-2-gdb.c
@@ -0,0 +1,7 @@
+#include <altivec.h>
+static vector unsigned int v = {0x01020304,0x05060708,0x21324354,0x65768798};
+static vector unsigned int f() { return vec_splat(v,0); }
+int main() {
+  vector unsigned int x = f();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/eg-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/eg-5.c
new file mode 100644
index 000000000..0b37e69d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/eg-5.c
@@ -0,0 +1,27 @@
+#include "harness.h"
+
+static vector float
+matvecmul4 (vector float c0, vector float c1, vector float c2,
+	    vector float c3, vector float v)
+{
+  /* Set result to a vector of f32 0's */
+  vector float result = ((vector float){0.,0.,0.,0.});
+
+  result  = vec_madd (c0, vec_splat (v, 0), result);
+  result  = vec_madd (c1, vec_splat (v, 1), result);
+  result  = vec_madd (c2, vec_splat (v, 2), result);
+  result  = vec_madd (c3, vec_splat (v, 3), result);
+
+  return result;
+}
+
+static void test()
+{
+  check(vec_all_eq(matvecmul4(((vector float){2,3,5,7}),
+			      ((vector float){11,13,17,19}),
+			      ((vector float){23,29,31,37}),
+			      ((vector float){41,43,47,53}),
+			      ((vector float){59,61,67,71})),
+		   ((vector float){5241, 5966, 6746, 7814})),
+	"matvecmul4");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/fft.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/fft.c
new file mode 100644
index 000000000..2b8a537c6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/fft.c
@@ -0,0 +1,99 @@
+/* { dg-do compile } */
+#include <altivec.h>
+
+inline void
+transpose4x4(vector float *matrix)
+{
+  vector float v0, v1, v2, v3;
+
+  v0 = vec_mergeh(matrix[0], matrix[2]);
+  v1 = vec_mergel(matrix[0], matrix[2]);
+  v2 = vec_mergeh(matrix[1], matrix[3]);
+  v3 = vec_mergel(matrix[1], matrix[3]);
+
+  matrix[0] = vec_mergeh(v0, v2);
+  matrix[1] = vec_mergel(v0, v2);
+  matrix[2] = vec_mergeh(v1, v3);
+  matrix[3] = vec_mergel(v1, v3);
+}
+
+void
+vec_ifft64(vector float *x0, vector float *x1)
+{
+  int i;
+  vector float real[4], imag[4];
+  vector float c0r, c1r, c2r, c3r, c0i, c1i, c2i, c3i;
+  vector float d0r, d1r, d2r, d3r, d0i, d1i, d2i, d3i;
+
+  /*
+   *  N=64
+   *
+   *  Stage 1: t=1 => k = 0, j = 0..15
+   *  ================================
+   *  for j = 0:15
+   *    c0 = x0(j+0*16);
+   *    c1 = x0(j+1*16);
+   *    c2 = x0(j+2*16);
+   *    c3 = x0(j+3*16);
+   *
+   *    d0 = c0 + c2;
+   *    d1 = c0 - c2;
+   *    d2 = c1 + c3;
+   *    d3 = i*(c1 - c3);
+   *
+   *    x1(4j+0) = d0 + d2;
+   *    x1(4j+1) = d1 + d3;
+   *    x1(4j+2) = d0 - d2;
+   *    x1(4j+3) = d1 - d3;
+   *  end
+   ******************************************************/
+
+  for (i=0; i < 4; i++)
+    {
+      c0r = x0[i];
+      c1r = x0[i+4];
+      c2r = x0[i+8];
+      c3r = x0[i+12];
+
+      c0i = x0[i+16];
+      c1i = x0[i+20];
+      c2i = x0[i+24];
+      c3i = x0[i+28];
+
+      d0r = vec_add(c0r, c2r);
+      d1r = vec_sub(c0r, c2r);
+      d2r = vec_add(c1r, c3r);
+      d3r = vec_sub(c3i, c1i);
+
+      d0i = vec_add(c0i, c2i);
+      d1i = vec_sub(c0i, c2i);
+      d2i = vec_add(c1i, c3i);
+      d3i = vec_sub(c1r, c3r);
+
+      /* Calculate real{x1} */
+      real[0] = vec_add(d0r, d2r);
+      real[1] = vec_add(d1r, d3r);
+      real[2] = vec_sub(d0r, d2r);
+      real[3] = vec_sub(d1r, d3r);
+
+      transpose4x4(real);
+
+      /* Calculate imag{x1} */
+      imag[0] = vec_add(d0i, d2i);
+      imag[1] = vec_add(d1i, d3i);
+      imag[2] = vec_sub(d0i, d2i);
+      imag[3] = vec_sub(d1i, d3i);
+
+      transpose4x4(imag);
+
+      x1[4*i]   = real[0];
+      x1[4*i+1] = real[1];
+      x1[4*i+2] = real[2];
+      x1[4*i+3] = real[3];
+
+      x1[4*i+16] = imag[0];
+      x1[4*i+17] = imag[1];
+      x1[4*i+18] = imag[2];
+      x1[4*i+19] = imag[3];
+    }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-1.c
new file mode 100644
index 000000000..684ffe90e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+#include <altivec.h>
+typedef struct n_a {
+  signed char m1;
+  vector float m2;
+} n_a;
+
+typedef struct n_b {
+  signed char m1;
+  struct n_a m2;
+} n_b;
+
+extern void f(n_b *);
+
+void initn_b(signed char p1, struct n_a p2)
+{
+   n_b _i;
+  ((_i).m1 = p1, (_i).m2 = p2);
+  f(&_i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-2.c
new file mode 100644
index 000000000..f2f3c4cfe
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-2.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+#include <altivec.h>
+typedef struct n_a {
+  signed char m1;
+  vector float m2;
+} n_a;
+
+typedef struct n_b {
+  signed char m1;
+  struct n_a m2;
+} n_b;
+
+extern void f(n_b *);
+
+void initn_b()
+{
+   n_b _i;
+  f(&_i);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-3.c
new file mode 100644
index 000000000..77b2a002f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-3.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+#include <altivec.h>
+void valuen014(vector float p1, vector float p2, vector float p3,
+	       vector float p4, vector float p5, vector float p6,
+	       vector float p7, vector float p8, vector float p9,
+	       vector float p10, vector float p11, vector float p12,
+	       int p13)
+{
+}
+
+void f()
+{
+  valuen014(((vector float) {1.83e+09, 5.73e+08, -2.96e+08, -7.46e+08}),
+	    ((vector float) {-2.01e+09, 9.89e+08, -1.92e+09, 2.09e+09}),
+	    ((vector float) {1.95e+09, -2.41e+08, 2.67e+08, 1.67e+09}),
+	    ((vector float) {-2.12e+09, 8.18e+08, 9.47e+08, -1.25e+09}),
+	    ((vector float) {-9.47e+08, -9.3e+08, -1.65e+09, 1.64e+09}),
+	    ((vector float) {-7.99e+07, 4.86e+08, -3.4e+06, 3.11e+08}),
+	    ((vector float) {1.78e+09, 1.22e+09, -1.27e+09, -3.11e+08}),
+	    ((vector float) {1.41e+09, -5.38e+07, -2.08e+09, 1.54e+09}),
+	    ((vector float) {3.1e+08, -1.49e+09, 5.38e+08, -1.3e+09}),
+	    ((vector float) {9.66e+08, 5.5e+08, 1.75e+08, -8.22e+07}),
+	    ((vector float) {-1.72e+08, -2.06e+09, 1.14e+09, -4.64e+08}),
+	    ((vector float) {-1.25e+09, 8.12e+07, -2.02e+09, 4.71e+08}), 
+	    962425441);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-4.c
new file mode 100644
index 000000000..beb920f2c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-4.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern vector unsigned int gn00111;
+long f() { return (long)&gn00111; }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-5.c
new file mode 100644
index 000000000..0eaa6adb7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-5.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+#include <altivec.h>
+void valuen014(vector float p1, vector float p2, vector float p3,
+	       vector float p4, vector float p5, vector float p6,
+	       vector float p7, vector float p8, vector float p9,
+	       vector float p10, vector float p11, vector float p12,
+	       vector float px)
+{
+}
+
+void f()
+{
+  valuen014(((vector float) {1.83e+09, 5.73e+08, -2.96e+08, -7.46e+08}),
+	    ((vector float) {-2.01e+09, 9.89e+08, -1.92e+09, 2.09e+09}),
+	    ((vector float) {1.95e+09, -2.41e+08, 2.67e+08, 1.67e+09}),
+	    ((vector float) {-2.12e+09, 8.18e+08, 9.47e+08, -1.25e+09}),
+	    ((vector float) {-9.47e+08, -9.3e+08, -1.65e+09, 1.64e+09}),
+	    ((vector float) {-7.99e+07, 4.86e+08, -3.4e+06, 3.11e+08}),
+	    ((vector float) {1.78e+09, 1.22e+09, -1.27e+09, -3.11e+08}),
+	    ((vector float) {1.41e+09, -5.38e+07, -2.08e+09, 1.54e+09}),
+	    ((vector float) {3.1e+08, -1.49e+09, 5.38e+08, -1.3e+09}),
+	    ((vector float) {9.66e+08, 5.5e+08, 1.75e+08, -8.22e+07}),
+	    ((vector float) {-1.72e+08, -2.06e+09, 1.14e+09, -4.64e+08}),
+	    ((vector float) {-1.25e+09, 8.12e+07, -2.02e+09, 4.71e+08}), 
+	    ((vector float){1,1,1,1}));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-6.c
new file mode 100644
index 000000000..f0a424a2b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-6.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+#include <altivec.h>
+void valuen014(vector float p1, vector float p2, vector float p3,
+	       vector float p4, vector float p5, vector float p6,
+	       vector float p7, vector float p8, vector float p9,
+	       vector float p10, vector float p11, vector float p12,
+	       vector float px, vector float py, vector float pz,
+	       int p13)
+{
+}
+
+void f()
+{
+  valuen014(((vector float) {1.83e+09, 5.73e+08, -2.96e+08, -7.46e+08}),
+	    ((vector float) {-2.01e+09, 9.89e+08, -1.92e+09, 2.09e+09}),
+	    ((vector float) {1.95e+09, -2.41e+08, 2.67e+08, 1.67e+09}),
+	    ((vector float) {-2.12e+09, 8.18e+08, 9.47e+08, -1.25e+09}),
+	    ((vector float) {-9.47e+08, -9.3e+08, -1.65e+09, 1.64e+09}),
+	    ((vector float) {-7.99e+07, 4.86e+08, -3.4e+06, 3.11e+08}),
+	    ((vector float) {1.78e+09, 1.22e+09, -1.27e+09, -3.11e+08}),
+	    ((vector float) {1.41e+09, -5.38e+07, -2.08e+09, 1.54e+09}),
+	    ((vector float) {3.1e+08, -1.49e+09, 5.38e+08, -1.3e+09}),
+	    ((vector float) {9.66e+08, 5.5e+08, 1.75e+08, -8.22e+07}),
+	    ((vector float) {-1.72e+08, -2.06e+09, 1.14e+09, -4.64e+08}),
+	    ((vector float) {-1.25e+09, 8.12e+07, -2.02e+09, 4.71e+08}), 
+	    ((vector float){1,1,1,1}), 
+	    ((vector float){2,2,2,2}), 
+	    ((vector float){3,3,3,3}), 
+	    962425441);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-7.c
new file mode 100644
index 000000000..452977bbf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-7.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern void referencen001(int *p1, int *p2, int *p3, int *p4, int *p5, int *p6, int *p7, vector float *p8);
+
+extern int gn0011;
+
+extern int gn0012;
+
+extern int gn0013;
+
+extern int gn0014;
+
+extern int gn0015;
+
+extern int gn0016;
+
+extern int gn0017;
+
+extern vector float gn0018;
+
+void testn001(void)
+{
+  int a1;
+  int a2;
+  int a3;
+  int a4;
+  int a5;
+  int a6;
+  int a7;
+  vector float a8;
+
+  (a1 = -53786696, a2 = -1840132710, a3 = -2130504990, a4 = 1429848501, a5 = 1139248605, a6 = 428762253, a7 = -1581480596, a8 = ((vector float) {1.66e+09, -1.83e+09, -6.79e+08, 1.58e+09}));
+
+  referencen001(&a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-8.c
new file mode 100644
index 000000000..33d4bd7e6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-8.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+#include <altivec.h>
+
+typedef struct n001 {
+  signed char m1;
+  vector float m2;
+  int m3;
+  vector signed short m4;
+  signed char m5;
+  vector unsigned short m6;
+} n001;
+
+ n001 _i = {-4, {-1.84e+09, -2.13e+09, 1.43e+09, 1.14e+09}, 428762253, {-24132, 25298, -27969, -10358, 24164, -5157, -18143, -6509}, 40, {0x8737, 0xd7cf, 0xb6a7, 0x948f, 0x790b, 0x9255, 0x872d, 0xe72c}};
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-9.c
new file mode 100644
index 000000000..b54338a3b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-9.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+#include <altivec.h>
+
+vector signed short _j =  {-24132, 25298, -27969, -10358, 24164, -5157, -18143, -6509};
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-b.c
new file mode 100644
index 000000000..e893ff181
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-b.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector  unsigned char   u8a,  u8b,  u8c,  u8d, *u8ptr;
+vector  signed short s16a, s16b, s16c, s16d;
+vector  unsigned short u16a, u16b, u16c, u16d;
+vector  unsigned int u32a, u32b, u32c, u32d;
+vector  float f32a, f32b, f32c, f32d, f32e;
+int i, j, *p;
+
+void test()
+{
+        u8c  = vec_add(u8a, u8b);
+        f32c = vec_ceil(f32a);
+        f32d = vec_vcfux(u32a, 31U);
+        s16c = vec_splat_s16(-16);
+        u8d  = vec_vsldoi(u8a, u8b, 15);
+        f32e = vec_vmaddfp(f32a, f32b, f32c);
+         
+        vec_dss(3);
+        vec_dssall();
+        vec_mtvscr(u8a);
+        u16a = vec_mfvscr();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-c.c
new file mode 100644
index 000000000..33fed4bd9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-c.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector signed short s16ss() { vector signed short a; return vec_subs(a,a); }
+vector signed short s16s() { vector signed short a; return vec_sub(a,a); }
+vector signed short s16x() { vector signed short a; return vec_xor(a,a); }
+vector signed short s16a() { vector signed short a; return vec_andc(a,a); }
+vector unsigned char u8;
+vector signed short s16;
+vector bool int b32;
+vector float f32;
+vector pixel p16;
+void x()
+{
+  u8 = ((vector unsigned char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  s16 = ((vector signed short){-7,-7,-7,-7,-7,-7,-7,-7});
+  b32 = ((vector bool int) {10,20,30,40});
+  f32 = ((vector float) {2,4,6,8});
+  p16 = ((vector pixel){23,23,23,23,23,23,23,23});
+}
+vector unsigned int a;
+vector unsigned int b;
+void f(void) {
+  a = ((vector unsigned int){1,1,1,1});
+  b = ((vector unsigned int){1,2,3,4});
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-d.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-d.c
new file mode 100644
index 000000000..2b2151eec
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-d.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+#include <altivec.h>
+static void f() {}
+extern void g() {}
+extern vector unsigned char permute_128(vector unsigned char);
+
+void foo()
+{
+  vector unsigned char input
+    = {0,1,2,4,8,16,32,64,128,0,1,2,4,8,16,32};
+  vector unsigned char result = permute_128(input);
+  void (*p)() = f;
+  void (*q)() = g;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-e.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-e.c
new file mode 100644
index 000000000..58e4fc3d3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-e.c
@@ -0,0 +1,44 @@
+#include "harness.h"
+
+typedef struct n_a
+{
+  signed char m1;
+  short m2;
+  int m3;
+  double m4;
+  vector float m5;
+}
+n_a;
+
+static void
+initn_a(signed char p1, short p2, int p3, double p4, vector float p5)
+{
+  n_a i;
+  static struct
+  {
+    n_a b;
+    char a;
+  }
+  x;
+
+  i.m1 = p1;
+  i.m2 = p2;
+  i.m3 = p3;
+  i.m4 = p4;
+  i.m5 = p5;
+
+  check(i.m1 == -17, "i.m1");
+  check(i.m2 == 9165, "i.m2");
+  check(i.m3 == -1857760764, "i.m3");
+  check(i.m4 == 7.3e+18, "i.m4");
+  check(vec_all_eq(i.m5, ((vector float){-5.02e+08,
+					  -4.34e+08,
+					  -1.04e+09,
+					   1.42e+09})), "i.m5");
+}
+
+static void test()
+{
+  initn_a(-17, 9165, -1857760764, 7.3e+18,
+	  ((vector float){-5.02e+08, -4.34e+08, -1.04e+09, 1.42e+09}));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-f.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-f.c
new file mode 100644
index 000000000..fb61bb15a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-f.c
@@ -0,0 +1,125 @@
+/* { dg-do compile } */
+#include <altivec.h>
+typedef short Word16;
+typedef int   Word32;
+typedef int   Flag;
+
+extern Flag Overflow;
+extern Flag Carry;
+
+extern vector  signed short table[8];
+extern vector  signed short slope_cos[8];
+
+void Lsf_lsp(
+  vector  signed short lsfq[],   
+  vector  signed short lspq[]    
+)
+{
+  vector  signed short Q17_con = ((vector signed short){20861,20861,20861,20861,20861,20861,20861,20861});
+  vector  unsigned char perm1 = ((vector  unsigned char){0, 8, 1, 9, 2, 10, 3, 
+							    11, 4, 12, 5 ,13, 6, 14, 7, 15});
+  vector  unsigned char PerIndex, tmpIndex;
+  vector  signed short tmp0, tmp1, tmp2, tmp3;
+  vector  signed short stmp0, stmp1, stmp2, stmp3;
+  vector  signed short index0, index1, offset0, offset1;
+  vector  signed short table0, table1, slope0, slope1;
+  vector  unsigned short select;
+  vector  signed int L_tmp0, L_tmp1, L_tmp2, L_tmp3;
+ 
+   
+  tmp0 = vec_madds(lsfq[0], Q17_con, (((vector signed short){0,0,0,0,0,0,0,0})) );
+  tmp1 = vec_madds(lsfq[1], Q17_con, (((vector signed short){0,0,0,0,0,0,0,0})) );
+
+   
+  offset0 = vec_and(tmp0, (((vector signed short){0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff})) );
+  offset1 = vec_and(tmp1, (((vector signed short){0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff})) );
+  
+   
+  index0 = vec_min(vec_sra(tmp0, (((vector unsigned short){8,8,8,8,8,8,8,8})) ), (((vector signed short){63,63,63,63,63,63,63,63})) );
+  index1 = vec_min(vec_sra(tmp1, (((vector unsigned short){8,8,8,8,8,8,8,8})) ), (((vector signed short){63,63,63,63,63,63,63,63})) );
+  
+   
+   
+  tmp0 = vec_sl(index0, (vector  unsigned short)((((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = (vector  unsigned char)vec_packs(tmp0, vec_add(tmp0, (((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = vec_perm(PerIndex, PerIndex, perm1);
+  
+    
+  tmp0 = vec_perm(table[0], table[1], PerIndex);
+  stmp0 = vec_perm(slope_cos[0], slope_cos[1], PerIndex);
+
+  tmpIndex = vec_sub(PerIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[2], table[3], tmpIndex);
+  stmp1 = vec_perm(slope_cos[2], slope_cos[3], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31})) );
+  tmp2 = vec_sel(tmp0, tmp1, select);
+  stmp2 = vec_sel(stmp0, stmp1, select);
+
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp0 = vec_perm(table[4], table[5], tmpIndex);
+  stmp0 = vec_perm(slope_cos[4], slope_cos[5], tmpIndex);
+  
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[6], table[7], tmpIndex);
+  stmp1 = vec_perm(slope_cos[6], slope_cos[7], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95})) );
+  tmp3 = vec_sel(tmp0, tmp1, select);
+  stmp3 = vec_sel(stmp0, stmp1, select);
+  
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63})) );
+  table0 = vec_sel(tmp2, tmp3, select);
+  slope0 = vec_sel(stmp2, stmp3, select);
+
+  tmp0 = vec_sl(index1, (vector  unsigned short)((((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = (vector  unsigned char)vec_packs(tmp0, vec_add(tmp0, (((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = vec_perm(PerIndex, PerIndex, perm1);
+
+   
+  tmp0 = vec_perm(table[0], table[1], PerIndex);
+  stmp0 = vec_perm(slope_cos[0], slope_cos[1], PerIndex);
+
+  tmpIndex = vec_sub(PerIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[2], table[3], tmpIndex);
+  stmp1 = vec_perm(slope_cos[2], slope_cos[3], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31})) );
+  tmp2 = vec_sel(tmp0, tmp1, select);
+  stmp2 = vec_sel(stmp0, stmp1, select);
+
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp0 = vec_perm(table[4], table[5], tmpIndex);
+  stmp0 = vec_perm(slope_cos[4], slope_cos[5], tmpIndex);
+  
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[6], table[7], tmpIndex);
+  stmp1 = vec_perm(slope_cos[6], slope_cos[7], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95})) );
+  tmp3 = vec_sel(tmp0, tmp1, select);
+  stmp3 = vec_sel(stmp0, stmp1, select);
+  
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63})) );
+  table1 = vec_sel(tmp2, tmp3, select);
+  slope1 = vec_sel(stmp2, stmp3, select);
+
+
+   
+  L_tmp0 = vec_sra(vec_mule(slope0, offset0), (((vector unsigned int){12,12,12,12})) );
+  L_tmp1 = vec_sra(vec_mulo(slope0, offset0), (((vector unsigned int){12,12,12,12})) );
+  L_tmp2 = vec_sra(vec_mule(slope1, offset1), (((vector unsigned int){12,12,12,12})) );
+  L_tmp3 = vec_sra(vec_mulo(slope1, offset1), (((vector unsigned int){12,12,12,12})) );
+
+  
+  tmp0 = vec_packs(L_tmp0, L_tmp2);
+  tmp1 = vec_packs(L_tmp1, L_tmp3);
+  tmp2 = vec_mergeh(tmp0, tmp1);
+  tmp3 = vec_mergel(tmp0, tmp1);
+  
+   
+  lspq[0] = vec_adds(table0, tmp2);
+  lspq[1] = vec_adds(table1, tmp3);
+
+  return;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-g.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-g.c
new file mode 100644
index 000000000..573a73b35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-g.c
@@ -0,0 +1,119 @@
+/* { dg-do compile } */
+#include <altivec.h>
+extern vector  signed short table[8];
+extern vector  signed short slope_cos[8];
+extern vector  signed short slope_acos[8];
+
+void Lsf_lsp(
+  vector  signed short lsfq[],   
+  vector  signed short lspq[]    
+)
+{
+  vector  signed short Q17_con = ((vector signed short){20861,20861,20861,20861,20861,20861,20861,20861});
+  vector  unsigned char perm1 = ((vector  unsigned char){0, 8, 1, 9, 2, 10, 3, 
+  											11, 4, 12, 5 ,13, 6, 14, 7, 15});
+  vector  unsigned char PerIndex, tmpIndex;
+  vector  signed short tmp0, tmp1, tmp2, tmp3;
+  vector  signed short stmp0, stmp1, stmp2, stmp3;
+  vector  signed short index0, index1, offset0, offset1;
+  vector  signed short table0, table1, slope0, slope1;
+  vector  unsigned short select;
+  vector  signed int L_tmp0, L_tmp1, L_tmp2, L_tmp3;
+ 
+   
+  tmp0 = vec_madds(lsfq[0], Q17_con, (((vector signed short){0,0,0,0,0,0,0,0})) );
+  tmp1 = vec_madds(lsfq[1], Q17_con, (((vector signed short){0,0,0,0,0,0,0,0})) );
+
+   
+  offset0 = vec_and(tmp0, (((vector signed short){0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff})) );
+  offset1 = vec_and(tmp1, (((vector signed short){0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff})) );
+  
+   
+  index0 = vec_min(vec_sra(tmp0, (((vector unsigned short){8,8,8,8,8,8,8,8})) ), (((vector signed short){63,63,63,63,63,63,63,63})) );
+  index1 = vec_min(vec_sra(tmp1, (((vector unsigned short){8,8,8,8,8,8,8,8})) ), (((vector signed short){63,63,63,63,63,63,63,63})) );
+  
+   
+   
+  tmp0 = vec_sl(index0, (vector  unsigned short)((((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = (vector  unsigned char)vec_packs(tmp0, vec_add(tmp0, (((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = vec_perm(PerIndex, PerIndex, perm1);
+  
+    
+  tmp0 = vec_perm(table[0], table[1], PerIndex);
+  stmp0 = vec_perm(slope_cos[0], slope_cos[1], PerIndex);
+
+  tmpIndex = vec_sub(PerIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[2], table[3], tmpIndex);
+  stmp1 = vec_perm(slope_cos[2], slope_cos[3], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31})) );
+  tmp2 = vec_sel(tmp0, tmp1, select);
+  stmp2 = vec_sel(stmp0, stmp1, select);
+
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp0 = vec_perm(table[4], table[5], tmpIndex);
+  stmp0 = vec_perm(slope_cos[4], slope_cos[5], tmpIndex);
+  
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[6], table[7], tmpIndex);
+  stmp1 = vec_perm(slope_cos[6], slope_cos[7], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95})) );
+  tmp3 = vec_sel(tmp0, tmp1, select);
+  stmp3 = vec_sel(stmp0, stmp1, select);
+  
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63})) );
+  table0 = vec_sel(tmp2, tmp3, select);
+  slope0 = vec_sel(stmp2, stmp3, select);
+
+  tmp0 = vec_sl(index1, (vector  unsigned short)((((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = (vector  unsigned char)vec_packs(tmp0, vec_add(tmp0, (((vector signed short){1,1,1,1,1,1,1,1})) ));
+  PerIndex = vec_perm(PerIndex, PerIndex, perm1);
+
+   
+  tmp0 = vec_perm(table[0], table[1], PerIndex);
+  stmp0 = vec_perm(slope_cos[0], slope_cos[1], PerIndex);
+
+  tmpIndex = vec_sub(PerIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[2], table[3], tmpIndex);
+  stmp1 = vec_perm(slope_cos[2], slope_cos[3], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31})) );
+  tmp2 = vec_sel(tmp0, tmp1, select);
+  stmp2 = vec_sel(stmp0, stmp1, select);
+
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp0 = vec_perm(table[4], table[5], tmpIndex);
+  stmp0 = vec_perm(slope_cos[4], slope_cos[5], tmpIndex);
+  
+  tmpIndex = vec_sub(tmpIndex, (((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32})) );
+  tmp1 = vec_perm(table[6], table[7], tmpIndex);
+  stmp1 = vec_perm(slope_cos[6], slope_cos[7], tmpIndex);
+
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95})) );
+  tmp3 = vec_sel(tmp0, tmp1, select);
+  stmp3 = vec_sel(stmp0, stmp1, select);
+  
+  select = (vector  unsigned short)vec_cmpgt(PerIndex, (((vector unsigned char){63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63})) );
+  table1 = vec_sel(tmp2, tmp3, select);
+  slope1 = vec_sel(stmp2, stmp3, select);
+
+
+   
+  L_tmp0 = vec_sra(vec_mule(slope0, offset0), (((vector unsigned int){12,12,12,12})) );
+  L_tmp1 = vec_sra(vec_mulo(slope0, offset0), (((vector unsigned int){12,12,12,12})) );
+  L_tmp2 = vec_sra(vec_mule(slope1, offset1), (((vector unsigned int){12,12,12,12})) );
+  L_tmp3 = vec_sra(vec_mulo(slope1, offset1), (((vector unsigned int){12,12,12,12})) );
+
+  
+  tmp0 = vec_packs(L_tmp0, L_tmp2);
+  tmp1 = vec_packs(L_tmp1, L_tmp3);
+  tmp2 = vec_mergeh(tmp0, tmp1);
+  tmp3 = vec_mergel(tmp0, tmp1);
+  
+   
+  lspq[0] = vec_adds(table0, tmp2);
+  lspq[1] = vec_adds(table1, tmp3);
+
+  return;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-i.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-i.c
new file mode 100644
index 000000000..58ccb3fe7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/gcc-bug-i.c
@@ -0,0 +1,42 @@
+#include "harness.h"
+
+/* This problem occurs if a function is inlined.  When its local
+   variables get allocated space on the caller's (the function to
+   which it is inlined) stack frame, they don't get 16-byte alignment
+   even if they need it.  Here's an example with a union (that's the
+   first case I uncovered, but it's probably a general occurrence on
+   inlining).  */
+
+#define N 10
+/* adjust N = size of buffer to try to get bad alignment for inlined union */
+
+#define DO_INLINE __attribute__ ((always_inline))
+#define DONT_INLINE __attribute__ ((noinline))
+
+static DO_INLINE int inline_me(vector signed short data) 
+{
+  union {vector signed short v; signed short s[8];} u;
+  u.v = data;
+  return u.s[7];
+}
+
+static DONT_INLINE int foo(vector signed short data)
+{
+  int c, buffer[N], i;
+  c = inline_me(data);
+  for (i=0; i<N; i++) {
+    if (i == 0)
+      buffer[i] = c;
+    else
+      buffer[i] = buffer[i-1] + c*i;
+  }
+  return buffer[N-1];
+}
+
+static void test()
+{
+  check(foo((vector signed short)
+	    ((vector unsigned char){1,2,3,4,5,6,7,8,
+				   9,10,11,12,13,14,15,16})) == 0x2b4e0,
+	"foo");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/harness.h b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/harness.h
new file mode 100644
index 000000000..faea3e97d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/harness.h
@@ -0,0 +1,30 @@
+/* Common code for most VMX test cases.  To use, include this file,
+   then write a routine named test() that performs a series of calls
+   to check().  */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <altivec.h>
+
+static int failed;
+static void test (void);
+
+static void
+check (int result, const char *name)
+{
+  if (!result)
+    {
+      failed++;
+      printf ("fail %s\n", name);
+    }
+}
+    
+int
+main (void)
+{
+  test ();
+  if (failed)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira1.c
new file mode 100644
index 000000000..eee286912
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira1.c
@@ -0,0 +1,10 @@
+#include <altivec.h>
+#include <stdlib.h>
+vector unsigned char u8a, u8b;
+
+int main()
+{
+  if (!vec_all_eq(u8a, u8b))
+    abort ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2.c
new file mode 100644
index 000000000..cf2248097
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+#include <altivec.h>
+vector unsigned char u8a,  u8b,  u8c,  u8d, *u8ptr;
+vector signed short s16a, s16b, s16c, s16d;
+vector unsigned short u16a, u16b, u16c, u16d;
+vector unsigned int u32a, u32b, u32c, u32d;
+vector float f32a, f32b, f32c, f32d, f32e;
+int i, j, *p;
+
+void test()
+{
+  u8c  = vec_add(u8a, u8b);
+  f32c = vec_ceil(f32a);
+  f32d = vec_vcfux(u32a, 31U);
+  s16c = vec_splat_s16(-16);
+  u8d  = vec_vsldoi(u8a, u8b, 15);
+  f32e = vec_vmaddfp(f32a, f32b, f32c);
+  /* vec_dstst(u8ptr, i, 3U); */
+  vec_dss(3);
+  vec_dssall();
+  vec_mtvscr(u8a);
+  u16a = vec_mfvscr();
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2a.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2a.c
new file mode 100644
index 000000000..e6a716d6f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2a.c
@@ -0,0 +1,9 @@
+#include <altivec.h>
+vector unsigned char  *u8ptr;
+int i;
+
+int main()
+{
+  vec_dstst(u8ptr, i, 3U);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2b.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2b.c
new file mode 100644
index 000000000..d9a33f2dd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2b.c
@@ -0,0 +1,17 @@
+#include "harness.h"
+
+static vector float
+f(vector float f32a, vector float f32b, vector float f32c)
+{
+  f32c = vec_ceil(f32a);
+  return vec_vmaddfp(f32a, f32b, f32c);
+}
+
+static void test()
+{
+  check(vec_all_eq(f(((vector float){2,3,5,7}),
+		     ((vector float){11,13,17,19}),
+		     ((vector float){23,29,31,37})),
+		   ((vector float){24, 42, 90, 140})),
+	"test");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2c.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2c.c
new file mode 100644
index 000000000..bce5469ce
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ira2c.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+
+double __fabs(double a) { return a; }
+double __fmadd(double a, double b, double c) { return a*b+c; }
+
+double
+test(double f32a, double f32b, double f32c)
+{
+  f32c = __fabs(f32a);
+  return __fmadd(f32a, f32b, f32c);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/mem.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/mem.c
new file mode 100644
index 000000000..a26eb3cfc
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/mem.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+#include <altivec.h>
+void
+f(vector unsigned char *a, vector unsigned char *b, vector unsigned char *c)
+{
+  int i;
+  for (i = 0; i < 16; i++)
+    c[i] = vec_add(a[i], b[i]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/newton-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/newton-1.c
new file mode 100644
index 000000000..c5963c034
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/newton-1.c
@@ -0,0 +1,67 @@
+/* { dg-do compile } */
+#include <altivec.h>
+                 
+#define SPLAT76 ((vector unsigned char)\
+                 {0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3})
+#define SPLAT54 ((vector unsigned char)\
+                 {4,5,6,7,4,5,6,7,4,5,6,7,4,5,6,7})
+#define SPLAT32 ((vector unsigned char)\
+                 {8,9,10,11,8,9,10,11,8,9,10,11,8,9,10,11})
+#define SPLAT10 ((vector unsigned char)\
+                 {12,13,14,15,12,13,14,15,12,13,14,15,12,13,14,15})
+#define INTERLEAVE ((vector unsigned char)\
+                    {0,1,16,17,4,5,20,21,8,9,24,25,12,13,28,29})
+
+long real_32_manytaps (long ntaps, vector signed short *c, long ndat,
+                       vector signed short *x, vector signed short *y)
+{
+  long i, j, op, ndatavec, ncoefvec;
+  vector signed short x0, x1;
+  vector signed short coef;
+  vector signed short cr10, cr32, cr54, cr76;
+  vector signed int y_even, y_odd;
+  vector signed short *x1p;
+
+  op = 0;
+  ndatavec = ndat >> 3;
+  ncoefvec = ntaps >> 3;
+
+  for (i = 0; i < ndatavec; i += 1) {
+    x0 = x[i];
+        
+    y_even = ((vector signed int){0x8000,0x8000,0x8000,0x8000});
+    y_odd = ((vector signed int){0x8000,0x8000,0x8000,0x8000});
+        
+    j = 0;
+    x1p = x + 1 + i;
+      
+    do {
+ 
+      coef = c[j];
+      x1 = x1p[j];
+    
+      cr10 = vec_perm(coef, coef, SPLAT10);
+      y_odd = vec_msums(cr10, x1, y_odd);
+      y_even = vec_msums(cr10, vec_sld(x0, x1, 14), y_even);
+
+      cr32 = vec_perm(coef, coef, SPLAT32);
+      y_odd = vec_msums(cr32, vec_sld(x0, x1, 12), y_odd);       
+      y_even = vec_msums(cr32, vec_sld(x0, x1, 10), y_even);
+
+      cr54 = vec_perm(coef, coef, SPLAT54);
+      y_odd = vec_msums(cr54, vec_sld(x0, x1, 8), y_odd);        
+      y_even = vec_msums(cr54, vec_sld(x0, x1, 6), y_even);
+
+      cr76 = vec_perm(coef, coef, SPLAT76);
+      y_odd = vec_msums(cr76, vec_sld(x0, x1, 4), y_odd);       
+      y_even = vec_msums(cr76, vec_sld(x0, x1, 2), y_even);
+
+      x0 = x1;
+
+    } while (++j < ncoefvec);
+    y[op++] = (vector signed short) vec_perm(y_even, y_odd, INTERLEAVE);
+
+  }
+
+  return op*8;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops-long-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops-long-1.c
new file mode 100644
index 000000000..547170679
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops-long-1.c
@@ -0,0 +1,80 @@
+/* { dg-do compile } */
+
+/* Checks from the original ops.c that pass pointers to long or
+   unsigned long for operations that support that in released versions
+   of <altivec.h>.  */
+
+#include <altivec.h>
+#include <stdlib.h>
+extern int *var_int;
+extern long * *var_long_ptr;
+extern unsigned long * *var_unsigned_long_ptr;
+extern vector signed int * *var_vec_s32_ptr;
+extern vector signed int *var_vec_s32;
+extern vector unsigned char * *var_vec_u8_ptr;
+extern vector unsigned char *var_vec_u8;
+extern vector unsigned int * *var_vec_u32_ptr;
+extern vector unsigned int *var_vec_u32;
+
+void f13() {
+  *var_vec_s32++ = vec_ld(var_int[0], var_long_ptr[1]);
+  *var_vec_s32++ = vec_lde(var_int[0], var_long_ptr[1]);
+  *var_vec_s32++ = vec_ldl(var_int[0], var_long_ptr[1]);
+  *var_vec_s32++ = vec_lvewx(var_int[0], var_long_ptr[1]);
+  *var_vec_s32++ = vec_lvx(var_int[0], var_long_ptr[1]);
+  *var_vec_s32++ = vec_lvxl(var_int[0], var_long_ptr[1]);
+}
+void f22() {
+  *var_vec_u32++ = vec_ld(var_int[0], var_unsigned_long_ptr[1]);
+  *var_vec_u32++ = vec_lde(var_int[0], var_unsigned_long_ptr[1]);
+  *var_vec_u32++ = vec_ldl(var_int[0], var_unsigned_long_ptr[1]);
+  *var_vec_u32++ = vec_lvewx(var_int[0], var_unsigned_long_ptr[1]);
+  *var_vec_u32++ = vec_lvx(var_int[0], var_unsigned_long_ptr[1]);
+  *var_vec_u32++ = vec_lvxl(var_int[0], var_unsigned_long_ptr[1]);
+}
+void f25() {
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_long_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_long_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_long_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_long_ptr[1]);
+}
+void f33() {
+  vec_dst(var_long_ptr[0], var_int[1], 0);
+  vec_dst(var_long_ptr[0], var_int[1], 1);
+  vec_dst(var_long_ptr[0], var_int[1], 2);
+  vec_dst(var_long_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_long_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_long_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_long_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_long_ptr[0], var_int[1], 3);
+}
+void f34() {
+  vec_dstst(var_long_ptr[0], var_int[1], 0);
+  vec_dstst(var_long_ptr[0], var_int[1], 1);
+  vec_dstst(var_long_ptr[0], var_int[1], 2);
+  vec_dstst(var_long_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_long_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_long_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_long_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_long_ptr[0], var_int[1], 3);
+}
+void f35() {
+  vec_dststt(var_long_ptr[0], var_int[1], 0);
+  vec_dststt(var_long_ptr[0], var_int[1], 1);
+  vec_dststt(var_long_ptr[0], var_int[1], 2);
+  vec_dststt(var_long_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_long_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_long_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_long_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_long_ptr[0], var_int[1], 3);
+  vec_dstt(var_long_ptr[0], var_int[1], 0);
+  vec_dstt(var_long_ptr[0], var_int[1], 1);
+  vec_dstt(var_long_ptr[0], var_int[1], 2);
+  vec_dstt(var_long_ptr[0], var_int[1], 3);
+}
+void f36() {
+  vec_dstt(var_unsigned_long_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_long_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_long_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_long_ptr[0], var_int[1], 3);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops-long-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops-long-2.c
new file mode 100644
index 000000000..9cb672106
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops-long-2.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+
+/* Checks from the original ops.c that pass pointers to long or
+   unsigned long to operations that do not support that in released
+   versions of altivec.h.  */
+
+#include <altivec.h>
+#include <stdlib.h>
+extern int *var_int;
+extern long * *var_long_ptr;
+extern unsigned long * *var_unsigned_long_ptr;
+extern vector signed int * *var_vec_s32_ptr;
+extern vector signed int *var_vec_s32;
+extern vector unsigned char * *var_vec_u8_ptr;
+extern vector unsigned char *var_vec_u8;
+extern vector unsigned int * *var_vec_u32_ptr;
+extern vector unsigned int *var_vec_u32;
+
+void f36() {
+  vec_st(var_vec_s32[0], var_int[1], var_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_st(var_vec_u32[0], var_int[1], var_unsigned_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+}
+void f37() {
+  vec_ste(var_vec_s32[0], var_int[1], var_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_ste(var_vec_u32[0], var_int[1], var_unsigned_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stl(var_vec_s32[0], var_int[1], var_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stl(var_vec_u32[0], var_int[1], var_unsigned_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stvewx(var_vec_s32[0], var_int[1], var_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stvewx(var_vec_u32[0], var_int[1], var_unsigned_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stvx(var_vec_s32[0], var_int[1], var_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stvx(var_vec_u32[0], var_int[1], var_unsigned_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stvxl(var_vec_s32[0], var_int[1], var_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+  vec_stvxl(var_vec_u32[0], var_int[1], var_unsigned_long_ptr[2]); /* { dg-error "invalid parameter combination" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops.c
new file mode 100644
index 000000000..b39ad1d65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/ops.c
@@ -0,0 +1,3831 @@
+/* { dg-do compile } */
+#include <altivec.h>
+#include <stdlib.h>
+extern char * *var_char_ptr;
+extern float * *var_float_ptr;
+extern int * *var_int_ptr;
+extern int *var_cc24f;
+extern int *var_cc24fd;
+extern int *var_cc24fr;
+extern int *var_cc24t;
+extern int *var_cc24td;
+extern int *var_cc24tr;
+extern int *var_cc26f;
+extern int *var_cc26fd;
+extern int *var_cc26fr;
+extern int *var_cc26t;
+extern int *var_cc26td;
+extern int *var_cc26tr;
+extern int *var_int;
+extern short * *var_short_ptr;
+extern signed char * *var_signed_char_ptr;
+extern unsigned char * *var_unsigned_char_ptr;
+extern unsigned int * *var_unsigned_int_ptr;
+extern unsigned short * *var_unsigned_short_ptr;
+extern vector bool char * *var_vec_b8_ptr;
+extern vector bool char *var_vec_b8;
+extern vector bool int * *var_vec_b32_ptr;
+extern vector bool int *var_vec_b32;
+extern vector bool short * *var_vec_b16_ptr;
+extern vector bool short *var_vec_b16;
+extern vector float * *var_vec_f32_ptr;
+extern vector float *var_vec_f32;
+extern vector pixel * *var_vec_p16_ptr;
+extern vector pixel *var_vec_p16;
+extern vector signed char * *var_vec_s8_ptr;
+extern vector signed char *var_vec_s8;
+extern vector signed int * *var_vec_s32_ptr;
+extern vector signed int *var_vec_s32;
+extern vector signed short * *var_vec_s16_ptr;
+extern vector signed short *var_vec_s16;
+extern vector unsigned char * *var_vec_u8_ptr;
+extern vector unsigned char *var_vec_u8;
+extern vector unsigned int * *var_vec_u32_ptr;
+extern vector unsigned int *var_vec_u32;
+extern vector unsigned short * *var_vec_u16_ptr;
+extern vector unsigned short *var_vec_u16;
+extern vector unsigned short *var_volatile_vec_u16;
+void f0() {
+  *var_cc24f++ = vec_any_le(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_nge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24f++ = vec_any_ngt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24fd++ = vec_any_nan(var_vec_f32[0]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24fr++ = vec_any_nle(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24fr++ = vec_any_nlt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24t++ = vec_all_ge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s8[0], var_vec_b8[1]);
+}
+void f1() {
+  *var_cc24t++ = vec_all_gt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24td++ = vec_all_numeric(var_vec_f32[0]);
+  *var_cc24tr++ = vec_all_le(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_ge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_out(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26fd++ = vec_any_numeric(var_vec_f32[0]);
+  *var_cc26fr++ = vec_any_le(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_in(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b8[0], var_vec_u8[1]);
+}
+void f2() {
+  *var_cc26t++ = vec_all_le(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_nge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26t++ = vec_all_ngt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26td++ = vec_all_nan(var_vec_f32[0]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26tr++ = vec_all_nle(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26tr++ = vec_all_nlt(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b16++ = vec_and(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_andc(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_cmpeq(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_cmpeq(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_cmpgt(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_cmpgt(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_ld(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_ldl(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_lvx(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_lvxl(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_mergeh(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_mergel(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_nor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_or(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_pack(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b16++ = vec_perm(var_vec_b16[0], var_vec_b16[1], var_vec_u8[2]);
+  *var_vec_b16++ = vec_sel(var_vec_b16[0], var_vec_b16[1], var_vec_b16[2]);
+  *var_vec_b16++ = vec_sel(var_vec_b16[0], var_vec_b16[1], var_vec_u16[2]);
+  *var_vec_b16++ = vec_sll(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_sll(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_sll(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 0);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 1);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 2);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 3);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 4);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 5);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 6);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 7);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 8);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 9);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 10);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 11);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 12);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 13);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 14);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 15);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 16);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 17);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 18);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 19);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 20);
+}
+void f3() {
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 21);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 22);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 23);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 24);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 25);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 26);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 27);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 28);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 29);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 30);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 31);
+  *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_unpackh(var_vec_b8[0]);
+  *var_vec_b16++ = vec_unpackl(var_vec_b8[0]);
+  *var_vec_b16++ = vec_vand(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vandc(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vcmpequh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_vcmpequh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vcmpgtsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_vcmpgtuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vmrghh(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vmrglh(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vnor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vperm(var_vec_b16[0], var_vec_b16[1], var_vec_u8[2]);
+  *var_vec_b16++ = vec_vpkuwum(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b16++ = vec_vsel(var_vec_b16[0], var_vec_b16[1], var_vec_b16[2]);
+  *var_vec_b16++ = vec_vsel(var_vec_b16[0], var_vec_b16[1], var_vec_u16[2]);
+  *var_vec_b16++ = vec_vsl(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vsl(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_vsl(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 0);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 1);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 2);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 3);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 4);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 5);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 6);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 7);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 8);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 9);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 10);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 11);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 12);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 13);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 14);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 15);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 16);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 17);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 18);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 19);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 20);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 21);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 22);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 23);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 24);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 25);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 26);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 27);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 28);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 29);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 30);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 31);
+  *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_vupkhsb(var_vec_b8[0]);
+  *var_vec_b16++ = vec_vupklsb(var_vec_b8[0]);
+  *var_vec_b16++ = vec_vxor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_xor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b32++ = vec_and(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_andc(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_cmpeq(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_cmpeq(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_cmpeq(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_cmpge(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_cmpgt(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_cmpgt(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_cmpgt(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_ld(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_ldl(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_lvx(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_lvxl(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_mergeh(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_mergel(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_nor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_or(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_perm(var_vec_b32[0], var_vec_b32[1], var_vec_u8[2]);
+  *var_vec_b32++ = vec_sel(var_vec_b32[0], var_vec_b32[1], var_vec_b32[2]);
+  *var_vec_b32++ = vec_sel(var_vec_b32[0], var_vec_b32[1], var_vec_u32[2]);
+  *var_vec_b32++ = vec_sll(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_sll(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_sll(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 0);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 1);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 2);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 3);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 4);
+}
+void f4() {
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 5);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 6);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 7);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 8);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 9);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 10);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 11);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 12);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 13);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 14);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 15);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 16);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 17);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 18);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 19);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 20);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 21);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 22);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 23);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 24);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 25);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 26);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 27);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 28);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 29);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 30);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 31);
+  *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_unpackh(var_vec_b16[0]);
+  *var_vec_b32++ = vec_unpackl(var_vec_b16[0]);
+  *var_vec_b32++ = vec_vand(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vandc(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vcmpeqfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_vcmpequw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_vcmpequw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vcmpgefp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_vcmpgtfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_vcmpgtsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_vcmpgtuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vmrghw(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vmrglw(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vnor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vperm(var_vec_b32[0], var_vec_b32[1], var_vec_u8[2]);
+  *var_vec_b32++ = vec_vsel(var_vec_b32[0], var_vec_b32[1], var_vec_b32[2]);
+  *var_vec_b32++ = vec_vsel(var_vec_b32[0], var_vec_b32[1], var_vec_u32[2]);
+  *var_vec_b32++ = vec_vsl(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_vsl(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vsl(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 0);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 1);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 2);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 3);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 4);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 5);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 6);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 7);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 8);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 9);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 10);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 11);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 12);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 13);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 14);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 15);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 16);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 17);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 18);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 19);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 20);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 21);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 22);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 23);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 24);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 25);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 26);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 27);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 28);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 29);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 30);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 31);
+  *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_vupkhsh(var_vec_b16[0]);
+  *var_vec_b32++ = vec_vupklsh(var_vec_b16[0]);
+  *var_vec_b32++ = vec_vxor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_xor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b8++ = vec_and(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_andc(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_cmpeq(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_cmpeq(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_cmpgt(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_cmpgt(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_ld(var_int[0], var_vec_b8_ptr[1]);
+  *var_vec_b8++ = vec_ldl(var_int[0], var_vec_b8_ptr[1]);
+  *var_vec_b8++ = vec_lvx(var_int[0], var_vec_b8_ptr[1]);
+  *var_vec_b8++ = vec_lvxl(var_int[0], var_vec_b8_ptr[1]);
+}
+void f5() {
+  *var_vec_b8++ = vec_mergeh(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_mergel(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_nor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_or(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_pack(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b8++ = vec_perm(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_sel(var_vec_b8[0], var_vec_b8[1], var_vec_b8[2]);
+  *var_vec_b8++ = vec_sel(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_sll(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_sll(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_sll(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 0);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 1);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 2);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 3);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 4);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 5);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 6);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 7);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 8);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 9);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 10);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 11);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 12);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 13);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 14);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 15);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 16);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 17);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 18);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 19);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 20);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 21);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 22);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 23);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 24);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 25);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 26);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 27);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 28);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 29);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 30);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 31);
+  *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vand(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vandc(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vcmpequb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_vcmpequb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vcmpgtsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_vcmpgtub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vmrghb(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vmrglb(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vnor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vperm(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_vpkuhum(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b8++ = vec_vsel(var_vec_b8[0], var_vec_b8[1], var_vec_b8[2]);
+  *var_vec_b8++ = vec_vsel(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_vsl(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_vsl(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_vsl(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 0);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 1);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 2);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 3);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 4);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 5);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 6);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 7);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 8);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 9);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 10);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 11);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 12);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 13);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 14);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 15);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 16);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 17);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 18);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 19);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 20);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 21);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 22);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 23);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 24);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 25);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 26);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 27);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 28);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 29);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 30);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 31);
+  *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vxor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_xor(var_vec_b8[0], var_vec_b8[1]);
+}
+void f6() {
+  *var_vec_f32++ = vec_add(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_and(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_and(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_and(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_andc(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_andc(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_andc(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_ceil(var_vec_f32[0]);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 0);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 1);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 2);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 3);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 4);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 5);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 6);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 7);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 8);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 9);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 10);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 11);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 12);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 13);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 14);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 15);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 16);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 17);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 18);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 19);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 20);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 21);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 22);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 23);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 24);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 25);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 26);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 27);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 28);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 29);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 30);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 31);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 0);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 1);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 2);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 3);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 4);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 5);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 6);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 7);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 8);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 9);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 10);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 11);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 12);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 13);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 14);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 15);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 16);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 17);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 18);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 19);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 20);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 21);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 22);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 23);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 24);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 25);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 26);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 27);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 28);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 29);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 30);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 31);
+  *var_vec_f32++ = vec_expte(var_vec_f32[0]);
+  *var_vec_f32++ = vec_floor(var_vec_f32[0]);
+  *var_vec_f32++ = vec_ld(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_ld(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_lde(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_ldl(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_ldl(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_loge(var_vec_f32[0]);
+  *var_vec_f32++ = vec_lvewx(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_lvx(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_lvx(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_lvxl(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_lvxl(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_madd(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_max(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_mergeh(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_mergel(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_min(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_nmsub(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_nor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_or(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_or(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_or(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_perm(var_vec_f32[0], var_vec_f32[1], var_vec_u8[2]);
+  *var_vec_f32++ = vec_re(var_vec_f32[0]);
+  *var_vec_f32++ = vec_round(var_vec_f32[0]);
+  *var_vec_f32++ = vec_rsqrte(var_vec_f32[0]);
+  *var_vec_f32++ = vec_sel(var_vec_f32[0], var_vec_f32[1], var_vec_b32[2]);
+}
+void f7() {
+  *var_vec_f32++ = vec_sel(var_vec_f32[0], var_vec_f32[1], var_vec_u32[2]);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 0);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 1);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 2);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 3);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 4);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 5);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 6);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 7);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 8);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 9);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 10);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 11);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 12);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 13);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 14);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 15);
+  *var_vec_f32++ = vec_slo(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_slo(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 0);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 1);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 2);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 3);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 4);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 5);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 6);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 7);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 8);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 9);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 10);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 11);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 12);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 13);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 14);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 15);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 16);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 17);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 18);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 19);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 20);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 21);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 22);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 23);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 24);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 25);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 26);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 27);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 28);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 29);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 30);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 31);
+  *var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_sub(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_trunc(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vaddfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vand(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vand(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vand(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vandc(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vandc(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vandc(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 0);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 1);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 2);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 3);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 4);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 5);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 6);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 7);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 8);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 9);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 10);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 11);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 12);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 13);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 14);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 15);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 16);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 17);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 18);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 19);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 20);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 21);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 22);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 23);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 24);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 25);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 26);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 27);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 28);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 29);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 30);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 31);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 0);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 1);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 2);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 3);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 4);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 5);
+}
+void f8() {
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 6);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 7);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 8);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 9);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 10);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 11);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 12);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 13);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 14);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 15);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 16);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 17);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 18);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 19);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 20);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 21);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 22);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 23);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 24);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 25);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 26);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 27);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 28);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 29);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 30);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 31);
+  *var_vec_f32++ = vec_vexptefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vlogefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vmaddfp(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_vmaxfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vminfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vmrghw(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vmrglw(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vnmsubfp(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_vnor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vor(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vor(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vperm(var_vec_f32[0], var_vec_f32[1], var_vec_u8[2]);
+  *var_vec_f32++ = vec_vrefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfim(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfin(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfip(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfiz(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrsqrtefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vsel(var_vec_f32[0], var_vec_f32[1], var_vec_b32[2]);
+  *var_vec_f32++ = vec_vsel(var_vec_f32[0], var_vec_f32[1], var_vec_u32[2]);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 0);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 1);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 2);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 3);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 4);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 5);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 6);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 7);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 8);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 9);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 10);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 11);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 12);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 13);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 14);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 15);
+  *var_vec_f32++ = vec_vslo(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_vslo(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 0);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 1);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 2);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 3);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 4);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 5);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 6);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 7);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 8);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 9);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 10);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 11);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 12);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 13);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 14);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 15);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 16);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 17);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 18);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 19);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 20);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 21);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 22);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 23);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 24);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 25);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 26);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 27);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 28);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 29);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 30);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 31);
+  *var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_vsubfp(var_vec_f32[0], var_vec_f32[1]);
+}
+void f9() {
+  *var_vec_f32++ = vec_vxor(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vxor(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vxor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_xor(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_xor(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_xor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_p16++ = vec_ld(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_ldl(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_lvx(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_lvxl(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_mergeh(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_mergel(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_packpx(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_perm(var_vec_p16[0], var_vec_p16[1], var_vec_u8[2]);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 0);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 1);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 2);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 3);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 4);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 5);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 6);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 7);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 8);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 9);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 10);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 11);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 12);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 13);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 14);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 15);
+  *var_vec_p16++ = vec_sll(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_sll(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_sll(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_slo(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_slo(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 0);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 1);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 2);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 3);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 4);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 5);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 6);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 7);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 8);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 9);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 10);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 11);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 12);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 13);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 14);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 15);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 16);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 17);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 18);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 19);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 20);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 21);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 22);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 23);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 24);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 25);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 26);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 27);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 28);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 29);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 30);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 31);
+  *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_sro(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_sro(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vmrghh(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_vmrglh(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_vperm(var_vec_p16[0], var_vec_p16[1], var_vec_u8[2]);
+  *var_vec_p16++ = vec_vpkpx(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_vsl(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_vsl(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_vsl(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 0);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 1);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 2);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 3);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 4);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 5);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 6);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 7);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 8);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 9);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 10);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 11);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 12);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 13);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 14);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 15);
+  *var_vec_p16++ = vec_vslo(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_vslo(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 0);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 1);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 2);
+}
+void f10() {
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 3);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 4);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 5);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 6);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 7);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 8);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 9);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 10);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 11);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 12);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 13);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 14);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 15);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 16);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 17);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 18);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 19);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 20);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 21);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 22);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 23);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 24);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 25);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 26);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 27);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 28);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 29);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 30);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 31);
+  *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vsro(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_vsro(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_add(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_add(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_add(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_adds(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_adds(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_adds(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_and(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_and(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_and(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_andc(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_andc(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_andc(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_avg(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_ld(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_ld(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_lde(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_ldl(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_ldl(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_lvehx(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_lvx(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_lvx(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_lvxl(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_lvxl(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_madds(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_max(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_max(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_max(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_mergeh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_mergel(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_min(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_min(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_min(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_mladd(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_mladd(var_vec_s16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_mladd(var_vec_u16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_mradds(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_mule(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_mulo(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_nor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_or(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_or(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_or(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_pack(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_packs(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_perm(var_vec_s16[0], var_vec_s16[1], var_vec_u8[2]);
+  *var_vec_s16++ = vec_rl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_sel(var_vec_s16[0], var_vec_s16[1], var_vec_b16[2]);
+  *var_vec_s16++ = vec_sel(var_vec_s16[0], var_vec_s16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_sl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 0);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 1);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 2);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 3);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 4);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 5);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 6);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 7);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 8);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 9);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 10);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 11);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 12);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 13);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 14);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 15);
+  *var_vec_s16++ = vec_sll(var_vec_s16[0], var_vec_u16[1]);
+}
+void f11() {
+  *var_vec_s16++ = vec_sll(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_sll(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_slo(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_slo(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 0);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 1);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 2);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 3);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 4);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 5);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 6);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 7);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 8);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 9);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 10);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 11);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 12);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 13);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 14);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 15);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 16);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 17);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 18);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 19);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 20);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 21);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 22);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 23);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 24);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 25);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 26);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 27);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 28);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 29);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 30);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 31);
+  *var_vec_s16++ = vec_splat_s16( 0);
+  *var_vec_s16++ = vec_splat_s16( 1);
+  *var_vec_s16++ = vec_splat_s16( 2);
+  *var_vec_s16++ = vec_splat_s16( 3);
+  *var_vec_s16++ = vec_splat_s16( 4);
+  *var_vec_s16++ = vec_splat_s16( 5);
+  *var_vec_s16++ = vec_splat_s16( 6);
+  *var_vec_s16++ = vec_splat_s16( 7);
+  *var_vec_s16++ = vec_splat_s16( 8);
+  *var_vec_s16++ = vec_splat_s16( 9);
+  *var_vec_s16++ = vec_splat_s16( -1);
+  *var_vec_s16++ = vec_splat_s16( -2);
+  *var_vec_s16++ = vec_splat_s16( -3);
+  *var_vec_s16++ = vec_splat_s16( -4);
+  *var_vec_s16++ = vec_splat_s16( -5);
+  *var_vec_s16++ = vec_splat_s16( -6);
+  *var_vec_s16++ = vec_splat_s16( -7);
+  *var_vec_s16++ = vec_splat_s16( -8);
+  *var_vec_s16++ = vec_splat_s16( -9);
+  *var_vec_s16++ = vec_splat_s16( 10);
+  *var_vec_s16++ = vec_splat_s16( 11);
+  *var_vec_s16++ = vec_splat_s16( 12);
+  *var_vec_s16++ = vec_splat_s16( 13);
+  *var_vec_s16++ = vec_splat_s16( 14);
+  *var_vec_s16++ = vec_splat_s16( 15);
+  *var_vec_s16++ = vec_splat_s16(-10);
+  *var_vec_s16++ = vec_splat_s16(-11);
+  *var_vec_s16++ = vec_splat_s16(-12);
+  *var_vec_s16++ = vec_splat_s16(-13);
+  *var_vec_s16++ = vec_splat_s16(-14);
+  *var_vec_s16++ = vec_splat_s16(-15);
+  *var_vec_s16++ = vec_splat_s16(-16);
+  *var_vec_s16++ = vec_sr(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_sra(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_srl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_srl(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_srl(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_sro(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_sro(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_sub(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_sub(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_sub(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_subs(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_subs(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_subs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_unpackh(var_vec_s8[0]);
+  *var_vec_s16++ = vec_unpackl(var_vec_s8[0]);
+  *var_vec_s16++ = vec_vaddshs(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vaddshs(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vaddshs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vadduhm(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vadduhm(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vadduhm(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vand(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vand(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vand(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vandc(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vandc(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vandc(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vavgsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmaxsh(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmaxsh(var_vec_s16[0], var_vec_b16[1]);
+}
+void f12() {
+  *var_vec_s16++ = vec_vmaxsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmhaddshs(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vmhraddshs(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vminsh(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vminsh(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vminsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmladduhm(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vmladduhm(var_vec_s16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_vmladduhm(var_vec_u16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vmrghh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmrglh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmulesb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vmulosb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vnor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vor(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vor(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vperm(var_vec_s16[0], var_vec_s16[1], var_vec_u8[2]);
+  *var_vec_s16++ = vec_vpkswss(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_vpkuwum(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_vrlh(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsel(var_vec_s16[0], var_vec_s16[1], var_vec_b16[2]);
+  *var_vec_s16++ = vec_vsel(var_vec_s16[0], var_vec_s16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_vsl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsl(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_vsl(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 0);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 1);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 2);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 3);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 4);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 5);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 6);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 7);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 8);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 9);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 10);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 11);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 12);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 13);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 14);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 15);
+  *var_vec_s16++ = vec_vslh(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vslo(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vslo(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 0);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 1);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 2);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 3);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 4);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 5);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 6);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 7);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 8);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 9);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 10);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 11);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 12);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 13);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 14);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 15);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 16);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 17);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 18);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 19);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 20);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 21);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 22);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 23);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 24);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 25);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 26);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 27);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 28);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 29);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 30);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 31);
+  *var_vec_s16++ = vec_vspltish( 0);
+  *var_vec_s16++ = vec_vspltish( 1);
+  *var_vec_s16++ = vec_vspltish( 2);
+  *var_vec_s16++ = vec_vspltish( 3);
+  *var_vec_s16++ = vec_vspltish( 4);
+  *var_vec_s16++ = vec_vspltish( 5);
+  *var_vec_s16++ = vec_vspltish( 6);
+  *var_vec_s16++ = vec_vspltish( 7);
+  *var_vec_s16++ = vec_vspltish( 8);
+  *var_vec_s16++ = vec_vspltish( 9);
+  *var_vec_s16++ = vec_vspltish( -1);
+  *var_vec_s16++ = vec_vspltish( -2);
+  *var_vec_s16++ = vec_vspltish( -3);
+  *var_vec_s16++ = vec_vspltish( -4);
+  *var_vec_s16++ = vec_vspltish( -5);
+  *var_vec_s16++ = vec_vspltish( -6);
+  *var_vec_s16++ = vec_vspltish( -7);
+  *var_vec_s16++ = vec_vspltish( -8);
+  *var_vec_s16++ = vec_vspltish( -9);
+  *var_vec_s16++ = vec_vspltish( 10);
+  *var_vec_s16++ = vec_vspltish( 11);
+  *var_vec_s16++ = vec_vspltish( 12);
+  *var_vec_s16++ = vec_vspltish( 13);
+}
+void f13() {
+  *var_vec_s16++ = vec_vspltish( 14);
+  *var_vec_s16++ = vec_vspltish( 15);
+  *var_vec_s16++ = vec_vspltish(-10);
+  *var_vec_s16++ = vec_vspltish(-11);
+  *var_vec_s16++ = vec_vspltish(-12);
+  *var_vec_s16++ = vec_vspltish(-13);
+  *var_vec_s16++ = vec_vspltish(-14);
+  *var_vec_s16++ = vec_vspltish(-15);
+  *var_vec_s16++ = vec_vspltish(-16);
+  *var_vec_s16++ = vec_vsr(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsr(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_vsr(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsrah(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsrh(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsro(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vsro(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsubshs(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vsubshs(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vsubshs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vsubuhm(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vsubuhm(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vsubuhm(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vupkhsb(var_vec_s8[0]);
+  *var_vec_s16++ = vec_vupklsb(var_vec_s8[0]);
+  *var_vec_s16++ = vec_vxor(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vxor(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vxor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_xor(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_xor(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_xor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_add(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_add(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_add(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_adds(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_adds(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_adds(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_and(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_and(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_and(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_andc(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_andc(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_andc(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_avg(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_cmpb(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 0);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 1);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 2);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 3);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 4);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 5);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 6);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 7);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 8);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 9);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 10);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 11);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 12);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 13);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 14);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 15);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 16);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 17);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 18);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 19);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 20);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 21);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 22);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 23);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 24);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 25);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 26);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 27);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 28);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 29);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 30);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 31);
+  *var_vec_s32++ = vec_ld(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_ld(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_lde(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_ldl(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_ldl(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_lvewx(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_lvx(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_lvx(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_lvxl(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_lvxl(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_max(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_max(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_max(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_mergeh(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_mergel(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_min(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_min(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_min(var_vec_s32[0], var_vec_s32[1]);
+}
+void f14() {
+  *var_vec_s32++ = vec_msum(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_msum(var_vec_s8[0], var_vec_u8[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_msums(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_mule(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_mulo(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_nor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_or(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_or(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_or(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_perm(var_vec_s32[0], var_vec_s32[1], var_vec_u8[2]);
+  *var_vec_s32++ = vec_rl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_sel(var_vec_s32[0], var_vec_s32[1], var_vec_b32[2]);
+  *var_vec_s32++ = vec_sel(var_vec_s32[0], var_vec_s32[1], var_vec_u32[2]);
+  *var_vec_s32++ = vec_sl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 0);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 1);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 2);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 3);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 4);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 5);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 6);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 7);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 8);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 9);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 10);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 11);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 12);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 13);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 14);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 15);
+  *var_vec_s32++ = vec_sll(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_sll(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_sll(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_slo(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_slo(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 0);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 1);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 2);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 3);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 4);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 5);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 6);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 7);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 8);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 9);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 10);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 11);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 12);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 13);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 14);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 15);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 16);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 17);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 18);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 19);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 20);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 21);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 22);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 23);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 24);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 25);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 26);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 27);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 28);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 29);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 30);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 31);
+  *var_vec_s32++ = vec_splat_s32( 0);
+  *var_vec_s32++ = vec_splat_s32( 1);
+  *var_vec_s32++ = vec_splat_s32( 2);
+  *var_vec_s32++ = vec_splat_s32( 3);
+  *var_vec_s32++ = vec_splat_s32( 4);
+  *var_vec_s32++ = vec_splat_s32( 5);
+  *var_vec_s32++ = vec_splat_s32( 6);
+  *var_vec_s32++ = vec_splat_s32( 7);
+  *var_vec_s32++ = vec_splat_s32( 8);
+  *var_vec_s32++ = vec_splat_s32( 9);
+  *var_vec_s32++ = vec_splat_s32( -1);
+  *var_vec_s32++ = vec_splat_s32( -2);
+  *var_vec_s32++ = vec_splat_s32( -3);
+  *var_vec_s32++ = vec_splat_s32( -4);
+  *var_vec_s32++ = vec_splat_s32( -5);
+  *var_vec_s32++ = vec_splat_s32( -6);
+  *var_vec_s32++ = vec_splat_s32( -7);
+  *var_vec_s32++ = vec_splat_s32( -8);
+  *var_vec_s32++ = vec_splat_s32( -9);
+  *var_vec_s32++ = vec_splat_s32( 10);
+  *var_vec_s32++ = vec_splat_s32( 11);
+  *var_vec_s32++ = vec_splat_s32( 12);
+  *var_vec_s32++ = vec_splat_s32( 13);
+  *var_vec_s32++ = vec_splat_s32( 14);
+  *var_vec_s32++ = vec_splat_s32( 15);
+  *var_vec_s32++ = vec_splat_s32(-10);
+  *var_vec_s32++ = vec_splat_s32(-11);
+  *var_vec_s32++ = vec_splat_s32(-12);
+  *var_vec_s32++ = vec_splat_s32(-13);
+  *var_vec_s32++ = vec_splat_s32(-14);
+  *var_vec_s32++ = vec_splat_s32(-15);
+  *var_vec_s32++ = vec_splat_s32(-16);
+  *var_vec_s32++ = vec_sr(var_vec_s32[0], var_vec_u32[1]);
+}
+void f15() {
+  *var_vec_s32++ = vec_sra(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_srl(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_srl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_srl(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_sro(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_sro(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_sub(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sub(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_sub(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_subs(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_subs(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_subs(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sum2s(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sum4s(var_vec_s16[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sum4s(var_vec_s8[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sums(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_unpackh(var_vec_s16[0]);
+  *var_vec_s32++ = vec_unpackl(var_vec_s16[0]);
+  *var_vec_s32++ = vec_vaddsws(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vaddsws(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vaddsws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vadduwm(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vadduwm(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vadduwm(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vand(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vand(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vand(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vandc(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vandc(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vandc(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vavgsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vcmpbfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 0);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 1);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 2);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 3);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 4);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 5);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 6);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 7);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 8);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 9);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 10);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 11);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 12);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 13);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 14);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 15);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 16);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 17);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 18);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 19);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 20);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 21);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 22);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 23);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 24);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 25);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 26);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 27);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 28);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 29);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 30);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 31);
+  *var_vec_s32++ = vec_vmaxsw(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmaxsw(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vmaxsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vminsw(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vminsw(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vminsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmrghw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmrglw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmsummbm(var_vec_s8[0], var_vec_u8[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_vmsumshm(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_vmsumshs(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_vmulesh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_vmulosh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_vnor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vor(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vor(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vperm(var_vec_s32[0], var_vec_s32[1], var_vec_u8[2]);
+  *var_vec_s32++ = vec_vrlw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsel(var_vec_s32[0], var_vec_s32[1], var_vec_b32[2]);
+  *var_vec_s32++ = vec_vsel(var_vec_s32[0], var_vec_s32[1], var_vec_u32[2]);
+  *var_vec_s32++ = vec_vsl(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_vsl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsl(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 0);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 1);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 2);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 3);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 4);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 5);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 6);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 7);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 8);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 9);
+}
+void f16() {
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 10);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 11);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 12);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 13);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 14);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 15);
+  *var_vec_s32++ = vec_vslo(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_vslo(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vslw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vspltisw( 0);
+  *var_vec_s32++ = vec_vspltisw( 1);
+  *var_vec_s32++ = vec_vspltisw( 2);
+  *var_vec_s32++ = vec_vspltisw( 3);
+  *var_vec_s32++ = vec_vspltisw( 4);
+  *var_vec_s32++ = vec_vspltisw( 5);
+  *var_vec_s32++ = vec_vspltisw( 6);
+  *var_vec_s32++ = vec_vspltisw( 7);
+  *var_vec_s32++ = vec_vspltisw( 8);
+  *var_vec_s32++ = vec_vspltisw( 9);
+  *var_vec_s32++ = vec_vspltisw( -1);
+  *var_vec_s32++ = vec_vspltisw( -2);
+  *var_vec_s32++ = vec_vspltisw( -3);
+  *var_vec_s32++ = vec_vspltisw( -4);
+  *var_vec_s32++ = vec_vspltisw( -5);
+  *var_vec_s32++ = vec_vspltisw( -6);
+  *var_vec_s32++ = vec_vspltisw( -7);
+  *var_vec_s32++ = vec_vspltisw( -8);
+  *var_vec_s32++ = vec_vspltisw( -9);
+  *var_vec_s32++ = vec_vspltisw( 10);
+  *var_vec_s32++ = vec_vspltisw( 11);
+  *var_vec_s32++ = vec_vspltisw( 12);
+  *var_vec_s32++ = vec_vspltisw( 13);
+  *var_vec_s32++ = vec_vspltisw( 14);
+  *var_vec_s32++ = vec_vspltisw( 15);
+  *var_vec_s32++ = vec_vspltisw(-10);
+  *var_vec_s32++ = vec_vspltisw(-11);
+  *var_vec_s32++ = vec_vspltisw(-12);
+  *var_vec_s32++ = vec_vspltisw(-13);
+  *var_vec_s32++ = vec_vspltisw(-14);
+  *var_vec_s32++ = vec_vspltisw(-15);
+  *var_vec_s32++ = vec_vspltisw(-16);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 0);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 1);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 2);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 3);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 4);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 5);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 6);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 7);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 8);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 9);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 10);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 11);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 12);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 13);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 14);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 15);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 16);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 17);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 18);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 19);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 20);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 21);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 22);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 23);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 24);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 25);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 26);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 27);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 28);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 29);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 30);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 31);
+  *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vsraw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsro(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_vsro(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vsrw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsubsws(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsubsws(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vsubsws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsubuwm(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsubuwm(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vsubuwm(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsum2sws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsum4sbs(var_vec_s8[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsum4shs(var_vec_s16[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsumsws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vupkhsh(var_vec_s16[0]);
+  *var_vec_s32++ = vec_vupklsh(var_vec_s16[0]);
+  *var_vec_s32++ = vec_vxor(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vxor(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vxor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_xor(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_xor(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_xor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s8++ = vec_add(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_add(var_vec_s8[0], var_vec_b8[1]);
+}
+void f17() {
+  *var_vec_s8++ = vec_add(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_adds(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_adds(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_adds(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_and(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_and(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_and(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_andc(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_andc(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_andc(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_avg(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_ld(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_ld(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_lde(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_ldl(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_ldl(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_lvebx(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_lvx(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_lvx(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_lvxl(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_lvxl(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_max(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_max(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_max(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_mergeh(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_mergel(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_min(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_min(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_min(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_nor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_or(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_or(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_or(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_pack(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_packs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_perm(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_rl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sel(var_vec_s8[0], var_vec_s8[1], var_vec_b8[2]);
+  *var_vec_s8++ = vec_sel(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_sl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 0);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 1);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 2);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 3);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 4);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 5);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 6);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 7);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 8);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 9);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 10);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 11);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 12);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 13);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 14);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 15);
+  *var_vec_s8++ = vec_sll(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_sll(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_sll(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_slo(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_slo(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 0);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 1);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 2);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 3);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 4);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 5);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 6);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 7);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 8);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 9);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 10);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 11);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 12);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 13);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 14);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 15);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 16);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 17);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 18);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 19);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 20);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 21);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 22);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 23);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 24);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 25);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 26);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 27);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 28);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 29);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 30);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 31);
+  *var_vec_s8++ = vec_splat_s8( 0);
+  *var_vec_s8++ = vec_splat_s8( 1);
+  *var_vec_s8++ = vec_splat_s8( 2);
+  *var_vec_s8++ = vec_splat_s8( 3);
+  *var_vec_s8++ = vec_splat_s8( 4);
+  *var_vec_s8++ = vec_splat_s8( 5);
+  *var_vec_s8++ = vec_splat_s8( 6);
+}
+void f18() {
+  *var_vec_s8++ = vec_splat_s8( 7);
+  *var_vec_s8++ = vec_splat_s8( 8);
+  *var_vec_s8++ = vec_splat_s8( 9);
+  *var_vec_s8++ = vec_splat_s8( -1);
+  *var_vec_s8++ = vec_splat_s8( -2);
+  *var_vec_s8++ = vec_splat_s8( -3);
+  *var_vec_s8++ = vec_splat_s8( -4);
+  *var_vec_s8++ = vec_splat_s8( -5);
+  *var_vec_s8++ = vec_splat_s8( -6);
+  *var_vec_s8++ = vec_splat_s8( -7);
+  *var_vec_s8++ = vec_splat_s8( -8);
+  *var_vec_s8++ = vec_splat_s8( -9);
+  *var_vec_s8++ = vec_splat_s8( 10);
+  *var_vec_s8++ = vec_splat_s8( 11);
+  *var_vec_s8++ = vec_splat_s8( 12);
+  *var_vec_s8++ = vec_splat_s8( 13);
+  *var_vec_s8++ = vec_splat_s8( 14);
+  *var_vec_s8++ = vec_splat_s8( 15);
+  *var_vec_s8++ = vec_splat_s8(-10);
+  *var_vec_s8++ = vec_splat_s8(-11);
+  *var_vec_s8++ = vec_splat_s8(-12);
+  *var_vec_s8++ = vec_splat_s8(-13);
+  *var_vec_s8++ = vec_splat_s8(-14);
+  *var_vec_s8++ = vec_splat_s8(-15);
+  *var_vec_s8++ = vec_splat_s8(-16);
+  *var_vec_s8++ = vec_sr(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sra(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_srl(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_srl(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_srl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sro(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_sro(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sub(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_sub(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_sub(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_subs(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_subs(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_subs(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddsbs(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddsbs(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vaddsbs(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddubm(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddubm(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vaddubm(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vand(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vand(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vand(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vandc(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vandc(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vandc(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vavgsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmaxsb(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmaxsb(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vmaxsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vminsb(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vminsb(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vminsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmrghb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmrglb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vnor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vor(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vor(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vperm(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_vpkshss(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_vpkuhum(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_vrlb(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsel(var_vec_s8[0], var_vec_s8[1], var_vec_b8[2]);
+  *var_vec_s8++ = vec_vsel(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_vsl(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_vsl(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_vsl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vslb(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 0);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 1);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 2);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 3);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 4);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 5);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 6);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 7);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 8);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 9);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 10);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 11);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 12);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 13);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 14);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 15);
+  *var_vec_s8++ = vec_vslo(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vslo(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 0);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 1);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 2);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 3);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 4);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 5);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 6);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 7);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 8);
+}
+void f19() {
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 9);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 10);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 11);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 12);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 13);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 14);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 15);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 16);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 17);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 18);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 19);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 20);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 21);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 22);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 23);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 24);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 25);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 26);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 27);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 28);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 29);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 30);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 31);
+  *var_vec_s8++ = vec_vspltisb( 0);
+  *var_vec_s8++ = vec_vspltisb( 1);
+  *var_vec_s8++ = vec_vspltisb( 2);
+  *var_vec_s8++ = vec_vspltisb( 3);
+  *var_vec_s8++ = vec_vspltisb( 4);
+  *var_vec_s8++ = vec_vspltisb( 5);
+  *var_vec_s8++ = vec_vspltisb( 6);
+  *var_vec_s8++ = vec_vspltisb( 7);
+  *var_vec_s8++ = vec_vspltisb( 8);
+  *var_vec_s8++ = vec_vspltisb( 9);
+  *var_vec_s8++ = vec_vspltisb( -1);
+  *var_vec_s8++ = vec_vspltisb( -2);
+  *var_vec_s8++ = vec_vspltisb( -3);
+  *var_vec_s8++ = vec_vspltisb( -4);
+  *var_vec_s8++ = vec_vspltisb( -5);
+  *var_vec_s8++ = vec_vspltisb( -6);
+  *var_vec_s8++ = vec_vspltisb( -7);
+  *var_vec_s8++ = vec_vspltisb( -8);
+  *var_vec_s8++ = vec_vspltisb( -9);
+  *var_vec_s8++ = vec_vspltisb( 10);
+  *var_vec_s8++ = vec_vspltisb( 11);
+  *var_vec_s8++ = vec_vspltisb( 12);
+  *var_vec_s8++ = vec_vspltisb( 13);
+  *var_vec_s8++ = vec_vspltisb( 14);
+  *var_vec_s8++ = vec_vspltisb( 15);
+  *var_vec_s8++ = vec_vspltisb(-10);
+  *var_vec_s8++ = vec_vspltisb(-11);
+  *var_vec_s8++ = vec_vspltisb(-12);
+  *var_vec_s8++ = vec_vspltisb(-13);
+  *var_vec_s8++ = vec_vspltisb(-14);
+  *var_vec_s8++ = vec_vspltisb(-15);
+  *var_vec_s8++ = vec_vspltisb(-16);
+  *var_vec_s8++ = vec_vsr(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_vsr(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_vsr(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsrab(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsrb(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsro(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsro(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsubsbs(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsubsbs(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vsubsbs(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsububm(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsububm(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vsububm(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vxor(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vxor(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vxor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_xor(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_xor(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_xor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_add(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_add(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_add(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_adds(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_adds(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_adds(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_and(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_and(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_and(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_andc(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_andc(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_andc(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_avg(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_ld(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_ld(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_lde(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_ldl(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_ldl(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_lvehx(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_lvx(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_lvx(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_lvxl(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_lvxl(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_max(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_max(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_max(var_vec_u16[0], var_vec_u16[1]);
+}
+void f20() {
+  *var_vec_u16++ = vec_mergeh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_mergel(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_min(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_min(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_min(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_mladd(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_mule(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_mulo(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_nor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_or(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_or(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_or(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_pack(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_packs(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_packsu(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_u16++ = vec_packsu(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_perm(var_vec_u16[0], var_vec_u16[1], var_vec_u8[2]);
+  *var_vec_u16++ = vec_rl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sel(var_vec_u16[0], var_vec_u16[1], var_vec_b16[2]);
+  *var_vec_u16++ = vec_sel(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_sl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 0);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 1);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 2);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 3);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 4);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 5);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 6);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 7);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 8);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 9);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 10);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 11);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 12);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 13);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 14);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 15);
+  *var_vec_u16++ = vec_sll(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sll(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_sll(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_slo(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_slo(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 0);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 1);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 2);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 3);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 4);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 5);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 6);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 7);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 8);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 9);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 10);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 11);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 12);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 13);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 14);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 15);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 16);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 17);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 18);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 19);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 20);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 21);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 22);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 23);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 24);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 25);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 26);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 27);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 28);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 29);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 30);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 31);
+  *var_vec_u16++ = vec_splat_u16( 0);
+  *var_vec_u16++ = vec_splat_u16( 1);
+  *var_vec_u16++ = vec_splat_u16( 2);
+  *var_vec_u16++ = vec_splat_u16( 3);
+  *var_vec_u16++ = vec_splat_u16( 4);
+  *var_vec_u16++ = vec_splat_u16( 5);
+  *var_vec_u16++ = vec_splat_u16( 6);
+  *var_vec_u16++ = vec_splat_u16( 7);
+  *var_vec_u16++ = vec_splat_u16( 8);
+  *var_vec_u16++ = vec_splat_u16( 9);
+  *var_vec_u16++ = vec_splat_u16( -1);
+  *var_vec_u16++ = vec_splat_u16( -2);
+  *var_vec_u16++ = vec_splat_u16( -3);
+  *var_vec_u16++ = vec_splat_u16( -4);
+  *var_vec_u16++ = vec_splat_u16( -5);
+  *var_vec_u16++ = vec_splat_u16( -6);
+  *var_vec_u16++ = vec_splat_u16( -7);
+  *var_vec_u16++ = vec_splat_u16( -8);
+  *var_vec_u16++ = vec_splat_u16( -9);
+  *var_vec_u16++ = vec_splat_u16( 10);
+  *var_vec_u16++ = vec_splat_u16( 11);
+  *var_vec_u16++ = vec_splat_u16( 12);
+  *var_vec_u16++ = vec_splat_u16( 13);
+  *var_vec_u16++ = vec_splat_u16( 14);
+  *var_vec_u16++ = vec_splat_u16( 15);
+  *var_vec_u16++ = vec_splat_u16(-10);
+}
+void f21() {
+  *var_vec_u16++ = vec_splat_u16(-11);
+  *var_vec_u16++ = vec_splat_u16(-12);
+  *var_vec_u16++ = vec_splat_u16(-13);
+  *var_vec_u16++ = vec_splat_u16(-14);
+  *var_vec_u16++ = vec_splat_u16(-15);
+  *var_vec_u16++ = vec_splat_u16(-16);
+  *var_vec_u16++ = vec_sr(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sra(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_srl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_srl(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_srl(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_sro(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_sro(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_sub(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sub(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_sub(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_subs(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_subs(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_subs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhm(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhm(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vadduhm(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhs(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhs(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vadduhs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vand(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vand(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vand(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vandc(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vandc(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vandc(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vavguh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmaxuh(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmaxuh(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vmaxuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vminuh(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vminuh(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vminuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmladduhm(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_vmrghh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmrglh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmuleub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vmuloub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vnor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vor(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vor(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vperm(var_vec_u16[0], var_vec_u16[1], var_vec_u8[2]);
+  *var_vec_u16++ = vec_vpkswus(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_u16++ = vec_vpkuwum(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vpkuwus(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vrlh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsel(var_vec_u16[0], var_vec_u16[1], var_vec_b16[2]);
+  *var_vec_u16++ = vec_vsel(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_vsl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsl(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vsl(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 0);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 1);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 2);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 3);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 4);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 5);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 6);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 7);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 8);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 9);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 10);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 11);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 12);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 13);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 14);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 15);
+  *var_vec_u16++ = vec_vslh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vslo(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_vslo(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 0);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 1);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 2);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 3);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 4);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 5);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 6);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 7);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 8);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 9);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 10);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 11);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 12);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 13);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 14);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 15);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 16);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 17);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 18);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 19);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 20);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 21);
+}
+void f22() {
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 22);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 23);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 24);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 25);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 26);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 27);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 28);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 29);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 30);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 31);
+  *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsrah(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsrh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsro(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_vsro(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsubuhm(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsubuhm(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vsubuhm(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsubuhs(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsubuhs(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vsubuhs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vxor(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vxor(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vxor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_xor(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_xor(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_xor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_add(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_add(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_add(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_addc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_adds(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_adds(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_adds(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_and(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_and(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_and(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_andc(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_andc(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_andc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_avg(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 0);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 1);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 2);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 3);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 4);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 5);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 6);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 7);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 8);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 9);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 10);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 11);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 12);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 13);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 14);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 15);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 16);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 17);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 18);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 19);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 20);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 21);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 22);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 23);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 24);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 25);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 26);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 27);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 28);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 29);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 30);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 31);
+  *var_vec_u32++ = vec_ld(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_ld(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_lde(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_ldl(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_ldl(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_lvewx(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_lvx(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_lvx(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_lvxl(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_lvxl(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_max(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_max(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_max(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_mergeh(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_mergel(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_min(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_min(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_min(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_msum(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+}
+void f23() {
+  *var_vec_u32++ = vec_msum(var_vec_u8[0], var_vec_u8[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_msums(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_mule(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_mulo(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_nor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_or(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_or(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_or(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_perm(var_vec_u32[0], var_vec_u32[1], var_vec_u8[2]);
+  *var_vec_u32++ = vec_rl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sel(var_vec_u32[0], var_vec_u32[1], var_vec_b32[2]);
+  *var_vec_u32++ = vec_sel(var_vec_u32[0], var_vec_u32[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_sl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 0);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 1);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 2);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 3);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 4);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 5);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 6);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 7);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 8);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 9);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 10);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 11);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 12);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 13);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 14);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 15);
+  *var_vec_u32++ = vec_sll(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_sll(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sll(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_slo(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_slo(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 0);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 1);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 2);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 3);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 4);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 5);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 6);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 7);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 8);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 9);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 10);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 11);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 12);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 13);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 14);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 15);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 16);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 17);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 18);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 19);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 20);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 21);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 22);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 23);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 24);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 25);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 26);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 27);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 28);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 29);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 30);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 31);
+  *var_vec_u32++ = vec_splat_u32( 0);
+  *var_vec_u32++ = vec_splat_u32( 1);
+  *var_vec_u32++ = vec_splat_u32( 2);
+  *var_vec_u32++ = vec_splat_u32( 3);
+  *var_vec_u32++ = vec_splat_u32( 4);
+  *var_vec_u32++ = vec_splat_u32( 5);
+  *var_vec_u32++ = vec_splat_u32( 6);
+  *var_vec_u32++ = vec_splat_u32( 7);
+  *var_vec_u32++ = vec_splat_u32( 8);
+  *var_vec_u32++ = vec_splat_u32( 9);
+  *var_vec_u32++ = vec_splat_u32( -1);
+  *var_vec_u32++ = vec_splat_u32( -2);
+  *var_vec_u32++ = vec_splat_u32( -3);
+  *var_vec_u32++ = vec_splat_u32( -4);
+  *var_vec_u32++ = vec_splat_u32( -5);
+  *var_vec_u32++ = vec_splat_u32( -6);
+  *var_vec_u32++ = vec_splat_u32( -7);
+  *var_vec_u32++ = vec_splat_u32( -8);
+  *var_vec_u32++ = vec_splat_u32( -9);
+  *var_vec_u32++ = vec_splat_u32( 10);
+  *var_vec_u32++ = vec_splat_u32( 11);
+  *var_vec_u32++ = vec_splat_u32( 12);
+  *var_vec_u32++ = vec_splat_u32( 13);
+  *var_vec_u32++ = vec_splat_u32( 14);
+  *var_vec_u32++ = vec_splat_u32( 15);
+  *var_vec_u32++ = vec_splat_u32(-10);
+  *var_vec_u32++ = vec_splat_u32(-11);
+  *var_vec_u32++ = vec_splat_u32(-12);
+  *var_vec_u32++ = vec_splat_u32(-13);
+  *var_vec_u32++ = vec_splat_u32(-14);
+  *var_vec_u32++ = vec_splat_u32(-15);
+  *var_vec_u32++ = vec_splat_u32(-16);
+  *var_vec_u32++ = vec_sr(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sra(var_vec_u32[0], var_vec_u32[1]);
+}
+void f24() {
+  *var_vec_u32++ = vec_srl(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_srl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_srl(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_sro(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_sro(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_sub(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sub(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_sub(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_subc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_subs(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_subs(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_subs(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sum4s(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_unpackh(var_vec_p16[0]);
+  *var_vec_u32++ = vec_unpackl(var_vec_p16[0]);
+  *var_vec_u32++ = vec_vaddcuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduwm(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduwm(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vadduwm(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduws(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduws(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vadduws(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vand(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vand(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vand(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vandc(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vandc(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vandc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vavguw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 0);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 1);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 2);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 3);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 4);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 5);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 6);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 7);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 8);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 9);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 10);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 11);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 12);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 13);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 14);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 15);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 16);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 17);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 18);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 19);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 20);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 21);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 22);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 23);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 24);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 25);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 26);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 27);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 28);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 29);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 30);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 31);
+  *var_vec_u32++ = vec_vmaxuw(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmaxuw(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vmaxuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vminuw(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vminuw(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vminuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmrghw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmrglw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmsumubm(var_vec_u8[0], var_vec_u8[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vmsumuhm(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vmsumuhs(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vmuleuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vmulouh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vnor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vor(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vor(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vperm(var_vec_u32[0], var_vec_u32[1], var_vec_u8[2]);
+  *var_vec_u32++ = vec_vrlw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsel(var_vec_u32[0], var_vec_u32[1], var_vec_b32[2]);
+  *var_vec_u32++ = vec_vsel(var_vec_u32[0], var_vec_u32[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vsl(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vsl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsl(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 0);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 1);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 2);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 3);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 4);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 5);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 6);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 7);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 8);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 9);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 10);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 11);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 12);
+}
+void f25() {
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 13);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 14);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 15);
+  *var_vec_u32++ = vec_vslo(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_vslo(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vslw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 0);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 1);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 2);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 3);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 4);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 5);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 6);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 7);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 8);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 9);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 10);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 11);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 12);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 13);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 14);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 15);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 16);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 17);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 18);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 19);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 20);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 21);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 22);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 23);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 24);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 25);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 26);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 27);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 28);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 29);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 30);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 31);
+  *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vsraw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsro(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_vsro(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vsrw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubcuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuwm(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuwm(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vsubuwm(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuws(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuws(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vsubuws(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsum4ubs(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vupkhpx(var_vec_p16[0]);
+  *var_vec_u32++ = vec_vupklpx(var_vec_p16[0]);
+  *var_vec_u32++ = vec_vxor(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vxor(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vxor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_xor(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_xor(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_xor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_add(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_add(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_add(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_adds(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_adds(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_adds(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_and(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_and(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_and(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_andc(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_andc(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_andc(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_avg(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_ld(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_ld(var_int[0], var_vec_u8_ptr[1]);
+  *var_vec_u8++ = vec_lde(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_ldl(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_ldl(var_int[0], var_vec_u8_ptr[1]);
+  *var_vec_u8++ = vec_lvebx(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_float_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_short_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_float_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_short_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u8++ = vec_lvx(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvx(var_int[0], var_vec_u8_ptr[1]);
+}
+void f26() {
+  *var_vec_u8++ = vec_lvxl(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvxl(var_int[0], var_vec_u8_ptr[1]);
+  *var_vec_u8++ = vec_max(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_max(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_max(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_mergeh(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_mergel(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_min(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_min(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_min(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_nor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_or(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_or(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_or(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_pack(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_packs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_packsu(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_u8++ = vec_packsu(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_perm(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_rl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sel(var_vec_u8[0], var_vec_u8[1], var_vec_b8[2]);
+  *var_vec_u8++ = vec_sel(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_sl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 0);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 1);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 2);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 3);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 4);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 5);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 6);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 7);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 8);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 9);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 10);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 11);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 12);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 13);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 14);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 15);
+  *var_vec_u8++ = vec_sll(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_sll(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_sll(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_slo(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_slo(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 0);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 1);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 2);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 3);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 4);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 5);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 6);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 7);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 8);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 9);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 10);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 11);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 12);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 13);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 14);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 15);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 16);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 17);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 18);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 19);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 20);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 21);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 22);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 23);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 24);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 25);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 26);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 27);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 28);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 29);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 30);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 31);
+  *var_vec_u8++ = vec_splat_u8( 0);
+  *var_vec_u8++ = vec_splat_u8( 1);
+  *var_vec_u8++ = vec_splat_u8( 2);
+  *var_vec_u8++ = vec_splat_u8( 3);
+  *var_vec_u8++ = vec_splat_u8( 4);
+  *var_vec_u8++ = vec_splat_u8( 5);
+  *var_vec_u8++ = vec_splat_u8( 6);
+  *var_vec_u8++ = vec_splat_u8( 7);
+  *var_vec_u8++ = vec_splat_u8( 8);
+  *var_vec_u8++ = vec_splat_u8( 9);
+  *var_vec_u8++ = vec_splat_u8( -1);
+  *var_vec_u8++ = vec_splat_u8( -2);
+  *var_vec_u8++ = vec_splat_u8( -3);
+  *var_vec_u8++ = vec_splat_u8( -4);
+  *var_vec_u8++ = vec_splat_u8( -5);
+  *var_vec_u8++ = vec_splat_u8( -6);
+  *var_vec_u8++ = vec_splat_u8( -7);
+  *var_vec_u8++ = vec_splat_u8( -8);
+  *var_vec_u8++ = vec_splat_u8( -9);
+  *var_vec_u8++ = vec_splat_u8( 10);
+  *var_vec_u8++ = vec_splat_u8( 11);
+  *var_vec_u8++ = vec_splat_u8( 12);
+  *var_vec_u8++ = vec_splat_u8( 13);
+  *var_vec_u8++ = vec_splat_u8( 14);
+}
+void f27() {
+  *var_vec_u8++ = vec_splat_u8( 15);
+  *var_vec_u8++ = vec_splat_u8(-10);
+  *var_vec_u8++ = vec_splat_u8(-11);
+  *var_vec_u8++ = vec_splat_u8(-12);
+  *var_vec_u8++ = vec_splat_u8(-13);
+  *var_vec_u8++ = vec_splat_u8(-14);
+  *var_vec_u8++ = vec_splat_u8(-15);
+  *var_vec_u8++ = vec_splat_u8(-16);
+  *var_vec_u8++ = vec_sr(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sra(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_srl(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_srl(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_srl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sro(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_sro(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sub(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sub(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_sub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_subs(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_subs(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_subs(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubm(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubm(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vaddubm(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubs(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubs(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vaddubs(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vand(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vand(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vand(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vandc(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vandc(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vandc(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vavgub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmaxub(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmaxub(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vmaxub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vminub(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vminub(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vminub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmrghb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmrglb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vnor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vor(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vor(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vperm(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_vpkshus(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_u8++ = vec_vpkuhum(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vpkuhus(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vrlb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsel(var_vec_u8[0], var_vec_u8[1], var_vec_b8[2]);
+  *var_vec_u8++ = vec_vsel(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_vsl(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vsl(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_vsl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vslb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 0);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 1);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 2);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 3);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 4);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 5);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 6);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 7);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 8);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 9);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 10);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 11);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 12);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 13);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 14);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 15);
+  *var_vec_u8++ = vec_vslo(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_vslo(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 0);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 1);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 2);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 3);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 4);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 5);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 6);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 7);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 8);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 9);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 10);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 11);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 12);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 13);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 14);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 15);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 16);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 17);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 18);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 19);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 20);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 21);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 22);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 23);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 24);
+}
+void f28() {
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 25);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 26);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 27);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 28);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 29);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 30);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 31);
+  *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsrab(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsrb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsro(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_vsro(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububm(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububm(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vsububm(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububs(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububs(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vsububs(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vxor(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vxor(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vxor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_xor(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_xor(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_xor(var_vec_u8[0], var_vec_u8[1]);
+  *var_volatile_vec_u16++ = vec_mfvscr();
+  if(!vec_all_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(!vec_all_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(!vec_all_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_in(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(!vec_all_le(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+}
+void f29() {
+  if(!vec_all_le(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(!vec_all_nan(var_vec_f32[0])) *var_cc26td++;
+  if(!vec_all_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(!vec_all_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(!vec_all_numeric(var_vec_f32[0])) *var_cc24td++;
+  if(!vec_any_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(!vec_any_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(!vec_any_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+}
+void f30() {
+  if(!vec_any_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_le(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(!vec_any_le(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc26fr++;
+  if(!vec_any_nan(var_vec_f32[0])) *var_cc24fd++;
+  if(!vec_any_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(!vec_any_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(!vec_any_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(!vec_any_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(!vec_any_numeric(var_vec_f32[0])) *var_cc26fd++;
+  if(!vec_any_out(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_all_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+}
+void f31() {
+  if(vec_all_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(vec_all_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(vec_all_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_in(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(vec_all_le(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(vec_all_nan(var_vec_f32[0])) *var_cc26td++;
+  if(vec_all_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+}
+void f32() {
+  if(vec_all_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(vec_all_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(vec_all_numeric(var_vec_f32[0])) *var_cc24td++;
+  if(vec_any_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_any_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(vec_any_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_le(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(vec_any_le(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc26fr++;
+}
+void f33() {
+  if(vec_any_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc26fr++;
+  if(vec_any_nan(var_vec_f32[0])) *var_cc24fd++;
+  if(vec_any_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(vec_any_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(vec_any_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(vec_any_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(vec_any_numeric(var_vec_f32[0])) *var_cc26fd++;
+  if(vec_any_out(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  vec_dss( 0);
+  vec_dss( 1);
+  vec_dss( 2);
+  vec_dss( 3);
+  vec_dssall();
+  vec_dst(var_float_ptr[0], var_int[1], 0);
+  vec_dst(var_float_ptr[0], var_int[1], 1);
+  vec_dst(var_float_ptr[0], var_int[1], 2);
+  vec_dst(var_float_ptr[0], var_int[1], 3);
+  vec_dst(var_int_ptr[0], var_int[1], 0);
+  vec_dst(var_int_ptr[0], var_int[1], 1);
+  vec_dst(var_int_ptr[0], var_int[1], 2);
+  vec_dst(var_int_ptr[0], var_int[1], 3);
+  vec_dst(var_short_ptr[0], var_int[1], 0);
+  vec_dst(var_short_ptr[0], var_int[1], 1);
+  vec_dst(var_short_ptr[0], var_int[1], 2);
+  vec_dst(var_short_ptr[0], var_int[1], 3);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 3);
+}
+void f34() {
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_dstst(var_float_ptr[0], var_int[1], 0);
+  vec_dstst(var_float_ptr[0], var_int[1], 1);
+  vec_dstst(var_float_ptr[0], var_int[1], 2);
+  vec_dstst(var_float_ptr[0], var_int[1], 3);
+  vec_dstst(var_int_ptr[0], var_int[1], 0);
+  vec_dstst(var_int_ptr[0], var_int[1], 1);
+  vec_dstst(var_int_ptr[0], var_int[1], 2);
+  vec_dstst(var_int_ptr[0], var_int[1], 3);
+  vec_dstst(var_short_ptr[0], var_int[1], 0);
+  vec_dstst(var_short_ptr[0], var_int[1], 1);
+  vec_dstst(var_short_ptr[0], var_int[1], 2);
+  vec_dstst(var_short_ptr[0], var_int[1], 3);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 3);
+}
+void f35() {
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_dststt(var_float_ptr[0], var_int[1], 0);
+  vec_dststt(var_float_ptr[0], var_int[1], 1);
+  vec_dststt(var_float_ptr[0], var_int[1], 2);
+  vec_dststt(var_float_ptr[0], var_int[1], 3);
+  vec_dststt(var_int_ptr[0], var_int[1], 0);
+  vec_dststt(var_int_ptr[0], var_int[1], 1);
+  vec_dststt(var_int_ptr[0], var_int[1], 2);
+  vec_dststt(var_int_ptr[0], var_int[1], 3);
+  vec_dststt(var_short_ptr[0], var_int[1], 0);
+  vec_dststt(var_short_ptr[0], var_int[1], 1);
+  vec_dststt(var_short_ptr[0], var_int[1], 2);
+  vec_dststt(var_short_ptr[0], var_int[1], 3);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_dstt(var_float_ptr[0], var_int[1], 0);
+  vec_dstt(var_float_ptr[0], var_int[1], 1);
+  vec_dstt(var_float_ptr[0], var_int[1], 2);
+  vec_dstt(var_float_ptr[0], var_int[1], 3);
+  vec_dstt(var_int_ptr[0], var_int[1], 0);
+  vec_dstt(var_int_ptr[0], var_int[1], 1);
+  vec_dstt(var_int_ptr[0], var_int[1], 2);
+  vec_dstt(var_int_ptr[0], var_int[1], 3);
+}
+void f36() {
+  vec_dstt(var_short_ptr[0], var_int[1], 0);
+  vec_dstt(var_short_ptr[0], var_int[1], 1);
+  vec_dstt(var_short_ptr[0], var_int[1], 2);
+  vec_dstt(var_short_ptr[0], var_int[1], 3);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_mtvscr(var_vec_b16[0]);
+  vec_mtvscr(var_vec_b32[0]);
+  vec_mtvscr(var_vec_b8[0]);
+  vec_mtvscr(var_vec_p16[0]);
+  vec_mtvscr(var_vec_s16[0]);
+  vec_mtvscr(var_vec_s32[0]);
+  vec_mtvscr(var_vec_s8[0]);
+  vec_mtvscr(var_vec_u16[0]);
+  vec_mtvscr(var_vec_u32[0]);
+  vec_mtvscr(var_vec_u8[0]);
+  vec_st(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_st(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_st(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_st(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_st(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_st(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_st(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_st(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_st(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_st(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_st(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_st(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_st(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_st(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_st(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_st(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_st(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_st(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+  vec_ste(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_ste(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+}
+void f37() {
+  vec_ste(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_ste(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_ste(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_ste(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_ste(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stl(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_stl(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_stl(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_stl(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stl(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_stl(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_stl(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stl(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_stl(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stl(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_stl(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stl(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_stl(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stl(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_stl(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stl(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_stl(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stl(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+  vec_stvebx(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stvebx(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stvehx(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stvehx(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stvewx(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stvewx(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stvewx(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stvx(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_stvx(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_stvx(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_stvx(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stvx(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_stvx(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_stvx(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stvx(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_stvx(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stvx(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_stvx(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stvx(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_stvx(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stvx(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_stvx(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stvx(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_stvx(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stvx(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+  vec_stvxl(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_stvxl(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_stvxl(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_stvxl(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stvxl(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_stvxl(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_stvxl(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stvxl(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_stvxl(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stvxl(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_stvxl(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stvxl(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_stvxl(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stvxl(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_stvxl(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stvxl(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_stvxl(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stvxl(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/pr27006.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/pr27006.c
new file mode 100644
index 000000000..d34d51e92
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/pr27006.c
@@ -0,0 +1,22 @@
+/* { dg-options "-maltivec" } */
+
+extern void abort ();
+
+typedef union
+{
+  int i[4];
+  __attribute__((altivec(vector__))) int v;
+} vec_int4;
+
+int main (void)
+{
+  vec_int4 i1;
+
+  i1.v = (__attribute__((altivec(vector__))) int){31, 31, 31, 31};
+
+  if (i1.i[0] != 31)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/pr27842.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/pr27842.c
new file mode 100644
index 000000000..ad3130d00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/pr27842.c
@@ -0,0 +1,26 @@
+#include <altivec.h>
+
+extern void abort (void);
+extern int memcmp (const void *, const void *, __SIZE_TYPE__);
+
+void test (vector float *p, int n)
+{
+  int i;
+  for (i = 0; i < n; i++)
+    p[i] = vec_abs (p[i]);
+}
+
+int
+main (void)
+{
+  vector float p = (vector float){ 0.5, 0.5, 0.5, 0.5 };
+  vector float q = p;
+
+  test (&p, 1);
+
+  if (memcmp (&p, &q, sizeof (p)))
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/sn7153.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/sn7153.c
new file mode 100644
index 000000000..a498a8620
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/sn7153.c
@@ -0,0 +1,62 @@
+/* In the source code, the vec_adds appears before the call to
+   validate_sat().  In the .s code, the vaddubs has been moved to after
+   the call to validate_sat().  This invalidates the meaning of checking
+   the saturation bit.  */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <altivec.h>
+
+static int failed;
+
+void validate_sat();
+void validate_u8(vector unsigned char, vector unsigned char);
+
+int
+main()
+{
+  vector unsigned char result_u8;
+  vec_mtvscr(((vector unsigned short){0,0,0,0,0,0,0,0}));
+  result_u8 = vec_adds(((vector unsigned
+			char){0,1,2,3,0xfc,0xfd,0xfe,0xff,
+			      0,1,2,3,0xfc,0xfd,0xfe,0xff}),
+		       ((vector unsigned
+			char){0,0xf0,0xfd,0xfd,2,2,2,2,0,
+			      0xf0,0xfd,0xfd,2,2,2,2}));
+  validate_sat();
+  validate_u8(result_u8, ((vector unsigned
+			  char){0,0xf1,0xff,0xff,0xfe,0xff,0xff,0xff,
+				  0,0xf1,0xff,0xff,0xfe,0xff,0xff,0xff}));
+  if (failed)
+    abort ();
+  return 0;
+}
+
+void validate_sat()
+{
+  if (vec_any_ne(vec_splat(vec_mfvscr(), 7), ((vector unsigned short){1,1,1,1,1,1,1,1})))
+    {
+      union {vector unsigned short v; unsigned short s[8];} u;
+      u.v = vec_mfvscr();
+      printf("error: vscr == { %d,%d,%d,%d,%d,%d,%d,%d }",
+	     u.s[0], u.s[1], u.s[2], u.s[3],
+	     u.s[4], u.s[5], u.s[6], u.s[7]);
+      printf("expected { 1,1,1,1,1,1,1,1 }\n");
+      failed++;
+    }
+}
+
+void validate_u8(vector unsigned char v, vector unsigned char vx)
+{
+  union {vector unsigned char v; unsigned char x[16]; } u, ux;
+  int i;
+  u.v = v;
+  ux.v = vx;
+  for (i=0; i<16; i++) {
+    if (u.x[i] != ux.x[i]) {
+      printf(" error: field %d %#2.2x expected %#2.2x\n",
+             i, u.x[i], ux.x[i]);
+      failed++;
+    }
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill.c
new file mode 100644
index 000000000..dad489c34
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill.c
@@ -0,0 +1,131 @@
+#include <altivec.h>
+extern vector unsigned char u8(void);
+extern vector signed char s8(void);
+extern vector bool char b8(void);
+extern vector unsigned short u16(void);
+extern vector signed short s16(void);
+extern vector bool short b16(void);
+extern vector unsigned int u32(void);
+extern vector signed int s32(void);
+extern vector bool int b32(void);
+extern vector float f32(void);
+extern vector pixel p16(void);
+
+extern void g(vector unsigned char, ...);
+
+void f()
+{
+  vector unsigned char u8l = u8();
+  vector signed char s8l = s8();
+  vector bool char b8l = b8();
+  vector unsigned short u16l = u16();
+  vector signed short s16l = s16();
+  vector bool short b16l = b16();
+  vector unsigned int u32l = u32();
+  vector signed int s32l = s32();
+  vector bool int b32l = b32();
+  vector float f32l = f32();
+  vector pixel p16l = p16();
+  vector unsigned char u8lx = u8();
+  vector signed char s8lx = s8();
+  vector bool char b8lx = b8();
+  vector unsigned short u16lx = u16();
+  vector signed short s16lx = s16();
+  vector bool short b16lx = b16();
+  vector unsigned int u32lx = u32();
+  vector signed int s32lx = s32();
+  vector bool int b32lx = b32();
+  vector float f32lx = f32();
+  vector pixel p16lx = p16();
+
+  g(u8l, s8l, b8l, u16l, s16l, b16l, u32l, s32l, b32l, f32l, p16l,
+    u8lx, s8lx, b8lx, u16lx, s16lx, b16lx, u32lx, s32lx, b32lx, f32lx, p16lx);
+}
+
+vector unsigned char
+u8(void)
+{
+  static vector unsigned char zero;
+  return zero;
+}
+
+vector signed char
+s8(void)
+{
+  static vector signed char zero;
+  return zero;
+}
+
+vector bool char
+b8(void)
+{
+  static vector bool char zero;
+  return zero;
+}
+
+vector unsigned short
+u16(void)
+{
+  static vector unsigned short zero;
+  return zero;
+}
+
+vector signed short
+s16(void)
+{
+  static vector signed short zero;
+  return zero;
+}
+
+vector bool short
+b16(void)
+{
+  static vector bool short zero;
+  return zero;
+}
+
+vector unsigned int
+u32(void)
+{
+  static vector unsigned int zero;
+  return zero;
+}
+
+vector signed int
+s32(void)
+{
+  static vector signed int zero;
+  return zero;
+}
+
+vector bool int
+b32(void)
+{
+  static vector bool int zero;
+  return zero;
+}
+
+vector float
+f32(void)
+{
+  static vector float zero;
+  return zero;
+}
+
+vector pixel
+p16(void)
+{
+  static vector pixel zero;
+  return zero;
+}
+
+void
+g(vector unsigned char a, ...)
+{
+}
+
+int main()
+{
+  f();
+  return 0; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill2.c
new file mode 100644
index 000000000..4c7337bd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill2.c
@@ -0,0 +1,155 @@
+#include <altivec.h>
+extern vector unsigned char u8(void);
+extern vector signed char s8(void);
+extern vector bool char b8(void);
+extern vector unsigned short u16(void);
+extern vector signed short s16(void);
+extern vector bool short b16(void);
+extern vector unsigned int u32(void);
+extern vector signed int s32(void);
+extern vector bool int b32(void);
+extern vector float f32(void);
+extern vector pixel p16(void);
+extern double d(void);
+extern int i(void);
+
+extern void g(vector unsigned char, ...);
+
+void f()
+{
+  int i1l = i();
+  vector unsigned char u8l = u8();
+  vector signed char s8l = s8();
+  vector bool char b8l = b8();
+  int i2l = i();
+  vector unsigned short u16l = u16();
+  vector signed short s16l = s16();
+  vector bool short b16l = b16();
+  int i3l = i();
+  vector unsigned int u32l = u32();
+  vector signed int s32l = s32();
+  vector bool int b32l = b32();
+  double d1l = d();
+  vector float f32l = f32();
+  vector pixel p16l = p16();
+  double d2l = d();
+  vector unsigned char u8lx = u8();
+  vector signed char s8lx = s8();
+  vector bool char b8lx = b8();
+  vector unsigned short u16lx = u16();
+  vector signed short s16lx = s16();
+  vector bool short b16lx = b16();
+  vector unsigned int u32lx = u32();
+  vector signed int s32lx = s32();
+  vector bool int b32lx = b32();
+  vector float f32lx = f32();
+  vector pixel p16lx = p16();
+
+  if (i1l)
+    g(u8l, s8l, b8l, u16l, s16l, b16l, u32l, s32l, b32l, f32l, p16l,
+      u8lx, s8lx, b8lx, u16lx, s16lx, b16lx, u32lx, s32lx, b32lx, f32lx, p16lx,
+      i1l, i2l, i3l, d1l, d2l);
+  g(u8l, i1l, i2l, i3l, d1l, d2l);
+}
+
+double
+d(void)
+{
+  static double zero;
+  return zero;
+}
+
+int
+i(void)
+{
+  static int non_zero;
+  return ++non_zero;
+}
+
+vector unsigned char
+u8(void)
+{
+  static vector unsigned char zero;
+  return zero;
+}
+
+vector signed char
+s8(void)
+{
+  static vector signed char zero;
+  return zero;
+}
+
+vector bool char
+b8(void)
+{
+  static vector bool char zero;
+  return zero;
+}
+
+vector unsigned short
+u16(void)
+{
+  static vector unsigned short zero;
+  return zero;
+}
+
+vector signed short
+s16(void)
+{
+  static vector signed short zero;
+  return zero;
+}
+
+vector bool short
+b16(void)
+{
+  static vector bool short zero;
+  return zero;
+}
+
+vector unsigned int
+u32(void)
+{
+  static vector unsigned int zero;
+  return zero;
+}
+
+vector signed int
+s32(void)
+{
+  static vector signed int zero;
+  return zero;
+}
+
+vector bool int
+b32(void)
+{
+  static vector bool int zero;
+  return zero;
+}
+
+vector float
+f32(void)
+{
+  static vector float zero;
+  return zero;
+}
+
+vector pixel
+p16(void)
+{
+  static vector pixel zero;
+  return zero;
+}
+
+void
+g(vector unsigned char a, ...)
+{
+}
+
+int main() 
+{
+  f();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill3.c
new file mode 100644
index 000000000..9f1c45c65
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/spill3.c
@@ -0,0 +1,156 @@
+#include <altivec.h>
+extern void g(vector unsigned char, ...);
+extern vector unsigned char v(void);
+extern double d(void);
+extern int i(void);
+
+static vector unsigned char v1l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v2l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v3l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v4l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v5l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v6l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v7l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v8l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v9l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v10l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v11l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static vector unsigned char v12l = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static double d1l = 0;
+static double d2l = 0;
+static double d3l = 0;
+static double d4l = 0;
+static double d5l = 0;
+static double d6l = 0;
+static double d7l = 0;
+static double d8l = 0;
+static double d9l = 0;
+static double d10l = 0;
+static double d11l = 0;
+static double d12l = 0;
+static double d13l = 0;
+static double d14l = 0;
+static double d15l = 0;
+static double d16l = 0;
+static double d17l = 0;
+static double d18l = 0;
+static int i1l = 0;
+static int i2l = 0;
+static int i3l = 0;
+static int i4l = 0;
+static int i5l = 0;
+static int i6l = 0;
+static int i7l = 0;
+static int i8l = 0;
+static int i9l = 0;
+static int i10l = 0;
+static int i11l = 0;
+static int i12l = 0;
+static int i13l = 0;
+static int i14l = 0;
+static int i15l = 0;
+static int i16l = 0;
+static int i17l = 0;
+static int i18l = 0;
+static int i19l = 0;
+
+void f()
+{
+  char buffer[23];
+  vector unsigned char v1l = v();
+  vector unsigned char v2l = v();
+  vector unsigned char v3l = v();
+  vector unsigned char v4l = v();
+  vector unsigned char v5l = v();
+  vector unsigned char v6l = v();
+  vector unsigned char v7l = v();
+  vector unsigned char v8l = v();
+  vector unsigned char v9l = v();
+  vector unsigned char v10l = v();
+  vector unsigned char v11l = v();
+  vector unsigned char v12l = v();
+
+  double d1l = d();
+  double d2l = d();
+  double d3l = d();
+  double d4l = d();
+  double d5l = d();
+  double d6l = d();
+  double d7l = d();
+  double d8l = d();
+  double d9l = d();
+  double d10l = d();
+  double d11l = d();
+  double d12l = d();
+  double d13l = d();
+  double d14l = d();
+  double d15l = d();
+  double d16l = d();
+  double d17l = d();
+  double d18l = d();
+
+  int i1l = i();
+  int i2l = i();
+  int i3l = i();
+  int i4l = i();
+  int i5l = i();
+  int i6l = i();
+  int i7l = i();
+  int i8l = i();
+  int i9l = i();
+  int i10l = i();
+  int i11l = i();
+  int i12l = i();
+  int i13l = i();
+  int i14l = i();
+  int i15l = i();
+  int i16l = i();
+  int i17l = i();
+  int i18l = i();
+  int i19l = i();
+
+  if (d1l)
+    g(v1l, v2l, v3l, v4l, v5l, v6l, v7l, v8l, v9l, v10l, v11l, v12l,
+      d1l, d2l, d3l, d4l, d5l, d6l, d7l, d8l, d9l, d10l, d11l, d12l,
+      d13l, d14l, d15l, d16l, d17l, d18l,
+      i1l, i2l, i3l, i4l, i5l, i6l, i7l, i8l, i9l, i10l, i11l, i12l,
+      i13l, i14l, i15l, i16l, i17l, i18l, i19l);
+
+  g(v1l, buffer,
+    d1l, d2l, d3l, d4l, d5l, d6l, d7l, d8l, d9l, d10l, d11l, d12l,
+    d13l, d14l, d15l, d16l, d17l, d18l,
+    i1l, i2l, i3l, i4l, i5l, i6l, i7l, i8l, i9l, i10l, i11l, i12l,
+    i13l, i14l, i15l, i16l, i17l, i18l, i19l);
+}
+
+double
+d(void)
+{
+  static double zero;
+  return zero;
+}
+
+int
+i(void)
+{
+  static int non_zero;
+  return ++non_zero;
+}
+
+vector unsigned char
+v(void)
+{
+  static vector unsigned char zero;
+  return zero;
+}
+
+void
+g(vector unsigned char a, ...)
+{
+}
+
+int main() 
+{
+  f();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/t.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/t.c
new file mode 100644
index 000000000..3a7d5a94a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/t.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+#include <altivec.h>
+typedef	unsigned long	size_t;
+vector signed int T_vec_s32;
+void *T_void_ptr;
+const void *T_const_void_ptr;
+size_t T_size_t;
+char *T_char_ptr;
+vector signed short T_vec_s16;
+vector signed char T_vec_s8;
+vector unsigned short T_vec_u16;
+vector unsigned int T_vec_u32;
+vector unsigned char T_vec_u8;
+vector float T_vec_f32;
+int T_int;
+float *T_float_ptr;
+void f(void);
+short *T_short_ptr;
+vector signed short *T_vec_s16_ptr;
+int *T_int_ptr;
+vector signed int *T_vec_s32_ptr;
+signed char *T_signed_char_ptr;
+vector signed char *T_vec_s8_ptr;
+unsigned short *T_unsigned_short_ptr;
+vector unsigned short *T_vec_u16_ptr;
+unsigned int *T_unsigned_int_ptr;
+vector unsigned int *T_vec_u32_ptr;
+unsigned char *T_unsigned_char_ptr;
+vector unsigned char *T_vec_u8_ptr;
+double T_double;
+int T_intb;
+vector bool short *T_vec_b16_ptr;
+vector bool int *T_vec_b32_ptr;
+vector bool char *T_vec_b8_ptr;
+vector float *T_vec_f32_ptr;
+vector pixel *T_vec_p16_ptr;
+vector bool short T_vec_b16;
+vector pixel T_vec_p16;
+vector bool int T_vec_b32;
+vector bool char T_vec_b8;
+float T_float;
+volatile void g(void);
+const char *T_const_char_ptr;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-1.c
new file mode 100644
index 000000000..596137464
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-1.c
@@ -0,0 +1,99 @@
+#include <altivec.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+typedef vector unsigned int T;
+
+extern void f1(int, ...);
+extern void f2(int, T, ...);
+extern void f3(int, T, T, ...);
+extern void f4(int, T, T, T);
+
+void printx(T a)
+{
+  union {
+    T v;
+    unsigned int a[4];
+  } u;
+  u.v = a;
+  printf("%d, %d, %d, %d\n", u.a[0], u.a[1], u.a[2], u.a[3]);
+}
+
+void f1(int a, ...)
+{
+  va_list ap;
+  va_start (ap, a);
+  while (a-- > 0)
+    printx(va_arg(ap, T));
+  va_end (ap);
+}
+
+void f2(int a, T b, ...)
+{
+  va_list ap;
+  printx(b);
+  a--;
+  va_start (ap, b);
+  while (a-- > 0)
+    printx(va_arg(ap, T));
+  va_end (ap);
+}
+
+void f3(int a, T b, T c, ...)
+{
+  va_list ap;
+  printx(b);
+  a--;
+  printx(c);
+  a--;
+  va_start (ap, c);
+  while (a-- > 0)
+    printx(va_arg(ap, T));
+  va_end (ap);
+}
+
+void f4(int a, T b, T c,
+	T d)
+{
+  printx(b);
+  a--;
+  printx(c);
+  a--;
+  printx(d);
+  a--;
+}
+
+int main()
+{
+  f4 (3,
+      ((T){1,1,1,1}),
+      ((T){2,2,2,2}), 
+      ((T){3,3,3,3}));
+  f3 (3,
+      ((T){4,4,4,4}),
+      ((T){5,5,5,5}), 
+      ((T){6,6,6,6}));
+  f2 (3,
+      ((T){7,7,7,7}),
+      ((T){8,8,8,8}), 
+      ((T){9,9,9,9}));
+  f1 (3,
+      ((T){10,10,10,10}),
+      ((T){11,11,11,11}), 
+      ((T){12,12,12,12}));
+  return 0;
+}
+
+/* { dg-output "1, 1, 1, 1(\n|\r\n|\r)" }
+   { dg-output "2, 2, 2, 2(\n|\r\n|\r)" }
+   { dg-output "3, 3, 3, 3(\n|\r\n|\r)" }
+   { dg-output "4, 4, 4, 4(\n|\r\n|\r)" }
+   { dg-output "5, 5, 5, 5(\n|\r\n|\r)" }
+   { dg-output "6, 6, 6, 6(\n|\r\n|\r)" }
+   { dg-output "7, 7, 7, 7(\n|\r\n|\r)" }
+   { dg-output "8, 8, 8, 8(\n|\r\n|\r)" }
+   { dg-output "9, 9, 9, 9(\n|\r\n|\r)" }
+   { dg-output "10, 10, 10, 10(\n|\r\n|\r)" }
+   { dg-output "11, 11, 11, 11(\n|\r\n|\r)" }
+   { dg-output "12, 12, 12, 12(\n|\r\n|\r)" }
+ */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-2.c
new file mode 100644
index 000000000..1df171529
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-2.c
@@ -0,0 +1,78 @@
+#include "harness.h"
+#include <stdarg.h>
+
+static void
+varargsn003(vector float p1, vector float p2, vector float p3, ...)
+{
+  va_list ap;
+  vector float i1;
+  vector float i2;
+  vector float i3;
+  vector float i4;
+  vector float i5;
+  vector float i6;
+  vector float i7;
+  vector float i8;
+  vector float i9;
+  vector float i10;
+  vector float i11;
+  vector float i12;
+  vector float i13;
+  vector float i14;
+  vector float i15;
+  int i16;
+
+  va_start(ap, p3);
+  i1 = p1;
+  i2 = p2;
+  i3 = p3;
+  i4 = va_arg(ap, vector float);
+  i5 = va_arg(ap, vector float);
+  i6 = va_arg(ap, vector float);
+  i7 = va_arg(ap, vector float);
+  i8 = va_arg(ap, vector float);
+  i9 = va_arg(ap, vector float);
+  i10 = va_arg(ap, vector float);
+  i11 = va_arg(ap, vector float);
+  i12 = va_arg(ap, vector float);
+  i13 = va_arg(ap, vector float);
+  i14 = va_arg(ap, vector float);
+  i15 = va_arg(ap, vector float);
+  i16 = va_arg(ap, int);
+  va_end(ap);
+
+  check(vec_all_eq(i1, ((vector float){1.14e+09, 4.29e+08, -1.58e+09, 1.66e+09})), "i1");
+  check(vec_all_eq(i2, ((vector float){-1.83e+09, -6.79e+08, 1.58e+09, -3.38e+08})), "i2");
+  check(vec_all_eq(i3, ((vector float){-1.19e+09, -4.27e+08, 6.84e+08, 1.21e+08})), "i3");
+  check(vec_all_eq(i4, ((vector float){1.47e+09, 9.17e+08, 3.45e+08, -1.17e+08})), "i4");
+  check(vec_all_eq(i5, ((vector float){3.08e+08, 1.2e+08, 1.73e+09, 1.77e+09})), "i5");
+  check(vec_all_eq(i6, ((vector float){1.89e+09, 2.06e+09, 2.64e+08, 1.05e+09})), "i6");
+  check(vec_all_eq(i7, ((vector float){5.45e+08, 1.37e+09, -8.2e+08, 4.32e+07})), "i7");
+  check(vec_all_eq(i8, ((vector float){3.47e+08, -1.66e+09, 1.25e+09, 1.53e+09})), "i8");
+  check(vec_all_eq(i9, ((vector float){-6.04e+08, 1.48e+09, -1.48e+09, 1.92e+09})), "i9");
+  check(vec_all_eq(i10, ((vector float){-1.66e+09, -8.92e+08, -3.78e+08, 2.11e+09})), "i10");
+  check(vec_all_eq(i11, ((vector float){-7.46e+08, 4.01e+08, -1.78e+09, 1.83e+09})), "i11");
+  check(vec_all_eq(i12, ((vector float){1.83e+09, 5.73e+08, -2.96e+08, -7.46e+08})), "i12");
+  check(vec_all_eq(i13, ((vector float){-2.01e+09, 9.89e+08, -1.92e+09, 2.09e+09})), "i13");
+  check(vec_all_eq(i14, ((vector float){1.95e+09, -2.41e+08, 2.67e+08, 1.67e+09})), "i14");
+  check(vec_all_eq(i15, ((vector float){-2.12e+09, 8.18e+08, 9.47e+08, -1.25e+09})), "i15");
+  check(i16 == -947264420, "i16");
+}
+
+static void test()
+{
+  varargsn003(((vector float){1.14e+09, 4.29e+08, -1.58e+09, 1.66e+09}),
+	      ((vector float){-1.83e+09, -6.79e+08, 1.58e+09, -3.38e+08}),
+	      ((vector float){-1.19e+09, -4.27e+08, 6.84e+08, 1.21e+08}),
+	      ((vector float){1.47e+09, 9.17e+08, 3.45e+08, -1.17e+08}),
+	      ((vector float){3.08e+08, 1.2e+08, 1.73e+09, 1.77e+09}),
+	      ((vector float){1.89e+09, 2.06e+09, 2.64e+08, 1.05e+09}),
+	      ((vector float){5.45e+08, 1.37e+09, -8.2e+08, 4.32e+07}),
+	      ((vector float){3.47e+08, -1.66e+09, 1.25e+09, 1.53e+09}),
+	      ((vector float){-6.04e+08, 1.48e+09, -1.48e+09, 1.92e+09}),
+	      ((vector float){-1.66e+09, -8.92e+08, -3.78e+08, 2.11e+09}),
+	      ((vector float){-7.46e+08, 4.01e+08, -1.78e+09, 1.83e+09}),
+	      ((vector float){1.83e+09, 5.73e+08, -2.96e+08, -7.46e+08}),
+	      ((vector float){-2.01e+09, 9.89e+08, -1.92e+09, 2.09e+09}),
+	      ((vector float){1.95e+09, -2.41e+08, 2.67e+08, 1.67e+09}), ((vector float){-2.12e+09, 8.18e+08, 9.47e+08, -1.25e+09}), -947264420);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-3.c
new file mode 100644
index 000000000..be8b71bf9
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-3.c
@@ -0,0 +1,75 @@
+#include "harness.h"
+#include <stdarg.h>
+
+typedef struct n_a
+{
+  signed char m1;
+  short m2;
+  int m3;
+  double m4;
+  vector float m5;
+}
+n_a;
+
+void
+varlistn_a(signed char p1, va_list ap)
+{
+  n_a q;
+  q.m1 = p1;
+  q.m2 = va_arg(ap, int);
+  q.m3 = va_arg(ap, int);
+  q.m4 = va_arg(ap, double);
+  q.m5 = va_arg(ap, vector float);
+
+  check(q.m1 == 77, "q.m1");
+  check(q.m2 == 1924, "q.m2");
+  check(q.m3 == -1471601920, "q.m3");
+  check(q.m4 == 3.65e+18, "q.m4");
+  check(vec_all_eq(q.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})), "q.m5");
+}
+
+void
+varargsn_a(signed char p1, ...)
+{
+  n_a r, s;
+  va_list ap;
+
+  va_start(ap, p1);
+  r.m1 = p1;
+  r.m2 = va_arg(ap, int);
+  r.m3 = va_arg(ap, int);
+  r.m4 = va_arg(ap, double);
+  r.m5 = va_arg(ap, vector float);
+  va_end(ap);
+
+  check(r.m1 == 77, "r.m1");
+  check(r.m2 == 1924, "r.m2");
+  check(r.m3 == -1471601920, "r.m3");
+  check(r.m4 == 3.65e+18, "r.m4");
+  check(vec_all_eq(r.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})), "r.m5");
+
+  va_start(ap, p1);
+  s.m1 = p1;
+  s.m2 = va_arg(ap, int);
+  s.m3 = va_arg(ap, int);
+  s.m4 = va_arg(ap, double);
+  s.m5 = va_arg(ap, vector float);
+  va_end(ap);
+
+  check(s.m1 == 77, "s.m1");
+  check(s.m2 == 1924, "s.m2");
+  check(s.m3 == -1471601920, "s.m3");
+  check(s.m4 == 3.65e+18, "s.m4");
+  check(vec_all_eq(s.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})), "s.m5");
+
+  va_start(ap, p1);
+  varlistn_a(p1, ap);
+  va_end(ap);
+}
+
+
+
+void test()
+{
+  varargsn_a(77, 1924, -1471601920, 3.65e+18, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08}));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-4.c
new file mode 100644
index 000000000..a17551953
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-4.c
@@ -0,0 +1,291 @@
+#include "harness.h"
+#include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+
+typedef struct n_a
+{
+  signed char m1;
+  short m2;
+  int m3;
+  double m4;
+  vector float m5;
+}
+n_a;
+
+static n_a gn_a;
+
+static int
+lay(char *p, int start, int end, int n)
+{
+  int b;
+  unsigned char ch;
+  unsigned int mask;
+
+  start *= 8;
+  end *= 8;
+  n *= 8;
+
+  for (b = 0; b + 8 <= start; b += 8)
+    {
+      ch = *p++;
+      if (ch != 0xff)
+	for (mask = 0x80; mask; b++, mask >>= 1)
+	  if ((ch & mask) != mask)
+	    return b;
+    }
+
+  if (b < start)
+    {
+      ch = *p++;
+      for (mask = 0x80; b < start; b++, mask >>= 1)
+	if ((ch & mask) != mask)
+	  return b;
+      for (; mask && b < end; b++, mask >>= 1)
+	if ((ch & mask) != 0)
+	  return b;
+    }
+
+  for (; b + 8 <= end; b += 8)
+    {
+      ch = *p++;
+      if (ch != 0)
+	for (mask = 0x80; mask; b++, mask >>= 1)
+	  if ((ch & mask) != 0)
+	    return b;
+    }
+
+  if (b < end)
+    {
+      ch = *p++;
+      for (mask = 0x80; b < end; b++, mask >>= 1)
+	if ((ch & mask) != 0)
+	  return b;
+      for (; mask && b < n; b++, mask >>= 1)
+	if ((ch & mask) != mask)
+	  return b;
+    }
+
+  for (; b + 8 <= n; b += 8)
+    {
+      ch = *p++;
+      if (ch != 0xff)
+	for (mask = 0x80; mask; b++, mask >>= 1)
+	  if ((ch & mask) != mask)
+	    return b;
+    }
+
+  return n;
+}
+
+static void
+initn_a(signed char p1, short p2, int p3, double p4, vector float p5)
+{
+  n_a i;
+
+  i.m1 = p1;
+  i.m2 = p2;
+  i.m3 = p3;
+  i.m4 = p4;
+  i.m5 = p5;
+
+  check(i.m1 == 77, "i.m1");
+  check(i.m2 == 1924, "i.m2");
+  check(i.m3 == -1471601920, "i.m3");
+  check(vec_all_eq(i.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"i.m5");
+
+  check(sizeof(n_a) == 32, "sizeof(n_a)");
+
+  check(offsetof(n_a, m1) == 0,  "offsetof(m1)");
+  check(offsetof(n_a, m2) == 2,  "offsetof(m2)");
+  check(offsetof(n_a, m3) == 4,  "offsetof(m3)");
+  check(offsetof(n_a, m4) == 8,  "offsetof(m4)");
+  check(offsetof(n_a, m5) == 16, "offsetof(m5)");
+
+  check(sizeof(i.m1) == 1,  "sizeof(m1)");
+  check(sizeof(i.m2) == 2,  "sizeof(m2)");
+  check(sizeof(i.m3) == 4,  "sizeof(m3)");
+  check(sizeof(i.m4) == 8,  "sizeof(m4)");
+  check(sizeof(i.m5) == 16, "sizeof(m5)");
+
+#define lay_check(field) do {				\
+  memset((char *)&i, 0xFF, sizeof(i));			\
+  lay_reset(field);					\
+  check(lay((char *)&i,					\
+	    offsetof(n_a, field),			\
+	    offsetof(n_a, field) + sizeof(i.field),	\
+	    sizeof(i)) == sizeof(i)*8,			\
+	"lay(" #field ")");				\
+  } while (0)
+#define lay_reset(field) i.field = 0
+
+  lay_check(m1);
+  lay_check(m2);
+  lay_check(m3);
+  lay_check(m4);
+#undef lay_reset
+#define lay_reset(field) i.field = ((vector float){0,0,0,0})
+  lay_check(m5);
+
+#undef lay_check
+#undef lay_reset
+}
+
+n_a
+valuen_a(void)
+{
+  return gn_a;
+}
+
+n_a *
+addrn_a(void)
+{
+  return &gn_a;
+}
+
+static void
+eqn_a(n_a * a)
+{
+  check(a->m1 == 77, "a->m1");
+  check(a->m2 == 1924, "a->m2");
+  check(a->m3 == -1471601920, "a->m3");
+  check(vec_all_eq(a->m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"a->m5");
+}
+
+static void
+getsn_a(n_a * a)
+{
+  a->m1 = 77;
+  a->m2 = 1924;
+  a->m3 = -1471601920;
+  a->m4 = 3.65e+18;
+  a->m5 = ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08});
+}
+
+static void
+varlistn_a(signed char p1, va_list ap)
+{
+  n_a q;
+  q.m1 = p1;
+  q.m2 = va_arg(ap, int);
+  q.m3 = va_arg(ap, int);
+  q.m4 = va_arg(ap, double);
+  q.m5 = va_arg(ap, vector float);
+
+  check(q.m1 == 77, "q.m1");
+  check(q.m2 == 1924, "q.m2");
+  check(q.m3 == -1471601920, "q.m3");
+  check(vec_all_eq(q.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"q.m5");
+}
+
+static void
+varargsn_a(signed char p1, ...)
+{
+  n_a q, r;
+  va_list ap;
+
+  va_start(ap, p1);
+  q.m1 = p1;
+  q.m2 = va_arg(ap, int);
+  q.m3 = va_arg(ap, int);
+  q.m4 = va_arg(ap, double);
+  q.m5 = va_arg(ap, vector float);
+  va_end(ap);
+
+  check(q.m1 == 77, "q.m1");
+  check(q.m2 == 1924, "q.m2");
+  check(q.m3 == -1471601920, "q.m3");
+  check(vec_all_eq(q.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"q.m5");
+
+  va_start(ap, p1);
+  r.m1 = p1;
+  r.m2 = va_arg(ap, int);
+  r.m3 = va_arg(ap, int);
+  r.m4 = va_arg(ap, double);
+  r.m5 = va_arg(ap, vector float);
+  va_end(ap);
+
+  check(r.m1 == 77, "r.m1");
+  check(r.m2 == 1924, "r.m2");
+  check(r.m3 == -1471601920, "r.m3");
+  check(vec_all_eq(r.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"r.m5");
+
+  va_start(ap, p1);
+  varlistn_a(p1, ap);
+  va_end(ap);
+}
+
+static void
+test()
+{
+  static struct
+  {
+    char a;
+    n_a b;
+  }
+  s;
+  n_a v[3], a, *p;
+
+  static n_a i = { 77, 1924, -1471601920, 3.65e+18, {-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08} };
+
+  memset((char *)&(v), -1, sizeof(v));
+  v[1] = s.b;
+  check(lay((char *)&v, sizeof(n_a), sizeof(n_a)*2, sizeof(n_a)*3) == sizeof(n_a)*3*8,
+	"structure assignment");
+
+  check(i.m1 == 77, "i.m1");
+  check(i.m2 == 1924, "i.m2");
+  check(i.m3 == -1471601920, "i.m3");
+  check(vec_all_eq(i.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"i.m5");
+
+  initn_a(77, 1924, -1471601920, 3.65e+18, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08}));
+  varargsn_a(77, 1924, -1471601920, 3.65e+18, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08}));
+
+  gn_a.m1 = 77;
+  gn_a.m2 = 1924;
+  gn_a.m3 = -1471601920;
+  gn_a.m4 = 3.65e+18;
+  gn_a.m5 = ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08});
+  a = valuen_a();
+
+  check(a.m1 == 77, "a.m1");
+  check(a.m2 == 1924, "a.m2");
+  check(a.m3 == -1471601920, "a.m3");
+  check(vec_all_eq(a.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"a.m5");
+
+  p = addrn_a();
+
+  check(p->m1 == 77, "p->m1");
+  check(p->m2 == 1924, "p->m2");
+  check(p->m3 == -1471601920, "p->m3");
+  check(vec_all_eq(p->m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"p->m5");
+
+  eqn_a(&a);
+
+  check(gn_a.m1 == 77, "gn_a.m1");
+  check(gn_a.m2 == 1924, "gn_a.m2");
+  check(gn_a.m3 == -1471601920, "gn_a.m3");
+  check(vec_all_eq(gn_a.m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"gn_a.m5");
+
+  getsn_a(&v[0]);
+  v[2].m1 = v[0].m1;
+  v[2].m2 = v[0].m2;
+  v[2].m3 = v[0].m3;
+  v[2].m4 = v[0].m4;
+  v[2].m5 = v[0].m5;
+
+  check(v[2].m1 == 77, "v[2].m1");
+  check(v[2].m2 == 1924, "v[2].m2");
+  check(v[2].m3 == -1471601920, "v[2].m3");
+  check(vec_all_eq(v[2].m5, ((vector float){-1.38e+09, 5.96e+08, 6.88e+08, -3.2e+08})),
+	"v[2].m5");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-5.c
new file mode 100644
index 000000000..ed551c2df
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-5.c
@@ -0,0 +1,71 @@
+#include "harness.h"
+#include <stdarg.h>
+
+typedef struct n025
+{
+  int m1;
+  double m2;
+  int m3;
+  vector signed int m4;
+}
+n025;
+
+static void
+varlistn025(int p1, double p2, va_list ap)
+{
+  n025 q;
+  q.m1 = p1;
+  q.m2 = p2;
+  q.m3 = va_arg(ap, int);
+  q.m4 = va_arg(ap, vector signed int);
+
+  check(q.m1 == 1363477585, "q.m1");
+  check(q.m2 == -8.72e+18, "q.m2");
+  check(q.m3 == 198652649, "q.m3");
+  check(vec_all_eq(q.m4, ((vector signed int){323001541, -1353029458, 1756879633, -327031280})),
+	"q.m5");
+}
+
+
+void
+varargsn025(int p1, double p2, ...)
+{
+  n025 r, s;
+  va_list ap;
+
+  va_start(ap, p2);
+  r.m1 = p1;
+  r.m2 = p2;
+  r.m3 = va_arg(ap, int);
+  r.m4 = va_arg(ap, vector signed int);
+  va_end(ap);
+
+  check(r.m1 == 1363477585, "r.m1");
+  check(r.m2 == -8.72e+18, "r.m2");
+  check(r.m3 == 198652649, "r.m3");
+  check(vec_all_eq(r.m4, ((vector signed int){323001541, -1353029458, 1756879633, -327031280})),
+	"r.m5");
+
+  va_start(ap, p2);
+  s.m1 = p1;
+  s.m2 = p2;
+  s.m3 = va_arg(ap, int);
+  s.m4 = va_arg(ap, vector signed int);
+  va_end(ap);
+
+  check(s.m1 == 1363477585, "s.m1");
+  check(s.m2 == -8.72e+18, "s.m2");
+  check(s.m3 == 198652649, "s.m3");
+  check(vec_all_eq(s.m4, ((vector signed int){323001541, -1353029458, 1756879633, -327031280})),
+	"s.m5");
+
+  va_start(ap, p2);
+  varlistn025(p1, p2, ap);
+  va_end(ap);
+}
+
+static void test()
+{
+  varargsn025(1363477585, -8.72e+18, 198652649,
+	      ((vector signed int){323001541, -1353029458, 1756879633, -327031280}));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-6.c
new file mode 100644
index 000000000..b1f436fd0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-6.c
@@ -0,0 +1,35 @@
+#include "harness.h"
+#include <stdarg.h>
+
+typedef struct n025
+{
+  int m1;
+  double m2;
+  int m3;
+  vector signed int m4;
+}
+n025;
+
+static void
+varargsn025(int p1, double p2, ...)
+{
+  n025 q;
+  va_list ap;
+  va_start(ap, p2);
+  q.m1 = p1;
+  q.m2 = p2;
+  q.m3 = va_arg(ap, int);
+  q.m4 = va_arg(ap, vector signed int);
+  va_end(ap);
+
+  check(q.m1 == 1363477585, "q.m1");
+  check(q.m2 == -8.72e+18, "q.m2");
+  check(q.m3 == 198652649, "q.m3");
+  check(vec_all_eq(q.m4, ((vector signed int){323001541, -1353029458, 1756879633, -327031280})),
+	"q.m4");
+}
+
+static void test()
+{
+  varargsn025(1363477585, -8.72e+18, 198652649, ((vector signed int){323001541, -1353029458, 1756879633, -327031280}));
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-7.c
new file mode 100644
index 000000000..2a09d0ca0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/varargs-7.c
@@ -0,0 +1,83 @@
+#include "harness.h"
+#include <stdarg.h>
+
+static void
+varargsn001(vector unsigned int p1, vector unsigned int p2,
+	    vector unsigned int p3, vector unsigned int p4,
+	    vector unsigned int p5, vector unsigned int p6,
+	    vector unsigned int p7, vector unsigned int p8,
+	    vector unsigned int p9, vector unsigned int p10,
+	    vector unsigned int p11, vector unsigned int p12,
+	    vector unsigned int p13, ...)
+{
+  va_list ap;
+  vector unsigned int i1;
+  vector unsigned int i2;
+  vector unsigned int i3;
+  vector unsigned int i4;
+  vector unsigned int i5;
+  vector unsigned int i6;
+  vector unsigned int i7;
+  vector unsigned int i8;
+  vector unsigned int i9;
+  vector unsigned int i10;
+  vector unsigned int i11;
+  vector unsigned int i12;
+  vector unsigned int i13;
+  vector unsigned int i14;
+  int i15;
+
+  va_start(ap, p13);
+
+  i1 = p1;
+  i2 = p2;
+  i3 = p3;
+  i4 = p4;
+  i5 = p5;
+  i6 = p6;
+  i7 = p7;
+  i8 = p8;
+  i9 = p9;
+  i10 = p10;
+  i11 = p11;
+  i12 = p12;
+  i13 = p13;
+  i14 = va_arg(ap, vector unsigned int);
+  i15 = va_arg(ap, int);
+  va_end(ap);
+
+  check(vec_all_eq(i1, ((vector unsigned int){1,1,1,1})), "i1");
+  check(vec_all_eq(i2, ((vector unsigned int){2,2,2,2})), "i2");
+  check(vec_all_eq(i3, ((vector unsigned int){3,3,3,3})), "i3");
+  check(vec_all_eq(i4, ((vector unsigned int){4,4,4,4})), "i4");
+  check(vec_all_eq(i5, ((vector unsigned int){5,5,5,5})), "i5");
+  check(vec_all_eq(i6, ((vector unsigned int){6,6,6,6})), "i6");
+  check(vec_all_eq(i7, ((vector unsigned int){7,7,7,7})), "i7");
+  check(vec_all_eq(i8, ((vector unsigned int){8,8,8,8})), "i8");
+  check(vec_all_eq(i9, ((vector unsigned int){9,9,9,9})), "i9");
+  check(vec_all_eq(i10, ((vector unsigned int){10,10,10,10})), "i10");
+  check(vec_all_eq(i11, ((vector unsigned int){11,11,11,11})), "i11");
+  check(vec_all_eq(i12, ((vector unsigned int){12,12,12,12})), "i12");
+  check(vec_all_eq(i13, ((vector unsigned int){13,13,13,13})), "i13");
+  check(vec_all_eq(i14, ((vector unsigned int){14,14,14,14})), "i14");
+  check(i15 == 15, "i15");
+}
+
+static void test()
+{
+  varargsn001(((vector unsigned int){1,1,1,1}),
+	      ((vector unsigned int){2,2,2,2}),
+	      ((vector unsigned int){3,3,3,3}),
+	      ((vector unsigned int){4,4,4,4}),
+	      ((vector unsigned int){5,5,5,5}),
+	      ((vector unsigned int){6,6,6,6}),
+	      ((vector unsigned int){7,7,7,7}),
+	      ((vector unsigned int){8,8,8,8}),
+	      ((vector unsigned int){9,9,9,9}),
+	      ((vector unsigned int){10,10,10,10}),
+	      ((vector unsigned int){11,11,11,11}),
+	      ((vector unsigned int){12,12,12,12}),
+	      ((vector unsigned int){13,13,13,13}),
+	      ((vector unsigned int){14,14,14,14}),
+	      15);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/vmx.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/vmx.exp
new file mode 100644
index 000000000..8a842e12f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/vmx.exp
@@ -0,0 +1,57 @@
+#   Copyright (C) 2004, 2006, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Skip these tests for non-PowerPC targets and for targets where AltiVec
+# is not supported.
+if {![istarget powerpc*-*-*]
+    || ![check_effective_target_powerpc_altivec_ok] } {
+    return
+}
+
+# If a testcase doesn't have special options, use these.
+# -pedantic-errors is inappropriate here, as this subdirectory tests
+# nothing but extensions.
+global DEFAULT_VMXCFLAGS
+if ![info exists DEFAULT_VMXCFLAGS] then {
+    set DEFAULT_VMXCFLAGS "-maltivec -mabi=altivec -std=gnu99"
+}
+
+# If the target system supports AltiVec instructions, the default action
+# for a test is 'run', otherwise it's 'compile'.
+global dg-do-what-default
+set save-dg-do-what-default ${dg-do-what-default}
+if { [check_vmx_hw_available ] } {
+  set dg-do-what-default run
+} else {
+  set dg-do-what-default compile
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c]] \
+	$DEFAULT_VMXCFLAGS
+
+# All done.
+dg-finish
+
+set dg-do-what-default ${save-dg-do-what-default}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-01.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-01.c
new file mode 100644
index 000000000..324e83e35
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-01.c
@@ -0,0 +1,25 @@
+#include <altivec.h>
+vector bool char
+g(vector unsigned char, vector bool char);
+
+vector bool char
+f(vector bool char b, vector unsigned char d) 
+{
+  vector bool char *p = &b;
+  *p = g(d,b);
+  return *p;
+}
+
+vector bool char b8;
+vector unsigned char u8;
+vector bool char
+g(vector unsigned char a, vector bool char b)
+{
+  return b8;
+}
+
+int main() 
+{ 
+  f(b8, u8);
+  return 0; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-02.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-02.c
new file mode 100644
index 000000000..4ddcc0c00
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-02.c
@@ -0,0 +1,34 @@
+#include <altivec.h>
+
+static vector bool char
+g(vector unsigned char, vector bool char);
+
+static int q(void);
+
+static vector bool char
+f(vector bool char b, vector unsigned char d) 
+{
+  vector bool char *p = &b;
+  *p = g(d,b);
+  return q() ? *p : b;
+}
+
+static vector bool char b8;
+static vector unsigned char u8;
+
+static vector bool char
+g(vector unsigned char a, vector bool char b)
+{
+  return b8;
+}
+
+static int q ()
+{
+  return 1;
+}
+
+int main() 
+{ 
+  f(b8, u8);
+  return 0; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-03.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-03.c
new file mode 100644
index 000000000..0972ac9a3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-03.c
@@ -0,0 +1,124 @@
+#include <altivec.h>
+extern vector unsigned char u8(void);
+extern vector signed char s8(void);
+extern vector bool char b8(void);
+extern vector unsigned short u16(void);
+extern vector signed short s16(void);
+extern vector bool short b16(void);
+extern vector unsigned int u32(void);
+extern vector signed int s32(void);
+extern vector bool int b32(void);
+extern vector float f32(void);
+extern vector pixel p16(void);
+
+extern void g(vector unsigned char, ...);
+
+void
+f(vector unsigned char u8p, vector signed char s8p, vector bool char b8p,
+  vector unsigned short u16p, vector signed short s16p,
+  vector bool short b16p, vector unsigned int u32p, 
+  vector signed int s32p, vector bool int b32p,
+  vector float f32p, vector pixel p16p)
+{
+  vector unsigned char u8l = u8();
+  vector signed char s8l = s8();
+  vector bool char b8l = b8();
+  vector unsigned short u16l = u16();
+  vector signed short s16l = s16();
+  vector bool short b16l = b16();
+  vector unsigned int u32l = u32();
+  vector signed int s32l = s32();
+  vector bool int b32l = b32();
+  vector float f32l = f32();
+  vector pixel p16l = p16();
+
+  g(u8l, s8l, b8l, u16l, s16l, b16l, u32l, s32l, b32l, f32l, p16l);
+}
+
+vector unsigned char
+u8(void)
+{
+  static vector unsigned char zero;
+  return zero;
+}
+
+vector signed char
+s8(void)
+{
+  static vector signed char zero;
+  return zero;
+}
+
+vector bool char
+b8(void)
+{
+  static vector bool char zero;
+  return zero;
+}
+
+vector unsigned short
+u16(void)
+{
+  static vector unsigned short zero;
+  return zero;
+}
+
+vector signed short
+s16(void)
+{
+  static vector signed short zero;
+  return zero;
+}
+
+vector bool short
+b16(void)
+{
+  static vector bool short zero;
+  return zero;
+}
+
+vector unsigned int
+u32(void)
+{
+  static vector unsigned int zero;
+  return zero;
+}
+
+vector signed int
+s32(void)
+{
+  static vector signed int zero;
+  return zero;
+}
+
+vector bool int
+b32(void)
+{
+  static vector bool int zero;
+  return zero;
+}
+
+vector float
+f32(void)
+{
+  static vector float zero;
+  return zero;
+}
+
+vector pixel
+p16(void)
+{
+  static vector pixel zero;
+  return zero;
+}
+
+void
+g(vector unsigned char a, ...)
+{
+}
+
+int main()
+{
+  f(u8(), s8(), b8(), u16(), s16(), b16(), u32(), s32(), b32(), f32(), p16());
+  return 0; 
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-04.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-04.c
new file mode 100644
index 000000000..44694c8a6
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-04.c
@@ -0,0 +1,80 @@
+#include <altivec.h>
+vector unsigned char
+permute_128(vector unsigned char input)
+{
+  vector unsigned char result, new_bit;
+
+  vector unsigned char select2 = ((vector unsigned char){2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2});
+  vector unsigned char select3 = ((vector unsigned char){4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4});
+  vector unsigned char select4 = ((vector unsigned char){8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8});
+  vector unsigned char select5 = ((vector unsigned char){16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16});
+  vector unsigned char select6 = ((vector unsigned char){32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32});
+  vector unsigned char select7 = ((vector unsigned char){64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64});
+  vector unsigned char select8 = ((vector unsigned char){128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128});
+
+  vector unsigned char control1
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control2
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control3
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control4
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control5
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control6
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control7
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char control8
+    = ((vector unsigned char){15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0});
+  vector unsigned char rotate1 = ((vector unsigned char){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1});
+  vector unsigned char rotate2 = ((vector unsigned char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  vector unsigned char rotate3 = ((vector unsigned char){5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5});
+  vector unsigned char rotate4 = ((vector unsigned char){7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7});
+  vector unsigned char rotate5 = ((vector unsigned char){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1});
+  vector unsigned char rotate6 = ((vector unsigned char){3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3});
+  vector unsigned char rotate7 = ((vector unsigned char){5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5});
+  vector unsigned char rotate8 = ((vector unsigned char){7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7});
+
+  result = vec_vperm(input, input, control1);
+  result = vec_rl(result, rotate1);
+
+  new_bit = vec_vperm(input, input, control2);
+  new_bit = vec_rl(new_bit, rotate2);
+  result = vec_sel(result, new_bit, select2);
+
+  new_bit = vec_vperm(input, input, control3);
+  new_bit = vec_rl(new_bit, rotate3);
+  result = vec_sel(result, new_bit, select3);
+
+  new_bit = vec_vperm(input, input, control4);
+  new_bit = vec_rl(new_bit, rotate4);
+  result = vec_sel(result, new_bit, select4);
+
+  new_bit = vec_vperm(input, input, control5);
+  new_bit = vec_rl(new_bit, rotate5);
+  result = vec_sel(result, new_bit, select5);
+
+  new_bit = vec_vperm(input, input, control6);
+  new_bit = vec_rl(new_bit, rotate6);
+  result = vec_sel(result, new_bit, select6);
+
+  new_bit = vec_vperm(input, input, control7);
+  new_bit = vec_rl(new_bit, rotate7);
+  result = vec_sel(result, new_bit, select7);
+
+  new_bit = vec_vperm(input, input, control8);
+  new_bit = vec_rl(new_bit, rotate8);
+  result = vec_sel(result, new_bit, select8);
+
+  return result;
+}
+
+int main()
+{
+  vector unsigned char input
+    = ((vector unsigned char){0,1,2,4,8,16,32,64,128,0,1,2,4,8,16,32});
+  vector unsigned char result = permute_128(input);
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-05.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-05.c
new file mode 100644
index 000000000..80c13dcf0
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/x-05.c
@@ -0,0 +1,82 @@
+#include <altivec.h>
+
+static vector unsigned char select2 = {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};
+static vector unsigned char select3 = {4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4};
+static vector unsigned char select4 = {8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8};
+static vector unsigned char select5 = {16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16};
+static vector unsigned char select6 = {32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32};
+static vector unsigned char select7 = {64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64};
+static vector unsigned char select8 = {128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128};
+
+static vector unsigned char control1
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control2
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control3
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control4
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control5
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control6
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control7
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char control8
+  = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
+static vector unsigned char rotate1 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static vector unsigned char rotate2 = {3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3};
+static vector unsigned char rotate3 = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
+static vector unsigned char rotate4 = {7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
+static vector unsigned char rotate5 = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static vector unsigned char rotate6 = {3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3};
+static vector unsigned char rotate7 = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
+static vector unsigned char rotate8 = {7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
+
+static vector unsigned char permute_128(vector unsigned char input)
+{
+  vector unsigned char result, new_bit;
+
+  /* and now the code */
+  result = vec_vperm(input, input, control1);
+  result = vec_rl(result, rotate1);
+
+  new_bit = vec_vperm(input, input, control2);
+  new_bit = vec_rl(new_bit, rotate2);
+  result = vec_sel(result, new_bit, select2);
+
+  new_bit = vec_vperm(input, input, control3);
+  new_bit = vec_rl(new_bit, rotate3);
+  result = vec_sel(result, new_bit, select3);
+
+  new_bit = vec_vperm(input, input, control4);
+  new_bit = vec_rl(new_bit, rotate4);
+  result = vec_sel(result, new_bit, select4);
+
+  new_bit = vec_vperm(input, input, control5);
+  new_bit = vec_rl(new_bit, rotate5);
+  result = vec_sel(result, new_bit, select5);
+
+  new_bit = vec_vperm(input, input, control6);
+  new_bit = vec_rl(new_bit, rotate6);
+  result = vec_sel(result, new_bit, select6);
+
+  new_bit = vec_vperm(input, input, control7);
+  new_bit = vec_rl(new_bit, rotate7);
+  result = vec_sel(result, new_bit, select7);
+
+  new_bit = vec_vperm(input, input, control8);
+  new_bit = vec_rl(new_bit, rotate8);
+  result = vec_sel(result, new_bit, select8);
+
+  return result;
+}
+
+int main()
+{
+  vector unsigned char input
+    = {0,1,2,4,8,16,32,64,128,0,1,2,4,8,16,32};
+  vector unsigned char result = permute_128(input);
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/yousufi-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/yousufi-1.c
new file mode 100644
index 000000000..eed4be3d1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/yousufi-1.c
@@ -0,0 +1,15 @@
+#include "harness.h"
+
+/* Tests the vec_ctu function, which converts a vector of floats to a vector
+   of unsigned ints.  In powerpc-eabisim-run ver. moto-1.0, vec_ctu produces
+   strange output for input values of less than ~.0039. -Umair */
+
+static void test()
+{
+  vector float input = ((vector float){0.003,0.003,0.003,0.003});
+  vector unsigned int output;
+  vector unsigned int expect = ((vector unsigned int){0,0,0,0});
+
+  output = vec_ctu(input, 1);
+  check(vec_all_eq(output, expect), "vec_ctu");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/zero-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/zero-1.c
new file mode 100644
index 000000000..637351cc5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/zero-1.c
@@ -0,0 +1,13 @@
+#include "harness.h"
+
+static vector unsigned int funny()
+{
+  vector unsigned int a;
+  return vec_andc(vec_add(a,a),vec_add(a,a));
+}
+
+static void test()
+{
+  static vector unsigned int zero;
+  check(vec_all_eq(funny(), zero), "funny");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/zero.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/zero.c
new file mode 100644
index 000000000..9a337e6e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vmx/zero.c
@@ -0,0 +1,100 @@
+#include "harness.h"
+
+vector signed short zs16() { return ((vector signed short){0,0,0,0,0,0,0,0}); }
+vector signed short s16ss() { vector signed short a; return vec_subs(a,a); }
+vector signed short s16s() { vector signed short a; return vec_sub(a,a); }
+vector signed short s16x() { vector signed short a; return vec_xor(a,a); }
+vector signed short s16a() { vector signed short a; return vec_andc(a,a); }
+
+vector unsigned short zu16() { return ((vector unsigned short){0,0,0,0,0,0,0,0}); }
+vector unsigned short u16ss() { vector unsigned short a; return vec_subs(a,a); }
+vector unsigned short u16s() { vector unsigned short a; return vec_sub(a,a); }
+vector unsigned short u16x() { vector unsigned short a; return vec_xor(a,a); }
+vector unsigned short u16a() { vector unsigned short a; return vec_andc(a,a); }
+
+vector signed int zs32() { return ((vector signed int){0,0,0,0}); }
+vector signed int s32ss() { vector signed int a; return vec_subs(a,a); }
+vector signed int s32s() { vector signed int a; return vec_sub(a,a); }
+vector signed int s32x() { vector signed int a; return vec_xor(a,a); }
+vector signed int s32a() { vector signed int a; return vec_andc(a,a); }
+
+vector unsigned int zu32() { return ((vector unsigned int){0,0,0,0}); }
+vector unsigned int u32ss() { vector unsigned int a; return vec_subs(a,a); }
+vector unsigned int u32s() { vector unsigned int a; return vec_sub(a,a); }
+vector unsigned int u32x() { vector unsigned int a; return vec_xor(a,a); }
+vector unsigned int u32a() { vector unsigned int a; return vec_andc(a,a); }
+
+vector signed char zs8() { return ((vector signed char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}); }
+vector signed char s8ss() { vector signed char a; return vec_subs(a,a); }
+vector signed char s8s() { vector signed char a; return vec_sub(a,a); }
+vector signed char s8x() { vector signed char a; return vec_xor(a,a); }
+vector signed char s8a() { vector signed char a; return vec_andc(a,a); }
+
+vector unsigned char zu8() { return ((vector unsigned char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}); }
+vector unsigned char u8ss() { vector unsigned char a; return vec_subs(a,a); }
+vector unsigned char u8s() { vector unsigned char a; return vec_sub(a,a); }
+vector unsigned char u8x() { vector unsigned char a; return vec_xor(a,a); }
+vector unsigned char u8a() { vector unsigned char a; return vec_andc(a,a); }
+
+vector pixel zp16() { return ((vector pixel){0,0,0,0,0,0,0,0}); }
+
+vector bool short zb16() { return ((vector bool short){0,0,0,0,0,0,0,0}); }
+
+vector bool short b16x() { vector bool short a; return vec_xor(a,a); }
+vector bool short b16a() { vector bool short a; return vec_andc(a,a); }
+vector bool int zb32() { return ((vector bool int){0,0,0,0}); }
+
+vector bool int b32x() { vector bool int a; return vec_xor(a,a); }
+vector bool int b32a() { vector bool int a; return vec_andc(a,a); }
+vector bool char zb8() { return ((vector bool char){0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}); }
+
+vector bool char b8x() { vector bool char a; return vec_xor(a,a); }
+vector bool char b8a() { vector bool char a; return vec_andc(a,a); }
+
+static void test()
+{
+  static vector unsigned int zerov;
+#define zcheck(val, tag) \
+  check(vec_all_eq((vector unsigned int)(val), zerov), tag)
+  
+  zcheck(zs16(), "zs16");
+  zcheck(s16ss(), "s16ss");
+  zcheck(s16s(), "s16s");
+  zcheck(s16x(), "s16x");
+  zcheck(s16a(), "s16a");
+  zcheck(zu16(), "zu16");
+  zcheck(u16ss(), "u16ss");
+  zcheck(u16s(), "u16s");
+  zcheck(u16x(), "u16x");
+  zcheck(u16a(), "u16a");
+  zcheck(zs32(), "zs32");
+  zcheck(s32ss(), "s32ss");
+  zcheck(s32s(), "s32s");
+  zcheck(s32x(), "s32x");
+  zcheck(s32a(), "s32a");
+  zcheck(zu32(), "zu32");
+  zcheck(u32ss(), "u32ss");
+  zcheck(u32s(), "u32s");
+  zcheck(u32x(), "u32x");
+  zcheck(u32a(), "u32a");
+  zcheck(zs8(), "zs8");
+  zcheck(s8ss(), "s8ss");
+  zcheck(s8s(), "s8s");
+  zcheck(s8x(), "s8x");
+  zcheck(s8a(), "s8a");
+  zcheck(zu8(), "zu8");
+  zcheck(u8ss(), "u8ss");
+  zcheck(u8s(), "u8s");
+  zcheck(u8x(), "u8x");
+  zcheck(u8a(), "u8a");
+  zcheck(zp16(), "zp16");
+  zcheck(zb16(), "zb16");
+  zcheck(b16x(), "b16x");
+  zcheck(b16a(), "b16a");
+  zcheck(zb32(), "zb32");
+  zcheck(b32x(), "b32x");
+  zcheck(b32a(), "b32a");
+  zcheck(zb8(), "zb8");
+  zcheck(b8x(), "b8x");
+  zcheck(b8a(), "b8a");
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/void-cast-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/void-cast-1.c
new file mode 100644
index 000000000..bd4e7b3bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/void-cast-1.c
@@ -0,0 +1,11 @@
+/* Don't warn where the left-hand side of a comma expression is a
+   comma expression whose right-hand side is cast to void.  Bug
+   21159.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+
+int a, b, c, d;
+int e(void) { return (void)a, b; }
+int f(void) { return (void)a, (void)b, c; }
+int g(void) { return (void)a, (void)b, (void)c, d; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/void-cast-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/void-cast-2.c
new file mode 100644
index 000000000..7accebfb7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/void-cast-2.c
@@ -0,0 +1,8 @@
+/* Test further cases of warnings for comma expressions, with and
+   without casts to void.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-options "-Wall" } */
+int a, b, c, d;
+int e(void) { return (char)a, b; } /* { dg-warning "left-hand operand of comma expression has no effect" } */
+int f(void) { return (a ? (void)b : (void)c), d; } /* { dg-warning "left-hand operand of comma expression has no effect" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/volatile1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/volatile1.c
new file mode 100644
index 000000000..61a3979b7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/volatile1.c
@@ -0,0 +1,9 @@
+/* PR c/12553: we were erroneously setting TREE_SIDE_EFFECTS on &y, which
+   confused tree-ssa.  */
+
+void f()
+{
+  int x;
+  volatile int y;
+  &x == &y;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/volatile2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/volatile2.c
new file mode 100644
index 000000000..4bfc441c8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/volatile2.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple -fdump-tree-optimized" } */
+
+struct GTeth_desc
+{
+  unsigned ed_cmdsts;
+};
+struct GTeth_softc
+{
+  struct GTeth_desc txq_desc[32];
+};
+
+void foo(struct GTeth_softc *sc)
+{
+  /* Verify that we retain the cast to (volatile struct GTeth_desc *)
+     after gimplification and that we keep the volatileness on the
+     store until after optimization.  */
+  volatile struct GTeth_desc *p = &sc->txq_desc[0];
+  p->ed_cmdsts = 0;
+}
+
+/* { dg-final { scan-tree-dump "\\(volatile struct GTeth_desc \\*\\) D" "gimple" } } */
+/* { dg-final { scan-tree-dump "{v}" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "gimple" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/initpri1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/initpri1.c
new file mode 100644
index 000000000..555bffe73
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/initpri1.c
@@ -0,0 +1,19 @@
+/* On VxWorks, in RTP mode, constructors and destructors go in named
+   sections.  The section names must include the initialization
+   priority, even for constructors and destructors with the default
+   priority.  */
+
+/* The selector below excludes VxWorks AE because AE does not support
+   RTP mode.  */
+/* { dg-do compile { target { *-*-vxworks* && { ! *-*-vxworksae* } } } } */
+/* { dg-options "-mrtp" } */
+/* { dg-final { scan-assembler "ctors\.00000" } } */
+/* { dg-final { scan-assembler "dtors\.00000" } } */
+
+volatile int i;
+
+void c1 () __attribute__((constructor));
+void c1 () { ++i; }
+
+void d1 () __attribute__((destructor));
+void d1 () { --i; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/initpri2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/initpri2.c
new file mode 100644
index 000000000..7f483efad
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/initpri2.c
@@ -0,0 +1,15 @@
+/* On VxWorks, in kernel mode, there is no support for .ctors/.dtors.
+   Instead, initialization is handled by munch.  */
+
+/* { dg-do compile { target vxworks_kernel } } */
+/* { dg-final { scan-assembler-not "\.ctors" } } */
+/* { dg-final { scan-assembler-not "\.dtors" } } */
+
+volatile int i;
+
+void c1 () __attribute__((constructor));
+void c1 () { ++i; }
+
+void d1 () __attribute__((destructor));
+void d1 () { --i; }
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/vxworks.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/vxworks.exp
new file mode 100644
index 000000000..8526c5866
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/vxworks/vxworks.exp
@@ -0,0 +1,36 @@
+#   Copyright (C) 1997, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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/*.\[cSi\]]] \
+	"" $DEFAULT_CFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/warn-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/warn-1.c
new file mode 100644
index 000000000..6db4ae5cd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/warn-1.c
@@ -0,0 +1,16 @@
+/* The compiler used to say passing arg 0 of, which is wrong.  */
+/* Radar 3069179 */
+
+/* { dg-options "-O3" } */
+
+static void foo (p)
+     int p;
+{
+}
+
+void bar (void)
+{
+  void *vp;
+
+  foo (vp);	/* { dg-bogus "passing argument 1 of" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/warn-addr-cmp.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/warn-addr-cmp.c
new file mode 100644
index 000000000..6ad94731a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/warn-addr-cmp.c
@@ -0,0 +1,79 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "-Waddress" } */
+/* Warning when addr convert to bool always gives known result.
+   Ada/Pascal programmers sometimes write 0-param functions without
+   (), and might as well warn on variables, too.  */
+
+int func (void);
+extern int var;
+int weak_func (void) __attribute__ ((weak));
+extern int weak_var __attribute__ ((weak));
+
+int
+test_func_cmp (void)
+{
+  if (func)      /* { dg-warning "the address of 'func'" } */
+    return 1;
+  if (!func)     /* { dg-warning "the address of 'func'" } */
+    return 1;
+  if (&var)     /* { dg-warning "the address of 'var'" } */
+    return 1;
+  if (!&var)     /* { dg-warning "the address of 'var'" } */
+    return 1;
+  if (weak_func)
+    return 1;
+  if (!weak_func)
+    return 1;
+  if (&weak_var)
+    return 1;
+  if (!&weak_var)
+    return 1;
+  return 0;
+}
+
+/* Test equality with 0 on the right hand side.  */
+int
+test_func_cmp_rhs_zero (void)
+{
+  if (func == 0)     /* { dg-warning "the address of 'func'" } */
+    return 1;
+  if (func != 0)     /* { dg-warning "the address of 'func'" } */
+    return 1;
+  if (&var == 0)     /* { dg-warning "the address of 'var'" } */
+    return 1;
+  if (&var != 0)     /* { dg-warning "the address of 'var'" } */
+    return 1;
+  if (weak_func == 0)
+    return 1;
+  if (weak_func != 0)
+    return 1;
+  if (&weak_var == 0)
+    return 1;
+  if (&weak_var != 0)
+    return 1;
+  return 0;
+}
+
+/* Test equality with 0 on the left hand side.  */
+int
+test_func_cmp_lhs_zero (void)
+{
+  if (0 == func)     /* { dg-warning "the address of 'func'" } */
+    return 1;
+  if (0 != func)     /* { dg-warning "the address of 'func'" } */
+    return 1;
+  if (0 == &var)     /* { dg-warning "the address of 'var'" } */
+    return 1;
+  if (0 != &var)     /* { dg-warning "the address of 'var'" } */
+    return 1;
+  if (0 == weak_func)
+    return 1;
+  if (0 != weak_func)
+    return 1;
+  if (0 == &weak_var)
+    return 1;
+  if (0 != &weak_var)
+    return 1;
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wcaselabel-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wcaselabel-1.c
new file mode 100644
index 000000000..6f673dfaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wcaselabel-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-w" } */
+
+
+int foo(int x)
+{
+  switch(x)
+  {
+
+  case 0 % 0:	 /* { dg-error "case label does not reduce to an integer constant" } */
+    return 1;
+  default:
+    return 2;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wchar_t-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wchar_t-1.c
new file mode 100644
index 000000000..8e22ece3c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wchar_t-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target wchar } } */
+/* { dg-options "-Wall" } */
+
+/* Compile with -Wall to get a warning if built-in and system wchar_t don't
+   match.  */
+
+#define _STDDEF_H
+#include <wchar.h>
+
+__WCHAR_TYPE__ __wc_t__;
+wchar_t *wc_t_p;
+
+void
+wct (void)
+{
+  wc_t_p = &__wc_t__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wchar_t-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wchar_t-2.c
new file mode 100644
index 000000000..95ddca0e5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wchar_t-2.c
@@ -0,0 +1,6 @@
+/* { dg-options "-fshort-wchar" } */
+/* Check that "-fshort-wchar" makes wchar_t the same size as "unsigned
+   short".  */
+
+extern int i[sizeof (L'a')];
+int i[sizeof (unsigned short)];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/typeof-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/typeof-2.c
new file mode 100644
index 000000000..5d97dc5c2
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/typeof-2.c
@@ -0,0 +1,46 @@
+/* Test typeof with __asm redirection. */
+/* { dg-do compile } */
+/* -mlongcall will cause us to place &baz3 in the CTR register.  */
+/* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-options "-O2" } */
+
+extern int foo1 (int x) __asm ("baz1");
+int bar1 (int x) { return x; }
+extern __typeof (bar1) foo1 __attribute ((weak, alias ("bar1")));
+
+extern int foo2 (int x) __attribute__ ((const));
+extern __typeof (foo2) foo2 __asm ("baz2");
+int bar2 (int x)
+{
+  return foo2 (x) + foo2 (x) + foo2 (x) + foo2 (x) + foo2 (x) + foo2 (x);
+}
+
+extern int foo3 (int x);
+extern __typeof (foo3) foo3 __asm ("baz3");
+int bar3 (int x)
+{
+  return foo3 (x) + foo3 (x) + foo3 (x) + foo3 (x) + foo3 (x) + foo3 (x);
+}
+
+// { dg-final { scan-assembler-not "foo1" } }
+// { dg-final { scan-assembler "baz1" } }
+// { dg-final { scan-assembler-not "foo2" } }
+// { dg-final { scan-assembler "baz2" } }
+// { dg-final { scan-assembler-not "baz2.*baz2.*baz2.*baz2.*baz2.*baz2" } }
+// { dg-final { scan-assembler-not "foo3" } }
+// SH targets put the funtion address into a constant pool and / or register,
+// so it does not appear repeated (as much as expected) in the assembler.
+// { dg-final { global target_triplet } }
+// { dg-final { if [string match sh-*-* $target_triplet ] {return} } }
+// { dg-final { if [string match {sh[elb1-9]*-*-*} $target_triplet ] {return} } }
+// Likewise for S/390 targets
+// { dg-final { if [string match s390*-*-* $target_triplet ] {return} } }
+// Likewise for CRIS targets.
+// { dg-final { if [string match cris-*-* $target_triplet ] {return} } }
+// { dg-final { if [string match crisv32-*-* $target_triplet ] {return} } }
+// Likewise for m68k targets.
+// { dg-final { if [string match fido-*-* $target_triplet ] {return} } }
+// { dg-final { if [string match m68k-*-* $target_triplet ] {return} } }
+// { dg-final { scan-assembler "baz3.*baz3.*baz3.*baz3.*baz3.*baz3" } }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-1.c
new file mode 100644
index 000000000..078c3ef36
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-1.c
@@ -0,0 +1,51 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?a" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?b" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?c" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?d" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?e" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?g" } } */
+/* { dg-final { scan-assembler-not "weak\[^ \t\]*\[ \t\]_?i" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?j" } } */
+
+#pragma weak a
+int a;
+
+int b;
+#pragma weak b
+
+#pragma weak c
+extern int c;
+int c;
+
+extern int d;
+#pragma weak d
+int d;
+
+#pragma weak e
+void e(void) { }
+
+#if 0
+/* This permutation is illegal.  */
+void f(void) { }
+#pragma weak f
+#endif
+
+#pragma weak g
+int g = 1;
+
+#if 0
+/* This permutation is illegal.  */
+int h = 1;
+#pragma weak h
+#endif
+
+#pragma weak i
+extern int i;
+
+#pragma weak j
+extern int j;
+int use_j() { return j; }
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-10.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-10.c
new file mode 100644
index 000000000..f39fbc4bb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-10.c
@@ -0,0 +1,13 @@
+/* Test for #pragma weak where the weak alias symbol isn't declared,
+   although the symbol it is an alias for is defined in the
+   translation unit.  Bug 7544.  */
+/* Origin: Joseph Myers <joseph@codesourcery.com> */
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?bar1" } } */
+
+#pragma weak bar1 = foo1
+void foo1 (void) {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-11.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-11.c
new file mode 100644
index 000000000..c20135a3a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-11.c
@@ -0,0 +1,10 @@
+/* PR 19031 */
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-options "-funit-at-a-time" } */
+
+/* { dg-final { scan-assembler "xyzzy" } } */
+
+static const int local = 1; 
+#pragma weak xyzzy = local
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-12.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-12.c
new file mode 100644
index 000000000..72cc1445e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-12.c
@@ -0,0 +1,17 @@
+/* Test for #pragma weak with declaration not at file scope.  */
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?foo" } } */
+
+#pragma weak foo
+
+int
+main (void)
+{
+  extern int foo (void);
+  if (&foo)
+    return foo ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-13.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-13.c
new file mode 100644
index 000000000..15106a534
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-13.c
@@ -0,0 +1,13 @@
+/* Test for weak aliases with multiple declarations.  Sun assembler
+   rejects multiple weak alias definitions in the output.  */
+/* { dg-do assemble } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-options "" } */
+
+#pragma weak foo = _foo
+
+extern int foo;
+extern int foo;
+
+int _foo = 4;
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-14.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-14.c
new file mode 100644
index 000000000..33c7933f1
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-14.c
@@ -0,0 +1,34 @@
+// { dg-do run }
+// { dg-require-weak "" }
+// { dg-require-alias "" }
+// { dg-options "-O2 -fno-common" }
+
+// Copyright 2005 Free Software Foundation, Inc.
+// Contributed by Alexandre Oliva <aoliva@redhat.com>
+
+// PR middle-end/24295
+
+// The unit-at-a-time call graph code used to fail to emit variables
+// without external linkage that were only used indirectly, through
+// aliases.  We might then get linker failures because the static
+// variable was not defined, or run-time errors because the weak alias
+// ended up pointing somewhere random.
+
+#include <stdlib.h>
+
+static unsigned long lv1 = 0xdeadbeefUL;
+#pragma weak Av1a = lv1
+extern unsigned long Av1a;
+
+static unsigned long lf1(void) { return 0x510bea7UL; }
+#pragma weak Af1a = lf1
+extern unsigned long Af1a(void);
+
+int main (void) {
+  if (! &Av1a
+      || ! &Af1a
+      || Av1a != 0xdeadbeefUL
+      || Af1a() != 0x510bea7UL)
+    abort ();
+  exit (0);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-15.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-15.c
new file mode 100644
index 000000000..2218ca4a7
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-15.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?a" } } */
+/* { dg-final { scan-assembler-not "weak\[^ \t\]*\[ \t\]_?b" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?c" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?d" } } */
+
+#pragma weak a
+extern char a[];
+
+char *user_a(void)
+{
+  return a+1;
+}
+
+int x;
+int extern inline b(int y)
+{
+  return x+y;
+}
+
+extern int b(int y);
+
+int user_b(int z)
+{
+  return b(z);
+}
+
+#pragma weak c
+extern int c;
+
+int *user_c = &c;
+
+#pragma weak d
+extern char d[];
+
+char *user_d = &d[1];
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-16.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-16.c
new file mode 100644
index 000000000..3bcf3885d
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-16.c
@@ -0,0 +1,21 @@
+/* From PR37280.  */
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common -Os" } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?kallsyms_token_index" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?kallsyms_token_table" } } */
+
+extern int kallsyms_token_index[] __attribute__((weak));
+extern int kallsyms_token_table[] __attribute__((weak));
+void kallsyms_expand_symbol(int *result)
+{
+  int len = *result;
+  int *tptr;
+  while(len) {
+    tptr = &kallsyms_token_table[ kallsyms_token_index[*result] ];
+    len--;
+    while (*tptr) tptr++;
+    *tptr = 1;
+  }
+ *result = 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-2.c
new file mode 100644
index 000000000..973f4c216
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-2.c
@@ -0,0 +1,47 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1a" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1b" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1c" } } */
+/* { dg-final { scan-assembler-not "weak\[^ \t\]*\[ \t\]_?ffoo1d" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1e" } } */
+
+/* test function addresses with #pragma weak */
+
+#pragma weak ffoo1a
+extern void * ffoo1a (void);
+void * foo1a (void)
+{
+  return (void *)ffoo1a;
+}
+
+extern void * ffoo1b (void);
+#pragma weak ffoo1b
+void * foo1b (void)
+{
+  return (void *)ffoo1b;
+}
+
+extern void * ffoo1c (void);
+void * foo1c (void)
+{
+  return (void *)ffoo1c;
+}
+#pragma weak ffoo1c
+
+
+int ffoo1d (void);
+#pragma weak ffoo1d
+
+
+extern void * ffoo1e (void);
+#pragma weak ffoo1e
+void * foo1e (void)
+{
+  if (ffoo1e)
+    ffoo1e ();
+  return 0;
+}
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-3.c
new file mode 100644
index 000000000..748bd236c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-3.c
@@ -0,0 +1,73 @@
+/* { dg-do compile } */
+/* { dg-require-alias "" } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common -Waddress" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1a" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1b" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1c" } } */
+/* { dg-final { scan-assembler-not "weak\[^ \t\]*\[ \t\]_?ffoo1d" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1e" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1f" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?ffoo1g" } } */
+
+/* test function addresses with __attribute__((weak)) */
+
+extern void * ffoo1a (void) __attribute__((weak));
+extern void * ffoo1a (void);
+void * foo1a (void)
+{
+  return (void *)ffoo1a;
+}
+
+
+extern void * ffoo1b (void);
+extern void * ffoo1b (void) __attribute__((weak));
+void * foo1b (void)
+{
+  return (void *)ffoo1b;
+}
+
+
+extern void * ffoo1c (void);  
+void * foo1c (void)
+{
+  return (void *)ffoo1c;
+}
+extern void * ffoo1c (void) __attribute__((weak));
+
+
+int ffoo1d (void);
+int ffoo1d (void) __attribute__((weak));
+
+
+extern void * ffoo1e (void);
+extern void * ffoo1e (void)  __attribute__((weak));
+void * foo1e (void)
+{
+  if (ffoo1e)
+    ffoo1e ();
+  return 0;
+}
+
+
+extern void * ffoo1f (void);    
+void * foo1f (void)
+{
+  if (ffoo1f) /* { dg-warning "" } */
+    ffoo1f ();
+  return 0;
+}
+void * ffoox1f (void) { return (void *)0; }
+extern void * ffoo1f (void)  __attribute__((weak, alias ("ffoox1f")));
+
+
+extern void * ffoo1g (void);
+void * ffoox1g (void) { return (void *)0; }
+extern void * ffoo1g (void)  __attribute__((weak, alias ("ffoox1g")));
+void * foo1g (void)
+{
+  if (ffoo1g)
+    ffoo1g ();
+  return 0;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-4.c
new file mode 100644
index 000000000..cd8a1e912
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-4.c
@@ -0,0 +1,105 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1a" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1b" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1c" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1d" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1e" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1f" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1g" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1h" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1i" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1j" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1k" } } */
+
+/* test variable addresses with #pragma weak */
+
+#pragma weak vfoo1a
+extern int vfoo1a;
+void * foo1a (void)
+{
+  return (void *)&vfoo1a;
+}
+
+
+extern int vfoo1b;
+#pragma weak vfoo1b
+void * foo1b (void)
+{
+  return (void *)&vfoo1b;
+}
+
+
+extern int vfoo1c;
+void * foo1c (void)
+{
+  return (void *)&vfoo1c;
+}
+#pragma weak vfoo1c
+
+
+#pragma weak vfoo1d
+int vfoo1d;
+void * foo1d (void)
+{
+  return (void *)&vfoo1d;
+}
+
+
+int vfoo1e;
+#pragma weak vfoo1e
+void * foo1e (void)
+{
+  return (void *)&vfoo1e;
+}
+
+
+int vfoo1f;
+void * foo1f (void)
+{
+  return (void *)&vfoo1f;
+}
+#pragma weak vfoo1f
+
+
+extern int vfoo1g;
+void * foo1g (void)
+{
+  return (void *)&vfoo1g;
+}
+#pragma weak vfoo1g
+int vfoo1g;
+
+
+extern int vfoo1h;
+void * foo1h (void)
+{
+  return (void *)&vfoo1h;
+}
+int vfoo1h;
+#pragma weak vfoo1h
+
+
+int vfoo1i;
+extern int vfoo1i;
+void * foo1i (void)
+{
+  return (void *)&vfoo1i;
+}
+#pragma weak vfoo1i
+
+
+extern int vfoo1j;
+int vfoo1j;
+void * foo1j (void)
+{
+  return (void *)&vfoo1j;
+}
+#pragma weak vfoo1j
+
+
+#pragma weak vfoo1k
+int vfoo1k = 1;
+
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-5.c
new file mode 100644
index 000000000..e82792af3
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-5.c
@@ -0,0 +1,109 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1a" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1b" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1c" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1d" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1e" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1f" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1g" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1h" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1i" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1j" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1k" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?vfoo1l" } } */
+
+/* test variable addresses with __attribute__ ((weak)) */
+
+extern int vfoo1a __attribute__((weak));
+extern int vfoo1a;
+void * foo1a (void)
+{
+  return (void *)&vfoo1a;
+}
+
+
+extern int vfoo1b;
+extern int vfoo1b __attribute__((weak));
+void * foo1b (void)
+{
+  return (void *)&vfoo1b;
+}
+
+
+extern int vfoo1c;  
+void * foo1c (void)
+{
+  return (void *)&vfoo1c;
+}
+extern int vfoo1c __attribute__((weak));
+
+
+extern int vfoo1d __attribute__((weak));
+int vfoo1d;
+void * foo1d (void)
+{
+  return (void *)&vfoo1d;
+}
+
+
+int vfoo1e;
+extern int vfoo1e __attribute__((weak));
+void * foo1e (void)
+{
+  return (void *)&vfoo1e;
+}
+
+
+int vfoo1f;
+void * foo1f (void)
+{
+  return (void *)&vfoo1f;
+}
+extern int vfoo1f __attribute__((weak));
+
+
+extern int vfoo1g;
+void * foo1g (void)
+{
+  return (void *)&vfoo1g;
+}
+int vfoo1g __attribute__((weak));
+
+
+extern int vfoo1h __attribute__((weak));
+void * foo1h (void)
+{
+  return (void *)&vfoo1h;
+}
+extern int vfoo1h __attribute__((weak));
+int vfoo1h;
+
+
+extern int vfoo1i __attribute__((weak));
+void * foo1i (void)
+{
+  return (void *)&vfoo1i;
+}
+extern int vfoo1i __attribute__((weak));
+extern int vfoo1i;
+
+
+extern int vfoo1j __attribute__((weak));
+void * foo1j (void)
+{
+  return (void *)&vfoo1j;
+}
+extern int vfoo1j;
+extern int vfoo1j __attribute__((weak));
+
+
+extern int vfoo1k __attribute__((weak));
+int vfoo1k = 1;
+
+
+int vfoox1l = 1;
+extern int vfoo1l __attribute__((weak, alias ("vfoox1l")));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-6.c
new file mode 100644
index 000000000..6fa0d66ff
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-6.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+
+extern void * foo (void);
+void * foo (void) { return (void *)foo; }
+/* { dg-error "function pointer" "pointer conversion" { target *-*-* } 5 } */
+#pragma weak foo
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-7.c
new file mode 100644
index 000000000..07c03bc97
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-7.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+
+extern void * foo (void);
+void * foo (void) { return (void *)foo; }
+/* { dg-error "function pointer" "pointer conversion" { target *-*-* } 5 } */
+extern void * foo (void) __attribute__((weak));
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-8.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-8.c
new file mode 100644
index 000000000..3de2e1e2f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-8.c
@@ -0,0 +1,8 @@
+/* { dg-do assemble } */
+/* { dg-require-weak "" } */
+
+__attribute__ ((weak)) int i;
+
+int f() {
+  return i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-9.c
new file mode 100644
index 000000000..abbd0201c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak-9.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-require-weak "" } */
+/* { dg-require-alias "" } */
+/* { dg-options "-fno-common" } */
+
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?f1" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?f2" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?f3" } } */
+/* { dg-final { scan-assembler "weak\[^ \t\]*\[ \t\]_?f4" } } */
+
+void notf1() { }
+void notf2() { }
+void notf3() { }
+void notf4() { }
+
+void f1() __attribute__((weak, alias("notf1")));
+void f2() __attribute__((alias("notf2"), weak));
+
+#pragma weak f3=notf3
+void f3();
+
+void f4();
+#pragma weak f4=notf4
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak.exp b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak.exp
new file mode 100644
index 000000000..5dde31edb
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/weak/weak.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 1997, 2003, 2007 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/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# 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"
+}
+
+dg-init
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] \
+    "" $DEFAULT_CFLAGS
+dg-finish
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-1.c
new file mode 100644
index 000000000..ac2ae8242
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-1.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2" } */
+
+void q(void);
+inline int t(void)
+{
+	int ret;
+	q();
+	ret = t();  /* We define sane semantics for inline keyword on recursive
+		       functions, so do not warn here.  */
+	q();
+	return ret;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-2.c
new file mode 100644
index 000000000..584c68fdd
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-2.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2" } */
+
+inline int q(void);		 /* { dg-warning "body not available" "" } */
+inline int t(void)
+{
+	return q();		 /* { dg-warning "called from here" "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-3.c
new file mode 100644
index 000000000..d586cba64
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-3.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2 --param max-inline-insns-single=1" } */
+
+void big (void);
+inline int q(void) /* { dg-warning "max-inline-insns-single" "" } */
+{
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+}
+inline int t (void)
+{
+	return q ();		 /* { dg-warning "called from here" "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-5.c
new file mode 100644
index 000000000..ad1fc4100
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-5.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2 --param inline-unit-growth=0 --param large-unit-insns=0" } */
+
+void big (void);
+inline int q(void) /* { dg-warning "inline-unit-growth" } */
+{
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+}
+inline int q1(void)
+{
+	big();
+	big();
+	big();
+}
+int t (void)
+{
+ /* We allow one inlining over limit.  */
+	q1();
+	return q ();		 /* { dg-warning "called from here" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-6.c
new file mode 100644
index 000000000..4e22ce144
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-6.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2 --param large-function-growth=0 --param large-function-insns=1" } */
+
+void big (void);
+inline int q(void) /* { dg-warning "large-function-growth" } */
+{
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+	big();
+}
+inline int t (void)
+{
+	return q () + 1;	 /* { dg-warning "called from here" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-7.c
new file mode 100644
index 000000000..19262da7c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-7.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-Winline -O2" } */
+
+extern void *alloca (__SIZE_TYPE__);
+
+void big (void);
+inline void *q (void) /* { dg-warning "(function not inlinable|alloca)" } */
+{
+	return alloca (10);
+}
+inline void *t (void)
+{
+	return q ();		 /* { dg-warning "called from here" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-9.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-9.c
new file mode 100644
index 000000000..fddf5c68f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/winline-9.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Winline --param large-stack-frame=10 --param large-stack-frame-growth=2" } */
+
+int a,b;
+void test(char *);
+static inline
+int aa (void)
+{
+  char t[10];
+  test(t);
+}
+static inline
+int bb (void) /* { dg-warning "large-stack-frame" "" } */
+{
+  char t[100];
+  test(t);
+}
+
+t()
+{
+  if (a)
+    aa();
+  if (b)
+    bb(); 			/* { dg-warning "called from here" "" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wint_t-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wint_t-1.c
new file mode 100644
index 000000000..0574fb9a4
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wint_t-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile { target wchar } } */
+/* { dg-options "-Wall" } */
+
+/* Compile with -Wall to get a warning if built-in and system wint_t don't
+   match.  */
+
+#define _STDDEF_H
+#include <wchar.h>
+
+__WINT_TYPE__ __wi_t__;
+wint_t *wi_t_p;
+
+void
+wit (void)
+{
+  wi_t_p = &__wi_t__;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wself-assign-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wself-assign-1.c
new file mode 100644
index 000000000..19324a645
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wself-assign-1.c
@@ -0,0 +1,27 @@
+/* Test the self-assignemnt detection and warning.  */
+/* { dg-do compile } */
+/* { dg-options "-Wself-assign" } */
+
+struct Bar {
+  int b_;
+  int c_;
+};
+
+int g;
+
+int main()
+{
+  struct Bar *bar;
+  int x = x; /* { dg-warning "assigned to itself" } */
+  static int y;
+  struct Bar b_array[5];
+
+  b_array[x+g].b_ = b_array[x+g].b_; /* { dg-warning "assigned to itself" } */
+  g = g; /* { dg-warning "assigned to itself" } */
+  y = y; /* { dg-warning "assigned to itself" } */
+  bar->b_ = bar->b_; /* { dg-warning "assigned to itself" } */
+  x += 0; /* should not warn */
+  y -= 0; /* should not warn */
+  x /= x; /* should not warn */
+  y *= y; /* should not warn */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wself-assign-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wself-assign-2.c
new file mode 100644
index 000000000..d0f69cbaf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wself-assign-2.c
@@ -0,0 +1,24 @@
+/* Test how self-assignment detection handles constant-folding happening */
+/*   when parsing the RHS or the initializer.  */
+/* { dg-do compile } */
+/* { dg-options "-Wself-assign" } */
+
+struct Bar {
+  int b_;
+  float c_;
+};
+
+int g;
+
+int main()
+{
+  struct Bar *bar;
+  int x = x - 0; /* should not warn */
+  static int y;
+  struct Bar b_array[5];
+
+  b_array[x+g].b_ = b_array[x+g].b_ * 1; /* should no warn */
+  g = g + 0; /* should not warn */
+  y = y / 1; /* should not warn */
+  bar->b_ = bar->b_ - 0; /* should not warn  */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-aggr-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-aggr-init-1.c
new file mode 100644
index 000000000..f17531e8f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-aggr-init-1.c
@@ -0,0 +1,48 @@
+/* Test for -Wtraditional warnings on automatic aggregate initialization.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+struct foo
+{
+  int i;
+  long l;
+};
+
+struct foo f0 = { 0, 0 };
+static struct foo f1 = { 0, 0 };
+
+void
+testfunc1 ()
+{
+  struct foo f3 = { 0, 0 }; /* { dg-warning "traditional C rejects automatic" "automatic aggregate initialization" } */
+  static struct foo f4 = { 0, 0 };
+  
+  f3 = f4;
+
+  __extension__ ({
+    struct foo f5 = { 0, 0 }; /* { dg-bogus "traditional C rejects automatic" "__extension__ disables warnings" } */
+    f5.i = 0;
+  });
+
+  {
+    struct foo f6 = { 0, 0 }; /* { dg-warning "traditional C rejects automatic" "__extension__ reenables warnings" } */
+    f6.i = 0;
+  }
+}
+  
+# 35 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+struct foo f7 = { 0, 0 };
+static struct foo f8 = { 0, 0 };
+
+void
+testfunc2 ()
+{
+  struct foo f9 = { 0, 0 };
+  static struct foo f10 = { 0, 0 };
+  
+  f9 = f10;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-conversion-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-conversion-1.c
new file mode 100644
index 000000000..72094c218
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-conversion-1.c
@@ -0,0 +1,66 @@
+/* Test for -Wtraditional warnings on conversions by prototypes.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 4/09/2001.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+extern void foo_i (int);
+extern void foo_f (float);
+extern void foo_ld (long double);
+extern void foo_cd (__complex__ double);
+
+extern int i;
+extern float f;
+extern long double ld;
+extern __complex__ double cd;
+
+void
+testfunc1 ()
+{
+  foo_i (i);
+  foo_i (f); /* { dg-warning "as integer rather than floating" "prototype conversion warning" } */
+  foo_i (ld); /* { dg-warning "as integer rather than floating" "prototype conversion warning" } */
+  foo_i (cd); /* { dg-warning "as integer rather than complex" "prototype conversion warning" } */
+
+  foo_f (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
+  foo_f (f); /* { dg-warning "as 'float' rather than 'double'" "prototype conversion warning" } */
+  foo_f (ld); /* { dg-warning "as 'float' rather than 'double'" "prototype conversion warning" } */
+  foo_f (cd); /* { dg-warning "as floating rather than complex" "prototype conversion warning" } */
+
+  foo_ld (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
+  foo_ld (f); /* { dg-warning "as 'float' rather than 'double'" "small double" { target { "avr-*-*" } } } */
+  foo_ld (ld);/* { dg-warning "as 'float' rather than 'double'" "small long double" { target { "avr-*-*" } } } */
+  foo_ld (cd);/* { dg-warning "as floating rather than complex" "prototype conversion warning" } */
+
+  foo_cd (i); /* { dg-warning "as complex rather than integer" "prototype conversion warning" } */
+  foo_cd (f); /* { dg-warning "as complex rather than floating" "prototype conversion warning" } */
+  foo_cd (ld); /* { dg-warning "as complex rather than floating" "prototype conversion warning" } */
+  foo_cd (cd);
+}
+  
+# 54 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+void
+testfunc2 ()
+{
+  foo_i (i);
+  foo_i (f);
+  foo_i (ld);
+  foo_i (cd);
+
+  foo_f (i);
+  foo_f (f);
+  foo_f (ld);
+  foo_f (cd);
+
+  foo_ld (i);
+  foo_ld (f);
+  foo_ld (ld);
+  foo_ld (cd);
+
+  foo_cd (i);
+  foo_cd (f);
+  foo_cd (ld);
+  foo_cd (cd);
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-escape-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-escape-1.c
new file mode 100644
index 000000000..7f48de5e8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-escape-1.c
@@ -0,0 +1,22 @@
+/* Test for -Wtraditional warnings on escape characters.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+void
+testfunc ()
+{
+  char c;
+
+  c = '\a'; /* { dg-warning "the meaning of" "escaped character warning " } */
+  c = '\x2'; /* { dg-warning "the meaning of" "escaped character warning " } */
+  c = '\n';
+
+# 17 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  c = '\a';
+  c = '\x2';
+  c = '\n';
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-func-def-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-func-def-1.c
new file mode 100644
index 000000000..049e05b85
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-func-def-1.c
@@ -0,0 +1,204 @@
+/* Test for -Wtraditional warnings on ISO C function definitions.
+   Note, gcc should omit these warnings in system header files.
+   Origin: Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 6/30/2002.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+/* Test some simple cases.  */
+
+void f_void1 (void) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+void f_void2 ()
+{
+  return;
+}
+
+void f_int1 (int f) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+void f_int2 (f)
+     int f;
+{
+  return;
+}
+
+/* Test that we don't ever warn about nested functions.  */
+
+void f_int3 (int f) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  void f3a (void) { return; }
+  void f3b () { return; }
+  void f3c (int f) { return; }
+  void f3d (f) int f; { return; }
+  void f3e (const char *f, ...) { return; }
+  return;
+}
+
+void f_int4 (int f) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  void f4a (void) { return; }
+  void f4b () { return; }
+  void f4c (int f) { return; }
+  void f4d (f) int f; { return; }
+  void f4e (const char *f, ...) { return; }
+  auto f4f (void) { return 0; }
+  return;
+}
+
+void f_int5 (f)
+     int f;
+{
+  void f5a (void) { return; }
+  void f5b () { return; }
+  void f5c (int f) { return; }
+  void f5d (f) int f; { return; }
+  void f5e (const char *f, ...) { return; }
+  return;
+}
+
+void f_int6 (f)
+     int f;
+{
+  void f6a (void) { return; }
+  void f6b () { return; }
+  void f6c (int f) { return; }
+  void f6d (f) int f; { return; }
+  void f6e (const char *f, ...) { return; }
+  auto f6f (void) { return 0; }
+  return;
+}
+
+/* Test that prototypes are silently accepted and function definitions
+   are still warned about.  */
+
+extern void f_int_p1 (int);
+void f_int_p1 (int f) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+extern void f_int_p2 (int f);
+void f_int_p2 (int f) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+extern void f_int_p3 (int);
+void f_int_p3 (f)
+     int f;
+{
+  return;
+}
+
+extern void f_int_p4 (int f);
+void f_int_p4 (f)
+     int f;
+{
+  return;
+}
+
+extern void f_void_p1 ();
+void f_void_p1 (void) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+extern void f_void_p2 (void);
+void f_void_p2 (void) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+extern void f_blank_p1 ();
+void f_blank_p1 ()
+{
+  return;
+}
+
+extern void f_blank_p2 (void);
+void f_blank_p2 ()
+{
+  return;
+}
+
+/* Test some implicit int functions.  */
+
+f_impl1()
+{
+  return 0;
+}
+
+f_impl2(void) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return 0;
+}
+
+f_impl3(int f) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return 0;
+}
+
+/* Test stdarg functions.  */
+
+f_stdarg1(const char *s, ...) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return 0;
+}
+
+void f_stdarg2(const char *s, ...) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+extern void f_stdarg3(const char *, ...);
+void f_stdarg3(const char *s, ...) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+/* Test handling function pointer parameters.  */
+
+void f_fnptr1 (int f, int (*fp)(int));
+void f_fnptr1 (int f, int (*fp)(int)) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return;
+}
+
+void f_fnptr2 (int f, int (*fp)(int));
+void f_fnptr2 (f, fp)
+     int f;
+     int (*fp)(int);
+{
+  return;
+}
+
+/* Test for main.  */
+
+int
+main (int argc, char **argv) /* { dg-warning "traditional C rejects ISO C style" } */
+{
+  return 0;
+}
+
+# 182 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+void fsys1 (void)
+{
+  return;
+}
+
+void fsys2 (int f)
+{
+  return;
+}
+
+void fsys3 (const char *f, ...)
+{
+  return;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-int-type-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-int-type-1.c
new file mode 100644
index 000000000..d44165d90
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-int-type-1.c
@@ -0,0 +1,43 @@
+/* Test for -Wtraditional warnings on integer constant types.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Wtraditional" } */
+
+void
+testfunc ()
+{
+  long long i;
+  
+  /* Octal and hex values shouldn't issue -Wtraditional warnings. */
+  i = 0x80000000;
+  i = 0xFFFFFFFF;
+  i = 037777777777;
+
+  i = 0x8000000000000000;
+  i = 0xFFFFFFFFFFFFFFFF;
+  i = 01777777777777777777777;
+
+  /* Nor should values outside the range of (32-bit) unsigned long but
+     inside the range of long long.  [since -traditional has no long long,
+     we can pretend it worked the way it does in C99.]  */
+  i = 9223372036854775807;
+
+  /* But this one should, since it doesn't fit in long (long), but
+     does fit in unsigned long (long).  */
+  i = 18446744073709551615; /* { dg-warning "decimal constant|unsigned" "decimal constant" } */
+  
+# 29 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  i = 0x80000000;
+  i = 0xFFFFFFFF;
+  i = 037777777777;
+  
+  i = 0x8000000000000000;
+  i = 0xFFFFFFFFFFFFFFFF;
+  i = 01777777777777777777777;
+  
+  i = 9223372036854775807;
+  i = 18446744073709551615;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-label-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-label-1.c
new file mode 100644
index 000000000..78a4d6b0a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-label-1.c
@@ -0,0 +1,52 @@
+/* Test for -Wtraditional warnings on label conflicts with identifiers.
+   Note, gcc should omit these warnings in system header files.
+   Origin: Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/24/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+enum foo1 { a };
+struct foo2 { int i; };
+union foo3 { int j; };
+int foo4;
+typedef int foo5;
+
+void
+testfunc1 (foo6)
+     int foo6;
+{
+  int foo7;
+
+ foo1:
+ foo2:
+ foo3:
+ foo4: /* { dg-warning "traditional C lacks" "label conflicts with identifier" } */
+ foo5: /* { dg-warning "traditional C lacks" "label conflicts with identifier" } */
+ foo6: /* { dg-warning "traditional C lacks" "label conflicts with identifier" } */
+ foo7: /* { dg-warning "traditional C lacks" "label conflicts with identifier" } */
+ testfunc1: /* { dg-warning "traditional C lacks" "label conflicts with identifier" } */
+ a: /* { dg-warning "traditional C lacks" "label conflicts with identifier" } */
+ i:
+ j: ;
+}
+  
+# 32 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+void
+testfunc2 (foo6)
+     int foo6;
+{
+  int foo7;
+
+ foo1:
+ foo2:
+ foo3:
+ foo4:
+ foo5:
+ foo6:
+ foo7:
+ testfunc2:
+ a:
+ i:
+ j: ;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-static-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-static-1.c
new file mode 100644
index 000000000..318b2f32c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-static-1.c
@@ -0,0 +1,14 @@
+/* Test for -Wtraditional warnings on static/non-static mismatches.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu>  8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+static void testfunc1(void); /* { dg-message "note: previous declaration" } */
+void testfunc1() {} /* { dg-warning "non-static.*follows static" "non-static follows static" } */
+
+# 11 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+static void testfunc2(void);
+void testfunc2() {}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-strcat-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-strcat-1.c
new file mode 100644
index 000000000..730a929c5
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-strcat-1.c
@@ -0,0 +1,18 @@
+/* Test for -Wtraditional warnings on string concatenation.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+void
+testfunc ()
+{
+  const char *foo;
+  
+  foo = "hello" "hello"; /* { dg-warning "concatenation" "string concatenation" } */
+
+# 15 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  foo = "hello" "hello";
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-suffix-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-suffix-1.c
new file mode 100644
index 000000000..ed0b40ecf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-suffix-1.c
@@ -0,0 +1,35 @@
+/* Test for -Wtraditional warnings on integer constant suffixes.
+   Note, gcc should omit these warnings in system header files.
+   Origin: Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/24/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+void
+testfunc ()
+{
+  int i;
+  double f;
+
+  i = 1L;
+  i = 1l;
+  i = 1U; /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+  i = 1u; /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+  f = 1.0;
+  f = 1.0F; /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+  f = 1.0f; /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+  f = 1.0L; /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+  f = 1.0l; /* { dg-warning "traditional C rejects" "numeric constant suffix" } */
+ 
+# 24 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  i = 1L;
+  i = 1l;
+  i = 1U;
+  i = 1u;
+  f = 1.0;
+  f = 1.0F;
+  f = 1.0f;
+  f = 1.0L;
+  f = 1.0l;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-switch-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-switch-1.c
new file mode 100644
index 000000000..f0381bc5e
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-switch-1.c
@@ -0,0 +1,25 @@
+/* Test for -Wtraditional warnings on switch operands of type long.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+void
+testfunc (l)
+     long l;
+{
+  switch (l) /* { dg-warning "switch expression" "switch expression" } */
+  {
+  default:
+    break;
+  }
+
+# 17 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  switch (l)
+  {
+  default:
+    break;
+  }
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-unary-plus-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-unary-plus-1.c
new file mode 100644
index 000000000..aee892c53
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-unary-plus-1.c
@@ -0,0 +1,20 @@
+/* Test for -Wtraditional warnings on the unary plus operator.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+void
+testfunc ()
+{
+  int i;
+  
+  i = +1; /* { dg-warning "unary plus operator" "unary plus operator" } */
+  i = +i; /* { dg-warning "unary plus operator" "unary plus operator" } */
+  
+# 16 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  i = +1;
+  i = +i;
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-1.c
new file mode 100644
index 000000000..b6a814d7a
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-1.c
@@ -0,0 +1,25 @@
+/* Test for -Wtraditional warnings on union initialization.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 8/22/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+union foo
+{
+  int i;
+  long l;
+};
+
+void
+testfunc ()
+{
+  /* Note we only warn for nonzero initializers.  */
+  static union foo f1 = { 0 };
+  static union foo f2 = { 1 }; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+
+# 21 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  static union foo f3 = { 0 };
+  static union foo f4 = { 1 };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-2.c
new file mode 100644
index 000000000..bea26f1bf
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-2.c
@@ -0,0 +1,45 @@
+/* Test for -Wtraditional warnings on union initialization.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 9/11/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+union foo1
+{
+  float f;
+  int i;
+  long l;
+};
+
+union foo2
+{
+  int i;
+  float f;
+  long l;
+};
+
+void
+testfunc ()
+{
+  /* Note we only warn for nonzero initializers.  */
+  static union foo1 f1 = {0};
+  static union foo2 f2 = {0};
+  static union foo1 f3 = {1}; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+  static union foo2 f4 = {1}; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+  static union foo1 f5 = {0.0};
+  static union foo2 f6 = {0.0};
+  static union foo1 f7 = {1.0}; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+  static union foo2 f8 = {1.0}; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+
+# 35 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  static union foo1 b1 = {0};
+  static union foo2 b2 = {0};
+  static union foo1 b3 = {1};
+  static union foo2 b4 = {1};
+  static union foo1 b5 = {0.0};
+  static union foo2 b6 = {0.0};
+  static union foo1 b7 = {1.0};
+  static union foo2 b8 = {1.0};
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-3.c
new file mode 100644
index 000000000..407554a9c
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtr-union-init-3.c
@@ -0,0 +1,64 @@
+/* Test for -Wtraditional warnings on union initialization.
+   Note, gcc should omit these warnings in system header files.
+   By Kaveh R. Ghazi <ghazi@caip.rutgers.edu> 9/11/2000.  */
+/* { dg-do compile } */
+/* { dg-options "-Wtraditional" } */
+
+struct bar
+{
+  int i;
+  long j;
+};
+
+union foo
+{
+  struct bar b;
+  int i;
+  long l;
+};
+
+union foo2
+{
+  int i;
+  long l;
+};
+
+struct baz
+{
+  int a;
+  double b;
+  union foo c;
+};
+
+struct baz2
+{
+  int a;
+  double b;
+  union foo2 c;
+};
+
+void
+testfunc ()
+{
+  /* Note we only warn for nonzero initializers.  Xfail on substructures. */
+  static union foo f1 = {{0,0}}; /* { dg-bogus "traditional C rejects initialization of unions" "initialization of unions" { xfail *-*-* } } */
+  static union foo f2 = {{1,1}}; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+
+  static struct baz f3 = { 1, 2, {{0,0}} }; /* { dg-bogus "traditional C rejects initialization of unions" "initialization of unions" { xfail *-*-* } } */
+  static struct baz f4 = { 1, 2, {{1,1}} }; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+
+  static struct baz2 f5 = { 1, 2, {0} };
+  static struct baz2 f6 = { 1, 2, {1} }; /* { dg-warning "traditional C rejects initialization of unions" "initialization of unions" } */
+
+# 54 "sys-header.h" 3
+/* We are in system headers now, no -Wtraditional warnings should issue.  */
+
+  static union foo b1 = {{0,0}};
+  static union foo b2 = {{1,1}};
+
+  static struct baz b3 = { 1, 2, {{0,0}} };
+  static struct baz b4 = { 1, 2, {{1,1}} };
+
+  static struct baz2 b5 = { 1, 2, {0} };
+  static struct baz2 b6 = { 1, 2, {1} };
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wtypequal.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtypequal.c
new file mode 100644
index 000000000..9a7189929
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wtypequal.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+
+int *__restrict *p;
+void f(void)
+{
+  __typeof(*p) *q = p; /* { dg-bogus "discards qualifiers" } */
+}
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-1.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-1.c
new file mode 100644
index 000000000..c8f21078b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-1.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -Wvla" } */
+
+extern void 
+func (int i, int array[i]); /* { dg-warning "variable length array 'array' is used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-2.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-2.c
new file mode 100644
index 000000000..d811a112f
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-2.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Wvla" } */
+
+extern void 
+func (int i, int array[i]); /* { dg-warning "variable length array 'array' is used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-3.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-3.c
new file mode 100644
index 000000000..45132fa6b
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-3.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -std=c89 -Wvla" } */
+
+extern void 
+func (int i, int array[i]); /* { dg-error "ISO C90 forbids variable.* array 'array'" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-4.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-4.c
new file mode 100644
index 000000000..8c15292ed
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-4.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -std=c99 -Wvla" } */
+
+extern void 
+func (int i, int array[i]); /* { dg-warning "variable length array 'array' is used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-5.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-5.c
new file mode 100644
index 000000000..919b8dc20
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-5.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -std=c89 -Wno-vla" } */
+
+extern void 
+func (int i, int array[i]);
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-6.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-6.c
new file mode 100644
index 000000000..f21435b02
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-6.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c89 -Wvla" } */
+
+extern void 
+func (int i, int [i]); /* { dg-warning "variable length array is used" } */
diff --git a/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-7.c b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-7.c
new file mode 100644
index 000000000..4c264f0d8
--- /dev/null
+++ b/gcc-4.4.3/gcc/testsuite/gcc.dg/wvla-7.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-pedantic-errors -std=c89 -Wvla" } */
+
+extern void 
+func (int i, int [i]); /* { dg-error "ISO C90 forbids variable" } */