Code cleanup to help build with newer version of llvm. (#4080)

* Code cleanup to help build with newer version of llvm.

* Use c++14 to enable std::make_unique for linux build.

* Merge llvm/llvm-project@e9110d7#diff-302b958882f0490f56723d598234f0cc7d3e4d3f3693e6850defdba6b75596af to fix MacOS build error for random_shuffle is marked deprecated.

Author: python3kgae

cmake/modules/HandleLLVMOptions.cmake

@@ -432,17 +432,17 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
     check_cxx_compiler_flag("-std=c++1y" CXX_SUPPORTS_CXX1Y)
     append_if(CXX_SUPPORTS_CXX1Y "-std=c++1y" CMAKE_CXX_FLAGS)
   else()
-    check_cxx_compiler_flag("-std=c++11" CXX_SUPPORTS_CXX11)
-    if (CXX_SUPPORTS_CXX11)
+    check_cxx_compiler_flag("-std=c++14" CXX_SUPPORTS_CXX14)
+    if (CXX_SUPPORTS_CXX14)
       if (CYGWIN OR MINGW)
         # MinGW and Cygwin are a bit stricter and lack things like
         # 'strdup', 'stricmp', etc in c++11 mode.
-        append("-std=gnu++11" CMAKE_CXX_FLAGS)
+        append("-std=gnu++14" CMAKE_CXX_FLAGS)
       else()
-        append("-std=c++11" CMAKE_CXX_FLAGS)
+        append("-std=c++14" CMAKE_CXX_FLAGS)
       endif()
     else()
-      message(FATAL_ERROR "LLVM requires C++11 support but the '-std=c++11' flag isn't supported.")
+      message(FATAL_ERROR "LLVM requires C++11 support but the '-std=c++14' flag isn't supported.")
     endif()
   endif()
   if (LLVM_ENABLE_MODULES)

lib/DXIL/CMakeLists.txt

@@ -13,6 +13,7 @@ add_llvm_library(LLVMDXIL
   DxilInterpolationMode.cpp
   DxilMetadataHelper.cpp
   DxilModule.cpp
+  DxilModuleHelper.cpp
   DxilOperations.cpp
   DxilResource.cpp
   DxilResourceBase.cpp
@@ -27,6 +28,7 @@ add_llvm_library(LLVMDXIL
   DxilSubobject.cpp
   DxilTypeSystem.cpp
   DxilUtil.cpp
+  DxilUtilDbgInfoAndMisc.cpp
   DxilPDB.cpp
 
   ADDITIONAL_HEADER_DIRS

lib/DXIL/DxilMetadataHelper.cpp

@@ -264,7 +264,7 @@ void DxilMDHelper::LoadDxilShaderModel(const ShaderModel *&pSM) {
   IFTBOOL(pShaderTypeMD != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
   unsigned Major = ConstMDToUint32(pShaderModelMD->getOperand(kDxilShaderModelMajorIdx));
   unsigned Minor = ConstMDToUint32(pShaderModelMD->getOperand(kDxilShaderModelMinorIdx));
-  string ShaderModelName = pShaderTypeMD->getString();
+  string ShaderModelName = pShaderTypeMD->getString().str();
   ShaderModelName += "_" + std::to_string(Major) + "_" +
     (Minor == ShaderModel::kOfflineMinor ? "x" : std::to_string(Minor));
   pSM = ShaderModel::GetByName(ShaderModelName.c_str());
@@ -384,7 +384,7 @@ void DxilMDHelper::GetDxilEntryPoint(const MDNode *MDO, Function *&pFunc, string
   IFTBOOL(MDOName.get() != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
   MDString *pMDName = dyn_cast<MDString>(MDOName);
   IFTBOOL(pMDName != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
-  Name = pMDName->getString();
+  Name = pMDName->getString().str();
 
   pSignatures = &pTupleMD->getOperand(kDxilEntryPointSignatures);
   pResources  = &pTupleMD->getOperand(kDxilEntryPointResources );
@@ -2580,20 +2580,14 @@ bool DxilMDHelper::IsKnownMetadataID(LLVMContext &Ctx, unsigned ID)
 
 void DxilMDHelper::GetKnownMetadataIDs(LLVMContext &Ctx, SmallVectorImpl<unsigned> *pIDs)
 {
-  auto AddIdIfExists = [&Ctx, &pIDs](StringRef Name) {
-    unsigned ID = 0;
-    if (Ctx.findMDKindID(hlsl::DxilMDHelper::kDxilPreciseAttributeMDName,
-                         &ID)) {
-      pIDs->push_back(ID);
+  SmallVector<StringRef, 4> Names;
+  Ctx.getMDKindNames(Names);
+  for (auto Name : Names) {
+    if (Name == hlsl::DxilMDHelper::kDxilPreciseAttributeMDName ||
+        Name == hlsl::DxilMDHelper::kDxilNonUniformAttributeMDName) {
+      pIDs->push_back(Ctx.getMDKindID(Name));
     }
-    if (Ctx.findMDKindID(hlsl::DxilMDHelper::kDxilNonUniformAttributeMDName,
-                         &ID)) {
-      pIDs->push_back(ID);
-    }
-  };
-
-  AddIdIfExists(hlsl::DxilMDHelper::kDxilPreciseAttributeMDName);
-  AddIdIfExists(hlsl::DxilMDHelper::kDxilNonUniformAttributeMDName);
+  }
 }
 
 void DxilMDHelper::combineDxilMetadata(llvm::Instruction *K,
@@ -2689,7 +2683,7 @@ float DxilMDHelper::ConstMDToFloat(const MDOperand &MDO) {
 string DxilMDHelper::StringMDToString(const MDOperand &MDO) {
   MDString *pMDString = dyn_cast<MDString>(MDO.get());
   IFTBOOL(pMDString != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
-  return pMDString->getString();
+  return pMDString->getString().str();
 }
 
 StringRef DxilMDHelper::StringMDToStringRef(const MDOperand &MDO) {

lib/DXIL/DxilModule.cpp

@@ -31,10 +31,11 @@
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include <unordered_set>
 
+using std::make_unique;
+
 using namespace llvm;
 using std::string;
 using std::vector;
@@ -85,18 +86,8 @@ const char *kDxIsHelperGlobalName = "dx.ishelper";
 const char *kHostLayoutTypePrefix = "hostlayout.";
 }
 
-// Avoid dependency on DxilModule from llvm::Module using this:
-void DxilModule_RemoveGlobal(llvm::Module* M, llvm::GlobalObject* G) {
-  if (M && G && M->HasDxilModule()) {
-    if (llvm::Function *F = dyn_cast<llvm::Function>(G))
-      M->GetDxilModule().RemoveFunction(F);
-  }
-}
-void DxilModule_ResetModule(llvm::Module* M) {
-  if (M && M->HasDxilModule())
-    delete &M->GetDxilModule();
-  M->SetDxilModule(nullptr);
-}
+void SetDxilHook(Module &M);
+void ClearDxilHook(Module &M);
 
 //------------------------------------------------------------------------------
 //
@@ -109,16 +100,16 @@ DxilModule::DxilModule(Module *pModule)
 , m_pModule(pModule)
 , m_pEntryFunc(nullptr)
 , m_EntryName("")
-, m_pMDHelper(llvm::make_unique<DxilMDHelper>(pModule, llvm::make_unique<DxilExtraPropertyHelper>(pModule)))
+, m_pMDHelper(make_unique<DxilMDHelper>(pModule, make_unique<DxilExtraPropertyHelper>(pModule)))
 , m_pDebugInfoFinder(nullptr)
 , m_pSM(nullptr)
 , m_DxilMajor(DXIL::kDxilMajor)
 , m_DxilMinor(DXIL::kDxilMinor)
 , m_ValMajor(1)
 , m_ValMinor(0)
 , m_ForceZeroStoreLifetimes(false)
-, m_pOP(llvm::make_unique<OP>(pModule->getContext(), pModule))
-, m_pTypeSystem(llvm::make_unique<DxilTypeSystem>(pModule))
+, m_pOP(make_unique<OP>(pModule->getContext(), pModule))
+, m_pTypeSystem(make_unique<DxilTypeSystem>(pModule))
 , m_bDisableOptimizations(false)
 , m_bUseMinPrecision(true) // use min precision by default
 , m_bAllResourcesBound(false)
@@ -129,8 +120,7 @@ DxilModule::DxilModule(Module *pModule)
 {
 
   DXASSERT_NOMSG(m_pModule != nullptr);
-  m_pModule->pfnRemoveGlobal = &DxilModule_RemoveGlobal;
-  m_pModule->pfnResetDxilModule = &DxilModule_ResetModule;
+  SetDxilHook(*m_pModule);
 
 #if defined(_DEBUG) || defined(DBG)
   // Pin LLVM dump methods.
@@ -142,10 +132,7 @@ DxilModule::DxilModule(Module *pModule)
 #endif
 }
 
-DxilModule::~DxilModule() {
-  if (m_pModule->pfnRemoveGlobal == &DxilModule_RemoveGlobal)
-    m_pModule->pfnRemoveGlobal = nullptr;
-}
+DxilModule::~DxilModule() { ClearDxilHook(*m_pModule); }
 
 LLVMContext &DxilModule::GetCtx() const { return m_Ctx; }
 Module *DxilModule::GetModule() const { return m_pModule; }
@@ -167,7 +154,7 @@ void DxilModule::SetShaderModel(const ShaderModel *pSM, bool bUseMinPrecision) {
     DxilFunctionProps props;
     props.shaderKind = m_pSM->GetKind();
     m_DxilEntryPropsMap[nullptr] =
-      llvm::make_unique<DxilEntryProps>(props, m_bUseMinPrecision);
+      make_unique<DxilEntryProps>(props, m_bUseMinPrecision);
   }
   m_SerializedRootSignature.clear();
 }
@@ -1209,7 +1196,7 @@ void DxilModule::ReplaceDxilEntryProps(llvm::Function *F,
 void DxilModule::CloneDxilEntryProps(llvm::Function *F, llvm::Function *NewF) {
   DXASSERT(m_DxilEntryPropsMap.count(F) != 0, "cannot find F in map");
   std::unique_ptr<DxilEntryProps> Props =
-      llvm::make_unique<DxilEntryProps>(*m_DxilEntryPropsMap[F]);
+      make_unique<DxilEntryProps>(*m_DxilEntryPropsMap[F]);
   m_DxilEntryPropsMap[NewF] = std::move(Props);
 }
 
@@ -1497,7 +1484,7 @@ void DxilModule::EmitDxilMetadata() {
       MDTuple *pSig = m_pMDHelper->EmitDxilSignatures(entryProps->sig);
 
       MDTuple *pSubEntry = m_pMDHelper->EmitDxilEntryPointTuple(
-          const_cast<Function *>(F), F->getName(), pSig, nullptr, pProps);
+          const_cast<Function *>(F), F->getName().str(), pSig, nullptr, pProps);
 
       Entries.emplace_back(pSubEntry);
     }
@@ -1589,7 +1576,7 @@ void DxilModule::LoadDxilMetadata() {
       }
 
       std::unique_ptr<DxilEntryProps> pEntryProps =
-          llvm::make_unique<DxilEntryProps>(props, m_bUseMinPrecision);
+          make_unique<DxilEntryProps>(props, m_bUseMinPrecision);
       m_pMDHelper->LoadDxilSignatures(*pSignatures, pEntryProps->sig);
 
       m_DxilEntryPropsMap[pFunc] = std::move(pEntryProps);
@@ -1603,7 +1590,7 @@ void DxilModule::LoadDxilMetadata() {
     }
   } else {
     std::unique_ptr<DxilEntryProps> pEntryProps =
-        llvm::make_unique<DxilEntryProps>(entryFuncProps, m_bUseMinPrecision);
+        make_unique<DxilEntryProps>(entryFuncProps, m_bUseMinPrecision);
     DxilFunctionProps *pFuncProps = &pEntryProps->props;
     m_pMDHelper->LoadDxilSignatures(*pEntrySignatures, pEntryProps->sig);
 
@@ -1722,6 +1709,10 @@ StripResourcesReflection(std::vector<std::unique_ptr<TResource>> &vec) {
   return bChanged;
 }
 
+bool isSequentialType(Type *Ty) {
+  return isa<ArrayType>(Ty) || isa<VectorType>(Ty) || isa<PointerType>(Ty);
+}
+
 // Return true if any members or components of struct <Ty> contain
 // scalars of less than 32 bits or are matrices, in which case translation is required
 typedef llvm::SmallSetVector<const StructType*, 4> SmallStructSetVector;
@@ -1732,9 +1723,8 @@ static bool ResourceTypeRequiresTranslation(const StructType * Ty, SmallStructSe
   containedStructs.insert(Ty);
   for (auto eTy : Ty->elements()) {
     // Skip past all levels of sequential types to test their elements
-    SequentialType *seqTy;
-    while ((seqTy = dyn_cast<SequentialType>(eTy))) {
-      eTy = seqTy->getElementType();
+    while ((isSequentialType(eTy))) {
+      eTy = eTy->getContainedType(0);
     }
     // Recursively call this function again to process internal structs
     if (StructType *structTy = dyn_cast<StructType>(eTy)) {
@@ -1954,39 +1944,12 @@ void DxilModule::StripDebugRelatedCode() {
 }
 DebugInfoFinder &DxilModule::GetOrCreateDebugInfoFinder() {
   if (m_pDebugInfoFinder == nullptr) {
-    m_pDebugInfoFinder = llvm::make_unique<llvm::DebugInfoFinder>();
+    m_pDebugInfoFinder = make_unique<llvm::DebugInfoFinder>();
     m_pDebugInfoFinder->processModule(*m_pModule);
   }
   return *m_pDebugInfoFinder;
 }
 
-hlsl::DxilModule *hlsl::DxilModule::TryGetDxilModule(llvm::Module *pModule) {
-  LLVMContext &Ctx = pModule->getContext();
-  std::string diagStr;
-  raw_string_ostream diagStream(diagStr);
-
-  hlsl::DxilModule *pDxilModule = nullptr;
-  // TODO: add detail error in DxilMDHelper.
-  try {
-    pDxilModule = &pModule->GetOrCreateDxilModule();
-  } catch (const ::hlsl::Exception &hlslException) {
-    diagStream << "load dxil metadata failed -";
-    try {
-      const char *msg = hlslException.what();
-      if (msg == nullptr || *msg == '\0')
-        diagStream << " error code " << hlslException.hr << "\n";
-      else
-        diagStream << msg;
-    } catch (...) {
-      diagStream << " unable to retrieve error message.\n";
-    }
-    Ctx.diagnose(DxilErrorDiagnosticInfo(diagStream.str().c_str()));
-  } catch (...) {
-    Ctx.diagnose(DxilErrorDiagnosticInfo("load dxil metadata failed - unknown error.\n"));
-  }
-  return pDxilModule;
-}
-
 // Check if the instruction has fast math flags configured to indicate
 // the instruction is precise.
 // Precise fast math flags means none of the fast math flags are set.
@@ -2028,18 +1991,3 @@ bool DxilModule::IsPrecise(const Instruction *inst) const {
 }
 
 } // namespace hlsl
-
-namespace llvm {
-hlsl::DxilModule &Module::GetOrCreateDxilModule(bool skipInit) {
-  std::unique_ptr<hlsl::DxilModule> M;
-  if (!HasDxilModule()) {
-    M = llvm::make_unique<hlsl::DxilModule>(this);
-    if (!skipInit) {
-      M->LoadDxilMetadata();
-    }
-    SetDxilModule(M.release());
-  }
-  return GetDxilModule();
-}
-
-}