obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

18 files changed, 289 insertions, 0 deletions

diff --git a/gcc/testsuite/g++.dg/compat/init/array5_main.C b/gcc/testsuite/g++.dg/compat/init/array5_main.C
new file mode 100644
index 000000000..96b2cc4b1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/array5_main.C
@@ -0,0 +1,14 @@
+// Copyright (C) 2002 Free Software Foundation
+// Contributed by Kriang Lerdsuwanakij <lerdsuwa@users.sourceforge.net>
+// Split into pieces for binary compatibility testing October 2002
+
+// Incorrect construction and destruction of multi-dimensional
+// array of class.
+
+extern void array5_x (void);
+
+int
+main ()
+{
+  array5_x ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/array5_x.C b/gcc/testsuite/g++.dg/compat/init/array5_x.C
new file mode 100644
index 000000000..dc138772c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/array5_x.C
@@ -0,0 +1,33 @@
+extern "C" void abort (void);
+
+extern int count;
+extern int num;
+
+struct A
+{
+  A();
+  ~A();
+};
+
+struct Array
+{
+  A array[2][2][2];
+};
+
+void
+array5_x ()
+{
+  for (num = 0; num <= 8; ++num)
+    {
+      count = 0;
+      try
+	{
+	  Array A;
+	}
+      catch (...)
+        {
+	}
+      if (count != 0)
+	abort();
+    }
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/array5_y.C b/gcc/testsuite/g++.dg/compat/init/array5_y.C
new file mode 100644
index 000000000..64b295ed5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/array5_y.C
@@ -0,0 +1,20 @@
+int count;
+int num;
+
+struct A
+{
+  A();
+  ~A();
+};
+
+A::A()
+{
+  if (count == num)
+    throw "";
+  count++;
+}
+
+A::~A()
+{
+  count--;
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/byval1.h b/gcc/testsuite/g++.dg/compat/init/byval1.h
new file mode 100644
index 000000000..2876b76ed
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/byval1.h
@@ -0,0 +1,6 @@
+struct C
+{
+  int m;
+  C();
+  ~C();
+};
diff --git a/gcc/testsuite/g++.dg/compat/init/byval1_main.C b/gcc/testsuite/g++.dg/compat/init/byval1_main.C
new file mode 100644
index 000000000..acefaab14
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/byval1_main.C
@@ -0,0 +1,12 @@
+// PR c++/3948
+// Test that the destructor call for a value parameter gets the
+// right address.
+// Split into pieces for binary compatibility testing October 2002
+
+extern void byval1_x (void);
+
+int
+main ()
+{
+  byval1_x ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/byval1_x.C b/gcc/testsuite/g++.dg/compat/init/byval1_x.C
new file mode 100644
index 000000000..248dbe763
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/byval1_x.C
@@ -0,0 +1,15 @@
+#include "byval1.h"
+
+extern "C" void abort (void);
+extern void Foo (C c);
+extern int r;
+
+void
+byval1_x ()
+{       
+  C c;
+
+  Foo (c);
+  if (r != 0)
+    abort ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/byval1_y.C b/gcc/testsuite/g++.dg/compat/init/byval1_y.C
new file mode 100644
index 000000000..6e217e84e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/byval1_y.C
@@ -0,0 +1,14 @@
+#include "byval1.h"
+
+void *p[2];
+
+int i;
+int r;
+
+C::C()  { p[i++] = this; }
+C::~C() { if (p[--i] != this) r = 1; }
+
+void Foo (C c)
+{
+  p[i++] = &c;
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/dtor1.h b/gcc/testsuite/g++.dg/compat/init/dtor1.h
new file mode 100644
index 000000000..77e21c12e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/dtor1.h
@@ -0,0 +1,30 @@
+struct B
+{
+  int x;
+  B (int);
+  ~B ();
+};
+
+struct C1 : public B {
+  C1 (int);
+};
+
+struct C2 : public B {
+  C2 (int);
+};
+
+struct D : public B {
+  D (int);
+};
+
+struct E : public B {
+  E (int);
+};
+
+struct A
+  : public C1, C2, virtual public D, virtual public E
+{
+  A ();
+  B x1;
+  B x2;
+};
diff --git a/gcc/testsuite/g++.dg/compat/init/dtor1_main.C b/gcc/testsuite/g++.dg/compat/init/dtor1_main.C
new file mode 100644
index 000000000..788687840
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/dtor1_main.C
@@ -0,0 +1,9 @@
+// Split into pieces for binary compatibility testing October 2002
+
+extern void dtor1_x (void);
+
+int
+main ()
+{
+  dtor1_x ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/dtor1_x.C b/gcc/testsuite/g++.dg/compat/init/dtor1_x.C
new file mode 100644
index 000000000..8a4727cfb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/dtor1_x.C
@@ -0,0 +1,7 @@
+#include "dtor1.h"
+
+void
+dtor1_x (void)
+{
+  A a;
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/dtor1_y.C b/gcc/testsuite/g++.dg/compat/init/dtor1_y.C
new file mode 100644
index 000000000..27610fc1e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/dtor1_y.C
@@ -0,0 +1,18 @@
+#include "dtor1.h"
+
+extern "C" void abort ();
+
+int d = 5;
+
+B::B (int i) : x (i) { }
+B::~B () { if (d-- != x) abort (); }
+
+C1::C1 (int i) : B (i) {}
+
+C2::C2 (int i) : B (i) {}
+
+D::D (int i) : B (i) {}
+
+E::E (int i) : B (i) {}
+
+A::A () : D (0), E (1), C1 (2), C2 (3), x1(4), x2(5) {}
diff --git a/gcc/testsuite/g++.dg/compat/init/elide1.h b/gcc/testsuite/g++.dg/compat/init/elide1.h
new file mode 100644
index 000000000..481e7308b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/elide1.h
@@ -0,0 +1,5 @@
+struct A {
+  A ();
+  A (const A&);
+  ~A ();
+};
diff --git a/gcc/testsuite/g++.dg/compat/init/elide1_main.C b/gcc/testsuite/g++.dg/compat/init/elide1_main.C
new file mode 100644
index 000000000..c08d02fff
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/elide1_main.C
@@ -0,0 +1,25 @@
+// Test that the destructor for a temporary passed by value isn't run
+// until end of full-expression, as per [class.copy]:
+
+// Whenever a temporary class object is copied using a copy  constructor,
+// and  this  object  and  the copy have the same cv-unqualified type, an
+// implementation is permitted to treat the original and the copy as  two
+// different  ways of referring to the same object and not perform a copy
+// at all, even if the class copy constructor  or  destructor  have  side
+// effects....                                       In these cases,  the
+// object  is  destroyed  at the later of times when the original and the
+// copy would have been destroyed without the optimization.
+
+// Here, the temporary would be destroyed later than the parm, so either we
+// must suppress the optimization in this case or destroy value parms in the
+// caller.
+
+// Split into pieces for binary compatibility testing October 2002
+
+extern void elide1_x (void);
+
+int
+main ()
+{
+  elide1_x ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/elide1_x.C b/gcc/testsuite/g++.dg/compat/init/elide1_x.C
new file mode 100644
index 000000000..dbc287e4e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/elide1_x.C
@@ -0,0 +1,15 @@
+#include "elide1.h"
+
+extern "C" void abort (void);
+extern void f (A);
+extern int d;
+
+void
+elide1_x (void)
+{
+  int r;
+  f (A ()), r = d;
+
+  if (r >= d || !d)
+    abort ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/elide1_y.C b/gcc/testsuite/g++.dg/compat/init/elide1_y.C
new file mode 100644
index 000000000..e767d0808
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/elide1_y.C
@@ -0,0 +1,9 @@
+#include "elide1.h"
+
+int d;
+
+A::A () { }
+A::A (const A&) { }
+A::~A() { ++d; }
+
+void f (A a) { }
diff --git a/gcc/testsuite/g++.dg/compat/init/init-ref2_main.C b/gcc/testsuite/g++.dg/compat/init/init-ref2_main.C
new file mode 100644
index 000000000..73782829e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/init-ref2_main.C
@@ -0,0 +1,11 @@
+// Submitted by Jason Merrill <jason_merrill@redhat.com>
+// Test for proper handling of local static references.
+// Split into pieces for binary compatibility testing October 2002
+
+extern void init_ref2_x (void);
+
+int
+main ()
+{
+  init_ref2_x ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/init-ref2_x.C b/gcc/testsuite/g++.dg/compat/init/init-ref2_x.C
new file mode 100644
index 000000000..7fbec89b6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/init-ref2_x.C
@@ -0,0 +1,22 @@
+extern "C" void abort (void);
+extern void g (void);
+extern void h (void);
+
+int r;
+int c;
+int f ()
+{
+  // Test that we only initialize i once.
+  if (++c > 1)
+    ++r;
+  return 42;
+}
+
+void
+init_ref2_x (void)
+{
+  g ();
+  h ();
+  if (r != 0)
+    abort ();
+}
diff --git a/gcc/testsuite/g++.dg/compat/init/init-ref2_y.C b/gcc/testsuite/g++.dg/compat/init/init-ref2_y.C
new file mode 100644
index 000000000..23e66b2f9
--- /dev/null
+++ b/gcc/testsuite/g++.dg/compat/init/init-ref2_y.C
@@ -0,0 +1,24 @@
+extern int f (void);
+extern int r;
+
+const int *p;
+
+void g ()
+{
+  static const int &i = f();
+
+  // Test that i points to the same place in both calls.
+  if (p && p != &i)
+    ++r;
+  // Test that if so, it points to static data.
+  if (i != 42)
+    ++r;
+
+  p = &i;
+}
+
+void h ()
+{
+  int arr[] = { 1, 1, 1, 1, 1, 1, 1 };
+  g ();
+}