///////////////////////////////////////////////////////////////////////////////

//                                                                           //

// dxcompilerobj.cpp                                                         //

// Copyright (C) Microsoft Corporation. All rights reserved.                 //

// This file is distributed under the University of Illinois Open Source     //

// License. See LICENSE.TXT for details.                                     //

//                                                                           //

// Implements the DirectX Compiler.                                          //

//                                                                           //

///////////////////////////////////////////////////////////////////////////////

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/TargetOptions.h"

#include "clang/CodeGen/CodeGenAction.h"

#include "clang/Frontend/ASTUnit.h"

#include "clang/Frontend/CompilerInstance.h"

#include "clang/Frontend/FrontendActions.h"

#include "clang/Frontend/FrontendDiagnostic.h"

#include "clang/Frontend/TextDiagnosticPrinter.h"

#include "clang/Lex/HLSLMacroExpander.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/SemaHLSL.h"

#include "llvm/Bitcode/ReaderWriter.h"

#include "llvm/IR/LLVMContext.h"

#include "llvm/Support/TimeProfiler.h"

#include "llvm/Support/Timer.h"

#include "llvm/Transforms/Utils/Cloning.h"

#include "dxc/DXIL/DxilModule.h"

#include "dxc/DXIL/DxilPDB.h"

#include "dxc/DxcBindingTable/DxcBindingTable.h"

#include "dxc/DxilContainer/DxilContainerAssembler.h"

#include "dxc/DxilRootSignature/DxilRootSignature.h"

#include "dxc/HLSL/HLSLExtensionsCodegenHelper.h"

#include "dxc/Support/Path.h"

#include "dxc/Support/WinIncludes.h"

#include "dxc/Support/dxcfilesystem.h"

#include "dxc/dxcapi.internal.h"

#include "dxcutil.h"

#include "dxc/Support/DxcLangExtensionsHelper.h"

#include "dxc/Support/FileIOHelper.h"

#include "dxc/Support/Global.h"

#include "dxc/Support/HLSLOptions.h"

#include "dxc/Support/Unicode.h"

#include "dxc/Support/dxcapi.impl.h"

#include "dxc/Support/dxcapi.use.h"

#include "dxc/Support/microcom.h"

#ifdef _WIN32

#include "dxcetw.h"

#endif

#include "dxcompileradapter.h"

#include "dxcshadersourceinfo.h"

#include "dxcversion.inc"

#include <algorithm>

#include <cfloat>

// SPIRV change starts

#ifdef ENABLE_SPIRV_CODEGEN

#include "clang/SPIRV/EmitSpirvAction.h"

#include "clang/SPIRV/FeatureManager.h"

#endif

// SPIRV change ends

#ifdef SUPPORT_QUERY_GIT_COMMIT_INFO

#include "clang/Basic/Version.h"

#endif // SUPPORT_QUERY_GIT_COMMIT_INFO

#ifdef ENABLE_METAL_CODEGEN

#include "metal_irconverter.h"

#endif

#define CP_UTF16 1200

using namespace llvm;

using namespace clang;

using namespace hlsl;

using std::string;

static bool ShouldBeCopiedIntoPDB(UINT32 FourCC) {

  switch (FourCC) {

  case hlsl::DFCC_ShaderDebugName:

  case hlsl::DFCC_ShaderHash:

    return true;

  }

  return false;

}

