Index: test/CXX/basic/basic.stc/basic.stc.dynamic/p2-noexceptions.cpp
===================================================================
--- test/CXX/basic/basic.stc/basic.stc.dynamic/p2-noexceptions.cpp
+++ test/CXX/basic/basic.stc/basic.stc.dynamic/p2-noexceptions.cpp
@@ -1,5 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
-// expected-no-diagnostics
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
 namespace std {
   class bad_alloc { };
   
@@ -11,4 +13,12 @@
 void* operator new(std::size_t); 
 void* operator new[](std::size_t);
 void operator delete(void*);
+#if __cplusplus >= 201103L
+// expected-warning@-2 {{function previously declared with an explicit exception specification redeclared with an implicit exception specificatio}}
+#else
+// expected-no-diagnostics
+#endif
 void operator delete[](void*);
+#if __cplusplus >= 201103L
+// expected-warning@-2 {{function previously declared with an explicit exception specification redeclared with an implicit exception specificatio}}
+#endif
Index: test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp
===================================================================
--- test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp
+++ test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp
@@ -1,4 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++11 %s
+
 int *use_new(int N) {
   if (N == 1)
     return new int;
@@ -19,10 +22,23 @@
   typedef __SIZE_TYPE__ size_t;
 }
 
-void* operator new(std::size_t) throw(std::bad_alloc); // expected-note{{previous declaration}}
+void* operator new(std::size_t) throw(std::bad_alloc);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous declaration is here}}
+#endif
+
 void* operator new[](std::size_t) throw(std::bad_alloc); 
 void operator delete(void*) throw(); // expected-note{{previous declaration}}
 void operator delete[](void*) throw();
 
-void* operator new(std::size_t); // expected-warning{{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
-void operator delete(void*); // expected-warning{{'operator delete' is missing exception specification 'throw()'}}
+void* operator new(std::size_t);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
+#endif
+
+void operator delete(void*);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{'operator delete' is missing exception specification 'throw()'}}
+#else
+// expected-warning@-4 {{function previously declared with an explicit exception specification redeclared with an implicit exception specification}}
+#endif
Index: test/CXX/class.access/class.friend/p1.cpp
===================================================================
--- test/CXX/class.access/class.friend/p1.cpp
+++ test/CXX/class.access/class.friend/p1.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // C++'0x [class.friend] p1:
 //   A friend of a class is a function or class that is given permission to use
@@ -214,9 +216,15 @@
 // PR6207
 namespace test6 {
   struct A {};
+#if __cplusplus >= 201103L
+    // expected-note@-2 {{previous declaration is here}}
+#endif
 
   struct B {
     friend A::A();
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{non-constexpr declaration of 'A' follows constexpr declaration}}
+#endif
     friend A::~A();
     friend A &A::operator=(const A&);
   };
@@ -225,6 +233,7 @@
 namespace test7 {
   template <class T> struct X {
     X();
+    X(const X&);
     ~X();
     void foo();
     void bar();
Index: test/CXX/class.access/p4.cpp
===================================================================
--- test/CXX/class.access/p4.cpp
+++ test/CXX/class.access/p4.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
 
 // C++0x [class.access]p4:
 
@@ -88,24 +90,49 @@
 namespace test2 {
   class A {
   private:
-    A(); // expected-note 3 {{declared private here}}
-
+    A();
+#if __cplusplus <= 199711L
+    // expected-note@-2 3 {{declared private here}}
+#else
+    // expected-note@-4 {{declared private here}}
+#endif
     static A foo;
   };
 
   A a; // expected-error {{calling a private constructor}}
   A A::foo; // okay
   
-  class B : A { }; // expected-error {{base class 'test2::A' has private default constructor}}
-  B b; // expected-note{{implicit default constructor}}
-  
+  class B : A { };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{base class 'test2::A' has private default constructor}}
+#else
+  // expected-note@-4 {{default constructor of 'B' is implicitly deleted because base class 'test2::A' has an inaccessible default constructor}}
+#endif
+  B b;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit default constructor}}
+#else
+  // expected-error@-4 {{call to implicitly-deleted default constructor of 'test2::B'}}
+#endif
+
   class C : virtual A { 
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{default constructor of 'D' is implicitly deleted because base class 'test2::A' has an inaccessible default constructor}}
+#endif
   public:
     C();
   };
 
-  class D : C { }; // expected-error {{inherited virtual base class 'test2::A' has private default constructor}}
-  D d; // expected-note{{implicit default constructor}}
+  class D : C { };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{inherited virtual base class 'test2::A' has private default constructor}}
+#endif
+  D d;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit default constructor}}
+#else
+  // expected-error@-4 {{call to implicitly-deleted default constructor of 'test2::D'}}
+#endif
 }
 
 // Implicit destructor calls.
@@ -123,11 +150,23 @@
     A local; // expected-error {{variable of type 'test3::A' has private destructor}}
   }
 
-  template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}
-  class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \
-                                               // expected-error {{base class 'Base<2>' has private destructor}}
-  class Base3 : virtual Base<3> { public: ~Base3(); }; // expected-error {{base class 'Base<3>' has private destructor}}
-
+  template <unsigned N> class Base { ~Base(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2 14 {{declared private here}}
+#else
+  // expected-note@-4 4 {{declared private here}}
+#endif
+  class Base2 : virtual Base<2> { ~Base2(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2 3 {{declared private here}}
+  // expected-error@-3 {{base class 'Base<2>' has private destructor}}
+#else
+  // expected-note@-5 {{declared private here}}
+#endif
+  class Base3 : virtual Base<3> { public: ~Base3(); };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{base class 'Base<3>' has private destructor}}
+#endif
   // These don't cause diagnostics because we don't need the destructor.
   class Derived0 : Base<0> { ~Derived0(); };
   class Derived1 : Base<1> { };
@@ -142,16 +181,35 @@
     ~Derived2() {}
   };
 
-  class Derived3 : // expected-error 2 {{inherited virtual base class 'Base<2>' has private destructor}} \
-                   // expected-error 2 {{inherited virtual base class 'Base<3>' has private destructor}} \
-    // expected-note 2{{implicit default constructor}}
-    Base<0>,  // expected-error 2 {{base class 'Base<0>' has private destructor}}
-    virtual Base<1>, // expected-error 2 {{base class 'Base<1>' has private destructor}}
-    Base2, // expected-error 2 {{base class 'test3::Base2' has private destructor}}
+  class Derived3 :
+#if __cplusplus <= 199711L
+  // expected-error@-2 2 {{inherited virtual base class 'Base<2>' has private destructor}}
+  // expected-error@-3 2 {{inherited virtual base class 'Base<3>' has private destructor}}
+  // expected-note@-4 2{{implicit default constructor}}
+#endif
+    Base<0>,
+#if __cplusplus <= 199711L
+    // expected-error@-2 2 {{base class 'Base<0>' has private destructor}}
+#else
+    // expected-note@-4 {{default constructor of 'Derived3' is implicitly deleted because base class 'Base<0>' has an inaccessible destructor}}
+#endif
+    virtual Base<1>,
+#if __cplusplus <= 199711L
+    // expected-error@-2 2 {{base class 'Base<1>' has private destructor}}
+#endif
+    Base2,
+#if __cplusplus <= 199711L
+    // expected-error@-2 2 {{base class 'test3::Base2' has private destructor}}
+#endif
     virtual Base3
   {}; 
-  Derived3 d3; // expected-note {{implicit default constructor}}\
-               // expected-note{{implicit destructor}}}
+  Derived3 d3;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit default constructor}}
+  // expected-note@-3 {{implicit destructor}}}
+#else
+  // expected-error@-5 {{call to implicitly-deleted default constructor of 'test3::Derived3'}}
+#endif
 }
 
 // Conversion functions.
