[HLSL] [Dirver] add dxv as a Driver Action Job

[python3kgae]

Summary

New option --dxv-path is added for dxc mode to set the installation path for dxv.
If cannot find dxv, a warning will be report.

dxv will be executed with command line dxv file_name -o file_name.
It will validate and sign the file and overwrite it.

[beanz]

Re-using the VerifyDebug action really doesn't make sense. That's not what the DXIL validator does, and it will be a source of confusion forever.

[beanz]

clang/lib/Driver/Driver.cpp

4215

Shouldn't the validator only run if we are targeting DXIL? Also we should probably add the -Vd flag to opt out.

clang/lib/Driver/ToolChains/HLSL.cpp

165

If this option isn't specified we should probably search for dxv relative to clang and on the PATH.

[python3kgae]

Add BinaryAnalyzeJobClass.
Add -Vd to disable validation.

[python3kgae]

In D141705#4059162, @beanz wrote:

Re-using the VerifyDebug action really doesn't make sense. That's not what the DXIL validator does, and it will be a source of confusion forever.

Added BinaryAnalyzeJobClass.

[jhuber6]

I'm not overly familiar with HLSL or DirectX here. Most of the changes are purely mechanical, but I don't see anywhere we create the tool. Does that come later? Normally you'd test these with -ccc-print-bindings, -ccc-print-bindings, and -###.

clang/lib/Driver/ToolChains/HLSL.cpp

146–147

Can we really just ignore this if we don't find the path? Normally this is a hard error. If this is purely optional I would probably suggest not creating the job in the first place.

170

Copy paste.

clang/test/Misc/warning-flags.c

19 ↗