static HRESULT CreateContainerForPDB(IMalloc *pMalloc, IDxcBlob *pOldContainer,

                                     IDxcBlob *pDebugBlob,

                                     IDxcVersionInfo *pVersionInfo,

                                     const hlsl::DxilSourceInfo *pSourceInfo,

                                     AbstractMemoryStream *pReflectionStream,

                                     IDxcBlob **ppNewContainer) {

  // If the pContainer is not a valid container, give up.

  if (!hlsl::IsValidDxilContainer(

          (hlsl::DxilContainerHeader *)pOldContainer->GetBufferPointer(),

          pOldContainer->GetBufferSize()))

    return E_FAIL;

  hlsl::DxilContainerHeader *DxilHeader =

      (hlsl::DxilContainerHeader *)pOldContainer->GetBufferPointer();

  hlsl::DxilProgramHeader *ProgramHeader = nullptr;

  std::unique_ptr<DxilContainerWriter> containerWriter(

      NewDxilContainerWriter(false));

  std::unique_ptr<DxilPartWriter> pDxilVersionWriter(

      NewVersionWriter(pVersionInfo));

  for (unsigned i = 0; i < DxilHeader->PartCount; 
i++28.8k
) {

    hlsl::DxilPartHeader *PartHeader = GetDxilContainerPart(DxilHeader, i);

    if (ShouldBeCopiedIntoPDB(PartHeader->PartFourCC)) {

      UINT32 uSize = PartHeader->PartSize;

      const void *pPartData = PartHeader + 1;

      containerWriter->AddPart(

          PartHeader->PartFourCC, uSize,

          [pPartData, uSize](AbstractMemoryStream *pStream) {

            ULONG uBytesWritten = 0;

            IFR(pStream->Write(pPartData, uSize, &uBytesWritten));

            return S_OK;

          });

    }

    // Could use any of these. We're mostly after the header version and all

    // that.

    if (PartHeader->PartFourCC == hlsl::DFCC_DXIL ||

        
PartHeader->PartFourCC == hlsl::DFCC_ShaderDebugInfoDXIL24.9k
) {

      ProgramHeader = (hlsl::DxilProgramHeader *)(PartHeader + 1);

    }

  }

  if (!ProgramHeader)

    return E_FAIL;

  if (pSourceInfo) {

    const UINT32 uPartSize = pSourceInfo->AlignedSizeInBytes;

    containerWriter->AddPart(hlsl::DFCC_ShaderSourceInfo, uPartSize,

                             [pSourceInfo](IStream *pStream) {

                               ULONG uBytesWritten = 0;

                               pStream->Write(pSourceInfo,

                                              pSourceInfo->AlignedSizeInBytes,

                                              &uBytesWritten);

                               return S_OK;

                             });

  }

  if (pReflectionStream) {

    const hlsl::DxilPartHeader *pReflectionPartHeader =

        (const hlsl::DxilPartHeader *)pReflectionStream->GetPtr();

    containerWriter->AddPart(

        hlsl::DFCC_ShaderStatistics, pReflectionPartHeader->PartSize,

        [pReflectionPartHeader](IStream *pStream) {

          ULONG uBytesWritten = 0;

          pStream->Write(pReflectionPartHeader + 1,

                         pReflectionPartHeader->PartSize, &uBytesWritten);

          return S_OK;

        });

  }

  if (pVersionInfo) {

    containerWriter->AddPart(

        hlsl::DFCC_CompilerVersion, pDxilVersionWriter->size(),

        [&pDxilVersionWriter](AbstractMemoryStream *pStream) {

          pDxilVersionWriter->write(pStream);

          return S_OK;

        });

  }

  if (pDebugBlob) {

    static auto AlignByDword = [](UINT32 uSize, UINT32 *pPaddingBytes) {

      UINT32 uRem = uSize % sizeof(UINT32);

      UINT32 uResult =

          (uSize / sizeof(UINT32) + (uRem ? 
10
 : 0)) * sizeof(UINT32);

      *pPaddingBytes = uRem ? 
(sizeof(UINT32) - uRem)0
 : 0;

      return uResult;

    };

    UINT32 uPaddingSize = 0;

    UINT32 uPartSize = AlignByDword(sizeof(hlsl::DxilProgramHeader) +

                                        pDebugBlob->GetBufferSize(),

                                    &uPaddingSize);

    containerWriter->AddPart(

        hlsl::DFCC_ShaderDebugInfoDXIL, uPartSize,

        [uPartSize, ProgramHeader, pDebugBlob, uPaddingSize](IStream *pStream) {

          hlsl::DxilProgramHeader Header = *ProgramHeader;

          Header.BitcodeHeader.BitcodeSize = pDebugBlob->GetBufferSize();

          Header.BitcodeHeader.BitcodeOffset = sizeof(hlsl::DxilBitcodeHeader);

          Header.SizeInUint32 = uPartSize / sizeof(UINT32);

          ULONG uBytesWritten = 0;

          IFR(pStream->Write(&Header, sizeof(Header), &uBytesWritten));

          IFR(pStream->Write(pDebugBlob->GetBufferPointer(),

                             pDebugBlob->GetBufferSize(), &uBytesWritten));

          if (uPaddingSize) {

            UINT32 uPadding = 0;

            assert(uPaddingSize <= sizeof(uPadding) &&

                   "Padding size calculation is wrong.");

            IFR(pStream->Write(&uPadding, uPaddingSize, &uBytesWritten));

          }

          return S_OK;

        });

  }

  CComPtr<hlsl::AbstractMemoryStream> pStrippedContainerStream;

  IFR(hlsl::CreateMemoryStream(pMalloc, &pStrippedContainerStream));

  containerWriter->write(pStrippedContainerStream);

  IFR(pStrippedContainerStream.QueryInterface(ppNewContainer));

  return S_OK;

}

#ifdef _WIN32

#pragma fenv_access(on)

struct DefaultFPEnvScope {

  // _controlfp_s is non-standard and <cfenv>.feholdexceptions doesn't work on

  // windows...?

  unsigned int previousValue;

  DefaultFPEnvScope() {

    // _controlfp_s returns the value of the control word as it is after

    // the call, not before the call.  This is the proper way to get the

    // previous value.

    errno_t error = _controlfp_s(&previousValue, 0, 0);

    IFT(error == 0 ? S_OK : E_FAIL);

    // No exceptions, preserve denormals & round to nearest.

    unsigned int newValue;

    error = _controlfp_s(&newValue, _MCW_EM | _DN_SAVE | _RC_NEAR,

                         _MCW_EM | _MCW_DN | _MCW_RC);

    IFT(error == 0 ? S_OK : E_FAIL);

  }

  ~DefaultFPEnvScope() {

    _clearfp();

    unsigned int newValue;

    errno_t error =

        _controlfp_s(&newValue, previousValue, _MCW_EM | _MCW_DN | _MCW_RC);

    // During cleanup we can't throw as we might already be handling another

    // one.

    DXASSERT_LOCALVAR(error, error == 0,

                      "Failed to restore floating-point environment.");

  }

};

#else // _WIN32

struct DefaultFPEnvScope {

  DefaultFPEnvScope() {} // Dummy ctor to avoid unused local warning

};

#endif // _WIN32

class HLSLExtensionsCodegenHelperImpl : public HLSLExtensionsCodegenHelper {

private:

  CompilerInstance &m_CI;

  DxcLangExtensionsHelper &m_langExtensionsHelper;

  std::string m_rootSigDefine;

  // The metadata format is a root node that has pointers to metadata

  // nodes for each define. The metatdata node for a define is a pair

  // of (name, value) metadata strings.

  //

  // Example:

  // !hlsl.semdefs = {!0, !1}