@@ -201,19 +259,42 @@
 // Implicit copy assignment operator uses.
 namespace test5 {
   class A {
-    void operator=(const A &); // expected-note 2 {{implicitly declared private here}}
+    void operator=(const A &);
+#if __cplusplus <= 199711L
+    // expected-note@-2 2 {{implicitly declared private here}}
+#endif
   };
 
-  class Test1 { A a; }; // expected-error {{private member}}
+  class Test1 { A a; };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{private member}}
+#else
+  // expected-note@-4 {{copy assignment operator of 'Test1' is implicitly deleted because field 'a' has an inaccessible copy assignment operator}}
+#endif
   void test1() {
     Test1 a; 
-    a = Test1(); // expected-note{{implicit copy}}
+    a = Test1();
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy}}
+#else
+    // expected-error@-4 {{object of type 'test5::Test1' cannot be assigned because its copy assignment operator is implicitly deleted}}
+#endif
   }
 
-  class Test2 : A {}; // expected-error {{private member}}
+  class Test2 : A {};
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{private member}}
+#else
+  // expected-note@-4 {{copy assignment operator of 'Test2' is implicitly deleted because base class 'test5::A' has an inaccessible copy assignment operator}}
+#endif
   void test2() {
     Test2 a;
-    a = Test2(); // expected-note{{implicit copy}}
+    a = Test2();
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy}}
+#else
+    // expected-error@-4 {{object of type 'test5::Test2' cannot be assigned because its copy assignment operator is implicitly deleted}}
+#endif
   }
 }
 
@@ -221,17 +302,40 @@
 namespace test6 {
   class A {
     public: A();
-    private: A(const A &); // expected-note 2 {{declared private here}}
+    private: A(const A &);
+#if __cplusplus <= 199711L
+    // expected-note@-2 2 {{declared private here}}
+#endif
   };
 
-  class Test1 { A a; }; // expected-error {{field of type 'test6::A' has private copy constructor}}
+  class Test1 { A a; };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{field of type 'test6::A' has private copy constructor}}
+#else
+  // expected-note@-4 {{copy constructor of 'Test1' is implicitly deleted because field 'a' has an inaccessible copy constructor}}
+#endif
   void test1(const Test1 &t) {
-    Test1 a = t; // expected-note{{implicit copy}}
+    Test1 a = t;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy constructor for 'test6::Test1' first required here}}
+#else
+    // expected-error@-4 {{call to implicitly-deleted copy constructor of 'test6::Test1'}}
+#endif
   }
 
-  class Test2 : A {}; // expected-error {{base class 'test6::A' has private copy constructor}}
+  class Test2 : A {};
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{base class 'test6::A' has private copy constructor}}
+#else
+  // expected-note@-4 {{copy constructor of 'Test2' is implicitly deleted because base class 'test6::A' has an inaccessible copy constructor}}
+#endif
   void test2(const Test2 &t) {
-    Test2 a = t; // expected-note{{implicit copy}}
+    Test2 a = t;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy constructor for 'test6::Test2' first required here}}
+#else
+    // expected-error@-4 {{call to implicitly-deleted copy constructor of 'test6::Test2'}}
+#endif
   }
 }
 
Index: test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp
===================================================================
--- test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp
+++ test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // C++03 [namespace.udecl]p4:
 //   A using-declaration used as a member-declaration shall refer to a
@@ -205,9 +207,19 @@
     using Base::bar; // expected-error {{no member named 'bar'}}
     using Unrelated::foo; // expected-error {{not a base class}}
     using C::foo; // legal in C++03
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{using declaration refers to its own class}}
+#endif
+
     using Subclass::foo; // legal in C++03
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{using declaration refers into 'Subclass::', which is not a base class of 'C'}}
+#endif
 
-    int bar(); //expected-note {{target of using declaration}}
+    int bar();
+#if __cplusplus <= 199711L
+    //expected-note@-2 {{target of using declaration}}
+#endif
     using C::bar; // expected-error {{refers to its own class}}
   };
 }
Index: test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp
===================================================================
--- test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp
+++ test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -Wc++11-compat -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wc++11-compat -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
 
 // Verify that the appropriate fixits are emitted for narrowing conversions in
 // initializer lists.
Index: test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp
===================================================================
--- test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp
+++ test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -Wbind-to-temporary-copy -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -Wbind-to-temporary-copy -verify -std=c++98 %s
 
 // C++03 requires that we check for a copy constructor when binding a
 // reference to a temporary, since we are allowed to make a copy, Even
Index: test/CXX/dcl.decl/dcl.init/p5.cpp
===================================================================
--- test/CXX/dcl.decl/dcl.init/p5.cpp
+++ test/CXX/dcl.decl/dcl.init/p5.cpp
@@ -1,27 +1,71 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 //   A program that calls for default-initialization or value-initialization of
 //   an entity of reference type is illformed. If T is a cv-qualified type, the
 //   cv-unqualified version of T is used for these definitions of
 //   zero-initialization, default-initialization, and value-initialization.
 
-struct S { // expected-error {{implicit default constructor for 'S' must explicitly initialize the reference member}}
-  int &x; // expected-note {{declared here}} expected-error 3{{reference to type 'int' requires an initializer}}
+struct S {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{implicit default constructor for 'S' must explicitly initialize the reference member}}
+#endif
+  int &x;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{declared here}}
+// expected-error@-3 3{{reference to type 'int' requires an initializer}}
+#else
+// expected-note@-5 4 {{default constructor of 'S' is implicitly deleted because field 'x' of reference type 'int &' would not be initialized}}
+#endif
 };
-S s; // expected-note {{implicit default constructor for 'S' first required here}}
+S s;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit default constructor for 'S' first required here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'S'}}
+#endif
+
 S f() {
-  return S(); // expected-note {{in value-initialization of type 'S' here}}
+  return S();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'S' here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'S'}}
+#endif
 }
 
 struct T
