[HLSL] [Driver] Add -no-legacy-cbuf-layout to control layout for cbuffer.

[python3kgae]

Summary

Two new options are added.
no-legacy-cbuf-layout for dxc mode to match dxc.
hlsl-no-legacy-cbuffer-layout for cc1 mode and save the information will saved in TargetOptions::HLSLNoLegacyCBufferLayout.

clang/include/clang/Basic/TargetOptions.h

public:
   /// compilation.
   llvm::VersionTuple DarwinTargetVariantSDKVersion;
 
   /// The validator version for dxil.
   std::string DxilValidatorVersion;
 
   /// The entry point name for HLSL shader being compiled as specified by -E.
   std::string HLSLEntry;
+
+  /// Not using legacy cbuffer layout for HLSL cbuffer.
+  unsigned HLSLNoLegacyCBufferLayout : 1;
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/Driver/Options.td

def hlsl_entrypoint : Option<["-"], "hlsl-entry", KIND_SEPARATE>,
                       Group<dxc_Group>,
                       Flags<[CC1Option]>,
                       MarshallingInfoString<TargetOpts<"HLSLEntry">, "\"main\"">,
                       HelpText<"Entry point name for hlsl">;
 def dxc_entrypoint : Option<["--", "/", "-"], "E", KIND_JOINED_OR_SEPARATE>,
                      Group<dxc_Group>,
                      Flags<[DXCOption, NoXarchOption]>,
                      HelpText<"Entry point name">;
+def hlsl_disable_legacy_cbuffer_layout : Option<["-"], "hlsl-no-legacy-cbuffer-layout", KIND_FLAG>,
+                      Group<dxc_Group>,
+                      Flags<[CC1Option]>,
+                      MarshallingInfoFlag<TargetOpts<"HLSLNoLegacyCBufferLayout">>,
+                      HelpText<"Do not use legacy cbuffer layout">;
+def dxc_no_legacy_cbuf_layout : DXCFlag<"no-legacy-cbuf-layout">,
+  HelpText<"Do not use legacy cbuffer layout">;

clang/lib/Driver/ToolChains/Clang.cpp

if ((types::isOpenCL(InputType) ||
       !Args.hasArg(options::OPT_cl_no_stdinc)) {
     CmdArgs.push_back("-finclude-default-header");
     CmdArgs.push_back("-fdeclare-opencl-builtins");
   }
 }
 
 static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs,
                               types::ID InputType) {
-  const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
-                                         options::OPT_D,
-                                         options::OPT_I,
-                                         options::OPT_S,
-                                         options::OPT_O,
-                                         options::OPT_emit_llvm,
-                                         options::OPT_emit_obj,
-                                         options::OPT_disable_llvm_passes,
-                                         options::OPT_fnative_half_type,
-                                         options::OPT_hlsl_entrypoint};
+  const unsigned ForwardedArguments[] = {
+      options::OPT_dxil_validator_version,
+      options::OPT_hlsl_entrypoint,
+      options::OPT_hlsl_disable_legacy_cbuffer_layout};
   if (!types::isHLSL(InputType))
     return;
   for (const auto &Arg : ForwardedArguments)
     if (const auto *A = Args.getLastArg(Arg))
       A->renderAsInput(Args, CmdArgs);
   // Add the default headers if dxc_no_stdinc is not set.
   if (!Args.hasArg(options::OPT_dxc_no_stdinc) &&
       !Args.hasArg(options::OPT_nostdinc))

clang/lib/Driver/ToolChains/HLSL.cpp

if (A->getOption().getID() == options::OPT_dxil_validator_version) {
         continue;
     }
     if (A->getOption().getID() == options::OPT_dxc_entrypoint) {
       DAL->AddSeparateArg(nullptr, Opts.getOption(options::OPT_hlsl_entrypoint),
                           A->getValue());
       A->claim();
       continue;
     }
