MS ABI: Add support for the -vm{b,g,s,m,v} flags

[majnemer]

Summary

These flags control the inheritance model initially used by the
translation unit.

[majnemer]

• Simplify representation method selection a little.

[hans]

include/clang/Driver/CLCompatOptions.td

108 ↗

(On Diff #6997)

Please update test/Driver/cl-options.c to cover these if possible.

lib/Driver/Tools.cpp

4028 ↗

(On Diff #6997)

can we have a test for this?

4042 ↗

(On Diff #6997)

Tests would be nice.

Also, this is pretty hard to follow. Does it get too ugly if you just handle the three cases separately? I.e. "if we have vms, check that we don't have vmm or vmv", and so on?

[majnemer]

• Address review comments

[aaron.ballman]

Tiny nits below.

Index: include/clang/Basic/LangOptions.def

• include/clang/Basic/LangOptions.def

+++ include/clang/Basic/LangOptions.def
@@ -113,6 +113,7 @@
BENIGN_LANGOPT(AccessControl , 1, 1, "C++ access control")
LANGOPT(CharIsSigned , 1, 1, "signed char")
LANGOPT(ShortWChar , 1, 0, "unsigned short wchar_t")
+ENUM_LANGOPT(MSPointerToMemberRepresentationMethod, PragmaMSPointersToMembersKind, 2, PPTMK_BestCase, "member-pointer representation method")

LANGOPT(ShortEnums , 1, 0, "short enum types")

Index: include/clang/Basic/LangOptions.h

• include/clang/Basic/LangOptions.h

+++ include/clang/Basic/LangOptions.h
@@ -66,6 +66,13 @@

  SOB_Trapping    // -ftrapv
};

+ enum PragmaMSPointersToMembersKind {
+ PPTMK_BestCase,
+ PPTMK_FullGeneralitySingleInheritance,
+ PPTMK_FullGeneralityMultipleInheritance,
+ PPTMK_FullGeneralityVirtualInheritance,
+ };
+

enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };

public:

Index: include/clang/Driver/CLCompatOptions.td

• include/clang/Driver/CLCompatOptions.td

+++ include/clang/Driver/CLCompatOptions.td
@@ -96,6 +96,16 @@

Alias<show_includes>;

def _SLASH_U : CLJoinedOrSeparate<"U">, HelpText<"Undefine macro">,

MetaVarName<"<macro>">, Alias<U>;

+def _SLASH_vmb : CLFlag<"vmb">,
+ HelpText<"Use a best case representation method for member pointers">;

It should be best-case instead of best case.

+def _SLASH_vmg : CLFlag<"vmg">,
+ HelpText<"Use a most general representation for member pointers">;

most-general instead of most general. Same goes below.

+def _SLASH_vms : CLFlag<"vms">,
+ HelpText<"Set the default most general representation to single inheritance">;
+def _SLASH_vmm : CLFlag<"vmm">,
+ HelpText<"Set the default most general representation to multiple inheritance">;
+def _SLASH_vmv : CLFlag<"vmv">,
+ HelpText<"Set the default most general representation to virtual inheritance">;
def _SLASH_W0 : CLFlag<"W0">, HelpText<"Disable all warnings">, Alias<w>;
def _SLASH_W1 : CLFlag<"W1">, HelpText<"Enable -Wall">, Alias<Wall>;
def _SLASH_W2 : CLFlag<"W2">, HelpText<"Enable -Wall">, Alias<Wall>;
@@ -168,7 +178,6 @@
def _SLASH_RTC : CLIgnoredJoined<"RTC">;
def _SLASH_sdl : CLIgnoredFlag<"sdl">;
def _SLASH_sdl_ : CLIgnoredFlag<"sdl-">;
-def _SLASH_vmg : CLIgnoredFlag<"vmg">;
def _SLASH_w : CLIgnoredJoined<"w">;
def _SLASH_Zc_forScope : CLIgnoredFlag<"Zc:forScope">;
def _SLASH_Zc_wchar_t : CLIgnoredFlag<"Zc:wchar_t">;
@@ -233,10 +242,6 @@
def _SLASH_u : CLFlag<"u">;
def _SLASH_V : CLFlag<"V">;
def _SLASH_vd : CLJoined<"vd">;
-def _SLASH_vmb : CLFlag<"vmb">;
-def _SLASH_vmm : CLFlag<"vmm">;
-def _SLASH_vms : CLFlag<"vms">;
-def _SLASH_vmv : CLFlag<"vmv">;
def _SLASH_volatile : CLFlag<"volatile">;
def _SLASH_WL : CLFlag<"WL">;
def _SLASH_Wp64 : CLFlag<"Wp64">;

Index: include/clang/Driver/Options.td

• include/clang/Driver/Options.td

+++ include/clang/Driver/Options.td
@@ -571,6 +571,7 @@
def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,

HelpText<"Parse templated function definitions at the end of the "
         "translation unit">,  Flags<[CC1Option]>;

+def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,

Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
HelpText<"Specify the module cache path">;

Index: include/clang/Sema/Sema.h

• include/clang/Sema/Sema.h

+++ include/clang/Sema/Sema.h
@@ -262,15 +262,9 @@

bool MSStructPragmaOn; // True when \#pragma ms_struct on

• enum PragmaMSPointersToMembersKind {
• PPTMK_BestCase,
• PPTMK_FullGeneralitySingleInheritance,
• PPTMK_FullGeneralityMultipleInheritance,
• PPTMK_FullGeneralityVirtualInheritance,
• }; - /// \brief Controls member pointer representation format under the MS ABI.
• PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod;

+ LangOptions::PragmaMSPointersToMembersKind
+ MSPointerToMemberRepresentationMethod;

This looks a bit odd; should MSPointerToMemberRepresentationMethod be indented?

/// \brief Source location for newly created implicit MSInheritanceAttrs
SourceLocation ImplicitMSInheritanceAttrLoc;

@@ -6986,8 +6980,9 @@

/// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
/// pointers_to_members(representation method[, general purpose
/// representation]).

• void ActOnPragmaMSPointersToMembers(PragmaMSPointersToMembersKind Kind,
• SourceLocation PragmaLoc);

+ void ActOnPragmaMSPointersToMembers(
+ LangOptions::PragmaMSPointersToMembersKind Kind,
+ SourceLocation PragmaLoc);

/// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
void ActOnPragmaDetectMismatch(StringRef Name, StringRef Value);

Index: lib/Driver/Tools.cpp

• lib/Driver/Tools.cpp

+++ lib/Driver/Tools.cpp
@@ -4017,6 +4017,36 @@

if (Arg *A = Args.getLastArg(options::OPT_show_includes))
  A->render(Args, CmdArgs);

+ const Driver &D = getToolChain().getDriver();
+ bool HasMostGeneralArg = Args.getLastArg(options::OPTSLASH_vmg);
+ bool HasBestCaseArg = Args.getLastArg(options::OPTSLASH_vmb);
+ if (HasMostGeneralArg && HasBestCaseArg)
+ D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+ << "-vmg" << "-vmb";
+
+ if (HasMostGeneralArg) {
+ bool HasSingleArg = Args.hasArg(options::OPTSLASH_vms);
+ bool HasMultipleArg = Args.hasArg(options::OPTSLASH_vmm);
+ bool HasVirtualArg = Args.hasArg(options::OPT__SLASH_vmv);
+
+ if (HasSingleArg && (HasMultipleArg || HasVirtualArg))
+ D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+ << "-vms" << (HasMultipleArg ? "-vmm" : "-vmv");
+ else if (HasMultipleArg && (HasSingleArg || HasVirtualArg))
+ D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+ << "-vmm" << (HasSingleArg ? "-vms" : "-vmv");
+ else if (HasVirtualArg && (HasSingleArg || HasMultipleArg))
+ D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+ << "-vmv" << (HasSingleArg ? "-vms" : "-vmm");
+
+ if (HasSingleArg)
+ CmdArgs.push_back("-fms-memptr-rep=single");
+ else if (HasMultipleArg)
+ CmdArgs.push_back("-fms-memptr-rep=multiple");
+ else
+ CmdArgs.push_back("-fms-memptr-rep=virtual");
+ }
+

if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
  CmdArgs.push_back("-fdiagnostics-format");
  if (Args.hasArg(options::OPT__SLASH_fallback))

Index: lib/Frontend/CompilerInvocation.cpp

• lib/Frontend/CompilerInvocation.cpp

+++ lib/Frontend/CompilerInvocation.cpp
@@ -1402,6 +1402,24 @@

  }
}