(On Diff #489935)

This comment looks relevant.

[beanz]

clang/include/clang/Basic/DiagnosticDriverKinds.td

701

Not all dxv binaries can sign… some just validate. Only the “official” releases support signing.

[python3kgae]

Only create dxv job when 'dxv' exist.
Test ccc-print-bindings.
Code cleanup.

[python3kgae]

In D141705#4082935, @jhuber6 wrote:

I'm not overly familiar with HLSL or DirectX here. Most of the changes are purely mechanical, but I don't see anywhere we create the tool. Does that come later? Normally you'd test these with -ccc-print-bindings, -ccc-print-bindings, and -###.

The tool ('dxv') is not included in hlsl compiler release yet. It will come later.
Added test with ccc-print-bindings.

clang/include/clang/Basic/DiagnosticDriverKinds.td

701

Fixed.

clang/lib/Driver/ToolChains/HLSL.cpp

146–147

This is optional.
I'll move the check when create the job.

170

Good catch.
Fixed.

clang/test/Misc/warning-flags.c

19 ↗

(On Diff #489935)

Fixed.

[jhuber6]

clang/lib/Driver/Driver.cpp

4216

Could we move this logic into the HLSL ToolChain like we do with CUDA / ROCm? You should be able to then cast the toolchain to HLSLToolChain and query it here.

4217

4222

Why is the type TY_Nothing? The ConstructJob invocation shows it using -o. So it should have output?

4224

clang/lib/Driver/ToolChains/HLSL.cpp

171

Just to check since I'm not really familiar at all with this toolchain, but does dxv exist as a clang tool? This path exists to search in the /path/to/llvm/install/bin directory. If it's an external binary this shouldn't be necessary.

clang/test/Driver/dxc_dxv_path.hlsl

12

Lines that check clang typically start with "-cc1"

15–16

Can we get a test for -ccc-print-phases as well? Also, I wouldn't bother checking the test file's name and it's good practice to stipulate NEXT on these kinds of tests.

[python3kgae]

add DX_CONTAINER Driver type.
Code cleanup.

[python3kgae]

clang/lib/Driver/Driver.cpp

4216

Cannot find a cast example :(
Created a static method for HLSLToolChain to put the logic.

clang/lib/Driver/ToolChains/HLSL.cpp

171

It will be external binary for a long time.
Removed the getDriver().Dir.

[beanz]

clang/include/clang/Driver/Types.def

110

The normal dx-container extension is dxbc right? not dxc?

[jhuber6]

clang/lib/Driver/Driver.cpp

4229–4230

4233

This should work, shouldn't it?

const auto &TC = static_cast<const toolchains::HLSLToolChain &>(getToolChain());

clang/test/Driver/dxc_dxv_path.hlsl

15–16

nit

20–24

[python3kgae]

clang/lib/Driver/Driver.cpp

4233

I'm not sure getToolChain will return a HLSLToolChain.
Is it OK to use dynamic_cast?

[jhuber6]

clang/lib/Driver/Driver.cpp

4233

Well, how is the compilation normally invoked? The Driver::getToolChain() function clearly returns an HLSLToolChain if the triple is ShaderModel. I'm assuming that's the only way to create this, and its set in the compilation. So it should be the ToolChain of the main compilation. This is in contract to an offloading compilation that can have multiple toolchains floating around I'm guessing.

And no, dynamic_cast doesn't work in LLVM. LLVM RTTI requires implementing a classof function, e.g. https://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html, which the ToolChains don't use.

clang/test/Driver/dxc_dxv_path.hlsl

20–24

Also get rid of the +-.

[python3kgae]

clang/include/clang/Driver/Types.def

110

There's no official extension.
Will go with dxo.

clang/lib/Driver/Driver.cpp

4233

const auto &TC = static_cast<const toolchains::HLSLToolChain *>(
    getToolChain(Args, C.getDefaultToolChain().getTriple()));

will hit " no viable conversion from 'const clang::driver::ToolChain' to 'const toolchains::HLSLToolChain'"

const auto &TC = getToolChain(Args, C.getDefaultToolChain().getTriple());
const auto *HLSLTC = static_cast<const toolchains::HLSLToolChain *>(&TC);

works, is it OK?

[python3kgae]

cast ToolChain to HLSLToolChain.

[jhuber6]

clang/lib/Driver/Driver.cpp

4232–4233

This can create a new ToolChain. We probably don't want that. Maybe someone more familiar with this compilation mode can chime in. But my guess is that when we created the Compilation.

This code will only fire if the above triple matches for the default ToolChain. So we should be safe in just casting it directly.

clang/lib/Driver/ToolChains/HLSL.cpp

258

We don't need to pass in D since this is no longer static. You can use getDriver()

clang/test/Driver/dxc_dxv_path.hlsl

20

nit. remove the +- and add whitespace to make it more readable.

[python3kgae]

switch to getDefaultToolChain.

[python3kgae]

clang/lib/Driver/Driver.cpp

4232–4233

Switched to getDefaultToolChain.

[jhuber6]

Thanks for the changes.

clang/lib/Driver/Driver.cpp

4241

nit. remember to clang-format

clang/lib/Driver/ToolChains/HLSL.cpp

170

I feel like this logic should go with the other random Tool versions we have in ToolChain.cpp. See ToolChain.cpp:440 and there should be examples of similar tools.

clang/lib/Driver/ToolChains/HLSL.h

53

Is needValidation a good name here? It's asking more like hasValidator or supportsValidation.

[python3kgae]

clang/lib/Driver/Driver.cpp

4241

arc did find some clang-format issue.
But missed this one :(

clang/lib/Driver/ToolChains/HLSL.cpp

170

This is following pattern of MachO::getTool for VerifyDebug.
https://github.com/llvm/llvm-project/blob/main/clang/lib/Driver/ToolChains/Darwin.cpp#L1078

I can add getValidator to HLSLToolChain if that helps.

clang/lib/Driver/ToolChains/HLSL.h

53

It is combination of hasValidator and requireValidator.
Maybe create hasValidator and requireValidator then move the warning reporting back to Driver?
Something like

if (TC.requireValidator()) {
    if (TC.hasValidator()) {
        add the action.
    } else {
        report warning.
    }
}

[jhuber6]

clang/lib/Driver/ToolChains/HLSL.cpp

170

Yeah, I guess it's a style thing. Personally I don't mind having everything in one place because you need to handle the ActionClass there anyway. But it's not a huge deal. I'll accept either.

clang/lib/Driver/ToolChains/HLSL.h

53

I think keeping the logic as-is and calling it requiresValidation would be fine.

[python3kgae]

rename to requiresValidation.

[python3kgae]

clang/lib/Driver/ToolChains/HLSL.cpp

170

Thanks. I'll keep it as is then.
The validator is only for HLSL now.
If other ToolChain uses it, I'll move it to ToolChain.

[jhuber6]

LGTM overall. Thanks for the patch. Others feel free to comment.

clang/lib/Driver/Driver.cpp

4214–4226

Extreme nit. whitespace above.

clang/test/Driver/dxc_dxv_path.hlsl

8

Would this be called dxv.exe on Windows?

[python3kgae]

Fix windows test fail.

[python3kgae]

clang/test/Driver/dxc_dxv_path.hlsl

8

Good catch.
Changed to dxv{{(.exe)?}}"

Thanks a lot for the review.

[MaskRay]

clang/include/clang/Basic/DiagnosticDriverKinds.td

701

Make sure there is a space after .. The diagnostics convention does not include the trailing period.

[python3kgae]

add space for warning message.

clang/include/clang/Basic/DiagnosticDriverKinds.td

701

Good catch!
Fixed.

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_target_variant_invalid : Error<
   "unsupported '%0' value '%1'; use 'ios-macabi' instead">;
 
 def err_drv_invalid_directx_shader_module : Error<
   "invalid profile : %0">;
 def err_drv_dxc_missing_target_profile : Error<
   "target profile option (-T) is missing">;
 def err_drv_hlsl_unsupported_target : Error<
   "HLSL code generation is unsupported for target '%0'">;
+def warn_drv_dxc_missing_dxv : Warning<"dxv not found. "
+    "Resulting DXIL will not be validated or signed for use in release environments.">,
+    InGroup<DXILValidation>;
 
 def err_drv_invalid_range_dxil_validator_version : Error<
   "invalid validator version : %0\n"
   "Validator version must be less than or equal to current internal version.">;
 def err_drv_invalid_format_dxil_validator_version : Error<
   "invalid validator version : %0\n"
   "Format of validator version is \"<major>.<minor>\" (ex:\"1.4\").">;
 def err_drv_invalid_empty_dxil_validator_version : Error<

clang/include/clang/Basic/DiagnosticGroups.td

def PedanticMacros : DiagGroup<"pedantic-macros",
                      FinalMacro]>;
 
 def BranchProtection : DiagGroup<"branch-protection">;
 
 // HLSL diagnostic groups
 // Warnings for HLSL Clang extensions
 def HLSLExtension : DiagGroup<"hlsl-extensions">;
 
+// Warnings for DXIL validation
+def DXILValidation : DiagGroup<"dxil-validation">;
+
 // Warnings and notes related to const_var_decl_type attribute checks
 def ReadOnlyPlacementChecks : DiagGroup<"read-only-types">;
 
 // Warnings and fixes to support the "safe buffers" programming model.
 def UnsafeBufferUsage : DiagGroup<"unsafe-buffer-usage">;

clang/include/clang/Driver/Action.h

enum ActionClass {
     DsymutilJobClass,
     VerifyDebugInfoJobClass,
     VerifyPCHJobClass,
     OffloadBundlingJobClass,
     OffloadUnbundlingJobClass,
     OffloadPackagerJobClass,
     LinkerWrapperJobClass,
     StaticLibJobClass,
+    BinaryAnalyzeJobClass,
 
     JobClassFirst = PreprocessJobClass,
-    JobClassLast = StaticLibJobClass
+    JobClassLast = BinaryAnalyzeJobClass
   };
 
   // The offloading kind determines if this action is binded to a particular
   // programming model. Each entry reserves one bit. We also have a special kind
   // to designate the host offloading tool chain.
   enum OffloadKind {
     OFK_None = 0x00,
 

 public:
   StaticLibJobAction(ActionList &Inputs, types::ID Type);
 
   static bool classof(const Action *A) {
     return A->getKind() == StaticLibJobClass;
   }
 };
 
+class BinaryAnalyzeJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  BinaryAnalyzeJobAction(Action *Input, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == BinaryAnalyzeJobClass;
+  }
+};
+
 } // namespace driver
 } // namespace clang
 
 #endif // LLVM_CLANG_DRIVER_ACTION_H

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 dxc_validator_path_EQ : Joined<["--"], "dxv-path=">, Group<dxc_Group>,
+  HelpText<"DXIL validator installation path">;
+def dxc_disable_validation : DXCFlag<"Vd">,
+  HelpText<"Disable validation">;

