[clang-cl] Add support for /kernel

[steplong]

Summary

MSVC defines _KERNEL_MODE when /kernel is passed.
Also, /kernel disables RTTI and C++ exception handling.

https://docs.microsoft.com/en-us/cpp/build/reference/kernel-create-kernel-mode-binary?view=msvc-170

[steplong]

• Test that exceptions aren't enabled with /kernel

[thakis]

https://docs.microsoft.com/en-us/cpp/build/reference/kernel-create-kernel-mode-binary?view=msvc-170 says we should err when /kernel is used with various flags (e.g. most /arch:) flags. Want to add that too?

It also says /kernel is passed on to the linker.

What does cl do if both /kernel and (eg) /EHsc is passed (try both orders)? Same question for /kernel /GR.

clang/lib/Driver/ToolChains/Clang.cpp

7461

hasFlag() is for when there's a positive (/kernel) and a negative (/kernel-) form. Is that the case here? Else, use hasArg instead.

[steplong]

In D126719#3548469, @thakis wrote:

What does cl do if both /kernel and (eg) /EHsc is passed (try both orders)? Same question for /kernel /GR.

From my experiments, cl doesn't complain and happily compiles the code if /kernel /EHsc is passed (both orders), unless the code uses exceptions. Then, it complains error C2980: C++ exception handling is not supported with /kernel (both orders)
For /GR, it complains Command line error D8016 : '/kernel' and '/GR' command-line options are incompatible

[steplong]

• Reject /kernel and /arch combinations for x64 and x86

[steplong]

In D126719#3548469, @thakis wrote:

It also says /kernel is passed on to the linker.

Do you know how the linker distinguishes objects created by /kernel vs non-/kernel? At the moment, we are just using MSVC's linker to link separately instead of being invoked by the compiler

[thakis]

clang/lib/Driver/ToolChains/Clang.cpp

7621

Making this list opt-in instead of opt-out (ie "SupportedArchs") seems a bit more future-proof: We're less likely to forget to update the list when new archs are added.

[steplong]

• Change UnsupportedArches to SupportedArches

[thakis]

Looking pretty good!

clang/lib/Driver/ToolChains/Clang.cpp

7620

Just SupportedArches.push_back("IA32") seems a bit simpler.

(Or use append_range, but there's really no need)

clang/test/Driver/cl-zc.cpp

47

Tests for interaction of /kernel with /GR and /EH would be nice too, as mentioned.

[steplong]

• Change to SupportedArches.insert()
• Add logic that errors if /kernel and /GR
• Add test for /kernel and /EHsc (silently override /EHsc. Only errors when trying to use exceptions in src code) and /kernel and /GR (fails with an error)

[steplong]

• Whoops missed a "/" in the test

[steplong]

• Clang-formatted patch

clang/include/clang/Basic/LangOptions.def

 #endif
 
 // FIXME: A lot of the BENIGN_ options should be COMPATIBLE_ instead.
 LANGOPT(C99               , 1, 0, "C99")
 LANGOPT(C11               , 1, 0, "C11")
 LANGOPT(C17               , 1, 0, "C17")
 LANGOPT(C2x               , 1, 0, "C2x")
 LANGOPT(MSVCCompat        , 1, 0, "Microsoft Visual C++ full compatibility mode")
+LANGOPT(Kernel            , 1, 0, "Kernel mode")
 LANGOPT(MicrosoftExt      , 1, 0, "Microsoft C++ extensions")
 LANGOPT(AsmBlocks         , 1, 0, "Microsoft inline asm blocks")
 LANGOPT(Borland           , 1, 0, "Borland extensions")
 LANGOPT(CPlusPlus         , 1, 0, "C++")
 LANGOPT(CPlusPlus11       , 1, 0, "C++11")
 LANGOPT(CPlusPlus14       , 1, 0, "C++14")
 LANGOPT(CPlusPlus17       , 1, 0, "C++17")
 LANGOPT(CPlusPlus20       , 1, 0, "C++20")

clang/include/clang/Driver/Options.td

defm delayed_template_parsing : BoolFOption<"delayed-template-parsing",
   PosFlag<SetTrue, [CC1Option], "Parse templated function definitions at the end of the translation unit">,
   NegFlag<SetFalse, [NoXarchOption], "Disable delayed template parsing">,
   BothFlags<[CoreOption]>>;
 def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>,
   Values<"single,multiple,virtual">, NormalizedValuesScope<"LangOptions">,
   NormalizedValues<["PPTMK_FullGeneralitySingleInheritance", "PPTMK_FullGeneralityMultipleInheritance",
                     "PPTMK_FullGeneralityVirtualInheritance"]>,
   MarshallingInfoEnum<LangOpts<"MSPointerToMemberRepresentationMethod">, "PPTMK_BestCase">;
+def fms_kernel : Flag<["-"], "fms-kernel">, Group<f_Group>, Flags<[CC1Option, NoDriverOption]>,
+  MarshallingInfoFlag<LangOpts<"Kernel">>;
 // __declspec is enabled by default for the PS4 by the driver, and also
 // enabled for Microsoft Extensions or Borland Extensions, here.
 //
 // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
 // CUDA extension. However, it is required for supporting
 // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
 // been rewritten in terms of something more generic, remove the Opts.CUDA
 // term here.

clang/lib/Basic/Targets/OSTargets.cpp

if (Opts.MicrosoftExt) {
 
     if (Opts.CPlusPlus11) {
       Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
       Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
       Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
     }
   }
 
+  if (Opts.Kernel)
+    Builder.defineMacro("_KERNEL_MODE");
+
   Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
   Builder.defineMacro("__STDC_NO_THREADS__");
 
   // Starting with VS 2022 17.1, MSVC predefines the below macro to inform
   // users of the execution character set defined at compile time.
   // The value given is the Windows Code Page Identifier:
   // https://docs.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
   //

clang/lib/Driver/ToolChains/Clang.cpp

 //===-- Clang.cpp - Clang+LLVM ToolChain Implementations --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Clang.h"
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
   // The default is that /GX is not specified.
   if (EHArgs.empty() &&
       Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
                    /*Default=*/false)) {
     EH.Synch = true;
     EH.NoUnwindC = true;
   }
 