+ if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
+ LangOptions::PragmaMSPointersToMembersKind InheritanceModel =
+ llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
+ A->getValue())
+ .Case("single",
+ LangOptions::PPTMK_FullGeneralitySingleInheritance)
+ .Case("multiple",
+ LangOptions::PPTMK_FullGeneralityMultipleInheritance)
+ .Case("virtual",
+ LangOptions::PPTMK_FullGeneralityVirtualInheritance)
+ .Default(LangOptions::PPTMK_BestCase);
+ if (InheritanceModel == LangOptions::PPTMK_BestCase)
+ Diags.Report(diag::err_drv_invalid_value)
+ << "-fms-memptr-rep=" << A->getValue();

Do we have a test for this?

+
+ Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
+ }
+

// Check if -fopenmp is specified.
Opts.OpenMP = Args.hasArg(OPT_fopenmp);

Index: lib/Parse/ParsePragma.cpp

• lib/Parse/ParsePragma.cpp

+++ lib/Parse/ParsePragma.cpp
@@ -182,8 +182,8 @@

void Parser::HandlePragmaMSPointersToMembers() {

assert(Tok.is(tok::annot_pragma_ms_pointers_to_members));

• Sema::PragmaMSPointersToMembersKind RepresentationMethod =
• static_cast<Sema::PragmaMSPointersToMembersKind>(

+ LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =
+ static_cast<LangOptions::PragmaMSPointersToMembersKind>(

        reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc);

@@ -834,9 +834,9 @@

}
PP.Lex(Tok);

• Sema::PragmaMSPointersToMembersKind RepresentationMethod;

+ LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;

if (Arg->isStr("best_case")) {

• RepresentationMethod = Sema::PPTMK_BestCase;

+ RepresentationMethod = LangOptions::PPTMK_BestCase;

} else {
  if (Arg->isStr("full_generality")) {
    if (Tok.is(tok::comma)) {

@@ -854,7 +854,7 @@

// #pragma pointers_to_members(full_generality) implicitly specifies
// virtual_inheritance.
Arg = 0;

• RepresentationMethod = Sema::PPTMK_FullGeneralityVirtualInheritance;

+ RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance;

} else {
  PP.Diag(Tok.getLocation(), diag::err_expected_punc)
      << "full_generality";

@@ -864,11 +864,14 @@

if (Arg) {
  if (Arg->isStr("single_inheritance")) {

• RepresentationMethod = Sema::PPTMK_FullGeneralitySingleInheritance;

+ RepresentationMethod =
+ LangOptions::PPTMK_FullGeneralitySingleInheritance;

} else if (Arg->isStr("multiple_inheritance")) {

• RepresentationMethod = Sema::PPTMK_FullGeneralityMultipleInheritance;

+ RepresentationMethod =
+ LangOptions::PPTMK_FullGeneralityMultipleInheritance;

} else if (Arg->isStr("virtual_inheritance")) {

• RepresentationMethod = Sema::PPTMK_FullGeneralityVirtualInheritance;

+ RepresentationMethod =
+ LangOptions::PPTMK_FullGeneralityVirtualInheritance;

} else {
  PP.Diag(Tok.getLocation(),
          diag::err_pragma_pointers_to_members_unknown_kind)

Index: lib/Sema/Sema.cpp

• lib/Sema/Sema.cpp

+++ lib/Sema/Sema.cpp
@@ -76,7 +76,9 @@

CollectStats(false), CodeCompleter(CodeCompleter),
CurContext(0), OriginalLexicalContext(0),
PackContext(0), MSStructPragmaOn(false),

• MSPointerToMemberRepresentationMethod(PPTMK_BestCase), VisContext(0),

+ MSPointerToMemberRepresentationMethod(
+ pp.getLangOpts().getMSPointerToMemberRepresentationMethod()),
+ VisContext(0),

IsBuildingRecoveryCallExpr(false),
ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0),

Index: lib/Sema/SemaAttr.cpp

• lib/Sema/SemaAttr.cpp

+++ lib/Sema/SemaAttr.cpp
@@ -288,7 +288,7 @@
}

void Sema::ActOnPragmaMSPointersToMembers(

• PragmaMSPointersToMembersKind RepresentationMethod,

+ LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,

  SourceLocation PragmaLoc) {
MSPointerToMemberRepresentationMethod = RepresentationMethod;
ImplicitMSInheritanceAttrLoc = PragmaLoc;

Index: lib/Sema/SemaType.cpp

• lib/Sema/SemaType.cpp

+++ lib/Sema/SemaType.cpp
@@ -5087,26 +5087,26 @@

MSInheritanceAttr::Spelling InheritanceModel;

switch (MSPointerToMemberRepresentationMethod) {

• case PPTMK_BestCase:

+ case LangOptions::PPTMK_BestCase:

InheritanceModel = RD->calculateInheritanceModel();
break;

• case PPTMK_FullGeneralitySingleInheritance:

+ case LangOptions::PPTMK_FullGeneralitySingleInheritance:

InheritanceModel = MSInheritanceAttr::Keyword_single_inheritance;
break;

• case PPTMK_FullGeneralityMultipleInheritance:

+ case LangOptions::PPTMK_FullGeneralityMultipleInheritance:

InheritanceModel =
    MSInheritanceAttr::Keyword_multiple_inheritance;
break;

• case PPTMK_FullGeneralityVirtualInheritance:

+ case LangOptions::PPTMK_FullGeneralityVirtualInheritance:

  InheritanceModel =
      MSInheritanceAttr::Keyword_unspecified_inheritance;
  break;
}

RD->addAttr(MSInheritanceAttr::CreateImplicit(
    getASTContext(), InheritanceModel,
    /*BestCase=*/MSPointerToMemberRepresentationMethod ==

• PPTMK_BestCase,

+ LangOptions::PPTMK_BestCase,

ImplicitMSInheritanceAttrLoc.isValid()
    ? ImplicitMSInheritanceAttrLoc
    : RD->getSourceRange()));

Index: test/Driver/cl-options.c

• test/Driver/cl-options.c

+++ test/Driver/cl-options.c
@@ -67,6 +67,24 @@
RUN: %clang_cl /U mymacro -### -- %s 2>&1 | FileCheck -check-prefix=U %s
U: "-U" "mymacro"

+ RUN: %clang_cl /vmg -# -- %s 2>&1 | FileCheck -check-prefix=VMG %s +// VMG: "-fms-memptr-rep=virtual" + +// RUN: %clang_cl /vmg /vms -# -- %s 2>&1 | FileCheck -check-prefix=VMS %s
+ VMS: "-fms-memptr-rep=single"
+
+ RUN: %clang_cl /vmg /vmm -# -- %s 2>&1 | FileCheck -check-prefix=VMM %s +// VMM: "-fms-memptr-rep=multiple" + +// RUN: %clang_cl /vmg /vmv -# -- %s 2>&1 | FileCheck -check-prefix=VMV %s
+ VMV: "-fms-memptr-rep=virtual"
+
+ RUN: %clang_cl /vmg /vmb -# -- %s 2>&1 | FileCheck -check-prefix=VMB %s +// VMB: '-vmg' not allowed with '-vmb' + +// RUN: %clang_cl /vmg /vmm /vms -# -- %s 2>&1 | FileCheck -check-prefix=VMX %s
+ VMX: '-vms' not allowed with '-vmm'
+
RUN: %clang_cl /W0 -### -- %s 2>&1 | FileCheck -check-prefix=W0 %s
W0: -w

@@ -197,10 +215,6 @@
RUN: /u \
RUN: /V \
RUN: /vd2 \
- RUN: /vmb \
- RUN: /vmm \
- RUN: /vms \
- RUN: /vmv \
RUN: /volatile \
RUN: /wfoo \
RUN: /WL \

Index: test/SemaCXX/member-pointer-ms.cpp

• test/SemaCXX/member-pointer-ms.cpp

+++ test/SemaCXX/member-pointer-ms.cpp
@@ -1,5 +1,6 @@
- RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify %s
- RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify %s
+ RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify -DVMB %s
+ RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMB %s
+ RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMV -fms-memptr-rep=virtual %s

This file should also give no diagnostics when run through cl.exe from MSVS
2012, which supports C++11 and static_assert. It should pass for both 64-bit
@@ -18,6 +19,7 @@

int f;

};

+#ifdef VMB
enum {

kSingleDataAlign             = 1 * sizeof(int),
kSingleFunctionAlign         = 1 * sizeof(void *),

@@ -43,11 +45,47 @@

kUnspecifiedDataSize        = 3 * sizeof(int),
kUnspecifiedFunctionSize    = 2 * sizeof(int) + 2 * sizeof(void *),

};
+#elif VMV
+enum {
+ Everything with more than 1 field is 8 byte aligned, except virtual data
+ member pointers on x64 (ugh).
+#ifdef _M_X64
+ kVirtualDataAlign = 4,
+#else
+ kVirtualDataAlign = 8,
+#endif
+ kMultipleDataAlign = kVirtualDataAlign,
+ kSingleDataAlign = kVirtualDataAlign,
+
+ kUnspecifiedFunctionAlign = 8,
+ kVirtualFunctionAlign = kUnspecifiedFunctionAlign,
+ kMultipleFunctionAlign = kUnspecifiedFunctionAlign,
+ kSingleFunctionAlign = kUnspecifiedFunctionAlign,
+
+ kUnspecifiedDataSize = 3 * sizeof(int),
+ kVirtualDataSize = kUnspecifiedDataSize,
+ kMultipleDataSize = kUnspecifiedDataSize,
+ kSingleDataSize = kUnspecifiedDataSize,
+
+ kUnspecifiedFunctionSize = 2 * sizeof(int) + 2 * sizeof(void *),
+ kVirtualFunctionSize = kUnspecifiedFunctionSize,
+ kMultipleFunctionSize = kUnspecifiedFunctionSize,
+ kSingleFunctionSize = kUnspecifiedFunctionSize,
+};
+#else
+#error "test doesn't yet support this mode!"
+#endif

// incomplete types
+#ifdef VMB
class single_inheritance IncSingle;
class multiple_inheritance IncMultiple;
class __virtual_inheritance IncVirtual;
+#else
+class IncSingle;
+class IncMultiple;
+class IncVirtual;
+#endif
static_assert(sizeof(int IncSingle::*) == kSingleDataSize, "");
static_assert(sizeof(int IncMultiple::*) == kMultipleDataSize, "");
static_assert(sizeof(int IncVirtual::*) == kVirtualDataSize, "");
@@ -83,9 +121,15 @@

Test both declared and defined templates.
template <typename T> class X;
+#ifdef VMB
template <> class single_inheritance X<IncSingle>;
template <> class multiple_inheritance X<IncMultiple>;
template <> class __virtual_inheritance X<IncVirtual>;
+#else
+template <> class X<IncSingle>;
+template <> class X<IncMultiple>;
+template <> class X<IncVirtual>;
+#endif
Don't declare X<IncUnspecified>.
static_assert(sizeof(int X<IncSingle>::*) == kSingleDataSize, "");
static_assert(sizeof(int X<IncMultiple>::*) == kMultipleDataSize, "");
@@ -183,8 +227,10 @@

void (T::*func_ptr)();

};

+#ifdef VMB
int Virtual::*CastTest = reinterpret_cast<int Virtual::*>(&AA::x);

// expected-error@-1 {{cannot reinterpret_cast from member pointer type}}

+#endif

namespace ErrorTest {
template <typename T, typename U> struct single_inheritance A;
@@ -202,7 +248,7 @@
struct virtual_inheritance D;
struct D : virtual B {};
}

+#ifdef VMB
#pragma pointers_to_members(full_generality, multiple_inheritance)
struct TrulySingleInheritance;
static_assert(sizeof(int TrulySingleInheritance::*) == kMultipleDataSize, "");
@@ -225,3 +271,4 @@
static_assert(sizeof(int SingleInheritanceAsVirtualBeforePragma::*) == 12, "");

#pragma pointers_to_members(single) // expected-error{{unexpected 'single'}}
+#endif

~Aaron

[hans]

Looks good from my end.

[majnemer]

Closed by commit rL201175 (authored by @majnemer).

cfe/trunk/include/clang/Basic/LangOptions.h

public:
   enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
   
   enum SignedOverflowBehaviorTy {
     SOB_Undefined,  // Default C standard behavior.
     SOB_Defined,    // -fwrapv
     SOB_Trapping    // -ftrapv
   };
 
+  enum PragmaMSPointersToMembersKind {
+    PPTMK_BestCase,
+    PPTMK_FullGeneralitySingleInheritance,
+    PPTMK_FullGeneralityMultipleInheritance,
+    PPTMK_FullGeneralityVirtualInheritance
+  };
+
   enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
 
 public:
   clang::ObjCRuntime ObjCRuntime;
 
   std::string ObjCConstantStringClass;
   
   /// \brief The name of the handler function to be called when -ftrapv is

cfe/trunk/include/clang/Basic/LangOptions.def

 LANGOPT(FastMath          , 1, 0, "__FAST_MATH__ predefined macro")
 LANGOPT(FiniteMathOnly    , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
 
 BENIGN_LANGOPT(ObjCGCBitmapPrint , 1, 0, "printing of GC's bitmap layout for __weak/__strong ivars")
 
 BENIGN_LANGOPT(AccessControl     , 1, 1, "C++ access control")
 LANGOPT(CharIsSigned      , 1, 1, "signed char")
 LANGOPT(ShortWChar        , 1, 0, "unsigned short wchar_t")
+ENUM_LANGOPT(MSPointerToMemberRepresentationMethod, PragmaMSPointersToMembersKind, 2, PPTMK_BestCase, "member-pointer representation method")
 
 LANGOPT(ShortEnums        , 1, 0, "short enum types")
 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL version")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(OpenMP            , 1, 0, "OpenMP support")

cfe/trunk/include/clang/Driver/CLCompatOptions.td

def _SLASH_Oy_ : CLFlag<"Oy-">, HelpText<"Disable frame pointer omission">,
   Alias<fno_omit_frame_pointer>;
 def _SLASH_QUESTION : CLFlag<"?">, Alias<help>,
   HelpText<"Display available options">;
 def _SLASH_showIncludes : CLFlag<"showIncludes">,
   HelpText<"Print info about included files to stderr">,
   Alias<show_includes>;
 def _SLASH_U : CLJoinedOrSeparate<"U">, HelpText<"Undefine macro">,
   MetaVarName<"<macro>">, Alias<U>;
+def _SLASH_vmb : CLFlag<"vmb">,
+  HelpText<"Use a best-case representation method for member pointers">;
+def _SLASH_vmg : CLFlag<"vmg">,
+  HelpText<"Use a most-general representation for member pointers">;
+def _SLASH_vms : CLFlag<"vms">,
+  HelpText<"Set the default most-general representation to single inheritance">;
+def _SLASH_vmm : CLFlag<"vmm">,
+  HelpText<"Set the default most-general representation to multiple inheritance">;
+def _SLASH_vmv : CLFlag<"vmv">,
+  HelpText<"Set the default most-general representation to virtual inheritance">;
 def _SLASH_W0 : CLFlag<"W0">, HelpText<"Disable all warnings">, Alias<w>;
 def _SLASH_W1 : CLFlag<"W1">, HelpText<"Enable -Wall">, Alias<Wall>;
 def _SLASH_W2 : CLFlag<"W2">, HelpText<"Enable -Wall">, Alias<Wall>;
 def _SLASH_W3 : CLFlag<"W3">, HelpText<"Enable -Wall">, Alias<Wall>;
 def _SLASH_W4 : CLFlag<"W4">, HelpText<"Enable -Wall">, Alias<Wall>;
 def _SLASH_Wall : CLFlag<"Wall">, HelpText<"Enable -Wall">, Alias<Wall>;
 def _SLASH_WX : CLFlag<"WX">, HelpText<"Treat warnings as errors">,
   Alias<W_Joined>, AliasArgs<["error"]>;

 def _SLASH_GS_ : CLIgnoredFlag<"GS-">;
 def _SLASH_kernel_ : CLIgnoredFlag<"kernel-">;
 def _SLASH_nologo : CLIgnoredFlag<"nologo">;
 def _SLASH_Ob1 : CLIgnoredFlag<"Ob1">;
 def _SLASH_Ob2 : CLIgnoredFlag<"Ob2">;
 def _SLASH_RTC : CLIgnoredJoined<"RTC">;
 def _SLASH_sdl : CLIgnoredFlag<"sdl">;
 def _SLASH_sdl_ : CLIgnoredFlag<"sdl-">;
-def _SLASH_vmg : CLIgnoredFlag<"vmg">;
 def _SLASH_w : CLIgnoredJoined<"w">;
 def _SLASH_Zc_forScope : CLIgnoredFlag<"Zc:forScope">;
 def _SLASH_Zc_wchar_t : CLIgnoredFlag<"Zc:wchar_t">;
 def _SLASH_Zm : CLIgnoredJoined<"Zm">;
 
 
 // Unsupported:
 

 def _SLASH_Qfast_transcendentals : CLFlag<"Qfast_transcendentals">;
 def _SLASH_QIfist : CLFlag<"QIfist">;
 def _SLASH_Qimprecise_fwaits : CLFlag<"Qimprecise_fwaits">;
 def _SLASH_Qpar : CLFlag<"Qpar">;
 def _SLASH_Qvec_report : CLJoined<"Qvec-report">;
 def _SLASH_u : CLFlag<"u">;
 def _SLASH_V : CLFlag<"V">;
 def _SLASH_vd : CLJoined<"vd">;
-def _SLASH_vmb : CLFlag<"vmb">;
-def _SLASH_vmm : CLFlag<"vmm">;
-def _SLASH_vms : CLFlag<"vms">;
-def _SLASH_vmv : CLFlag<"vmv">;
 def _SLASH_volatile : CLFlag<"volatile">;
 def _SLASH_WL : CLFlag<"WL">;
 def _SLASH_Wp64 : CLFlag<"Wp64">;
 def _SLASH_X : CLFlag<"X">;
 def _SLASH_Yc : CLJoined<"Yc">;
 def _SLASH_Y_ : CLFlag<"Y-">;
 def _SLASH_Yd : CLFlag<"Yd">;
 def _SLASH_Yl : CLJoined<"Yl">;

cfe/trunk/include/clang/Driver/Options.td

def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;
 def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable full Microsoft Visual C++ compatibility">;
 def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
   HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
 def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,
   HelpText<"Parse templated function definitions at the end of the "
            "translation unit">,  Flags<[CC1Option]>;
+def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
 def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
   Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module cache path">;
 def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,
   HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">;
 def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,

cfe/trunk/include/clang/Sema/Sema.h

public:
   DeclarationName VAListTagName;
 
   /// PackContext - Manages the stack for \#pragma pack. An alignment
   /// of 0 indicates default alignment.
   void *PackContext; // Really a "PragmaPackStack*"
 
   bool MSStructPragmaOn; // True when \#pragma ms_struct on
 
-  enum PragmaMSPointersToMembersKind {
-    PPTMK_BestCase,
-    PPTMK_FullGeneralitySingleInheritance,
-    PPTMK_FullGeneralityMultipleInheritance,
-    PPTMK_FullGeneralityVirtualInheritance
-  };
-
   /// \brief Controls member pointer representation format under the MS ABI.
-  PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod;
+  LangOptions::PragmaMSPointersToMembersKind
+      MSPointerToMemberRepresentationMethod;
 
   /// \brief Source location for newly created implicit MSInheritanceAttrs
   SourceLocation ImplicitMSInheritanceAttrLoc;
 
   /// VisContext - Manages the stack for \#pragma GCC visibility.
   void *VisContext; // Really a "PragmaVisStack*"
 
   /// \brief Flag indicating if Sema is building a recovery call expression.

 
   /// ActOnPragmaMSComment - Called on well formed
   /// \#pragma comment(kind, "arg").
   void ActOnPragmaMSComment(PragmaMSCommentKind Kind, StringRef Arg);
 
   /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
   /// pointers_to_members(representation method[, general purpose
   /// representation]).
-  void ActOnPragmaMSPointersToMembers(PragmaMSPointersToMembersKind Kind,
-                                      SourceLocation PragmaLoc);
+  void ActOnPragmaMSPointersToMembers(
+      LangOptions::PragmaMSPointersToMembersKind Kind,
 
   /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
   void ActOnPragmaDetectMismatch(StringRef Name, StringRef Value);
 
   /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
   void ActOnPragmaUnused(const Token &Identifier,
                          Scope *curScope,
                          SourceLocation PragmaLoc);

cfe/trunk/lib/Driver/Tools.cpp

void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
   // This provides POSIX compatibility (maps 'open' to '_open'), which most
   // users want.  The /Za flag to cl.exe turns this off, but it's not
   // implemented in clang.
   CmdArgs.push_back("--dependent-lib=oldnames");
 
   if (Arg *A = Args.getLastArg(options::OPT_show_includes))
     A->render(Args, CmdArgs);
 
+  const Driver &D = getToolChain().getDriver();
+  Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
+  Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
+  if (MostGeneralArg && BestCaseArg)
+    D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+        << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
+
+  if (MostGeneralArg) {
+    Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
+    Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
+    Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
+
+    Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
+    Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
+    if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
+      D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+          << FirstConflict->getAsString(Args)
+          << SecondConflict->getAsString(Args);
+
+    if (SingleArg)
+      CmdArgs.push_back("-fms-memptr-rep=single");
+    else if (MultipleArg)
+      CmdArgs.push_back("-fms-memptr-rep=multiple");
+    else
+      CmdArgs.push_back("-fms-memptr-rep=virtual");
+  }
+
   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
     if (Args.hasArg(options::OPT__SLASH_fallback))
       CmdArgs.push_back("msvc-fallback");
     else
       CmdArgs.push_back("msvc");
   }
 }

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

case LangOptions::ASMM_On:
       Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
       break;
     case LangOptions::ASMM_Off:
       Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
       break;
     }
   }
 
+  if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
+    LangOptions::PragmaMSPointersToMembersKind InheritanceModel =
+        llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
+            A->getValue())
+            .Case("single",
+                  LangOptions::PPTMK_FullGeneralitySingleInheritance)
+            .Case("multiple",
+                  LangOptions::PPTMK_FullGeneralityMultipleInheritance)
+            .Case("virtual",
+                  LangOptions::PPTMK_FullGeneralityVirtualInheritance)
+            .Default(LangOptions::PPTMK_BestCase);
+    if (InheritanceModel == LangOptions::PPTMK_BestCase)
+      Diags.Report(diag::err_drv_invalid_value)
+          << "-fms-memptr-rep=" << A->getValue();
+
+    Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
+  }
+
   // Check if -fopenmp is specified.
   Opts.OpenMP = Args.hasArg(OPT_fopenmp);
 
   // Record whether the __DEPRECATED define was requested.
   Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
                                  OPT_fno_deprecated_macro,
                                  Opts.Deprecated);
 

