Define computation of the value computed using major and minor

version Shader Model in a single place to be used both
by DXILEmitter and by the lowering pass.

Author: bharadwajy

llvm/include/llvm/Support/DXILABI.h

@@ -90,4 +90,9 @@ enum class ElementType : uint32_t {
 } // namespace dxil
 } // namespace llvm
 
+// Generate a unique value for given Major, Minor pair of Shader Model
+// version. Allows for 100 minor versions for a given major version number.
+// To be used uniformly by DXILEmitter backend as well as DXIL Lowering pass.
+#define COMPUTE_SM_VERSION_VALUE(MAJ, MIN) ((MAJ * 100) + MIN)
+
 #endif // LLVM_SUPPORT_DXILABI_H

llvm/lib/Target/DirectX/DXIL.td

@@ -16,7 +16,8 @@ include "llvm/IR/Intrinsics.td"
 // Abstract class to demarcate minimum Shader model version required
 // to support DXIL Op
 class DXILShaderModel<int major, int minor> {
-  int MajorAndMinor = !add(!mul(major, 10), minor);
+  int Major = major;
+  int Minor = minor;
 }
 
 // Valid minimum Shader model version records
@@ -25,7 +26,7 @@ class DXILShaderModel<int major, int minor> {
 foreach i = 0...9 in {
   def SM6_#i : DXILShaderModel<6, i>;
 }
-// Shader Mode 7.x - for now 7.0 is defined. Extend as needed
+// Shader Model 7.x - for now 7.0 is defined. Extend as needed
 foreach i = 0 in {
   def SM7_#i : DXILShaderModel<7, i>;
 }

llvm/lib/Target/DirectX/DXILOpLowering.cpp

@@ -73,7 +73,7 @@ static SmallVector<Value *> argVectorFlatten(CallInst *Orig,
   return NewOperands;
 }
 
-static uint32_t getShaderModelVer(Module &M) {
+static uint32_t getModuleShaderModelVersion(Module &M) {
   std::string TTStr = M.getTargetTriple();
   std::string Error;
   auto Target = TargetRegistry::lookupTarget(TTStr, Error);
@@ -85,13 +85,13 @@ static uint32_t getShaderModelVer(Module &M) {
   auto Major = Triple(TTStr).getOSVersion().getMajor();
   auto MinorOrErr = Triple(TTStr).getOSVersion().getMinor();
   uint32_t Minor = MinorOrErr.has_value() ? *MinorOrErr : 0;
-  return ((Major * 10) + Minor);
+  return COMPUTE_SM_VERSION_VALUE(Major, Minor);
 }
 
 static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M) {
   IRBuilder<> B(M.getContext());
   DXILOpBuilder DXILB(M, B);
-  uint32_t SMVer = getShaderModelVer(M);
+  uint32_t SMVer = getModuleShaderModelVersion(M);
   Type *OverloadTy = DXILB.getOverloadTy(DXILOp, SMVer, F.getFunctionType());
   for (User *U : make_early_inc_range(F.users())) {
     CallInst *CI = dyn_cast<CallInst>(U);

llvm/utils/TableGen/DXILEmitter.cpp

@@ -184,13 +184,20 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
   std::vector<Record *> OverloadTypeRecs =
       R->getValueAsListOfDefs("OpOverloadTypes");
   // Sort records in ascending order of Shader Model version
-  std::sort(
-      OverloadTypeRecs.begin(), OverloadTypeRecs.end(),
-      [](Record *a, Record *b) {
-        return (
-            a->getValueAsDef("ShaderModel")->getValueAsInt("MajorAndMinor") <
-            b->getValueAsDef("ShaderModel")->getValueAsInt("MajorAndMinor"));
-      });
+  std::sort(OverloadTypeRecs.begin(), OverloadTypeRecs.end(),
+            [](Record *RecA, Record *RecB) {
+              uint16_t RecAMaj =
+                  RecA->getValueAsDef("ShaderModel")->getValueAsInt("Major");
+              uint16_t RecAMin =
+                  RecA->getValueAsDef("ShaderModel")->getValueAsInt("Minor");
+              uint16_t RecBMaj =
+                  RecB->getValueAsDef("ShaderModel")->getValueAsInt("Major");
+              uint16_t RecBMin =
+                  RecB->getValueAsDef("ShaderModel")->getValueAsInt("Minor");
+
+              return (COMPUTE_SM_VERSION_VALUE(RecAMaj, RecAMin) <
+                      COMPUTE_SM_VERSION_VALUE(RecBMaj, RecBMin));
+            });
   unsigned OverloadTypeRecsSize = OverloadTypeRecs.size();
   // Populate OpOverloads with
   for (unsigned I = 0; I < OverloadTypeRecsSize; I++) {
@@ -255,6 +262,11 @@ static std::string getParameterKindStr(ParameterKind Kind) {
   llvm_unreachable("Unknown llvm::dxil::ParameterKind enum");
 }
 
+/// Return a string representation of OverloadKind enum that maps to
+/// input LLVMType record
+/// \param R TableGen def record of class LLVMType
+/// \return std::string string representation of OverloadKind
+
 static std::string getOverloadKindStr(const Record *R) {
   Record *VTRec = R->getValueAsDef("VT");
   switch (getValueType(VTRec)) {
@@ -293,10 +305,12 @@ static std::string getOverloadKindStrs(const SmallVector<Record *> Recs) {
   OverloadString.append("{");
   for (auto OvRec : Recs) {
     OverloadString.append(Prefix).append("{");
-    OverloadString
-        .append(std::to_string(OvRec->getValueAsDef("ShaderModel")
-                                   ->getValueAsInt("MajorAndMinor")))
-        .append(", ");
+    uint16_t RecAMaj =
+        OvRec->getValueAsDef("ShaderModel")->getValueAsInt("Major");
+    uint16_t RecAMin =
+        OvRec->getValueAsDef("ShaderModel")->getValueAsInt("Minor");
+    uint16_t RecMajMin = COMPUTE_SM_VERSION_VALUE(RecAMaj, RecAMin);
+    OverloadString.append(std::to_string(RecMajMin)).append(", ");
     auto OverloadTys = OvRec->getValueAsListOfDefs("OpOverloads");
     auto Iter = OverloadTys.begin();
     OverloadString.append(getOverloadKindStr(*Iter++));