[Driver] Ignore -fmsc-version= -fms-compatibility-version= values smaller than 19

[MaskRay]

Summary

It's perhaps time to drop support for MSVC<2015 (-std=c++11,
-fno-threadsafe-statics, and a lot of LangOptions::MSVC2015) compatibility
checking code).

Emit warnings for now.

Note: D92515/D103293 bumped MSVC required version for building llvm-project.

[rnk]

I don't see the MSVC build requirement as being related to the version of MSVC that clang-cl supports targeting. Those can be separate. That said, this might be the right time to sunset this compatibility logic.

If we do this, I'd like it to be a policy change. We should add a release note about dropping support for -fmsc-version=N for N<1900, and audit for other logic like this:
https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaDeclCXX.cpp#L6390

Bonus points for a warning when the user passes -fms-compatibility-version=18.*.

[MaskRay]

.

[rnk]

There are a lot more hits for isCompatibleWithMSVC used with 2015 across the codebase. Do you want to handle them in a follow up? That's fine with me.

I would like to get a second opinion before doing this. [e-mail]

[hans]

I'm conflicted about this. I see where you're coming from, but I could imagine people using clang-cl with old VS versions e.g. to target old Windows. I agree we shouldn't go out of our way to support that, but do we think it's too much effort to keep the functionality we have (as defined by the lit tests) working?

[STL_MSFT]

A couple of notes/reminders that may help you make a decision here (I have no particular opinion as this doesn't impact how VS and microsoft/STL use Clang):

1. VS 2013's support lifecycle, documented at https://learn.microsoft.com/en-us/lifecycle/products/visual-studio-2013 , is ending soon: Apr 9, 2024.

2. VS 2013 was the last release before the current "v19" binary-compatible era (VS 2015/2017/2019/2022). Code compiled with VS 2013 can't link with any other version (the CRT became the UCRT and the STL changed) - I believe this makes it less likely that users are stuck on this version.

[probinson]

These kinds of compatibility changes generally should get a Discourse post for better visibility.

clang/docs/ReleaseNotes.rst

85

Or words to that effect. "19.0" isn't particularly descriptive.

[aaron.ballman]

Adding clang-vendors for awareness as this has the potential to impact folks vending clang.

In D134468#3811882, @probinson wrote:

These kinds of compatibility changes generally should get a Discourse post for better visibility.

Strong +1, this needs a community RFC to see if we have folks relying on this support. For example, Intel supports ICX as a drop-in replacement for cl, and I'm not certain what our MSVC compatibility requirements are (I'm trying to find out though; CC @andrew.w.kaylor
for awareness).

In D134468#3810030, @hans wrote:

I'm conflicted about this. I see where you're coming from, but I could imagine people using clang-cl with old VS versions e.g. to target old Windows. I agree we shouldn't go out of our way to support that, but do we think it's too much effort to keep the functionality we have (as defined by the lit tests) working?

I'm also conflicted -- what's the pain point we're trying to solve with these changes? It doesn't seem like maintenance is an actual burden in practice.

In D134468#3809713, @rnk wrote:

If we do this, I'd like it to be a policy change. We should add a release note about dropping support for -fmsc-version=N for N<1900, and audit for other logic like this:
https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaDeclCXX.cpp#L6390

Do we have a policy written down anywhere for this? We have one for what versions of MSVC we'll support building LLVM with, but I don't think we have a policy for what versions of MSVC we'll support being compatible with. Given that we still have GCC compatibility hacks for GCC 4.2 (which we still report we emulate with the GNU version macros!) which came out in 2008, I'd like more motivation as for why we want to drop support for MSVC 2013 and a better understanding of how we decide when we no longer will support compatibility with an older compiler -- we should be able to communicate this to users so their expectations are set appropriately.

[thieta]

I think we should define a policy for this. I doubt we have many users on these older versions but I think maybe we should give deprecation messages for at least one release before we drop it?

[MaskRay]