cfe/trunk/lib/Parse/ParsePragma.cpp

#include "clang/Basic/OpenCLExtensions.def"
   else {
     PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
     return;
   }
 }
 
 void Parser::HandlePragmaMSPointersToMembers() {
   assert(Tok.is(tok::annot_pragma_ms_pointers_to_members));
-  Sema::PragmaMSPointersToMembersKind RepresentationMethod =
-      static_cast<Sema::PragmaMSPointersToMembersKind>(
+  LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =
+      static_cast<LangOptions::PragmaMSPointersToMembersKind>(
           reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
   SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
   Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc);
 }
 
 
 // #pragma GCC visibility comes in two variants:
 //   'push' '(' [visibility] ')'
void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP,
   const IdentifierInfo *Arg = Tok.getIdentifierInfo();
   if (!Arg) {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
       << "pointers_to_members";
     return;
   }
   PP.Lex(Tok);
 
-  Sema::PragmaMSPointersToMembersKind RepresentationMethod;
+  LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;
   if (Arg->isStr("best_case")) {
-    RepresentationMethod = Sema::PPTMK_BestCase;
+    RepresentationMethod = LangOptions::PPTMK_BestCase;
   } else {
     if (Arg->isStr("full_generality")) {
       if (Tok.is(tok::comma)) {
         PP.Lex(Tok);
 
         Arg = Tok.getIdentifierInfo();
         if (!Arg) {
           PP.Diag(Tok.getLocation(),
                   diag::err_pragma_pointers_to_members_unknown_kind)
               << Tok.getKind() << /*OnlyInheritanceModels*/ 0;
           return;
         }
         PP.Lex(Tok);
       } else if (Tok.is(tok::r_paren)) {
         // #pragma pointers_to_members(full_generality) implicitly specifies
         // virtual_inheritance.
         Arg = 0;
-        RepresentationMethod = Sema::PPTMK_FullGeneralityVirtualInheritance;
+        RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance;
       } else {
         PP.Diag(Tok.getLocation(), diag::err_expected_punc)
             << "full_generality";
         return;
       }
     }
 
     if (Arg) {
       if (Arg->isStr("single_inheritance")) {
-        RepresentationMethod = Sema::PPTMK_FullGeneralitySingleInheritance;
+        RepresentationMethod =
+            LangOptions::PPTMK_FullGeneralitySingleInheritance;
       } else if (Arg->isStr("multiple_inheritance")) {
-        RepresentationMethod = Sema::PPTMK_FullGeneralityMultipleInheritance;
+        RepresentationMethod =
+            LangOptions::PPTMK_FullGeneralityMultipleInheritance;
       } else if (Arg->isStr("virtual_inheritance")) {
-        RepresentationMethod = Sema::PPTMK_FullGeneralityVirtualInheritance;
+        RepresentationMethod =
+            LangOptions::PPTMK_FullGeneralityVirtualInheritance;
       } else {
         PP.Diag(Tok.getLocation(),
                 diag::err_pragma_pointers_to_members_unknown_kind)
             << Arg << /*HasPointerDeclaration*/ 1;
         return;
       }
     }
   }

cfe/trunk/lib/Sema/Sema.cpp

Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
            CodeCompleteConsumer *CodeCompleter)
   : ExternalSource(0),
     isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()),
     LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer),
     Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
     CollectStats(false), CodeCompleter(CodeCompleter),
     CurContext(0), OriginalLexicalContext(0),
     PackContext(0), MSStructPragmaOn(false),