+  if (Args.hasFlag(options::OPT__SLASH_kernel, options::OPT__SLASH_kernel,
+                   false)) {
+    EH.Synch = false;
+    EH.NoUnwindC = false;
+    EH.Asynch = false;
+  }
+
   return EH;
 }
 
 void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
                            ArgStringList &CmdArgs,
                            codegenoptions::DebugInfoKind *DebugInfoKind,
                            bool *EmitCodeView) const {
   unsigned RTOptionID = options::OPT__SLASH_MT;
if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
   CmdArgs.push_back("-fno-dllexport-inlines");
  }
 
  if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_,
                   options::OPT__SLASH_Zc_wchar_t, false)) {
    CmdArgs.push_back("-fno-wchar");
  }
 
+ if (Args.hasFlag(options::OPT__SLASH_kernel, options::OPT__SLASH_kernel,
+                  false)) {
+   CmdArgs.push_back("-fno-rtti");
+ }
+
   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 (Args.hasFlag(options::OPT__SLASH_kernel, options::OPT__SLASH_kernel,
 
   Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
 
   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
     CmdArgs.push_back("msvc");
   }
 
+  if (Args.hasArg(options::OPT__SLASH_kernel))
+    CmdArgs.push_back("-fms-kernel");
+
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
     StringRef GuardArgs = A->getValue();
     // The only valid options are "cf", "cf,nochecks", "cf-", "ehcont" and
     // "ehcont-".
     if (GuardArgs.equals_insensitive("cf")) {
       // Emit CFG instrumentation and the table of address-taken functions.
       CmdArgs.push_back("-cfguard");
     } else if (GuardArgs.equals_insensitive("cf,nochecks")) {

clang/test/Driver/cl-zc.cpp

 // SIZED-DEALLOC-OFF-NOT: "-fsized-deallocation"
 
 // RUN: %clang_cl /c /std:c++17 -### /Zc:alignedNew -- %s 2>&1 | FileCheck -check-prefix=ALIGNED-NEW-ON %s
 // ALIGNED-NEW-ON: "-faligned-allocation"
 
 // RUN: %clang_cl /c /std:c++17 -### /Zc:alignedNew- -- %s 2>&1 | FileCheck -check-prefix=ALIGNED-NEW-OFF %s
 // ALIGNED-NEW-OFF-NOT: "-faligned-allocation"
 
+// RUN: %clang_cl /c -### /kernel -- %s 2>&1 | FileCheck -check-prefix=KERNEL %s
+// KERNEL: "-fno-rtti"
+
 // RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=STRICTSTRINGS-DEFAULT %s
 // STRICTSTRINGS-DEFAULT-NOT: -Werror=c++11-compat-deprecated-writable-strings
 // RUN: %clang_cl /c -### /Zc:strictStrings -- %s 2>&1 | FileCheck -check-prefix=STRICTSTRINGS-ON %s
 // STRICTSTRINGS-ON: -Werror=c++11-compat-deprecated-writable-strings
 // RUN: %clang_cl /c -### /Zc:strictStrings- -- %s 2>&1 | FileCheck -check-prefix=STRICTSTRINGS-OFF %s
 // STRICTSTRINGS-OFF: argument unused during compilation
 
 
 // RUN: %clang_cl /c -### /Zc:foobar -- %s 2>&1 | FileCheck -check-prefix=FOOBAR-ON %s
 // FOOBAR-ON: argument unused during compilation
 // RUN: %clang_cl /c -### /Zc:foobar- -- %s 2>&1 | FileCheck -check-prefix=FOOBAR-ON %s
 // FOOBAR-OFF: argument unused during compilation
 
 // These are ignored if enabled, and warn if disabled.
 
 // RUN: %clang_cl /c -### /Zc:forScope -- %s 2>&1 | FileCheck -check-prefix=FORSCOPE-ON %s
 // FORSCOPE-ON-NOT: argument unused during compilation
 // RUN: %clang_cl /c -### /Zc:forScope- -- %s 2>&1 | FileCheck -check-prefix=FORSCOPE-OFF %s
 // FORSCOPE-OFF: argument unused during compilation
 
 // RUN: %clang_cl /c -### /Zc:wchar_t -- %s 2>&1 | FileCheck -check-prefix=WCHAR_T-ON %s
 // WCHAR_T-ON-NOT: argument unused during compilation
 // RUN: %clang_cl /c -### /Zc:wchar_t- -- %s 2>&1 | FileCheck -check-prefix=WCHAR_T-OFF %s
 // WCHAR_T-OFF: "-fno-wchar"
 
 // RUN: %clang_cl /c -### /Zc:auto -- %s 2>&1 | FileCheck -check-prefix=AUTO-ON %s