I am not a Windows driver user. This patch is entirely motivated by Windows discussions in D131465 and I want to make /std: default rule simple (say, clang 16 uses C++17 for every mode for Windows). If the -fno-threadsafe-statics compatibility change is considered too risky, perhaps I'll just change this patch to just do C++17.

[hans]

In D134468#3812846, @MaskRay wrote:

I am not a Windows driver user. This patch is entirely motivated by Windows discussions in D131465 and I want to make /std: default rule simple (say, clang 16 uses C++17 for every mode for Windows). If the -fno-threadsafe-statics compatibility change is considered too risky, perhaps I'll just change this patch to just do C++17.

If the D131465 discussion decides to bump to c++17, I think we should just do that bump and not drop the other compatibility stuff.

[MaskRay]

I am not a user of the MSVC toolchain, so leaving this work to someone working on it is better:)

clang/docs/ReleaseNotes.rst

- Clang now disallows types whose sizes aren't a multiple of their alignments to
 
   .. code-block:: c
 
     void func(const int *i);
     void other(void) {
       void (*fp)(int *) = func; // Previously a warning, now a downgradable error.
     }
 
+- When ``-fmsc-version=`` or ``-fms-compatibility-version=`` is specified,
+  a version smaller than ``19.0`` is now unsupported.
+
 
 What's New in Clang |release|?
 ==============================
 Some of the major new features and improvements to Clang are listed
 here. Generic improvements to Clang as a whole or to its underlying
 infrastructure are described first, followed by language-specific
 sections with improvements to Clang's support for those languages.
 

clang/include/clang/Basic/DiagnosticDriverKinds.td

def warn_drv_ps_sdk_dir : Warning<
   InGroup<InvalidOrNonExistentDirectory>;
 
 def err_drv_defsym_invalid_format : Error<"defsym must be of the form: sym=value: %0">;
 def err_drv_defsym_invalid_symval : Error<"value is not an integer: %0">;
 def warn_drv_msvc_not_found : Warning<
   "unable to find a Visual Studio installation; "
   "try running Clang from a developer command prompt">,
   InGroup<DiagGroup<"msvc-not-found">>;
+def warn_drv_unsupported_ms_compatibility_version : Warning<"unsupported '%0' is ignored. "
+  "19.0 is the minimum supported version">,
+  InGroup<OptionIgnored>;
 
 def warn_drv_fuse_ld_path : Warning<
   "'-fuse-ld=' taking a path is deprecated; use '--ld-path=' instead">,
   InGroup<FUseLdPath>, DefaultIgnore;
 
 def warn_drv_fine_grained_bitfield_accesses_ignored : Warning<
   "option '-ffine-grained-bitfield-accesses' cannot be enabled together with a sanitizer; flag ignored">,
   InGroup<OptionIgnored>;

clang/lib/Driver/ToolChain.cpp