-    MSPointerToMemberRepresentationMethod(PPTMK_BestCase), VisContext(0),
+    MSPointerToMemberRepresentationMethod(
+        pp.getLangOpts().getMSPointerToMemberRepresentationMethod()),
+    VisContext(0),
     IsBuildingRecoveryCallExpr(false),
     ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
     IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
     NSNumberDecl(0),
     NSStringDecl(0), StringWithUTF8StringMethod(0),
     NSArrayDecl(0), ArrayWithObjectsMethod(0),
     NSDictionaryDecl(0), DictionaryWithObjectsMethod(0),
     GlobalNewDeleteDeclared(false),

cfe/trunk/lib/Sema/SemaAttr.cpp

 }
 
 void Sema::ActOnPragmaDetectMismatch(StringRef Name, StringRef Value) {
   // FIXME: Serialize this.
   Consumer.HandleDetectMismatch(Name, Value);
 }
 
 void Sema::ActOnPragmaMSPointersToMembers(
-    PragmaMSPointersToMembersKind RepresentationMethod,
+    LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
     SourceLocation PragmaLoc) {
   MSPointerToMemberRepresentationMethod = RepresentationMethod;
   ImplicitMSInheritanceAttrLoc = PragmaLoc;
 }
 
 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
                              SourceLocation PragmaLoc) {
 

cfe/trunk/lib/Sema/SemaType.cpp

if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
         if (!MPTy->getClass()->isDependentType()) {
           RequireCompleteType(Loc, QualType(MPTy->getClass(), 0), 0);
 
           CXXRecordDecl *RD = MPTy->getMostRecentCXXRecordDecl();
           if (!RD->hasAttr<MSInheritanceAttr>()) {
             MSInheritanceAttr::Spelling InheritanceModel;
 
             switch (MSPointerToMemberRepresentationMethod) {
-            case PPTMK_BestCase:
+            case LangOptions::PPTMK_BestCase:
               InheritanceModel = RD->calculateInheritanceModel();
               break;
-            case PPTMK_FullGeneralitySingleInheritance:
+            case LangOptions::PPTMK_FullGeneralitySingleInheritance:
               InheritanceModel = MSInheritanceAttr::Keyword_single_inheritance;
               break;
-            case PPTMK_FullGeneralityMultipleInheritance:
+            case LangOptions::PPTMK_FullGeneralityMultipleInheritance:
               InheritanceModel =
                   MSInheritanceAttr::Keyword_multiple_inheritance;
               break;
-            case PPTMK_FullGeneralityVirtualInheritance:
+            case LangOptions::PPTMK_FullGeneralityVirtualInheritance:
               InheritanceModel =
                   MSInheritanceAttr::Keyword_unspecified_inheritance;
               break;
             }
 
             RD->addAttr(MSInheritanceAttr::CreateImplicit(
                 getASTContext(), InheritanceModel,
                 /*BestCase=*/MSPointerToMemberRepresentationMethod ==
-                    PPTMK_BestCase,
+                    LangOptions::PPTMK_BestCase,
                 ImplicitMSInheritanceAttrLoc.isValid()
                     ? ImplicitMSInheritanceAttrLoc
                     : RD->getSourceRange()));
           }
         }
       }
     }
 