-  : S { // expected-note 2{{in value-initialization of type 'S' here}}
+  : S {
+#if __cplusplus <= 199711L
+// expected-note@-2 2 {{in value-initialization of type 'S' here}}
+#else
+// expected-note@-4 2 {{default constructor of 'T' is implicitly deleted because base class 'S' has a deleted default constructor}}
+#endif
 };
-T t = T(); // expected-note {{in value-initialization of type 'T' here}}
+T t = T();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'T' here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'T'}}
+#endif
+
 
 struct U {
-  T t[3]; // expected-note {{in value-initialization of type 'T' here}}
+  T t[3];
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'T' here}}
+#else
+// expected-note@-4 {{default constructor of 'U' is implicitly deleted because field 't' has a deleted default constructor}}
+#endif
 };
-U u = U(); // expected-note {{in value-initialization of type 'U' here}}
+U u = U();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'U' here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'U'}}
+#endif
+
 
 // Ensure that we handle C++11 in-class initializers properly as an extension.
 // In this case, there is no user-declared default constructor, so we
@@ -29,12 +73,18 @@
 // constructor call anyway, because the default constructor is not trivial.
 struct V {
   int n;
-  int &r = n; // expected-warning {{C++11}}
+  int &r = n;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
 };
 V v = V(); // ok
 struct W {
   int n;
-  S s = { n }; // expected-warning {{C++11}}
+  S s = { n };
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
 };
 W w = W(); // ok
 
Index: test/CXX/special/class.dtor/p9.cpp
===================================================================
--- test/CXX/special/class.dtor/p9.cpp
+++ test/CXX/special/class.dtor/p9.cpp
@@ -1,5 +1,9 @@
 // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=gnu++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=gnu++11 %s
 // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=gnu++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=gnu++11 %s
 
 typedef typeof(sizeof(int)) size_t;
 
@@ -64,11 +68,29 @@
   B::~B() {} // expected-error {{no suitable member 'operator delete' in 'B'}}
 
   struct CBase { virtual ~CBase(); };
-  struct C : CBase { // expected-error {{no suitable member 'operator delete' in 'C'}}
-    static void operator delete(void*, const int &); // expected-note {{declared here}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{overridden virtual function is here}}
+#endif
+
+  struct C : CBase {
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{no suitable member 'operator delete' in 'C'}}
+#else
+  // expected-error@-4 {{deleted function '~C' cannot override a non-deleted function}}
+  // expected-note@-5 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+    static void operator delete(void*, const int &);
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{member 'operator delete' declared her}}
+#endif
   };
   void test() {
-    C c; // expected-note {{first required here}}
+    C c;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit destructor for 'test2::C' first required here}}
+#else
+    // expected-error@-4 {{attempt to use a deleted function}}
+#endif
   }
 }
 
Index: test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
===================================================================
--- test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
+++ test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // C++0x [temp.arg.nontype] p5:
 //   The following conversions are performed on each expression used as
@@ -48,12 +50,26 @@
   template<X const *Ptr> struct A2; // expected-note{{template parameter is declared here}}
   
   X *X_ptr;
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
   X an_X;
   X array_of_Xs[10];
-  A2<X_ptr> *a12; // expected-error{{must have its address taken}}
+  A2<X_ptr> *a12;
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'const pointer_to_object_parameters::X *' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'pointer_to_object_parameters::X *' is not a constant expression}}
+  // expected-note@-5 {{read of non-constexpr variable 'X_ptr' is not allowed in a constant expression}}
+#endif
+
   A2<array_of_Xs> *a13;
   A2<&an_X> *a13_2;
-  A2<(&an_X)> *a13_3; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
+  A2<(&an_X)> *a13_3;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{address non-type template argument cannot be surrounded by parentheses}}
+#endif
 
   // PR6244
   struct X1 {} X1v;
@@ -63,11 +79,31 @@
 
   // PR6563
   int *bar;
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
   template <int *> struct zed {}; // expected-note 2{{template parameter is declared here}}
-  void g(zed<bar>*); // expected-error{{must have its address taken}}
+  void g(zed<bar>*);
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+  // expected-note@-5 {{read of non-constexpr variable 'bar' is not allowed in a constant expression}}
+#endif
 
   int baz;
-  void g2(zed<baz>*); // expected-error{{must have its address taken}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
+  void g2(zed<baz>*);
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'int' is not a constant expression}}
+  // expected-note@-5 {{read of non-const variable 'baz' is not allowed in a constant expression}}
+#endif
 
   void g3(zed<&baz>*); // okay
 }
@@ -143,11 +179,20 @@
   int f(float);
   int g(float);
   int (*funcptr)(int);
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
   void x0a(X0<f>);
   void x0b(X0<&f>);
   void x0c(X0<g>); // expected-error{{non-type template argument of type 'int (float)' cannot be converted to a value of type 'int (*)(int)'}}
   void x0d(X0<&g>); // expected-error{{non-type template argument of type 'int (*)(float)' cannot be converted to a value of type 'int (*)(int)'}}
-  void x0e(X0<funcptr>); // expected-error{{must have its address taken}}
+  void x0e(X0<funcptr>);
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int (*)(int)' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'int (*)(int)' is not a constant expression}}
+  // expected-note@-5 {{read of non-constexpr variable 'funcptr' is not allowed in a constant expression}}
+#endif
 }
 
 //     -- For a non-type template-parameter of type reference to function, no