clang/include/clang/Driver/Types.def

 TYPE("object",                   Object,       INVALID,         "o",      phases::Link)
 TYPE("treelang",                 Treelang,     INVALID,         nullptr,  phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("image",                    Image,        INVALID,         "out",    phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("dSYM",                     dSYM,         INVALID,         "dSYM",   phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("dependencies",             Dependencies, INVALID,         "d",      phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("cuda-fatbin",              CUDA_FATBIN,  INVALID,         "fatbin", phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("hip-fatbin",               HIP_FATBIN,   INVALID,         "hipfb",  phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("api-information",          API_INFO,     INVALID,         "json",   phases::Precompile)
+TYPE("dx-container",             DX_CONTAINER, INVALID,         "dxo",    phases::Compile, phases::Backend)
 TYPE("none",                     Nothing,      INVALID,         nullptr,  phases::Compile, phases::Backend, phases::Assemble, phases::Link)

clang/lib/Driver/Action.cpp

const char *Action::getClassName(ActionClass AC) {
   case OffloadUnbundlingJobClass:
     return "clang-offload-unbundler";
   case OffloadPackagerJobClass:
     return "clang-offload-packager";
   case LinkerWrapperJobClass:
     return "clang-linker-wrapper";
   case StaticLibJobClass:
     return "static-lib-linker";
+  case BinaryAnalyzeJobClass:
+    return "binary-analyzer";
   }
 
   llvm_unreachable("invalid class");
 }
 
 void Action::propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch,
                                         const ToolChain *OToolChain) {
   // Offload action set its own kinds on their dependences.

 LinkerWrapperJobAction::LinkerWrapperJobAction(ActionList &Inputs,
                                                types::ID Type)
     : JobAction(LinkerWrapperJobClass, Inputs, Type) {}
 
 void StaticLibJobAction::anchor() {}
 
 StaticLibJobAction::StaticLibJobAction(ActionList &Inputs, types::ID Type)
     : JobAction(StaticLibJobClass, Inputs, Type) {}
+
+void BinaryAnalyzeJobAction::anchor() {}
+
+BinaryAnalyzeJobAction::BinaryAnalyzeJobAction(Action *Input, types::ID Type)
+    : JobAction(BinaryAnalyzeJobClass, Input, Type) {}

clang/lib/Driver/Driver.cpp

if (Arg *A = Args.getLastArg(options::OPT_print_supported_cpus)) {
     // Use the -mcpu=? flag as the dummy input to cc1.
     Actions.clear();
     Action *InputAc = C.MakeAction<InputAction>(*A, types::TY_C);
     Actions.push_back(
         C.MakeAction<PrecompileJobAction>(InputAc, types::TY_Nothing));
     for (auto &I : Inputs)
       I.second->claim();
   }
 
+  // Call validator for dxil when -Vd not in Args.
+  if (C.getDefaultToolChain().getTriple().isDXIL()) {
+    // Only add action when needValidation.
+    const auto &TC =
+        static_cast<const toolchains::HLSLToolChain &>(C.getDefaultToolChain());
+    if (TC.requiresValidation(Args)) {
+      Action *LastAction = Actions.back();
+      Actions.push_back(C.MakeAction<BinaryAnalyzeJobAction>(
+          LastAction, types::TY_DX_CONTAINER));
+    }
+  }
+
   // Claim ignored clang-cl options.
   Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
 }
 
 /// Returns the canonical name for the offloading architecture when using a HIP
 /// or CUDA architecture.
 static StringRef getCanonicalArchString(Compilation &C,
                                         const llvm::opt::DerivedArgList &Args,
                                         StringRef ArchStr,
                                         const llvm::Triple &Triple,
                                         bool SuppressError = false) {
   // Lookup the CUDA / HIP architecture string. Only report an error if we were
   // expecting the triple to be only NVPTX / AMDGPU.
   CudaArch Arch = StringToCudaArch(getProcessorFromTargetID(Triple, ArchStr));
   if (!SuppressError && Triple.isNVPTX() &&
       (Arch == CudaArch::UNKNOWN || !IsNVIDIAGpuArch(Arch))) {
     C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
         << "CUDA" << ArchStr;
     return StringRef();
   } else if (!SuppressError && Triple.isAMDGPU() &&
              (Arch == CudaArch::UNKNOWN || !IsAMDGpuArch(Arch))) {
     C.getDriver().Diag(clang::diag::err_drv_offload_bad_gpu_arch)
         << "HIP" << ArchStr;
void Driver::BuildJobs(Compilation &C) const {
   // into a single offloading action. We should count all inputs to the action
   // as outputs. Also ignore device-only outputs if we're compiling with
   // -fsyntax-only.
   if (FinalOutput) {
     unsigned NumOutputs = 0;
     unsigned NumIfsOutputs = 0;
     for (const Action *A : C.getActions()) {
       if (A->getType() != types::TY_Nothing &&
+          A->getType() != types::TY_DX_CONTAINER &&
           !(A->getKind() == Action::IfsMergeJobClass ||
             (A->getType() == clang::driver::types::TY_IFS_CPP &&
              A->getKind() == clang::driver::Action::CompileJobClass &&
              0 == NumIfsOutputs++) ||
             (A->getKind() == Action::BindArchClass && A->getInputs().size() &&
              A->getInputs().front()->getKind() == Action::IfsMergeJobClass)))
         ++NumOutputs;
       else if (A->getKind() == Action::OffloadClass &&

clang/lib/Driver/ToolChain.cpp

case Action::StaticLibJobClass:
     return getStaticLibTool();
 
   case Action::InputClass:
   case Action::BindArchClass:
   case Action::OffloadClass:
   case Action::LipoJobClass:
   case Action::DsymutilJobClass:
   case Action::VerifyDebugInfoJobClass:
+  case Action::BinaryAnalyzeJobClass:
     llvm_unreachable("Invalid tool kind.");
 
   case Action::CompileJobClass:
   case Action::PrecompileJobClass:
   case Action::PreprocessJobClass:
   case Action::ExtractAPIJobClass:
   case Action::AnalyzeJobClass:
   case Action::MigrateJobClass:

clang/lib/Driver/ToolChains/HLSL.h

 //===--- HLSL.h - HLSL 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_HLSL_H
 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_HLSL_H
 
+#include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 
 namespace clang {
 namespace driver {
 
+namespace tools {
+
+namespace hlsl {
+class LLVM_LIBRARY_VISIBILITY Validator : public Tool {
+public:
+  Validator(const ToolChain &TC) : Tool("hlsl::Validator", "dxv", TC) {}
+
+  bool hasIntegratedCPP() const override { return false; }
+
+  void ConstructJob(Compilation &C, const JobAction &JA,
+                    const InputInfo &Output, const InputInfoList &Inputs,
+                    const llvm::opt::ArgList &TCArgs,
+                    const char *LinkingOutput) const override;
+};
+} // namespace hlsl
+} // namespace tools
+
 namespace toolchains {
 
 class LLVM_LIBRARY_VISIBILITY HLSLToolChain : public ToolChain {
 public:
   HLSLToolChain(const Driver &D, const llvm::Triple &Triple,
                 const llvm::opt::ArgList &Args);
+  Tool *getTool(Action::ActionClass AC) const override;
+
   bool isPICDefault() const override { return false; }
   bool isPIEDefault(const llvm::opt::ArgList &Args) const override {
     return false;
   }
   bool isPICDefaultForced() const override { return false; }
 
   llvm::opt::DerivedArgList *
   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
                 Action::OffloadKind DeviceOffloadKind) const override;
   static std::optional<std::string> parseTargetProfile(StringRef TargetProfile);
+  bool requiresValidation(llvm::opt::DerivedArgList &Args) const;
+
+private:
+  mutable std::unique_ptr<tools::hlsl::Validator> Validator;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_HLSL_H

clang/lib/Driver/ToolChains/HLSL.cpp

 //===--- HLSL.cpp - HLSL 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 "HLSL.h"
 #include "CommonArgs.h"
+#include "clang/Driver/Compilation.h"
 #include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Job.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
if (Version < MinVer) {
     D.Diag(diag::err_drv_invalid_range_dxil_validator_version) << ValVersionStr;
     return false;
   }
   return true;
 }
 
 } // namespace
 
+void tools::hlsl::Validator::ConstructJob(Compilation &C, const JobAction &JA,
+                                          const InputInfo &Output,
+                                          const InputInfoList &Inputs,
+                                          const ArgList &Args,
+                                          const char *LinkingOutput) const {
+  std::string DxvPath = getToolChain().GetProgramPath("dxv");
+  assert(DxvPath != "dxv" && "cannot find dxv");
+
+  ArgStringList CmdArgs;
+  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
+  const InputInfo &Input = Inputs[0];
+  assert(Input.isFilename() && "Unexpected verify input");
+  // Grabbing the output of the earlier cc1 run.
+  CmdArgs.push_back(Input.getFilename());
+  // Use the same name as output.
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Input.getFilename());
+
+  const char *Exec = Args.MakeArgString(DxvPath);
+  C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
+                                         Exec, CmdArgs, Inputs, Input));
+}
+
 /// DirectX Toolchain
 HLSLToolChain::HLSLToolChain(const Driver &D, const llvm::Triple &Triple,
                              const ArgList &Args)
-    : ToolChain(D, Triple, Args) {}
+    : ToolChain(D, Triple, Args) {
+  if (Args.hasArg(options::OPT_dxc_validator_path_EQ))
+    getProgramPaths().push_back(
+        Args.getLastArgValue(options::OPT_dxc_validator_path_EQ).str());
+}
+
+Tool *clang::driver::toolchains::HLSLToolChain::getTool(
+    Action::ActionClass AC) const {
+  switch (AC) {
+  case Action::BinaryAnalyzeJobClass:
+    if (!Validator)
+      Validator.reset(new tools::hlsl::Validator(*this));
+    return Validator.get();
+  default:
+    return ToolChain::getTool(AC);
+  }
+}
 
 std::optional<std::string>
 clang::driver::toolchains::HLSLToolChain::parseTargetProfile(
     StringRef TargetProfile) {
   return tryParseProfile(TargetProfile);
 }
 
 DerivedArgList *
HLSLToolChain::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
   if (!DAL->hasArg(options::OPT_O_Group)) {
     DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_O), "3");
   }
   // FIXME: add validation for enable_16bit_types should be after HLSL 2018 and
   // shader model 6.2.
   // See: https://github.com/llvm/llvm-project/issues/57876
   return DAL;
 }
+
+bool HLSLToolChain::requiresValidation(DerivedArgList &Args) const {
+  if (Args.getLastArg(options::OPT_dxc_disable_validation))
+    return false;
+
+  std::string DxvPath = GetProgramPath("dxv");
+  if (DxvPath != "dxv")
+    return true;
+
+  getDriver().Diag(diag::warn_drv_dxc_missing_dxv);
+  return false;
+}

clang/test/Driver/dxc_D.hlsl

-// RUN: %clang_dxc -DTEST=2  -### %s 2>&1 | FileCheck %s
+// RUN: %clang_dxc -DTEST=2 -Tlib_6_7 -### %s 2>&1 | FileCheck %s
 // RUN: %clang_dxc -DTEST=2  -Tlib_6_7 %s -fcgl -Fo - | FileCheck %s --check-prefix=ERROR
 
 // Make sure -D send to cc1.
 // CHECK:"-D" "TEST=2"
 
 #ifndef TEST
 #error "TEST not defined"
 #elif TEST != 2
 #error "TEST defined to wrong value"
 #endif
 
 // ERROR-NOT: error:

clang/test/Driver/dxc_I.hlsl

-// RUN: %clang_dxc -I test  -### %s 2>&1 | FileCheck %s
+// RUN: %clang_dxc -I test -Tlib_6_3  -### %s 2>&1 | FileCheck %s
 
 // Make sure -I send to cc1.
 // CHECK:"-I" "test"

clang/test/Driver/dxc_dxv_path.hlsl

+// RUN: %clang_dxc -I test -Tlib_6_3  -### %s 2>&1 | FileCheck %s
+
+// Make sure report warning.
+// CHECK:dxv not found.
+
+// RUN: echo "dxv" > %T/dxv && chmod 754 %T/dxv && %clang_dxc --dxv-path=%T %s -Tlib_6_3 -### 2>&1 | FileCheck %s --check-prefix=DXV_PATH
+// DXV_PATH:dxv{{(.exe)?}}" "-" "-o" "-"
+
+// RUN: %clang_dxc -I test -Vd -Tlib_6_3  -### %s 2>&1 | FileCheck %s --check-prefix=VD
+// VD:"-cc1"{{.*}}"-triple" "dxil-unknown-shadermodel6.3-library"
+// VD-NOT:dxv not found
+
+// RUN: %clang_dxc -Tlib_6_3 -ccc-print-bindings --dxv-path=%T -Fo %t.dxo  %s 2>&1 | FileCheck %s --check-prefix=BINDINGS
+// BINDINGS: "dxil-unknown-shadermodel6.3-library" - "clang", inputs: ["[[INPUT:.+]]"], output: "[[DXC:.+]].dxo"
+// BINDINGS-NEXT: "dxil-unknown-shadermodel6.3-library" - "hlsl::Validator", inputs: ["[[DXC]].dxo"], output: "[[DXC]].dxo"
+
+// RUN: %clang_dxc -Tlib_6_3 -ccc-print-phases --dxv-path=%T -Fo %t.dxc  %s 2>&1 | FileCheck %s --check-prefix=PHASES
+
+// PHASES: 0: input, "[[INPUT:.+]]", hlsl
+// PHASES-NEXT: 1: preprocessor, {0}, c++-cpp-output
+// PHASES-NEXT: 2: compiler, {1}, ir
+// PHASES-NEXT: 3: backend, {2}, assembler
+// PHASES-NEXT: 4: binary-analyzer, {3}, dx-container

clang/unittests/Driver/DXCModeTest.cpp

 using namespace clang::driver;
 
 static void validateTargetProfile(
     StringRef TargetProfile, StringRef ExpectTriple,
     IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> &InMemoryFileSystem,
     DiagnosticsEngine &Diags) {
   Driver TheDriver("/bin/clang", "", Diags, "", InMemoryFileSystem);
   std::unique_ptr<Compilation> C{TheDriver.BuildCompilation(
-      {"clang", "--driver-mode=dxc", TargetProfile.data(), "foo.hlsl"})};
+      {"clang", "--driver-mode=dxc", TargetProfile.data(), "foo.hlsl", "-Vd"})};
   EXPECT_TRUE(C);
   EXPECT_STREQ(TheDriver.getTargetTriple().c_str(), ExpectTriple.data());
   EXPECT_EQ(Diags.getNumErrors(), 0u);
 }
 
 static void validateTargetProfile(
     StringRef TargetProfile, StringRef ExpectError,
     IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> &InMemoryFileSystem,
     DiagnosticsEngine &Diags, SimpleDiagnosticConsumer *DiagConsumer,
     unsigned NumOfErrors) {
   Driver TheDriver("/bin/clang", "", Diags, "", InMemoryFileSystem);
   std::unique_ptr<Compilation> C{TheDriver.BuildCompilation(
-      {"clang", "--driver-mode=dxc", TargetProfile.data(), "foo.hlsl"})};
+      {"clang", "--driver-mode=dxc", TargetProfile.data(), "foo.hlsl", "-Vd"})};
   EXPECT_TRUE(C);
   EXPECT_EQ(Diags.getNumErrors(), NumOfErrors);
   EXPECT_STREQ(DiagConsumer->Errors.back().c_str(), ExpectError.data());
   Diags.Clear();
   DiagConsumer->clear();
 }
 
 TEST(DxcModeTest, TargetProfileValidation) {