[NFC] create static lib for validator. (microsoft#6811)

A static lib dxcvalidator is added.
The validators in dxcompiler and dxrfallbackcompiler links dxcvalidator.

Fixes microsoft#6790

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: python3kgae

tools/clang/tools/CMakeLists.txt

@@ -26,6 +26,7 @@ add_llvm_external_project(clang-tools-extra extra)
 add_subdirectory(dxcompiler)
 add_subdirectory(dxclib)
 add_subdirectory(dxc)
+add_subdirectory(dxcvalidator)
 add_subdirectory(dxa)
 add_subdirectory(dxopt)
 add_subdirectory(dxl)

tools/clang/tools/dxcompiler/CMakeLists.txt

@@ -102,6 +102,7 @@ set(LIBRARIES
   clangTooling
   clangBasic
   libclang
+  dxcvalidator
   )
 
 if(WIN32)
@@ -136,6 +137,7 @@ if (ENABLE_SPIRV_CODEGEN)
   target_link_libraries(dxcompiler PRIVATE clangSPIRV)
 endif (ENABLE_SPIRV_CODEGEN)
 include_directories(AFTER ${LLVM_INCLUDE_DIR}/dxc/Tracing ${DIASDK_INCLUDE_DIRS} ${HLSL_VERSION_LOCATION})
+include_directories(${LLVM_SOURCE_DIR}/tools/clang/tools/dxcvalidator)
 
 set_target_properties(dxcompiler
   PROPERTIES

tools/clang/tools/dxcompiler/dxcvalidator.cpp

@@ -9,26 +9,13 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "llvm/Bitcode/ReaderWriter.h"
-#include "llvm/IR/DiagnosticPrinter.h"
-#include "llvm/IR/LLVMContext.h"
+#include "dxcvalidator.h"
 
-#include "dxc/DxilContainer/DxilContainer.h"
-#include "dxc/HLSL/DxilValidation.h"
 #include "dxc/Support/WinIncludes.h"
 
-#include "dxc/DxilRootSignature/DxilRootSignature.h"
-#include "dxc/Support/FileIOHelper.h"
 #include "dxc/Support/Global.h"
-#include "dxc/Support/dxcapi.impl.h"
 #include "dxc/Support/microcom.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/MSFileSystem.h"
-#include "llvm/Support/MemoryBuffer.h"
-
-#ifdef _WIN32
-#include "dxcetw.h"
-#endif
+#include "dxc/dxcapi.h"
 
 #ifdef SUPPORT_QUERY_GIT_COMMIT_INFO
 #include "clang/Basic/Version.h"
@@ -37,22 +24,6 @@
 using namespace llvm;
 using namespace hlsl;
 
-// Utility class for setting and restoring the diagnostic context so we may
-// capture errors/warnings
-struct DiagRestore {
-  LLVMContext &Ctx;
-  void *OrigDiagContext;
-  LLVMContext::DiagnosticHandlerTy OrigHandler;
-
-  DiagRestore(llvm::LLVMContext &Ctx, void *DiagContext) : Ctx(Ctx) {
-    OrigHandler = Ctx.getDiagnosticHandler();
-    OrigDiagContext = Ctx.getDiagnosticContext();
-    Ctx.setDiagnosticHandler(PrintDiagnosticContext::PrintDiagnosticHandler,
-                             DiagContext);
-  }
-  ~DiagRestore() { Ctx.setDiagnosticHandler(OrigHandler, OrigDiagContext); }
-};
-
 class DxcValidator : public IDxcValidator2,
 #ifdef SUPPORT_QUERY_GIT_COMMIT_INFO
                      public IDxcVersionInfo2
@@ -63,16 +34,6 @@ class DxcValidator : public IDxcValidator2,
 private:
   DXC_MICROCOM_TM_REF_FIELDS()
 
-  HRESULT RunValidation(
-      IDxcBlob *pShader,          // Shader to validate.
-      UINT32 Flags,               // Validation flags.
-      llvm::Module *pModule,      // Module to validate, if available.
-      llvm::Module *pDebugModule, // Debug module to validate, if available
-      AbstractMemoryStream *pDiagStream);
-
-  HRESULT RunRootSignatureValidation(IDxcBlob *pShader, // Shader to validate.
-                                     AbstractMemoryStream *pDiagStream);
-
 public:
   DXC_MICROCOM_TM_ADDREF_RELEASE_IMPL()
   DXC_MICROCOM_TM_CTOR(DxcValidator)
@@ -129,17 +90,7 @@ HRESULT STDMETHODCALLTYPE DxcValidator::Validate(
     IDxcOperationResult *
         *ppResult // Validation output status, buffer, and errors
 ) {
-  DxcThreadMalloc TM(m_pMalloc);
-  if (ppResult == nullptr)
-    return E_INVALIDARG;
-  *ppResult = nullptr;
-  if (pShader == nullptr || Flags & ~DxcValidatorFlags_ValidMask)
-    return E_INVALIDARG;
-  if ((Flags & DxcValidatorFlags_ModuleOnly) &&
-      (Flags &
-       (DxcValidatorFlags_InPlaceEdit | DxcValidatorFlags_RootSignatureOnly)))
-    return E_INVALIDARG;
-  return ValidateWithOptModules(pShader, Flags, nullptr, nullptr, ppResult);
+  return hlsl::validate(pShader, Flags, ppResult);
 }
 
 HRESULT STDMETHODCALLTYPE DxcValidator::ValidateWithDebug(
@@ -150,42 +101,7 @@ HRESULT STDMETHODCALLTYPE DxcValidator::ValidateWithDebug(
     IDxcOperationResult *
         *ppResult // Validation output status, buffer, and errors
 ) {
-  if (ppResult == nullptr)
-    return E_INVALIDARG;
-  *ppResult = nullptr;
-  if (pShader == nullptr || Flags & ~DxcValidatorFlags_ValidMask)
-    return E_INVALIDARG;
-  if ((Flags & DxcValidatorFlags_ModuleOnly) &&
-      (Flags &
-       (DxcValidatorFlags_InPlaceEdit | DxcValidatorFlags_RootSignatureOnly)))
-    return E_INVALIDARG;
-  if (pOptDebugBitcode &&
-      (pOptDebugBitcode->Ptr == nullptr || pOptDebugBitcode->Size == 0 ||
-       pOptDebugBitcode->Size >= UINT32_MAX))
-    return E_INVALIDARG;
-
-  HRESULT hr = S_OK;
-  DxcThreadMalloc TM(m_pMalloc);
-  try {
-    LLVMContext Ctx;
-    CComPtr<AbstractMemoryStream> pDiagStream;
-    IFT(CreateMemoryStream(m_pMalloc, &pDiagStream));
-    raw_stream_ostream DiagStream(pDiagStream);
-    llvm::DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
-    PrintDiagnosticContext DiagContext(DiagPrinter);
-    Ctx.setDiagnosticHandler(PrintDiagnosticContext::PrintDiagnosticHandler,
-                             &DiagContext, true);
-    std::unique_ptr<llvm::Module> pDebugModule;
-    if (pOptDebugBitcode) {
-      IFT(ValidateLoadModule((const char *)pOptDebugBitcode->Ptr,
-                             (uint32_t)pOptDebugBitcode->Size, pDebugModule,
-                             Ctx, DiagStream, /*bLazyLoad*/ false));
-    }
-    return ValidateWithOptModules(pShader, Flags, nullptr, pDebugModule.get(),
-                                  ppResult);
-  }
-  CATCH_CPP_ASSIGN_HRESULT();
-  return hr;
+  return hlsl::validateWithDebug(pShader, Flags, pOptDebugBitcode, ppResult);
 }
 
 HRESULT DxcValidator::ValidateWithOptModules(
@@ -196,51 +112,13 @@ HRESULT DxcValidator::ValidateWithOptModules(
     IDxcOperationResult *
         *ppResult // Validation output status, buffer, and errors
 ) {
-  *ppResult = nullptr;
-  HRESULT hr = S_OK;
-  HRESULT validationStatus = S_OK;
-  DxcEtw_DxcValidation_Start();
-  DxcThreadMalloc TM(m_pMalloc);
-  try {
-    CComPtr<AbstractMemoryStream> pDiagStream;
-    IFT(CreateMemoryStream(m_pMalloc, &pDiagStream));
-
-    // Run validation may throw, but that indicates an inability to validate,
-    // not that the validation failed (eg out of memory).
-    if (Flags & DxcValidatorFlags_RootSignatureOnly) {
-      validationStatus = RunRootSignatureValidation(pShader, pDiagStream);
-    } else {
-      validationStatus =
-          RunValidation(pShader, Flags, pModule, pDebugModule, pDiagStream);
-    }
-    if (FAILED(validationStatus)) {
-      std::string msg("Validation failed.\n");
-      ULONG cbWritten;
-      pDiagStream->Write(msg.c_str(), msg.size(), &cbWritten);
-    }
-    // Assemble the result object.
-    CComPtr<IDxcBlob> pDiagBlob;
-    hr = pDiagStream.QueryInterface(&pDiagBlob);
-    DXASSERT_NOMSG(SUCCEEDED(hr));
-    IFT(DxcResult::Create(
-        validationStatus, DXC_OUT_NONE,
-        {DxcOutputObject::ErrorOutput(
-            CP_UTF8, // TODO Support DefaultTextCodePage
-            (LPCSTR)pDiagBlob->GetBufferPointer(), pDiagBlob->GetBufferSize())},
-        ppResult));
-  }
-  CATCH_CPP_ASSIGN_HRESULT();
-
-  DxcEtw_DxcValidation_Stop(SUCCEEDED(hr) ? validationStatus : hr);
-  return hr;
+  return hlsl::validateWithOptModules(pShader, Flags, pModule, pDebugModule,
+                                      ppResult);
 }
 
 HRESULT STDMETHODCALLTYPE DxcValidator::GetVersion(UINT32 *pMajor,
                                                    UINT32 *pMinor) {
-  if (pMajor == nullptr || pMinor == nullptr)
-    return E_INVALIDARG;
-  GetValidationVersion(pMajor, pMinor);
-  return S_OK;
+  return hlsl::getValidationVersion(pMajor, pMinor);
 }
 
 #ifdef SUPPORT_QUERY_GIT_COMMIT_INFO
@@ -273,106 +151,6 @@ HRESULT STDMETHODCALLTYPE DxcValidator::GetFlags(UINT32 *pFlags) {
   return S_OK;
 }
 
-HRESULT DxcValidator::RunValidation(
-    IDxcBlob *pShader,
-    UINT32 Flags,               // Validation flags.
-    llvm::Module *pModule,      // Module to validate, if available.
-    llvm::Module *pDebugModule, // Debug module to validate, if available
-    AbstractMemoryStream *pDiagStream) {
-
-  // Run validation may throw, but that indicates an inability to validate,
-  // not that the validation failed (eg out of memory). That is indicated
-  // by a failing HRESULT, and possibly error messages in the diagnostics
-  // stream.
-
-  raw_stream_ostream DiagStream(pDiagStream);
-
-  if (Flags & DxcValidatorFlags_ModuleOnly) {
-    IFRBOOL(!IsDxilContainerLike(pShader->GetBufferPointer(),
-                                 pShader->GetBufferSize()),
-            E_INVALIDARG);
-  } else {
-    IFRBOOL(IsDxilContainerLike(pShader->GetBufferPointer(),
-                                pShader->GetBufferSize()),
-            DXC_E_CONTAINER_INVALID);
-  }
-
-  if (!pModule) {
-    DXASSERT_NOMSG(pDebugModule == nullptr);
-    if (Flags & DxcValidatorFlags_ModuleOnly) {
-      return ValidateDxilBitcode((const char *)pShader->GetBufferPointer(),
-                                 (uint32_t)pShader->GetBufferSize(),
-                                 DiagStream);
-    } else {
-      return ValidateDxilContainer(pShader->GetBufferPointer(),
-                                   pShader->GetBufferSize(), DiagStream);
-    }
-  }
-
-  llvm::DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
-  PrintDiagnosticContext DiagContext(DiagPrinter);
-  DiagRestore DR(pModule->getContext(), &DiagContext);
-
-  IFR(hlsl::ValidateDxilModule(pModule, pDebugModule));
-  if (!(Flags & DxcValidatorFlags_ModuleOnly)) {
-    IFR(ValidateDxilContainerParts(
-        pModule, pDebugModule,
-        IsDxilContainerLike(pShader->GetBufferPointer(),
-                            pShader->GetBufferSize()),
-        (uint32_t)pShader->GetBufferSize()));
-  }
-
-  if (DiagContext.HasErrors() || DiagContext.HasWarnings()) {
-    return DXC_E_IR_VERIFICATION_FAILED;
-  }
-
-  return S_OK;
-}
-
-HRESULT
-DxcValidator::RunRootSignatureValidation(IDxcBlob *pShader,
-                                         AbstractMemoryStream *pDiagStream) {
-
-  const DxilContainerHeader *pDxilContainer = IsDxilContainerLike(
-      pShader->GetBufferPointer(), pShader->GetBufferSize());
-  if (!pDxilContainer) {
-    return DXC_E_IR_VERIFICATION_FAILED;
-  }
-
-  const DxilProgramHeader *pProgramHeader =
-      GetDxilProgramHeader(pDxilContainer, DFCC_DXIL);
-  const DxilPartHeader *pPSVPart =
-      GetDxilPartByType(pDxilContainer, DFCC_PipelineStateValidation);
-  const DxilPartHeader *pRSPart =
-      GetDxilPartByType(pDxilContainer, DFCC_RootSignature);
-  IFRBOOL(pRSPart, DXC_E_MISSING_PART);
-  if (pProgramHeader) {
-    // Container has shader part, make sure we have PSV.
-    IFRBOOL(pPSVPart, DXC_E_MISSING_PART);
-  }
-  try {
-    RootSignatureHandle RSH;
-    RSH.LoadSerialized((const uint8_t *)GetDxilPartData(pRSPart),
-                       pRSPart->PartSize);
-    RSH.Deserialize();
-    raw_stream_ostream DiagStream(pDiagStream);
-    if (pProgramHeader) {
-      IFRBOOL(VerifyRootSignatureWithShaderPSV(
-                  RSH.GetDesc(),
-                  GetVersionShaderType(pProgramHeader->ProgramVersion),
-                  GetDxilPartData(pPSVPart), pPSVPart->PartSize, DiagStream),
-              DXC_E_INCORRECT_ROOT_SIGNATURE);
-    } else {
-      IFRBOOL(VerifyRootSignature(RSH.GetDesc(), DiagStream, false),
-              DXC_E_INCORRECT_ROOT_SIGNATURE);
-    }
-  } catch (...) {
-    return DXC_E_IR_VERIFICATION_FAILED;
-  }
-
-  return S_OK;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 HRESULT RunInternalValidator(IDxcValidator *pValidator, llvm::Module *pModule,

tools/clang/tools/dxcvalidator/CMakeLists.txt

@@ -0,0 +1,25 @@
+# Copyright (C) Microsoft Corporation. All rights reserved.
+# This file is distributed under the University of Illinois Open Source License.
+# See LICENSE.TXT for details.
+
+set( LLVM_LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+  dxcsupport
+  DXIL
+  DxilContainer
+  HLSL
+  Option     # option library
+  Support    # just for assert and raw streams
+  )
+
+add_clang_library(dxcvalidator
+  dxcvalidator.cpp
+  )
+
+if (MINGW)
+  target_link_options(dxcvalidator PUBLIC -mconsole -municode)
+  target_link_libraries(dxcvalidator PRIVATE version)
+endif()
+
+target_compile_definitions(dxcvalidator
+    PRIVATE VERSION_STRING_SUFFIX=" for ${CMAKE_SYSTEM_NAME}")