Index: test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp
===================================================================
--- test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp
+++ test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp
@@ -1,6 +1,13 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
-struct IntHolder { // expected-note{{here}} // expected-note 2{{candidate constructor (the implicit copy constructor)}}
+struct IntHolder { // expected-note 2{{candidate constructor (the implicit copy constructor) not viable}}
+#if __cplusplus <=199711L
+// expected-note@-2 {{'IntHolder' declared here}}
+#else
+// expected-note@-4 2 {{candidate constructor (the implicit move constructor) not viable}}
+#endif
   IntHolder(int); // expected-note 2{{candidate constructor}}
 };
 
@@ -12,8 +19,16 @@
 
   void g() { }
   
-  struct Inner {  // expected-error{{implicit default}}
-    T value; 	// expected-note {{member is declared here}}
+  struct Inner {
+#if __cplusplus <=199711L
+  // expected-error@-2 {{implicit default constructor for 'X<IntHolder, int>::Inner' must explicitly initialize the member 'value' which does not have a default constructor}}
+#endif
+    T value;
+#if __cplusplus <=199711L
+    // expected-note@-2 {{member is declared here}}
+#else
+    // expected-note@-4 {{default constructor of 'Inner' is implicitly deleted because field 'value' has no default constructor}}
+#endif
   };
   
   static T value;
@@ -26,8 +41,13 @@
   xih.g(); // okay
   xih.f(); // expected-note{{instantiation}}
   
-  X<IntHolder, int>::Inner inner; // expected-note {{first required here}}
-  
+  X<IntHolder, int>::Inner inner;
+#if __cplusplus <=199711L
+  // expected-note@-2 {{implicit default constructor for 'X<IntHolder, int>::Inner' first required here}}
+#else
+  // expected-error@-4 {{call to implicitly-deleted default constructor of 'X<IntHolder, int>::Inner'}}
+#endif
+
   return X<IntHolder, int>::value; // expected-note{{instantiation}}
 }
 
Index: test/CXX/temp/temp.spec/temp.explicit/p4.cpp
===================================================================
--- test/CXX/temp/temp.spec/temp.explicit/p4.cpp
+++ test/CXX/temp/temp.spec/temp.explicit/p4.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
 
 template<typename T> void f0(T); // expected-note{{here}}
 template void f0(int); // expected-error{{explicit instantiation of undefined function template}}
@@ -16,20 +18,50 @@
 
 template int X0<int>::value; // expected-error{{explicit instantiation of undefined static data member}}
 
-template<> void f0(long); // expected-note{{previous template specialization is here}}
-template void f0(long); // expected-warning{{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
-
-template<> void X0<long>::f1(); // expected-note{{previous template specialization is here}}
-template void X0<long>::f1(); // expected-warning{{explicit instantiation of 'f1' that occurs after an explicit specialization will be ignored}}
-
-template<> struct X0<long>::Inner; // expected-note{{previous template specialization is here}}
-template struct X0<long>::Inner; // expected-warning{{explicit instantiation of 'Inner' that occurs after an explicit specialization will be ignored}}
-
-template<> long X0<long>::value; // expected-note{{previous template specialization is here}}
-template long X0<long>::value; // expected-warning{{explicit instantiation of 'value' that occurs after an explicit specialization will be ignored}}
-
-template<> struct X0<double>; // expected-note{{previous template specialization is here}}
-template struct X0<double>; // expected-warning{{explicit instantiation of 'X0<double>' that occurs after an explicit specialization will be ignored}}
+template<> void f0(long);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template void f0(long);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> void X0<long>::f1();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template void X0<long>::f1();
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'f1' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> struct X0<long>::Inner;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template struct X0<long>::Inner;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'Inner' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> long X0<long>::value;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template long X0<long>::value;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'value' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> struct X0<double>;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template struct X0<double>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'X0<double>' that occurs after an explicit specialization will be ignored}}
+#endif
 
 // PR 6458
 namespace test0 {
@@ -43,6 +75,9 @@
     // inappropriately instantiating this template.
     void *ptr = x;
   }
-  extern template class foo<char>; // expected-warning {{extern templates are a C++11 extension}}
+  extern template class foo<char>;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{extern templates are a C++11 extension}}
+#endif
   template class foo<char>;
 }
Index: test/CodeGenCXX/debug-info-use-after-free.cpp
===================================================================
--- test/CodeGenCXX/debug-info-use-after-free.cpp
+++ test/CodeGenCXX/debug-info-use-after-free.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only %s
+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only -std=c++98 %s
+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only -std=c++11 %s
 // Check that we don't crash.
 // PR12305, PR12315
 