  // !0 = !{!"FOO", !"BAR"}

  // !1 = !{!"BOO", !"HOO"}

  void WriteSemanticDefines(llvm::Module *M,

                            const ParsedSemanticDefineList &defines) {

    // Create all metadata nodes for each define. Each node is a (name, value)

    // pair.

    std::vector<MDNode *> mdNodes;

    const std::string enableStr("_ENABLE_");

    const std::string disableStr("_DISABLE_");

    const std::string selectStr("_SELECT_");

    auto &optToggles = m_CI.getCodeGenOpts().HLSLOptimizationToggles.Toggles;

    auto &optSelects = m_CI.getCodeGenOpts().HLSLOptimizationToggles.Selects;

    const llvm::SmallVector<std::string, 2> &semDefPrefixes =

        m_langExtensionsHelper.GetSemanticDefines();

    // Add semantic defines to mdNodes and also to codeGenOpts

    for (const ParsedSemanticDefine &define : defines) {

      MDString *name = MDString::get(M->getContext(), define.Name);

      MDString *value = MDString::get(M->getContext(), define.Value);

      mdNodes.push_back(MDNode::get(M->getContext(), {name, value}));

      // Find index for end of matching semantic define prefix

      size_t prefixPos = 0;

      for (auto prefix : semDefPrefixes) {

        if (IsMacroMatch(define.Name, prefix)) {

          prefixPos = prefix.length() - 1;

          break;

        }

      }

      // Add semantic defines to option flag equivalents

      // Convert define-style '_' into option-style '-' and lowercase everything

      if (!define.Name.compare(prefixPos, enableStr.length(), enableStr)) {

        std::string optName =

            define.Name.substr(prefixPos + enableStr.length());

        std::replace(optName.begin(), optName.end(), '_', '-');

        optToggles[StringRef(optName).lower()] = true;

      } else if (!define.Name.compare(prefixPos, disableStr.length(),

                                      disableStr)) {

        std::string optName =

            define.Name.substr(prefixPos + disableStr.length());

        std::replace(optName.begin(), optName.end(), '_', '-');

        optToggles[StringRef(optName).lower()] = false;

      } else if (!define.Name.compare(prefixPos, selectStr.length(),

                                      selectStr)) {

        std::string optName =

            define.Name.substr(prefixPos + selectStr.length());

        std::replace(optName.begin(), optName.end(), '_', '-');

        optSelects[StringRef(optName).lower()] = define.Value;

      }

    }

    // Add root node with pointers to all define metadata nodes.

    NamedMDNode *Root = M->getOrInsertNamedMetadata(

        m_langExtensionsHelper.GetSemanticDefineMetadataName());

    for (MDNode *node : mdNodes)

      Root->addOperand(node);

  }

  SemanticDefineErrorList

  GetValidatedSemanticDefines(const ParsedSemanticDefineList &defines,

                              ParsedSemanticDefineList &validated,

                              SemanticDefineErrorList &errors) {

    for (const ParsedSemanticDefine &define : defines) {

      DxcLangExtensionsHelper::SemanticDefineValidationResult result =

          m_langExtensionsHelper.ValidateSemanticDefine(define.Name,

                                                        define.Value);

      if (result.HasError())

        errors.emplace_back(SemanticDefineError(

            define.Location, SemanticDefineError::Level::Error, result.Error));

      if (result.HasWarning())

        errors.emplace_back(SemanticDefineError(

            define.Location, SemanticDefineError::Level::Warning,

            result.Warning));

      if (!result.HasError())

        validated.emplace_back(define);

    }

    return errors;

  }

public:

  HLSLExtensionsCodegenHelperImpl(CompilerInstance &CI,

                                  DxcLangExtensionsHelper &langExtensionsHelper,

                                  StringRef rootSigDefine)

      : m_CI(CI), m_langExtensionsHelper(langExtensionsHelper),

        m_rootSigDefine(rootSigDefine) {}

  // Write semantic defines as metadata in the module.

  virtual void WriteSemanticDefines(llvm::Module *M) override {

    // Grab the semantic defines seen by the parser.

    ParsedSemanticDefineList defines =

        CollectSemanticDefinesParsedByCompiler(m_CI, &m_langExtensionsHelper);

    // Nothing to do if we have no defines.

    SemanticDefineErrorList errors;

    if (!defines.size())

      return;

    ParsedSemanticDefineList validated;

    GetValidatedSemanticDefines(defines, validated, errors);

    WriteSemanticDefines(M, validated);

    auto &Diags = m_CI.getDiagnostics();

    for (const auto &error : errors) {

      clang::DiagnosticsEngine::Level level = clang::DiagnosticsEngine::Error;

      if (error.IsWarning())

        level = clang::DiagnosticsEngine::Warning;

      unsigned DiagID = Diags.getCustomDiagID(level, "%0");

      Diags.Report(clang::SourceLocation::getFromRawEncoding(error.Location()),

                   DiagID)

          << error.Message();

    }

  }

  // Update CodeGenOption based on HLSLOptimizationToggles.

  void UpdateCodeGenOptions(clang::CodeGenOptions &CGO) override {

    auto &CodeGenOpts = m_CI.getCodeGenOpts();

    CGO.HLSLEnableLifetimeMarkers &=

        CodeGenOpts.HLSLOptimizationToggles.IsEnabled(

            hlsl::options::TOGGLE_LIFETIME_MARKERS);

  }

  virtual bool IsOptionEnabled(hlsl::options::Toggle toggle) override {

    return m_CI.getCodeGenOpts().HLSLOptimizationToggles.IsEnabled(toggle);

  }

