Use the MS ABI for Win32 target by default

[hans]

Summary

This makes Clang use the MS ABI by default when targeting Win32.

In addition to being a sensible default, this also improves the test coverage for the MS ABI: any bot that targets Win32 will now run the tests in MS ABI mode by default.

I plan to commit this in two steps: test updates first, and functionality change second so that it can be reverted separately if needed.

[rnk]

I think all the test/CodeGen* changes are good, and should probably land now.

The test/CXX and test/SemaCXX changes should probably be reviewed separately by Richard.

test/CXX/drs/dr2xx.cpp

543 ↗

(On Diff #6089)

So, I remember we decided to do it this way, but now we've essentially weakened this test to pass if we fail to diagnose this in the Itanium C++ ABI. Can you remind me what the issue is here? This has to do with differing operator delete lookup behavior?

[rsmith]

I wonder if we're being too eager when performing operator delete lookup for a class with a virtual destructor. Instead of performing the lookup when the destructor is declared, could we defer it until the vtable is used?

test/CXX/class.access/p4.cpp

129 ↗

(On Diff #6089)

Why do we do the access check in the callee under the MS ABI? We can still do dtor access checks in the caller, even though we actually make the call in the callee, can't we? Presumably MSVC redundantly checks access in both places?

(Do we need to omit the access checking in the caller for compatibility somehow?)

test/CXX/drs/dr2xx.cpp

543 ↗

(On Diff #6089)

Please conditionalize this extra diagnostic on use of the MS ABI. Do we have a predefined macro indicating the ABI? If not, maybe we should add one?

test/CXX/special/class.dtor/p5-0x.cpp

98–104 ↗

(On Diff #6089)

This looks incorrect. We shouldn't be trying to mark the operator delete as used if the destructor is deleted.

test/Sema/empty1.c

1 ↗

(On Diff #6089)

This looks weird. I think you're adding this because empty structs have size 4 under MSVC, but that's controlled by the psABI, not the C++ ABI.

test/SemaCXX/destructor.cpp

86–93 ↗

(On Diff #6089)

Please test that this produces diagnostics with the MS ABI, rather than not testing it at all.

108–117 ↗

(On Diff #6089)

There's something odd here. We should be producing a note indicating the place at which the instantiation of A<int> was triggered under the MS ABI.

test/SemaCXX/implicit-virtual-member-functions.cpp

7–16 ↗

(On Diff #6089)

Can you provide an alternative set of expected diagnostics here for MS ABI rather than disabling that half of the test? (I assume the point is that we trigger operator delete lookup earlier?)

test/SemaCXX/undefined-internal.cpp

1–4 ↗

(On Diff #6089)

Why does this test need to force the Itanium ABI?

test/SemaCXX/virtual-base-used.cpp

1 ↗

(On Diff #6089)

Why does this test need to force the Itanium ABI?

test/SemaCXX/warn-weak-vtables.cpp

1 ↗

(On Diff #6089)

Can you also test this in MS ABI mode, to ensure the warning is suppressed there? Something like -Wweak-vtables -Wweak-template-vtables -Werror (with no -verify)?

test/SemaTemplate/virtual-member-functions.cpp

89–93 ↗

(On Diff #6089)

Maybe instead change this test to pass the arguments by reference instead of by value?

[hans]

I think all the test/CodeGen* changes are good, and should probably land now.

OK, I'll split off and commit those. It should make this patch easier to manage :)

test/CXX/class.access/p4.cpp

129 ↗

(On Diff #6089)

IIRC, Reid told me that John had told him to do the access check in the callee too when he implemented this.

We still have the access check in the caller.

test/CXX/drs/dr2xx.cpp

543 ↗

(On Diff #6089)

Can you remind me what the issue is here? This has to do with differing operator delete lookup behavior?

Yes, we diagnose the multiple 'operator delete' when 'virtual ~C()' is declared below, whereas in Itanium we diagnose it when that dtor is defined further on.

543 ↗

(On Diff #6089)

Please conditionalize this extra diagnostic on use of the MS ABI.

Done.

Do we have a predefined macro indicating the ABI? If not, maybe we should add one?

No, we don't have a macro for this. We could create one, but it's also easy to run the test in both modes and set a macro ourselves, I've done that in a few other tests.

test/CXX/special/class.dtor/p5-0x.cpp

98–104 ↗

(On Diff #6089)

But neither ~D3() nor ~D4() below are deleted.

test/Sema/empty1.c

1 ↗

(On Diff #6089)

Hmm, it seems to be controlled by -cxx-abi by us :) I agree this is weird, though.

Would you be ok a FIXME here and filing a bug with Warren on the cc list? Or running the test with a fixed target?

test/SemaCXX/destructor.cpp

86–93 ↗

(On Diff #6089)

Done.

108–117 ↗

(On Diff #6089)

But we are. In MS ABI we emit a note on the declaration of '~A()'. On itanium the note comes later, on the definition of 'class B'.

test/SemaCXX/implicit-virtual-member-functions.cpp

7–16 ↗

(On Diff #6089)

In MS ABI we don't require the destructor for B here, so we expect no diagnostics. I've fixed the test to check that.

test/SemaCXX/undefined-internal.cpp

1–4 ↗

(On Diff #6089)

We fail during codegen with "error: cannot mangle RTTI descriptors for type 'A' yet", and we need RTTI for the typeid which is used in the test.

This isn't a problem for the '-verify' line though. I'll update that.

test/SemaCXX/virtual-base-used.cpp

1 ↗

(On Diff #6089)

In MS ABI we don't emit any diagnostics in this test. We should probably take a second look and verify that's correct behaviour.

I figured the test mostly seemed to be a regression test for the ICE in PR7800, so maybe we shouldn't run it in MS mode since none of the expectations apply.

test/SemaCXX/warn-weak-vtables.cpp

1 ↗

(On Diff #6089)

Done.

test/SemaTemplate/virtual-member-functions.cpp

89–93 ↗

(On Diff #6089)

Done.

[hans]

Address comments and cut out the CodeGenCXX tests which were committed in r197281.

[rsmith]

test/CXX/class.access/p4.cpp

129 ↗

(On Diff #6089)

So the access check in the callee serves no purpose other than to reject valid code? Can we just remove it?

test/CXX/drs/dr2xx.cpp

543 ↗

(On Diff #6089)

I think the macro would be generally useful, and not just as a way of cleaning up these tests slightly. But that's something we can address separately.

test/CXX/special/class.dtor/p5-0x.cpp

98–104 ↗

(On Diff #6089)

The expected-* diagnostics below say that they both are.

test/Sema/empty1.c

1 ↗

(On Diff #6089)

Sure, a FIXME works for me.

test/SemaCXX/destructor.cpp

108–117 ↗

(On Diff #6089)

Sure, but that diagnostic doesn't actually say why we're instantiating A<int>; we're missing the outermost level of the instantiation backtrace.

test/SemaCXX/implicit-virtual-member-functions.cpp

7–16 ↗

(On Diff #6089)

That seems inconsistent: B (implicitly) has a virtual destructor, and operator delete lookup for it would fail, but we don't diagnose it.

test/SemaCXX/undefined-internal.cpp

1–4 ↗

(On Diff #6089)

Please either XFAIL or add a FIXME; this test *should* pass without the -cxx-abi itanium.

test/SemaCXX/virtual-base-used.cpp

1 ↗

(On Diff #6089)

This looks like the same root cause as implicit-virtual-member-functions.cpp -- we don't trigger vtable emission, so we don't implicitly define the destructor. In both that file and this one, you could get more consistent behavior in the MS ABI with something like this:

  void D::foo() {}
  D d;
#if MSABI
  // expected-note@-2 {{implicit destructor for 'B' first required here}}
#else
  // expected-note@-5 {{implicit destructor for 'B' first required here}}
#endif

[hans]

Thanks for the review! New patch coming up.

test/CXX/class.access/p4.cpp

129 ↗

(On Diff #6089)

I've sent out a patch for this: http://llvm-reviews.chandlerc.com/D2409

test/Sema/empty1.c

1 ↗

(On Diff #6089)

OK, added a FIXME.

test/SemaCXX/destructor.cpp

108–117 ↗

(On Diff #6089)

I think something like this is happening (and correct me if I'm wrong, because I'm not familiar with the instantiation process):

When we declare B, we require the complete class of A, so we instantiate it (Sema::InstantiateClass), and then we do Sema::CheckCompletedCXXClass. In MS ABI mode, this means that we call CheckDestructor() (see r182270), which will mark the destructor as referenced, and is added to PendingInstantiations.

Later, we process the destructor in PendingInstantiations. But now we don't have anything on the ActiveInstantiations list, so we fail to emit a note about why we're instantiating it.

I don't see a straightforward way of fixing this, and since we plan on moving these checks to some later time (vtable emission or something), would it be alright to just put a FIXME here in the meantime?

test/SemaCXX/implicit-virtual-member-functions.cpp

7–16 ↗

(On Diff #6089)

I've added "new D" calls to trigger vtable emission, I think it worked out pretty well in this test.

test/SemaCXX/undefined-internal.cpp

1–4 ↗

(On Diff #6089)

I've added a FIXME.

test/SemaCXX/virtual-base-used.cpp

1 ↗

(On Diff #6089)

This worked great in implicit-virtual-member-functions.cpp, but in this test it gets a bit more hairy as it we start getting a bunch of notes about requiring implicit default constructors etc. I don't know if it's ok, if there's a cleaner way, or if it's not worth the mess to run the test in ms mode.

[hans]

Address comments.

[hans]

Tiny update: no need to change test/CXX/special/class.dtor/p5-0x.cpp anymore.

[hans]

I'd really like to get this in, so trying to summarize where we are on the tests. I think these are the three tests that are still under discussion:

test/CXX/class.access/p4.cpp
The "Elide dtor access checks for pass-by-val objects in callees" patch at http://llvm-reviews.chandlerc.com/D2409 addresses this. Can we decide to make the expectations in this test depend on the outcome of that code review?

test/SemaCXX/destructor.cpp
The missing outermost level of template instantiation backtrace. I've commented on this.

test/SemaCXX/virtual-base-used.cpp
Adding "new D" to trigger vtable emission got pretty hairy here, so maybe we don't want to do that.

Richard: I'm interested to hear your thoughts.

• Hans

[hans]

Back from the holidays, let's see if we can get this landed :)

I've rebased the patch. The only necessary change was to force itanium mode for CodeGenCXX/instr-profile.cpp (it has expectations on itanium-mangled names, and uses exceptions/RTTI which the MS mode cannot handle).

IIRC, this is where we left last year:

test/CXX/class.access/p4.cpp - Dtor access checks for pass-by-value objects in callee. I think David's comment on http://llvm-reviews.chandlerc.com/D2409 about this being SFINAE-detectable means we need to follow visual studio here.

test/SemaCXX/destructor.cpp - Missing outermost level of template instantiation backtrace, I've commented on this at http://llvm-reviews.chandlerc.com/D2401?id=6089#inline-12902

test/SemaCXX/virtual-base-used.cpp - Adding "new D" to trigger vtable emission got pretty hairy here, so maybe we don't want to do that.

Please take a look.

[rsmith]

LGTM

I'd still be interested in us pursuing two things:

1. Don't access-check the dtor call for a by-val parameter (D2409), and
2. Don't perform operator delete lookup when we see a virtual dtor declaration, instead perform it when we see a dtor definition or a use of the vtable.

But those don't have to happen before this lands.

test/SemaCXX/virtual-base-used.cpp

1–2 ↗

(On Diff #6401)

Please add a comment somewhere in this test explaining that we need to do different things for MSVC versus Itanium because MSVC doesn't have key functions.

test/SemaCXX/warn-weak-vtables.cpp

2 ↗

(On Diff #6401)

Maybe -Werror here? Otherwise I'm not sure what the -Wno-weak-* are for.

test/SemaTemplate/instantiate-exception-spec-cxx11.cpp

1 ↗

(On Diff #6401)

Please add a comment saying that this test is Itanium-specific because it depends on key functions in namespace PR12763 (maybe as a FIXME).

[hans]

Closed by commit rL199130 (authored by @hans).

cfe/trunk/test/Analysis/inlining/dyn-dispatch-bifurcate.cpp

-// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=dynamic-bifurcate -verify %s
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=dynamic-bifurcate -verify -Wno-reinterpret-base-class %s
 
 void clang_analyzer_eval(bool);
 
 class A {
 public:
   virtual int get() { return 0; }
 };
 

cfe/trunk/test/CXX/dcl.dcl/dcl.link/p7.cpp

-// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s
 
 struct X { };
 
 // CHECK: @x1 = global %struct.X zeroinitializer
 // CHECK: @x4 = global %struct.X zeroinitializer
 // CHECK: @x2 = external global %struct.X
 // CHECK: @x3 = external global %struct.X
 extern "C" {
-
-
   X x1;
 }
 
 extern "C" X x2;
 
 extern X x3;
 
 X x4;

cfe/trunk/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p2.cpp

-// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm -cxx-abi itanium %s -o - | FileCheck %s
 
 // constexpr functions and constexpr constructors are implicitly inline.
 struct S {
   constexpr S(int n);
   constexpr int g();
   int n;
 };
 

cfe/trunk/test/CXX/drs/dr2xx.cpp

-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi itanium
+// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi itanium
+// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi itanium
+
+// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi microsoft -DMSABI
+// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi microsoft -DMSABI
+// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -cxx-abi microsoft -DMSABI
 
 // PR13819 -- __SIZE_TYPE__ is incompatible.
 typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}}
 
 #if __cplusplus < 201103L
 #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
 #else
 #define fold
namespace dr250 { // dr250: yes
   FPtr fp = &f<3>;
 
   template<int I = 3> void g(double x[]); // expected-error 0-1{{extension}}
   FPtr gp = &g<>;
 }
 
 namespace dr252 { // dr252: yes
   struct A {
+#ifdef MSABI
+    // expected-note@+2 {{found}}
+#endif
     void operator delete(void*); // expected-note {{found}}
   };
   struct B {
+#ifdef MSABI
+    // expected-note@+2 {{found}}
+#endif
     void operator delete(void*); // expected-note {{found}}
   };
   struct C : A, B {
+#ifdef MSABI
+    // expected-error@+2 {{'operator delete' found in multiple base classes}}
+#endif
     virtual ~C();
   };
   C::~C() {} // expected-error {{'operator delete' found in multiple base classes}}
 
   struct D {
+#ifdef MSABI
+    // expected-note@+3 {{here}} MSABI
+    // expected-error@+3 {{no suitable member 'operator delete'}}
+#endif
     void operator delete(void*, int); // expected-note {{here}}
     virtual ~D();
   };
   D::~D() {} // expected-error {{no suitable member 'operator delete'}}
 
   struct E {
     void operator delete(void*, int);
-    void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note {{here}}
-    virtual ~E();
+    void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note 1-2 {{here}}
+    virtual ~E(); // expected-error 0-1 {{attempt to use a deleted function}}
   };
-  E::~E() {} // expected-error {{deleted}}
+  E::~E() {} // expected-error {{attempt to use a deleted function}}
 
   struct F {
     // If both functions are available, the first one is a placement delete.
     void operator delete(void*, size_t);
+#ifdef MSABI
+    // expected-note@+3 {{here}}
+    // expected-error@+3 {{attempt to use a deleted function}}
+#endif
     void operator delete(void*) = delete; // expected-error 0-1{{extension}} expected-note {{here}}
     virtual ~F();
   };
-  F::~F() {} // expected-error {{deleted}}
+  F::~F() {} // expected-error {{attempt to use a deleted function}}
 
   struct G {
     void operator delete(void*, size_t);
     virtual ~G();
   };
   G::~G() {}
 }
 

cfe/trunk/test/CXX/special/class.copy/implicit-move-def.cpp

-// FIXME: %clang_cc1 -emit-llvm -o - -std=c++11 %s | FileCheck -check-prefix=CHECK %s
-// RUN: %clang_cc1 -emit-llvm -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-ASSIGN %s
-// RUN: %clang_cc1 -emit-llvm -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-CTOR %s
+// FIXME: %clang_cc1 -emit-llvm -cxx-abi itanium -o - -std=c++11 %s | FileCheck -check-prefix=CHECK %s
+// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-ASSIGN %s
+// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -o - -std=c++11 %s | FileCheck -check-prefix=CHECK-CTOR %s
 
 // construct
 
 struct E {
   E();
   E(E&&);
 };
 

cfe/trunk/test/CXX/special/class.dtor/p3-0x.cpp

-// RUN: %clang_cc1 -std=c++11 -fexceptions -fcxx-exceptions -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fexceptions -fcxx-exceptions -emit-llvm -o - %s | FileCheck %s
 
 struct A {
   ~A();
 };
 
 struct B {
   ~B() throw(int);
 };

cfe/trunk/test/CXX/special/class.dtor/p9.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s
+// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -DMSABI -verify %s
 
 typedef typeof(sizeof(int)) size_t;
 
 // PR7803
 namespace test0 {
   class A {
   public:
     static void operator delete(void *p) {};
namespace test0 {
 
   // Shouldn't have an error.
   C::~C() {}
 }
 
 namespace test1 {
   class A {
   public:
+#ifdef MSABI
+    // expected-note@+2 {{declared here}}
+#endif
     static void operator delete(void *p) {}; // expected-note {{member 'operator delete' declared here}}
     virtual ~A();
   };
 
   class B : protected A {
   public:
+#ifdef MSABI
+    // expected-note@+2 {{declared here}}
+#endif
     static void operator delete(void *, size_t) {}; // expected-note {{member 'operator delete' declared here}}
     ~B();
   };
 
   class C : protected B {
   public:
     using A::operator delete;
     using B::operator delete;
 
+#ifdef MSABI
+    // expected-error@+2 {{multiple suitable 'operator delete' functions in 'C'}}
+#endif
     ~C();
   };
 
   C::~C() {} // expected-error {{multiple suitable 'operator delete' functions in 'C'}}
 }
 
 // ...at the point of definition of a virtual destructor...
 namespace test2 {
   struct A {
+#ifdef MSABI
+    // expected-error@+3 {{no suitable member 'operator delete' in 'A'}}
+    // expected-note@+3 {{declared here}}
+#endif
     virtual ~A();
     static void operator delete(void*, const int &);
   };
 
   struct B {
+#ifdef MSABI
+    // expected-error@+2 {{no suitable member 'operator delete' in 'B'}}
+#endif
     virtual ~B();
+#ifdef MSABI
+    // expected-note@+2 {{declared here}}
+#endif
     static void operator delete(void*, const int &); // expected-note {{declared here}}
   };
   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}}
   };
   void test() {
     C c; // expected-note {{first required here}}
   }
 }
 
 // PR7346
 namespace test3 {
   struct A {
+#ifdef MSABI
+    // expected-error@+2 {{no suitable member 'operator delete' in 'A'}}
+#endif
     virtual ~A();
+#ifdef MSABI
+    // expected-note@+2 {{declared here}}
+#endif
     static void operator delete(void*, const int &);
   };
 
   struct B : A {
     virtual ~B() {}
     static void operator delete(void*);
   };
 }

cfe/trunk/test/CodeGen/builtin-ms-noop.cpp

-// RUN: %clang_cc1 -fms-extensions -triple i686-pc-win32 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fms-extensions -triple i686-pc-win32 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s
 
 class A {
  public:
   ~A() {}
 };
 
 void f() {
 // CHECK: @_Z1fv
 // CHECK-NOT: call void @_ZN1AD1Ev
 // CHECK: ret void
   __noop(A());
 };
-

cfe/trunk/test/CodeGen/captured-statements.c

-// RUN: %clang_cc1 -emit-llvm %s -o %t
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o %t
 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-GLOBALS
 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-1
 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2
 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-3
 
 int foo();
 int global;
 

cfe/trunk/test/CodeGen/complex-convert.c

void foo(signed char sc, unsigned char uc, signed long long sll,
   unsigned char uc1;
   signed long long sll1;
   unsigned long long ull1;
   _Complex signed char csc1;
   _Complex unsigned char cuc1;
   _Complex signed long long csll1;
   _Complex unsigned long long cull1;
   // CHECK-LABEL: define void @foo(
-  // CHECK: alloca i[[CHSIZE:[0-9]+]], align [[CHALIGN:[0-9]+]]
-  // CHECK-NEXT: alloca i[[CHSIZE]], align [[CHALIGN]]
-  // CHECK-NEXT: alloca i[[LLSIZE:[0-9]+]], align [[LLALIGN:[0-9]+]]
+  // Match the prototype to pick up the size of sc and sll.
+  // CHECK: i[[CHSIZE:[0-9]+]]{{[^,]*}},
+  // CHECK: i[[CHSIZE]]{{[^,]*}},
+  // CHECK: i[[LLSIZE:[0-9]+]]
+
+  // Match against the allocas to pick up the alignments.
+  // CHECK: alloca i[[CHSIZE]], align [[CHALIGN:[0-9]+]]
+  // CHECK: alloca i[[LLSIZE]], align [[LLALIGN:[0-9]+]]
 
   sc1 = csc;
   // CHECK: %[[VAR1:[A-Za-z0-9.]+]] = getelementptr inbounds { i[[CHSIZE]], i[[CHSIZE]]  }* %[[CSC:[A-Za-z0-9.]+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
   // CHECK-NEXT: %[[VAR2:[A-Za-z0-9.]+]] = load i[[CHSIZE]]* %[[VAR1]]
   // CHECK-NEXT: store i[[CHSIZE]] %[[VAR2]], i[[CHSIZE]]* %[[SC1:[A-Za-z0-9.]+]], align [[CHALIGN]]
 
   sc1 = cuc;
   // CHECK-NEXT: %[[VAR3:[A-Za-z0-9.]+]] = getelementptr inbounds { i[[CHSIZE]], i[[CHSIZE]]  }* %[[CUC:[A-Za-z0-9.]+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0

cfe/trunk/test/CodeGen/cxx-default-arg.cpp

-// RUN: %clang_cc1 -emit-llvm %s -o %t
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o %t
 
 // Note-LABEL: define CLANG_GENERATE_KNOWN_GOOD and compile to generate code
 // that makes all of the defaulted arguments explicit. The resulting
 // byte code should be identical to the compilation without
 // CLANG_GENERATE_KNOWN_GOOD.
 #ifdef CLANG_GENERATE_KNOWN_GOOD
 #  define DEFARG(...) __VA_ARGS__
 #else

cfe/trunk/test/CodeGen/fp-contract-pragma.cpp

-// RUN: %clang_cc1 -O3 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -O3 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s
 
 // Is FP_CONTRACT is honored in a simple case?
 float fp_contract_1(float a, float b, float c) {
 // CHECK: _Z13fp_contract_1fff
 // CHECK: tail call float @llvm.fmuladd
   #pragma STDC FP_CONTRACT ON
   return a * b + c;
 }

cfe/trunk/test/CodeGen/overloadable.c

-// RUN: %clang_cc1 -emit-llvm %s -o - | grep _Z1fPA10_1X
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | grep _Z1fPA10_1X
 int __attribute__((overloadable)) f(int x) { return x; }
 float __attribute__((overloadable)) f(float x) { return x; }
 double __attribute__((overloadable)) f(double x) { return x; }
 double _Complex __attribute__((overloadable)) f(double _Complex x) { return x; }
 typedef short v4hi __attribute__ ((__vector_size__ (8)));
 v4hi __attribute__((overloadable)) f(v4hi x) { return x; }
 
 struct X { };

cfe/trunk/test/CodeGen/tbaa-for-vptr.cpp

-// RUN: %clang_cc1 -emit-llvm -o - -fsanitize=thread %s | FileCheck %s
-// RUN: %clang_cc1 -emit-llvm -o - -O1 %s | FileCheck %s
-// RUN: %clang_cc1 -emit-llvm -o - -O1  -relaxed-aliasing -fsanitize=thread %s | FileCheck %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -fsanitize=thread %s | FileCheck %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -O1 %s | FileCheck %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -O1  -relaxed-aliasing -fsanitize=thread %s | FileCheck %s
 //
-// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s --check-prefix=NOTBAA
-// RUN: %clang_cc1 -emit-llvm -o - -O2  -relaxed-aliasing %s | FileCheck %s --check-prefix=NOTBAA
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s --check-prefix=NOTBAA
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - -O2  -relaxed-aliasing %s | FileCheck %s --check-prefix=NOTBAA
 //
 // Check that we generate TBAA for vtable pointer loads and stores.
 // When -fthread-sanitizer is used TBAA should be generated at all opt levels
 // even if -relaxed-aliasing is present.
 struct A {
   virtual int foo() const ;
   virtual ~A();
 };

cfe/trunk/test/CodeGenCUDA/filter-decl.cu

-// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-HOST %s
-// RUN: %clang_cc1 -emit-llvm %s -o - -fcuda-is-device | FileCheck -check-prefix=CHECK-DEVICE %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-HOST %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - -fcuda-is-device | FileCheck -check-prefix=CHECK-DEVICE %s
 
 #include "../SemaCUDA/cuda.h"
 
 // CHECK-HOST-NOT: constantdata = global
 // CHECK-DEVICE: constantdata = global
 __constant__ char constantdata[256];
 
 // CHECK-HOST-NOT: devicedata = global

cfe/trunk/test/CodeGenCXX/instr-profile.cpp

 // Test that instrumentation based profiling feeds branch prediction
 // correctly. This tests both generation of profile data and use of the same,
 // and the input file for the -fprofile-instr-use case is expected to be result
 // of running the program generated by the -fprofile-instr-generate case. As
 // such, main() should call every function in this test.
 
 // FIXME: Don't seek bb labels, like "if.else"
 // REQUIRES: asserts
 
-// RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate | FileCheck -check-prefix=PGOGEN %s
-// RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate | FileCheck -check-prefix=PGOGEN-EXC %s
+// RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOGEN %s
+// RUN: %clangxx %s -o - -emit-llvm -S -fprofile-instr-generate -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOGEN-EXC %s
 
-// RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata | FileCheck -check-prefix=PGOUSE %s
-// RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata | FileCheck -check-prefix=PGOUSE-EXC %s
+// RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOUSE %s
+// RUN: %clang %s -o - -emit-llvm -S -fprofile-instr-use=%S/Inputs/instr-profile.pgodata -Xclang -cxx-abi -Xclang itanium | FileCheck -check-prefix=PGOUSE-EXC %s
 
 // PGOGEN: @[[THC:__llvm_pgo_ctr[0-9]*]] = private global [11 x i64] zeroinitializer
 // PGOGEN-EXC: @[[THC:__llvm_pgo_ctr[0-9]*]] = private global [11 x i64] zeroinitializer
 
 // PGOGEN-LABEL: @_Z6throwsv()
 // PGOUSE-LABEL: @_Z6throwsv()
 // PGOGEN: store {{.*}} @[[THC]], i64 0, i64 0
 void throws() {

cfe/trunk/test/CodeGenObjC/debug-info-self.m

-// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -cxx-abi itanium -g %s -o - | FileCheck %s
 // self and _cmd are marked as DW_AT_artificial. 
 // myarg is not marked as DW_AT_artificial.
 
 @interface MyClass {
 }
 - (id)init:(int) myarg;
 @end
 

cfe/trunk/test/CodeGenObjC/overloadable.m

 // rdar://6657613
-// RUN: %clang_cc1 -emit-llvm %s -o %t
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm %s -o - | FileCheck %s
 
 @class C;
 
-// RUN: grep _Z1fP11objc_object %t | count 1
+// CHECK: _Z1fP11objc_object
+// CHECK-NOT: _Z1fP11objc_object
 void __attribute__((overloadable)) f(id c) { }
 
-// RUN: grep _Z1fP1C %t | count 1
+// CHECK: _Z1fP1C
+// CHECK-NOT: _Z1fP1C
 void __attribute__((overloadable)) f(C *c) { }

cfe/trunk/test/CodeGenObjCXX/arc-mangle.mm

-// RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s
 
 // CHECK-LABEL: define void @_Z1fPU8__strongP11objc_object(i8**)
 void f(__strong id *) {}
 // CHECK-LABEL: define void @_Z1fPU6__weakP11objc_object(i8**)
 void f(__weak id *) {}
 // CHECK-LABEL: define void @_Z1fPU15__autoreleasingP11objc_object(i8**)
 void f(__autoreleasing id *) {}
 // CHECK-LABEL: define void @_Z1fPP11objc_object(i8**)

cfe/trunk/test/CodeGenOpenCL/address-spaces-mangling.cl

-// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=yes -emit-llvm -o - | FileCheck -check-prefix=ASMANG %s
-// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -emit-llvm -o - | FileCheck -check-prefix=NOASMANG %s
+// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=yes -cxx-abi itanium -emit-llvm -o - | FileCheck -check-prefix=ASMANG %s
+// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -cxx-abi itanium -emit-llvm -o - | FileCheck -check-prefix=NOASMANG %s
 
 // We can't name this f as private is equivalent to default
 // no specifier given address space so we get multiple definition
 // warnings, but we do want it for comparison purposes.
 __attribute__((overloadable))
 void ff(int *arg) { }
 // ASMANG: @_Z2ffPi
 // NOASMANG: @_Z2ffPi

cfe/trunk/test/CodeGenOpenCL/local.cl

-// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -cxx-abi itanium -emit-llvm -o - | FileCheck %s
 
 __kernel void foo(void) {
   // CHECK: @foo.i = internal addrspace(2)
   __local int i;
   ++i;
 }
 
 // CHECK-LABEL: define void @_Z3barPU7CLlocali
 __kernel void __attribute__((__overloadable__)) bar(local int *x) {
   *x = 5;
 }

cfe/trunk/test/PCH/cxx-reference.cpp

 // Test this without pch.
-// RUN: %clang_cc1 -x c++ -std=c++11 -include %S/cxx-reference.h -fsyntax-only -emit-llvm -o - %s
+// RUN: %clang_cc1 -x c++ -cxx-abi itanium -std=c++11 -include %S/cxx-reference.h -fsyntax-only -emit-llvm -o - %s
 
 // Test with pch.
-// RUN: %clang_cc1 -x c++ -std=c++11 -emit-pch -o %t %S/cxx-reference.h
-// RUN: %clang_cc1 -x c++ -std=c++11 -include-pch %t -fsyntax-only -emit-llvm -o - %s 
+// RUN: %clang_cc1 -x c++ -cxx-abi itanium -std=c++11 -emit-pch -o %t %S/cxx-reference.h
+// RUN: %clang_cc1 -x c++ -cxx-abi itanium -std=c++11 -include-pch %t -fsyntax-only -emit-llvm -o - %s 

cfe/trunk/test/PCH/cxx-required-decls.cpp

 // Test this without pch.
-// RUN: %clang_cc1 -include %S/cxx-required-decls.h %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -include %S/cxx-required-decls.h %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s
 
 // Test with pch.
-// RUN: %clang_cc1 -x c++-header -emit-pch -o %t %S/cxx-required-decls.h
-// RUN: %clang_cc1 -include-pch %t %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -x c++-header -cxx-abi itanium -emit-pch -o %t %S/cxx-required-decls.h
+// RUN: %clang_cc1 -include-pch %t %s -cxx-abi itanium -emit-llvm -o - | FileCheck %s
 
 // CHECK: @_ZL5globS = internal global %struct.S zeroinitializer
 // CHECK: @_ZL3bar = internal global i32 0, align 4
 // CHECK: @glob_var = global i32 0

cfe/trunk/test/PCH/cxx-templates.cpp

 // Test this without pch.
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -include %S/cxx-templates.h -verify %s -ast-dump -o -
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -include %S/cxx-templates.h %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include %S/cxx-templates.h -verify %s -ast-dump -o -
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include %S/cxx-templates.h %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
 
 // Test with pch.
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -include-pch %t -verify %s -ast-dump  -o -
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include-pch %t -verify %s -ast-dump  -o -
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
 
 // Test with modules.
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -fmodules -x c++-header -emit-pch -o %t %S/cxx-templates.h
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -fmodules -include-pch %t -verify %s -ast-dump  -o -
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fexceptions -fmodules -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -fmodules -x c++-header -emit-pch -o %t %S/cxx-templates.h
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -fmodules -include-pch %t -verify %s -ast-dump  -o -
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fexceptions -fmodules -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
 
 // Test with pch and delayed template parsing.
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fdelayed-template-parsing -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t -verify %s -ast-dump  -o -
-// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fdelayed-template-parsing -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t -verify %s -ast-dump  -o -
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
 
 // CHECK: define weak_odr {{.*}}void @_ZN2S4IiE1mEv
 // CHECK: define linkonce_odr {{.*}}void @_ZN2S3IiE1mEv
 
 struct A {
   typedef int type;
   static void my_f();
   template <typename T>

cfe/trunk/test/PCH/irgen-rdar13114142.mm

-// RUN: %clang_cc1 %s -emit-pch -o %t.pch
-// RUN: %clang_cc1 %s -emit-llvm -include-pch %t.pch -o - | FileCheck %s
+// RUN: %clang_cc1 %s -cxx-abi itanium -emit-pch -o %t.pch
+// RUN: %clang_cc1 %s -cxx-abi itanium -emit-llvm -include-pch %t.pch -o - | FileCheck %s
 
 #ifndef HEADER
 #define HEADER
 
 class OOArray{
 public:
   ~OOArray();
 };

cfe/trunk/test/PCH/objc_literals.mm

-// RUN: %clang_cc1 -emit-pch -x objective-c++ -std=c++0x -o %t %s
-// RUN: %clang_cc1 -include-pch %t -x objective-c++ -std=c++0x  -verify %s
-// RUN: %clang_cc1 -include-pch %t -x objective-c++ -std=c++0x  -ast-print %s | FileCheck -check-prefix=CHECK-PRINT %s
-// RUN: %clang_cc1 -include-pch %t -x objective-c++ -std=c++0x  -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-IR %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-pch -x objective-c++ -std=c++0x -o %t %s
+// RUN: %clang_cc1 -cxx-abi itanium -include-pch %t -x objective-c++ -std=c++0x -verify %s
+// RUN: %clang_cc1 -cxx-abi itanium -include-pch %t -x objective-c++ -std=c++0x -ast-print %s | FileCheck -check-prefix=CHECK-PRINT %s
+// RUN: %clang_cc1 -cxx-abi itanium -include-pch %t -x objective-c++ -std=c++0x -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-IR %s
 
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 typedef unsigned char BOOL;
 

cfe/trunk/test/PCH/objcxx-ivar-class.mm

 // Test this without pch.
-// RUN: not %clang_cc1 -include %S/objcxx-ivar-class.h -verify %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -include %S/objcxx-ivar-class.h -cxx-abi itanium %s -emit-llvm -o - | FileCheck %s
 
 // Test with pch.
-// RUN: %clang_cc1 -x objective-c++-header -emit-pch -o %t %S/objcxx-ivar-class.h
-// RUN: not %clang_cc1 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -x objective-c++-header -cxx-abi itanium -emit-pch -o %t %S/objcxx-ivar-class.h
+// RUN: %clang_cc1 -include-pch %t -cxx-abi itanium %s -emit-llvm -o - | FileCheck %s
 
 // CHECK: [C position]
 // CHECK: call {{.*}} @_ZN1SC1ERKS_
 
 // CHECK: [C setPosition:]
 // CHECK: = call {{.*}}%struct.S* @_ZN1SaSERKS_
 
 // CHECK: [C .cxx_destruct]
 // CHECK: [C .cxx_construct]

cfe/trunk/test/Sema/empty1.c

-// RUN: %clang_cc1 %s -fsyntax-only -verify -Wc++-compat
+// RUN: %clang_cc1 %s -cxx-abi itanium -fsyntax-only -verify -Wc++-compat
+
+// FIXME: Empty C structs are 4 bytes in MSVC, but the -cxx-abi flag probably
+// shouldn't affect this since it's not C++. PR18263.
 
 struct emp_1 { // expected-warning {{empty struct has size 0 in C, size 1 in C++}}
 };
 
 union emp_2 { // expected-warning {{empty union has size 0 in C, size 1 in C++}}
 };
 
 struct emp_3 { // expected-warning {{struct has size 0 in C, size 1 in C++}}

cfe/trunk/test/SemaCXX/deleted-operator.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 struct PR10757 {
   bool operator~() = delete; // expected-note {{explicitly deleted}}
   bool operator==(const PR10757&) = delete; // expected-note {{explicitly deleted}}
   operator float();
 };
 int PR10757f() {
   PR10757 a1;
   // FIXME: We get a ridiculous number of "built-in candidate" notes here...
   if(~a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 8 {{built-in candidate}}
   if(a1==a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 121 {{built-in candidate}}
 }
 
 struct DelOpDel {
-  virtual ~DelOpDel() {} // expected-error {{deleted function}}
-  void operator delete(void*) = delete; // expected-note {{deleted here}}
+  // FIXME: In MS ABI, we error twice below.
+  virtual ~DelOpDel() {} // expected-error 1-2 {{attempt to use a deleted function}}
+  void operator delete(void*) = delete; // expected-note 1-2 {{deleted here}}
 };

cfe/trunk/test/SemaCXX/destructor.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi itanium -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s
+// RUN: %clang_cc1 -std=c++11 -cxx-abi microsoft -DMSABI -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s
 class A {
 public:
   ~A();
 };
 
 class B {
 public:
   ~B() { }
void disconnect()
       T* t;
       bob<QGenericArgument>(t); // expected-error{{undeclared identifier 'bob'}} \
       // expected-error{{does not refer to a value}}
     }
   };
 }
 
 namespace PR6709 {
+#ifdef MSABI
+  // This bug, "Clang instantiates destructor for function argument" is intended
+  // behaviour in the Microsoft ABI because the callee needs to destruct the arguments.
+  // expected-error@+3 {{indirection requires pointer operand ('int' invalid)}}
+  // expected-note@+3 {{in instantiation of member function 'PR6709::X<int>::~X' requested here}}
+#endif
   template<class T> class X { T v; ~X() { ++*v; } };
   void a(X<int> x) {}
 }
 
 struct X0 { virtual ~X0() throw(); };
 struct X1 : public X0 { };
 
 // Make sure we instantiate operator deletes when building a virtual
 // destructor.
 namespace test6 {
   template <class T> class A {
   public:
     void *operator new(__SIZE_TYPE__);
     void operator delete(void *p) {
       T::deleteIt(p); // expected-error {{type 'int' cannot be used prior to '::'}}
     }
 
+#ifdef MSABI
+    // expected-note@+2 {{in instantiation of member function 'test6::A<int>::operator delete' requested here}}
+#endif
     virtual ~A() {}
   };
 
-  class B : A<int> { B(); }; // expected-note {{in instantiation of member function 'test6::A<int>::operator delete' requested here}}
+#ifndef MSABI
+    // expected-note@+2 {{in instantiation of member function 'test6::A<int>::operator delete' requested here}}
+#endif
+  class B : A<int> { B(); };
   B::B() {}
 }
 
 // Make sure classes are marked invalid when they have invalid
 // members.  This avoids a crash-on-invalid.
 namespace test7 {
   struct A {
     ~A() const; // expected-error {{'const' qualifier is not allowed on a destructor}}

cfe/trunk/test/SemaCXX/implicit-virtual-member-functions.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s
+// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -DMSABI -verify %s
 struct A {
   virtual ~A();
 };
 
 struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}}
   virtual void f();
 
   void operator delete (void *, int); // expected-note {{'operator delete' declared here}}
 };
 
+#ifdef MSABI
+B b; // expected-note {{implicit destructor for 'B' first required here}}
+#else
 void B::f() { // expected-note {{implicit destructor for 'B' first required here}}
 }
+#endif
 
 struct C : A { // expected-error {{no suitable member 'operator delete' in 'C'}}
   C();
   void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
 };
 
 C::C() { }  // expected-note {{implicit destructor for 'C' first required here}}
 
 struct D : A { // expected-error {{no suitable member 'operator delete' in 'D'}}
   void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
 }; 
 
 void f() {
   new D; // expected-note {{implicit destructor for 'D' first required here}}
 }
-

cfe/trunk/test/SemaCXX/primary-base.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -cxx-abi itanium -fsyntax-only -verify %s
 // expected-no-diagnostics
 class A { virtual void f(); };
 class B : virtual A { };
 
 class C : B { };
 
 // Since A is already a primary base class, C should be the primary base class
 // of F.
 class F : virtual A, virtual C { };
 
 int sa[sizeof(F) == sizeof(A) ? 1 : -1];

cfe/trunk/test/SemaCXX/typeid-ref.cpp

-// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm -o - %s | FileCheck %s
 namespace std {
   class type_info;
 }
 
 struct X { };
 
 void f() {
   // CHECK: @_ZTS1X = linkonce_odr constant
   // CHECK: @_ZTI1X = linkonce_odr unnamed_addr constant 
   (void)typeid(X&);
 }

cfe/trunk/test/SemaCXX/undefined-internal.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Make sure we don't produce invalid IR.
-// RUN: %clang_cc1 -emit-llvm-only %s
+// RUN: %clang_cc1 -cxx-abi itanium -emit-llvm-only %s
+
+// FIXME: -cxx-abi itanium shouldn't be necessary; the test should pass
+// in MS mode too.
 
 namespace test1 {
   static void foo(); // expected-warning {{function 'test1::foo' has internal linkage but is not defined}}
   template <class T> static void bar(); // expected-warning {{function 'test1::bar<int>' has internal linkage but is not defined}}
 
   void test() {
     foo(); // expected-note {{used here}}
     bar<int>(); // expected-note {{used here}}

cfe/trunk/test/SemaCXX/virtual-base-used.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -cxx-abi itanium -verify %s
+// RUN: %clang_cc1 -fsyntax-only -cxx-abi microsoft -DMSABI -verify %s
 // PR7800
 
+// The Microsoft ABI doesn't have the concept of key functions, so we have different
+// expectations about when functions are first required for that case.
+
+#ifdef MSABI
+// expected-note@+2 3 {{declared private here}}
+#endif
 class NoDestroy { ~NoDestroy(); }; // expected-note 3 {{declared private here}}
 struct A {
   virtual ~A();
 };
 
+#ifdef MSABI
+// expected-error@+3 {{field of type 'NoDestroy' has private destructor}}
+#endif
 struct B : public virtual A {
   NoDestroy x; // expected-error {{field of type 'NoDestroy' has private destructor}}
 };
+#ifdef MSABI
+// expected-note@+3 {{implicit default constructor for 'B' first required here}}
+// expected-note@+2 {{implicit destructor for 'B' first required here}}
+#endif
 struct D : public virtual B {
   virtual void foo();
   ~D();
 };
+#ifdef MSABI
+D d; // expected-note {{implicit default constructor for 'D' first required here}}
+#else
 void D::foo() { // expected-note {{implicit destructor for 'B' first required here}}
 }
+#endif
 
+#ifdef MSABI
+// expected-error@+3 {{field of type 'NoDestroy' has private destructor}}
+#endif
 struct E : public virtual A {
   NoDestroy x; // expected-error {{field of type 'NoDestroy' has private destructor}}
 };
+#ifdef MSABI
+// expected-note@+2 {{implicit default constructor for 'E' first required here}}
+#endif
 struct F : public E { // expected-note {{implicit destructor for 'E' first required here}}
 };
+#ifdef MSABI
+// expected-note@+2 {{implicit default constructor for 'F' first required here}}
+#endif
 struct G : public virtual F {
   virtual void foo();
   ~G();
 };
+#ifdef MSABI
+G g; // expected-note {{implicit default constructor for 'G' first required here}}
+#else
 void G::foo() { // expected-note {{implicit destructor for 'F' first required here}}
 }
+#endif
 
+#ifdef MSABI
+// expected-note@+3 {{'H' declared here}}
+// expected-error@+3 {{field of type 'NoDestroy' has private destructor}}
+#endif
 struct H : public virtual A {
   NoDestroy x; // expected-error {{field of type 'NoDestroy' has private destructor}}
 };
+#ifdef MSABI
+// expected-error@+3 {{implicit default constructor for 'I' must explicitly initialize the base class 'H' which does not have a default constructor}}
+// expected-note@+2 {{implicit destructor for 'H' first required here}}
+#endif
 struct I : public virtual H {
   ~I();
 };
+#ifdef MSABI
+// expected-note@+3 {{implicit default constructor for 'H' first required here}}
+// expected-note@+2 {{implicit default constructor for 'I' first required here}}
+#endif
 struct J : public I {
   virtual void foo();
   ~J();
 };
+#ifdef MSABI
+J j; // expected-note {{implicit default constructor for 'J' first required here}}
+#else
 void J::foo() { // expected-note {{implicit destructor for 'H' first required here}}
 }
+#endif

cfe/trunk/test/SemaCXX/warn-reinterpret-base-class.cpp

-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
-// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi itanium -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi microsoft -DMSABI -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
+
+// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi itanium -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
+// RUN: not %clang_cc1 -std=c++11 -fsyntax-only -cxx-abi microsoft -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
 
 // PR 13824
 class A {
 };
 class DA : public A {
 };
 class DDA : public DA {
 };
void different_subobject_downcast(E *e, F *f, A *a) {
 
 
   (void)reinterpret_cast<G *>(f);
   // expected-warning@+2 {{'reinterpret_cast' to class 'I *' from its virtual base 'F *' behaves differently from 'static_cast'}}
   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
   (void)reinterpret_cast<I *>(f);
   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
 
+#ifdef MSABI
+  // In MS ABI mode, A is at non-zero offset in H.
+  // expected-warning@+3 {{'reinterpret_cast' to class 'H *' from its base at non-zero offset 'A *' behaves differently from 'static_cast'}}
+  // expected-note@+2 {{use 'static_cast'}}
+#endif
   (void)reinterpret_cast<H *>(a);
 
   // expected-warning@+2 {{'reinterpret_cast' to class 'L' (aka 'const F *volatile') from its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
   (void)reinterpret_cast<L>(e);
   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
 }
 
 void different_subobject_upcast(F *f, G *g, H *h, I *i) {
   // expected-warning@+2 {{'reinterpret_cast' from class 'F *' to its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
   (void)reinterpret_cast<E *>(f);
   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
 
   (void)reinterpret_cast<F *>(g);
   // expected-warning@+2 {{'reinterpret_cast' from class 'G *' to its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
   (void)reinterpret_cast<E *>(g);
   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
 
   (void)reinterpret_cast<E *>(h);
+
+#ifdef MSABI
+  // In MS ABI mode, A is at non-zero offset in H.
+  // expected-warning@+3 {{'reinterpret_cast' from class 'H *' to its base at non-zero offset 'A *' behaves differently from 'static_cast'}}
+  // expected-note@+2 {{use 'static_cast'}}
+#endif
   (void)reinterpret_cast<A *>(h);
 
   // expected-warning@+2 {{'reinterpret_cast' from class 'I *' to its virtual base 'F *' behaves differently from 'static_cast'}}
   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
   (void)reinterpret_cast<F *>(i);
   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
 
   // expected-warning@+2 {{'reinterpret_cast' from class 'I *' to its virtual base 'E *' behaves differently from 'static_cast'}}
   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
   (void)reinterpret_cast<E *>(i);
   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
 }

cfe/trunk/test/SemaCXX/warn-weak-vtables.cpp

-// RUN: %clang_cc1 %s -fsyntax-only -verify -Wweak-vtables -Wweak-template-vtables
+// RUN: %clang_cc1 %s -fsyntax-only -verify -cxx-abi itanium -Wweak-vtables -Wweak-template-vtables
+// RUN: %clang_cc1 %s -fsyntax-only -cxx-abi microsoft -Werror -Wno-weak-vtables -Wno-weak-template-vtables
 
 struct A { // expected-warning {{'A' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit}}
   virtual void f() { } 
 };
 
 template<typename T> struct B {
   virtual void f() { } 
 };

cfe/trunk/test/SemaTemplate/inject-templated-friend-post.cpp

-// RUN: %clang %s -std=c++98 -S -emit-llvm -o - | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
-// RUN: %clang %s -std=c++98 -S -emit-llvm -o - -DPROTOTYPE | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
-// RUN: %clang %s -std=c++98 -S -emit-llvm -o - -DINSTANTIATE | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
-// RUN: %clang %s -std=c++98 -S -emit-llvm -o - -DPROTOTYPE -DINSTANTIATE | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - -DPROTOTYPE | FileCheck --check-prefix=CHECK-PROTOTYPE %s
+// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - -DINSTANTIATE | FileCheck --check-prefix=CHECK-INSTANTIATE %s
+// RUN: %clang_cc1 %s -std=c++98 -cxx-abi itanium -emit-llvm -o - -DPROTOTYPE -DINSTANTIATE | FileCheck --check-prefix=CHECK-PROTOTYPE-INSTANTIATE %s
 // RUN: %clang_cc1 %s -DREDEFINE -verify
 // RUN: %clang_cc1 %s -DPROTOTYPE -DREDEFINE -verify
 // PR8007: friend function not instantiated, reordered version.
 // Corresponds to http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38392
 
+// CHECK: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
+// CHECK-PROTOTYPE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
+// CHECK-INSTANTIATE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
+// CHECK-PROTOTYPE-INSTANTIATE: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
+
 struct std_ostream
 {
   int dummy;
 };
 
 std_ostream cout;
 
 template <typename STRUCT_TYPE>

cfe/trunk/test/SemaTemplate/inject-templated-friend.cpp

-// RUN: %clang %s -S -emit-llvm -o - | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang_cc1 %s -emit-llvm -cxx-abi itanium -o - | FileCheck %s
 // RUN: %clang_cc1 %s -DREDEFINE -verify
 // PR8007: friend function not instantiated.
 
+// CHECK: define linkonce_odr{{.*}}_ZlsR11std_ostreamRK8StreamerI3FooE
+
 struct std_ostream
 {
   int dummy;
 };
 
 std_ostream cout;
 
 template <typename STRUCT_TYPE>

cfe/trunk/test/SemaTemplate/instantiate-complete.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -cxx-abi itanium -fsyntax-only -verify %s
+// RUN: %clang_cc1 -cxx-abi microsoft -DMSABI -fsyntax-only -verify %s
 
 // Tests various places where requiring a complete type involves
 // instantiation of that type.
 
 template<typename T>
 struct X {
   X(T);
 
+#ifdef MSABI
+// expected-error@+2{{data member instantiated with function type 'long (long)'}}
+#endif
   T f; // expected-error{{data member instantiated with function type 'float (int)'}} \
        // expected-error{{data member instantiated with function type 'int (int)'}} \
        // expected-error{{data member instantiated with function type 'char (char)'}} \
        // expected-error{{data member instantiated with function type 'short (short)'}} \
        // expected-error{{data member instantiated with function type 'float (float)'}}
 };
 
 X<int> f() { return 0; }

 
 void test_new() {
   (void)new X<float>(0);
   (void)new X<float(float)>; // expected-note{{in instantiation of template class 'X<float (float)>' requested here}}
 }
 
 void test_memptr(X<long> *p1, long X<long>::*pm1,
                  X<long(long)> *p2, 
+#ifdef MSABI
+                 long (X<long(long)>::*pm2)(long)) { // expected-note{{in instantiation of template class 'X<long (long)>' requested here}}
+#else
                  long (X<long(long)>::*pm2)(long)) {
+#endif
   (void)(p1->*pm1);
 }
 
 // Reference binding to a base
 template<typename T>
 struct X1 { };
 
 template<typename T>

cfe/trunk/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -ftemplate-depth 16 -fcxx-exceptions -fexceptions %s
+// RUN: %clang_cc1 -fsyntax-only -verify -cxx-abi itanium -std=c++11 -ftemplate-depth 16 -fcxx-exceptions -fexceptions %s
 
 // DR1330: an exception specification for a function template is only
 // instantiated when it is needed.
 
+// Note: the test is Itanium-specific because it depends on key functions in the
+// PR12763 namespace.
+
 template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}}
 struct Incomplete; // expected-note{{forward}}
 
 void test_f1(Incomplete *incomplete_p, int *int_p) {
   f1(int_p);
   f1(incomplete_p); // expected-note{{instantiation of exception spec}}
 }
 

cfe/trunk/test/SemaTemplate/virtual-member-functions.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -cxx-abi itanium -fsyntax-only -verify %s
+// RUN: %clang_cc1 -cxx-abi microsoft -DMSABI -fsyntax-only -verify %s
 
 namespace PR5557 {
 template <class T> struct A {
   A();
   virtual void anchor();
   virtual int a(T x);
 };
 template<class T> A<T>::A() {}
namespace PR7114 {
   public:
     class Inner : public A { }; // expected-error{{base class 'PR7114::A' has private destructor}}
     static Inner i;
     static const unsigned value = sizeof(i) == 4;
   };
 
   int f() { return B<int>::value; }
 
+#ifdef MSABI
+  void test_typeid(B<float>::Inner bfi) { // expected-note{{implicit destructor}}
+    (void)typeid(bfi);
+#else
   void test_typeid(B<float>::Inner bfi) {
     (void)typeid(bfi); // expected-note{{implicit destructor}}
+#endif
   }
 
   template<typename T>
   struct X : A {
     void f() { }
   };
 
-  void test_X(X<int> xi, X<float> xf) {
+  void test_X(X<int> &xi, X<float> &xf) {
     xi.f();
   }
 }
 
 namespace DynamicCast {
   struct Y {};
   template<typename T> struct X : virtual Y {
     virtual void foo() { T x; } // expected-error {{variable has incomplete type 'void'}}
   };
   template<typename T> struct X2 : virtual Y {
     virtual void foo() { T x; }
   };
   Y* f(X<void>* x) { return dynamic_cast<Y*>(x); } // expected-note {{in instantiation of member function 'DynamicCast::X<void>::foo' requested here}}
   Y* f2(X<void>* x) { return dynamic_cast<Y*>(x); }
 }