@@ -233,6 +235,7 @@
 namespace {
 class
     AAA {
+protected:
       virtual ~
           AAA () {
           }};
Index: test/CodeGenCXX/dynamic-cast-hint.cpp
===================================================================
--- test/CodeGenCXX/dynamic-cast-hint.cpp
+++ test/CodeGenCXX/dynamic-cast-hint.cpp
@@ -1,7 +1,9 @@
 // RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -std=c++98 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -std=c++11 -o - %s | FileCheck %s
 
-class A { virtual ~A() {} };
-class B { virtual ~B() {} };
+class A { protected: virtual ~A() {} };
+class B { protected: virtual ~B() {} };
 
 class C : A { char x; };
 class D : public A { short y; };
Index: test/OpenMP/distribute_collapse_messages.cpp
===================================================================
--- test/OpenMP/distribute_collapse_messages.cpp
+++ test/OpenMP/distribute_collapse_messages.cpp
@@ -1,8 +1,13 @@
 // RUN: %clang_cc1 -verify -fopenmp %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s
 
 void foo() {
 }
 
+#if __cplusplus >= 201103L
+  // expected-note@+2 4 {{declared here}}
+#endif
 bool foobool(int argc) {
   return argc;
 }
@@ -29,6 +34,9 @@
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp distribute', but found only 1}}
+#if __cplusplus >= 201103L
+  // expected-note@+5 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   // expected-error@+3 2 {{directive '#pragma omp distribute' cannot contain more than one 'collapse' clause}}
   // expected-error@+2 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   // expected-error@+1 2 {{expression is not an integral constant expression}}
@@ -36,7 +44,11 @@
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (S) // expected-error {{'S' does not refer to a value}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
-  // expected-error@+1 2 {{expression is not an integral constant expression}}
+#if __cplusplus <= 199711L
+  // expected-error@+4 2 {{expression is not an integral constant expression}}
+#else
+  // expected-error@+2 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#endif
   #pragma omp distribute collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (1)
@@ -59,8 +71,14 @@
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp distribute', but found only 1}}
   #pragma omp distribute collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp distribute' are ignored}}  expected-note {{as specified in 'collapse' clause}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp distribute', but found only 1}}
+#if __cplusplus >= 201103L
+  // expected-note@+2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   #pragma omp distribute collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
+#if __cplusplus >= 201103L
+  // expected-note@+5 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   // expected-error@+3 {{expression is not an integral constant expression}}
   // expected-error@+2 2 {{directive '#pragma omp distribute' cannot contain more than one 'collapse' clause}}
   // expected-error@+1 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
@@ -68,7 +86,11 @@
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp distribute collapse (S1) // expected-error {{'S1' does not refer to a value}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
-  // expected-error@+1 {{expression is not an integral constant expression}}
+#if __cplusplus <= 199711L
+  // expected-error@+4 {{expression is not an integral constant expression}}
+#else
+  // expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#endif
   #pragma omp distribute collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   // expected-error@+3 {{statement after '#pragma omp distribute' must be a for loop}}
Index: test/OpenMP/ordered_messages.cpp
===================================================================
--- test/OpenMP/ordered_messages.cpp
+++ test/OpenMP/ordered_messages.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -o - %s
+// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++98 -o - %s
+// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++11 -o - %s
 
 int foo();
 
@@ -123,6 +125,9 @@
 #pragma omp ordered depend(sink : j, i) // expected-error {{expected 'i' loop iteration variable}} expected-error {{expected 'j' loop iteration variable}}
 #pragma omp ordered depend(sink : i, j, k) // expected-error {{unexpected expression: number of expressions is larger than the number of associated loops}}
 #pragma omp ordered depend(sink : i+foo(), j/4) // expected-error {{expression is not an integral constant expression}} expected-error {{expected '+' or '-' operation}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foo' cannot be used in a constant expression}}
+#endif
 #pragma omp ordered depend(sink : i*0, j-4)// expected-error {{expected '+' or '-' operation}}
 #pragma omp ordered depend(sink : i-0, j+sizeof(T)) depend(sink : i-0, j+sizeof(T))
 #pragma omp ordered depend(sink : i-0, j+sizeof(T)) depend(source) // expected-error {{'depend(source)' clause cannot be mixed with 'depend(sink:vec)' clauses}}
@@ -133,6 +138,9 @@
 }
 
 int foo() {
+#if __cplusplus >= 201103L
+// expected-note@-2 2 {{declared here}}
+#endif
 int k;
   #pragma omp for ordered
   for (int i = 0; i < 10; ++i) {
@@ -252,6 +260,9 @@
 #pragma omp ordered depend(sink : j, i) // expected-error {{expected 'i' loop iteration variable}} expected-error {{expected 'j' loop iteration variable}}
 #pragma omp ordered depend(sink : i, j, k) // expected-error {{unexpected expression: number of expressions is larger than the number of associated loops}}
 #pragma omp ordered depend(sink : i+foo(), j/4) // expected-error {{expression is not an integral constant expression}} expected-error {{expected '+' or '-' operation}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foo' cannot be used in a constant expression}}
+#endif
 #pragma omp ordered depend(sink : i*0, j-4)// expected-error {{expected '+' or '-' operation}}
 #pragma omp ordered depend(sink : i-0, j+sizeof(int)) depend(sink : i-0, j+sizeof(int))
 #pragma omp ordered depend(sink : i-0, j+sizeof(int)) depend(source) // expected-error {{'depend(source)' clause cannot be mixed with 'depend(sink:vec)' clauses}}
Index: test/OpenMP/target_parallel_for_collapse_messages.cpp
===================================================================
--- test/OpenMP/target_parallel_for_collapse_messages.cpp
+++ test/OpenMP/target_parallel_for_collapse_messages.cpp
@@ -1,9 +1,14 @@
 // RUN: %clang_cc1 -verify -fopenmp %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s
 
 void foo() {
 }
 
 bool foobool(int argc) {
+#if __cplusplus >= 201103L
+// expected-note@-2 4 {{declared here}}
+#endif
   return argc;
 }
 
@@ -33,10 +38,17 @@
   // expected-error@+2 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   // expected-error@+1 2 {{expression is not an integral constant expression}}
   #pragma omp target parallel for collapse (foobool(argc)), collapse (true), collapse (-5)
+#if __cplusplus >= 201103L
+// expected-note@-2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse (S) // expected-error {{'S' does not refer to a value}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
-  // expected-error@+1 2 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 2 {{expression is not an integral constant expression}}
+#endif
   #pragma omp target parallel for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse (1)
@@ -60,15 +72,25 @@
   #pragma omp target parallel for collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp target parallel for' are ignored}}  expected-note {{as specified in 'collapse' clause}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp target parallel for', but found only 1}}
   #pragma omp target parallel for collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   // expected-error@+3 {{expression is not an integral constant expression}}
   // expected-error@+2 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'collapse' clause}}
   // expected-error@+1 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   #pragma omp target parallel for collapse (foobool(argc)), collapse (true), collapse (-5) 
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp target parallel for collapse (S1) // expected-error {{'S1' does not refer to a value}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
-  // expected-error@+1 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 {{expression is not an integral constant expression}}
+#endif
   #pragma omp target parallel for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   // expected-error@+3 {{statement after '#pragma omp target parallel for' must be a for loop}}
Index: test/OpenMP/target_parallel_for_ordered_messages.cpp
===================================================================
--- test/OpenMP/target_parallel_for_ordered_messages.cpp
+++ test/OpenMP/target_parallel_for_ordered_messages.cpp
@@ -1,9 +1,14 @@
 // RUN: %clang_cc1 -verify -fopenmp %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s
 
 void foo() {
 }
 
 bool foobool(int argc) {
+#if __cplusplus >= 201103L
+// expected-note@-2 4 {{declared here}}
+#endif
   return argc;
 }
 
@@ -36,6 +41,9 @@
 #pragma omp target parallel for ordered((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'ordered' clause}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp target parallel for', but found only 1}}
+#if __cplusplus >= 201103L
+// expected-note@+5 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
 // expected-error@+3 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'ordered' clause}}
 // expected-error@+2 2 {{argument to 'ordered' clause must be a strictly positive integer value}}
 // expected-error@+1 2 {{expression is not an integral constant expression}}
@@ -45,7 +53,11 @@
 #pragma omp target parallel for ordered(S) // expected-error {{'S' does not refer to a value}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
-// expected-error@+1 2 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 2 {{expression is not an integral constant expression}}
+#endif
 #pragma omp target parallel for ordered(argv[1] = 2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
@@ -76,9 +88,15 @@
 #pragma omp target parallel for ordered(2 + 2))      // expected-warning {{extra tokens at the end of '#pragma omp target parallel for' are ignored}}  expected-note {{as specified in 'ordered' clause}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];            // expected-error {{expected 4 for loops after '#pragma omp target parallel for', but found only 1}}
+#if __cplusplus >= 201103L
+// expected-note@+2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
 #pragma omp target parallel for ordered(foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
+#if __cplusplus >= 201103L
+// expected-note@+5 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
 // expected-error@+3 {{expression is not an integral constant expression}}
 // expected-error@+2 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'ordered' clause}}
 // expected-error@+1 2 {{argument to 'ordered' clause must be a strictly positive integer value}}
@@ -88,7 +106,11 @@
 #pragma omp target parallel for ordered(S1) // expected-error {{'S1' does not refer to a value}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
-// expected-error@+1 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 {{expression is not an integral constant expression}}
+#endif
 #pragma omp target parallel for ordered(argv[1] = 2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
Index: test/SemaCXX/i-c-e-cxx.cpp
===================================================================
--- test/SemaCXX/i-c-e-cxx.cpp
+++ test/SemaCXX/i-c-e-cxx.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=gnu++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=gnu++11 %s
 
 // C++-specific tests for integral constant expressions.
 
@@ -16,9 +18,21 @@
 }
 
 int a() {
-  const int t=t; // expected-note {{declared here}} expected-note {{read of object outside its lifetime}}
-  switch(1) { // expected-warning {{no case matching constant switch condition '1'}}
-    case t:; // expected-error {{not an integral constant expression}} expected-note {{initializer of 't' is not a constant expression}}
+  const int t=t; // expected-note {{declared here}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{read of object outside its lifetime}}
+#endif
+
+  switch(1) {
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{no case matching constant switch condition '1'}}
+#endif
+    case t:; // expected-note {{initializer of 't' is not a constant expression}}
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{not an integral constant expression}}
+#else
+    // expected-error@-4 {{case value is not a constant expression}}
+#endif
   }
 }
 