+    if (A->getOption().getID() == options::OPT_dxc_no_legacy_cbuf_layout) {
+      DAL->AddFlagArg(
+          nullptr,
+          Opts.getOption(options::OPT_hlsl_disable_legacy_cbuffer_layout));
+      A->claim();
+      continue;
+    }
     if (A->getOption().getID() == options::OPT__SLASH_O) {
       StringRef OStr = A->getValue();
       if (OStr == "d") {
         DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_O0));
         A->claim();
         continue;
       } else {
         DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_O), OStr);

clang/lib/Frontend/CompilerInvocation.cpp

static bool FixupInvocation(CompilerInvocation &Invocation,
   if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
     Diags.Report(diag::err_drv_argument_not_allowed_with)
         << "-fgnu89-inline" << GetInputKindName(IK);
 
   if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
     Diags.Report(diag::err_drv_argument_not_allowed_with)
         << "-hlsl-entry" << GetInputKindName(IK);
 
+  if (Args.hasArg(OPT_hlsl_disable_legacy_cbuffer_layout) && !LangOpts.HLSL)
+    Diags.Report(diag::err_drv_argument_not_allowed_with)
+        << "-hlsl-no-legacy-cbuffer-layout" << GetInputKindName(IK);
+
   if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
     Diags.Report(diag::warn_ignored_hip_only_option)
         << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
 
   if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
     Diags.Report(diag::warn_ignored_hip_only_option)
         << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
 

clang/test/Driver/dxc_no_legacy_cbuf_layout.hlsl

+// RUN: %clang_dxc -T lib_6_7  -no-legacy-cbuf-layout -### %s 2>&1 | FileCheck %s
+// RUN: %clang_dxc -T lib_6_7   -### %s 2>&1 | FileCheck %s --check-prefix=LEGACY
+
+// Make sure hlsl-no-legacy-cbuffer-layout is enabled.
+// CHECK: "-hlsl-no-legacy-cbuffer-layout"
+
+// Make sure hlsl-no-legacy-cbuffer-layout is not enabled.
+// LEGACY-NOT: "-hlsl-no-legacy-cbuffer-layout"
+
+

clang/unittests/Driver/DXCModeTest.cpp

TEST(DxcModeTest, DefaultEntry) {
 
   const char *EntryArgs[] = {"clang", "--driver-mode=dxc", "-Ebar", "-Tcs_6_7",
                              "foo.hlsl"};
   CInvok = createInvocation(EntryArgs, std::move(CIOpts));
   EXPECT_TRUE(CInvok);
   // Make sure "-E" will set entry.
   EXPECT_STREQ(CInvok->getTargetOpts().HLSLEntry.c_str(), "bar");
 }
+
+TEST(DxcModeTest, NoLegacyCBufLayout) {
+  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
+      new llvm::vfs::InMemoryFileSystem);
+
+  InMemoryFileSystem->addFile("foo.hlsl", 0,
+                              llvm::MemoryBuffer::getMemBuffer("\n"));
+
+  const char *Args[] = {"clang", "--driver-mode=dxc", "-Tcs_6_7",
+                        "-no-legacy-cbuf-layout", "foo.hlsl"};
+
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+
+  CreateInvocationOptions CIOpts;
+  CIOpts.Diags = Diags;
+  std::unique_ptr<CompilerInvocation> CInvok =
+      createInvocation(Args, std::move(CIOpts));
+  EXPECT_TRUE(CInvok);
+  // Make sure HLSLNoLegacyCBufferLayout is enabled.
+  EXPECT_TRUE(CInvok->getTargetOpts().HLSLNoLegacyCBufferLayout);
+
+  const char *DefaultArgs[] = {"clang", "--driver-mode=dxc", "-Tcs_6_7",
+                               "foo.hlsl"};
+  CInvok = createInvocation(DefaultArgs, std::move(CIOpts));
+  EXPECT_TRUE(CInvok);
+  // Make sure HLSLNoLegacyCBufferLayout is disabled.
+  EXPECT_FALSE(CInvok->getTargetOpts().HLSLNoLegacyCBufferLayout);
+}