Allow loading DXIL shader model without module

Adds a dxilutil function to retrieve shader model from metadata. To
enable this, the metadata helper implementation is split into a few
utility functions which will continue to throw the exceptions as they
did before, but allows passes to call them without fear of crashes as a
result of that. Passes will assume the default shader model where it
can't retrieve it for one reason or another.

Changes scalarizer to try to retrieve the shader module when no module
is found. Changes dyanmicvector to array to use the utility function and
never try to recreate the hlmodule. Instead it will try the dxilmodule
and if that isn't present, it will use the metadata for shader model
only.

Author: Greg Roth

include/dxc/DXIL/DxilMetadataHelper.h

@@ -435,6 +435,7 @@ class DxilMDHelper {
   // Shader model.
   void EmitDxilShaderModel(const ShaderModel *pSM);
   void LoadDxilShaderModel(const ShaderModel *&pSM);
+  static const ShaderModel *LoadDxilShaderModel(const llvm::Module *pModule);
 
   // Intermediate flags
   void EmitDxilIntermediateOptions(uint32_t flags);
@@ -687,6 +688,8 @@ class DxilMDHelper {
   static void
   CopyMetadata(llvm::Instruction &I, llvm::Instruction &SrcInst,
                llvm::ArrayRef<unsigned> WL = llvm::ArrayRef<unsigned>());
+  static bool
+  LoadShaderModelName(const llvm::Module *pModule, std::string &str);
 
 private:
   llvm::LLVMContext &m_Ctx;

include/dxc/DXIL/DxilUtil.h

@@ -221,6 +221,10 @@ bool DeleteDeadAllocas(llvm::Function &F);
 llvm::Value *GEPIdxToOffset(llvm::GetElementPtrInst *GEP,
                             llvm::IRBuilder<> &Builder, hlsl::OP *OP,
                             const llvm::DataLayout &DL);
+
+// Returns shader model appropriate to given module.
+const ShaderModel *LoadShaderModel(const llvm::Module &M);
+
 } // namespace dxilutil
 
 } // namespace hlsl

lib/DXIL/DxilMetadataHelper.cpp

@@ -261,31 +261,49 @@ void DxilMDHelper::EmitDxilShaderModel(const ShaderModel *pSM) {
   SetShaderModel(pSM);
 }
 