@@ -48,7 +62,10 @@
 namespace rdar9204520 {
   
 struct A {
-  static const int B = int(0.75 * 1000 * 1000); // expected-warning {{not a constant expression; folding it to a constant is a GNU extension}}
+  static const int B = int(0.75 * 1000 * 1000);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{not a constant expression; folding it to a constant is a GNU extension}}
+#endif
 };
 
 int foo() { return A::B; }
@@ -59,10 +76,24 @@
 int* y = reinterpret_cast<const char&>(x); // expected-error {{cannot initialize}}
 
 // This isn't an integral constant expression, but make sure it folds anyway.
-struct PR8836 { char _; long long a; }; // expected-warning {{long long}}
-int PR8836test[(__typeof(sizeof(int)))&reinterpret_cast<const volatile char&>((((PR8836*)0)->a))]; // expected-warning {{folded to constant array as an extension}} expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
+struct PR8836 { char _; long long a; };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{'long long' is a C++11 extension}}
+#endif
+
+int PR8836test[(__typeof(sizeof(int)))&reinterpret_cast<const volatile char&>((((PR8836*)0)->a))];
+// expected-warning@-1 {{folded to constant array as an extension}}
+// expected-note@-2 {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
+
+const int nonconst = 1.0;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{declared here}}
+#endif
+int arr[nonconst];
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{folded to constant array as an extension}}
+// expected-note@-3 {{initializer of 'nonconst' is not a constant expression}}
+#endif
 
-const int nonconst = 1.0; // expected-note {{declared here}}
-int arr[nonconst]; // expected-warning {{folded to constant array as an extension}} expected-note {{initializer of 'nonconst' is not a constant expression}}
 const int castfloat = static_cast<int>(1.0);
 int arr2[castfloat]; // ok
Index: test/SemaCXX/implicit-virtual-member-functions.cpp
===================================================================
--- test/SemaCXX/implicit-virtual-member-functions.cpp
+++ test/SemaCXX/implicit-virtual-member-functions.cpp
@@ -1,33 +1,84 @@
 // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++11 %s
 // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++11 %s
+
 struct A {
   virtual ~A();
+#if __cplusplus >= 201103L
+// expected-note@-2 3 {{overridden virtual function is here}}
+#endif
 };
 
-struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}}
+struct B : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'B'}}
+#else
+// expected-error@-4 {{deleted function '~B' cannot override a non-deleted function}}
+#ifdef MSABI
+// expected-note@-6 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+#endif
   virtual void f();
 
-  void operator delete (void *, int); // expected-note {{'operator delete' declared here}}
+  void operator delete (void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 };
 
 #ifdef MSABI
-B b; // expected-note {{implicit destructor for 'B' first required here}}
+B b;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'B' first required here}}
+#else
+// expected-error@-4 {{attempt to use a deleted function}}
+#endif
+
 #else
-void B::f() { // expected-note {{implicit destructor for 'B' first required here}}
+void B::f() {
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'B' first required here}}
+#endif
 }
 #endif
 
-struct C : A { // expected-error {{no suitable member 'operator delete' in 'C'}}
+struct C : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'C'}}
+#else
+// expected-error@-4 {{deleted function '~C' cannot override a non-deleted function}}
+#endif
+
   C();
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 };
 
-C::C() { }  // expected-note {{implicit destructor for 'C' first required here}}
+C::C() { }
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'C' first required here}}
+#endif
 
-struct D : A { // expected-error {{no suitable member 'operator delete' in 'D'}}
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+struct D : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'D'}}
+#else
+// expected-error@-4 {{deleted function '~D' cannot override a non-deleted function}}
+#endif
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 }; 
 
 void f() {
-  new D; // expected-note {{implicit destructor for 'D' first required here}}
+  new D;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'D' first required here}}
+#endif
 }
Index: test/SemaCXX/new-delete.cpp
===================================================================
--- test/SemaCXX/new-delete.cpp
+++ test/SemaCXX/new-delete.cpp
@@ -1,7 +1,12 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null
+// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null -std=c++98
+// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null -std=c++11
 
 #include <stddef.h>
 
+#if __cplusplus >= 201103L
+// expected-note@+2 {{candidate constructor (the implicit move constructor) not viable}}
+#endif
 struct S // expected-note {{candidate}}
 {
   S(int, int, double); // expected-note {{candidate}}
@@ -19,6 +24,9 @@
 };
 
 inline void operator delete(void *); // expected-warning {{replacement function 'operator delete' cannot be declared 'inline'}}
+#if __cplusplus >= 201103L
+// expected-warning@-2 {{function previously declared with an explicit exception specification redeclared with an implicit exception specification}}
+#endif
 
 __attribute__((used))
 inline void *operator new(size_t) { // no warning, due to __attribute__((used))
@@ -72,7 +80,13 @@
   (void)new; // expected-error {{expected a type}}
   (void)new 4; // expected-error {{expected a type}}
   (void)new () int; // expected-error {{expected expression}}
-  (void)new int[1.1]; // expected-error {{array size expression must have integral or enumeration type, not 'double'}}
+  (void)new int[1.1];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array size expression must have integral or enumeration type, not 'double'}}
+#else
+  // expected-error@-4 {{array size expression must have integral or unscoped enumeration type, not 'double'}}
+#endif
+
   (void)new int[1][i]; // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
   (void)new (int[1][i]); // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
   (void)new (int[i]); // expected-warning {{when type is in parentheses}}
@@ -83,9 +97,27 @@
   (void)new const int; // expected-error {{default initialization of an object of const type 'const int'}}
   (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}}
   // Undefined, but clang should reject it directly.
-  (void)new int[-1]; // expected-error {{array size is negative}}
-  (void)new int[2000000000]; // expected-error {{array is too large}}
-  (void)new int[*(S*)0]; // expected-error {{array size expression must have integral or enumeration type, not 'S'}}
+  (void)new int[-1];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array size is negative}}
+#else
+  // expected-warning@-4 {{array size is negative}}
+#endif
+
+  (void)new int[2000000000];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array is too large}}
+#else
+  // expected-warning@-4 {{array is too large}}
+#endif
+
+  (void)new int[*(S*)0];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array size expression must have integral or enumeration type, not 'S'}}
+#else
+  // expected-error@-4 {{array size expression must have integral or unscoped enumeration type, not 'S'}}
+#endif
+
   (void)::S::new int; // expected-error {{expected unqualified-id}}
   (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}}
   (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}}
@@ -109,7 +141,12 @@
 void bad_deletes()
 {
   delete 0; // expected-error {{cannot delete expression of type 'int'}}
-  delete [0] (int*)0; // expected-error {{expected expression}}
+  delete [0] (int*)0;
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{expected expression}}
+#else
+  // expected-error@-4 {{expected variable name or 'this' in lambda capture list}}
+#endif
   delete (void*)0; // expected-warning {{cannot delete expression with pointer-to-'void' type 'void *'}}
   delete (T*)0; // expected-warning {{deleting pointer to incomplete type}}
   ::S::delete (int*)0; // expected-error {{expected unqualified-id}}