cfe/trunk/test/Driver/cl-options.c

 
 // RUN: %clang_cl /showIncludes -### -- %s 2>&1 | FileCheck -check-prefix=showIncludes %s
 // showIncludes: --show-includes
 
 // RUN: %clang_cl /Umymacro -### -- %s 2>&1 | FileCheck -check-prefix=U %s
 // RUN: %clang_cl /U mymacro -### -- %s 2>&1 | FileCheck -check-prefix=U %s
 // U: "-U" "mymacro"
 
+// RUN: %clang_cl /vmg -### -- %s 2>&1 | FileCheck -check-prefix=VMG %s
+// VMG: "-fms-memptr-rep=virtual"
+
+// RUN: %clang_cl /vmg /vms -### -- %s 2>&1 | FileCheck -check-prefix=VMS %s
+// VMS: "-fms-memptr-rep=single"
+
+// RUN: %clang_cl /vmg /vmm -### -- %s 2>&1 | FileCheck -check-prefix=VMM %s
+// VMM: "-fms-memptr-rep=multiple"
+
+// RUN: %clang_cl /vmg /vmv -### -- %s 2>&1 | FileCheck -check-prefix=VMV %s
+// VMV: "-fms-memptr-rep=virtual"
+
+// RUN: %clang_cl /vmg /vmb -### -- %s 2>&1 | FileCheck -check-prefix=VMB %s
+// VMB: '/vmg' not allowed with '/vmb'
+
+// RUN: %clang_cl /vmg /vmm /vms -### -- %s 2>&1 | FileCheck -check-prefix=VMX %s
+// VMX: '/vms' not allowed with '/vmm'
+
 // RUN: %clang_cl /W0 -### -- %s 2>&1 | FileCheck -check-prefix=W0 %s
 // W0: -w
 
 // RUN: %clang_cl /W1 -### -- %s 2>&1 | FileCheck -check-prefix=W1 %s
 // RUN: %clang_cl /W2 -### -- %s 2>&1 | FileCheck -check-prefix=W1 %s
 // RUN: %clang_cl /W3 -### -- %s 2>&1 | FileCheck -check-prefix=W1 %s
 // RUN: %clang_cl /W4 -### -- %s 2>&1 | FileCheck -check-prefix=W1 %s
 // RUN: %clang_cl /Wall -### -- %s 2>&1 | FileCheck -check-prefix=W1 %s

 // RUN:     /Qfast_transcendentals \
 // RUN:     /QIfist \
 // RUN:     /Qimprecise_fwaits \
 // RUN:     /Qpar \
 // RUN:     /Qvec-report:2 \
 // RUN:     /u \
 // RUN:     /V \
 // RUN:     /vd2 \