  virtual std::string GetIntrinsicName(UINT opcode) override {

    return m_langExtensionsHelper.GetIntrinsicName(opcode);

  }

  virtual bool GetDxilOpcode(UINT opcode, OP::OpCode &dxilOpcode) override {

    UINT dop = static_cast<UINT>(OP::OpCode::NumOpCodes);

    if (m_langExtensionsHelper.GetDxilOpCode(opcode, dop)) {

      if (dop < static_cast<UINT>(OP::OpCode::NumOpCodes)) {

        dxilOpcode = static_cast<OP::OpCode>(dop);

        return true;

      }

    }

    return false;

  }

  virtual HLSLExtensionsCodegenHelper::CustomRootSignature::Status

  GetCustomRootSignature(CustomRootSignature *out) override {

    // Find macro definition in preprocessor.

    Preprocessor &pp = m_CI.getPreprocessor();

    MacroInfo *macro = MacroExpander::FindMacroInfo(pp, m_rootSigDefine);

    if (!macro)

      return CustomRootSignature::NOT_FOUND;

    // Combine tokens into single string

    MacroExpander expander(pp, MacroExpander::STRIP_QUOTES);

    if (!expander.ExpandMacro(macro, &out->RootSignature))

      return CustomRootSignature::NOT_FOUND;

    // Record source location of root signature macro.

    out->EncodedSourceLocation = macro->getDefinitionLoc().getRawEncoding();

    return CustomRootSignature::FOUND;

  }

};

static void CreateDefineStrings(const DxcDefine *pDefines, UINT defineCount,

                                std::vector<std::string> &defines) {

  // Not very efficient but also not very important.

  for (UINT32 i = 0; i < defineCount; 
i++8.04k
) {

    CW2A utf8Name(pDefines[i].Name);

    CW2A utf8Value(pDefines[i].Value);

    std::string val(utf8Name.m_psz);

    val += "=";

    val += (pDefines[i].Value) ? 
utf8Value.m_psz7.27k
 : 
"1"774
;

    defines.push_back(val);

  }

}

static HRESULT ErrorWithString(const std::string &error, REFIID riid,

                               void **ppResult) {

  CComPtr<IDxcResult> pResult;

  IFT(DxcResult::Create(

      E_FAIL, DXC_OUT_NONE,

      {DxcOutputObject::ErrorOutput(CP_UTF8, error.data(), error.size())},

      &pResult));

  IFT(pResult->QueryInterface(riid, ppResult));

  return S_OK;

}

class DxcCompiler : public IDxcCompiler3,

                    public IDxcLangExtensions3,

                    public IDxcContainerEvent,

                    public IDxcVersionInfo3,

#ifdef SUPPORT_QUERY_GIT_COMMIT_INFO

                    public IDxcVersionInfo2

#else

                    public IDxcVersionInfo

#endif // SUPPORT_QUERY_GIT_COMMIT_INFO