-void DxilMDHelper::LoadDxilShaderModel(const ShaderModel *&pSM) {
+// Retrieve the name string of the shader model for the given module.
+// Returns true and passes shader model target string through str if valid.
+// Returns false if metadata is missing or invalid.
+bool DxilMDHelper::LoadShaderModelName(const Module *pModule, string &Name) {
   NamedMDNode *pShaderModelNamedMD =
-      m_pModule->getNamedMetadata(kDxilShaderModelMDName);
-  IFTBOOL(pShaderModelNamedMD != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
-  IFTBOOL(pShaderModelNamedMD->getNumOperands() == 1,
-          DXC_E_INCORRECT_DXIL_METADATA);
+      pModule->getNamedMetadata(kDxilShaderModelMDName);
+  IFRBOOL(pShaderModelNamedMD != nullptr, false);
+  IFRBOOL(pShaderModelNamedMD->getNumOperands() == 1, false);
 
   MDNode *pShaderModelMD = pShaderModelNamedMD->getOperand(0);
-  IFTBOOL(pShaderModelMD->getNumOperands() == kDxilShaderModelNumFields,
-          DXC_E_INCORRECT_DXIL_METADATA);
+  IFRBOOL(pShaderModelMD->getNumOperands() == kDxilShaderModelNumFields, false);
 
   MDString *pShaderTypeMD =
       dyn_cast<MDString>(pShaderModelMD->getOperand(kDxilShaderModelTypeIdx));
-  IFTBOOL(pShaderTypeMD != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
+  IFRBOOL(pShaderTypeMD != nullptr, false);
   unsigned Major =
       ConstMDToUint32(pShaderModelMD->getOperand(kDxilShaderModelMajorIdx));
   unsigned Minor =
       ConstMDToUint32(pShaderModelMD->getOperand(kDxilShaderModelMinorIdx));
-  string ShaderModelName = pShaderTypeMD->getString().str();
-  ShaderModelName +=
-      "_" + std::to_string(Major) + "_" +
-      (Minor == ShaderModel::kOfflineMinor ? "x" : std::to_string(Minor));
-  pSM = ShaderModel::GetByName(ShaderModelName.c_str());
+  Name = pShaderTypeMD->getString().str();
+  Name += "_" + std::to_string(Major) + "_" +
+          (Minor == ShaderModel::kOfflineMinor ? "x" : std::to_string(Minor));
+  return true;
+}
+
+// Load shader model object from metadata contained in pModule.
+// Throws exceptions if any metadata is invalid or the values
+// of the shader model are invalid.
+const ShaderModel *DxilMDHelper::LoadDxilShaderModel(const Module *pModule) {
+  string ShaderModelName;
+  IFRBOOL(LoadShaderModelName(pModule, ShaderModelName), nullptr);
+  return ShaderModel::GetByName(ShaderModelName.c_str());
+}
+
+// Load shader model object from metadata MDHelper's module
+// and set it as current for MDHelper.
+void DxilMDHelper::LoadDxilShaderModel(const ShaderModel *&pSM) {
+  pSM = LoadDxilShaderModel(m_pModule);
+  IFTBOOL(pSM != nullptr, DXC_E_INCORRECT_DXIL_METADATA);
   if (!pSM->IsValidForDxil()) {
     char ErrorMsgTxt[40];
+    string ShaderModelName;
+    LoadShaderModelName(m_pModule, ShaderModelName);
     StringCchPrintfA(ErrorMsgTxt, _countof(ErrorMsgTxt),
                      "Unknown shader model '%s'", ShaderModelName.c_str());
     string ErrorMsg(ErrorMsgTxt);

lib/DXIL/DxilUtil.cpp

@@ -1394,5 +1394,16 @@ bool DeleteDeadAllocas(llvm::Function &F) {
   return Changed;
 }
 
+// Retrieve stored shader model in the given module.
+// Where the module doesn't have HL nor Dxil modules,
+// it identifies and returns the shader model from the module metatdata.
+// Returns nullptr where none of that works, but that shouldn't happen much.
+const ShaderModel *LoadShaderModel(const llvm::Module &M) {
+  if (M.HasDxilModule())
+    return M.GetDxilModule().GetShaderModel();
+
+  return DxilMDHelper::LoadDxilShaderModel(&M);
+}
+
 } // namespace dxilutil
 } // namespace hlsl

lib/Transforms/Scalar/LowerTypePasses.cpp

@@ -212,19 +212,15 @@ class DynamicIndexingVectorToArray : public LowerTypePass {
 };
 
 void DynamicIndexingVectorToArray::initialize(Module &M) {
-  // Can be invoked in a few places:
-  //  - From standard compile before dxilgen.
-  //  - When linking, where dxmodule is available.
-  //  - In isolated dxopt, where the module will need to be created.
-  // When linking, we expect a dxil module and can't create an HL module,
-  //  so we try for the dxil module first.
-  // Otherwise, either retrieve or generate the HL module.
-  if (M.HasDxilModule()) {
-    SupportsVectors = M.GetOrCreateDxilModule().GetShaderModel()->IsSM69Plus();
-  } else {
-    HLModule &HLM = M.GetOrCreateHLModule();
-    SupportsVectors = HLM.GetShaderModel()->IsSM69Plus();
-  }
+  // Set vector support according to available shader model.
+  // Use HLModule shader model if present.
+  // Otherwise retrieve from dxil module or metadata.
+  const ShaderModel *SM = nullptr;
+  if (M.HasHLModule())
+    SM = M.GetHLModule().GetShaderModel();
+  else
+    SM = dxilutil::LoadShaderModel(M);
+  SupportsVectors = SM && SM->IsSM69Plus();
 }
 
 void DynamicIndexingVectorToArray::applyOptions(PassOptions O) {

lib/Transforms/Scalar/Scalarizer.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "dxc/DXIL/DxilModule.h"
+#include "dxc/DXIL/DxilUtil.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/IRBuilder.h"
@@ -293,9 +294,9 @@ bool Scalarizer::doInitialization(Module &M) {
 }
 
 bool Scalarizer::runOnFunction(Function &F) {
-  Module *M = F.getParent();
-  if (M->HasDxilModule() && M->GetDxilModule().GetShaderModel()->IsSM69Plus())
-    SupportsVectors = true;
+  const Module *M = F.getParent();
+  const hlsl::ShaderModel *SM = hlsl::dxilutil::LoadShaderModel(*M);
+  SupportsVectors = SM && SM->IsSM69Plus();
 
   for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) {
     BasicBlock *BB = BBI;