ToolChain::computeMSVCVersion(const Driver *D,
   if (MSCompatibilityVersion) {
     VersionTuple MSVT;
     if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
       if (D)
         D->Diag(diag::err_drv_invalid_value)
             << MSCompatibilityVersion->getAsString(Args)
             << MSCompatibilityVersion->getValue();
     } else {
+      if (MSVT.getMajor() < 19) {
+        if (D)
+          D->Diag(diag::warn_drv_unsupported_ms_compatibility_version)
+              << MSCompatibilityVersion->getAsString(Args);
+        MSVT = VersionTuple();
+      }
       return MSVT;
     }
   }
 
   if (MSCVersion) {
     unsigned Version = 0;
     if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {
       if (D)
         D->Diag(diag::err_drv_invalid_value)
             << MSCVersion->getAsString(Args) << MSCVersion->getValue();
     } else {
-      return separateMSVCFullVersion(Version);
+      VersionTuple MSVT = separateMSVCFullVersion(Version);
+      if (MSVT.getMajor() < 19) {
+        if (D)
+          D->Diag(diag::warn_drv_unsupported_ms_compatibility_version)
+              << MSCVersion->getAsString(Args);
+        MSVT = VersionTuple();
+      }
+      return MSVT;
     }
   }
 
   return VersionTuple();
 }
 
 llvm::opt::DerivedArgList *ToolChain::TranslateOpenMPTargetArgs(
     const llvm::opt::DerivedArgList &Args, bool SameTripleAsHost,

clang/lib/Driver/ToolChains/Clang.cpp

CmdArgs.push_back(
         Args.MakeArgString("-fgnuc-version=" + GNUCVer.getAsString()));
   }
 
   VersionTuple MSVT = TC.computeMSVCVersion(&D, Args);
   if (!MSVT.empty())
     CmdArgs.push_back(
         Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
 
-  bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
   if (ImplyVCPPCVer) {
     StringRef LanguageStandard;
     if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
       Std = StdArg;
       LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
                              .Case("c11", "-std=c11")
                              .Case("c17", "-std=c17")
                              .Default("");
if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
                              .Case("c++20", "-std=c++20")
                              .Case("c++latest", "-std=c++2b")
                              .Default("");
       if (LanguageStandard.empty())
         D.Diag(clang::diag::warn_drv_unused_argument)
             << StdArg->getAsString(Args);
     }
 
-    if (LanguageStandard.empty()) {
-      if (IsMSVC2015Compatible)
-        LanguageStandard = "-std=c++14";
-      else
-        LanguageStandard = "-std=c++11";
-    }
+    if (LanguageStandard.empty())
 
     CmdArgs.push_back(LanguageStandard.data());
   }
 
   Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions,
                     options::OPT_fno_borland_extensions);
 
   // -fno-declspec is default, except for PS4/PS5.
   if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
                    RawTriple.isPS()))
     CmdArgs.push_back("-fdeclspec");
   else if (Args.hasArg(options::OPT_fno_declspec))
     CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec.
 
-  // -fthreadsafe-static is default, except for MSVC compatibility versions less
-  // than 19.
+  // -fthreadsafe-static is default, except for OpenCL.
   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
                     options::OPT_fno_threadsafe_statics,
-                    !types::isOpenCL(InputType) &&
-                        (!IsWindowsMSVC || IsMSVC2015Compatible)))
+                    !types::isOpenCL(InputType)))
     CmdArgs.push_back("-fno-threadsafe-statics");
 
   // -fno-delayed-template-parsing is default, except when targeting MSVC.
   // Many old Windows SDK versions require this to parse.
   // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their
   // compiler. We should be able to disable this by default at some point.
   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
                    options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))

clang/test/Driver/cl-options.c

 // Args.hasArg to test whether a boolean flag is present without caring
 // where it appeared. And for this test, it appeared to the left of -gdwarf
 // which made it "win". This test could not detect that bug.
 // RUN: %clang_cl /Z7 -gdwarf /c -### -- %s 2>&1 | FileCheck -check-prefix=Z7_gdwarf %s
 // Z7_gdwarf: "-gcodeview"
 // Z7_gdwarf: "-debug-info-kind=constructor"
 // Z7_gdwarf: "-dwarf-version=
 
-// RUN: %clang_cl -fmsc-version=1800 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX11 %s
-// CXX11: -std=c++11
+// RUN: %clang_cl -fmsc-version=1800 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX14 %s
 
 // RUN: %clang_cl -fmsc-version=1900 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX14 %s
 // CXX14: -std=c++14
 
 // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++14 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX14 %s
 // STDCXX14: -std=c++14
 
 // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++17 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX17 %s

clang/test/Driver/cl-zc.cpp

 // RUN: %clang_cl /c -### /Zc:inline- -- %s 2>&1 | FileCheck -check-prefix=INLINE-OFF %s
 // INLINE-OFF: argument unused during compilation
 
 // RUN: %clang_cl /c -### /Zc:ternary -- %s 2>&1 | FileCheck -check-prefix=TERNARY-ON %s
 // TERNARY-ON-NOT: argument unused during compilation
 // RUN: %clang_cl /c -### /Zc:ternary- -- %s 2>&1 | FileCheck -check-prefix=TERNARY-OFF %s
 // TERNARY-OFF: argument unused during compilation
 