-// RUN:     /vmb \
-// RUN:     /vmm \
-// RUN:     /vms \
-// RUN:     /vmv \
 // RUN:     /volatile \
 // RUN:     /wfoo \
 // RUN:     /WL \
 // RUN:     /Wp64 \
 // RUN:     /X \
 // RUN:     /Y- \
 // RUN:     /Yc \
 // RUN:     /Ycstdafx.h \

cfe/trunk/test/SemaCXX/member-pointer-ms.cpp

-// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify %s
-// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify %s
+// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify -DVMB %s
+// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMB %s
+// RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMV -fms-memptr-rep=virtual %s
 //
 // This file should also give no diagnostics when run through cl.exe from MSVS
 // 2012, which supports C++11 and static_assert.  It should pass for both 64-bit
 // and 32-bit x86.
 //
 // Test the size of various member pointer combinations:
 // - complete and incomplete
 // - single, multiple, and virtual inheritance (and unspecified for incomplete)
 // - data and function pointers
 // - templated with declared specializations with annotations
 // - template that can be instantiated
 
 // http://llvm.org/PR12070
 struct Foo {
   typedef int Foo::*FooInt;
   int f;
 };
 
+#ifdef VMB
 enum {
   kSingleDataAlign             = 1 * sizeof(int),
   kSingleFunctionAlign         = 1 * sizeof(void *),
   kMultipleDataAlign           = 1 * sizeof(int),
   // Everything with more than 1 field is 8 byte aligned, except virtual data
   // member pointers on x64 (ugh).
   kMultipleFunctionAlign       = 8,
 #ifdef _M_X64
#endif
   kSingleFunctionSize         = 1 * sizeof(void *),
   kMultipleDataSize           = 1 * sizeof(int),
   kMultipleFunctionSize       = 2 * sizeof(void *),
   kVirtualDataSize            = 2 * sizeof(int),
   kVirtualFunctionSize        = 2 * sizeof(int) + 1 * sizeof(void *),
   kUnspecifiedDataSize        = 3 * sizeof(int),
   kUnspecifiedFunctionSize    = 2 * sizeof(int) + 2 * sizeof(void *),
 };
