Create new class to handle external validation, and rename existing dll loading class.

include/dxc/Support/HLSLOptions.h

@@ -36,7 +36,7 @@ class raw_ostream;
 } // namespace llvm
 
 namespace dxc {
-class DxcDllSupport;
+class SpecificDllLoader;
 }
 
 namespace hlsl {
@@ -304,9 +304,10 @@ int ReadDxcOpts(const llvm::opt::OptTable *optionTable, unsigned flagsToInclude,
                 const MainArgs &argStrings, DxcOpts &opts,
                 llvm::raw_ostream &errors);
 
-/// Sets up the specified DxcDllSupport instance as per the given options.
-int SetupDxcDllSupport(const DxcOpts &opts, dxc::DxcDllSupport &dxcSupport,
-                       llvm::raw_ostream &errors);
+/// Sets up a SpecificDllLoader instance as per the given options.
+int SetupSpecificDllLoader(const DxcOpts &opts,
+                           dxc::SpecificDllLoader &dxcSupport,
+                           llvm::raw_ostream &errors);
 
 void CopyArgsToWStrings(const llvm::opt::InputArgList &inArgs,
                         unsigned flagsToInclude,

include/dxc/Support/dxcapi.extval.h

@@ -0,0 +1,29 @@
+#include "dxc/Support/dxcapi.use.h"
+#include <cassert>
+#include <string>
+
+namespace dxc {
+class DxcDllExtValidationLoader : public DllLoader {
+  // DxCompilerSupport manages the
+  // lifetime of dxcompiler.dll, while DxilExtValSupport
+  // manages the lifetime of dxil.dll
+  dxc::SpecificDllLoader DxCompilerSupport;
+  dxc::SpecificDllLoader DxilExtValSupport;
+  std::string DxilDllPath;
+
+public:
+  std::string GetDxilDllPath() { return DxilDllPath; }
+  bool DxilDllFailedToLoad() {
+    return !DxilDllPath.empty() && !DxilExtValSupport.IsEnabled();
+  }
+
+  HRESULT CreateInstanceImpl(REFCLSID clsid, REFIID riid,
+                             IUnknown **pResult) override;
+  HRESULT CreateInstance2Impl(IMalloc *pMalloc, REFCLSID clsid, REFIID riid,
+                              IUnknown **pResult) override;
+
+  HRESULT Initialize();
+
+  bool IsEnabled() const override { return DxCompilerSupport.IsEnabled(); }
+};
+} // namespace dxc

include/dxc/Support/dxcapi.use.h

@@ -19,9 +19,47 @@ namespace dxc {
 extern const char *kDxCompilerLib;
 extern const char *kDxilLib;
 
-// Helper class to dynamically load the dxcompiler or a compatible libraries.
-class DxcDllSupport {
+// Interface for common dll operations
+class DllLoader {
+
 protected:
+  virtual HRESULT CreateInstanceImpl(REFCLSID clsid, REFIID riid,
+                                     IUnknown **pResult) = 0;
+  virtual HRESULT CreateInstance2Impl(IMalloc *pMalloc, REFCLSID clsid,
+                                      REFIID riid, IUnknown **pResult) = 0;
+  virtual ~DllLoader() {}
+
+public:
+  DllLoader() = default;
+  DllLoader(const DllLoader &) = delete;
+  DllLoader(DllLoader &&) = delete;
+
+  template <typename TInterface>
+  HRESULT CreateInstance(REFCLSID clsid, TInterface **pResult) {
+    return CreateInstanceImpl(clsid, __uuidof(TInterface),
+                              (IUnknown **)pResult);
+  }
+  HRESULT CreateInstance(REFCLSID clsid, REFIID riid, IUnknown **pResult) {
+    return CreateInstanceImpl(clsid, riid, (IUnknown **)pResult);
+  }
+
+  template <typename TInterface>
+  HRESULT CreateInstance2(IMalloc *pMalloc, REFCLSID clsid,
+                          TInterface **pResult) {
+    return CreateInstance2Impl(pMalloc, clsid, __uuidof(TInterface),
+                               (IUnknown **)pResult);
+  }
+  HRESULT CreateInstance2(IMalloc *pMalloc, REFCLSID clsid, REFIID riid,
+                          IUnknown **pResult) {
+    return CreateInstance2Impl(pMalloc, clsid, riid, (IUnknown **)pResult);
+  }
+
+  virtual bool IsEnabled() const = 0;
+};
+
+// Helper class to dynamically load the dxcompiler or a compatible libraries.
+class SpecificDllLoader : public DllLoader {
+
   HMODULE m_dll;
   DxcCreateInstanceProc m_createFn;
   DxcCreateInstance2Proc m_createFn2;
@@ -74,33 +112,19 @@ class DxcDllSupport {
   }
 
 public:
-  DxcDllSupport() : m_dll(nullptr), m_createFn(nullptr), m_createFn2(nullptr) {}
-
-  DxcDllSupport(DxcDllSupport &&other) {
-    m_dll = other.m_dll;
-    other.m_dll = nullptr;
-    m_createFn = other.m_createFn;
-    other.m_createFn = nullptr;
-    m_createFn2 = other.m_createFn2;
-    other.m_createFn2 = nullptr;
-  }
-
-  ~DxcDllSupport() { Cleanup(); }
+  SpecificDllLoader()
+      : m_dll(nullptr), m_createFn(nullptr), m_createFn2(nullptr) {}
 
-  HRESULT Initialize() {
-    return InitializeInternal(kDxCompilerLib, "DxcCreateInstance");
-  }
+  ~SpecificDllLoader() override { Cleanup(); }
 
   HRESULT InitializeForDll(LPCSTR dll, LPCSTR entryPoint) {
     return InitializeInternal(dll, entryPoint);
   }
 
-  template <typename TInterface>
-  HRESULT CreateInstance(REFCLSID clsid, TInterface **pResult) {
-    return CreateInstance(clsid, __uuidof(TInterface), (IUnknown **)pResult);
-  }
-
-  HRESULT CreateInstance(REFCLSID clsid, REFIID riid, IUnknown **pResult) {
+  // Also bring visibility into the interface definition of this function
+  // which takes 2 args
+  HRESULT CreateInstanceImpl(REFCLSID clsid, REFIID riid,
+                             IUnknown **pResult) override {
     if (pResult == nullptr)
       return E_POINTER;
     if (m_dll == nullptr)
@@ -109,15 +133,10 @@ class DxcDllSupport {
     return hr;
   }
 
-  template <typename TInterface>
-  HRESULT CreateInstance2(IMalloc *pMalloc, REFCLSID clsid,
-                          TInterface **pResult) {
-    return CreateInstance2(pMalloc, clsid, __uuidof(TInterface),
-                           (IUnknown **)pResult);
-  }
-
-  HRESULT CreateInstance2(IMalloc *pMalloc, REFCLSID clsid, REFIID riid,
-                          IUnknown **pResult) {
+  // Also bring visibility into the interface definition of this function
+  // which takes 3 args
+  HRESULT CreateInstance2Impl(IMalloc *pMalloc, REFCLSID clsid, REFIID riid,
+                              IUnknown **pResult) override {
     if (pResult == nullptr)
       return E_POINTER;
     if (m_dll == nullptr)
@@ -130,7 +149,16 @@ class DxcDllSupport {
 
   bool HasCreateWithMalloc() const { return m_createFn2 != nullptr; }
 
-  bool IsEnabled() const { return m_dll != nullptr; }
+  bool IsEnabled() const override { return m_dll != nullptr; }
+
+  bool GetCreateInstanceProcs(DxcCreateInstanceProc *pCreateFn,
+                              DxcCreateInstance2Proc *pCreateFn2) const {
+    if (pCreateFn == nullptr || pCreateFn2 == nullptr || m_createFn == nullptr)
+      return false;
+    *pCreateFn = m_createFn;
+    *pCreateFn2 = m_createFn2;
+    return true;
+  }
 
   void Cleanup() {
     if (m_dll != nullptr) {
@@ -152,6 +180,13 @@ class DxcDllSupport {
   }
 };
 
+class DxCompilerDllLoader : public SpecificDllLoader {
+public:
+  HRESULT Initialize() {
+    return InitializeForDll(kDxCompilerLib, "DxcCreateInstance");
+  }
+};
+
 inline DxcDefine GetDefine(LPCWSTR name, LPCWSTR value) {
   DxcDefine result;
   result.Name = name;
@@ -162,8 +197,8 @@ inline DxcDefine GetDefine(LPCWSTR name, LPCWSTR value) {
 // Checks an HRESULT and formats an error message with the appended data.
 void IFT_Data(HRESULT hr, LPCWSTR data);
 
-void EnsureEnabled(DxcDllSupport &dxcSupport);
-void ReadFileIntoBlob(DxcDllSupport &dxcSupport, LPCWSTR pFileName,
+void EnsureEnabled(SpecificDllLoader &dxcSupport);
+void ReadFileIntoBlob(DllLoader &dxcSupport, LPCWSTR pFileName,
                       IDxcBlobEncoding **ppBlobEncoding);
 void WriteBlobToConsole(IDxcBlob *pBlob, DWORD streamType = STD_OUTPUT_HANDLE);
 void WriteBlobToFile(IDxcBlob *pBlob, LPCWSTR pFileName, UINT32 textCodePage);

include/dxc/Test/CompilationResult.h

@@ -101,11 +101,9 @@ class TrivialDxcUnsavedFile : public IDxcUnsavedFile {
   }
 };
 
-class HlslIntellisenseSupport : public dxc::DxcDllSupport {
+class HlslIntellisenseSupport : public dxc::DxCompilerDllLoader {
 public:
   HlslIntellisenseSupport() {}
-  HlslIntellisenseSupport(HlslIntellisenseSupport &&other)
-      : dxc::DxcDllSupport(std::move(other)) {}
 
   HRESULT CreateIntellisense(IDxcIntelliSense **pResult) {
     return CreateInstance(CLSID_DxcIntelliSense, pResult);

include/dxc/Test/DxcTestUtils.h

@@ -109,11 +109,11 @@ class FileRunCommandPart {
   FileRunCommandPart(const FileRunCommandPart &) = default;
   FileRunCommandPart(FileRunCommandPart &&) = default;
 
-  FileRunCommandResult Run(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult Run(dxc::DllLoader &DllSupport,
                            const FileRunCommandResult *Prior,
                            PluginToolsPaths *pPluginToolsPaths = nullptr,
                            LPCWSTR dumpName = nullptr);
-  FileRunCommandResult RunHashTests(dxc::DxcDllSupport &DllSupport);
+  FileRunCommandResult RunHashTests(dxc::DllLoader &DllSupport);
 
   FileRunCommandResult ReadOptsForDxc(hlsl::options::MainArgs &argStrings,
                                       hlsl::options::DxcOpts &Opts,
@@ -127,30 +127,30 @@ class FileRunCommandPart {
 private:
   FileRunCommandResult RunFileChecker(const FileRunCommandResult *Prior,
                                       LPCWSTR dumpName = nullptr);
-  FileRunCommandResult RunDxc(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunDxc(dxc::DllLoader &DllSupport,
                               const FileRunCommandResult *Prior);
-  FileRunCommandResult RunDxv(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunDxv(dxc::DllLoader &DllSupport,
                               const FileRunCommandResult *Prior);
-  FileRunCommandResult RunOpt(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunOpt(dxc::DllLoader &DllSupport,
                               const FileRunCommandResult *Prior);
-  FileRunCommandResult RunListParts(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunListParts(dxc::DllLoader &DllSupport,
                                     const FileRunCommandResult *Prior);
-  FileRunCommandResult RunD3DReflect(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunD3DReflect(dxc::DllLoader &DllSupport,
                                      const FileRunCommandResult *Prior);
-  FileRunCommandResult RunDxr(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunDxr(dxc::DllLoader &DllSupport,
                               const FileRunCommandResult *Prior);
-  FileRunCommandResult RunLink(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunLink(dxc::DllLoader &DllSupport,
                                const FileRunCommandResult *Prior);
   FileRunCommandResult RunTee(const FileRunCommandResult *Prior);
   FileRunCommandResult RunXFail(const FileRunCommandResult *Prior);
-  FileRunCommandResult RunDxilVer(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunDxilVer(dxc::DllLoader &DllSupport,
                                   const FileRunCommandResult *Prior);
-  FileRunCommandResult RunDxcHashTest(dxc::DxcDllSupport &DllSupport);
+  FileRunCommandResult RunDxcHashTest(dxc::DllLoader &DllSupport);
   FileRunCommandResult RunFromPath(const std::string &path,
                                    const FileRunCommandResult *Prior);
   FileRunCommandResult RunFileCompareText(const FileRunCommandResult *Prior);
 #ifdef _WIN32
-  FileRunCommandResult RunFxc(dxc::DxcDllSupport &DllSupport,
+  FileRunCommandResult RunFxc(dxc::DllLoader &DllSupport,
                               const FileRunCommandResult *Prior);
 #endif
 
@@ -175,12 +175,12 @@ class FileRunTestResult {
                       PluginToolsPaths *pPluginToolsPaths = nullptr,
                       LPCWSTR dumpName = nullptr);
   static FileRunTestResult
-  RunFromFileCommands(LPCWSTR fileName, dxc::DxcDllSupport &dllSupport,
+  RunFromFileCommands(LPCWSTR fileName, dxc::DxCompilerDllLoader &dllSupport,
                       PluginToolsPaths *pPluginToolsPaths = nullptr,
                       LPCWSTR dumpName = nullptr);
 };
 
-void AssembleToContainer(dxc::DxcDllSupport &dllSupport, IDxcBlob *pModule,
+void AssembleToContainer(dxc::DllLoader &dllSupport, IDxcBlob *pModule,
                          IDxcBlob **pContainer);
 std::string BlobToUtf8(IDxcBlob *pBlob);
 std::wstring BlobToWide(IDxcBlob *pBlob);
@@ -195,36 +195,34 @@ bool CheckMsgs(const LPCSTR pText, size_t TextCount, const LPCSTR *pErrorMsgs,
                size_t errorMsgCount, bool bRegex);
 bool CheckNotMsgs(const LPCSTR pText, size_t TextCount,
                   const LPCSTR *pErrorMsgs, size_t errorMsgCount, bool bRegex);
-void GetDxilPart(dxc::DxcDllSupport &dllSupport, IDxcBlob *pProgram,
+void GetDxilPart(dxc::DllLoader &dllSupport, IDxcBlob *pProgram,
                  IDxcBlob **pDxilPart);
-std::string DisassembleProgram(dxc::DxcDllSupport &dllSupport,
+std::string DisassembleProgram(dxc::DxCompilerDllLoader &dllSupport,
                                IDxcBlob *pProgram);
 void SplitPassList(LPWSTR pPassesBuffer, std::vector<LPCWSTR> &passes);
-void MultiByteStringToBlob(dxc::DxcDllSupport &dllSupport,
-                           const std::string &val, UINT32 codePoint,
-                           IDxcBlob **ppBlob);
-void MultiByteStringToBlob(dxc::DxcDllSupport &dllSupport,
-                           const std::string &val, UINT32 codePoint,
-                           IDxcBlobEncoding **ppBlob);
-void Utf8ToBlob(dxc::DxcDllSupport &dllSupport, const std::string &val,
+void MultiByteStringToBlob(dxc::DllLoader &dllSupport, const std::string &val,
+                           UINT32 codePoint, IDxcBlob **ppBlob);
+void MultiByteStringToBlob(dxc::DllLoader &dllSupport, const std::string &val,
+                           UINT32 codePoint, IDxcBlobEncoding **ppBlob);
+void Utf8ToBlob(dxc::DllLoader &dllSupport, const std::string &val,
                 IDxcBlob **ppBlob);
-void Utf8ToBlob(dxc::DxcDllSupport &dllSupport, const std::string &val,
+void Utf8ToBlob(dxc::DllLoader &dllSupport, const std::string &val,
                 IDxcBlobEncoding **ppBlob);
-void Utf8ToBlob(dxc::DxcDllSupport &dllSupport, const char *pVal,
+void Utf8ToBlob(dxc::DllLoader &dllSupport, const char *pVal,
                 IDxcBlobEncoding **ppBlob);
-void WideToBlob(dxc::DxcDllSupport &dllSupport, const std::wstring &val,
+void WideToBlob(dxc::DllLoader &dllSupport, const std::wstring &val,
                 IDxcBlob **ppBlob);
-void WideToBlob(dxc::DxcDllSupport &dllSupport, const std::wstring &val,
+void WideToBlob(dxc::DllLoader &dllSupport, const std::wstring &val,
                 IDxcBlobEncoding **ppBlob);
-void VerifyCompileOK(dxc::DxcDllSupport &dllSupport, LPCSTR pText,
+void VerifyCompileOK(dxc::DllLoader &dllSupport, LPCSTR pText,
                      LPCWSTR pTargetProfile, LPCWSTR pArgs,
                      IDxcBlob **ppResult);
-void VerifyCompileOK(dxc::DxcDllSupport &dllSupport, LPCSTR pText,
+void VerifyCompileOK(dxc::DllLoader &dllSupport, LPCSTR pText,
                      LPCWSTR pTargetProfile, std::vector<LPCWSTR> &args,
                      IDxcBlob **ppResult);
 
-HRESULT GetVersion(dxc::DxcDllSupport &DllSupport, REFCLSID clsid,
-                   unsigned &Major, unsigned &Minor);
+HRESULT GetVersion(dxc::DllLoader &DllSupport, REFCLSID clsid, unsigned &Major,
+                   unsigned &Minor);
 bool ParseTargetProfile(llvm::StringRef targetProfile,
                         llvm::StringRef &outStage, unsigned &outMajor,
                         unsigned &outMinor);
@@ -240,7 +238,7 @@ class VersionSupportInfo {
 
   VersionSupportInfo();
   // Initialize version info structure.  TODO: add device shader model support
-  void Initialize(dxc::DxcDllSupport &dllSupport);
+  void Initialize(dxc::DllLoader &dllSupport);
   // Return true if IR sensitive test should be skipped, and log comment
   bool SkipIRSensitiveTest();
   // Return true if test requiring DXIL of given version should be skipped, and

lib/DxcSupport/CMakeLists.txt

@@ -10,6 +10,7 @@ add_llvm_library(LLVMDxcSupport
   WinAdapter.cpp
   WinIncludes.cpp
   WinFunctions.cpp
+  dxcapi.extval.cpp
   )
 
 #generate header with platform-specific library name

lib/DxcSupport/HLSLOptions.cpp

@@ -1383,9 +1383,10 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
   return 0;
 }
 
-/// Sets up the specified DxcDllSupport instance as per the given options.
-int SetupDxcDllSupport(const DxcOpts &opts, dxc::DxcDllSupport &dxcSupport,
-                       llvm::raw_ostream &errors) {
+/// Sets up a SpecificDllLoader instance as per the given options.
+int SetupSpecificDllLoader(const DxcOpts &opts,
+                           dxc::SpecificDllLoader &dxcSupport,
+                           llvm::raw_ostream &errors) {
   if (!opts.ExternalLib.empty()) {
     DXASSERT(!opts.ExternalFn.empty(), "else ReadDxcOpts should have failed");
     HRESULT hrLoad = dxcSupport.InitializeForDll(opts.ExternalLib.data(),