failing first draft

Author: bob80905

dxc_releases/1.7.2212.github_release/x64/dxil.dll

@@ -114,13 +114,6 @@ struct RewriterOpts {
   bool DeclGlobalCB = false;          // OPT_rw_decl_global_cb
 };
 
-enum class ValidatorSelection : int {
-  Auto,        // Force internal validator (even if DXIL.dll is present)
-  Internal,    // Force internal validator (even if DXIL.dll is present)
-  External,    // Use DXIL.dll, failing compilation if not available
-  Invalid = -1 // Invalid
-};
-
 /// Use this class to capture all options.
 class DxcOpts {
 public:
@@ -225,8 +218,7 @@ class DxcOpts {
   bool ResMayAlias = false;                  // OPT_res_may_alias
   unsigned long ValVerMajor = UINT_MAX,
                 ValVerMinor = UINT_MAX; // OPT_validator_version
-  ValidatorSelection SelectValidator =
-      ValidatorSelection::Auto;         // OPT_select_validator
+  std::string DxilDLLPath = "";         // OPT_dxil_dll_path
   unsigned ScanLimit = 0;               // OPT_memdep_block_scan_limit
   bool ForceZeroStoreLifetimes = false; // OPT_force_zero_store_lifetimes
   bool EnableLifetimeMarkers = false;   // OPT_enable_lifetime_markers

include/dxc/Support/HLSLOptions.h

@@ -317,6 +317,8 @@ def print_before_all : Flag<["-", "/"], "print-before-all">, Group<hlslcomp_Grou
   HelpText<"Print LLVM IR before each pass.">;
 def print_before : Separate<["-", "/"], "print-before">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
   HelpText<"Print LLVM IR before a specific pass. May be specificied multiple times.">;
+def dxil_dll_path : Separate<["-", "/"], "dxil-dll-path">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
+  HelpText<"Specify an absolute path to a DXIL.dll file to set the metadata version and validate the DXIL output.">;
 def print_after_all : Flag<["-", "/"], "print-after-all">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
   HelpText<"Print LLVM IR after each pass.">;
 def print_after : Separate<["-", "/"], "print-after">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,

include/dxc/Support/HLSLOptions.td

@@ -13,6 +13,7 @@
 #define __DXCAPI_USE_H__
 
 #include "dxc/dxcapi.h"
+#include <string>
 
 namespace dxc {
 
@@ -25,6 +26,7 @@ class DxcDllSupport {
   HMODULE m_dll;
   DxcCreateInstanceProc m_createFn;
   DxcCreateInstance2Proc m_createFn2;
+  std::string DxilDLLPath = "";
 
   HRESULT InitializeInternal(LPCSTR dllName, LPCSTR fnName) {
     if (m_dll != nullptr)
@@ -34,6 +36,12 @@ class DxcDllSupport {
     m_dll = LoadLibraryA(dllName);
     if (m_dll == nullptr)
       return HRESULT_FROM_WIN32(GetLastError());
+    // load dxil.dll too
+    HMODULE dxildllModule =
+        LoadLibraryA(DxilDLLPath == "" ? "dxil.dll" : GetDxilDLLPath());
+    if (dxildllModule == nullptr) {
+      return HRESULT_FROM_WIN32(GetLastError());
+    }
     m_createFn = (DxcCreateInstanceProc)GetProcAddress(m_dll, fnName);
 
     if (m_createFn == nullptr) {
@@ -74,6 +82,10 @@ class DxcDllSupport {
   }
 
 public:
+  LPCSTR GetDxilDLLPath() {return DxilDLLPath.data();}
+  void SetDxilDLLPath(LPCSTR p) {
+    DxilDLLPath = p;
+  }
   DxcDllSupport() : m_dll(nullptr), m_createFn(nullptr), m_createFn2(nullptr) {}
 
   DxcDllSupport(DxcDllSupport &&other) {
@@ -88,7 +100,8 @@ class DxcDllSupport {
   ~DxcDllSupport() { Cleanup(); }
 
   HRESULT Initialize() {
-    return InitializeInternal(kDxCompilerLib, "DxcCreateInstance");
+    // load dxcompiler.dll
+   return InitializeInternal(kDxCompilerLib, "DxcCreateInstance");
   }
 
   HRESULT InitializeForDll(LPCSTR dll, LPCSTR entryPoint) {

include/dxc/Support/dxcapi.use.h

@@ -26,6 +26,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include <optional>
+#include <filesystem>
 
 using namespace llvm::opt;
 using namespace dxc;
@@ -409,6 +410,15 @@ LangStd parseHLSLVersion(llvm::StringRef Ver) {
 }
 namespace options {
 
+bool AbsolutePathExists(const std::filesystem::path &p) {
+  // First check if it’s an absolute path
+  if (!p.is_absolute()) {
+    return false;
+  }
+  // Then check if it exists
+  return std::filesystem::exists(p);
+}
+
 /// Reads all options from the given argument strings, populates opts, and
 /// validates reporting errors and warnings.
 int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
@@ -1033,6 +1043,20 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
     opts.ValVerMinor = (unsigned long)minor64;
   }
 
+  llvm::StringRef dxilDLLPathStr =
+      Args.getLastArgValue(OPT_dxil_dll_path);
+  std::filesystem::path p = dxilDLLPathStr.str();
+
+  // when the dxil_dll_path argument has an empty string,
+  // then the internal validator should be used
+  // otherwise, check that this path exists and is absolute
+  if (dxilDLLPathStr.str() == "" || AbsolutePathExists(p)) {
+    opts.DxilDLLPath = dxilDLLPathStr.str();
+  } else {
+    errors << "Absolute path \"" << dxilDLLPathStr << "\" does not exist.";
+    return 1;
+  }
+
   if (opts.IsLibraryProfile() && Minor == 0xF) {
     if (opts.ValVerMajor != UINT_MAX && opts.ValVerMajor != 0) {
       errors << "Offline library profile cannot be used with non-zero "
@@ -1395,6 +1419,8 @@ int SetupDxcDllSupport(const DxcOpts &opts, dxc::DxcDllSupport &dxcSupport,
       return 1;
     }
   }
+
+  dxcSupport.SetDxilDLLPath(opts.DxilDLLPath.data());
   return 0;
 }
 

lib/DxcSupport/HLSLOptions.cpp

@@ -75,6 +75,7 @@ void IFT_Data(HRESULT hr, LPCWSTR data) {
 
 void EnsureEnabled(DxcDllSupport &dxcSupport) {
   if (!dxcSupport.IsEnabled()) {
+    // first initialize Dxil.dll
     IFT(dxcSupport.Initialize());
   }
 }

lib/DxcSupport/dxcapi.use.cpp

@@ -0,0 +1,6 @@
+// RUN: %dxc -T cs_6_6 -E main -dxil-dll-path D:\DXC\dxc_releases\1.7.2212.github_release\x64\dxil.dll 2>&1 %s | FileCheck %s
+
+[shader("compute")]
+[numthreads(2,2,1)]
+// CHECK: warning: External validator loaded at D:\DXC\dxc_releases\1.7.2212.github_release\x64\dxil.dll
+void main() {}

tools/clang/test/DXC/Inputs/dxil_dll_path.hlsl

@@ -65,7 +65,6 @@ static HRESULT InitMaybeFail() throw() {
   fsSetup = true;
   IFC(hlsl::SetupRegistryPassForHLSL());
   IFC(hlsl::SetupRegistryPassForPIX());
-  IFC(DxilLibInitialize());
   if (hlsl::options::initHlslOptTable()) {
     hr = E_FAIL;
     goto Cleanup;

tools/clang/tools/dxcompiler/DXCompiler.cpp

@@ -850,11 +850,12 @@ class DxcCompiler : public IDxcCompiler3,
           compiler.getCodeGenOpts().HLSLValidatorMajorVer = opts.ValVerMajor;
           compiler.getCodeGenOpts().HLSLValidatorMinorVer = opts.ValVerMinor;
         } else {
-          // Version from dxil.dll, or internal validator if unavailable
+          // Version internal validator, or dxil dll if specified
+          // with dxil_dll_path option
           dxcutil::GetValidatorVersion(
               &compiler.getCodeGenOpts().HLSLValidatorMajorVer,
               &compiler.getCodeGenOpts().HLSLValidatorMinorVer,
-              opts.SelectValidator);
+              opts.DxilDLLPath);
         }
 
         // Root signature-only container validation is only supported on 1.5 and
@@ -934,7 +935,7 @@ class DxcCompiler : public IDxcCompiler3,
             CComPtr<IDxcBlobEncoding> pValErrors;
             // Validation failure communicated through diagnostic error
             dxcutil::ValidateRootSignatureInContainer(
-                pOutputBlob, &compiler.getDiagnostics(), opts.SelectValidator);
+                pOutputBlob, &compiler.getDiagnostics(), opts.DxilDLLPath);
           }
         }
       } else if (opts.VerifyDiagnostics) {
@@ -1055,7 +1056,7 @@ class DxcCompiler : public IDxcCompiler3,
               SerializeFlags, pOutputStream, 0, opts.GetPDBName(),
               &compiler.getDiagnostics(), &ShaderHashContent, pReflectionStream,
               pRootSigStream, pRootSignatureBlob, pPrivateBlob,
-              opts.SelectValidator);
+              opts.DxilDLLPath);
 
           inputs.pVersionInfo = static_cast<IDxcVersionInfo *>(this);
 
@@ -1109,7 +1110,7 @@ class DxcCompiler : public IDxcCompiler3,
                 // Validation failure communicated through diagnostic error
                 dxcutil::ValidateRootSignatureInContainer(
                     pRootSignature, &compiler.getDiagnostics(),
-                    opts.SelectValidator);
+                    opts.DxilDLLPath);
               }
               IFT(pResult->SetOutputObject(DXC_OUT_ROOT_SIGNATURE,
                                            pRootSignature));

tools/clang/tools/dxcompiler/dxcompilerobj.cpp

@@ -51,25 +51,20 @@ namespace {
 
 // return true if the internal validator was used, false otherwise
 bool CreateValidator(CComPtr<IDxcValidator> &pValidator,
-                     hlsl::options::ValidatorSelection SelectValidator =
-                         hlsl::options::ValidatorSelection::Auto) {
-  bool bInternal =
-      SelectValidator == hlsl::options::ValidatorSelection::Internal;
-  bool bExternal =
-      SelectValidator == hlsl::options::ValidatorSelection::External;
-  bool bAuto = SelectValidator == hlsl::options::ValidatorSelection::Auto;
-
-  // default behavior uses internal validator, as well as
-  // explicitly specifying internal
-  if (bInternal || bAuto) {
+                     std::string DxilDLLPath = "") {
+  
+  // default behavior uses internal validator
+  if (DxilDLLPath == "") {
     IFT(CreateDxcValidator(IID_PPV_ARGS(&pValidator)));
     return true;
   }
 
-  if (bExternal) {
-    // if external was explicitly specified, but no
-    // external validator could be found (no DXIL.dll), then error
-    IFTBOOL(DxilLibIsEnabled(), DXC_E_VALIDATOR_MISSING);
+  // otherwise, use the external validator provided by the dxil_dll_path
+  // argument
+  else {
+    // if a valid absolute path was given, but the DXIL.dll
+    // is invalid, then error
+    IFTBOOL(DxilLibIsEnabled(DxilDLLPath), DXC_E_VALIDATOR_MISSING);
     IFT(DxilLibCreateInstance(CLSID_DxcValidator, &pValidator));
 
     return false;
@@ -90,22 +85,22 @@ AssembleInputs::AssembleInputs(
     clang::DiagnosticsEngine *pDiag, hlsl::DxilShaderHash *pShaderHashOut,
     AbstractMemoryStream *pReflectionOut, AbstractMemoryStream *pRootSigOut,
     CComPtr<IDxcBlob> pRootSigBlob, CComPtr<IDxcBlob> pPrivateBlob,
-    hlsl::options::ValidatorSelection SelectValidator)
+    std::string DxilDLLPath)
     : pM(std::move(pM)), pOutputContainerBlob(pOutputContainerBlob),
       pMalloc(pMalloc), SerializeFlags(SerializeFlags),
       ValidationFlags(ValidationFlags), pModuleBitcode(pModuleBitcode),
       DebugName(DebugName), pDiag(pDiag), pShaderHashOut(pShaderHashOut),
       pReflectionOut(pReflectionOut), pRootSigOut(pRootSigOut),
       pRootSigBlob(pRootSigBlob), pPrivateBlob(pPrivateBlob),
-      SelectValidator(SelectValidator) {}
+      DxilDLLPath(DxilDLLPath) {}
 
 void GetValidatorVersion(unsigned *pMajor, unsigned *pMinor,
-                         hlsl::options::ValidatorSelection SelectValidator) {
+                         std::string DxilDLLPath) {
   if (pMajor == nullptr || pMinor == nullptr)
     return;
 
   CComPtr<IDxcValidator> pValidator;
-  CreateValidator(pValidator, SelectValidator);
+  CreateValidator(pValidator, DxilDLLPath);
 
   CComPtr<IDxcVersionInfo> pVersionInfo;
   if (SUCCEEDED(pValidator.QueryInterface(&pVersionInfo))) {
@@ -115,6 +110,7 @@ void GetValidatorVersion(unsigned *pMajor, unsigned *pMinor,
     *pMajor = 1;
     *pMinor = 0;
   }
+  return;
 }
 
 void AssembleToContainer(AssembleInputs &inputs) {
@@ -177,8 +173,14 @@ HRESULT ValidateAndAssembleToContainer(AssembleInputs &inputs) {
   std::unique_ptr<llvm::Module> llvmModuleWithDebugInfo;
 
   CComPtr<IDxcValidator> pValidator;
-  bool bInternalValidator = CreateValidator(pValidator, inputs.SelectValidator);
-  // Warning on internal Validator
+  bool bInternalValidator = CreateValidator(pValidator, inputs.DxilDLLPath);
+  // Warning on external Validator
+  if (!bInternalValidator) {
+    unsigned diagID = inputs.pDiag->getCustomDiagID(
+          clang::DiagnosticsEngine::Level::Warning,
+        "External validator loaded at %0");
+    inputs.pDiag->Report(diagID) << inputs.DxilDLLPath;
+  }
 
   CComPtr<IDxcValidator2> pValidator2;
   if (!bInternalValidator) {
@@ -273,11 +275,11 @@ HRESULT ValidateAndAssembleToContainer(AssembleInputs &inputs) {
 
 HRESULT ValidateRootSignatureInContainer(
     IDxcBlob *pRootSigContainer, clang::DiagnosticsEngine *pDiag,
-    hlsl::options::ValidatorSelection SelectValidator) {
+    std::string DxilDLLPath) {
   HRESULT valHR = S_OK;
   CComPtr<IDxcValidator> pValidator;
   CComPtr<IDxcOperationResult> pValResult;
-  CreateValidator(pValidator);
+  CreateValidator(pValidator, DxilDLLPath);
   IFT(pValidator->Validate(pRootSigContainer,
                            DxcValidatorFlags_RootSignatureOnly |
                                DxcValidatorFlags_InPlaceEdit,