+#elif VMV
+enum {
+  // Everything with more than 1 field is 8 byte aligned, except virtual data
+  // member pointers on x64 (ugh).
+#ifdef _M_X64
+  kVirtualDataAlign = 4,
+#else
+  kVirtualDataAlign = 8,
+#endif
+  kMultipleDataAlign = kVirtualDataAlign,
+  kSingleDataAlign = kVirtualDataAlign,
+
+  kUnspecifiedFunctionAlign = 8,
+  kVirtualFunctionAlign = kUnspecifiedFunctionAlign,
+  kMultipleFunctionAlign = kUnspecifiedFunctionAlign,
+  kSingleFunctionAlign = kUnspecifiedFunctionAlign,
+
+  kUnspecifiedDataSize = 3 * sizeof(int),
+  kVirtualDataSize = kUnspecifiedDataSize,
+  kMultipleDataSize = kUnspecifiedDataSize,
+  kSingleDataSize = kUnspecifiedDataSize,
+
+  kUnspecifiedFunctionSize = 2 * sizeof(int) + 2 * sizeof(void *),
+  kVirtualFunctionSize = kUnspecifiedFunctionSize,
+  kMultipleFunctionSize = kUnspecifiedFunctionSize,
+  kSingleFunctionSize = kUnspecifiedFunctionSize,
+};
+#else
+#error "test doesn't yet support this mode!"
+#endif
 
 // incomplete types