@@ -209,14 +246,31 @@
 
 struct X10 {
   virtual ~X10();
-};
-
-struct X11 : X10 { // expected-error {{no suitable member 'operator delete' in 'X11'}}
-  void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{overridden virtual function is here}}
+#endif
+};
+
+struct X11 : X10 {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'X11'}}
+#else
+// expected-error@-4 {{deleted function '~X11' cannot override a non-deleted function}}
+// expected-note@-5 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+  void operator delete(void*, int);
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{'operator delete' declared here}}
+#endif
 };
 
 void f() {
-  X11 x11; // expected-note {{implicit destructor for 'X11' first required here}}
+  X11 x11;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit destructor for 'X11' first required here}}
+#else
+  // expected-error@-4 {{attempt to use a deleted function}}
+#endif
 }
 
 struct X12 {
@@ -398,10 +452,24 @@
 }
 
 namespace ArrayNewNeedsDtor {
-  struct A { A(); private: ~A(); }; // expected-note {{declared private here}}
-  struct B { B(); A a; }; // expected-error {{field of type 'ArrayNewNeedsDtor::A' has private destructor}}
+  struct A { A(); private: ~A(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{declared private here}}
+#endif
+  struct B { B(); A a; };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{field of type 'ArrayNewNeedsDtor::A' has private destructor}}
+#else
+  // expected-note@-4 {{destructor of 'B' is implicitly deleted because field 'a' has an inaccessible destructor}}
+#endif
+
   B *test9() {
-    return new B[5]; // expected-note {{implicit destructor for 'ArrayNewNeedsDtor::B' first required here}}
+    return new B[5];
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit destructor for 'ArrayNewNeedsDtor::B' first required here}}
+#else
+    // expected-error@-4 {{attempt to use a deleted function}}
+#endif
   }
 }
 
Index: test/SemaCXX/no-wchar.cpp
===================================================================
--- test/SemaCXX/no-wchar.cpp
+++ test/SemaCXX/no-wchar.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify -std=c++98 %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify -std=c++11 %s
 wchar_t x; // expected-error {{unknown type name 'wchar_t'}}
 
 typedef unsigned short wchar_t;
@@ -9,7 +11,11 @@
 }
 
 void foo1(wchar_t * t = L"");
-// expected-warning@-1 {{conversion from string literal to 'wchar_t *' (aka 'unsigned short *') is deprecated}}
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{conversion from string literal to 'wchar_t *' (aka 'unsigned short *') is deprecated}}
+#else
+// expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'wchar_t *' (aka 'unsigned short *')}}
+#endif
 
 short *a = L"";
 // expected-error@-1 {{cannot initialize a variable of type 'short *' with an lvalue of type 'const unsigned short [1]'}}
Index: test/SemaCXX/virtual-member-functions-key-function.cpp
===================================================================
--- test/SemaCXX/virtual-member-functions-key-function.cpp
+++ test/SemaCXX/virtual-member-functions-key-function.cpp
@@ -1,20 +1,49 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
 struct A {
   virtual ~A();
+#if __cplusplus >= 201103L
+// expected-note@-2 2 {{overridden virtual function is here}}
+#endif
 };
 
-struct B : A {  // expected-error {{no suitable member 'operator delete' in 'B'}}
-  B() { } // expected-note {{implicit destructor for 'B' first required here}}
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+struct B : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'B'}}
+#else
+// expected-error@-4 {{deleted function '~B' cannot override a non-deleted function}}
+#endif
+  B() { }
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'B' first required here}}
+#endif
+
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 }; 
 
-struct C : A {  // expected-error {{no suitable member 'operator delete' in 'C'}}
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+struct C : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'C'}}
+#else
+// expected-error@-4 {{deleted function '~C' cannot override a non-deleted function}}
+#endif
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 }; 
 
 void f() {
   (void)new B; 
-  (void)new C; // expected-note {{implicit destructor for 'C' first required here}}
+  (void)new C;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'C' first required here}}
+#endif
 }
 
 // Make sure that the key-function computation is consistent when the
