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.

33 files changed, 835 insertions, 0 deletions

diff --git a/gcc/testsuite/g++.dg/tc1/dr1.C b/gcc/testsuite/g++.dg/tc1/dr1.C
new file mode 100644
index 000000000..9196218f1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr1.C
@@ -0,0 +1,18 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR1: What if two using-declarations refer to the same function but the 
+//  declarations introduce different default-arguments? 
+
+namespace A { 
+  extern "C" void f(int = 5); 
+} 
+namespace B { 
+  extern "C" void f(int = 5); 
+} 
+using A::f; 
+using B::f; 
+
+void use() { 
+  f(3);       
+  f();        // { dg-error "" "" { xfail *-*-* } }
+} 
diff --git a/gcc/testsuite/g++.dg/tc1/dr101.C b/gcc/testsuite/g++.dg/tc1/dr101.C
new file mode 100644
index 000000000..0316aaaa7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr101.C
@@ -0,0 +1,30 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR101: Redeclaration of extern "C" names via using-declarations 
+
+namespace Test1 {
+
+  typedef unsigned int X;
+  extern "C" void f1();
+  namespace N {
+    typedef unsigned int X;
+    extern "C" void f1();
+  }
+  using N::f1; // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+  using N::X;  // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+}
+
+
+namespace Test2 {
+
+  typedef unsigned int X;   // { dg-bogus "X" "" }
+  extern "C" int f2();
+  namespace N {
+    typedef unsigned int X; // { dg-bogus "X" "" }
+    extern "C" int f2();
+  }
+  using namespace N;
+  int i = f2(); // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+  X x;          // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr108.C b/gcc/testsuite/g++.dg/tc1/dr108.C
new file mode 100644
index 000000000..43bae15ea
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr108.C
@@ -0,0 +1,13 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR108: Are classes nested in templates dependent?
+
+template <class T> struct S {
+  struct I1 {
+    typedef int X;
+  };
+  struct I2 : public I1 {
+    X x;    // { dg-error "does not name a type" "name" }
+	    // { dg-message "note" "note" { target *-*-* } 10 }
+  };
+};
diff --git a/gcc/testsuite/g++.dg/tc1/dr127.C b/gcc/testsuite/g++.dg/tc1/dr127.C
new file mode 100644
index 000000000..4dddc6d77
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr127.C
@@ -0,0 +1,28 @@
+// { dg-do link }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR127: Ambiguity in description of matching deallocation function
+
+#include <cstddef>
+#include <new>
+
+struct A 
+{
+  // placement new, but can be called through normal new syntax.
+  void* operator new(std::size_t size, float = 0.0f)
+  {
+    return ::operator new(size);
+  }
+
+  // The matching deallocation function must be called, which means
+  //  the placemente delete.
+  void operator delete(void*);
+  void operator delete(void*, float) {}
+
+  A()
+  { throw 5; }
+};
+
+int main()
+{
+  (void)new A;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr128.C b/gcc/testsuite/g++.dg/tc1/dr128.C
new file mode 100644
index 000000000..4dd78d57f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr128.C
@@ -0,0 +1,17 @@
+// { dg-do run }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR128: Casting between enum types
+
+extern "C" void abort(void);
+
+enum E1 { BLACK = 0, RED = 1 };
+enum E2 { WHITE = 0, YELLOW = 1};
+
+int main(void)
+{
+  E1 e1 = RED;
+  E2 e2 = static_cast<E2>(e1);
+  if (e2 != YELLOW)
+    abort();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr135.C b/gcc/testsuite/g++.dg/tc1/dr135.C
new file mode 100644
index 000000000..beed8cdfd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr135.C
@@ -0,0 +1,8 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR135: Class type in in-class member function definitions 
+
+struct S {
+  S f() { return S(); }  // { dg-bogus "" "incomplete class type is allowed as return type" }
+  void g(S) { }          // { dg-bogus "" "incomplete class type is allowed as parameter type" }
+};
diff --git a/gcc/testsuite/g++.dg/tc1/dr137.C b/gcc/testsuite/g++.dg/tc1/dr137.C
new file mode 100644
index 000000000..bc1beb021
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr137.C
@@ -0,0 +1,13 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR137: static_cast of cv void*
+
+struct A;
+
+const void* v;
+
+void foo(void)
+{
+  (void)static_cast<const volatile A *>(v);
+  (void)static_cast<A *>(v);  // { dg-error "" "static_cast cannot remove cv qualifiers" }
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr142.C b/gcc/testsuite/g++.dg/tc1/dr142.C
new file mode 100644
index 000000000..c49f4dd20
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr142.C
@@ -0,0 +1,32 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR142: Injection-related errors in access example 
+
+class B {                 // { dg-error "inaccessible" }
+public:
+  int mi;                 // { dg-error "inaccessible" }
+  static int si;          // { dg-error "inaccessible" }
+};
+
+class D: private B {
+};
+
+class DD: public D {
+  void f();
+};
+
+void DD::f() {
+  mi = 3;          // { dg-error "within this context" "" }
+  si = 3;          // { dg-error "within this context" "" }
+  ::B b;
+  b.mi = 3;
+  b.si = 3;
+  ::B::si = 3;
+  ::B* bp1 = this;        // { dg-error "inaccessible base" "" }
+  ::B* bp2 = (::B*)this;
+  bp2->mi = 3;
+
+
+  B b2;                   // { dg-error "within this context" "" }
+  B::si = 3;              // { dg-error "within this context" "" }
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr147.C b/gcc/testsuite/g++.dg/tc1/dr147.C
new file mode 100644
index 000000000..6799b7dcc
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr147.C
@@ -0,0 +1,66 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR147: Naming the constructor (PR 11764) 
+
+namespace N1 {
+
+struct A { A(); void f(); };
+struct B: public A { B(); };
+
+A::A() { }
+B::B() { }
+
+B::A ba;
+A::A a; // { dg-error "constructor" "the injected-class-name can never be found through qualified lookup" }
+
+void A::f()
+{
+  A::A();			// { dg-message "::A" "c++/42415" }
+}
+
+void f()
+{
+  A::A a; // { dg-error "constructor" }
+} // { dg-error "" "" { target *-*-* } 23 } error cascade
+}
+
+namespace N2 {
+
+// This is nasty: if we allowed the injected-class-name to be looked as a 
+//  qualified type, then the following code would be well-formed. Basically
+//  the last line is defining the static member (with redundant parenthesis).
+// Instead, it should be rejected as a malformed constructor declaration.
+
+template <class T> struct A {
+  template <class T2> A(T2);
+  static A x;
+};
+template<> template <> A<char>::A<char>(char);
+template<> A<int>::A<int>(A<int>::x);  // { dg-error "" "this is an invalid declaration of the constructor" }
+
+}
+
+// But DR 318 says that in situations where a type is syntactically
+// required, lookup finds it.
+
+struct C
+{
+  C();
+  typedef int T;
+};
+struct C::C c;
+C::C::T t;
+struct D: C::C
+{
+  D(): C::C() { }
+};
+
+// And if lookup doesn't find the injected-class-name, we aren't naming the
+// constructor (c++/44401).
+
+struct E
+{
+  int E;
+};
+
+int E::*p = &E::E;
diff --git a/gcc/testsuite/g++.dg/tc1/dr152.C b/gcc/testsuite/g++.dg/tc1/dr152.C
new file mode 100644
index 000000000..f930d2e28
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr152.C
@@ -0,0 +1,38 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR152: explicit copy constructors 
+
+namespace N1 {
+  struct X {
+    X();			// { dg-message "note" }
+    explicit X(const X&);
+  };
+  void f(X);			// { dg-error "initializing" }
+  int foo() 
+  { 
+    X x; 
+    f(x);     // { dg-error "matching" "matching" }
+    // { dg-message "candidate" "candidate note" { target *-*-* } 14 }
+  }
+}
+
+namespace N2 {
+  template <class T>
+  struct X {
+    X();			// { dg-message "note" }
+    explicit X(const X&);
+  };
+
+  template <class T>
+  void f(T ) {}			// { dg-error "initializing" }
+  
+  template <class T>
+  int foo() 
+  { 
+    X<T> x; 
+    N2::f(x);   // { dg-error "matching" "matching" }
+    // { dg-message "candidate" "candidate note" { target *-*-* } 33 }
+  }
+
+  template int foo<float>();  // { dg-message "instantiated from here" }
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr159.C b/gcc/testsuite/g++.dg/tc1/dr159.C
new file mode 100644
index 000000000..74d23f1cd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr159.C
@@ -0,0 +1,12 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR159: Namespace qualification in declarators 
+
+namespace N {
+  namespace M {
+    void f();
+    void g();
+  }
+  void M::f(){}
+  void N::M::g(){}
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr161.C b/gcc/testsuite/g++.dg/tc1/dr161.C
new file mode 100644
index 000000000..49f679a0c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr161.C
@@ -0,0 +1,50 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR161: Access to protected nested type 
+
+namespace N1 {
+  struct A 
+  {
+  protected:
+    typedef int type;
+  };
+
+  struct B : public A
+  {
+    void test(void)
+    {
+      A::type t;
+    }
+
+    friend void ftest(void)
+    {
+      A::type t;
+    }
+  };
+}
+
+
+namespace N2 {
+  template <class T>
+  struct A 
+  {
+  protected:
+    typedef int type;
+  };
+
+  template <class T>
+  struct B : public A<T>
+  {
+    void test(B b)
+    {
+      typename A<T>::type t;
+    }
+
+    friend void ftest(B b)
+    {
+      typename A<T>::type t;
+    }
+  };
+
+  template struct B<void>;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr164.C b/gcc/testsuite/g++.dg/tc1/dr164.C
new file mode 100644
index 000000000..026ec096f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr164.C
@@ -0,0 +1,17 @@
+// { dg-do link }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR164: Overlap between Koenig and normal lookup 
+
+void f(int);
+
+template <class T> void g(T t) {
+  f(t);
+}
+
+enum E { e };
+
+void f(E) {}
+
+int main() {
+  g(e);
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr166.C b/gcc/testsuite/g++.dg/tc1/dr166.C
new file mode 100644
index 000000000..8c142906a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr166.C
@@ -0,0 +1,60 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR166: Friend declarations of template-ids 
+
+namespace N {
+  template <class T> void f(T);
+  void g();
+
+  namespace M {
+    class A {
+      friend void f<int>(int); // N::f
+      static int x;   // { dg-error "private" }
+    };
+    
+    class B {
+      template <class T> friend void f(T);  // M::f
+      static int x;   // { dg-error "private" }
+    };
+
+    class C {
+      friend void g(); // M::g
+      static int x;   // { dg-error "private" }
+    };
+
+    template <class T> void f(T)  // will be instantiated as f<long>
+    {
+      M::A::x = 0;    // { dg-error "within this context" }
+      M::B::x = 0;
+    }
+    template <> void f<int>(int)
+    { M::A::x = 0; }      // { dg-error "within this context" }
+    template <> void f<double>(double )
+    { 
+      M::B::x = 0; 
+      M::f<long>(0);   // { dg-message "instantiated" }
+    }
+
+    void g(void)
+    { M::C::x = 0; }
+  }
+
+  template <class T> void f(T)  // will be instantiated as f<long>
+  { 
+    M::A::x = 0;       // { dg-error "within this context" }
+    M::B::x = 0;       // { dg-error "within this context" }
+  }
+
+  template <> void f<int>(int )
+  { 
+    N::f<long>(0);        // { dg-message "instantiated" }
+    M::A::x = 0; 
+    M::B::x = 0;       // { dg-error "within this context" }
+  }
+
+  template <> void f<char>(char )
+  { M::A::x = 0; }      // { dg-error "within this context" }
+
+  void g(void)
+  { M::C::x = 0; }      // { dg-error "within this context" }
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr176.C b/gcc/testsuite/g++.dg/tc1/dr176.C
new file mode 100644
index 000000000..2879ac4e7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr176.C
@@ -0,0 +1,29 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR176: Name injection and templates 
+
+namespace N1 {
+  template <class T> struct Base {
+    Base* p;
+    Base<T*>* p2;
+    ::Base* p3;    // { dg-error "" "" }
+  };
+
+  template <class T> struct Derived: public Base<T> {
+    Base* p;     // { dg-error "" "unqualified name binds to N1::Base" }
+    Base<T*>* p2;
+    typename Derived::Base* p3;   // { dg-bogus "" "injected class name in derived classes" }
+  };
+
+  template struct Derived<void>;  // { dg-bogus "instantiated from here" "everything should be looked up at parsing time (after DR224)" }
+}
+
+
+namespace N2 {
+  template <class T> struct Base {};
+  template <class T> struct Derived: public Base<T> {
+    typename Derived::template Base<double>* p1;  // { dg-bogus "" "" }
+  };
+
+  template struct Derived<void>;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr179.C b/gcc/testsuite/g++.dg/tc1/dr179.C
new file mode 100644
index 000000000..39e4164d2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr179.C
@@ -0,0 +1,13 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR179: Function pointers and subtraction
+
+void foo(void);
+typedef void (*fp)(void);
+
+int main()
+{
+  fp f1 = foo;
+  fp f2 = foo;
+  (void)f2-f1;  // { dg-error "" "cannot subtract pointers to function" }
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr185.C b/gcc/testsuite/g++.dg/tc1/dr185.C
new file mode 100644
index 000000000..2cd4e397f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr185.C
@@ -0,0 +1,26 @@
+// { dg-do run }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR185: "Named" temporaries and copy elision 
+
+extern "C" void abort(void);
+
+struct A {
+  mutable int value;
+  explicit A(int i) : value(i) {}
+  void mutate(int i) const { value = i; }
+};
+
+int foo() {
+  A const& t = A(1);
+  A n(t);          // can this copy be elided? NO!
+  t.mutate(2);
+  return n.value;  // can this return 2? NO!
+}
+
+int main()
+{
+  int x = foo();
+  if (x != 1)
+    abort();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr188.C b/gcc/testsuite/g++.dg/tc1/dr188.C
new file mode 100644
index 000000000..3a10fa476
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr188.C
@@ -0,0 +1,9 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR188: Comma operator and rvalue conversion
+
+template <bool> struct StaticAssert;
+template <> struct StaticAssert<true> {};
+
+char arr[100];
+StaticAssert<(sizeof(0,arr) == 100)> check;
diff --git a/gcc/testsuite/g++.dg/tc1/dr193.C b/gcc/testsuite/g++.dg/tc1/dr193.C
new file mode 100644
index 000000000..40b065084
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr193.C
@@ -0,0 +1,72 @@
+// { dg-do run }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR193: Order of destruction of local automatics of destructor 
+
+extern "C" void abort(void);
+
+namespace N1 {
+  bool a_done = false;
+  struct A
+  { 
+    ~A()
+    {
+      a_done = true;
+    }
+  };
+
+  struct B
+  { 
+    ~B()
+    {
+      if (!a_done)
+        abort();
+    }
+  };
+
+  struct C {
+    B x;
+    ~C() {
+      A y;
+    }
+  };
+}
+
+
+namespace N2 {
+  bool a_done = false;
+
+  template <class>
+  struct A
+  { 
+    ~A()
+    {
+      a_done = true;
+    }
+  };
+
+  template <class>
+  struct B
+  { 
+    ~B()
+    {
+      if (!a_done)
+        abort();
+    }
+  };
+
+  template <class T>
+  struct C {
+    B<T> x;
+    ~C() {
+      A<T> y;
+    }
+  };
+}
+
+
+int main(void)
+{
+  N1::C c1;
+  N2::C<void> c2;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr194.C b/gcc/testsuite/g++.dg/tc1/dr194.C
new file mode 100644
index 000000000..3ed130071
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr194.C
@@ -0,0 +1,16 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR194: Identifying constructors 
+
+struct A
+{
+  inline explicit A();
+};
+
+template <class>
+struct B
+{
+  inline explicit B();
+};
+
+template struct B<void>;
diff --git a/gcc/testsuite/g++.dg/tc1/dr20.C b/gcc/testsuite/g++.dg/tc1/dr20.C
new file mode 100644
index 000000000..fe5862129
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr20.C
@@ -0,0 +1,34 @@
+// { dg-do run }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR20: Some clarifications needed for 12.8 para 15 
+
+extern "C" void printf(const char*, ...);
+extern "C" void abort(void);
+
+int count = 0;
+
+class Thing {
+public:
+  Thing() {
+  }
+  ~Thing() {
+  }
+  Thing(const Thing&)
+  {
+    count += 1;
+  }
+};
+
+Thing f() {
+  Thing t;
+  return t;
+}
+
+int main(void)
+{
+  Thing t2 = f();
+  printf("%d %x\n", count, &t2);
+  if (count != 0)
+    abort();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr213.C b/gcc/testsuite/g++.dg/tc1/dr213.C
new file mode 100644
index 000000000..2cc70138a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr213.C
@@ -0,0 +1,27 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR213: Lookup in dependent base classes
+
+// We should emit an error at *instantiation* time because g(t) can't be
+//  resolved to any function.
+
+template <class T> struct A : T {
+  void h(T t) {
+    f(t);
+    g(t);     // { dg-error "" "" { xfail *-*-* } }
+  }
+};
+
+struct B {
+  void f(B);
+  void g(B) {}
+};
+
+void f(B) {}
+
+int main()
+{
+  A<B> ab;   // { dg-error "" "" { xfail *-*-* } }
+  B b;
+  ab.h(b);
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr217.C b/gcc/testsuite/g++.dg/tc1/dr217.C
new file mode 100644
index 000000000..cfa280397
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr217.C
@@ -0,0 +1,14 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR217: Default arguments for non-template member functions of class 
+//  templates 
+
+template <class T>
+struct S
+{
+  void foo (int);
+};
+
+template <class T>
+void S<T>::foo (int = 0)  // { dg-error "" "default arguments for parameters of member functions of class templates can be specified in the initial declaration only" { xfail *-*-* } }
+{ }
diff --git a/gcc/testsuite/g++.dg/tc1/dr48.C b/gcc/testsuite/g++.dg/tc1/dr48.C
new file mode 100644
index 000000000..19c173878
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr48.C
@@ -0,0 +1,13 @@
+// { dg-do link }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR48: Definitions of unused static members 
+
+struct A {
+  static const int size = 10;
+  int array[size];
+};
+
+int main() {
+  A a;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr49.C b/gcc/testsuite/g++.dg/tc1/dr49.C
new file mode 100644
index 000000000..753d96b69
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr49.C
@@ -0,0 +1,19 @@
+// { dg-do compile }
+// Contributed by: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR 49: Non-constant pointers are invalid template arguments.
+
+template<int *a> struct R { /* ... */ };
+template<int b[5]> struct S { /* ... */ };
+
+int p;
+template struct R<&p>; // OK
+template struct S<&p>; // OK due to parameter adjustment
+
+int *ptr;
+template struct R<ptr>; // { dg-error "argument" }
+template struct S<ptr>; // { dg-error "argument" }
+
+int v[5];
+template struct R<v>; // OK due to implicit argument conversion
+template struct S<v>; // OK due to both adjustment and conversion
+
diff --git a/gcc/testsuite/g++.dg/tc1/dr52.C b/gcc/testsuite/g++.dg/tc1/dr52.C
new file mode 100644
index 000000000..4f4015dc9
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr52.C
@@ -0,0 +1,34 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR52: Non-static members, member selection and access checking
+
+struct A 
+{
+  void foo(void);
+};
+
+struct B
+{
+private:
+  void foo(void);
+};
+
+struct B1 : B {};
+struct B2 : B {};
+
+struct C
+{ // { dg-error "C" }
+  void foo(void);
+};
+
+struct D : private C {};
+
+struct X: A, B1, B2, D
+{
+public:
+  void bar(void)
+  {
+    this->B::foo();  // { dg-error "" }
+    this->C::foo();  // { dg-error "inaccessible|context" }
+  }
+};
diff --git a/gcc/testsuite/g++.dg/tc1/dr68.C b/gcc/testsuite/g++.dg/tc1/dr68.C
new file mode 100644
index 000000000..253f04943
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr68.C
@@ -0,0 +1,20 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR68: Grammar does not allow "friend class A<int>;" 
+
+namespace A{
+  class B{};
+}
+
+namespace B{
+  class A{};
+  class C{
+    friend class ::A::B;
+  };
+}
+
+
+template <typename> class K;
+class J {
+  friend class K<int>;
+};
diff --git a/gcc/testsuite/g++.dg/tc1/dr74.C b/gcc/testsuite/g++.dg/tc1/dr74.C
new file mode 100644
index 000000000..155c7981b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr74.C
@@ -0,0 +1,9 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR74: Enumeration value in direct-new-declarator 
+
+struct A {};
+enum E1 { COUNT = 10 };
+
+A* a = new A[COUNT];
+
diff --git a/gcc/testsuite/g++.dg/tc1/dr76.C b/gcc/testsuite/g++.dg/tc1/dr76.C
new file mode 100644
index 000000000..0859b0c73
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr76.C
@@ -0,0 +1,8 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR76: Are const volatile variables considered "constant expressions"? 
+
+volatile const int a = 5;
+
+template <int> struct K;
+template struct K<a>;	// { dg-error "" }
diff --git a/gcc/testsuite/g++.dg/tc1/dr80.C b/gcc/testsuite/g++.dg/tc1/dr80.C
new file mode 100644
index 000000000..2327428a0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr80.C
@@ -0,0 +1,53 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR80: Class members with same name as class 
+
+struct A 
+{
+  int A;
+};
+
+struct A2
+{
+  static int A2;  // { dg-error "same name as" }
+};
+
+
+template <class>
+struct A3
+{
+  int A3;
+};
+
+template <class>
+struct A4
+{
+  static int A4;  // { dg-error "same name as" }
+};
+
+
+struct B
+{
+  B();
+  int B;  // { dg-error "same name as" }
+};
+
+struct B2
+{
+  B2();
+  static int B2;  // { dg-error "same name as" }
+};
+
+template <class>
+struct B3
+{
+  B3();
+  int B3;  // { dg-error "same name as" "this error should appear at parsing time" { xfail *-*-* } }
+};
+
+template <class>
+struct B4
+{
+  B4();
+  static int B4;  // { dg-error "same name as" }
+};
diff --git a/gcc/testsuite/g++.dg/tc1/dr85.C b/gcc/testsuite/g++.dg/tc1/dr85.C
new file mode 100644
index 000000000..31dde8cbb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr85.C
@@ -0,0 +1,8 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR85: Redeclaration of member class
+
+struct Base {
+  struct Data {};  
+  struct Data;  // { dg-error "" "redeclaration of nested class is invalid" { xfail *-*-* } }
+};
diff --git a/gcc/testsuite/g++.dg/tc1/dr90.C b/gcc/testsuite/g++.dg/tc1/dr90.C
new file mode 100644
index 000000000..b6ec24cc8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr90.C
@@ -0,0 +1,20 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR90: Should the enclosing class be an "associated class" too? 
+
+struct A {
+  union U {};
+  friend void f(U);
+};
+
+struct B {
+  struct S {};
+  friend void f(S);
+};
+
+int main() { 
+  A::U    u; 
+  f(u);
+  B::S    s;
+  f(s);
+}
diff --git a/gcc/testsuite/g++.dg/tc1/dr94.C b/gcc/testsuite/g++.dg/tc1/dr94.C
new file mode 100644
index 000000000..97cf0c256
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tc1/dr94.C
@@ -0,0 +1,9 @@
+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR94: Inconsistencies in the descriptions of constant expressions 
+
+struct S {
+  static const int c = 5;
+};
+int a[S::c];
+