-// thread safe statics are off for versions < 19.
-// RUN: %clang_cl /c -### -fms-compatibility-version=18 -- %s 2>&1 | FileCheck -check-prefix=NoThreadSafeStatics %s
-// RUN: %clang_cl /Zc:threadSafeInit /Zc:threadSafeInit- /c -### -- %s 2>&1 | FileCheck -check-prefix=NoThreadSafeStatics %s
-// NoThreadSafeStatics: "-fno-threadsafe-statics"
-
 // RUN: %clang_cl /Zc:threadSafeInit /c -### -- %s 2>&1 | FileCheck -check-prefix=ThreadSafeStatics %s
 // ThreadSafeStatics-NOT: "-fno-threadsafe-statics"
 
 // RUN: %clang_cl /Zc:dllexportInlines- /c -### -- %s 2>&1 | FileCheck -check-prefix=NoDllExportInlines %s
 // NoDllExportInlines: "-fno-dllexport-inlines"
 // RUN: %clang_cl /Zc:dllexportInlines /c -### -- %s 2>&1 | FileCheck -check-prefix=DllExportInlines %s
 // DllExportInlines-NOT: "-fno-dllexport-inlines"
 

clang/test/Driver/msc-version.c

 //
 // Verify -fms-compatibility-version parsing
 //
 
-// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=14 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR
+// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=20 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR
 
 // CHECK-MSC-VERSION-MAJOR: _MSC_BUILD 1
-// CHECK-MSC-VERSION-MAJOR: _MSC_FULL_VER 140000000
-// CHECK-MSC-VERSION-MAJOR: _MSC_VER 1400
+// CHECK-MSC-VERSION-MAJOR: _MSC_FULL_VER 200000000
+// CHECK-MSC-VERSION-MAJOR: _MSC_VER 2000
 
-// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=15.00 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR-MINOR
+// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=19.00 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR-MINOR
 
 // CHECK-MSC-VERSION-MAJOR-MINOR: _MSC_BUILD 1
-// CHECK-MSC-VERSION-MAJOR-MINOR: _MSC_FULL_VER 150000000
-// CHECK-MSC-VERSION-MAJOR-MINOR: _MSC_VER 1500
+// CHECK-MSC-VERSION-MAJOR-MINOR: _MSC_FULL_VER 190000000
+// CHECK-MSC-VERSION-MAJOR-MINOR: _MSC_VER 1900
 
-// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=15.00.20706 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR-MINOR-BUILD
+// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=19.00.20706 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR-MINOR-BUILD
 
 // CHECK-MSC-VERSION-MAJOR-MINOR-BUILD: _MSC_BUILD 1
-// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD: _MSC_FULL_VER 150020706
-// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD: _MSC_VER 1500
+// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD: _MSC_FULL_VER 190020706
+// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD: _MSC_VER 1900
 
-// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=15.00.20706.01 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH
+// RUN: %clang -target i686-windows -fms-compatibility -fms-compatibility-version=19.00.20706.01 -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH
 
 // CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH: _MSC_BUILD 1
-// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH: _MSC_FULL_VER 150020706
-// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH: _MSC_VER 1500
+// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH: _MSC_FULL_VER 190020706
+// CHECK-MSC-VERSION-MAJOR-MINOR-BUILD-PATCH: _MSC_VER 1900
 
 
 //
 // Verify -fmsc-version and -fms-compatibility-version diagnostic
 //
 
-// RUN: not %clang -target i686-windows -fms-compatibility -fmsc-version=1700 -fms-compatibility-version=17.00.50727.1 -E - </dev/null 2>&1 | FileCheck %s -check-prefix CHECK-BASIC-EXTENDED-DIAGNOSTIC
+// RUN: not %clang -target i686-windows -fms-compatibility -fmsc-version=1900 -fms-compatibility-version=19.00.50727.1 -E - </dev/null 2>&1 | FileCheck %s -check-prefix CHECK-BASIC-EXTENDED-DIAGNOSTIC
 
 // CHECK-BASIC-EXTENDED-DIAGNOSTIC: invalid argument '-fmsc-version={{.*}}' not allowed with '-fms-compatibility-version={{.*}}'
 
 
 //
 // Verify -fmsc-version to -fms-compatibility-version conversion
 //
 