Index: test/SemaCXX/warn-bool-conversion.cpp
===================================================================
--- test/SemaCXX/warn-bool-conversion.cpp
+++ test/SemaCXX/warn-bool-conversion.cpp
@@ -1,19 +1,66 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 namespace BooleanFalse {
-int* j = false; // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
-
-void foo(int* i, int *j=(false)) // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+int* j = false;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'bool'}}
+#endif
+
+#if __cplusplus <= 199711L
+// expected-warning@+6 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@+4 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'bool'}}
+// expected-note@+3 {{passing argument to parameter 'j' here}}
+// expected-note@+2 6 {{candidate function not viable: requires 2 arguments, but 1 was provided}}
+#endif
+void foo(int* i, int *j=(false))
 {
-  foo(false); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
-  foo((int*)false); // no-warning: explicit cast
-  foo(0); // no-warning: not a bool, even though its convertible to bool
-
-  foo(false == true); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
-  foo((42 + 24) < 32); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+  foo(false);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo((int*)false);
+#if __cplusplus <= 199711L
+// no-warning: explicit cast
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo(0);
+#if __cplusplus <= 199711L
+// no-warning: not a bool, even though its convertible to bool
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo(false == true);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo((42 + 24) < 32);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
 
   const bool kFlag = false;
-  foo(kFlag); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+  foo(kFlag);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
 }
 
 char f(struct Undefined*);
Index: test/SemaCXX/zero-length-arrays.cpp
===================================================================
--- test/SemaCXX/zero-length-arrays.cpp
+++ test/SemaCXX/zero-length-arrays.cpp
@@ -1,5 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
-// expected-no-diagnostics
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // <rdar://problem/10228639>
 class Foo {
@@ -12,6 +13,9 @@
 class Bar {
   int foo_count;
   Foo foos[0];
+#if __cplusplus >= 201103L
+// expected-note@-2 {{copy constructor of 'Bar' is implicitly deleted because field 'foos' has an inaccessible copy constructor}}
+#endif
   Foo foos2[0][2];
   Foo foos3[2][0];
 
@@ -23,5 +27,10 @@
 void testBar() {
   Bar b;
   Bar b2(b);
+#if __cplusplus >= 201103L
+// expected-error@-2 {{call to implicitly-deleted copy constructor of 'Bar}}
+#else
+// expected-no-diagnostics
+#endif
   b = b2;
 }
Index: test/SemaTemplate/instantiate-c99.cpp
===================================================================
--- test/SemaTemplate/instantiate-c99.cpp
+++ test/SemaTemplate/instantiate-c99.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // Test template instantiation for C99-specific features.
 
@@ -9,8 +11,13 @@
 struct DesigInit0 {
   void f(XType x, YType y) {
     T agg = { 
+#if __cplusplus <= 199711L
       .y = y, // expected-error{{does not refer}}
       .x = x  // expected-error{{does not refer}}
+#else
+      .y = static_cast<float>(y), // expected-error{{does not refer}}
+      .x = static_cast<float>(x)  // expected-error{{does not refer}}
+#endif
     };
   }
 };
@@ -44,7 +51,11 @@
 struct DesigArrayInit0 {
   void f(Val1 val1, Val2 val2) {
     T array = {
+#if __cplusplus <= 199711L
       [Subscript1] = val1,
+#else
+      [Subscript1] = static_cast<int>(val1),
+#endif
       [Subscript2] = val2 // expected-error{{exceeds array bounds}}
     };
 
@@ -60,7 +71,11 @@
 struct DesigArrayRangeInit0 {
   void f(Val1 val1) {
     T array = {
+#if __cplusplus <= 199711L
       [Subscript1...Subscript2] = val1 // expected-error{{exceeds}}
+#else
+      [Subscript1...Subscript2] = static_cast<int>(val1) // expected-error{{exceeds}}
+#endif
     };
   }
 };
@@ -74,7 +89,11 @@
 template<typename T, typename Arg1, typename Arg2>
 struct CompoundLiteral0 {
   T f(Arg1 a1, Arg2 a2) {
+#if __cplusplus <= 199711L
     return (T){a1, a2};
+#else
+    return (T){static_cast<float>(a1), a2};
+#endif
   }
 };
 
Index: test/SemaTemplate/temp_explicit.cpp
===================================================================
--- test/SemaTemplate/temp_explicit.cpp
+++ test/SemaTemplate/temp_explicit.cpp
@@ -1,4 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
 //
 // Tests explicit instantiation of templates.
 template<typename T, typename U = T> class X0 { };
@@ -25,8 +27,15 @@
 // instantiations or declarations.
 template class X0<int, int>; // expected-error{{duplicate}}
 
-template<> class X0<char> { }; // expected-note{{previous}}
-template class X0<char>; // expected-warning{{ignored}}
+template<> class X0<char> { };
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+
+template class X0<char>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'X0<char, char>' that occurs after an explicit specialization will be ignored (C++11 extension)}}
+#endif
 
 void foo(X0<short>) { }
 template class X0<short>;
@@ -98,7 +107,12 @@
 template struct X5<float&>::Inner2; // expected-note{{instantiation}}
 
 namespace N3 {
-  template struct N2::X5<int>::Inner2; // expected-warning {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+  template struct N2::X5<int>::Inner2;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+#endif
 }
 
 struct X6 {
@@ -145,7 +159,17 @@
 namespace N2 {
   using namespace N1;
 
-  template struct X7<double>; // expected-warning{{must occur in namespace}}
-
-  template struct X9<float>; // expected-warning{{must occur at global scope}}
+  template struct X7<double>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
+#endif
+
+  template struct X9<float>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'X9' must occur at global scope}}
+#else
+// expected-error@-4 {{explicit instantiation of 'X9' must occur at global scope}}
+#endif
 }
Index: test/SemaTemplate/value-dependent-null-pointer-constant.cpp
===================================================================
--- test/SemaTemplate/value-dependent-null-pointer-constant.cpp
+++ test/SemaTemplate/value-dependent-null-pointer-constant.cpp
@@ -1,17 +1,30 @@
-// RUN: %clang_cc1 -fsyntax-only %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 template<typename T, int N>
 struct X0 {
   const char *f0(bool Cond) {
     return Cond? "honk" : N;
+#if __cplusplus >= 201103L
+// expected-error@-2 {{incompatible operand types ('const char *' and 'int')}}
+#else
+// expected-no-diagnostics
+#endif
   }
 
   const char *f1(bool Cond) {
     return Cond? N : "honk";
+#if __cplusplus >= 201103L
+// expected-error@-2 {{incompatible operand types ('int' and 'const char *')}}
+#endif
   }
   
   bool f2(const char *str) {
     return str == N;
+#if __cplusplus >= 201103L
+// expected-error@-2 {{comparison between pointer and integer ('const char *' and 'int')}}
+#endif
   }
 };
 
Index: test/SemaTemplate/virtual-member-functions.cpp
===================================================================
--- test/SemaTemplate/virtual-member-functions.cpp
+++ test/SemaTemplate/virtual-member-functions.cpp
@@ -1,5 +1,9 @@
 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -std=c++98 -verify %s
+// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -std=c++11 -verify %s
 
 namespace PR5557 {
 template <class T> struct A {
@@ -76,34 +80,74 @@
 }
 
 namespace PR7114 {
-  class A { virtual ~A(); }; // expected-note{{declared private here}}
+  class A { virtual ~A(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2{{declared private here}}
+#else
+  // expected-note@-4 3 {{overridden virtual function is here}}
+#endif
 
   template<typename T>
   class B {
   public:
-    class Inner : public A { }; // expected-error{{base class 'PR7114::A' has private destructor}}
+    class Inner : public A { };
+#if __cplusplus <= 199711L
+// expected-error@-2{{base class 'PR7114::A' has private destructor}}
+#else
+// expected-error@-4 2 {{deleted function '~Inner' cannot override a non-deleted function}}
+#ifdef MSABI
+// expected-note@-6 1 {{destructor of 'Inner' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor}}
+#endif
+#endif
+
     static Inner i;
     static const unsigned value = sizeof(i) == 4;
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of member class 'PR7114::B<int>::Inner' requested here}}
+// expected-note@-3 {{in instantiation of member class 'PR7114::B<float>::Inner' requested here}}
+#endif
   };
 
   int f() { return B<int>::value; }
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of template class 'PR7114::B<int>' requested here}}
+#endif
 
 #ifdef MSABI
-  void test_typeid(B<float>::Inner bfi) { // expected-note{{implicit destructor}}
+  void test_typeid(B<float>::Inner bfi) {
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor}}
+#else
+// expected-error@-4 {{attempt to use a deleted function}}
+// expected-note@-5 {{in instantiation of template class 'PR7114::B<float>' requested here}}
+#endif
+
     (void)typeid(bfi);
 #else
   void test_typeid(B<float>::Inner bfi) {
-    (void)typeid(bfi); // expected-note{{implicit destructor}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of template class 'PR7114::B<float>' requested here}}
+#endif
+    (void)typeid(bfi);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor}}
+#endif
 #endif
   }
 
   template<typename T>
   struct X : A {
+#if __cplusplus >= 201103L
+// expected-error@-2{{deleted function '~X' cannot override a non-deleted function}}
+#endif
     void f() { }
   };
 
   void test_X(X<int> &xi, X<float> &xf) {
     xi.f();
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of template class 'PR7114::X<int>' requested here}}
+#endif
   }
 }