{

private:

  DXC_MICROCOM_TM_REF_FIELDS()

  DxcLangExtensionsHelper m_langExtensionsHelper;

  CComPtr<IDxcContainerEventsHandler> m_pDxcContainerEventsHandler;

  DxcCompilerAdapter m_DxcCompilerAdapter;

public:

  DxcCompiler(IMalloc *pMalloc)

      : m_dwRef(0), m_pMalloc(pMalloc), m_DxcCompilerAdapter(this, pMalloc) {}

  DXC_MICROCOM_TM_ADDREF_RELEASE_IMPL()

  DXC_MICROCOM_TM_ALLOC(DxcCompiler)

  DXC_LANGEXTENSIONS_HELPER_IMPL(m_langExtensionsHelper)

  HRESULT STDMETHODCALLTYPE RegisterDxilContainerEventHandler(

      IDxcContainerEventsHandler *pHandler, UINT64 *pCookie) override {

    DXASSERT(m_pDxcContainerEventsHandler == nullptr,

             "else events handler is already registered");

    *pCookie = 1; // Only one EventsHandler supported

    m_pDxcContainerEventsHandler = pHandler;

    return S_OK;

  };

  HRESULT STDMETHODCALLTYPE

  UnRegisterDxilContainerEventHandler(UINT64 cookie) override {

    DXASSERT(m_pDxcContainerEventsHandler != nullptr,

             "else unregister should not have been called");

    m_pDxcContainerEventsHandler.Release();

    return S_OK;

  }

  HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid,

                                           void **ppvObject) override {

    HRESULT hr = DoBasicQueryInterface<IDxcCompiler3, IDxcLangExtensions,

                                       IDxcLangExtensions2, IDxcLangExtensions3,

                                       IDxcContainerEvent, IDxcVersionInfo

#ifdef SUPPORT_QUERY_GIT_COMMIT_INFO

                                       ,

                                       IDxcVersionInfo2

#endif // SUPPORT_QUERY_GIT_COMMIT_INFO

                                       ,

                                       IDxcVersionInfo3>(this, iid, ppvObject);

    if (FAILED(hr)) {

      return DoBasicQueryInterface<IDxcCompiler, IDxcCompiler2>(

          &m_DxcCompilerAdapter, iid, ppvObject);

    }

    return hr;

  }

  // Compile a single entry point to the target shader model with debug

  // information.

  HRESULT STDMETHODCALLTYPE Compile(

      const DxcBuffer *pSource,            // Source text to compile

      LPCWSTR *pArguments,                 // Array of pointers to arguments

      UINT32 argCount,                     // Number of arguments

      IDxcIncludeHandler *pIncludeHandler, // user-provided interface to handle

                                           // #include directives (optional)

      REFIID riid, LPVOID *ppResult // IDxcResult: status, buffer, and errors

      ) override {

    llvm::TimeTraceScope TimeScope("Compile", StringRef(""));

    if (pSource == nullptr || ppResult == nullptr ||

        (argCount > 0 && pArguments == nullptr))

      return E_INVALIDARG;

    if (!(IsEqualIID(riid, __uuidof(IDxcResult)) ||

          
IsEqualIID(riid, 0
__uuidof0
(IDxcOperationResult))))

      return E_INVALIDARG;

    *ppResult = nullptr;

    HRESULT hr = S_OK;

    CComPtr<IDxcBlobUtf8> utf8Source;

    CComPtr<AbstractMemoryStream> pOutputStream;

    CComPtr<IDxcOperationResult> pDxcOperationResult;

    bool bCompileStarted = false;

    bool bPreprocessStarted = false;

    DxilShaderHash ShaderHashContent;

    DxcThreadMalloc TM(m_pMalloc);

    try {

      DefaultFPEnvScope fpEnvScope;

      IFT(CreateMemoryStream(m_pMalloc, &pOutputStream));

      // Parse command-line options into DxcOpts

      int argCountInt;

      IFT(UIntToInt(argCount, &argCountInt));

      hlsl::options::MainArgs mainArgs(argCountInt, pArguments, 0);

      hlsl::options::DxcOpts opts;

      std::string warnings;

      raw_string_ostream w(warnings);

      {

        bool finished = false;

        CComPtr<AbstractMemoryStream> pOptionErrorStream;

        IFT(CreateMemoryStream(m_pMalloc, &pOptionErrorStream));

        dxcutil::ReadOptsAndValidate(mainArgs, opts, pOptionErrorStream,

                                     &pDxcOperationResult, finished);

        if (finished) {

          IFT(pDxcOperationResult->QueryInterface(riid, ppResult));

          hr = S_OK;

          goto Cleanup;

        }

        if (pOptionErrorStream->GetPtrSize() > 0) {

          w << StringRef((const char *)pOptionErrorStream->GetPtr(),

                         (size_t)pOptionErrorStream->GetPtrSize());

        }

      }

      bool isPreprocessing = !opts.Preprocess.empty();

      if (isPreprocessing) {

        DxcEtw_DXCompilerPreprocess_Start();

        bPreprocessStarted = true;

      } else {

        DxcEtw_DXCompilerCompile_Start();

        bCompileStarted = true;

      }

      CComPtr<DxcResult> pResult = DxcResult::Alloc(m_pMalloc);

      IFT(pResult->SetEncoding(opts.DefaultTextCodePage));

      DxcOutputObject primaryOutput;

      // Formerly API values.

      const char *pUtf8SourceName =

          opts.InputFile.empty() ? 
"hlsl.hlsl"16
 : 
opts.InputFile.data()25.5k
;

      CA2W pWideSourceName(pUtf8SourceName);

      const char *pUtf8EntryPoint =

          opts.EntryPoint.empty() ? 
"main"1.57k
 : 
opts.EntryPoint.data()23.9k
;

      const char *pUtf8OutputName = isPreprocessing ? 
opts.Preprocess.data()256

                                    : 
opts.OutputObject.empty()25.3k

                                        ? 
""25.1k

                                        : 
opts.OutputObject.data()176
;

      CA2W pWideOutputName(isPreprocessing ? 
opts.Preprocess.data()256

                                           : 
pUtf8OutputName25.3k
);

      LPCWSTR pObjectName = (!isPreprocessing && 
opts.OutputObject.empty()25.3k
)

                                ? 
nullptr25.1k

                                : 
pWideOutputName.m_psz432
;

      IFT(primaryOutput.SetName(pObjectName));

      // Wrap source in blob

      CComPtr<IDxcBlobEncoding> pSourceEncoding;

      IFT(hlsl::DxcCreateBlob(pSource->Ptr, pSource->Size, true, false,

                              pSource->Encoding != 0, pSource->Encoding,

                              nullptr, &pSourceEncoding));

#ifdef ENABLE_SPIRV_CODEGEN

      // We want to embed the original source code in the final SPIR-V if

      // debug information is enabled. But the compiled source requires

      // pre-seeding with #line directives. We invoke Preprocess() here

      // first for such case. Then we invoke the compilation process over the

      // preprocessed source code.

      if (!isPreprocessing && 
opts.GenSPIRV25.3k
 && 
opts.DebugInfo3.23k
) {

        // Convert source code encoding

        CComPtr<IDxcBlobUtf8> pOrigUtf8Source;

        IFC(hlsl::DxcGetBlobAsUtf8(pSourceEncoding, m_pMalloc,

                                   &pOrigUtf8Source));

        opts.SpirvOptions.origSource.assign(

            static_cast<const char *>(pOrigUtf8Source->GetStringPointer()),

            pOrigUtf8Source->GetStringLength());

        CComPtr<IDxcResult> pSrcCodeResult;

        std::vector<LPCWSTR> PreprocessArgs;

        PreprocessArgs.reserve(argCount + 1);

        PreprocessArgs.assign(pArguments, pArguments + argCount);

        PreprocessArgs.push_back(L"-P");

        PreprocessArgs.push_back(L"-Fi");

        PreprocessArgs.push_back(L"preprocessed.hlsl");

        IFT(Compile(pSource, PreprocessArgs.data(), PreprocessArgs.size(),

                    pIncludeHandler, IID_PPV_ARGS(&pSrcCodeResult)));

        HRESULT status;

        IFT(pSrcCodeResult->GetStatus(&status));

        if (SUCCEEDED(status)) {

          pSourceEncoding.Release();

          IFT(pSrcCodeResult->GetOutput(

              DXC_OUT_HLSL, IID_PPV_ARGS(&pSourceEncoding), nullptr));

        }

      }

#endif // ENABLE_SPIRV_CODEGEN

      // Convert source code encoding

      IFC(hlsl::DxcGetBlobAsUtf8(pSourceEncoding, m_pMalloc, &utf8Source,

                                 opts.DefaultTextCodePage));

      CComPtr<IDxcBlob> pOutputBlob;

      dxcutil::DxcArgsFileSystem *msfPtr = dxcutil::CreateDxcArgsFileSystem(

          utf8Source, pWideSourceName.m_psz, pIncludeHandler,

          opts.DefaultTextCodePage);

      std::unique_ptr<::llvm::sys::fs::MSFileSystem> msf(msfPtr);

      ::llvm::sys::fs::AutoPerThreadSystem pts(msf.get());

      IFTLLVM(pts.error_code());

      IFT(pOutputStream.QueryInterface(&pOutputBlob));

      primaryOutput.kind = DXC_OUT_OBJECT;

      if (opts.AstDump || 
opts.OptDump25.3k
 || 
opts.DumpDependencies25.3k
 ||

          
opts.VerifyDiagnostics25.3k
)

        primaryOutput.kind = DXC_OUT_TEXT;

      else if (isPreprocessing)

        primaryOutput.kind = DXC_OUT_HLSL;

      IFT(pResult->SetOutputName(DXC_OUT_REFLECTION,

                                 opts.OutputReflectionFile));

      IFT(pResult->SetOutputName(DXC_OUT_SHADER_HASH,

                                 opts.OutputShaderHashFile));

      IFT(pResult->SetOutputName(DXC_OUT_ERRORS, opts.OutputWarningsFile));

      IFT(pResult->SetOutputName(DXC_OUT_ROOT_SIGNATURE,

                                 opts.OutputRootSigFile));

      if (opts.DisplayIncludeProcess)

        msfPtr->EnableDisplayIncludeProcess();

      IFT(msfPtr->RegisterOutputStream(L"output.bc", pOutputStream));

      IFT(msfPtr->CreateStdStreams(m_pMalloc));

      StringRef Data(utf8Source->GetStringPointer(),

                     utf8Source->GetStringLength());

      // Not very efficient but also not very important.

      std::vector<std::string> defines;

      CreateDefineStrings(opts.Defines.data(), opts.Defines.size(), defines);

      // Setup a compiler instance.

      raw_stream_ostream outStream(pOutputStream.p);

      llvm::LLVMContext

          llvmContext; // LLVMContext should outlive CompilerInstance

      std::unique_ptr<llvm::Module> debugModule;

      CComPtr<AbstractMemoryStream> pReflectionStream;

      CompilerInstance compiler;

      std::unique_ptr<TextDiagnosticPrinter> diagPrinter =

          llvm::make_unique<TextDiagnosticPrinter>(

              w, &compiler.getDiagnosticOpts());

      SetupCompilerForCompile(compiler, &m_langExtensionsHelper,

                              pUtf8SourceName, diagPrinter.get(), defines, opts,

                              pArguments, argCount);

      msfPtr->SetupForCompilerInstance(compiler);

      // The clang entry point (cc1_main) would now create a compiler invocation

      // from arguments, but depending on the Preprocess option, we either

      // compile to LLVM bitcode and then package that into a DXBC blob, or

      // preprocess to HLSL text.

      //

      // With the compiler invocation built from command line arguments, the

      // next step is to call ExecuteCompilerInvocation, which creates a

      // FrontendAction* of EmitBCAction, which is a CodeGenAction, which is an

      // ASTFrontendAction. That sets up a BackendConsumer as the ASTConsumer.

      compiler.getFrontendOpts().OutputFile = "output.bc";

      compiler.WriteDefaultOutputDirectly = true;

      compiler.setOutStream(&outStream);

      unsigned rootSigMajor = 0;

      unsigned rootSigMinor = 0;

      bool produceFullContainer = false;

      bool needsValidation = false;

      bool validateRootSigContainer = false;

      if (isPreprocessing) {

        TimeTraceScope TimeScope("PreprocessAction", StringRef(""));

        // These settings are back-compatible with fxc.

        clang::PreprocessorOutputOptions &PPOutOpts =

            compiler.getPreprocessorOutputOpts();

        PPOutOpts.ShowCPP = 1;         // Print normal preprocessed output.

        PPOutOpts.ShowComments = 0;    // Show comments.

        PPOutOpts.ShowLineMarkers = 1; // Show \#line markers.

        PPOutOpts.UseLineDirectives =

            1; // Use \#line instead of GCC-style \# N.

        PPOutOpts.ShowMacroComments = 0; // Show comments, even in macros.

        PPOutOpts.ShowMacros = 0;        // Print macro definitions.

        PPOutOpts.RewriteIncludes = 0;   // Preprocess include directives only.

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        clang::PrintPreprocessedAction action;

        if (action.BeginSourceFile(compiler, file)) {

          action.Execute();

          action.EndSourceFile();

        }

        outStream.flush();

      } else {

        compiler.getLangOpts().HLSLEntryFunction =

            compiler.getCodeGenOpts().HLSLEntryFunction = pUtf8EntryPoint;

        // Parse and apply

        if (opts.BindingTableDefine.size()) {

          // Just pass the define for now because preprocessor is not available

          // yet.

          struct BindingTableParserImpl

              : public CodeGenOptions::BindingTableParserType {

            CompilerInstance &compiler;

            std::string define;

            BindingTableParserImpl(CompilerInstance &compiler, StringRef define)

                : compiler(compiler), define(define.str()) {}

            bool Parse(llvm::raw_ostream &os,

                       hlsl::DxcBindingTable *outBindingTable) override {

              Preprocessor &pp = compiler.getPreprocessor();

              MacroInfo *macro = MacroExpander::FindMacroInfo(pp, define);

              if (!macro) {

                os << Twine("Binding table define'") + define + "' not found.";

                os.flush();

                return false;

              }

              std::string bindingTableStr;

              // Combine tokens into single string

              MacroExpander expander(pp, MacroExpander::STRIP_QUOTES);

              if (!expander.ExpandMacro(macro, &bindingTableStr)) {

                os << Twine("Binding table define'") + define +

                          "' failed to expand.";

                os.flush();

                return false;

              }

              return hlsl::ParseBindingTable(define, StringRef(bindingTableStr),

                                             os, outBindingTable);

            }

          };

          compiler.getCodeGenOpts().BindingTableParser.reset(

              new BindingTableParserImpl(compiler, opts.BindingTableDefine));

        } else if (opts.ImportBindingTable.size()) {

          hlsl::options::StringRefWide wstrRef(opts.ImportBindingTable);

          CComPtr<IDxcBlob> pBlob;

          std::string error;

          llvm::raw_string_ostream os(error);

          if (!pIncludeHandler) {

            os << Twine("Binding table binding file '") +

                      opts.ImportBindingTable +

                      "' specified, but no include handler was given.";

            os.flush();

            return ErrorWithString(error, riid, ppResult);

          } else if (SUCCEEDED(pIncludeHandler->LoadSource(wstrRef, &pBlob))) {

            bool succ = hlsl::ParseBindingTable(

                opts.ImportBindingTable,

                StringRef((const char *)pBlob->GetBufferPointer(),

                          pBlob->GetBufferSize()),

                os, &compiler.getCodeGenOpts().HLSLBindingTable);

            if (!succ) {

              os.flush();

              return ErrorWithString(error, riid, ppResult);

            }

          } else {

            os << Twine("Could not load binding table file '") +

                      opts.ImportBindingTable + "'.";

            os.flush();

            return ErrorWithString(error, riid, ppResult);

          }

        }

        if (compiler.getCodeGenOpts().HLSLProfile == "rootsig_1_1") {

          rootSigMajor = 1;

          rootSigMinor = 1;

        } else if (compiler.getCodeGenOpts().HLSLProfile == "rootsig_1_0") {

          rootSigMajor = 1;

          rootSigMinor = 0;

        }

        compiler.getLangOpts().IsHLSLLibrary = opts.IsLibraryProfile();

        if (compiler.getLangOpts().IsHLSLLibrary && 
opts.GenMetal3.86k
)

          return ErrorWithString("Shader libraries unsupported in Metal (yet)",

                                 riid, ppResult);

        // Clear entry function if library target

        if (compiler.getLangOpts().IsHLSLLibrary)

          compiler.getLangOpts().HLSLEntryFunction =

              compiler.getCodeGenOpts().HLSLEntryFunction = "";

        produceFullContainer = opts.ProduceFullContainer();

        needsValidation = opts.NeedsValidation();

        if (compiler.getCodeGenOpts().HLSLProfile == "lib_6_x") {

          // Currently do not support stripping reflection from offline linking

          // target.

          opts.KeepReflectionInDxil = true;

        }

        if (opts.ValVerMajor != UINT_MAX) {

          // user-specified validator version override

          compiler.getCodeGenOpts().HLSLValidatorMajorVer = opts.ValVerMajor;

          compiler.getCodeGenOpts().HLSLValidatorMinorVer = opts.ValVerMinor;

        } else {

          dxcutil::GetValidatorVersion(

              &compiler.getCodeGenOpts().HLSLValidatorMajorVer,

              &compiler.getCodeGenOpts().HLSLValidatorMinorVer);

        }

        // Root signature-only container validation is only supported on 1.5 and

        // above.

        validateRootSigContainer =

            DXIL::CompareVersions(

                compiler.getCodeGenOpts().HLSLValidatorMajorVer,

                compiler.getCodeGenOpts().HLSLValidatorMinorVer, 1, 5) >= 0;

      }

      compiler.getTarget().adjust(compiler.getLangOpts());

      if (opts.AstDump) {

        TimeTraceScope TimeScope("DumpAST", StringRef(""));

        clang::ASTDumpAction dumpAction;

        // Consider - ASTDumpFilter, ASTDumpLookups

        compiler.getFrontendOpts().ASTDumpDecls = true;

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        dumpAction.BeginSourceFile(compiler, file);

        dumpAction.Execute();

        dumpAction.EndSourceFile();

        outStream.flush();

      } else if (opts.DumpDependencies) {

        TimeTraceScope TimeScope("DumpDependencies", StringRef(""));

        auto dependencyCollector = std::make_shared<DependencyCollector>();

        compiler.addDependencyCollector(dependencyCollector);

        compiler.createPreprocessor(clang::TranslationUnitKind::TU_Complete);

        clang::PreprocessOnlyAction preprocessAction;

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        preprocessAction.BeginSourceFile(compiler, file);

        preprocessAction.Execute();

        preprocessAction.EndSourceFile();

        outStream << (opts.OutputObject.empty() ? opts.InputFile

                                                : 
opts.OutputObject0
);

        bool firstDependency = true;

        for (auto &dependency : dependencyCollector->getDependencies()) {

          if (firstDependency) {

            outStream << ": " << dependency;

            firstDependency = false;

            continue;

          }

          outStream << " \\\n " << dependency;

        }

        outStream << "\n";

        outStream.flush();

      } else if (opts.OptDump) {

        EmitOptDumpAction action(&llvmContext);

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        action.BeginSourceFile(compiler, file);

        action.Execute();

        action.EndSourceFile();

        outStream.flush();

      } else if (rootSigMajor) {

        HLSLRootSignatureAction action(

            compiler.getCodeGenOpts().HLSLEntryFunction, rootSigMajor,

            rootSigMinor);

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        action.BeginSourceFile(compiler, file);

        action.Execute();

        action.EndSourceFile();

        outStream.flush();

        // Don't do work to put in a container if an error has occurred

        bool compileOK = !compiler.getDiagnostics().hasErrorOccurred();

        if (compileOK) {

          auto rootSigHandle = action.takeRootSigHandle();

          CComPtr<AbstractMemoryStream> pContainerStream;

          IFT(CreateMemoryStream(m_pMalloc, &pContainerStream));

          SerializeDxilContainerForRootSignature(rootSigHandle.get(),

                                                 pContainerStream);

          pOutputBlob.Release();

          IFT(pContainerStream.QueryInterface(&pOutputBlob));

          if (validateRootSigContainer && !opts.DisableValidation) {

            CComPtr<IDxcBlobEncoding> pValErrors;

            // Validation failure communicated through diagnostic error

            dxcutil::ValidateRootSignatureInContainer(

                pOutputBlob, &compiler.getDiagnostics());

          }

        }

      } else if (opts.VerifyDiagnostics) {

        SyntaxOnlyAction action;

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        if (action.BeginSourceFile(compiler, file)) {

          action.Execute();

          action.EndSourceFile();

        }

      }

      // SPIRV change starts

#ifdef ENABLE_SPIRV_CODEGEN

      else if (!isPreprocessing && 
opts.GenSPIRV24.3k
) {

        // Since SpirvOptions is passed to the SPIR-V CodeGen as a whole

        // structure, we need to copy a few non-spirv-specific options into the

        // structure.

        opts.SpirvOptions.enable16BitTypes = opts.Enable16BitTypes;

        opts.SpirvOptions.codeGenHighLevel = opts.CodeGenHighLevel;

        opts.SpirvOptions.defaultRowMajor = opts.DefaultRowMajor;

        opts.SpirvOptions.disableValidation = opts.DisableValidation;

        opts.SpirvOptions.IEEEStrict = opts.IEEEStrict;

        // Save a string representation of command line options and

        // input file name.

        if (opts.DebugInfo) {

          opts.SpirvOptions.inputFile = opts.InputFile;

          for (auto opt : mainArgs.getArrayRef()) {

            if (opts.InputFile.compare(opt) != 0) {

              opts.SpirvOptions.clOptions += " " + std::string(opt);

            }

          }

        }

        compiler.getCodeGenOpts().SpirvOptions = opts.SpirvOptions;

        clang::EmitSpirvAction action;

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        action.BeginSourceFile(compiler, file);

        action.Execute();

        action.EndSourceFile();

        outStream.flush();

      }

#endif

      // SPIRV change ends

      else if (!isPreprocessing) {

        EmitBCAction action(&llvmContext);

        FrontendInputFile file(pUtf8SourceName, IK_HLSL);

        bool compileOK;

        TimeTraceScope TimeScope("Compile Action", StringRef(""));

        if (action.BeginSourceFile(compiler, file)) {

          action.Execute();

          action.EndSourceFile();

          compileOK = !compiler.getDiagnostics().hasErrorOccurred();

        } else {

          compileOK = false;

        }

        outStream.flush();

        SerializeDxilFlags SerializeFlags =

            hlsl::options::ComputeSerializeDxilFlags(opts);

        CComPtr<IDxcBlob> pRootSignatureBlob = nullptr;

        CComPtr<IDxcBlob> pPrivateBlob = nullptr;

        if (!opts.RootSignatureSource.empty()) {

          hlsl::options::StringRefWide wstrRef(opts.RootSignatureSource);

          std::string error;

          llvm::raw_string_ostream os(error);

          if (!pIncludeHandler) {

            os << Twine("Root Signature file '") + opts.RootSignatureSource +

                      "' specified, but no include handler was given.";

            os.flush();

            return ErrorWithString(error, riid, ppResult);

          } else if (SUCCEEDED(pIncludeHandler->LoadSource(

                         wstrRef, &pRootSignatureBlob))) {

          } else {

            os << Twine("Could not load root signature file '") +

                      opts.RootSignatureSource + "'.";

            os.flush();

            return ErrorWithString(error, riid, ppResult);

          }

        }

        if (!opts.PrivateSource.empty()) {

          hlsl::options::StringRefWide wstrRef(opts.PrivateSource);

          std::string error;

          llvm::raw_string_ostream os(error);

          if (!pIncludeHandler) {

            os << Twine("Private file '") + opts.PrivateSource +

                      "' specified, but no include handler was given.";

            os.flush();

            return ErrorWithString(error, riid, ppResult);

          } else if (SUCCEEDED(

                         pIncludeHandler->LoadSource(wstrRef, &pPrivateBlob))) {

          } else {

            os << Twine("Could not load root signature file '") +