-// RUN: %clang -### -target i686-windows -fms-compatibility -fmsc-version=17 -E - </dev/null -o /dev/null 2>&1 | FileCheck %s -check-prefix CHECK-MSC-17
+// RUN: %clang -### -target i686-windows -fms-compatibility -fmsc-version=19 -E - </dev/null -o /dev/null 2>&1 | FileCheck %s -check-prefix CHECK-MSC-17
 
-// CHECK-MSC-17-NOT: "-fmsc-version=1700"
-// CHECK-MSC-17: "-fms-compatibility-version=17"
+// CHECK-MSC-17-NOT: "-fmsc-version=1900"
+// CHECK-MSC-17: "-fms-compatibility-version=19"
 
-// RUN: %clang -### -target i686-windows -fms-compatibility -fmsc-version=1600 -E - </dev/null -o /dev/null 2>&1 | FileCheck %s -check-prefix CHECK-MSC-16
+// RUN: %clang -### -target i686-windows -fms-compatibility -fmsc-version=1900 -E - </dev/null -o /dev/null 2>&1 | FileCheck %s -check-prefix CHECK-MSC-16
 
-// CHECK-MSC-16-NOT: "-fmsc-version=1600"
-// CHECK-MSC-16: "-fms-compatibility-version=16.0"
+// CHECK-MSC-16-NOT: "-fmsc-version=1900"
+// CHECK-MSC-16: "-fms-compatibility-version=19.0"
 
-// RUN: %clang -### -target i686-windows -fms-compatibility -fmsc-version=150020706 -E - </dev/null -o /dev/null 2>&1 | FileCheck %s -check-prefix CHECK-MSC-15
+// RUN: %clang -### -target i686-windows -fms-compatibility -fmsc-version=190020706 -E - </dev/null -o /dev/null 2>&1 | FileCheck %s -check-prefix CHECK-MSC-15
 
-// CHECK-MSC-15-NOT: "-fmsc-version=150020706"
-// CHECK-MSC-15: "-fms-compatibility-version=15.0.20706"
+// CHECK-MSC-15-NOT: "-fmsc-version=190020706"
+// CHECK-MSC-15: "-fms-compatibility-version=19.0.20706"
 
 //
 // Verify default version with -fms-extensions
 //
 
 // RUN: %clang -target i686-windows -fms-extensions -dM -E - </dev/null -o - | FileCheck %s -check-prefix CHECK-MS-EXTENSIONS
 
 // CHECK-MS-EXTENSIONS: _MSC_BUILD 1
 // CHECK-MS-EXTENSIONS: _MSC_FULL_VER {{.+}}
 // CHECK-MS-EXTENSIONS: _MSC_VER {{....}}
+
+/// Versions before 19 are ignored.
+// RUN: %clang --target=i686-windows -fms-compatibility -fmsc-version=18 -dM -E %s -o - 2>&1 | FileCheck %s --check-prefixes=IGNORED-MSC,MSC-18
+// RUN: %clang --target=i686-windows -fms-compatibility -fms-compatibility-version=18 -dM -E %s -o - 2>&1 | FileCheck %s --check-prefixes=IGNORED-MS-COMPATIBILITY,MSC-18
+
+// IGNORED-MSC: warning: unsupported '-fmsc-version=18' is ignored. 19.0 is the minimum supported version [-Woption-ignored]
+// IGNORED-MS-COMPATIBILITY: warning: unsupported '-fms-compatibility-version=18' is ignored. 19.0 is the minimum supported version [-Woption-ignored]
+
+// MSC-18-NOT: _MSC_FULL_VER 180000000
+// MSC-18-NOT: _MSC_VER 1800