+#ifdef VMB
 class __single_inheritance IncSingle;
 class __multiple_inheritance IncMultiple;
 class __virtual_inheritance IncVirtual;
+#else
+class IncSingle;
+class IncMultiple;
+class IncVirtual;
+#endif
 static_assert(sizeof(int IncSingle::*)        == kSingleDataSize, "");
 static_assert(sizeof(int IncMultiple::*)      == kMultipleDataSize, "");
 static_assert(sizeof(int IncVirtual::*)       == kVirtualDataSize, "");
 static_assert(sizeof(void (IncSingle::*)())   == kSingleFunctionSize, "");
 static_assert(sizeof(void (IncMultiple::*)()) == kMultipleFunctionSize, "");
 static_assert(sizeof(void (IncVirtual::*)())  == kVirtualFunctionSize, "");
 
 static_assert(__alignof(int IncSingle::*)        == kSingleDataAlign, "");

 static_assert(sizeof(int Multiple::*)      == kMultipleDataSize, "");
 static_assert(sizeof(int Virtual::*)       == kVirtualDataSize, "");
 static_assert(sizeof(void (Single::*)())   == kSingleFunctionSize, "");
 static_assert(sizeof(void (Multiple::*)()) == kMultipleFunctionSize, "");
 static_assert(sizeof(void (Virtual::*)())  == kVirtualFunctionSize, "");
 
 // Test both declared and defined templates.
 template <typename T> class X;
+#ifdef VMB
 template <> class __single_inheritance   X<IncSingle>;
 template <> class __multiple_inheritance X<IncMultiple>;
 template <> class __virtual_inheritance  X<IncVirtual>;
+#else
+template <> class X<IncSingle>;
+template <> class X<IncMultiple>;
+template <> class X<IncVirtual>;
+#endif
 // Don't declare X<IncUnspecified>.
 static_assert(sizeof(int X<IncSingle>::*)           == kSingleDataSize, "");
 static_assert(sizeof(int X<IncMultiple>::*)         == kMultipleDataSize, "");
 static_assert(sizeof(int X<IncVirtual>::*)          == kVirtualDataSize, "");
 static_assert(sizeof(int X<IncUnspecified>::*)      == kUnspecifiedDataSize, "");
 static_assert(sizeof(void (X<IncSingle>::*)())      == kSingleFunctionSize, "");
 static_assert(sizeof(void (X<IncMultiple>::*)())    == kMultipleFunctionSize, "");
 static_assert(sizeof(void (X<IncVirtual>::*)())     == kVirtualFunctionSize, "");

 template <typename T>
 struct MemPtrInTemplate {
   // We can't require that the template arg be complete until we're
   // instantiated.
   int T::*data_ptr;
   void (T::*func_ptr)();
 };
 
+#ifdef VMB
 int Virtual::*CastTest = reinterpret_cast<int Virtual::*>(&AA::x);
   // expected-error@-1 {{cannot reinterpret_cast from member pointer type}}
+#endif
 
 namespace ErrorTest {
 template <typename T, typename U> struct __single_inheritance A;
   // expected-warning@-1 {{inheritance model ignored on primary template}}
 template <typename T> struct __multiple_inheritance A<T, T>;
   // expected-warning@-1 {{inheritance model ignored on partial specialization}}
 template <> struct __single_inheritance A<int, float>;
 
 struct B {}; // expected-note {{B defined here}}
 struct __multiple_inheritance B; // expected-error{{inheritance model does not match definition}}
 
 struct __multiple_inheritance C {}; // expected-error{{inheritance model does not match definition}}
  // expected-note@-1 {{C defined here}}
 
 struct __virtual_inheritance D;
 struct D : virtual B {};
 }
-
+#ifdef VMB
 #pragma pointers_to_members(full_generality, multiple_inheritance)
 struct TrulySingleInheritance;
 static_assert(sizeof(int TrulySingleInheritance::*) == kMultipleDataSize, "");
 #pragma pointers_to_members(best_case)
 // This definition shouldn't conflict with the increased generality that the
 // multiple_inheritance model gave to TrulySingleInheritance.
 struct TrulySingleInheritance {};
 
 // Even if a definition proceeds the first mention of a pointer to member, we
 // still give the record the fully general representation.
 #pragma pointers_to_members(full_generality, virtual_inheritance)
 struct SingleInheritanceAsVirtualAfterPragma {};
 static_assert(sizeof(int SingleInheritanceAsVirtualAfterPragma::*) == 12, "");
 
 #pragma pointers_to_members(best_case)
 
 // The above holds even if the pragma comes after the definition.
 struct SingleInheritanceAsVirtualBeforePragma {};
 #pragma pointers_to_members(virtual_inheritance)
 static_assert(sizeof(int SingleInheritanceAsVirtualBeforePragma::*) == 12, "");
 
 #pragma pointers_to_members(single) // expected-error{{unexpected 'single'}}
+#endif